X-Git-Url: https://git.hcoop.net/bpt/guile.git/blobdiff_plain/c94577b4456b27ab035a26ffabae4b43fe83872e..1bd07992b6d08380d84fdc3d48e8f77666641544:/NEWS diff --git a/NEWS b/NEWS index 30a3da0a7..c79e3eb4d 100644 --- a/NEWS +++ b/NEWS @@ -1,9 +1,1071 @@ 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.4: + +* Changes to the distribution + +* Changes to the stand-alone interpreter + +** It's now possible to create modules with controlled environments + +Example: + +(use-modules (ice-9 safe)) +(define m (make-safe-module)) +;;; m will now be a module containing only a safe subset of R5RS +(eval-in-module '(+ 1 2) m) --> 3 +(eval-in-module 'load m) --> ERROR: Unbound variable: load + +* Changes to Scheme functions and syntax + +** New define-module option: pure + +Tells the module system not to include any bindings from the root +module. + +Example: + +(define-module (totally-empty-module) + :pure) + +** New define-module option: export NAME1 ... + +Export names NAME1 ... + +This option is required if you want to be able to export bindings from +a module which doesn't import one of `define-public' or `export'. + +Example: + +(define-module (foo) + :pure + :use-module (ice-9 r5rs) + :export (bar)) + +;;; Note that we're pure R5RS below this point! + +(define (bar) + ...) + +* Changes to the gh_ interface + +* Changes to the scm_ interface + +** New function: scm_done_free (long size) + +This function is the inverse of scm_done_malloc. Use it to report the +amount of smob memory you free. The previous method, which involved +calling scm_done_malloc with negative argument, was somewhat +unintuitive (and is still available, of course). + +** New global variable scm_gc_running_p introduced. + +Use this variable to find out if garbage collection is being executed. Up to +now applications have used scm_gc_heap_lock to test if garbage collection was +running, which also works because of the fact that up to know only the garbage +collector has set this variable. But, this is an implementation detail that +may change. Further, scm_gc_heap_lock is not set throughout gc, thus the use +of this variable is (and has been) not fully safe anyway. + +** Deprecated macros: SCM_OUTOFRANGE, SCM_NALLOC, SCM_HUP_SIGNAL, +SCM_INT_SIGNAL, SCM_FPE_SIGNAL, SCM_BUS_SIGNAL, SCM_SEGV_SIGNAL, +SCM_ALRM_SIGNAL, SCM_GC_SIGNAL, SCM_TICK_SIGNAL, SCM_SIG_ORD, +SCM_ORD_SIG, SCM_NUM_SIGS + +Use SCM_ASSERT_RANGE or SCM_VALIDATE_XXX_RANGE instead of SCM_OUTOFRANGE. +Use scm_memory_error instead of SCM_NALLOC. + + +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. + +** Header files kw.h and genio.h have been removed. + +** The module (ice-9 getopt-gnu-style) has been removed. + +** New module (ice-9 documentation) + +Implements the interface to documentation strings associated with +objects. + +* Changes to the stand-alone interpreter + +** New command line option --debug + +Start Guile with debugging evaluator and backtraces enabled. + +This is useful when debugging your .guile init file or scripts. + +** New help facility + +Usage: (help NAME) gives documentation about objects named NAME (a symbol) + (help REGEXP) ditto for objects with names matching REGEXP (a string) + (help ,EXPR) gives documentation for object returned by EXPR + (help) gives this text + +`help' searches among bindings exported from loaded modules, while +`apropos' searches among bindings visible from the "current" module. + +Examples: (help help) + (help cons) + (help "output-string") + +** `help' and `apropos' now prints full module names + +** 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.) + +** Part of module system symbol lookup now implemented in C + +The eval closure of most modules is now implemented in C. Since this +was one of the bottlenecks for loading speed, Guile now loads code +substantially faster than before. + +** 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. + +** Improvements to garbage collector + +Guile 1.4 has a new policy for triggering heap allocation and +determining the sizes of heap segments. It fixes a number of problems +in the old GC. + +1. The new policy can handle two separate pools of cells + (2-word/4-word) better. (The old policy would run wild, allocating + more and more memory for certain programs.) + +2. The old code would sometimes allocate far too much heap so that the + Guile process became gigantic. The new code avoids this. + +3. The old code would sometimes allocate too little so that few cells + were freed at GC so that, in turn, too much time was spent in GC. + +4. The old code would often trigger heap allocation several times in a + row. (The new scheme predicts how large the segments needs to be + in order not to need further allocation.) + +All in all, the new GC policy will make larger applications more +efficient. + +The new GC scheme also is prepared for POSIX threading. Threads can +allocate private pools of cells ("clusters") with just a single +function call. Allocation of single cells from such a cluster can +then proceed without any need of inter-thread synchronization. + +** New environment variables controlling GC parameters + +GUILE_MAX_SEGMENT_SIZE Maximal segment size + (default = 2097000) + +Allocation of 2-word cell heaps: + +GUILE_INIT_SEGMENT_SIZE_1 Size of initial heap segment in bytes + (default = 360000) + +GUILE_MIN_YIELD_1 Minimum number of freed cells at each + GC in percent of total heap size + (default = 40) + +Allocation of 4-word cell heaps +(used for real numbers and misc other objects): + +GUILE_INIT_SEGMENT_SIZE_2, GUILE_MIN_YIELD_2 + +(See entry "Way for application to customize GC parameters" under + section "Changes to the scm_ interface" below.) + +** Guile now implements reals using 4-word cells + +This speeds up computation with reals. (They were earlier allocated +with `malloc'.) There is still some room for optimizations, however. + +** Some further steps toward POSIX thread support have been taken + +*** Guile's critical sections (SCM_DEFER/ALLOW_INTS) +don't have much effect any longer, and many of them will be removed in +next release. + +*** Signals +are only handled at the top of the evaluator loop, immediately after +I/O, and in scm_equalp. + +*** The GC can allocate thread private pools of pairs. + +* 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. + +** Deprecated: list* + +The list* functionality is now provided by cons* (SRFI-1 compliant) + +** New procedure: cons* ARG1 ARG2 ... ARGn + +Like `list', but the last arg provides the tail of the constructed list, +returning (cons ARG1 (cons ARG2 (cons ... ARGn))). + +Requires at least one argument. If given one argument, that argument +is returned as result. + +This function is called `list*' in some other Schemes and in Common LISP. + +** Removed deprecated: serial-map, serial-array-copy!, serial-array-map! + +** New procedure: object-documentation OBJECT + +Returns the documentation string associated with OBJECT. The +procedure uses a caching mechanism so that subsequent lookups are +faster. + +Exported by (ice-9 documentation). + +** module-name now returns full names of modules + +Previously, only the last part of the name was returned (`session' for +`(ice-9 session)'). Ex: `(ice-9 session)'. + +* 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: SCM_DEFINE/SCM_DEFINE1/SCM_PROC + +Now Guile primitives are defined using the SCM_DEFINE/SCM_DEFINE1/SCM_PROC +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). + +However, a major overhaul of these macros is scheduled for the next release of +guile. + +** 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. + +** The following types, functions and macros from numbers.h are deprecated: +scm_dblproc, SCM_UNEGFIXABLE, SCM_FLOBUFLEN, SCM_INEXP, SCM_CPLXP, SCM_REAL, +SCM_IMAG, SCM_REALPART, scm_makdbl, SCM_SINGP, SCM_NUM2DBL, SCM_NO_BIGDIG + +Further, it is recommended not to rely on implementation details for guile's +current implementation of bignums. It is planned to replace this +implementation with gmp in the future. + +** 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. + +** Way for application to customize GC parameters + +The application can set up other default values for the GC heap +allocation parameters + + GUILE_INIT_HEAP_SIZE_1, GUILE_MIN_YIELD_1, + GUILE_INIT_HEAP_SIZE_2, GUILE_MIN_YIELD_2, + GUILE_MAX_SEGMENT_SIZE, + +by setting + + scm_default_init_heap_size_1, scm_default_min_yield_1, + scm_default_init_heap_size_2, scm_default_min_yield_2, + scm_default_max_segment_size + +respectively before callong scm_boot_guile. + +(See entry "New environment variables ..." in section +"Changes to the stand-alone interpreter" above.) + +** scm_protect_object/scm_unprotect_object now nest + +This means that you can call scm_protect_object multiple times on an +object and count on the object being protected until +scm_unprotect_object has been call the same number of times. + +The functions also have better time complexity. + +Still, it is usually possible to structure the application in a way +that you don't need to use these functions. For example, if you use a +protected standard Guile list to keep track of live objects rather +than some custom data type, objects will die a natural death when they +are no longer needed. + +** Deprecated type tags: scm_tc16_flo, scm_tc_flo, scm_tc_dblr, scm_tc_dblc + +Guile does not provide the float representation for inexact real numbers any +more. Now, only doubles are used to represent inexact real numbers. Further, +the tag names scm_tc_dblr and scm_tc_dblc have been changed to scm_tc16_real +and scm_tc16_complex, respectively. + +** Removed deprecated type scm_smobfuns + +** Removed deprecated function scm_newsmob + +** Warning: scm_make_smob_type_mfpe might become deprecated in a future release + +There is an ongoing discussion among the developers whether to +deprecate `scm_make_smob_type_mfpe' or not. Please use the current +standard interface (scm_make_smob_type, scm_set_smob_XXX) in new code +until this issue has been settled. + +** Removed deprecated type tag scm_tc16_kw + +** Added type tag scm_tc16_keyword + +(This was introduced already in release 1.3.4 but was not documented + until now.) + +** gdb_print now prints "*** Guile not initialized ***" until Guile initialized + +* 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 @@ -1034,7 +2096,7 @@ 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. ** The procedure truncate-file now works on string ports as well as file ports. If the size argument is omitted, the current @@ -1086,6 +2148,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 @@ -1107,8 +2179,8 @@ 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