Please send Guile bug reports to bug-guile@gnu.org.
\f
+Changes since Guile 1.3.4:
+
+\f
+Changes since Guile 1.3.2:
+
+* Changes to the stand-alone interpreter
+
+** Debugger
+
+An initial version of the Guile debugger written by Chris Hanson has
+been added. The debugger is still under development but is included
+in the distribution anyway since it is already quite useful.
+
+Type
+
+ (debug)
+
+after an error to enter the debugger. Type `help' inside the debugger
+for a description of available commands.
+
+If you prefer to have stack frames numbered and printed in
+anti-chronological order and prefer up in the stack to be down on the
+screen as is the case in gdb, you can put
+
+ (debug-enable 'backwards)
+
+in your .guile startup file. (However, this means that Guile can't
+use indentation to indicate stack level.)
+
+The debugger is autoloaded into Guile at the first use.
+
+** Further enhancements to backtraces
+
+There is a new debug option `width' which controls the maximum width
+on the screen of printed stack frames. Fancy printing parameters
+("level" and "length" as in Common LISP) are adaptively adjusted for
+each stack frame to give maximum information while still fitting
+within the bounds. If the stack frame can't be made to fit by
+adjusting parameters, it is simply cut off at the end. This is marked
+with a `$'.
+
+** Some modules are now only loaded when the repl is started
+
+The modules (ice-9 debug), (ice-9 session), (ice-9 threads) and (ice-9
+regex) are now loaded into (guile-user) only if the repl has been
+started. The effect is that the startup time for scripts has been
+reduced to 30% of what it was previously.
+
+Correctly written scripts load the modules they require at the top of
+the file and should not be affected by this change.
+
+** Hooks are now represented as smobs
+
+* Changes to Scheme functions and syntax
+
+** Readline support has changed again.
+
+The old (readline-activator) module is gone. Use (ice-9 readline)
+instead, which now contains all readline functionality. So the code
+to activate readline is now
+
+ (use-modules (ice-9 readline))
+ (activate-readline)
+
+This should work at any time, including from the guile prompt.
+
+To avoid confusion about the terms of Guile's license, please only
+enable readline for your personal use; please don't make it the
+default for others. Here is why we make this rather odd-sounding
+request:
+
+Guile is normally licensed under a weakened form of the GNU General
+Public License, which allows you to link code with Guile without
+placing that code under the GPL. This exception is important to some
+people.
+
+However, since readline is distributed under the GNU General Public
+License, when you link Guile with readline, either statically or
+dynamically, you effectively change Guile's license to the strict GPL.
+Whenever you link any strictly GPL'd code into Guile, uses of Guile
+which are normally permitted become forbidden. This is a rather
+non-obvious consequence of the licensing terms.
+
+So, to make sure things remain clear, please let people choose for
+themselves whether to link GPL'd libraries like readline with Guile.
+
+** regexp-substitute/global has changed slightly, but incompatibly.
+
+If you include a function in the item list, the string of the match
+object it receives is the same string passed to
+regexp-substitute/global, not some suffix of that string.
+Correspondingly, the match's positions are relative to the entire
+string, not the suffix.
+
+If the regexp can match the empty string, the way matches are chosen
+from the string has changed. regexp-substitute/global recognizes the
+same set of matches that list-matches does; see below.
+
+** New function: list-matches REGEXP STRING [FLAGS]
+
+Return a list of match objects, one for every non-overlapping, maximal
+match of REGEXP in STRING. The matches appear in left-to-right order.
+list-matches only reports matches of the empty string if there are no
+other matches which begin on, end at, or include the empty match's
+position.
+
+If present, FLAGS is passed as the FLAGS argument to regexp-exec.
+
+** New function: fold-matches REGEXP STRING INIT PROC [FLAGS]
+
+For each match of REGEXP in STRING, apply PROC to the match object,
+and the last value PROC returned, or INIT for the first call. Return
+the last value returned by PROC. We apply PROC to the matches as they
+appear from left to right.
+
+This function recognizes matches according to the same criteria as
+list-matches.
+
+Thus, you could define list-matches like this:
+
+ (define (list-matches regexp string . flags)
+ (reverse! (apply fold-matches regexp string '() cons flags)))
+
+If present, FLAGS is passed as the FLAGS argument to regexp-exec.
+
+** Hooks
+
+*** New function: hook? OBJ
+
+Return #t if OBJ is a hook, otherwise #f.
+
+*** New function: make-hook-with-name NAME [ARITY]
+
+Return a hook with name NAME and arity ARITY. The default value for
+ARITY is 0. The only effect of NAME is that it will appear when the
+hook object is printed to ease debugging.
+
+*** New function: hook-empty? HOOK
+
+Return #t if HOOK doesn't contain any procedures, otherwise #f.
+
+*** New function: hook->list HOOK
+
+Return a list of the procedures that are called when run-hook is
+applied to HOOK.
+
+** `map' signals an error if its argument lists are not all the same length.
+
+This is the behavior required by R5RS, so this change is really a bug
+fix. But it seems to affect a lot of people's code, so we're
+mentioning it here anyway.
+
+** Print-state handling has been made more transparent
+
+Under certain circumstances, ports are represented as a port with an
+associated print state. Earlier, this pair was represented as a pair
+(see "Some magic has been added to the printer" below). It is now
+indistinguishable (almost; see `get-print-state') from a port on the
+user level.
+
+*** New function: port-with-print-state OUTPUT-PORT PRINT-STATE
+
+Return a new port with the associated print state PRINT-STATE.
+
+*** New function: get-print-state OUTPUT-PORT
+
+Return the print state associated with this port if it exists,
+otherwise return #f.
+
+*** New function: directory-stream? OBJECT
+
+Returns true iff OBJECT is a directory stream --- the sort of object
+returned by `opendir'.
+
+** New function: using-readline?
+
+Return #t if readline is in use in the current repl.
+
+** structs will be removed in 1.4
+
+Structs will be replaced in Guile 1.4. We will merge GOOPS into Guile
+and use GOOPS objects as the fundamental record type.
+
+* Changes to the scm_ interface
+
+** structs will be removed in 1.4
+
+The entire current struct interface (struct.c, struct.h) will be
+replaced in Guile 1.4. We will merge GOOPS into libguile and use
+GOOPS objects as the fundamental record type.
+
+** The internal representation of subr's has changed
+
+Instead of giving a hint to the subr name, the CAR field of the subr
+now contains an index to a subr entry in scm_subr_table.
+
+*** New variable: scm_subr_table
+
+An array of subr entries. A subr entry contains the name, properties
+and documentation associated with the subr. The properties and
+documentation slots are not yet used.
+
+** A new scheme for "forwarding" calls to a builtin to a generic function
+
+It is now possible to extend the functionality of some Guile
+primitives by letting them defer a call to a GOOPS generic function on
+argument mismatch. This means that there is no loss of efficiency in
+normal evaluation.
+
+Example:
+
+ (use-modules (oop goops)) ; Must be GOOPS version 0.2.
+ (define-method + ((x <string>) (y <string>))
+ (string-append x y))
+
++ will still be as efficient as usual in numerical calculations, but
+can also be used for concatenating strings.
+
+Who will be the first one to extend Guile's numerical tower to
+rationals? :) [OK, there a few other things to fix before this can
+be made in a clean way.]
+
+*** New snarf macros for defining primitives: SCM_GPROC, SCM_GPROC1
+
+ New macro: SCM_GPROC (CNAME, SNAME, REQ, OPT, VAR, CFUNC, GENERIC)
+
+ New macro: SCM_GPROC1 (CNAME, SNAME, TYPE, CFUNC, GENERIC)
+
+These do the same job as SCM_PROC and SCM_PROC1, but they also define
+a variable GENERIC which can be used by the dispatch macros below.
+
+[This is experimental code which may change soon.]
+
+*** New macros for forwarding control to a generic on arg type error
+
+ New macro: SCM_WTA_DISPATCH_1 (GENERIC, ARG1, POS, SUBR)
+
+ New macro: SCM_WTA_DISPATCH_2 (GENERIC, ARG1, ARG2, POS, SUBR)
+
+These correspond to the scm_wta function call, and have the same
+behaviour until the user has called the GOOPS primitive
+`enable-primitive-generic!'. After that, these macros will apply the
+generic function GENERIC to the argument(s) instead of calling
+scm_wta.
+
+[This is experimental code which may change soon.]
+
+*** New macros for argument testing with generic dispatch
+
+ New macro: SCM_GASSERT1 (COND, GENERIC, ARG1, POS, SUBR)
+
+ New macro: SCM_GASSERT2 (COND, GENERIC, ARG1, ARG2, POS, SUBR)
+
+These correspond to the SCM_ASSERT macro, but will defer control to
+GENERIC on error after `enable-primitive-generic!' has been called.
+
+[This is experimental code which may change soon.]
+
+** New function: SCM scm_eval_body (SCM body, SCM env)
+
+Evaluates the body of a special form.
+
+** The internal representation of struct's has changed
+
+Previously, four slots were allocated for the procedure(s) of entities
+and operators. The motivation for this representation had to do with
+the structure of the evaluator, the wish to support tail-recursive
+generic functions, and efficiency. Since the generic function
+dispatch mechanism has changed, there is no longer a need for such an
+expensive representation, and the representation has been simplified.
+
+This should not make any difference for most users.
+
+** GOOPS support has been cleaned up.
+
+Some code has been moved from eval.c to objects.c and code in both of
+these compilation units has been cleaned up and better structured.
+
+*** New functions for applying generic functions
+
+ New function: SCM scm_apply_generic (GENERIC, ARGS)
+ New function: SCM scm_call_generic_0 (GENERIC)
+ New function: SCM scm_call_generic_1 (GENERIC, ARG1)
+ New function: SCM scm_call_generic_2 (GENERIC, ARG1, ARG2)
+ New function: SCM scm_call_generic_3 (GENERIC, ARG1, ARG2, ARG3)
+
+** Deprecated function: scm_make_named_hook
+
+It is now replaced by:
+
+** New function: SCM scm_create_hook (const char *name, int arity)
+
+Creates a hook in the same way as make-hook above but also
+binds a variable named NAME to it.
+
+This is the typical way of creating a hook from C code.
+
+Currently, the variable is created in the "current" module.
+This might change when we get the new module system.
+
+[The behaviour is identical to scm_make_named_hook.]
+
+
+\f
Changes since Guile 1.3:
+* Changes to mailing lists
+
+** Some of the Guile mailing lists have moved to sourceware.cygnus.com.
+
+See the README file to find current addresses for all the Guile
+mailing lists.
+
* Changes to the distribution
** Readline support is no longer included with Guile by default.
explicitly offered two independent decisions about the use of these
two packages.
+You can activate the readline support by issuing
+
+ (use-modules (readline-activator))
+ (activate-readline)
+
+from your ".guile" file, for example.
+
* Changes to the stand-alone interpreter
** All builtins now print as primitives.
* Changes to Scheme functions and syntax
+** Guile now correctly handles internal defines by rewriting them into
+their equivalent letrec. Previously, internal defines would
+incrementally add to the innermost environment, without checking
+whether the restrictions specified in RnRS were met. This lead to the
+correct behaviour when these restriction actually were met, but didn't
+catch all illegal uses. Such an illegal use could lead to crashes of
+the Guile interpreter or or other unwanted results. An example of
+incorrect internal defines that made Guile behave erratically:
+
+ (let ()
+ (define a 1)
+ (define (b) a)
+ (define c (1+ (b)))
+ (define d 3)
+
+ (b))
+
+ => 2
+
+The problem with this example is that the definition of `c' uses the
+value of `b' directly. This confuses the meoization machine of Guile
+so that the second call of `b' (this time in a larger environment that
+also contains bindings for `c' and `d') refers to the binding of `c'
+instead of `a'. You could also make Guile crash with a variation on
+this theme:
+
+ (define (foo flag)
+ (define a 1)
+ (define (b flag) (if flag a 1))
+ (define c (1+ (b flag)))
+ (define d 3)
+
+ (b #t))
+
+ (foo #f)
+ (foo #t)
+
+From now on, Guile will issue an `Unbound variable: b' error message
+for both examples.
+
** Hooks
A hook contains a list of functions which should be called on
** the procedures uniform-array-read! and uniform-array-write! now
work on any kind of port, not just ports which are open on a file.
-** now 'l' in a port mode requests line buffering.
+** Now 'l' in a port mode requests line buffering.
-** new procedure: ftruncate PORT [LENGTH]
-Truncates PORT after LENGTH bytes, or at the current position if
-LENGTH is omitted. Works on random-access file and string ports.
+** The procedure truncate-file now works on string ports as well
+as file ports. If the size argument is omitted, the current
+file position is used.
-** new procedure: lseek PORT/FDES OFFSET WHENCE
+** new procedure: seek PORT/FDES OFFSET WHENCE
The arguments are the same as for the old fseek procedure, but it
works on string ports as well as random-access file ports.
** the fseek procedure now works on string ports, since it has been
-redefined using lseek.
+redefined using seek.
** the setvbuf procedure now uses a default size if mode is _IOFBF and
size is not supplied.
`(current-module)' is now consulted for definitions to return, instead
of simply returning #f, the former behavior.
+** The #/ syntax for lists is no longer supported.
+
+Earlier versions of Scheme accepted this syntax, but printed a
+warning.
+
+** Guile no longer consults the SCHEME_LOAD_PATH environment variable.
+
+Instead, you should set GUILE_LOAD_PATH to tell Guile where to find
+modules.
+
* Changes to the gh_ interface
** gh_scm2doubles
This is the typical way of creating a hook from C code.
-Currently, the variable is created in the root module. This will
-change when we get the new module system.
+Currently, the variable is created in the "current" module. This
+might change when we get the new module system.
+
+** The smob interface
+
+The interface for creating smobs has changed. For documentation, see
+data-rep.info (made from guile-core/doc/data-rep.texi).
+
+*** Deprecated function: SCM scm_newsmob (scm_smobfuns *)
+
+>>> This function will be removed in 1.3.4. <<<
+
+It is replaced by:
+
+*** Function: SCM scm_make_smob_type (const char *name, scm_sizet size)
+This function adds a new smob type, named NAME, with instance size
+SIZE to the system. The return value is a tag that is used in
+creating instances of the type. If SIZE is 0, then no memory will
+be allocated when instances of the smob are created, and nothing
+will be freed by the default free function.
+
+*** Function: void scm_set_smob_mark (long tc, SCM (*mark) (SCM))
+This function sets the smob marking procedure for the smob type
+specified by the tag TC. TC is the tag returned by
+`scm_make_smob_type'.
+
+*** Function: void scm_set_smob_free (long tc, SCM (*mark) (SCM))
+This function sets the smob freeing procedure for the smob type
+specified by the tag TC. TC is the tag returned by
+`scm_make_smob_type'.
+
+*** Function: void scm_set_smob_print (tc, print)
+
+ - Function: void scm_set_smob_print (long tc,
+ scm_sizet (*print) (SCM,
+ SCM,
+ scm_print_state *))
+
+This function sets the smob printing procedure for the smob type
+specified by the tag TC. TC is the tag returned by
+`scm_make_smob_type'.
+
+*** Function: void scm_set_smob_equalp (long tc, SCM (*equalp) (SCM, SCM))
+This function sets the smob equality-testing predicate for the
+smob type specified by the tag TC. TC is the tag returned by
+`scm_make_smob_type'.
+
+*** Macro: void SCM_NEWSMOB (SCM var, long tc, void *data)
+Make VALUE contain a smob instance of the type with type code TC and
+smob data DATA. VALUE must be previously declared as C type `SCM'.
+
+*** Macro: fn_returns SCM_RETURN_NEWSMOB (long tc, void *data)
+This macro expands to a block of code that creates a smob instance
+of the type with type code TC and smob data DATA, and returns that
+`SCM' value. It should be the last piece of code in a block.
** The interfaces for using I/O ports and implementing port types
(ptobs) have changed significantly. The new interface is based on
shared access to buffers and a new set of ptob procedures.
+*** scm_newptob has been removed
+
+It is replaced by:
+
+*** Function: SCM scm_make_port_type (type_name, fill_buffer, write_flush)
+
+- Function: SCM scm_make_port_type (char *type_name,
+ int (*fill_buffer) (SCM port),
+ void (*write_flush) (SCM port));
+
+Similarly to the new smob interface, there is a set of function
+setters by which the user can customize the behaviour of his port
+type. See ports.h (scm_set_port_XXX).
+
** scm_strport_to_string: New function: creates a new string from
a string port's buffer.
It might be a good idea to use these functions from your C code so
that only one random generator is used by all code in your program.
-You can get the default random state using:
+The default random state is stored in:
*** Variable: SCM scm_var_random_state
Contains the vcell of the Scheme variable "*random-state*" which is
Example:
- double x = scm_i_uniform01 (SCM_RSTATE (SCM_CDR (scm_var_random_state)));
+ double x = scm_c_uniform01 (SCM_RSTATE (SCM_CDR (scm_var_random_state)));
+
+*** Function: scm_rstate *scm_c_default_rstate (void)
+This is a convenience function which returns the value of
+scm_var_random_state. An error message is generated if this value
+isn't a random state.
-*** Function: double scm_i_uniform01 (scm_rstate *STATE)
+*** Function: scm_rstate *scm_c_make_rstate (char *SEED, int LENGTH)
+Make a new random state from the string SEED of length LENGTH.
+
+It is generally not a good idea to use multiple random states in a
+program. While subsequent random numbers generated from one random
+state are guaranteed to be reasonably independent, there is no such
+guarantee for numbers generated from different random states.
+
+*** Macro: unsigned long scm_c_uniform32 (scm_rstate *STATE)
+Return 32 random bits.
+
+*** Function: double scm_c_uniform01 (scm_rstate *STATE)
Return a sample from the uniform(0,1) distribution.
-*** Function: double scm_i_normal01 (scm_rstate *STATE)
+*** Function: double scm_c_normal01 (scm_rstate *STATE)
Return a sample from the normal(0,1) distribution.
-*** Function: double scm_i_exp1 (scm_rstate *STATE)
+*** Function: double scm_c_exp1 (scm_rstate *STATE)
Return a sample from the exp(1) distribution.
-*** Function: unsigned long scm_i_random (unsigned long M, scm_rstate *STATE)
+*** Function: unsigned long scm_c_random (scm_rstate *STATE, unsigned long M)
+Return a sample from the discrete uniform(0,M) distribution.
+
+*** Function: SCM scm_c_random_bignum (scm_rstate *STATE, SCM M)
Return a sample from the discrete uniform(0,M) distribution.
+M must be a bignum object. The returned value may be an INUM.
\f
HCoop / bpt / guile.git / blobdiff