X-Git-Url: http://git.hcoop.net/bpt/guile.git/blobdiff_plain/28d77376bc138cf90ba0fe6c9f4c14ab5858297d..c0997079b4f65b10fc96da4467ce0b4fcb534080:/NEWS diff --git a/NEWS b/NEWS index f9059f0a1..73e92a914 100644 --- a/NEWS +++ b/NEWS @@ -1,104 +1,61 @@ 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: - -* New primitive: `simple-format', affects `scm-error', scm_display_error, & scm_error message strings - -(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." - -The two C procedures: scm_display_error and scm_error, as well as the -primitive `scm-error', now use scm_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. +Changes since Guile 1.4: -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: +* Changes to the distribution -#ifdef HAVE_SCM_SIMPLE_FORMAT -#define FMT_S "~S" -#else -#define FMT_S "%S" -#endif +* Changes to the stand-alone interpreter -Then represent each of your error messages using a preprocessor macro: +** It's now possible to create modules with controlled environments -#define E_SPIDER_ERROR "There's a spider in your " ## FMT_S ## "!!!" - -In Scheme: +Example: -(define fmt-s (if (defined? 'simple-format) "~S" "%S")) -(define make-message string-append) +(define m (make-module 1021 (list (resolve-interface '(ice-9 safe-r5rs))))) +;;; 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 -(define e-spider-error (make-message "There's a spider in your " fmt-s "!!!")) +* Changes to Scheme functions and syntax -Method 2: Use the oldfmt function found in doc/oldfmt.c. +** New define-module option: pure -In C: +Tells the module system not to include any bindings from the root +module. -scm_misc_error ("picnic", scm_c_oldfmt0 ("There's a spider in your ~S!!!"), - ...); +Example: -In Scheme: +(define-module (totally-empty-module) + :pure) -(scm-error 'misc-error "picnic" (oldfmt "There's a spider in your ~S!!!") - ...) +** New define-module option: export NAME1 ... -* Massive software engineering face-lift by Greg J. Badros +Export names NAME1 ... -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). +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'. -Also, many SCM_VALIDATE_* macros are defined to ease the redundancy and -improve the readability of argument checking. +Example: -All (nearly?) K&R prototypes for functions replaced with ANSI C equivalents. +(define-module (foo) + :pure + :use-module (ice-9 r5rs) + :export (bar)) -* Dynamic linking now uses libltdl from the libtool package. +;;; Note that we're pure R5RS below this point! -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. +(define (bar) + ...) -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. +* Changes to the gh_ interface -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. +* Changes to the scm_ interface -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. + +Changes since Guile 1.3.4: * Changes to the distribution @@ -136,7 +93,7 @@ features: These are likely to become separate modules some day. -** Added new configure option --enable-debug-freelist +** 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!'. @@ -152,8 +109,92 @@ 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 @@ -182,14 +223,223 @@ at the top of the script. (The first options enables the debugging evaluator. The second enables backtraces.) -** New procedure: port-closed? PORT -Returns #t if PORT is closed or #f if it is open. +** 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. @@ -211,16 +461,239 @@ 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