X-Git-Url: http://git.hcoop.net/bpt/guile.git/blobdiff_plain/7cb11224c7f141d25f9468b8e6d51b6a22707fb3..e87f059319e40b582d5ee8fd815876550f1148b9:/NEWS diff --git a/NEWS b/NEWS index f6cb30eba..408f3f990 100644 --- a/NEWS +++ b/NEWS @@ -1,10 +1,1572 @@ Guile NEWS --- history of user-visible changes. -Copyright (C) 1996-2012 Free Software Foundation, Inc. +Copyright (C) 1996-2014 Free Software Foundation, Inc. See the end for copying conditions. Please send Guile bug reports to bug-guile@gnu.org. + +Changes in 2.1.1 (changes since the 2.0.x series): + +* Notable changes + +** Speed + +The biggest change in Guile 2.2 is a complete rewrite of its virtual +machine and compiler internals. The result is faster startup time, +better memory usage, and faster execution of user code. See the +"Performance improvements" section below for more details. + +** Better thread-safety + +This new release series takes the ABI-break opportunity to fix some +interfaces that were difficult to use correctly from multiple threads. +Notably, weak hash tables are now transparently thread-safe. Ports are +also thread-safe; see "New interfaces" below for details on the changes +to the C interface. + +** Better space-safety + +It used to be the case that, when calling a Scheme procedure, the +procedure and arguments were always preserved against garbage +collection. This is no longer the case; Guile is free to collect the +procedure and arguments if they become unreachable, or to re-use their +slots for other local variables. Guile still offers good-quality +backtraces by determining the procedure being called from the +instruction pointer instead of from the value in slot 0 of an +application frame, and by using a live variable map that allows the +debugger to know which locals are live at all points in a frame. + +** Off-main-thread finalization + +Following Guile 2.0.6's change to invoke finalizers via asyncs, Guile +2.2 takes the additional step of invoking finalizers from a dedicated +finalizer thread, if threads are enabled. This avoids concurrency +issues between finalizers and application code, and also speeds up +finalization. If your application's finalizers are not robust to the +presence of threads, see "Foreign Objects" in the manual for information +on how to disable automatic finalization and instead run finalizers +manually. + +** Better locale support in Guile scripts + +When Guile is invoked directly, either from the command line or via a +hash-bang line (e.g. "#!/usr/bin/guile"), it now installs the current +locale via a call to `(setlocale LC_ALL "")'. For users with a unicode +locale, this makes all ports unicode-capable by default, without the +need to call `setlocale' in your program. This behavior may be +controlled via the GUILE_INSTALL_LOCALE environment variable; see the +manual for more. + +** Complete Emacs-compatible Elisp implementation + +Thanks to the work of BT Templeton, Guile's Elisp implementation is now +fully Emacs-compatible, implementing all of Elisp's features and quirks +in the same way as the editor we know and love. + +** Dynamically expandable stacks + +Instead of allocating fixed stack sizes for running Scheme code, Guile +now starts off each thread with only one page of stack, and expands and +shrinks it dynamically as needed. Guile will throw an exception for +stack overflows if growing the stack fails. It is also possible to +impose a stack limit during the extent of a function call. See "Stack +Overflow" in the manual, for more. + +This change allows users to write programs that use the stack as a data +structure for pending computations, as it was meant to be, without +reifying that data out to the heap. Where you would previously make a +loop that collect its results in reverse order only to re-reverse them +at the end, now you can just recurse without worrying about stack +overflows. + +** Out-of-memory improvements + +Instead of aborting, failures to allocate memory will now raise an +unwind-only `out-of-memory' exception, and cause the corresponding +`catch' expression to run garbage collection in order to free up memory. + +* Performance improvements + +** Faster programs via new virtual machine + +Guile's new virtual machine compiles programs to instructions for a new +virtual machine. The new virtual machine's instructions can address +their source and destination operands by "name" (slot). This makes +access to named temporary values much faster, and removes a lot of +value-shuffling that the old virtual machine had to do. The end result +is that loop-heavy code can be two or three times as fast with Guile 2.2 +as in 2.0. Your mileage may vary, of course; see "A Virtual Machine for +Guile" in the manual for the nitties and the gritties. + +** Better startup time, memory usage with ELF object file format + +Guile now uses the standard ELF format for its compiled code. (Guile +has its own loader and linker, so this does not imply a dependency on +any particular platform's ELF toolchain.) The benefit is that Guile is +now able to statically allocate more data in the object files. ELF also +enables more sharing of data between processes, and decreases startup +time (about 40% faster than the already fast startup of the Guile 2.0 +series). Guile also uses DWARF for some of its debugging information. +Much of the debugging information can be stripped from the object files +as well. See "Object File Format" in the manual, for full details. + +** Better optimizations via compiler rewrite + +Guile's compiler now uses a Continuation-Passing Style (CPS) +intermediate language, allowing it to reason easily about temporary +values and control flow. Examples of optimizations that this permits +are optimal contification, optimal common subexpression elimination, +dead code elimination, parallel moves with at most one temporary, +allocation of stack slots using precise liveness information, and +closure optimization. For more, see "Continuation-Passing Style" in the +manual. + +** Faster interpreter + +Combined with a number of optimizations to the interpreter itself, +simply compiling `eval.scm' with the new compiler yields an interpreter +that is consistently two or three times faster than the one in Guile +2.0. + +** Allocation-free dynamic stack + +Guile now implements the dynamic stack with an actual stack instead of a +list of heap objects, avoiding most allocation. This speeds up prompts, +the `scm_dynwind_*' family of functions, fluids, and `dynamic-wind'. + +** Optimized UTF-8 and Latin-1 ports, symbols, and strings + +Guile 2.2 is faster at reading and writing UTF-8 and Latin-1 strings +from ports, and at converting symbols and strings to and from these +encodings. + +** Optimized hash functions + +Guile 2.2 now uses Bob Jenkins' `hashword2' (from his `lookup3.c') for +its string hash, and Thomas Wang's integer hash function for `hashq' and +`hashv'. These functions produce much better hash values across all +available fixnum bits. + +** Optimized generic array facility + +Thanks to work by Daniel Llorens, the generic array facility is much +faster now, as it is internally better able to dispatch on the type of +the underlying backing store. + +* New interfaces + +** New `cond-expand' feature: `guile-2.2' + +Use this feature if you need to check for Guile 2.2 from Scheme code. + +** New predicate: `nil?' + +See "Nil" in the manual. + +** New compiler modules + +Since the compiler was rewritten, there are new modules for the back-end +of the compiler and the low-level loader and introspection interfaces. +See the "Guile Implementation" chapter in the manual for all details. + +** New functions: `scm_to_intptr_t', `scm_from_intptr_t' +** New functions: `scm_to_uintptr_t', `scm_from_uintptr_t' + +See "Integers" in the manual, for more. + +** New thread-safe port API + +For details on `scm_c_make_port', `scm_c_make_port_with_encoding', +`scm_c_lock_port', `scm_c_try_lock_port', `scm_c_unlock_port', +`scm_c_port_type_ref', `scm_c_port_type_add_x', `SCM_PORT_DESCRIPTOR', +and `scm_dynwind_lock_port', see XXX. + +There is now a routine to atomically adjust port "revealed counts". See +XXX for more on `scm_adjust_port_revealed_x' and +`adjust-port-revealed!', + +All other port API now takes the lock on the port if needed. There are +some C interfaces if you know that you don't need to take a lock; see +XXX for details on `scm_get_byte_or_eof_unlocked', +`scm_peek_byte_or_eof_unlocked' `scm_c_read_unlocked', +`scm_getc_unlocked' `scm_unget_byte_unlocked', `scm_ungetc_unlocked', +`scm_ungets_unlocked', `scm_fill_input_unlocked' `scm_putc_unlocked', +`scm_puts_unlocked', and `scm_lfwrite_unlocked'. + +** New inline functions: `scm_new_smob', `scm_new_double_smob' + +These can replace many uses of SCM_NEWSMOB, SCM_RETURN_NEWSMOB2, and the +like. See XXX in the manual, for more. + +** New low-level type accessors + +For more on `SCM_HAS_TYP7', `SCM_HAS_TYP7S', `SCM_HAS_TYP16', see XXX. + +`SCM_HEAP_OBJECT_P' is now an alias for the inscrutable `SCM_NIMP'. + +`SCM_UNPACK_POINTER' and `SCM_PACK_POINTER' are better-named versions of +the old `SCM2PTR' and `PTR2SCM'. Also, `SCM_UNPACK_POINTER' yields a +void*. + +** , standard-vtable-fields + +See "Structures" in the manual for more on these + +** Convenience utilities for ports and strings. + +See XXX for more on `scm_from_port_string', `scm_from_port_stringn', +`scm_to_port_string', and `scm_to_port_stringn'. + +** New expressive PEG parser + +See "PEG Parsing" in the manual for more. Thanks to Michael Lucy for +originally writing these, and to Noah Lavine for integration work. + +* Incompatible changes + +** ASCII is not ISO-8859-1 + +In Guile 2.0, if a user set "ASCII" or "ANSI_X3.4-1968" as the encoding +of a port, Guile would treat it as ISO-8859-1. While these encodings +are the same for codepoints 0 to 127, ASCII does not extend past that +range, whereas ISO-8859-1 goes up to 255. Guile 2.2 no longer treats +ASCII as ISO-8859-1. This is likely to be a problem only if the user's +locale is set to ASCII, and the user or a program writes non-ASCII +codepoints to a port. + +** String ports default to UTF-8 + +Guile 2.0 would use the `%default-port-encoding' when creating string +ports. This resulted in ports that could only accept a subset of valid +characters, which was surprising to users. Now string ports default to +the UTF-8 encoding. Sneaky users can still play encoding conversion +games with string ports by explicitly setting the encoding of a port +after it is open. See "Ports" in the manual for more. + +** `scm_from_stringn' and `scm_to_stringn' encoding arguments are never NULL + +These functions now require a valid `encoding' argument, and will abort +if given `NULL'. + +** All r6rs ports are both textual and binary + +Because R6RS ports are a thin layer on top of Guile's ports, and Guile's +ports are both textual and binary, Guile's R6RS ports are also both +textual and binary, and thus both kinds have port transcoders. This is +an incompatibility with respect to R6RS. + +** Vtable hierarchy changes + +In an attempt to make Guile's structure and record types integrate +better with GOOPS by unifying the vtable hierarchy, `make-vtable-vtable' +is now deprecated. Instead, users should just use `make-vtable' with +appropriate arguments. See "Structures" in the manual for all of the +details. As such, `record-type-vtable' and `%condition-type-vtable' now +have a parent vtable and are no longer roots of the vtable hierarchy. + +** Syntax parameters are a distinct type + +Guile 2.0's transitional implementation of `syntax-parameterize' was +based on the `fluid-let-syntax' interface inherited from the psyntax +expander. This interface allowed any binding to be dynamically rebound +-- even bindings like `lambda'. This is no longer the case in Guile +2.2. Syntax parameters must be defined via `define-syntax-parameter', +and only such bindings may be parameterized. See "Syntax Parameters" in +the manual for more. + +** Defined identifiers scoped in the current module + +Sometimes Guile's expander would attach incorrect module scoping +information for top-level bindings made by an expansion. For example, +given the following R6RS library: + + (library (defconst) + (export defconst) + (import (guile)) + (define-syntax-rule (defconst name val) + (begin + (define t val) + (define-syntax-rule (name) t)))) + +Attempting to use it would produce an error: + + (import (defconst)) + (defconst foo 42) + (foo) + =| Unbound variable: t + +It wasn't clear that we could fix this in Guile 2.0 without breaking +someone's delicate macros, so the fix is only coming out now. + +** Pseudo-hygienically rename macro-introduced bindings + +Bindings introduced by macros, like `t' in the `defconst' example above, +are now given pseudo-fresh names. This allows + + (defconst foo 42) + (defconst bar 37) + +to introduce different bindings for `t'. These pseudo-fresh names are +made in such a way that if the macro is expanded again, for example as +part of a simple recompilation, the introduced identifiers get the same +pseudo-fresh names. See "Hygiene and the Top-Level" in the manual, for +details. + +** Fix literal matching for module-bound literals + +`syntax-rules' and `syntax-case' macros can take a set of "literals": +bound or unbound keywords that the syntax matcher treats specially. +Before, literals were always matched symbolically (by name). Now they +are matched by binding. This allows literals to be reliably bound to +values, renamed by imports or exports, et cetera. See "Syntax-rules +Macros" in the manual for more on literals. + +** `dynamic-wind' doesn't check that guards are thunks + +Checking that the dynamic-wind out-guard procedure was actually a thunk +before doing the wind was slow, unreliable, and not strictly needed. + +** All deprecated code removed + +All code deprecated in Guile 2.0 has been removed. See older NEWS, and +check that your programs can compile without linker warnings and run +without runtime warnings. See "Deprecation" in the manual. + +** Remove miscellaneous unused interfaces + +We have removed accidentally public, undocumented interfaces that we +think are not used, and not useful. This includes `scm_markstream', +`SCM_FLUSH_REGISTER_WINDOWS', `SCM_THREAD_SWITCHING_CODE', `SCM_FENCE', +`scm_call_generic_0', `scm_call_generic_1', `scm_call_generic_2' +`scm_call_generic_3', `scm_apply_generic', and `scm_program_source'. +`scm_async_click' was renamed to `scm_async_tick', and `SCM_ASYNC_TICK' +was made private (use `SCM_TICK' instead). + +** Many internal compiler / VM changes + +As the compiler and virtual machine were re-written, there are many +changes in the back-end of Guile to interfaces that were introduced in +Guile 2.0. These changes are only only of interest if you wrote a +language on Guile 2.0 or a tool using Guile 2.0 internals. If this is +the case, drop by the IRC channel to discuss the changes. + +** Defining a SMOB or port type no longer mucks exports of `(oop goops)' + +It used to be that defining a SMOB or port type added an export to +GOOPS, for the wrapper class of the smob type. This violated +modularity, though, so we have removed this behavior. + +** Bytecode replaces objcode as a target language + +One way in which people may have used details of Guile's runtime in +Guile 2.0 is in compiling code to thunks for later invocation. Instead +of compiling to objcode and then calling `make-program', now the way to +do it is to compile to `bytecode' and then call `load-thunk-from-memory' +from `(system vm loader)'. + +** Weak pairs removed + +Weak pairs were not safe to access with `car' and `cdr', and so were +removed. + +** Weak alist vectors removed + +Use weak hash tables instead. + +** Weak vectors may no longer be accessed via `vector-ref' et al + +Weak vectors may no longer be accessed with the vector interface. This +was a source of bugs in the 2.0 Guile implementation, and a limitation +on using vectors as building blocks for other abstractions. Vectors in +Guile are now a concrete type; for an abstract interface, use the +generic array facility (`array-ref' et al). + +** scm_t_array_implementation removed + +This interface was introduced in 2.0 but never documented. It was a +failed attempt to layer the array implementation that actually +introduced too many layers, as it prevented the "vref" and "vset" +members of scm_t_array_handle (called "ref" and "set" in 1.8, not +present in 2.0) from specializing on array backing stores. + +Notably, the definition of scm_t_array_handle has now changed, to not +include the (undocumented) "impl" member. We are sorry for any +inconvenience this may cause. + +* New deprecations + +** SCM_WTA_DISPATCH_0, SCM_WTA_DISPATCH_1, SCM_WTA_DISPATCH_2, SCM_WTA_DISPATCH_N +** SCM_GASSERT0, SCM_GASSERT1, SCM_GASSERT2, SCM_GASSERTn +** SCM_WTA_DISPATCH_1_SUBR + +These macros were used in dispatching primitive generics. They can be +replaced by using C functions (the same name but in lower case), if +needed, but this is a hairy part of Guile that perhaps you shouldn't be +using. + +* Changes to the distribution + +** New minor version + +The "effective version" of Guile is now 2.2, which allows parallel +installation with other effective versions (for example, the older Guile +2.0). See "Parallel Installations" in the manual for full details. +Notably, the `pkg-config' file is now `guile-2.2'. + +** Bump required libgc version to 7.2, released March 2012. + +** The readline extension is now installed in the extensionsdir + +The shared library that implements Guile's readline extension is no +longer installed to the libdir. This change should be transparent to +users, but packagers may be interested. + + + +Changes in 2.0.11 (since 2.0.10): + +This release fixes an embarrassing regression introduced in the C +interface to SRFI-4 vectors. See + +for details. + + +Changes in 2.0.10 (since 2.0.9): + +* Notable changes + +** New GDB extension to support Guile + +Guile now comes with an extension for GDB 7.8 or later (unreleased at +the time of writing) that simplifies debugging of C code that uses +Guile. See "GDB Support" in the manual. + +** Improved integration between R6RS and native Guile exceptions + +R6RS exception handlers, established using 'with-exception-handler' or +'guard', are now able to catch native Guile exceptions, which are +automatically converted into appropriate R6RS condition objects. + +** Support for HTTP proxies + +Guile's built-in web client now honors the 'http_proxy' environment +variable, as well as the new 'current-http-proxy' parameter. See +"Web Client" in the manual for details. + +** Lexical syntax improvements + +*** Support |...| symbol notation. + +Guile's core reader and printer now support the R7RS |...| notation +for writing symbols with arbitrary characters, as a more portable and +attractive alternative to Guile's native #{...}# notation. To enable +this notation by default, put one or both of the following in your +~/.guile: + + (read-enable 'r7rs-symbols) + (print-enable 'r7rs-symbols) + +*** Support '#true' and '#false' notation for booleans. + +The booleans '#t' and '#f' may now be written as '#true' and '#false' +for improved readability, per R7RS. + +*** Recognize '#\escape' character name. + +The escape character '#\esc' may now be written as '#\escape', per R7RS. + +*** Accept "\|" in string literals. + +The pipe character may now be preceded by a backslash, per R7RS. + +** Custom binary input ports now support 'setvbuf'. + +Until now, ports returned by 'make-custom-binary-input-port' were always +full-buffered. Now, their buffering mode can be changed using 'setvbuf'. + +** SRFI-4 predicates and length accessors no longer accept arrays. + +Given that the SRFI-4 accessors don't work for arrays, the fact that the +predicates and length accessors returned true for arrays was a bug. + +** GUILE_PROGS now supports specifying a minimum required version. + +The 'GUILE_PROGS' autoconf macro in guile.m4 now allows an optional +argument to specify a minimum required Guile version. By default, it +requires Guile >= 2.0. A micro version can also be specified, e.g.: +GUILE_PROGS([2.0.10]) + +** Error reporting improvements + +*** Improved run-time error reporting in (ice-9 match). + +If no pattern matches in a 'match' form, the datum that failed to match +is printed along with the location of the failed 'match' invocation. + +*** Print the faulty object upon invalid-keyword errors. +*** Improved error reporting of procedures defined by define-inlinable. +*** Improved error reporting for misplaced ellipses in macro definitions. +*** Improved error checking in 'define-public' and 'module-add!'. +*** Improved error when 'include' form with relative path is not in a file. + +** Speed improvements + +*** 'scm_c_read' on ISO-8859-1 (e.g. binary) unbuffered ports is faster. +*** New inline asm for VM fixnum multiply, for faster overflow checking. +*** New inline asm for VM fixnum operations on ARM and 32-bit x86. +*** 'positive?' and 'negative?' are now compiled to VM primitives. +*** Numerical comparisons with more than 2 arguments are compiled to VM code. +*** Several R6RS bitwise operators have been optimized. + +** Miscellaneous + +*** Web: 'content-disposition' headers are now supported. +*** Web: 'uri-encode' hexadecimal percent-encoding is now uppercase. +*** Size argument to 'make-doubly-weak-hash-table' is now optional. +*** Timeout for 'unlock-mutex' and SRFI-18 'mutex-unlock!' may now be #f. + +** Gnulib update + +Guile's copy of Gnulib was updated to v0.1-92-g546ff82. The following +modules were imported from Gnulib: copysign, fsync, isfinite, link, +lstat, mkdir, mkstemp, readlink, rename, rmdir, and unistd. + +* New interfaces + +** Cooperative REPL servers + +This new facility supports REPLs that run at specified times within an +existing thread, for example in programs utilizing an event loop or in +single-threaded programs. This allows for safe access and mutation of +a program's data structures from the REPL without concern for thread +synchronization. See "Cooperative REPL Servers" in the manual for +details. + +** SRFI-43 (Vector Library) + +Guile now includes SRFI-43, a comprehensive library of vector operations +analogous to the SRFI-1 list library. See "SRFI-43" in the manual for +details. + +** SRFI-64 (A Scheme API for test suites) + +Guile now includes SRFI-64, a flexible framework for creating test +suites. The reference implementation of SRFI-64 has also been updated +to fully support earlier versions of Guile. + +** SRFI-111 (Boxes) + +See "SRFI-111" in the manual. + +** 'define-values' + +See "Binding multiple return values" in the manual. + +** Custom ellipsis identifiers using 'with-ellipsis' or SRFI-46. + +Guile now allows macro definitions to use identifiers other than '...' +as the ellipsis. This is convenient when writing macros that generate +macro definitions. The desired ellipsis identifier can be given as the +first operand to 'syntax-rules', as specified in SRFI-46 and R7RS, or by +using the new 'with-ellipsis' special form in procedural macros. With +this addition, Guile now fully supports SRFI-46. + +See "Specifying a Custom Ellipsis Identifier" and "Custom Ellipsis +Identifiers for syntax-case Macros" in the manual for details. + +** R7RS 'syntax-error' + +Guile now supports 'syntax-error', as specified by R7RS, allowing for +improved compile-time error reporting from 'syntax-rules' macros. See +"Reporting Syntax Errors in Macros" in the manual for details. + +** New procedures to convert association lists into hash tables + +Guile now includes the convenience procedures 'alist->hash-table', +'alist->hashq-table', 'alist->hashv-table', and 'alist->hashx-table'. +See "Hash Table Reference" in the manual. + +** New predicates: 'exact-integer?' and 'scm_is_exact_integer' + +See "Integers" in the manual. + +** 'weak-vector-length', 'weak-vector-ref', and 'weak-vector-set!' + +These should now be used to access weak vectors, instead of +'vector-length', 'vector-ref', and 'vector-set!'. + +* Manual updates + +** Improve docs for 'eval-when'. + +Each 'eval-when' condition is now explained in detail, including +'expand' which was previously undocumented. (expand load eval) is now +the recommended set of conditions, instead of (compile load eval). +See "Eval When" in the manual, for details. + +** Update the section on SMOBs and memory management. + +See "Defining New Types (Smobs)" in the manual. + +** Fixes + +*** GOOPS: #:dsupers is the init keyword for the dsupers slot. +*** 'unfold-right' takes a tail, not a tail generator. +*** Clarify that 'append!' and 'reverse!' might not mutate. +*** Fix doc that incorrectly claimed (integer? +inf.0) => #t. + (http://bugs.gnu.org/16356) +*** Document that we support SRFI-62 (S-expression comments). +*** Document that we support SRFI-87 (=> in case clauses). +*** Document 'equal?' in the list of R6RS incompatibilities. +*** Remove outdated documentation of LTDL_LIBRARY_PATH. +*** Fix 'weak-vector?' doc: Weak hash tables are not weak vectors. +*** Fix 'my-or' examples to use let-bound variable. + (http://bugs.gnu.org/14203) + +* New deprecations + +** General 'uniform-vector' interface + +This interface lacked both generality and specificity. The general +replacements are 'array-length', 'array-ref', and friends on the scheme +side, and the array handle interface on the C side. On the specific +side of things, there are the specific bytevector, SRFI-4, and bitvector +interfaces. + +** Use of the vector interface on arrays +** 'vector-length', 'vector-ref', and 'vector-set!' on weak vectors +** 'vector-length', 'vector-ref', and 'vector-set!' as primitive-generics + +Making the vector interface operate only on a single representation will +allow future versions of Guile to compile loops involving vectors to +more efficient native code. + +** 'htons', 'htonl', 'ntohs', 'ntohl' + +These procedures, like their C counterpart, were used to convert numbers +to/from network byte order, typically in conjunction with the +now-deprecated uniform vector API. + +This functionality is now covered by the bytevector and binary I/O APIs. +See "Interpreting Bytevector Contents as Integers" in the manual. + +** 'gc-live-object-stats' + +It hasn't worked in the whole 2.0 series. There is no replacement, +unfortunately. + +** 'scm_c_program_source' + +This internal VM function was not meant to be public. Use +'scm_procedure_source' instead. + +* Build fixes + +** Fix build with Clang 3.4. + +** MinGW build fixes +*** Do not add $(EXEEXT) to guild or guile-tools. +*** tests: Use double quotes around shell arguments, for Windows. +*** tests: Don't rely on $TMPDIR and /tmp on Windows. +*** tests: Skip FFI tests that use `qsort' when it's not accessible. +*** tests: Remove symlink only when it exists. +*** tests: Don't rely on `scm_call_2' being visible. + +** Fix computation of LIBLOBJS so dependencies work properly. + (http://bugs.gnu.org/14193) + +* Bug fixes + +** Web: Fix web client with methods other than GET. + (http://bugs.gnu.org/15908) +** Web: Add Content-Length header for empty bodies. +** Web: Accept "UTC" as the zone offset in date headers. + (http://bugs.gnu.org/14128) +** Web: Don't throw if a response is longer than its Content-Length says. +** Web: Write out HTTP Basic auth headers correctly. + (http://bugs.gnu.org/14370) +** Web: Always print a path component in 'write-request-line'. +** Fix 'define-public' from (ice-9 curried-definitions). +** psyntax: toplevel variable definitions discard previous syntactic binding. + (http://bugs.gnu.org/11988) +** Fix thread-unsafe lazy initializations. +** Make (ice-9 popen) thread-safe. + (http://bugs.gnu.org/15683) +** Make guardians thread-safe. +** Make regexp_exec thread-safe. + (http://bugs.gnu.org/14404) +** vm: Gracefully handle stack overflows. + (http://bugs.gnu.org/15065) +** Fix 'rationalize'. + (http://bugs.gnu.org/14905) +** Fix inline asm for VM fixnum operations on x32. +** Fix 'SCM_SYSCALL' to really swallow EINTR. +** Hide EINTR returns from 'accept'. +** SRFI-19: Update the table of leap seconds. +** Add missing files to the test-suite Makefile. +** Make sure 'ftw' allows directory traversal when running as root. +** Fix 'hash-for-each' for weak hash tables. +** SRFI-18: Export 'current-thread'. + (http://bugs.gnu.org/16890) +** Fix inlining of tail list to apply. + (http://bugs.gnu.org/15533) +** Fix bug in remqueue in threads.c when removing last element. +** Fix build when '>>' on negative integers is not arithmetic. +** Fix 'bitwise-bit-count' for negative arguments. + (http://bugs.gnu.org/14864) +** Fix VM 'ash' for right shifts by large amounts. + (http://bugs.gnu.org/14864) +** Fix rounding in scm_i_divide2double for negative arguments. +** Avoid lossy conversion from inum to double in numerical comparisons. +** Fix numerical comparison of fractions to infinities. +** Allow fl+ and fl* to accept zero arguments. + (http://bugs.gnu.org/14869) +** flonum? returns false for complex number objects. + (http://bugs.gnu.org/14866) +** flfinite? applied to a NaN returns false. + (http://bugs.gnu.org/14868) +** Flonum operations always return flonums. + (http://bugs.gnu.org/14871) +** min and max: NaNs beat infinities, per R6RS errata. + (http://bugs.gnu.org/14865) +** Fix 'fxbit-count' for negative arguments. +** 'gcd' and 'lcm' support inexact integer arguments. + (http://bugs.gnu.org/14870) +** Fix R6RS 'fixnum-width'. + (http://bugs.gnu.org/14879) +** tests: Use shell constructs that /bin/sh on Solaris 10 can understand. + (http://bugs.gnu.org/14042) +** Fix display of symbols containing backslashes. + (http://bugs.gnu.org/15033) +** Fix truncated-print for uniform vectors. +** Define `AF_UNIX' only when Unix-domain sockets are supported. +** Decompiler: fix handling of empty 'case-lambda' expressions. +** Fix handling of signed zeroes and infinities in 'numerator' and 'denominator'. +** dereference-pointer: check for null pointer. +** Optimizer: Numerical comparisons are not negatable, for correct NaN handling. +** Compiler: Evaluate '-' and '/' in left-to-right order. + (for more robust floating-point arithmetic) +** snarf.h: Declare static const function name vars as SCM_UNUSED. +** chars.c: Remove duplicate 'const' specifiers. +** Modify SCM_UNPACK type check to avoid warnings in clang. +** Arrange so that 'file-encoding' does not truncate the encoding name. + (http://bugs.gnu.org/16463) +** Improve error checking in bytevector->uint-list and bytevector->sint-list. + (http://bugs.gnu.org/15100) +** Fix (ash -1 SCM_I_FIXNUM_BIT-1) to return a fixnum instead of a bignum. +** i18n: Fix null pointer dereference when locale info is missing. +** Fix 'string-copy!' to work properly with overlapping src/dest. +** Fix hashing of vectors to run in bounded time. +** 'port-position' works on CBIPs that do not support 'set-port-position!'. +** Custom binary input ports sanity-check the return value of 'read!'. +** bdw-gc.h: Check SCM_USE_PTHREAD_THREADS using #if not #ifdef. +** REPL Server: Don't establish a SIGINT handler. +** REPL Server: Redirect warnings to client socket. +** REPL Server: Improve robustness of 'stop-server-and-clients!'. +** Add srfi-16, srfi-30, srfi-46, srfi-62, srfi-87 to %cond-expand-features. +** Fix trap handlers to handle applicable structs. + (http://bugs.gnu.org/15691) +** Fix optional end argument in `uniform-vector-read!'. + (http://bugs.gnu.org/15370) +** Fix brainfuck->scheme compiler. +** texinfo: Fix newline preservation in @example with lines beginning with @ + +** C standards conformance improvements + +Improvements and bug fixes were made to the C part of Guile's run-time +support (libguile). + +*** Don't use the identifier 'noreturn'. + (http://bugs.gnu.org/15798) +*** Rewrite SCM_I_INUM to avoid unspecified behavior when not using GNU C. +*** Improve fallback implemention of SCM_SRS to avoid unspecified behavior. +*** SRFI-60: Reimplement 'rotate-bit-field' on inums to be more portable. +*** Improve compliance with C standards regarding signed integer shifts. +*** Avoid signed overflow in random.c. +*** VM: Avoid signed overflows in 'add1' and 'sub1'. +*** VM: Avoid overflow in ASM_ADD when the result is most-positive-fixnum. +*** read: Avoid signed integer overflow in 'read_decimal_integer'. + + + +Changes in 2.0.9 (since 2.0.7): + +Note: 2.0.8 was a brown paper bag release that was never announced, but +some mirrors may have picked it up. Please do not use it. + +* Notable changes + +** New keyword arguments for procedures that open files + +The following procedures that open files now support keyword arguments +to request binary I/O or to specify the character encoding for text +files: `open-file', `open-input-file', `open-output-file', +`call-with-input-file', `call-with-output-file', `with-input-from-file', +`with-output-to-file', and `with-error-to-file'. + +It is also now possible to specify whether Guile should scan files for +Emacs-style coding declarations. This scan was done by default in +versions 2.0.0 through 2.0.7, but now must be explicitly requested. + +See "File Ports" in the manual for details. + +** Rewritten guile.m4 + +The `guile.m4' autoconf macros have been rewritten to use `guild' and +`pkg-config' instead of the deprecated `guile-config' (which itself +calls pkg-config). + +There is also a new macro, `GUILE_PKG', which allows packages to select +the version of Guile that they want to compile against. See "Autoconf +Macros" in the manual, for more information. + +** Better Windows support + +Guile now correctly identifies absolute paths on Windows (MinGW), and +creates files on that platform according to its path conventions. See +"File System" in the manual, for all details. + +In addition, the new Gnulib imports provide `select' and `poll' on +Windows builds. + +As an incompatible change, systems that are missing were +previously provided a public `scm_std_select' C function that defined a +version of `select', but unhappily it also provided its own incompatible +definitions for FD_SET, FD_ZERO, and other system interfaces. Guile +should not be setting these macros in public API, so this interface was +removed on those plaforms (basically only MinGW). + +** Numerics improvements + +`number->string' now reliably outputs enough digits to produce the same +number when read back in. Previously, it mishandled subnormal numbers +(printing them as "#.#"), and failed to distinguish between some +distinct inexact numbers, e.g. 1.0 and (+ 1.0 (expt 2.0 -52)). These +problems had far-reaching implications, since the compiler uses +`number->string' to serialize numeric constants into .go files. + +`sqrt' now produces exact rational results when possible, and handles +very large or very small numbers more robustly. + +A number (ahem) of operations involving exact rationals have been +optimized, most notably `integer-expt' and `expt'. + +`exact->inexact' now performs correct IEEE rounding. + +** New optimizations + +There were a number of improvements to the partial evaluator, allowing +complete reduction of forms such as: + + ((let ((_ 10)) (lambda () _))) + + ((lambda _ _)) + + (apply (lambda _ _) 1 2 3 '(4)) + + (call-with-values (lambda () (values 1 2)) (lambda _ _)) + +`string-join' now handles huge lists efficiently. + +`get-bytevector-some' now uses buffered input, which is much faster. + +Finally, `array-ref', `array-set!' on arrays of rank 1 or 2 is now +faster, because it avoids building a rest list. Similarly, the +one-argument case of `array-for-each' and `array-map!' has been +optimized, and `array-copy!' and `array-fill!' are faster. + +** `peek-char' no longer consumes EOF + +As required by the R5RS, if `peek-char' returns EOF, then the next read +will also return EOF. Previously `peek-char' would consume the EOF. +This makes a difference for terminal devices where it is possible to +read past an EOF. + +** Gnulib update + +Guile's copy of Gnulib was updated to v0.0-7865-ga828bb2. The following +modules were imported from Gnulib: select, times, pipe-posix, fstat, +getlogin, poll, and c-strcase. + +** `include' resolves relative file names relative to including file + +Given a relative file name, `include' will look for it relative to the +directory of the including file. This harmonizes the behavior of +`include' with that of `load'. + +** SLIB compatibility restored + +Guile 2.0.8 is now compatible with SLIB. You will have to use a +development version of SLIB, however, until a new version of SLIB is +released. + +** Better ,trace REPL command + +Sometimes the ,trace output for nested function calls could overflow the +terminal width, which wasn't useful. Now there is a limit to the amount +of space the prefix will take. See the documentation for ",trace" for +more information. + +** Better docstring syntax supported for `case-lambda' + +Docstrings can now be placed immediately after the `case-lambda' or +`case-lambda*' keyword. See "Case-lambda" in the manual. + +** Improved handling of Unicode byte order marks + +See "BOM Handling" in the manual for details. + +** Update predefined character sets to Unicode 6.2 + +** GMP 4.2 or later required + +Guile used to require GMP at least version 4.1 (released in May 2002), +and now requires at least version 4.2 (released in March 2006). + +* Manual updates + +** Better SXML documentation + +The documentation for SXML modules was much improved, though there is +still far to go. See "SXML" in manual. + +** Style updates + +Use of "iff" was replaced with standard English. Keyword arguments are +now documented consistently, along with their default values. + +** An end to the generated-documentation experiment + +When Guile 2.0 imported some modules from Guile-Lib, they came with a +system that generated documentation from docstrings and module +commentaries. This produced terrible documentation. We finally bit the +bullet and incorporated these modules into the main text, and will be +improving them manually over time, as is the case with SXML. Help is +appreciated. + +** New documentation + +There is now documentation for `scm_array_type', and `scm_array_ref', as +well as for the new `array-length' / 'scm_c_array_length' / +`scm_array_length' functions. `array-in-bounds?' has better +documentation as well. The `program-arguments-alist' and +`program-lambda-list' functions are now documented, as well as `and=>', +`exit', and `quit'. The (system repl server) module is now documented +(see REPL Servers). Finally, the GOOPS class hierarchy diagram has been +regenerated for the web and print output formats. + +* New deprecations + +** Deprecate generalized vector interface + +The generalized vector interface, introduced in 1.8.0, is simply a +redundant, verbose interface to arrays of rank 1. `array-ref' and +similar functions are entirely sufficient. Thus, +`scm_generalized_vector_p', `scm_generalized_vector_length', +`scm_generalized_vector_ref', `scm_generalized_vector_set_x', and +`scm_generalized_vector_to_list' are now deprecated. + +** Deprecate SCM_CHAR_CODE_LIMIT and char-code-limit + +These constants were defined to 256, which is not the highest codepoint +supported by Guile. Given that they were useless and incorrect, they +have been deprecated. + +** Deprecate `http-get*' + +The new `#:streaming?' argument to `http-get' subsumes the functionality +of `http-get*' (introduced in 2.0.7). Also, the `#:extra-headers' +argument is deprecated in favor of `#:headers'. + +** Deprecate (ice-9 mapping) + +This module, present in Guile since 1996 but never used or documented, +has never worked in Guile 2.0. It has now been deprecated and will be +removed in Guile 2.2. + +** Deprecate undocumented array-related C functions + +These are `scm_array_fill_int', `scm_ra_eqp', `scm_ra_lessp', +`scm_ra_leqp', `scm_ra_grp', `scm_ra_greqp', `scm_ra_sum', +`scm_ra_product', `scm_ra_difference', `scm_ra_divide', and +`scm_array_identity'. + +* New interfaces + +** SRFI-41 Streams + +See "SRFI-41" in the manual. + +** SRFI-45 exports `promise?' + +SRFI-45 now exports a `promise?' procedure that works with its promises. +Also, its promises now print more nicely. + +** New HTTP client procedures + +See "Web Client" for documentation on the new `http-head', `http-post', +`http-put', `http-delete', `http-trace', and `http-options' procedures, +and also for more options to `http-get'. + +** Much more capable `xml->sxml' + +See "Reading and Writing XML" for information on how the `xml->sxml' +parser deals with namespaces, processed entities, doctypes, and literal +strings. Incidentally, `current-ssax-error-port' is now a parameter +object. + +** New procedures for converting strings to and from bytevectors + +See "Representing Strings as Bytes" for documention on the new `(ice-9 +iconv)' module and its `bytevector->string' and `string->bytevector' +procedures. + +** Escape continuations with `call/ec' and `let/ec' + +See "Prompt Primitives". + +** New procedures to read all characters from a port + +See "Line/Delimited" in the manual for documentation on `read-string' + and `read-string!'. + +** New procedure `sendfile' + +See "File System". + +** New procedure `unget-bytevector' + +See "R6RS Binary Input". + +** New C helper: `scm_c_bind_keyword_arguments' + +See "Keyword Procedures". + +** New command-line arguments: `--language' and `-C' + +See "Command-line Options" in the manual. + +** New environment variables: `GUILE_STACK_SIZE', `GUILE_INSTALL_LOCALE' + +See "Environment Variables". + +** New procedures for dealing with file names + +See "File System" for documentation on `system-file-name-convention', +`file-name-separator?', `absolute-file-name?', and +`file-name-separator-string'. + +** `array-length', an array's first dimension + +See "Array Procedures". + +** `hash-count', for hash tables + +See "Hash Tables". + +** `round-ash', a bit-shifting operator that rounds on right-shift + +See "Bitwise Operations". + +** New foreign types: `ssize_t', `ptrdiff_t' + +See "Foreign Types". + +** New C helpers: `scm_from_ptrdiff_t', `scm_to_ptrdiff_t' + +See "Integers". + +** Socket option `SO_REUSEPORT' now available from Scheme + +If supported on the platform, `SO_REUSEPORT' is now available from +Scheme as well. See "Network Sockets and Communication". + +** `current-language' in default environment + +Previously defined only in `(system base language)', `current-language' +is now defined in the default environment, and is used to determine the +language for the REPL, and for `compile-and-load'. + +** New procedure: `fluid->parameter' + +See "Parameters", for information on how to convert a fluid to a +parameter. + +** New `print' REPL option + +See "REPL Commands" in the manual for information on the new +user-customizable REPL printer. + +** New variable: %site-ccache-dir + +The "Installing Site Packages" and "Build Config" manual sections now +refer to this variable to describe where users should install their +`.go' files. + +* Build fixes + +** Fix compilation against libgc 7.3. +** Fix cross-compilation of `c-tokenize.o'. +** Fix warning when compiling against glibc 2.17. +** Fix documentation build against Texinfo 5.0. +** Fix building Guile from a directory with non-ASCII characters. +** Fix native MinGW build. +** Fix --disable-posix build. +** Fix MinGW builds with networking, POSIX, and thread support. + +* Bug fixes + +** Fix inexact number printer. + (http://bugs.gnu.org/13757) +** Fix infinite loop when parsing optional-argument short options (SRFI-37). + (http://bugs.gnu.org/13176) +** web: Support non-GMT date headers in the HTTP client. + (http://bugs.gnu.org/13544) +** web: support IP-literal (IPv6 address) in Host header. +** Avoid stack overflows with `par-map' and nested futures in general. + (http://bugs.gnu.org/13188) +** Peek-char no longer consumes EOF. + (http://bugs.gnu.org/12216) +** Avoid swallowing multiple EOFs in R6RS binary-input procedures. +** A fork when multiple threads are running will now print a warning. +** Allow for spurious wakeups from pthread_cond_wait. + (http://bugs.gnu.org/10641) +** Warn and ignore module autoload failures. + (http://bugs.gnu.org/12202) +** Use chmod portably in (system base compile). + (http://bugs.gnu.org/10474) +** Fix response-body-port for HTTP responses without content-length. + (http://bugs.gnu.org/13857) +** Allow case-lambda expressions with no clauses. + (http://bugs.gnu.org/9776) +** Improve standards conformance of string->number. + (http://bugs.gnu.org/11887) +** Support calls and tail-calls with more than 255 formals. +** ,option evaluates its right-hand-side. + (http://bugs.gnu.org/13076) +** Structs with tail arrays are not simple. + (http://bugs.gnu.org/12808) +** Make `SCM_LONG_BIT' usable in preprocessor conditionals. + (http://bugs.gnu.org/13848) +** Fix thread-unsafe lazy initializations. +** Allow SMOB mark procedures to be called from parallel markers. + (http://bugs.gnu.org/13611) +** Fix later-bindings-win logic in with-fluids. + (http://bugs.gnu.org/13843) +** Fix duplicate removal of with-fluids. + (http://bugs.gnu.org/13838) +** Support calling foreign functions of 10 arguments or more. + (http://bugs.gnu.org/13809) +** Let reverse! accept arbitrary types as second argument. + (http://bugs.gnu.org/13835) +** Recognize the `x86_64.*-gnux32' triplet. +** Check whether a triplet's OS part specifies an ABI. +** Recognize mips64* as having 32-bit pointers by default. +** Use portable sed constructs. + (http://bugs.gnu.org/14042) +** Remove language/glil/decompile-assembly.scm. + (http://bugs.gnu.org/10622) +** Use O_BINARY in `copy-file', `load-objcode', `mkstemp'. +** Use byte-oriented functions in `get-bytevector*'. +** Fix abort when iconv swallows BOM from UTF-16 or UTF-32 stream. +** Fix compilation of functions with more than 255 local variables. +** Fix `getgroups' for when zero supplementary group IDs exist. +** Allow (define-macro name (lambda ...)). +** Various fixes to the (texinfo) modules. +** guild: Gracefully handle failures to install the locale. +** Fix format string warnings for ~!, ~|, ~/, ~q, ~Q, and ~^. + (http://bugs.gnu.org/13485) +** Fix source annotation bug in psyntax 'expand-body'. +** Ecmascript: Fix conversion to boolean for non-numbers. +** Use case-insensitive comparisons for encoding names. +** Add missing cond-expand feature identifiers. +** A failure to find a module's file does not prevent future loading. +** Many (oop goops save) fixes. +** `http-get': don't shutdown write end of socket. + (http://bugs.gnu.org/13095) +** Avoid signed integer overflow in scm_product. +** http: read-response-body always returns bytevector or #f, never EOF. +** web: Correctly detect "No route to host" conditions. +** `system*': failure to execvp no longer leaks dangling processes. + (http://bugs.gnu.org/13166) +** More sensible case-lambda* dispatch. + (http://bugs.gnu.org/12929) +** Do not defer expansion of internal define-syntax forms. + (http://bugs.gnu.org/13509) + + + +Changes in 2.0.7 (since 2.0.6): + +* Notable changes + +** SRFI-105 curly infix expressions are supported + +Curly infix expressions as described at +http://srfi.schemers.org/srfi-105/srfi-105.html are now supported by +Guile's reader. This allows users to write things like {a * {b + c}} +instead of (* a (+ b c)). SRFI-105 support is enabled by using the +`#!curly-infix' directive in source code, or the `curly-infix' reader +option. See the manual for details. + +** Reader options may now be per-port + +Historically, `read-options' and related procedures would manipulate +global options, affecting the `read' procedure for all threads, and all +current uses of `read'. + +Guile can now associate `read' options with specific ports, allowing +different ports to use different options. For instance, the +`#!fold-case' and `#!no-fold-case' reader directives have been +implemented, and their effect is to modify the current read options of +the current port only; similarly for `#!curly-infix'. Thus, it is +possible, for instance, to have one port reading case-sensitive code, +while another port reads case-insensitive code. + +** Futures may now be nested + +Futures may now be nested: a future can itself spawn and then `touch' +other futures. In addition, any thread that touches a future that has +not completed now processes other futures while waiting for the touched +future to completed. This allows all threads to be kept busy, and was +made possible by the use of delimited continuations (see the manual for +details.) + +Consequently, `par-map' and `par-for-each' have been rewritten and can +now use all cores. + +** `GUILE_LOAD_PATH' et al can now add directories to the end of the path + +`GUILE_LOAD_PATH' and `GUILE_LOAD_COMPILED_PATH' can now be used to add +directories to both ends of the load path. If the special path +component `...' (ellipsis) is present in these environment variables, +then the default path is put in place of the ellipsis, otherwise the +default path is placed at the end. See "Environment Variables" in the +manual for details. + +** `load-in-vicinity' search for `.go' files in `%load-compiled-path' + +Previously, `load-in-vicinity' would look for compiled files in the +auto-compilation cache, but not in `%load-compiled-path'. This is now +fixed. This affects `load', and the `-l' command-line flag. See + for details. + +** Extension search order fixed, and LD_LIBRARY_PATH preserved + +Up to 2.0.6, Guile would modify the `LD_LIBRARY_PATH' environment +variable (or whichever is relevant for the host OS) to insert its own +default extension directories in the search path (using GNU libltdl +facilities was not possible here.) This approach was problematic in two +ways. + +First, the `LD_LIBRARY_PATH' modification would be visible to +sub-processes, and would also affect future calls to `dlopen', which +could lead to subtle bugs in the application or sub-processes. Second, +when the installation prefix is /usr, the `LD_LIBRARY_PATH' modification +would typically end up inserting /usr/lib before /usr/local/lib in the +search path, which is often the opposite of system-wide settings such as +`ld.so.conf'. + +Both issues have now been fixed. + +** `make-vtable-vtable' is now deprecated + +Programs should instead use `make-vtable' and `'. + +** The `-Wduplicate-case-datum' and `-Wbad-case-datum' are enabled + +These recently introduced warnings have been documented and are now +enabled by default when auto-compiling. + +** Optimize calls to `equal?' or `eqv?' with a constant argument + +The compiler simplifies calls to `equal?' or `eqv?' with a constant +argument to use `eq?' instead, when applicable. + +* Manual updates + +** SRFI-9 records now documented under "Compound Data Types" + +The documentation of SRFI-9 record types has been moved in the "Compound +Data Types", next to Guile's other record APIs. A new section +introduces the various record APIs, and describes the trade-offs they +make. These changes were made in an attempt to better guide users +through the maze of records API, and to recommend SRFI-9 as the main +API. + +The documentation of Guile's raw `struct' API has also been improved. + +** (ice-9 and-let-star) and (ice-9 curried-definitions) now documented + +These modules were missing from the manual. + +* New interfaces + +** New "functional record setters" as a GNU extension of SRFI-9 + +The (srfi srfi-9 gnu) module now provides three new macros to deal with +"updates" of immutable records: `define-immutable-record-type', +`set-field', and `set-fields'. + +The first one allows record type "functional setters" to be defined; +such setters keep the record unchanged, and instead return a new record +with only one different field. The remaining macros provide the same +functionality, and also optimize updates of multiple or nested fields. +See the manual for details. + +** web: New `http-get*', `response-body-port', and `text-content-type?' + procedures + +These procedures return a port from which to read the response's body. +Unlike `http-get' and `read-response-body', they allow the body to be +processed incrementally instead of being stored entirely in memory. + +The `text-content-type?' predicate allows users to determine whether the +content type of a response is textual. + +See the manual for details. + +** `string-split' accepts character sets and predicates + +The `string-split' procedure can now be given a SRFI-14 character set or +a predicate, instead of just a character. + +** R6RS SRFI support + +Previously, in R6RS modules, Guile incorrectly ignored components of +SRFI module names after the SRFI number, making it impossible to specify +sub-libraries. This release corrects this, bringing us into accordance +with SRFI 97. + +** `define-public' is no a longer curried definition by default + +The (ice-9 curried-definitions) should be used for such uses. See the +manual for details. + +* Build fixes + +** Remove reference to `scm_init_popen' when `fork' is unavailable + +This fixes a MinGW build issue (http://bugs.gnu.org/12477). + +** Fix race between installing `guild' and the `guile-tools' symlink + +* Bug fixes + +** Procedures returned by `eval' now have docstrings + (http://bugs.gnu.org/12173) +** web client: correctly handle uri-query, etc. in relative URI headers + (http://bugs.gnu.org/12827) +** Fix docs for R6RS `hashtable-copy' +** R6RS `string-for-each' now accepts multiple string arguments +** Fix out-of-range error in the compiler's CSE pass + (http://bugs.gnu.org/12883) +** Add missing R6RS `open-file-input/output-port' procedure +** Futures: Avoid creating the worker pool more than once +** Fix invalid assertion about mutex ownership in threads.c + (http://bugs.gnu.org/12719) +** Have `SCM_NUM2FLOAT' and `SCM_NUM2DOUBLE' use `scm_to_double' +** The `scandir' procedure now uses `lstat' instead of `stat' +** Fix `generalized-vector->list' indexing bug with shared arrays + (http://bugs.gnu.org/12465) +** web: Change `http-get' to try all the addresses for the given URI +** Implement `hash' for structs + (http://lists.gnu.org/archive/html/guile-devel/2012-10/msg00031.html) +** `read' now adds source properties for data types beyond pairs +** Improve error reporting in `append!' +** In fold-matches, set regexp/notbol unless matching string start +** Don't stat(2) and access(2) the .go location before using it +** SRFI-19: use zero padding for hours in ISO 8601 format, not blanks +** web: Fix uri-encoding for strings with no unreserved chars, and octets 0-15 +** More robust texinfo alias handling +** Optimize `format' and `simple-format' + (http://bugs.gnu.org/12033) +** Angle of -0.0 is pi, not zero + + +Changes in 2.0.6 (since 2.0.5): + +* Notable changes + +** New optimization pass: common subexpression elimination (CSE) + +Guile's optimizer will now run a CSE pass after partial evaluation. +This pass propagates static information about branches taken, bound +lexicals, and effects from an expression's dominators. It can replace +common subexpressions with their boolean values (potentially enabling +dead code elimination), equivalent bound lexicals, or it can elide them +entirely, depending on the context in which they are executed. This +pass is especially useful in removing duplicate type checks, such as +those produced by SRFI-9 record accessors. + +** Improvements to the partial evaluator + +Peval can now hoist tests that are common to both branches of a +conditional into the test. This can help with long chains of +conditionals, such as those generated by the `match' macro. Peval can +now do simple beta-reductions of procedures with rest arguments. It +also avoids residualizing degenerate lexical aliases, even when full +inlining is not possible. Finally, peval now uses the effects analysis +introduced for the CSE pass. More precise effects analysis allows peval +to move more code. + +** Run finalizers asynchronously in asyncs + +Finalizers are now run asynchronously, via an async. See Asyncs in the +manual. This allows Guile and user code to safely allocate memory while +holding a mutex. + +** Update SRFI-14 character sets to Unicode 6.1 + +Note that this update causes the Latin-1 characters `§' and `¶' to be +reclassified as punctuation. They were previously considered to be part +of `char-set:symbol'. + +** Better source information for datums + +When the `positions' reader option is on, as it is by default, Guile's +reader will record source information for more kinds of datums. + +** Improved error and warning messages + +`syntax-violation' errors now prefer `subform' for source info, with +`form' as fallback. Syntactic errors in `cond' and `case' now produce +better errors. `case' can now warn on duplicate datums, or datums that +cannot be usefully compared with `eqv?'. `-Warity-mismatch' now handles +applicable structs. `-Wformat' is more robust in the presence of +`gettext'. Finally, various exceptions thrown by the Web modules now +define appropriate exception printers. + +** A few important bug fixes in the HTTP modules. + +Guile's web server framework now checks if an application returns a body +where it is not permitted, for example in response to a HEAD request, +and warn or truncate the response as appropriate. Bad requests now +cause a 400 Bad Request response to be printed before closing the port. +Finally, some date-printing and URL-parsing bugs were fixed. + +** Pretty-print improvements + +When Guile needs to pretty-print Tree-IL, it will try to reconstruct +`cond', `or`, and other derived syntax forms from the primitive tree-IL +forms. It also uses the original names instead of the fresh unique +names, when it is unambiguous to do so. This can be seen in the output +of REPL commands like `,optimize'. + +Also, the `pretty-print' procedure has a new keyword argument, +`#:max-expr-width'. + +** Fix memory leak involving applicable SMOBs + +At some point in the 1.9.x series, Guile began leaking any applicable +SMOB that was actually applied. (There was a weak-key map from SMOB to +trampoline functions, where the value had a strong reference on the +key.) This has been fixed. There was much rejoicing! + +** Support for HTTP/1.1 chunked transfer coding + +See "Transfer Codings" in the manual, for more. + +** Micro-optimizations + +A pile of micro-optimizations: the `string-trim' function when called +with `char-set:whitespace'; the `(web http)' parsers; SMOB application; +conversion of raw UTF-8 and UTF-32 data to and from SCM strings; vlists +and vhashes; `read' when processing string literals. + +** Incompatible change to `scandir' + +As was the original intention, `scandir' now runs the `select?' +procedure on all items, including subdirectories and the `.' and `..' +entries. It receives the basename of the file in question instead of +the full name. We apologize for this incompatible change to this +function introduced in the 2.0.4 release. + +* Manual updates + +The manual has been made much more consistent in its naming conventions +with regards to formal parameters of functions. Thanks to Bake Timmons. + +* New interfaces + +** New C function: `scm_to_pointer' +** New C inline functions: `scm_new_smob', `scm_new_double_smob' +** (ice-9 format): Add ~h specifier for localized number output. +** (web response): New procedure: `response-must-not-include-body?' +** New predicate: 'supports-source-properties?' +** New C helpers: `scm_c_values', `scm_c_nvalues' +** Newly public inline C function: `scm_unget_byte' +** (language tree-il): New functions: `tree-il=?', `tree-il-hash' +** New fluid: `%default-port-conversion-strategy' +** New syntax: `=>' within `case' +** (web http): `make-chunked-input-port', `make-chunked-output-port' +** (web http): `declare-opaque-header!' + +Search the manual for these identifiers, for more information. + +* New deprecations + +** `close-io-port' deprecated + +Use `close-port'. + +** `scm_sym2var' deprecated + +In most cases, replace with `scm_lookup' or `scm_module_variable'. Use +`scm_define' or `scm_module_ensure_local_variable' if the second +argument is nonzero. See "Accessing Modules from C" in the manual, for +full details. + +** Lookup closures deprecated + +These were never documented. See "Module System Reflection" in the +manual for replacements. + +* Build fixes + +** Fix compilation against uninstalled Guile on non-GNU platforms. +** Fix `SCM_I_ERROR' definition for MinGW without networking. +** Fix compilation with the Sun C compiler. +** Fix check for `clock_gettime' on OpenBSD and some other systems. +** Fix build with --enable-debug-malloc. +** Honor $(program_transform_name) for the `guile-tools' symlink. +** Fix cross-compilation of GOOPS-using code. + +* Bug fixes + +** Fix use of unitialized stat buffer in search-path of absolute paths. +** Avoid calling `freelocale' with a NULL argument. +** Work around erroneous tr_TR locale in Darwin 8 in tests. +** Fix `getaddrinfo' test for Darwin 8. +** Use Gnulib's `regex' module for better regex portability. +** `source-properties' and friends work on any object +** Rewrite open-process in C, for robustness related to threads and fork +** Fix vector-length when applied to other uniform vector types +** Fix escape-only prompt optimization (was disabled previously) +** Fix a segfault when /dev/urandom is not accessible +** Fix flush on soft ports, so that it actually runs. +** Better compatibility of SRFI-9 records with core records +** Fix and clarify documentation of `sorted?'. +** Fix IEEE-754 endianness conversion in bytevectors. +** Correct thunk check in the `wind' instruction. +** Add @acronym support to texinfo modules +** Fix docbook->texi for without URL +** Fix `setvbuf' to leave the line/column number unchanged. +** Add missing public declaration for `scm_take_from_input_buffers'. +** Fix relative file name canonicalization with empty %LOAD-PATH entries. +** Import newer (ice-9 match) from Chibi-Scheme. +** Fix unbound variables and unbound values in ECMAScript runtime. +** Make SRFI-6 string ports Unicode-capable. + + +Changes in 2.0.5 (since 2.0.4): + +This release fixes the binary interface information (SONAME) of +libguile, which was incorrect in 2.0.4. It does not contain other +changes. + + Changes in 2.0.4 (since 2.0.3): * Notable changes