-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.
\f
+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
+
+** 'call-with-current-continuation' is now also available under the name
+ 'call/cc'.
+
+** 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 (different warning if overriding core binding).
+ 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 <extended-generic>
+ merge-accessors merge accessors with a common name
+
+The default duplicates handler is:
+
+ (replace warn-override-core 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 <extended-generic>, 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 #<unspecified>
+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 <libguile.h>, 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
-** As per RELEASE directions, deprecated items have been removed
+** A top-level TODO file is included.
-*** Macros removed
+** Guile now uses a versioning scheme similar to that of the Linux kernel.
- SCM_INPORTP, SCM_OUTPORTP SCM_ICHRP, SCM_ICHR, SCM_MAKICHR
- SCM_SETJMPBUF SCM_NSTRINGP SCM_NRWSTRINGP SCM_NVECTORP SCM_DOUBLE_CELLP
+Guile now always uses three numbers to represent the version,
+i.e. "1.6.5". The first number, 1, is the major version number, the
+second number, 6, is the minor version number, and the third number,
+5, is the micro version number. Changes in major version number
+indicate major changes in Guile.
-*** C Functions removed
+Minor version numbers that are even denote stable releases, and odd
+minor version numbers denote development versions (which may be
+unstable). The micro version number indicates a minor sub-revision of
+a given MAJOR.MINOR release.
- scm_sysmissing scm_tag scm_tc16_flo scm_tc_flo
- scm_fseek - replaced by scm_seek.
- gc-thunk - replaced by after-gc-hook.
- gh_int2scmb - replaced by gh_bool2scm.
- scm_tc_dblr - replaced by scm_tc16_real.
- scm_tc_dblc - replaced by scm_tc16_complex.
- scm_list_star - replaced by scm_cons_star.
+In keeping with the new scheme, (minor-version) and scm_minor_version
+no longer return everything but the major version number. They now
+just return the minor version number. Two new functions
+(micro-version) and scm_micro_version have been added to report the
+micro version number.
-*** scheme functions removed:
+In addition, ./GUILE-VERSION now defines GUILE_MICRO_VERSION.
- tag - no replacement.
- fseek - replaced by seek.
- list* - replaced by cons*.
+** 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
+environment variable GUILE_WARN_DEPRECATED control this mechanism.
+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 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.
+
+These implement a fairly direct interface to the libc functions of the
+same name.
+
+** The #. reader extension is now disabled by default.
+
+For safety reasons, #. evaluation is disabled by default. To
+re-enable it, set the fluid read-eval? to #t. For example:
+
+ (fluid-set! read-eval? #t)
+
+but make sure you realize the potential security risks involved. With
+read-eval? enabled, reading a data file from an untrusted source can
+be dangerous.
** New SRFI modules have been added:
SRFI-0 `cond-expand' is now supported in Guile, without requiring
using a module.
+(srfi srfi-1) is a library containing many useful pair- and list-processing
+ procedures.
+
(srfi srfi-2) exports and-let*.
+(srfi srfi-4) implements homogeneous numeric vector datatypes.
+
(srfi srfi-6) is a dummy module for now, since guile already provides
all of the srfi-6 procedures by default: open-input-string,
open-output-string, get-output-string.
doc-snarf
generate-autoload
punify
+ read-scheme-source
use2dot
See README there for more info.
(oop goops composite-slot)
The Guile Object Oriented Programming System (GOOPS) has been
-integrated into Guile.
-
-Type
-
- (use-modules (oop goops))
-
-access GOOPS bindings.
-
-We're now ready to try some basic GOOPS functionality.
-
-Generic functions
-
- (define-method (+ (x <string>) (y <string>))
- (string-append x y))
-
- (+ 1 2) --> 3
- (+ "abc" "de") --> "abcde"
-
-User-defined types
-
- (define-class <2D-vector> ()
- (x #:init-value 0 #:accessor x-component #:init-keyword #:x)
- (y #:init-value 0 #:accessor y-component #:init-keyword #:y))
-
- (define-method write ((obj <2D-vector>) port)
- (display (format #f "<~S, ~S>" (x-component obj) (y-component obj))
- port))
-
- (define v (make <2D-vector> #:x 3 #:y 4))
- v --> <3, 4>
-
- (define-method + ((x <2D-vector>) (y <2D-vector>))
- (make <2D-vector>
- #:x (+ (x-component x) (x-component y))
- #:y (+ (y-component x) (y-component y))))
-
- (+ v v) --> <6, 8>
-
-Asking for the type of an object
-
- (class-of v) --> #<<class> <2D-vector> 40241ac0>
- <2D-vector> --> #<<class> <2D-vector> 40241ac0>
- (class-of 1) --> #<<class> <integer> 401b2a98>
- <integer> --> #<<class> <integer> 401b2a98>
-
- (is-a? v <2D-vector>) --> #t
-
-See further in the GOOPS manual and tutorial in the `doc' directory,
-in info (goops.info) and texinfo formats.
+integrated into Guile. For further information, consult the GOOPS
+manual and tutorial in the `doc' directory.
** New module (ice-9 rdelim).
** New module (ice-9 rw)
This is a subset of the (scsh rw) module from guile-scsh. Currently
-it defines a single procedure:
-
-** New function: read-string!/partial str [port_or_fdes [start [end]]]
-
- Read characters from an fport or file descriptor into a string
- STR. This procedure is scsh-compatible and can efficiently read
- large strings. It will:
+it defines two procedures:
- * attempt to fill the entire string, unless the START and/or
- END arguments are supplied. i.e., START defaults to 0 and
- END defaults to `(string-length str)'
+*** New function: read-string!/partial str [port_or_fdes [start [end]]]
- * use the current input port if PORT_OR_FDES is not supplied.
+ Read characters from a port or file descriptor into a string STR.
+ A port must have an underlying file descriptor -- a so-called
+ fport. This procedure is scsh-compatible and can efficiently read
+ large strings.
- * read any characters that are currently available, without
- waiting for the rest (short reads are possible).
+*** New function: write-string/partial str [port_or_fdes [start [end]]]
- * wait for as long as it needs to for the first character to
- become available, unless the port is in non-blocking mode
-
- * return `#f' if end-of-file is encountered before reading any
- characters, otherwise return the number of characters read.
-
- * return 0 if the port is in non-blocking mode and no characters
- are immediately available.
-
- * return 0 if the request is for 0 bytes, with no end-of-file
- check
+ Write characters from a string STR to a port or file descriptor.
+ A port must have an underlying file descriptor -- a so-called
+ fport. This procedure is mostly compatible and can efficiently
+ write large strings.
** New module (ice-9 match)
-This module includes Andrew K. Wright's pattern matcher:
-
-(use-modules (ice-9 match))
+This module includes Andrew K. Wright's pattern matcher. See
+ice-9/match.scm for brief description or
-(match '(+ 1 2)
- (('+ x) x)
- (('+ x y) `(add ,x ,y))
- (('- x y) `(sub ,x ,y))) => (add 1 2)
+ http://www.star-lab.com/wright/code.html
-See ice-9/match.scm for brief description or
-http://www.star-lab.com/wright/code.html for complete documentation.
-
-This module requires SLIB to be installed and available from Guile.
+for complete documentation.
** New module (ice-9 buffered-input)
See the README file in the `doc' directory for more details.
+** There are a couple of examples in the examples/ directory now.
+
* Changes to the stand-alone interpreter
-** Evaluation of "()", the empty list, is now an error.
+** New command line option `--use-srfi'
+
+Using this option, SRFI modules can be loaded on startup and be
+available right from the beginning. This makes programming portable
+Scheme programs easier.
+
+The option `--use-srfi' expects a comma-separated list of numbers,
+each representing a SRFI number to be loaded into the interpreter
+before starting evaluating a script file or the REPL. Additionally,
+the feature identifier for the loaded SRFIs is recognized by
+`cond-expand' when using this option.
+
+Example:
+$ guile --use-srfi=8,13
+guile> (receive (x z) (values 1 2) (+ 1 2))
+3
+guile> (string-pad "bla" 20)
+" bla"
+
+** Guile now always starts up in the `(guile-user)' module.
+
+Previously, scripts executed via the `-s' option would run in the
+`(guile)' module and the repl would run in the `(guile-user)' module.
+Now every user action takes place in the `(guile-user)' module by
+default.
-Previously, you could for example write (cons 1 ()); now you need to
-be more explicit and write (cons 1 '()).
+* Changes to Scheme functions and syntax
+
+** Character classifiers work for non-ASCII characters.
+
+The predicates `char-alphabetic?', `char-numeric?',
+`char-whitespace?', `char-lower?', `char-upper?' and `char-is-both?'
+no longer check whether their arguments are ASCII characters.
+Previously, a character would only be considered alphabetic when it
+was also ASCII, for example.
+
+** Previously deprecated Scheme functions have been removed:
+
+ tag - no replacement.
+ fseek - replaced by seek.
+ list* - replaced by cons*.
** It's now possible to create modules with controlled environments
(eval '(+ 1 2) m) --> 3
(eval 'load m) --> ERROR: Unbound variable: load
-* Changes to Scheme functions and syntax
-
-** The empty combination is no longer valid syntax.
+** Evaluation of "()", the empty list, is now an error.
Previously, the expression "()" evaluated to the empty list. This has
been changed to signal a "missing expression" error. The correct way
to write the empty list as a literal constant is to use quote: "'()".
+** New concept of `Guile Extensions'.
+
+A Guile Extension is just a ordinary shared library that can be linked
+at run-time. We found it advantageous to give this simple concept a
+dedicated name to distinguish the issues related to shared libraries
+from the issues related to the module system.
+
+*** New function: load-extension
+
+Executing (load-extension lib init) is mostly equivalent to
+
+ (dynamic-call init (dynamic-link lib))
+
+except when scm_register_extension has been called previously.
+Whenever appropriate, you should use `load-extension' instead of
+dynamic-link and dynamic-call.
+
+*** New C function: scm_c_register_extension
+
+This function registers a initialization function for use by
+`load-extension'. Use it when you don't want specific extensions to
+be loaded as shared libraries (for example on platforms that don't
+support dynamic linking).
+
** Auto-loading of compiled-code modules is deprecated.
Guile used to be able to automatically find and link a shared
"foo/libbar.so" (or with a different extension) in a directory on the
load path of Guile.
-This has been found to be too tricky, and is no longer supported.
-What you should do instead now is to write a small Scheme file that
-explicitly calls `dynamic-link' to load the shared library and
-`dynamic-call' to initialize it.
+This has been found to be too tricky, and is no longer supported. The
+shared libraries are now called "extensions". You should now write a
+small Scheme file that calls `load-extension' to load the shared
+library and initialize it explicitely.
The shared libraries themselves should be installed in the usual
places for shared libraries, with names like "libguile-foo-bar".
(define-module (foo bar))
- (dynamic-call "foobar_init" (dynamic-link "libguile-foo-bar"))
+ (load-extension "libguile-foo-bar" "foobar_init")
+
+** Backward incompatible change: eval EXP ENVIRONMENT-SPECIFIER
+
+`eval' is now R5RS, that is it takes two arguments.
+The second argument is an environment specifier, i.e. either
+
+ (scheme-report-environment 5)
+ (null-environment 5)
+ (interaction-environment)
+
+or
-The file name passed to `dynamic-link' should not contain an
-extension. It will be provided automatically.
+ any module.
** The module system has been made more disciplined.
-The function `eval' will now save and restore the current module
-around the evaluation of the specified expression. While this
-expression is evaluated, `(current-module)' will now return the right
-module, which is the module specified as the second argument to
-`eval'.
+The function `eval' will save and restore the current module around
+the evaluation of the specified expression. While this expression is
+evaluated, `(current-module)' will now return the right module, which
+is the module specified as the second argument to `eval'.
-A consequence of this change is that `eval' is not particularily
+A consequence of this change is that `eval' is not particularly
useful when you want allow the evaluated code to change what module is
designated as the current module and have this change persist from one
call to `eval' to the next. The read-eval-print-loop is an example
etc. did not respect changes to the current module although these
subforms are at the top-level as well.
-To prevent strange behaviour, the forms `define-module',
+To prevent strange behavior, the forms `define-module',
`use-modules', `use-syntax', and `export' have been restricted to only
work on the top level. The forms `define-public' and
`defmacro-public' only export the new binding on the top level. They
behave just like `define' and `defmacro', respectively, when they are
used in a lexical environment.
+Also, `export' will no longer silently re-export bindings imported
+from a used module. It will emit a `deprecation' warning and will
+cease to perform any re-export in the next version. If you actually
+want to re-export bindings, use the new `re-export' in place of
+`export'. The new `re-export' will not make copies of variables when
+rexporting them, as `export' did wrongly.
+
+** Module system now allows selection and renaming of imported bindings
+
+Previously, when using `use-modules' or the `#:use-module' clause in
+the `define-module' form, all the bindings (association of symbols to
+values) for imported modules were added to the "current module" on an
+as-is basis. This has been changed to allow finer control through two
+new facilities: selection and renaming.
+
+You can now select which of the imported module's bindings are to be
+visible in the current module by using the `:select' clause. This
+clause also can be used to rename individual bindings. For example:
+
+ ;; import all bindings no questions asked
+ (use-modules (ice-9 common-list))
+
+ ;; import four bindings, renaming two of them;
+ ;; the current module sees: every some zonk-y zonk-n
+ (use-modules ((ice-9 common-list)
+ :select (every some
+ (remove-if . zonk-y)
+ (remove-if-not . zonk-n))))
+
+You can also programmatically rename all selected bindings using the
+`:renamer' clause, which specifies a proc that takes a symbol and
+returns another symbol. Because it is common practice to use a prefix,
+we now provide the convenience procedure `symbol-prefix-proc'. For
+example:
+
+ ;; import four bindings, renaming two of them specifically,
+ ;; and all four w/ prefix "CL:";
+ ;; the current module sees: CL:every CL:some CL:zonk-y CL:zonk-n
+ (use-modules ((ice-9 common-list)
+ :select (every some
+ (remove-if . zonk-y)
+ (remove-if-not . zonk-n))
+ :renamer (symbol-prefix-proc 'CL:)))
+
+ ;; import four bindings, renaming two of them specifically,
+ ;; and all four by upcasing.
+ ;; the current module sees: EVERY SOME ZONK-Y ZONK-N
+ (define (upcase-symbol sym)
+ (string->symbol (string-upcase (symbol->string sym))))
+
+ (use-modules ((ice-9 common-list)
+ :select (every some
+ (remove-if . zonk-y)
+ (remove-if-not . zonk-n))
+ :renamer upcase-symbol))
+
+Note that programmatic renaming is done *after* individual renaming.
+Also, the above examples show `use-modules', but the same facilities are
+available for the `#:use-module' clause of `define-module'.
+
+See manual for more info.
+
** The semantics of guardians have changed.
The changes are for the most part compatible. An important criterion
Note that all this hair is hardly very important, since guardian
objects are usually permanent.
-** Escape procedures created by call-with-current-continuation now
-accept any number of arguments, as required by R5RS.
+** Continuations created by call-with-current-continuation now accept
+any number of arguments, as required by R5RS.
** New function `issue-deprecation-warning'
-This function is used to displaying the deprecation messages that are
+This function is used to display the deprecation messages that are
controlled by GUILE_WARN_DEPRECATION as explained in the README.
(define (id x)
The old reader syntax `#&' is still supported, but deprecated. It
will be removed in the next release.
-** Backward incompatible change: eval EXP ENVIRONMENT-SPECIFIER
-
-`eval' is now R5RS, that is it takes two arguments.
-The second argument is an environment specifier, i.e. either
-
- (scheme-report-environment 5)
- (null-environment 5)
- (interaction-environment)
-
-or
-
- any module.
-
** New define-module option: pure
Tells the module system not to include any bindings from the root
Example:
-(define-module (foo)
- :pure
- :use-module (ice-9 r5rs)
- :export (bar))
-
-;;; Note that we're pure R5RS below this point!
-
-(define (bar)
- ...)
-
-** Deprecated: scm_make_shared_substring
-
-Explicit shared substrings will disappear from Guile.
-
-Instead, "normal" strings will be implemented using sharing
-internally, combined with a copy-on-write strategy.
-
-** Deprecated: scm_read_only_string_p
+ (define-module (foo)
+ :pure
+ :use-module (ice-9 r5rs)
+ :export (bar))
-The concept of read-only strings will disappear in next release of
-Guile.
-
-** Deprecated: scm_sloppy_memq, scm_sloppy_memv, scm_sloppy_member
+ ;;; Note that we're pure R5RS below this point!
-Instead, use scm_c_memq or scm_memq, scm_memv, scm_member.
+ (define (bar)
+ ...)
** New function: object->string OBJ
** New function: port-for-each proc
- Apply PROC to each port in the Guile port table in turn. The
- return value is unspecified. More specifically, PROC is applied
- exactly once to every port that exists in the system at the time
- PORT-FOR-EACH is invoked. Changes to the port table while
- PORT-FOR-EACH is running have no effect as far as PORT-FOR-EACH is
- concerned.
+Apply PROC to each port in the Guile port table in turn. The return
+value is unspecified. More specifically, PROC is applied exactly once
+to every port that exists in the system at the time PORT-FOR-EACH is
+invoked. Changes to the port table while PORT-FOR-EACH is running
+have no effect as far as PORT-FOR-EACH is concerned.
** New function: dup2 oldfd newfd
** New function: inet-pton family address
- Convert a printable string network address into an integer. Note
- that unlike the C version of this function, the result is an
- integer with normal host byte ordering. FAMILY can be `AF_INET'
- or `AF_INET6'. e.g.,
- (inet-pton AF_INET "127.0.0.1") => 2130706433
- (inet-pton AF_INET6 "::1") => 1
+Convert a printable string network address into an integer. Note that
+unlike the C version of this function, the result is an integer with
+normal host byte ordering. FAMILY can be `AF_INET' or `AF_INET6'.
+e.g.,
+
+ (inet-pton AF_INET "127.0.0.1") => 2130706433
+ (inet-pton AF_INET6 "::1") => 1
** New function: inet-ntop family address
- Convert an integer network address into a printable string. Note
- that unlike the C version of this function, the input is an
- integer with normal host byte ordering. FAMILY can be `AF_INET'
- or `AF_INET6'. e.g.,
- (inet-ntop AF_INET 2130706433) => "127.0.0.1"
- (inet-ntop AF_INET6 (- (expt 2 128) 1)) =>
+Convert an integer network address into a printable string. Note that
+unlike the C version of this function, the input is an integer with
+normal host byte ordering. FAMILY can be `AF_INET' or `AF_INET6'.
+e.g.,
+
+ (inet-ntop AF_INET 2130706433) => "127.0.0.1"
+ (inet-ntop AF_INET6 (- (expt 2 128) 1)) =>
ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff
** Deprecated: id
** Deprecated: return-it
-Use `noop' instead.
+Do without it.
** Deprecated: string-character-length
(use-modules (oop goops old-define-method) (oop goops))
-* Changes to the gh_ interface
+** Deprecated function: builtin-variable
+ Removed function: builtin-bindings
-* Changes to the scm_ interface
+There is no longer a distinction between builtin or other variables.
+Use module system operations for all variables.
+
+** Lazy-catch handlers are no longer allowed to return.
+
+That is, a call to `throw', `error', etc is now guaranteed to not
+return.
+
+** Bugfixes for (ice-9 getopt-long)
+
+This module is now tested using test-suite/tests/getopt-long.test.
+The following bugs have been fixed:
+
+*** Parsing for options that are specified to have `optional' args now checks
+if the next element is an option instead of unconditionally taking it as the
+option arg.
+
+*** An error is now thrown for `--opt=val' when the option description
+does not specify `(value #t)' or `(value optional)'. This condition used to
+be accepted w/o error, contrary to the documentation.
+
+*** The error message for unrecognized options is now more informative.
+It used to be "not a record", an artifact of the implementation.
+
+*** The error message for `--opt' terminating the arg list (no value), when
+`(value #t)' is specified, is now more informative. It used to be "not enough
+args".
+
+*** "Clumped" single-char args now preserve trailing string, use it as arg.
+The expansion used to be like so:
+
+ ("-abc5d" "--xyz") => ("-a" "-b" "-c" "--xyz")
+
+Note that the "5d" is dropped. Now it is like so:
+
+ ("-abc5d" "--xyz") => ("-a" "-b" "-c" "5d" "--xyz")
+
+This enables single-char options to have adjoining arguments as long as their
+constituent characters are not potential single-char options.
+
+** (ice-9 session) procedure `arity' now works with (ice-9 optargs) `lambda*'
+
+The `lambda*' and derivative forms in (ice-9 optargs) now set a procedure
+property `arglist', which can be retrieved by `arity'. The result is that
+`arity' can give more detailed information than before:
+
+Before:
+
+ guile> (use-modules (ice-9 optargs))
+ guile> (define* (foo #:optional a b c) a)
+ guile> (arity foo)
+ 0 or more arguments in `lambda*:G0'.
+
+After:
+
+ guile> (arity foo)
+ 3 optional arguments: `a', `b' and `c'.
+ guile> (define* (bar a b #:key c d #:allow-other-keys) a)
+ guile> (arity bar)
+ 2 required arguments: `a' and `b', 2 keyword arguments: `c'
+ and `d', other keywords allowed.
+ guile> (define* (baz a b #:optional c #:rest r) a)
+ guile> (arity baz)
+ 2 required arguments: `a' and `b', 1 optional argument: `c',
+ the rest in `r'.
+
+* Changes to the C interface
+
+** Types have been renamed from scm_*_t to scm_t_*.
+
+This has been done for POSIX sake. It reserves identifiers ending
+with "_t". What a concept.
+
+The old names are still available with status `deprecated'.
+
+** scm_t_bits (former scm_bits_t) is now a unsigned type.
+
+** Deprecated features have been removed.
+
+*** Macros removed
+
+ SCM_INPORTP, SCM_OUTPORTP SCM_ICHRP, SCM_ICHR, SCM_MAKICHR
+ SCM_SETJMPBUF SCM_NSTRINGP SCM_NRWSTRINGP SCM_NVECTORP SCM_DOUBLE_CELLP
+
+*** C Functions removed
+
+ scm_sysmissing scm_tag scm_tc16_flo scm_tc_flo
+ scm_fseek - replaced by scm_seek.
+ gc-thunk - replaced by after-gc-hook.
+ gh_int2scmb - replaced by gh_bool2scm.
+ scm_tc_dblr - replaced by scm_tc16_real.
+ scm_tc_dblc - replaced by scm_tc16_complex.
+ scm_list_star - replaced by scm_cons_star.
+
+** Deprecated: scm_makfromstr
+
+Use scm_mem2string instead.
+
+** Deprecated: scm_make_shared_substring
+
+Explicit shared substrings will disappear from Guile.
+
+Instead, "normal" strings will be implemented using sharing
+internally, combined with a copy-on-write strategy.
+
+** Deprecated: scm_read_only_string_p
+
+The concept of read-only strings will disappear in next release of
+Guile.
+
+** Deprecated: scm_sloppy_memq, scm_sloppy_memv, scm_sloppy_member
+
+Instead, use scm_c_memq or scm_memq, scm_memv, scm_member.
+
+** New functions: scm_call_0, scm_call_1, scm_call_2, scm_call_3
+
+Call a procedure with the indicated number of arguments.
+
+Example:
+
+ scm_call_1 (proc, arg1);
+
+** New functions: scm_apply_0, scm_apply_1, scm_apply_2, scm_apply_3
+
+Call a procedure with the indicated number of arguments and a list
+of arguments.
+
+Example:
+
+ scm_apply_1 (proc, arg1, args);
+
+** New functions: scm_list_1, scm_list_2, scm_list_3, scm_list_4, scm_list_5
+
+Create a list of the given number of elements.
+
+** Renamed function: scm_listify has been replaced by scm_list_n.
+
+** Deprecated macros: SCM_LIST0, SCM_LIST1, SCM_LIST2, SCM_LIST3, SCM_LIST4,
+SCM_LIST5, SCM_LIST6, SCM_LIST7, SCM_LIST8, SCM_LIST9.
+
+Use functions scm_list_N instead.
** New function: scm_c_read (SCM port, void *buffer, scm_sizet size)
scm_gensym now only takes one argument.
-** New function: scm_gentemp (SCM prefix, SCM obarray)
-
-The builtin `gentemp' has now become a primitive.
-
** Deprecated type tags: scm_tc7_ssymbol, scm_tc7_msymbol, scm_tcs_symbols,
scm_tc7_lvector
Use scm_wrong_type_arg, or another appropriate error signalling function
instead.
+** Explicit support for obarrays has been deprecated.
+
+Use `scm_str2symbol' and the generic hashtable functions instead.
+
+** The concept of `vcells' has been deprecated.
+
+The data type `variable' is now used exclusively. `Vcells' have been
+a low-level concept so you are likely not affected by this change.
+
+*** Deprecated functions: scm_sym2vcell, scm_sysintern,
+ scm_sysintern0, scm_symbol_value0, scm_intern, scm_intern0.
+
+Use scm_c_define or scm_c_lookup instead, as appropriate.
+
+*** New functions: scm_c_module_lookup, scm_c_lookup,
+ scm_c_module_define, scm_c_define, scm_module_lookup, scm_lookup,
+ scm_module_define, scm_define.
+
+These functions work with variables instead of with vcells.
+
+** New functions for creating and defining `subr's and `gsubr's.
+
+The new functions more clearly distinguish between creating a subr (or
+gsubr) object and adding it to the current module.
+
+These new functions are available: scm_c_make_subr, scm_c_define_subr,
+scm_c_make_subr_with_generic, scm_c_define_subr_with_generic,
+scm_c_make_gsubr, scm_c_define_gsubr, scm_c_make_gsubr_with_generic,
+scm_c_define_gsubr_with_generic.
+
+** Deprecated functions: scm_make_subr, scm_make_subr_opt,
+ scm_make_subr_with_generic, scm_make_gsubr,
+ scm_make_gsubr_with_generic.
+
+Use the new ones from above instead.
+
+** C interface to the module system has changed.
+
+While we suggest that you avoid as many explicit module system
+operations from C as possible for the time being, the C interface has
+been made more similar to the high-level Scheme module system.
+
+*** New functions: scm_c_define_module, scm_c_use_module,
+ scm_c_export, scm_c_resolve_module.
+
+They mostly work like their Scheme namesakes. scm_c_define_module
+takes a function that is called a context where the new module is
+current.
+
+*** Deprecated functions: scm_the_root_module, scm_make_module,
+ scm_ensure_user_module, scm_load_scheme_module.
+
+Use the new functions instead.
+
+** Renamed function: scm_internal_with_fluids becomes
+ scm_c_with_fluids.
+
+scm_internal_with_fluids is available as a deprecated function.
+
+** New function: scm_c_with_fluid.
+
+Just like scm_c_with_fluids, but takes one fluid and one value instead
+of lists of same.
+
+** Deprecated typedefs: long_long, ulong_long.
+
+They are of questionable utility and they pollute the global
+namespace.
+
+** Deprecated typedef: scm_sizet
+
+It is of questionable utility now that Guile requires ANSI C, and is
+oddly named.
+
+** Deprecated typedefs: scm_port_rw_active, scm_port,
+ scm_ptob_descriptor, scm_debug_info, scm_debug_frame, scm_fport,
+ scm_option, scm_rstate, scm_rng, scm_array, scm_array_dim.
+
+Made more compliant with the naming policy by adding a _t at the end.
+
+** Deprecated functions: scm_mkbig, scm_big2num, scm_adjbig,
+ scm_normbig, scm_copybig, scm_2ulong2big, scm_dbl2big, scm_big2dbl
+
+With the exception of the mysterious scm_2ulong2big, they are still
+available under new names (scm_i_mkbig etc). These functions are not
+intended to be used in user code. You should avoid dealing with
+bignums directly, and should deal with numbers in general (which can
+be bignums).
+
+** Change in behavior: scm_num2long, scm_num2ulong
+
+The scm_num2[u]long functions don't any longer accept an inexact
+argument. This change in behavior is motivated by concordance with
+R5RS: It is more common that a primitive doesn't want to accept an
+inexact for an exact.
+
+** New functions: scm_short2num, scm_ushort2num, scm_int2num,
+ scm_uint2num, scm_size2num, scm_ptrdiff2num, scm_num2short,
+ scm_num2ushort, scm_num2int, scm_num2uint, scm_num2ptrdiff,
+ scm_num2size.
+
+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]
+
+See above.
+
+** New functions: scm_gc_protect_object, scm_gc_unprotect_object
+
+These are just nicer-named old scm_protect_object and
+scm_unprotect_object.
+
+** Deprecated functions: scm_protect_object, scm_unprotect_object
+
+** New functions: scm_gc_[un]register_root, scm_gc_[un]register_roots
+
+These functions can be used to register pointers to locations that
+hold SCM values.
+
+** Deprecated function: scm_create_hook.
+
+Its sins are: misleading name, non-modularity and lack of general
+usefulness.
+
\f
Changes since Guile 1.3.4:
Usage: (help NAME) gives documentation about objects named NAME (a symbol)
(help REGEXP) ditto for objects with names matching REGEXP (a string)
+ (help 'NAME) gives documentation for NAME, even if it is not an object
(help ,EXPR) gives documentation for object returned by EXPR
(help (my module)) gives module commentary for `(my module)'
(help) gives this text
mode: outline
paragraph-separate: "[ \f]*$"
end:
-
HCoop / bpt / guile.git / blobdiff