X-Git-Url: https://git.hcoop.net/bpt/guile.git/blobdiff_plain/ad91d6c3ff24d03c929dd730391f93faf937de0b..96372e45b84bc062290806bee3390880bbbac7ff:/NEWS diff --git a/NEWS b/NEWS index abd7bc851..73acbb772 100644 --- a/NEWS +++ b/NEWS @@ -1,11 +1,804 @@ Guile NEWS --- history of user-visible changes. -*- text -*- -Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc. +Copyright (C) 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc. See the end for copying conditions. Please send Guile bug reports to bug-guile@gnu.org. +Changes since Guile 1.3.4: + +* Changes to the distribution + +** Trees from nightly snapshots and CVS now require you to run autogen.sh. + +We've changed the way we handle generated files in the Guile source +repository. As a result, the procedure for building trees obtained +from the nightly FTP snapshots or via CVS has changed: +- You must have appropriate versions of autoconf, automake, and + libtool installed on your system. See README for info on how to + obtain these programs. +- Before configuring the tree, you must first run the script + `autogen.sh' at the top of the source tree. + +The Guile repository used to contain not only source files, written by +humans, but also some generated files, like configure scripts and +Makefile.in files. Even though the contents of these files could be +derived mechanically from other files present, we thought it would +make the tree easier to build if we checked them into CVS. + +However, this approach means that minor differences between +developer's installed tools and habits affected the whole team. +So we have removed the generated files from the repository, and +added the autogen.sh script, which will reconstruct them +appropriately. + + +** configure now has experimental options to remove support for certain +features: + +--disable-arrays omit array and uniform array support +--disable-posix omit posix interfaces +--disable-networking omit networking interfaces +--disable-regex omit regular expression interfaces + +These are likely to become separate modules some day. + +** New configure option --enable-debug-freelist + +This enables a debugging version of SCM_NEWCELL(), and also registers +an extra primitive, the setter `gc-set-debug-check-freelist!'. + +Configure with the --enable-debug-freelist option to enable +the gc-set-debug-check-freelist! primitive, and then use: + +(gc-set-debug-check-freelist! #t) # turn on checking of the freelist +(gc-set-debug-check-freelist! #f) # turn off checking + +Checking of the freelist forces a traversal of the freelist and +a garbage collection before each allocation of a cell. This can +slow down the interpreter dramatically, so the setter should be used to +turn on this extra processing only when necessary. + +** New configure option --enable-debug-malloc + +Include code for debugging of calls to scm_must_malloc/realloc/free. + +Checks that + +1. objects freed by scm_must_free has been mallocated by scm_must_malloc +2. objects reallocated by scm_must_realloc has been allocated by + scm_must_malloc +3. reallocated objects are reallocated with the same what string + +But, most importantly, it records the number of allocated objects of +each kind. This is useful when searching for memory leaks. + +A Guile compiled with this option provides the primitive +`malloc-stats' which returns an alist with pairs of kind and the +number of objects of that kind. + +** All includes are now referenced relative to the root directory + +Since some users have had problems with mixups between Guile and +system headers, we have decided to always refer to Guile headers via +their parent directories. This essentially creates a "private name +space" for Guile headers. This means that the compiler only is given +-I options for the root build and root source directory. + +* Changes to the stand-alone interpreter + +** New help facility + +Typing (help) prints helpful information. +Typing (help NAME) gives documentation about NAME. + +** Dynamic linking now uses libltdl from the libtool package. + +The old system dependent code for doing dynamic linking has been +replaced with calls to the libltdl functions which do all the hairy +details for us. + +The major improvement is that you can now directly pass libtool +library names like "libfoo.la" to `dynamic-link' and `dynamic-link' +will be able to do the best shared library job you can get, via +libltdl. + +The way dynamic libraries are found has changed and is not really +portable across platforms, probably. It is therefore recommended to +use absolute filenames when possible. + +If you pass a filename without an extension to `dynamic-link', it will +try a few appropriate ones. Thus, the most platform ignorant way is +to specify a name like "libfoo", without any directories and +extensions. + +** Guile COOP threads are now compatible with LinuxThreads + +Previously, COOP threading wasn't possible in applications linked with +Linux POSIX threads due to their use of the stack pointer to find the +thread context. This has now been fixed with a workaround which uses +the pthreads to allocate the stack. + +** New primitives: `pkgdata-dir', `site-dir', `library-dir' + +** Positions of erring expression in scripts + +With version 1.3.4, the location of the erring expression in Guile +scipts is no longer automatically reported. (This should have been +documented before the 1.3.4 release.) + +You can get this information by enabling recording of positions of +source expressions and running the debugging evaluator. Put this at +the top of your script (or in your "site" file): + + (read-enable 'positions) + (debug-enable 'debug) + +** Backtraces in scripts + +It is now possible to get backtraces in scripts. + +Put + + (debug-enable 'debug 'backtrace) + +at the top of the script. + +(The first options enables the debugging evaluator. + The second enables backtraces.) + +** Attempting to get the value of an unbound variable now produces +an exception with a key of 'unbound-variable instead of 'misc-error. + +** The initial default output port is now unbuffered if it's using a +tty device. Previously in this situation it was line-buffered. + +** gc-thunk is deprecated + +gc-thunk will be removed in next release of Guile. It has been +replaced by after-gc-hook. + +** New hook: after-gc-hook + +after-gc-hook takes over the role of gc-thunk. This hook is run at +the first SCM_TICK after a GC. (Thus, the code is run at the same +point during evaluation as signal handlers.) + +Note that this hook should be used only for diagnostic and debugging +purposes. It is not certain that it will continue to be well-defined +when this hook is run in the future. + +C programmers: Note the new C level hooks scm_before_gc_c_hook, +scm_before_sweep_c_hook, scm_after_gc_c_hook. + +* Changes to Scheme functions and syntax + +** close-input-port and close-output-port are now R5RS + +These procedures have been turned into primitives and have R5RS behaviour. + +** New procedure: simple-format PORT MESSAGE ARG1 ... + +(ice-9 boot) makes `format' an alias for `simple-format' until possibly +extended by the more sophisticated version in (ice-9 format) + +(simple-format port message . args) +Write MESSAGE to DESTINATION, defaulting to `current-output-port'. +MESSAGE can contain ~A (was %s) and ~S (was %S) escapes. When printed, +the escapes are replaced with corresponding members of ARGS: +~A formats using `display' and ~S formats using `write'. +If DESTINATION is #t, then use the `current-output-port', +if DESTINATION is #f, then return a string containing the formatted text. +Does not add a trailing newline." + +** string-ref: the second argument is no longer optional. + +** string, list->string: no longer accept strings in their arguments, +only characters, for compatibility with R5RS. + +** New procedure: port-closed? PORT +Returns #t if PORT is closed or #f if it is open. + +* Changes to the gh_ interface + +** Deprecated: gh_int2scmb + +Use gh_bool2scm instead. + +* Changes to the scm_ interface + +** Guile primitives now carry docstrings! + +Thanks to Greg Badros! + +** Guile primitives are defined in a new way: GUILE_PROC/GUILE_PROC1 + +Now Guile primitives are defined using the GUILE_PROC/GUILE_PROC1 macros +and must contain a docstring that is extracted into foo.doc using a new +guile-doc-snarf script (that uses guile-doc-snarf.awk). + +** Guile primitives use a new technique for validation of arguments + +SCM_VALIDATE_* macros are defined to ease the redundancy and improve +the readability of argument checking. + +** All (nearly?) K&R prototypes for functions replaced with ANSI C equivalents. + +** New macros: SCM_PACK, SCM_UNPACK + +Compose/decompose an SCM value. + +The SCM type is now treated as an abstract data type and may be defined as a +long, a void* or as a struct, depending on the architecture and compile time +options. This makes it easier to find several types of bugs, for example when +SCM values are treated as integers without conversion. Values of the SCM type +should be treated as "atomic" values. These macros are used when +composing/decomposing an SCM value, either because you want to access +individual bits, or because you want to treat it as an integer value. + +E.g., in order to set bit 7 in an SCM value x, use the expression + + SCM_PACK (SCM_UNPACK (x) | 0x80) + +** The name property of hooks is deprecated. +Thus, the use of SCM_HOOK_NAME and scm_make_hook_with_name is deprecated. + +You can emulate this feature by using object properties. + +** Deprecated macros: SCM_INPORTP, SCM_OUTPORTP, SCM_CRDY, SCM_ICHRP, +SCM_ICHR, SCM_MAKICHR, SCM_SETJMPBUF, SCM_NSTRINGP, SCM_NRWSTRINGP, +SCM_NVECTORP + +These macros will be removed in a future release of Guile. + +** Port internals: the rw_random variable in the scm_port structure +must be set to non-zero in any random access port. In recent Guile +releases it was only set for bidirectional random-access ports. + +** Port internals: the seek ptob procedure is now responsible for +resetting the buffers if required. The change was made so that in the +special case of reading the current position (i.e., seek p 0 SEEK_CUR) +the fport and strport ptobs can avoid resetting the buffers, +in particular to avoid discarding unread chars. An existing port +type can be fixed by adding something like the following to the +beginning of the ptob seek procedure: + + if (pt->rw_active == SCM_PORT_READ) + scm_end_input (object); + else if (pt->rw_active == SCM_PORT_WRITE) + ptob->flush (object); + +although to actually avoid resetting the buffers and discard unread +chars requires further hacking that depends on the characteristics +of the ptob. + +** Deprecated functions: scm_fseek, scm_tag + +These functions are no longer used and will be removed in a future version. + +** The scm_sysmissing procedure is no longer used in libguile. +Unless it turns out to be unexpectedly useful to somebody, it will be +removed in a future version. + +** The format of error message strings has changed + +The two C procedures: scm_display_error and scm_error, as well as the +primitive `scm-error', now use scm_simple_format to do their work. +This means that the message strings of all code must be updated to use +~A where %s was used before, and ~S where %S was used before. + +During the period when there still are a lot of old Guiles out there, +you might want to support both old and new versions of Guile. + +There are basically two methods to achieve this. Both methods use +autoconf. Put + + AC_CHECK_FUNCS(scm_simple_format) + +in your configure.in. + +Method 1: Use the string concatenation features of ANSI C's + preprocessor. + +In C: + +#ifdef HAVE_SCM_SIMPLE_FORMAT +#define FMT_S "~S" +#else +#define FMT_S "%S" +#endif + +Then represent each of your error messages using a preprocessor macro: + +#define E_SPIDER_ERROR "There's a spider in your " ## FMT_S ## "!!!" + +In Scheme: + +(define fmt-s (if (defined? 'simple-format) "~S" "%S")) +(define make-message string-append) + +(define e-spider-error (make-message "There's a spider in your " fmt-s "!!!")) + +Method 2: Use the oldfmt function found in doc/oldfmt.c. + +In C: + +scm_misc_error ("picnic", scm_c_oldfmt0 ("There's a spider in your ~S!!!"), + ...); + +In Scheme: + +(scm-error 'misc-error "picnic" (oldfmt "There's a spider in your ~S!!!") + ...) + + +** Deprecated: coop_mutex_init, coop_condition_variable_init + +Don't use the functions coop_mutex_init and +coop_condition_variable_init. They will change. + +Use scm_mutex_init and scm_cond_init instead. + +** New function: int scm_cond_timedwait (scm_cond_t *COND, scm_mutex_t *MUTEX, const struct timespec *ABSTIME) + `scm_cond_timedwait' atomically unlocks MUTEX and waits on + COND, as `scm_cond_wait' does, but it also bounds the duration + of the wait. If COND has not been signaled before time ABSTIME, + the mutex MUTEX is re-acquired and `scm_cond_timedwait' + returns the error code `ETIMEDOUT'. + + The ABSTIME parameter specifies an absolute time, with the same + origin as `time' and `gettimeofday': an ABSTIME of 0 corresponds + to 00:00:00 GMT, January 1, 1970. + +** New function: scm_cond_broadcast (scm_cond_t *COND) + `scm_cond_broadcast' restarts all the threads that are waiting + on the condition variable COND. Nothing happens if no threads are + waiting on COND. + +** New function: scm_key_create (scm_key_t *KEY, void (*destr_function) (void *)) + `scm_key_create' allocates a new TSD key. The key is stored in + the location pointed to by KEY. There is no limit on the number + of keys allocated at a given time. The value initially associated + with the returned key is `NULL' in all currently executing threads. + + The DESTR_FUNCTION argument, if not `NULL', specifies a destructor + function associated with the key. When a thread terminates, + DESTR_FUNCTION is called on the value associated with the key in + that thread. The DESTR_FUNCTION is not called if a key is deleted + with `scm_key_delete' or a value is changed with + `scm_setspecific'. The order in which destructor functions are + called at thread termination time is unspecified. + + Destructors are not yet implemented. + +** New function: scm_setspecific (scm_key_t KEY, const void *POINTER) + `scm_setspecific' changes the value associated with KEY in the + calling thread, storing the given POINTER instead. + +** New function: scm_getspecific (scm_key_t KEY) + `scm_getspecific' returns the value currently associated with + KEY in the calling thread. + +** New function: scm_key_delete (scm_key_t KEY) + `scm_key_delete' deallocates a TSD key. It does not check + whether non-`NULL' values are associated with that key in the + currently executing threads, nor call the destructor function + associated with the key. + +** New function: scm_c_hook_init (scm_c_hook_t *HOOK, void *HOOK_DATA, scm_c_hook_type_t TYPE) + +Initialize a C level hook HOOK with associated HOOK_DATA and type +TYPE. (See scm_c_hook_run ().) + +** New function: scm_c_hook_add (scm_c_hook_t *HOOK, scm_c_hook_function_t FUNC, void *FUNC_DATA, int APPENDP) + +Add hook function FUNC with associated FUNC_DATA to HOOK. If APPENDP +is true, add it last, otherwise first. The same FUNC can be added +multiple times if FUNC_DATA differ and vice versa. + +** New function: scm_c_hook_remove (scm_c_hook_t *HOOK, scm_c_hook_function_t FUNC, void *FUNC_DATA) + +Remove hook function FUNC with associated FUNC_DATA from HOOK. A +function is only removed if both FUNC and FUNC_DATA matches. + +** New function: void *scm_c_hook_run (scm_c_hook_t *HOOK, void *DATA) + +Run hook HOOK passing DATA to the hook functions. + +If TYPE is SCM_C_HOOK_NORMAL, all hook functions are run. The value +returned is undefined. + +If TYPE is SCM_C_HOOK_OR, hook functions are run until a function +returns a non-NULL value. This value is returned as the result of +scm_c_hook_run. If all functions return NULL, NULL is returned. + +If TYPE is SCM_C_HOOK_AND, hook functions are run until a function +returns a NULL value, and NULL is returned. If all functions returns +a non-NULL value, the last value is returned. + +** New C level GC hooks + +Five new C level hooks has been added to the garbage collector. + + scm_before_gc_c_hook + scm_after_gc_c_hook + +are run before locking and after unlocking the heap. The system is +thus in a mode where evaluation can take place. (Except that +scm_before_gc_c_hook must not allocate new cells.) + + scm_before_mark_c_hook + scm_before_sweep_c_hook + scm_after_sweep_c_hook + +are run when the heap is locked. These are intended for extension of +the GC in a modular fashion. Examples are the weaks and guardians +modules. + +* Changes to system call interfaces: + +** The "select" procedure now tests port buffers for the ability to +provide input or accept output. Previously only the underlying file +descriptors were checked. + +** New variable PIPE_BUF: the maximum number of bytes that can be +atomically written to a pipe. + +** If a facility is not available on the system when Guile is +compiled, the corresponding primitive procedure will not be defined. +Previously it would have been defined but would throw a system-error +exception if called. Exception handlers which catch this case may +need minor modification: an error will be thrown with key +'unbound-variable instead of 'system-error. Alternatively it's +now possible to use `defined?' to check whether the facility is +available. + +** Procedures which depend on the timezone should now give the correct +result on systems which cache the TZ environment variable, even if TZ +is changed without calling tzset. + +* Changes to the networking interfaces: + +** New functions: htons, ntohs, htonl, ntohl: for converting short and +long integers between network and host format. For now, it's not +particularly convenient to do this kind of thing, but consider: + +(define write-network-long + (lambda (value port) + (let ((v (make-uniform-vector 1 1 0))) + (uniform-vector-set! v 0 (htonl value)) + (uniform-vector-write v port)))) + +(define read-network-long + (lambda (port) + (let ((v (make-uniform-vector 1 1 0))) + (uniform-vector-read! v port) + (ntohl (uniform-vector-ref v 0))))) + +** If inet-aton fails, it now throws an error with key 'misc-error +instead of 'system-error, since errno is not relevant. + +** Certain gethostbyname/gethostbyaddr failures now throw errors with +specific keys instead of 'system-error. The latter is inappropriate +since errno will not have been set. The keys are: +'host-not-found, 'try-again, 'no-recovery and 'no-data. + +** sethostent, setnetent, setprotoent, setservent: now take an +optional argument STAYOPEN, which specifies whether the database +remains open after a database entry is accessed randomly (e.g., using +gethostbyname for the hosts database.) The default is #f. Previously +#t was always used. + + +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 ) (y )) + (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.] + + + 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. @@ -33,6 +826,13 @@ can use Guile may not be able to use Readline. Now users will be 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. @@ -46,6 +846,46 @@ in backtraces. * 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 @@ -980,18 +1820,18 @@ read again in last-in first-out order. ** 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. @@ -1032,6 +1872,16 @@ argument, a relative module reference. In the case of no argument, `(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 @@ -1053,13 +1903,80 @@ 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 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. @@ -1119,7 +2036,7 @@ These functions use the current RNG through the scm_the_rng interface. 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 @@ -1128,19 +2045,39 @@ level interface. 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: scm_rstate *scm_c_make_rstate (char *SEED, int LENGTH) +Make a new random state from the string SEED of length LENGTH. -*** Function: double scm_i_uniform01 (scm_rstate *STATE) +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.