* Changes to the distribution
+** Nightly snapshots are now available from ftp.red-bean.com.
+The old server, ftp.cyclic.com, has been relinquished to its rightful
+owner.
+
+Nightly snapshots of the Guile development sources are now available via
+anonymous FTP from ftp.red-bean.com, as /pub/guile/guile-snap.tar.gz.
+
+Via the web, that's: ftp://ftp.red-bean.com/pub/guile/guile-snap.tar.gz
+For getit, that's: ftp.red-bean.com:/pub/guile/guile-snap.tar.gz
+
+** To run Guile without installing it, the procedure has changed a bit.
+
+If you used a separate build directory to compile Guile, you'll need
+to include the build directory in SCHEME_LOAD_PATH, as well as the
+source directory. See the `INSTALL' file for examples.
+
* Changes to the procedure for linking libguile with your programs
+** Like Guile 1.0, Guile 1.2 will now use the Rx regular expression
+library, if it is installed on your system. When you are linking
+libguile into your own programs, this means you will have to link
+against -lguile, -lqt (if you configured Guile with thread support),
+and -lrx.
+
+If you are using autoconf to generate configuration scripts for your
+application, the following lines should suffice to add the appropriate
+libraries to your link command:
+
+### Find Rx, quickthreads and libguile.
+AC_CHECK_LIB(rx, main)
+AC_CHECK_LIB(qt, main)
+AC_CHECK_LIB(guile, scm_shell)
+
* Changes to Scheme functions and syntax
+** The dynamic linking features of Guile are now enabled by default.
+You can disable them by giving the `--disable-dynamic-linking' option
+to configure.
+
+ (dynamic-link FILENAME)
+
+ Find the object file denoted by FILENAME (a string) and link it
+ into the running Guile application. When everything works out,
+ return a Scheme object suitable for representing the linked object
+ file. Otherwise an error is thrown. How object files are
+ searched is system dependent.
+
+ (dynamic-object? VAL)
+
+ Determine whether VAL represents a dynamically linked object file.
+
+ (dynamic-unlink DYNOBJ)
+
+ Unlink the indicated object file from the application. DYNOBJ
+ should be one of the values returned by `dynamic-link'.
+
+ (dynamic-func FUNCTION DYNOBJ)
+
+ Search the C function indicated by FUNCTION (a string or symbol)
+ in DYNOBJ and return some Scheme object that can later be used
+ with `dynamic-call' to actually call this function. Right now,
+ these Scheme objects are formed by casting the address of the
+ function to `long' and converting this number to its Scheme
+ representation.
+
+ (dynamic-call FUNCTION DYNOBJ)
+
+ Call the C function indicated by FUNCTION and DYNOBJ. The
+ function is passed no arguments and its return value is ignored.
+ When FUNCTION is something returned by `dynamic-func', call that
+ function and ignore DYNOBJ. When FUNCTION is a string (or symbol,
+ etc.), look it up in DYNOBJ; this is equivalent to
+
+ (dynamic-call (dynamic-func FUNCTION DYNOBJ) #f)
+
+ Interrupts are deferred while the C function is executing (with
+ SCM_DEFER_INTS/SCM_ALLOW_INTS).
+
+ (dynamic-args-call FUNCTION DYNOBJ ARGS)
+
+ Call the C function indicated by FUNCTION and DYNOBJ, but pass it
+ some arguments and return its return value. The C function is
+ expected to take two arguments and return an `int', just like
+ `main':
+
+ int c_func (int argc, char **argv);
+
+ ARGS must be a list of strings and is converted into an array of
+ `char *'. The array is passed in ARGV and its size in ARGC. The
+ return value is converted to a Scheme number and returned from the
+ call to `dynamic-args-call'.
+
+When dynamic linking is disabled or not supported on your system,
+the above functions throw errors, but they are still available.
+
+Here is a small example that works on GNU/Linux:
+
+ (define libc-obj (dynamic-link "libc.so"))
+ (dynamic-args-call 'rand libc-obj '())
+
+See the file `libguile/DYNAMIC-LINKING' for additional comments.
+
+** The #/ syntax for module names is depreciated, and will be removed
+in a future version of Guile. Instead of
+
+ #/foo/bar/baz
+
+instead write
+
+ (foo bar baz)
+
+The latter syntax is more consistent with existing Lisp practice.
+
+** Guile now does fancier printing of structures. Structures are the
+underlying implementation for records, which in turn are used to
+implement modules, so all of these object now print differently and in
+a more informative way.
+
+The Scheme printer will examine the builtin variable *struct-printer*
+whenever it needs to print a structure object. When this variable is
+not `#f' it is deemed to be a procedure and will be applied to the
+structure object and the output port. When *struct-printer* is `#f'
+or the procedure return `#f' the structure object will be printed in
+the boring #<struct 80458270> form.
+
+This hook is used by some routines in ice-9/boot-9.scm to implement
+type specific printing routines. Please read the comments there about
+"printing structs".
+
+One of the more specific uses of structs are records. The printing
+procedure that could be passed to MAKE-RECORD-TYPE is now actually
+called. It should behave like a *struct-printer* procedure (described
+above).
+
** Guile now supports a new R4RS-compliant syntax for keywords. A
token of the form #:NAME, where NAME has the same syntax as a Scheme
symbol, is the external representation of the keyword named NAME.
* Changes to the scm_ interface
+** The new function scm_handle_by_message_noexit is just like the
+existing scm_handle_by_message function, except that it doesn't call
+exit to terminate the process. Instead, it prints a message and just
+returns #f. This might be a more appropriate catch-all handler for
+new dynamic roots and threads.
+
* Changes to system call interfaces:
** The value returned by `raise' is now unspecified. It throws an exception
provide solutions to the problem of consistent access to data
structures.
+** A new procedure `flush-all-ports' is equivalent to running
+`force-output' on every port open for output.
+
\f
Changes in Guile 1.1 (Fri May 16 1997):
date, or incomplete. As soon as we have current documentation, we
will distribute it.
+
+
* Changes to the stand-alone interpreter
** guile now accepts command-line arguments compatible with SCSH, Olin