X-Git-Url: https://git.hcoop.net/bpt/guile.git/blobdiff_plain/0b073f0f148649a425edcb184e6b3a749b545919..fe6ee0528b08d48a8305dc6809e09dac97060118:/NEWS diff --git a/NEWS b/NEWS index f29a14ef2..bac814d1b 100644 --- a/NEWS +++ b/NEWS @@ -1,24 +1,663 @@ -Guile NEWS --- history of user-visible changes. -*- text -*- -Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc. +Guile NEWS --- history of user-visible changes. +Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. See the end for copying conditions. Please send Guile bug reports to bug-guile@gnu.org. Changes since the stable branch: +* Changes to the distribution + +** Guile now provide and uses an "effective" version number. + +Guile now provides scm_effective_version and effective-version +functions which return the "effective" version number. This is just +the normal full version string without the final micro-version number, +so the current effective-version is "1.6". The effective version +should remain unchanged during a stable series, and should be used for +items like the versioned share directory name +i.e. /usr/share/guile/1.6. + +Providing an unchanging version number during a stable release for +things like the versioned share directory can be particularly +important for Guile "add-on" packages, since it provides a directory +that they can install to that won't be changed out from under them +with each micro release during a stable series. + +** There are two new thread implementation options: "null" and "coop-pthreads". + +When you configure "--with-threads=null", you will get the usual +threading API (call-with-new-thread, make-mutex, etc), but you can't +actually create new threads. Also, "--with-threads=no" is now +equivalent to "--with-threads=null". This means that the thread API +is always present, although you might not be able to create new +threads. + +The "coop-pthread" (or shorter: "copt") thread implementation will use +portable POSIX threads but will restrict them so that only one thread +can execute 'in Guile' at any one time. This option will give you the +same basic behavior as the old "coop" option, but hopefully in a more +portable way. + +The default is now "coop-pthread", unless your platform doesn't have +pthreads, in which case "null" threads are used. + +** Guile now includes its own version of libltdl. + +We now use a modified version of libltdl that allows us to make +improvements to it without having to rely on libtool releases. + +* Changes to the standalone interpreter + +** New command line option `--no-debug'. + +Specifying `--no-debug' on the command line will keep the debugging +evaluator turned off, even for interactive sessions. + +** User-init file ~/.guile is now loaded with the debugging evaluator. + +Previously, the normal evaluator would have been used. Using the +debugging evaluator gives better error messages. + +* Changes to Scheme functions and syntax + +** Checking for duplicate bindings in module system + +The module system now can check for name conflicts among imported +bindings. + +The behavior can be controlled by specifying one or more duplicates +handlers. For example, to make Guile return an error for every name +collision, write: + +(define-module (foo) + :use-module (bar) + :use-module (baz) + :duplicates check) + +The new default behavior of the module system when a name collision +has been detected is to + + 1. Give priority to bindings marked as a replacement. + 2. Issue a warning. + 3. Give priority to the last encountered binding (this corresponds to + the old behavior). + +If you want the old behavior back without replacements or warnings you +can add the line: + + (default-duplicate-binding-handler 'last) + +to your .guile init file. + +The syntax for the :duplicates option is: + + :duplicates HANDLER-NAME | (HANDLER1-NAME HANDLER2-NAME ...) + +Specifying multiple handlers is useful since some handlers (such as +replace) can defer conflict resolution to others. Each handler is +tried until a binding is selected. + +Currently available duplicates handlers are: + + check report an error for bindings with a common name + warn issue a warning for bindings with a common name + replace replace bindings which have an imported replacement + warn-override-core issue a warning for imports which override core bindings + and accept the override + first select the first encountered binding (override) + last select the last encountered binding (override) + +These two are provided by the (oop goops) module: + + merge-generics merge generic functions with a common name + into an + merge-accessors merge accessors with a common name + +The default duplicates handler is: + + (replace warn last) + +A recommended handler (which is likely to correspond to future Guile +behavior) can be installed with: + + (default-duplicate-binding-handler '(replace warn-override-core check)) + +** New define-module option: :replace + +:replace works as :export, but, in addition, marks the binding as a +replacement. + +A typical example is `format' in (ice-9 format) which is a replacement +for the core binding `format'. + +** Adding prefixes to imported bindings in the module system + +There is now a new :use-module option :prefix. It can be used to add +a prefix to all imported bindings. + + (define-module (foo) + :use-module ((bar) :prefix bar:)) + +will import all bindings exported from bar, but rename them by adding +the prefix `bar:'. + +** Merging generic functions + +It is sometimes tempting to use GOOPS accessors with short names. +For example, it is tempting to use the name `x' for the x-coordinate +in vector packages. + +Assume that we work with a graphical package which needs to use two +independent vector packages for 2D and 3D vectors respectively. If +both packages export `x' we will encounter a name collision. + +This can now be resolved automagically with the duplicates handler +`merge-generics' which gives the module system license to merge all +generic functions sharing a common name: + +(define-module (math 2D-vectors) + :use-module (oop goops) + :export (x y ...)) + +(define-module (math 3D-vectors) + :use-module (oop goops) + :export (x y z ...)) + +(define-module (my-module) + :use-module (math 2D-vectors) + :use-module (math 3D-vectors) + :duplicates merge-generics) + +x in (my-module) will now share methods with x in both imported +modules. + +There will, in fact, now be three distinct generic functions named +`x': x in (2D-vectors), x in (3D-vectors), and x in (my-module). The +last function will be an , extending the previous +two functions. + +Let's call the imported generic functions the "ancestor functions". x +in (my-module) is, in turn, a "descendant function" of the imported +functions, extending its ancestors. + +For any generic function G, the applicable methods are selected from +the union of the methods of the descendant functions, the methods of G +itself and the methods of the ancestor functions. + +This, ancestor functions share methods with their descendants and vice +versa. This implies that x in (math 2D-vectors) can will share the +methods of x in (my-module) and vice versa, while x in (math 2D-vectors) +doesn't share the methods of x in (math 3D-vectors), thus preserving +modularity. + +Sharing is dynamic, so that adding new methods to a descendant implies +adding it to the ancestor. + +If duplicates checking is desired in the above example, the following +form of the :duplicates option can be used instead: + + :duplicates (merge-generics check) + +** New function: effective-version + +Returns the "effective" version number. This is just the normal full +version string without the final micro-version number. See "Changes +to the distribution" above. + +** Futures + +Futures is a way of providing an alternative evaluation policy, very +similar in principle to "promises". Like promises, futures allow the +main process to continue instantly, but while promises postpone +evaluation ("lazy" evaluation) until the value is requested, futures +immediately starts evaluation in a parallel thread. + +Futures are good when you want to express that "I'll need the value of +this computation sometime soon" and want to allow processing to go on +in the background until that time arrives. + +** New syntax: future FORM + +Begin evaluation of FORM in a parallel thread and return the future +immediately. (Akin to 'delay'.) + +** New procedure: future-ref FUTURE + +Return the computed value of the future. Wait if the computation is +not finished. (Akin to 'force'.) + +** New syntax: parallel FORM ... + +Compute the results of FORM ... in parallel (in a separate thread for +each form) and return them as multiple values. + +** New syntax: letpar ((VAR EXP) ...) BODYFORM ... + +Like 'let' but evaluates the binding expressions EXP ... in parallel. + +** New functions: par-map, par-for-each PROC ARGLIST ... + +Like 'map' and 'for-each' but evaluate the procedure PROC in a +separate thread for each (set of) argument(s). All applications are +guaranteed to be completed before the procedure returns. + +** New functions: n-par-map, n-par-for-each N PROC ARGLIST ... + +Like 'par-map' and 'par-for-each' but evaluate the procedure PROC in N +threads. This is useful when PROC uses large amounts of resources +and/or the argument list(s) is/are long so that one thread per (set +of) argument(s) would consume too much system resources. On a +dual-CPU system, N = 4 would often be a good choice. + +** Fair mutexes and condition variables + +Fair mutexes and condition variables have been added. The fairness +means that scheduling is arranged to give as equal time shares as +possible and that threads are awakened in a first-in-first-out +manner. This is not guaranteed with standard mutexes and condition +variables. + +In addition, fair mutexes are recursive. Locking a fair mutex that +you have already locked will succeed. Every call to lock-mutex must +be matched with a call to unlock-mutex. Only the last call to +unlock-mutex will actually unlock the mutex. + +A fair condition variable must be used together with a fair mutex, +just as a standard condition variable must be used together with a +standard mutex. + +** New functions: make-fair-mutex, make-fair-condition-variable' + +Make a new fair mutex and a new fair condition variable respectively. + +** New function 'try-mutex'. + +This function will attempt to lock a mutex but will return immediately +instead if blocking and indicate failure. + +** Waiting on a condition variable can have a timeout. + +The funtion 'wait-condition-variable' now takes a third, optional +argument that specifies the point in time where the waiting should be +aborted. + +** New function 'broadcast-condition-variable'. + +** New functions 'all-threads' and 'current-thread'. + +** Signals and system asyncs work better with threads. + +The function 'sigaction' now takes a fourth, optional, argument that +specifies the thread that the handler should run in. When the +argument is omitted, the handler will run in the thread that called +'sigaction'. + +Likewise, 'system-async-mark' takes a second, optional, argument that +specifies the thread that the async should run in. When it is +omitted, the async will run in the thread that called +'system-async-mark'. + +C code can use the new functions scm_sigaction_for_thread and +scm_system_async_mark_for_thread to pass the new thread argument. + +** The function 'system-async' is deprecated. + +You can now pass any zero-argument procedure to 'system-async-mark'. +The function 'system-async' will just return its argument unchanged +now. + +** New functions 'call-with-blocked-asyncs' and + 'call-with-unblocked-asyncs' + +The expression (call-with-blocked-asyncs PROC) will call PROC and will +block execution of system asyncs for the current thread by one level +while PROC runs. Likewise, call-with-unblocked-asyncs will call a +procedure and will unblock the execution of system asyncs by one +level for the current thread. + +Only system asyncs are affected by these functions. + +** The functions 'mask-signals' and 'unmask-signals' are deprecated. + +Use 'call-with-blocked-asyncs' or 'call-with-unblocked-asyncs' +instead. Those functions are easier to use correctly and can be +nested. + +** New function 'unsetenv'. + +** New macro 'define-syntax-public'. + +It works like 'define-syntax' and also exports the defined macro (but +only on top-level). + +** There is support for Infinity and NaNs. + +Following PLT Scheme, Guile can now work with infinite numbers, and +'not-a-numbers'. + +There is new syntax for numbers: "+inf.0" (infinity), "-inf.0" +(negative infinity), "+nan.0" (not-a-number), and "-nan.0" (same as +"+nan.0"). These numbers are inexact and have no exact counterpart. + +Dividing by an inexact zero returns +inf.0 or -inf.0, depending on the +sign of the dividend. The infinities are integers, and they answer #t +for both 'even?' and 'odd?'. The +nan.0 value is not an integer and is +not '=' to itself, but '+nan.0' is 'eqv?' to itself. + +For example + + (/ 1 0.0) + => +inf.0 + + (/ 0 0.0) + => +nan.0 + + (/ 0) + ERROR: Numerical overflow + +Two new predicates 'inf?' and 'nan?' can be used to test for the +special values. + +** Inexact zero can have a sign. + +Guile can now distinguish between plus and minus inexact zero, if your +platform supports this, too. The two zeros are equal according to +'=', but not according to 'eqv?'. For example + + (- 0.0) + => -0.0 + + (= 0.0 (- 0.0)) + => #t + + (eqv? 0.0 (- 0.0)) + => #f + +** We now have uninterned symbols. + +The new function 'make-symbol' will return a uninterned symbol. This +is a symbol that is unique and is guaranteed to remain unique. +However, uninterned symbols can not yet be read back in. + +Use the new function 'symbol-interned?' to check whether a symbol is +interned or not. + +** pretty-print has more options. + +The function pretty-print from the (ice-9 pretty-print) module can now +also be invoked with keyword arguments that control things like +maximum output width. See its online documentation. + ** Variables have no longer a special behavior for `equal?'. Previously, comparing two variables with `equal?' would recursivly compare their values. This is no longer done. Variables are now only `equal?' if they are `eq?'. +** `(begin)' is now valid. + +You can now use an empty `begin' form. It will yield # +when evaluated and simply be ignored in a definition context. + +** Removed: substring-move-left!, substring-move-right! + +Use `substring-move!' instead. + +** Deprecated: procedure->macro + +Change your code to use either procedure->memoizing-macro or, probably better, +to use r5rs macros. Also, be aware that macro expansion will not be done +during evaluation, but prior to evaluation. + +** Soft ports now allow a `char-ready?' procedure + +The vector argument to `make-soft-port' can now have a length of +either 5 or 6. (Previously the length had to be 5.) The optional 6th +element is interpreted as an `input-waiting' thunk -- i.e. a thunk +that returns the number of characters that can be read immediately +without the soft port blocking. + +** New debugging feature: breakpoints. + +Guile now has breakpoints. For details see the `Debugging Features' +chapter in the reference manual. + +** Deprecated: undefine + +There is no replacement for undefine. + * Changes to the C interface +** New function: scm_effective_version + +Returns the "effective" version number. This is just the normal full +version string without the final micro-version number. See "Changes +to the distribution" above. + +** The function scm_call_with_new_thread has a new prototype. + +Instead of taking a list with the thunk and handler, these two +arguments are now passed directly: + + SCM scm_call_with_new_thread (SCM thunk, SCM handler); + +This is an incompatible change. + +** The value 'scm_mask_ints' is no longer writable. + +Previously, you could set scm_mask_ints directly. This is no longer +possible. Use scm_c_call_with_blocked_asyncs and +scm_c_call_with_unblocked_asyncs instead. + +** New functions scm_c_call_with_blocked_asyncs and + scm_c_call_with_unblocked_asyncs + +Like scm_call_with_blocked_asyncs etc. but for C functions. + +** New snarfer macro SCM_DEFINE_PUBLIC. + +This is like SCM_DEFINE, but also calls scm_c_export for the defined +function in the init section. + +** The snarfer macro SCM_SNARF_INIT is now officially supported. + +** New macros SCM_VECTOR_REF and SCM_VECTOR_SET. + +Use these in preference to SCM_VELTS. + +** The SCM_VELTS macros now returns a read-only vector. For writing, +use the new macros SCM_WRITABLE_VELTS or SCM_VECTOR_SET. The use of +SCM_WRITABLE_VELTS is discouraged, though. + +** Garbage collector rewrite. + +The garbage collector is cleaned up a lot, and now uses lazy +sweeping. This is reflected in the output of (gc-stats); since cells +are being freed when they are allocated, the cells-allocated field +stays roughly constant. + +For malloc related triggers, the behavior is changed. It uses the same +heuristic as the cell-triggered collections. It may be tuned with the +environment variables GUILE_MIN_YIELD_MALLOC. This is the percentage +for minimum yield of malloc related triggers. The default is 40. +GUILE_INIT_MALLOC_LIMIT sets the initial trigger for doing a GC. The +default is 200 kb. + +Debugging operations for the freelist have been deprecated, along with +the C variables that control garbage collection. The environment +variables GUILE_MAX_SEGMENT_SIZE, GUILE_INIT_SEGMENT_SIZE_2, +GUILE_INIT_SEGMENT_SIZE_1, and GUILE_MIN_YIELD_2 should be used. + +** The function scm_definedp has been renamed to scm_defined_p + +The name scm_definedp is deprecated. + +** The struct scm_cell has been renamed to scm_t_cell + +This is in accordance to Guile's naming scheme for types. Note that +the name scm_cell is now used for a function that allocates and +initializes a new cell (see below). + +** New functions for memory management + +A new set of functions for memory management has been added since the +old way (scm_must_malloc, scm_must_free, etc) was error prone and +indeed, Guile itself contained some long standing bugs that could +cause aborts in long running programs. + +The new functions are more symmetrical and do not need cooperation +from smob free routines, among other improvements. + +The new functions are scm_malloc, scm_realloc, scm_calloc, scm_strdup, +scm_strndup, scm_gc_malloc, scm_gc_calloc, scm_gc_realloc, +scm_gc_free, scm_gc_register_collectable_memory, and +scm_gc_unregister_collectable_memory. Refer to the manual for more +details and for upgrading instructions. + +The old functions for memory management have been deprecated. They +are: scm_must_malloc, scm_must_realloc, scm_must_free, +scm_must_strdup, scm_must_strndup, scm_done_malloc, scm_done_free. + ** New function: scm_str2string This function creates a scheme string from a 0-terminated C string. The input string is copied. +** Declarations of exported features are marked with SCM_API. + +Every declaration of a feature that belongs to the exported Guile API +has been marked by adding the macro "SCM_API" to the start of the +declaration. This macro can expand into different things, the most +common of which is just "extern" for Unix platforms. On Win32, it can +be used to control which symbols are exported from a DLL. + +If you `#define SCM_IMPORT' before including , SCM_API +will expand into "__declspec (dllimport) extern", which is needed for +linking to the Guile DLL in Windows. + +There are also SCM_RL_IMPORT, QT_IMPORT, SCM_SRFI1314_IMPORT, and +SCM_SRFI4_IMPORT, for the corresponding libraries. + +** SCM_NEWCELL and SCM_NEWCELL2 have been deprecated. + +Use the new functions scm_cell and scm_double_cell instead. The old macros +had problems because with them allocation and initialization was separated and +the GC could sometimes observe half initialized cells. Only careful coding by +the user of SCM_NEWCELL and SCM_NEWCELL2 could make this safe and efficient. + +** CHECK_ENTRY, CHECK_APPLY and CHECK_EXIT have been deprecated. + +Use the variables scm_check_entry_p, scm_check_apply_p and scm_check_exit_p +instead. + +** SRCBRKP has been deprecated. + +Use scm_c_source_property_breakpoint_p instead. + +** Deprecated: scm_makmacro + +Change your code to use either scm_makmmacro or, probably better, to use r5rs +macros. Also, be aware that macro expansion will not be done during +evaluation, but prior to evaluation. + +** Removed from scm_root_state: def_inp, def_outp, def_errp, together +with corresponding macros scm_def_inp, scm_def_outp and scm_def_errp. +These were undocumented and unused copies of the standard ports at the +time that Guile was initialised. Normally the current ports should be +used instead, obtained from scm_current_input_port () etc. If an +application needs to retain earlier ports, it should save them in a +gc-protected location. + +** Removed compile time option MEMOIZE_LOCALS + +Now, caching of local variable positions during memoization is mandatory. +However, the option to disable the caching has most probably not been used +anyway. + +** Removed compile time option SCM_RECKLESS + +Full number of arguments checking of closures is mandatory now. However, the +option to disable the checking has most probably not been used anyway. + +** Removed compile time option SCM_CAUTIOUS + +Full number of arguments checking of closures is mandatory now. However, the +option to disable the checking has most probably not been used anyway. + +** Deprecated configure flags USE_THREADS and GUILE_ISELECT + +Previously, when the C preprocessor macro USE_THREADS was defined, +libguile included a thread API. This API is now always included, even +when threads are not really supported. Thus, you don't need to test +for USE_THREADS. + +Analogously, GUILE_ISELECT was defined when the function +scm_internal_select was provided by Guile. This function is now +always defined, and GUILE_ISELECT with it. + +** Removed definitions: scm_lisp_nil, scm_lisp_t, s_nil_ify, scm_m_nil_ify, +s_t_ify, scm_m_t_ify, s_0_cond, scm_m_0_cond, s_0_ify, scm_m_0_ify, s_1_ify, +scm_m_1_ify, scm_debug_newcell, scm_debug_newcell2, scm_tc16_allocated, +SCM_SET_SYMBOL_HASH, SCM_IM_NIL_IFY, SCM_IM_T_IFY, SCM_IM_0_COND, +SCM_IM_0_IFY, SCM_IM_1_IFY, SCM_GC_SET_ALLOCATED, scm_debug_newcell, +scm_debug_newcell2, scm_substring_move_left_x, scm_substring_move_right_x, +long_long, ulong_long, scm_sizet, SCM_WNA, 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, moddata, registered_mods, +scm_register_module_xxx, scm_registered_modules, +scm_clear_registered_modules, scm_wta, *top-level-lookup-closure*, +scm_top_level_lookup_closure_var, scm_system_transformer, scm_eval_3, +scm_eval2, SCM_SETAND_CAR, SCM_SETOR_CAR, SCM_SETAND_CDR, SCM_SETOR_CDR, +SCM_FREEP, SCM_NFREEP, SCM_GC8MARKP, SCM_SETGC8MARK, SCM_CLRGC8MARK, +SCM_GCTYP16, SCM_GCCDR, scm_remember, scm_protect_object, +scm_unprotect_object, root_module_lookup_closure, scm_sym_app, +scm_sym_modules, module_prefix, make_modules_in_var, +beautify_user_module_x_var, try_module_autoload_var, scm_module_full_name, +scm_the_root_module, scm_make_module, scm_ensure_user_module, +scm_load_scheme_module, scm_port, scm_ptob_descriptor, scm_port_rw_active, +scm_close_all_ports_except, scm_rstate, scm_rng, scm_i_rstate, +SCM_SLOPPY_STRINGP, SCM_RWSTRINGP, SCM_STRING_UCHARS, SCM_STRING_CHARS, +scm_read_only_string_p, scm_makstr, scm_makfromstr, +scm_make_shared_substring, scm_tc7_substring, SCM_SLOPPY_CONSP, +SCM_SLOPPY_NCONSP, scm_tc7_ssymbol, scm_tc7_msymbol, scm_tcs_symbols, +sym_huh, scm_variable_set_name_hint, scm_builtin_variable, SCM_VARVCELL, +SCM_UDVARIABLEP, SCM_DEFVARIABLEP, scm_internal_with_fluids, +scm_make_gsubr, scm_make_gsubr_with_generic, scm_create_hook, list*, +SCM_LIST0, SCM_LIST1, SCM_LIST2, SCM_LIST3, SCM_LIST4, SCM_LIST5, +SCM_LIST6, SCM_LIST7, SCM_LIST8, SCM_LIST9, scm_listify, scm_sloppy_memq, +scm_sloppy_memv, scm_sloppy_member, scm_end_of_file_key, +scm_read_and_eval_x, scm_mkbig, scm_big2inum, scm_adjbig, scm_normbig, +scm_copybig, scm_2ulong2big, scm_dbl2big, scm_big2dbl, SCM_FIXNUM_BIT, +scm_subr_entry, SCM_SUBR_DOC, scm_make_subr_opt, scm_make_subr, +scm_make_subr_with_generic, setjmp_type, setjmp_type, +scm_call_catching_errors, scm_make_smob_type_mfpe, scm_set_smob_mfpe, +scm_strprint_obj, scm_read_0str, scm_eval_0str, SCM_CHARS, SCM_UCHARS, +SCM_SETCHARS, SCM_SLOPPY_SUBSTRP, SCM_SUBSTR_STR, SCM_SUBSTR_OFFSET, +SCM_LENGTH_MAX, SCM_LENGTH, SCM_SETLENGTH, SCM_ROSTRINGP, SCM_ROLENGTH, +SCM_ROCHARS, SCM_ROUCHARS, SCM_SUBSTRP, SCM_COERCE_SUBSTR, scm_strhash, +scm_sym2vcell, scm_sym2ovcell_soft, scm_sym2ovcell, +scm_intern_obarray_soft, scm_intern_obarray, scm_intern, scm_intern0, +scm_sysintern, scm_sysintern0, scm_sysintern0_no_module_lookup, +scm_symbol_value0, scm_string_to_obarray_symbol, scm_intern_symbol, +scm_unintern_symbol, scm_symbol_binding, scm_symbol_interned_p, +scm_symbol_bound_p, scm_symbol_set_x, scm_gentemp, +scm_init_symbols_deprecated, s_vector_set_length_x, scm_vector_set_length_x, +scm_contregs, scm_debug_info, scm_debug_frame, SCM_DSIDEVAL, SCM_OPDIRP, +scm_fport, scm_option, SCM_CONST_LONG, SCM_VCELL, SCM_GLOBAL_VCELL, +SCM_VCELL_INIT, SCM_GLOBAL_VCELL_INIT, scm_srcprops, scm_srcprops_chunk, +scm_info_frame, scm_stack, scm_array, scm_array_dim, SCM_ARRAY_CONTIGUOUS, +SCM_HUGE_LENGTH, SCM_FUNC_NAME, SCM_WTA, RETURN_SCM_WTA, +SCM_VALIDATE_NUMBER_COPY, SCM_VALIDATE_NUMBER_DEF_COPY, +SCM_VALIDATE_STRINGORSUBSTR, SCM_VALIDATE_ROSTRING, +SCM_VALIDATE_ROSTRING_COPY, SCM_VALIDATE_NULLORROSTRING_COPY, +SCM_VALIDATE_RWSTRING, SCM_VALIDATE_OPDIR, DIGITS, scm_small_istr2int, +scm_istr2int, scm_istr2flo, scm_istring2number, scm_istr2int, +scm_istr2flo, scm_istring2number, scm_vtable_index_vcell, scm_si_vcell, +SCM_ECONSP, SCM_NECONSP, SCM_GLOC_VAR, SCM_GLOC_VAL, SCM_GLOC_SET_VAL, +SCM_GLOC_VAL_LOC, scm_make_gloc, scm_gloc_p, scm_tc16_variable + Changes since Guile 1.4: * Changes to the distribution @@ -46,6 +685,11 @@ micro version number. In addition, ./GUILE-VERSION now defines GUILE_MICRO_VERSION. +** New preprocessor definitions are available for checking versions. + +version.h now #defines SCM_MAJOR_VERSION, SCM_MINOR_VERSION, and +SCM_MICRO_VERSION to the appropriate integer values. + ** Guile now actively warns about deprecated features. The new configure option `--enable-deprecated=LEVEL' and the @@ -55,8 +699,9 @@ See INSTALL and README for more information. ** Guile is much more likely to work on 64-bit architectures. Guile now compiles and passes "make check" with only two UNRESOLVED GC -cases on Alpha based machines now. Thanks to John Goerzen for the use -of a test machine. +cases on Alpha and ia64 based machines now. Thanks to John Goerzen +for the use of a test machine, and thanks to Stefan Jahn for ia64 +patches. ** New functions: setitimer and getitimer. @@ -1208,6 +1853,12 @@ These are conversion functions between the various ANSI C integral types and Scheme numbers. NOTE: The scm_num2xxx functions don't accept an inexact argument. +** New functions: scm_float2num, scm_double2num, + scm_num2float, scm_num2double. + +These are conversion functions between the two ANSI C float types and +Scheme numbers. + ** New number validation macros: SCM_NUM2{SIZE,PTRDIFF,SHORT,USHORT,INT,UINT}[_DEF] @@ -5914,4 +6565,3 @@ Local variables: mode: outline paragraph-separate: "[ ]*$" end: -