X-Git-Url: https://git.hcoop.net/bpt/guile.git/blobdiff_plain/53f4876abcebf3f05d2a88bba3a898ddcda25a74..13922e3fa9f1d5747dd15ee4cf34447ec8939b7c:/NEWS diff --git a/NEWS b/NEWS index c83e2d675..08dc112e7 100644 --- a/NEWS +++ b/NEWS @@ -1,37 +1,853 @@ Guile NEWS --- history of user-visible changes. -Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. +Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. See the end for copying conditions. -Please send Guile bug reports to bug-guile@gnu.org. Note that you -must be subscribed to this list first, in order to successfully send a -report to it. +Please send Guile bug reports to bug-guile@gnu.org. -Changes in 1.9.0: +(During the 1.9 series, we will keep an incremental NEWS for the latest +prerelease, and a full NEWS corresponding to 1.8 -> 2.0.) -* New modules (see the manual for details) +Changes in 1.9.5 (since the 1.9.4 prerelease): -** `(srfi srfi-18)', multithreading support -** The `(ice-9 i18n)' module provides internationalization support +** Compiled procedures may now have more than one arity. -* Changes to the distribution +This can be the case, for example, in case-lambda procedures. The +arities of compiled procedures may be accessed via procedures from the +`(system vm program)' module; see "Compiled Procedures", "Optional +Arguments", and "Case-lambda" in the manual. + +** `case-lambda' is now available in the default environment. + +The binding in the default environment is equivalent to the one from the +`(srfi srfi-16)' module. Use the srfi-16 module explicitly if you wish +to maintain compatibility with Guile 1.8 and earlier. + +** VM calling convention change: callee-parsed arguments + +As an internal implementation detail, compiled procedures are now +responsible for parsing their own arguments, which they receive on the +stack. + +** VM support for multiple-arity dispatch + +Calls to procedures with multiple arities, for example those made be +`case-lambda', now dispatch via special opcodes, without the need to +cons a rest list. + +** Intermediate language support for multiple-arity procedures. + +In the intermediate language, tree-il, all procedures may have one or +more arities. This allows all Guile languages to have multiple arities. +It is, however, an incompatible change, and anyone maintaining a +compiler out-of-tree would be advised to get it into Guile soon :) + +** `lambda*' and `define*' are now available in the default environment + +As with `case-lambda', `(ice-9 optargs)' continues to be supported, for +compatibility purposes. No semantic change has been made (we hope). +Optional and keyword arguments now dispatch via special VM operations, +without the need to cons rest arguments, making them very fast. + +** Better support for Lisp `nil'. + +The bit representation of `nil' has been tweaked so that it is now very +efficient to check e.g. if a value is equal to Scheme's end-of-list or +Lisp's nil. Additionally there are a heap of new, specific predicates +like scm_is_null_or_nil. Probably in the future we will #define +scm_is_null to scm_is_null_or_nil. + +** No future. + +Actually the future is still in the state that it was, is, and ever +shall be, Amen, except that `futures.c' and `futures.h' are no longer a +part of it. These files were experimental, never compiled, and would be +better implemented in Scheme anyway. In the future, that is. + +** Support for static allocation of strings, symbols, and subrs. + +Calls to snarfing CPP macros like SCM_DEFINE macro will now allocate +much of their associated data as static variables, reducing Guile's +memory footprint. + +** Inline vector allocation + +Instead of having vectors point out into the heap for their data, their +data is now allocated inline to the vector object itself. The same is +true for bytevectors, by default, though there is an indirection +available which should allow for making a bytevector from an existing +memory region. + +** New syntax: include-from-path. + +`include-from-path' is like `include', except it looks for its file in +the load path. It can be used to compile other files into a file. + +** New syntax: quasisyntax. + +`quasisyntax' is to `syntax' as `quasiquote' is to `quote'. See the R6RS +documentation for more information. Thanks to Andre van Tonder for the +implementation. + +** Cleanups to Guile's primitive object system. + +There were a number of pieces in `objects.[ch]' that tried to be a +minimal object system, but were never documented, and were quickly +obseleted by GOOPS' merge into Guile proper. So `scm_make_class_object', +`scm_make_subclass_object', `scm_metaclass_standard', and like symbols +from objects.h are no more. In the very unlikely case in which these +were useful to you, we urge you to contact guile-devel. + +** GOOPS cleanups. + +GOOPS had a number of concepts that were relevant to the days of Tcl, +but not any more: operators and entities, mainly. These objects were +never documented, and it is unlikely that they were ever used. Operators +were a kind of generic specific to the Tcl support. Entities were +applicable structures, but were unusable; entities will come back in the +next alpha release, but with a less stupid name. + +** Faster bit operations. + +The bit-twiddling operations `ash', `logand', `logior', and `logxor' now +have dedicated bytecodes. Guile is not just for symbolic computation, +it's for number crunching too. + +** `inet-ntop' and `inet-pton' are always available. + +Guile now use a portable implementation of `inet_pton'/`inet_ntop', so +there is no more need to use `inet-aton'/`inet-ntoa'. The latter +functions are deprecated. + +** R6RS block comment support + +Guile now supports R6RS nested block comments. The start of a comment is +marked with `#|', and the end with `|#'. + +** `guile-2' cond-expand feature + +To test if your code is running under Guile 2.0 (or its alpha releases), +test for the `guile-2' cond-expand feature. Like this: + + (cond-expand (guile-2 (eval-when (compile) + ;; This must be evaluated at compile time. + (fluid-set! current-reader my-reader))) + (guile + ;; Earlier versions of Guile do not have a + ;; separate compilation phase. + (fluid-set! current-reader my-reader))) + +** ABI harmonization + +`scm_search_path' now has the signature it did in 1.8, reverting an +incompatible change made in 1.9.0. + +** Compile-time warnings: -Warity-mismatch -** Guile now uses Gnulib as a portability aid +Guile can warn when you pass the wrong number of arguments to a +procedure. Pass the -Warity-mismatch on the `guile-tools compile' +command line, or add `#:warnings '(arity-mismatch)' to your `compile' +or `compile-file' invocation. + +** Guile is now built without `-Werror' by default + +Use the `--enable-error-on-warning' configure option to enable it. + +** And of course, the usual collection of bugfixes + +Interested users should see the ChangeLog for more information. + + + +Changes in 1.9.x (since the 1.8.x series): + +* New modules (see the manual for details) + +** `(srfi srfi-18)', more sophisticated multithreading support +** `(ice-9 i18n)', internationalization support +** `(rnrs bytevector)', the R6RS bytevector API +** `(rnrs io ports)', a subset of the R6RS I/O port API +** `(system xref)', a cross-referencing facility (FIXME undocumented) * Changes to the stand-alone interpreter + +** Guile now can compile Scheme to bytecode for a custom virtual machine. + +Compiled code loads much faster than Scheme source code, and runs around +3 or 4 times as fast, generating much less garbage in the process. + +** The stack limit is now initialized from the environment. + +If getrlimit(2) is available and a stack limit is set, Guile will set +its stack limit to 80% of the rlimit. Otherwise the limit is 160000 +words, a four-fold increase from the earlier default limit. + +** New environment variables: GUILE_LOAD_COMPILED_PATH, + GUILE_SYSTEM_LOAD_COMPILED_PATH + +GUILE_LOAD_COMPILED_PATH is for compiled files what GUILE_LOAD_PATH is +for source files. It is a different path, however, because compiled +files are architecture-specific. GUILE_SYSTEM_LOAD_COMPILED_PATH is like +GUILE_SYSTEM_PATH. + +** New read-eval-print loop (REPL) implementation + +Running Guile with no arguments drops the user into the new REPL. While +it is self-documenting to an extent, the new REPL has not yet been +documented in the manual. This will be fixed before 2.0. + +** New `guile-tools' commands: `compile', `disassemble' + +Pass the `--help' command-line option to these commands for more +information. + +** Guile now adds its install prefix to the LTDL_LIBRARY_PATH + +Users may now install Guile to nonstandard prefixes and just run +`/path/to/bin/guile', instead of also having to set LTDL_LIBRARY_PATH to +include `/path/to/lib'. + +** Guile's Emacs integration is now more keyboard-friendly + +Backtraces may now be disclosed with the keyboard in addition to the +mouse. + * Changes to Scheme functions and syntax -** A new 'memoize-symbol evaluator trap has been added. This trap can -be used for efficiently implementing a Scheme code coverage. +** Procedure removed: `the-environment' + +This procedure was part of the interpreter's execution model, and does +not apply to the compiler. + +** Files loaded with `primitive-load-path' will now be compiled + automatically. + +If a compiled .go file corresponding to a .scm file is not found or is +not fresh, the .scm file will be compiled on the fly, and the resulting +.go file stored away. An advisory note will be printed on the console. + +Note that this mechanism depends on preservation of the .scm and .go +modification times; if the .scm or .go files are moved after +installation, care should be taken to preserve their original +timestamps. + +Autocompiled files will be stored in the $XDG_CACHE_HOME/guile/ccache +directory, where $XDG_CACHE_HOME defaults to ~/.cache. This directory +will be created if needed. + +To inhibit autocompilation, set the GUILE_AUTO_COMPILE environment +variable to 0, or pass --no-autocompile on the Guile command line. + +Note that there is currently a bug here: automatic compilation will +sometimes be attempted when it shouldn't. + +For example, the old (lang elisp) modules are meant to be interpreted, +not compiled. This bug will be fixed before 2.0. FIXME 2.0: Should say +something here about module-transformer called for compile. + +** Files loaded with `load' will now be compiled automatically. + +As with files loaded via `primitive-load-path', `load' will also compile +its target if autocompilation is enabled, and a fresh compiled file is +not found. + +There are two points of difference to note, however. First, `load' does +not search `GUILE_LOAD_COMPILED_PATH' for the file; it only looks in the +autocompilation directory, normally a subdirectory of ~/.cache/guile. + +Secondly, autocompilation also applies to files loaded via the -l +command-line argument -- so the user may experience a slight slowdown +the first time they run a Guile script, as the script is autocompiled. + +** New POSIX procedures: `getrlimit' and `setrlimit' + +Note however that the interface of these functions is likely to change +in the next prerelease. + +** New procedure in `(oops goops)': `method-formals' + +** BUG: (procedure-property func 'arity) does not work on compiled + procedures + +This will be fixed one way or another before 2.0. + +** New procedures in (ice-9 session): `add-value-help-handler!', + `remove-value-help-handler!', `add-name-help-handler!' + `remove-name-help-handler!', `procedure-arguments', + +The value and name help handlers provide some minimal extensibility to +the help interface. Guile-lib's `(texinfo reflection)' uses them, for +example, to make stexinfo help documentation available. See those +procedures' docstrings for more information. + +`procedure-arguments' describes the arguments that a procedure can take, +combining arity and formals. For example: + + (procedure-arguments resolve-interface) + => ((required . (name)) (rest . args)) + +Additionally, `module-commentary' is now publically exported from +`(ice-9 session). + +** Deprecated: `procedure->memoizing-macro', `procedure->syntax' + +These procedures will not work with syncase expansion, and indeed are +not used in the normal course of Guile. They are still used by the old +Emacs Lisp support, however. + +** New language: ECMAScript + +Guile now ships with one other high-level language supported, +ECMAScript. The goal is to support all of version 3.1 of the standard, +but not all of the libraries are there yet. This support is not yet +documented; ask on the mailing list if you are interested. + +** New language: Brainfuck + +Brainfuck is a toy language that closely models Turing machines. Guile's +brainfuck compiler is meant to be an example of implementing other +languages. See the manual for details, or +http://en.wikipedia.org/wiki/Brainfuck for more information about the +Brainfuck language itself. + +** Defmacros may now have docstrings. + +Indeed, any macro may have a docstring. `object-documentation' from +`(ice-9 documentation)' may be used to retrieve the docstring, once you +have a macro value -- but see the above note about first-class macros. +Docstrings are associated with the syntax transformer procedures. + +** The psyntax expander now knows how to interpret the @ and @@ special + forms. + +** The psyntax expander is now hygienic with respect to modules. + +Free variables in a macro are scoped in the module that the macro was +defined in, not in the module the macro is used in. For example, code +like this works now: + + (define-module (foo) #:export (bar)) + (define (helper x) ...) + (define-syntax bar + (syntax-rules () ((_ x) (helper x)))) + + (define-module (baz) #:use-module (foo)) + (bar qux) + +It used to be you had to export `helper' from `(foo)' as well. +Thankfully, this has been fixed. + +** New function, `procedure-module' + +While useful on its own, `procedure-module' is used by psyntax on syntax +transformers to determine the module in which to scope introduced +identifiers. + +** `eval-case' has been deprecated, and replaced by `eval-when'. + +The semantics of `eval-when' are easier to understand. It is still +missing documentation, however. + +** Guile is now more strict about prohibiting definitions in expression + contexts. + +Although previous versions of Guile accepted it, the following +expression is not valid, in R5RS or R6RS: + + (if test (define foo 'bar) (define foo 'baz)) + +In this specific case, it would be better to do: + + (define foo (if test 'bar 'baz)) + +It is certainly possible to circumvent this resriction with e.g. +`(module-define! (current-module) 'foo 'baz)'. We would appreciate +feedback about this change (a consequence of using psyntax as the +default expander), and may choose to revisit this situation before 2.0 +in response to user feedback. + +** Defmacros must now produce valid Scheme expressions. + +It used to be that defmacros could unquote in Scheme values, as a way of +supporting partial evaluation, and avoiding some hygiene issues. For +example: + + (define (helper x) ...) + (define-macro (foo bar) + `(,helper ,bar)) + +Assuming this macro is in the `(baz)' module, the direct translation of +this code would be: + + (define (helper x) ...) + (define-macro (foo bar) + `((@@ (baz) helper) ,bar)) + +Of course, one could just use a hygienic macro instead: + + (define-syntax foo + (syntax-rules () + ((_ bar) (helper bar)))) + +** Guile's psyntax now supports docstrings and internal definitions. + +The following Scheme is not strictly legal: + + (define (foo) + "bar" + (define (baz) ...) + (baz)) + +However its intent is fairly clear. Guile interprets "bar" to be the +docstring of `foo', and the definition of `baz' is still in definition +context. + +** Macros need to be defined before their first use. + +It used to be that with lazy memoization, this might work: + + (define (foo x) + (ref x)) + (define-macro (ref x) x) + (foo 1) => 1 + +But now, the body of `foo' is interpreted to mean a call to the toplevel +`ref' function, instead of a macro expansion. The solution is to define +macros before code that uses them. + +** Functions needed by macros at expand-time need to be present at + expand-time. + +For example, this code will work at the REPL: + + (define (double-helper x) (* x x)) + (define-macro (double-literal x) (double-helper x)) + (double-literal 2) => 4 + +But it will not work when a file is compiled, because the definition of +`double-helper' is not present at expand-time. The solution is to wrap +the definition of `double-helper' in `eval-when': + + (eval-when (load compile eval) + (define (double-helper x) (* x x))) + (define-macro (double-literal x) (double-helper x)) + (double-literal 2) => 4 + +See the (currently missing) documentation for eval-when for more +information. + +** New variable, %pre-modules-transformer + +Need to document this one some more. + +** Temporarily removed functions: `macroexpand', `macroexpand-1' + +`macroexpand' will be added back before 2.0. It is unclear how to +implement `macroexpand-1' with syntax-case, though PLT Scheme does prove +that it is possible. + +** New reader macros: #' #` #, #,@ + +These macros translate, respectively, to `syntax', `quasisyntax', +`unsyntax', and `unsyntax-splicing'. See the R6RS for more information. +These reader macros may be overridden by `read-hash-extend'. + +** Incompatible change to #' + +Guile did have a #' hash-extension, by default, which just returned the +subsequent datum: #'foo => foo. In the unlikely event that anyone +actually used this, this behavior may be reinstated via the +`read-hash-extend' mechanism. + +** Scheme expresssions may be commented out with #; + +#; comments out an entire expression. See SRFI-62 or the R6RS for more +information. + +** `make-stack' with a tail-called procedural narrowing argument no longer + works (with compiled procedures) + +It used to be the case that a captured stack could be narrowed to select +calls only up to or from a certain procedure, even if that procedure +already tail-called another procedure. This was because the debug +information from the original procedure was kept on the stack. + +Now with the new compiler, the stack only contains active frames from +the current continuation. A narrow to a procedure that is not in the +stack will result in an empty stack. To fix this, narrow to a procedure +that is active in the current continuation, or narrow to a specific +number of stack frames. + +** backtraces through compiled procedures only show procedures that are + active in the current continuation + +Similarly to the previous issue, backtraces in compiled code may be +different from backtraces in interpreted code. There are no semantic +differences, however. Please mail bug-guile@gnu.org if you see any +deficiencies with Guile's backtraces. + +** syntax-rules and syntax-case macros now propagate source information + through to the expanded code + +This should result in better backtraces. + +** The currying behavior of `define' has been removed. + +Before, `(define ((f a) b) (* a b))' would translate to + + (define f (lambda (a) (lambda (b) (* a b)))) + +Now a syntax error is signaled, as this syntax is not supported by +default. If there is sufficient demand, this syntax can be supported +again by default. + +** All modules have names now + +Before, you could have anonymous modules: modules without names. Now, +because of hygiene and macros, all modules have names. If a module was +created without a name, the first time `module-name' is called on it, a +fresh name will be lazily generated for it. + +** Many syntax errors have different texts now + +Syntax errors still throw to the `syntax-error' key, but the arguments +are often different now. Perhaps in the future, Guile will switch to +using standard SRFI-35 conditions. + +** Returning multiple values to compiled code will silently truncate the + values to the expected number + +For example, the interpreter would raise an error evaluating the form, +`(+ (values 1 2) (values 3 4))', because it would see the operands as +being two compound "values" objects, to which `+' does not apply. + +The compiler, on the other hand, receives multiple values on the stack, +not as a compound object. Given that it must check the number of values +anyway, if too many values are provided for a continuation, it chooses +to truncate those values, effectively evaluating `(+ 1 3)' instead. + +The idea is that the semantics that the compiler implements is more +intuitive, and the use of the interpreter will fade out with time. +This behavior is allowed both by the R5RS and the R6RS. + +** Multiple values in compiled code are not represented by compound + objects + +This change may manifest itself in the following situation: + + (let ((val (foo))) (do-something) val) + +In the interpreter, if `foo' returns multiple values, multiple values +are produced from the `let' expression. In the compiler, those values +are truncated to the first value, and that first value is returned. In +the compiler, if `foo' returns no values, an error will be raised, while +the interpreter would proceed. + +Both of these behaviors are allowed by R5RS and R6RS. The compiler's +behavior is more correct, however. If you wish to preserve a potentially +multiply-valued return, you will need to set up a multiple-value +continuation, using `call-with-values'. + +** Defmacros are now implemented in terms of syntax-case. + +The practical ramification of this is that the `defmacro?' predicate has +been removed, along with `defmacro-transformer', `macro-table', +`xformer-table', `assert-defmacro?!', `set-defmacro-transformer!' and +`defmacro:transformer'. This is because defmacros are simply macros. If +any of these procedures provided useful facilities to you, we encourage +you to contact the Guile developers. + +** psyntax is now the default expander + +Scheme code is now expanded by default by the psyntax hygienic macro +expander. Expansion is performed completely before compilation or +interpretation. + +Notably, syntax errors will be signalled before interpretation begins. +In the past, many syntax errors were only detected at runtime if the +code in question was memoized. + +As part of its expansion, psyntax renames all lexically-bound +identifiers. Original identifier names are preserved and given to the +compiler, but the interpreter will see the renamed variables, e.g., +`x432' instead of `x'. + +Note that the psyntax that Guile uses is a fork, as Guile already had +modules before incompatible modules were added to psyntax -- about 10 +years ago! Thus there are surely a number of bugs that have been fixed +in psyntax since then. If you find one, please notify bug-guile@gnu.org. + +** syntax-rules and syntax-case are available by default. + +There is no longer any need to import the `(ice-9 syncase)' module +(which is now deprecated). The expander may be invoked directly via +`sc-expand', though it is normally searched for via the current module +transformer. + +Also, the helper routines for syntax-case are available in the default +environment as well: `syntax->datum', `datum->syntax', +`bound-identifier=?', `free-identifier=?', `generate-temporaries', +`identifier?', and `syntax-violation'. See the R6RS for documentation. + +** Lexical bindings introduced by hygienic macros may not be referenced + by nonhygienic macros. + +If a lexical binding is introduced by a hygienic macro, it may not be +referenced by a nonhygienic macro. For example, this works: + + (let () + (define-macro (bind-x val body) + `(let ((x ,val)) ,body)) + (define-macro (ref x) + x) + (bind-x 10 (ref x))) + +But this does not: + + (let () + (define-syntax bind-x + (syntax-rules () + ((_ val body) (let ((x val)) body)))) + (define-macro (ref x) + x) + (bind-x 10 (ref x))) + +It is not normal to run into this situation with existing code. However, +as code is ported over from defmacros to syntax-case, it is possible to +run into situations like this. In the future, Guile will probably port +its `while' macro to syntax-case, which makes this issue one to know +about. + +** Macros may no longer be referenced as first-class values. + +In the past, you could evaluate e.g. `if', and get its macro value. Now, +expanding this form raises a syntax error. + +Macros still /exist/ as first-class values, but they must be +/referenced/ via the module system, e.g. `(module-ref (current-module) +'if)'. + +This decision may be revisited before the 2.0 release. Feedback welcome +to guile-devel@gnu.org (subscription required) or bug-guile@gnu.org (no +subscription required). + +** `case-lambda' is now available in the default environment. + +The binding in the default environment is equivalent to the one from the +`(srfi srfi-16)' module. Use the srfi-16 module explicitly if you wish +to maintain compatibility with Guile 1.8 and earlier. + +** `lambda*' and `define*' are now available in the default environment + +As with `case-lambda', `(ice-9 optargs)' continues to be supported, for +compatibility purposes. No semantic change has been made (we hope). +Optional and keyword arguments now dispatch via special VM operations, +without the need to cons rest arguments, making them very fast. + +** New syntax: include-from-path. + +`include-from-path' is like `include', except it looks for its file in +the load path. It can be used to compile other files into a file. + +** New syntax: quasisyntax. + +`quasisyntax' is to `syntax' as `quasiquote' is to `quote'. See the R6RS +documentation for more information. Thanks to Andre van Tonder for the +implementation. + +** Unicode characters + +Unicode characters may be entered in octal format via e.g. `#\454', or +created via (integer->char 300). A hex external representation will +probably be introduced at some point. + +** Unicode strings + +Internally, strings are now represented either in the `latin-1' +encoding, one byte per character, or in UTF-32, with four bytes per +character. Strings manage their own allocation, switching if needed. + +Extended characters may be written in a literal string using the +hexadecimal escapes `\xXX', `\uXXXX', or `\UXXXXXX', for 8-bit, 16-bit, +or 24-bit codepoints, respectively, or entered directly in the native +encoding of the port on which the string is read. + +** Unicode symbols + +One may now use U+03BB (GREEK SMALL LETTER LAMBDA) as an identifier. + +** Support for non-ASCII source code files + +The default reader now handles source code files for some of the +non-ASCII character encodings, such as UTF-8. A non-ASCII source file +should have an encoding declaration near the top of the file. Also, +there is a new function, `file-encoding', that scans a port for a coding +declaration. See the section of the manual entitled, "Character Encoding +of Source Files". + +The pre-1.9.3 reader handled 8-bit clean but otherwise unspecified source +code. This use is now discouraged. + +** Support for locale transcoding when reading from and writing to ports + +Ports now have an associated character encoding, and port read and write +operations do conversion to and from locales automatically. Ports also +have an associated strategy for how to deal with locale conversion +failures. + +See the documentation in the manual for the four new support functions, +`set-port-encoding!', `port-encoding', `set-port-conversion-strategy!', +and `port-conversion-strategy'. + +** String and SRFI-13 functions can operate on Unicode strings + +** Unicode support for SRFI-14 character sets + +The default character sets are no longer locale dependent and contain +characters from the whole Unicode range. There is a new predefined +character set, `char-set:designated', which contains all assigned +Unicode characters. There is a new debugging function, `%char-set-dump'. + +** Character functions operate on Unicode characters + +`char-upcase' and `char-downcase' use default Unicode casing rules. +Character comparisons such as `charuniform-array, list->uniform-array, array-prototype + +Instead, use make-typed-array, list->typed-array, or array-type, +respectively. + +** Last but not least, the `λ' macro can be used in lieu of `lambda' + * Changes to the C interface +** Guile now uses libgc, the Boehm-Demers-Weiser garbage collector + +The semantics of `scm_gc_malloc ()' have been changed, in a +backward-compatible way. A new allocation routine, +`scm_gc_malloc_pointerless ()', was added. + +Libgc is a conservative GC, which we hope will make interaction with C +code easier and less error-prone. + +** The GH interface (deprecated in version 1.6, 2001) was removed. + ** Internal `scm_i_' functions now have "hidden" linkage with GCC/ELF This makes these internal functions technically not callable from @@ -40,6 +856,145 @@ application code. ** Functions for handling `scm_option' now no longer require an argument indicating length of the `scm_t_option' array. +** scm_primitive_load_path has additional argument, exception_on_error + +** New C function: scm_module_public_interface + +This procedure corresponds to Scheme's `module-public-interface'. + +** Inline vector allocation + +Instead of having vectors point out into the heap for their data, their +data is now allocated inline to the vector object itself. The same is +true for bytevectors, by default, though there is an indirection +available which should allow for making a bytevector from an existing +memory region. + +** Removal of Guile's primitive object system. + +There were a number of pieces in `objects.[ch]' that tried to be a +minimal object system, but were never documented, and were quickly +obseleted by GOOPS' merge into Guile proper. So `scm_make_class_object', +`scm_make_subclass_object', `scm_metaclass_standard', and like symbols +from objects.h are no more. In the very unlikely case in which these +were useful to you, we urge you to contact guile-devel. + +** No future. + +Actually the future is still in the state that it was, is, and ever +shall be, Amen, except that `futures.c' and `futures.h' are no longer a +part of it. These files were experimental, never compiled, and would be +better implemented in Scheme anyway. In the future, that is. + +** Support for static allocation of strings, symbols, and subrs. + +Calls to snarfing CPP macros like SCM_DEFINE macro will now allocate +much of their associated data as static variables, reducing Guile's +memory footprint. + +** `scm_stat' has an additional argument, `exception_on_error' +** `scm_primitive_load_path' has an additional argument `exception_on_not_found' + +** `scm_set_port_seek' and `scm_set_port_truncate' use the `scm_t_off' type + +Previously they would use the `off_t' type, which is fragile since its +definition depends on the application's value for `_FILE_OFFSET_BITS'. + +** The `long_long' C type, deprecated in 1.8, has been removed + +** Removed deprecated uniform array procedures: scm_make_uve, + scm_array_prototype, scm_list_to_uniform_array, + scm_dimensions_to_uniform_array, scm_make_ra, scm_shap2ra, scm_cvref, + scm_ra_set_contp, scm_aind, scm_raprin1 + +These functions have been deprecated since early 2005. + +* Changes to the distribution + +** Guile's license is now LGPLv3+ + +In other words the GNU Lesser General Public License, version 3 or +later (at the discretion of each person that chooses to redistribute +part of Guile). + +** GOOPS documentation folded into Guile reference manual + +GOOPS, Guile's object system, used to be documented in separate manuals. +This content is now included in Guile's manual directly. + +** `guile-config' will be deprecated in favor of `pkg-config' + +`guile-config' has been rewritten to get its information from +`pkg-config', so this should be a transparent change. Note however that +guile.m4 has yet to be modified to call pkg-config instead of +guile-config. + +** Guile now provides `guile-2.0.pc' instead of `guile-1.8.pc' + +Programs that use `pkg-config' to find Guile or one of its Autoconf +macros should now require `guile-2.0' instead of `guile-1.8'. + +** New installation directory: $(pkglibdir)/1.9/ccache + +If $(libdir) is /usr/lib, for example, Guile will install its .go files +to /usr/lib/guile/1.9/ccache. These files are architecture-specific. + +** Dynamically loadable extensions may be placed in a Guile-specific path + +Before, Guile only searched the system library paths for extensions +(e.g. /usr/lib), which meant that the names of Guile extensions had to +be globally unique. Installing them to a Guile-specific extensions +directory is cleaner. Use `pkg-config --variable=extensionsdir +guile-2.0' to get the location of the extensions directory. + +** New dependency: libgc + +See http://www.hpl.hp.com/personal/Hans_Boehm/gc/, for more information. + +** New dependency: GNU libunistring + +See http://www.gnu.org/software/libunistring/, for more information. Our +Unicode support uses routines from libunistring. + + + +Changes in 1.8.8 (since 1.8.7) + +* Bugs fixed + +** Fix possible buffer overruns when parsing numbers +** Avoid clash with system setjmp/longjmp on IA64 +** Fix `wrong type arg' exceptions with IPv6 addresses + + +Changes in 1.8.7 (since 1.8.6) + +* New modules (see the manual for details) + +** `(srfi srfi-98)', an interface to access environment variables + +* Bugs fixed + +** Fix compilation with `--disable-deprecated' +** Fix %fast-slot-ref/set!, to avoid possible segmentation fault +** Fix MinGW build problem caused by HAVE_STRUCT_TIMESPEC confusion +** Fix build problem when scm_t_timespec is different from struct timespec +** Fix build when compiled with -Wundef -Werror +** More build fixes for `alphaev56-dec-osf5.1b' (Tru64) +** Build fixes for `powerpc-ibm-aix5.3.0.0' (AIX 5.3) +** With GCC, always compile with `-mieee' on `alpha*' and `sh*' +** Better diagnose broken `(strftime "%z" ...)' in `time.test' (bug #24130) +** Fix parsing of SRFI-88/postfix keywords longer than 128 characters +** Fix reading of complex numbers where both parts are inexact decimals + +** Allow @ macro to work with (ice-9 syncase) + +Previously, use of the @ macro in a module whose code is being +transformed by (ice-9 syncase) would cause an "Invalid syntax" error. +Now it works as you would expect (giving the value of the specified +module binding). + +** Have `scm_take_locale_symbol ()' return an interned symbol (bug #25865) Changes in 1.8.6 (since 1.8.5) @@ -54,6 +1009,8 @@ When you use GDS to evaluate Scheme code from Emacs, you can now use `C-u' to indicate that you want to single step through that code. See `Evaluating Scheme Code' in the manual for more details. +** New "guile(1)" man page! + * Changes to the distribution ** Automake's `AM_MAINTAINER_MODE' is no longer used @@ -61,16 +1018,34 @@ When you use GDS to evaluate Scheme code from Emacs, you can now use Thus, the `--enable-maintainer-mode' configure option is no longer available: Guile is now always configured in "maintainer mode". +** `ChangeLog' files are no longer updated + +Instead, changes are detailed in the version control system's logs. See +the top-level `ChangeLog' files for details. + + * Bugs fixed +** `symbol->string' now returns a read-only string, as per R5RS +** Fix incorrect handling of the FLAGS argument of `fold-matches' ** `guile-config link' now prints `-L$libdir' before `-lguile' ** Fix memory corruption involving GOOPS' `class-redefinition' ** Fix possible deadlock in `mutex-lock' ** Fix build issue on Tru64 and ia64-hp-hpux11.23 (`SCM_UNPACK' macro) ** Fix build issue on mips, mipsel, powerpc and ia64 (stack direction) ** Fix build issue on hppa2.0w-hp-hpux11.11 (`dirent64' and `readdir64_r') +** Fix build issue on i386-unknown-freebsd7.0 ("break strict-aliasing rules") ** Fix misleading output from `(help rationalize)' ** Fix build failure on Debian hppa architecture (bad stack growth detection) +** Fix `gcd' when called with a single, negative argument. +** Fix `Stack overflow' errors seen when building on some platforms +** Fix bug when `scm_with_guile ()' was called several times from the + same thread +** The handler of SRFI-34 `with-exception-handler' is now invoked in the + dynamic environment of the call to `raise' +** Fix potential deadlock in `make-struct' +** Fix compilation problem with libltdl from Libtool 2.2.x +** Fix sloppy bound checking in `string-{ref,set!}' with the empty string Changes in 1.8.5 (since 1.8.4) @@ -139,13 +1114,6 @@ lead to a stack overflow. ** Fixed shadowing of libc's on Tru64, which broke compilation ** Make sure all tests honor `$TMPDIR' -* Changes to the distribution - -** New FAQ - -We've started collecting Frequently Asked Questions (FAQ), and will -distribute these (with answers!) in future Guile releases. - Changes in 1.8.4 (since 1.8.3) @@ -223,7 +1191,6 @@ Changes in 1.8.3 (since 1.8.2) ** The reader is now faster, which reduces startup time ** Procedures returned by `record-accessor' and `record-modifier' are faster - Changes in 1.8.2 (since 1.8.1): @@ -232,6 +1199,16 @@ Changes in 1.8.2 (since 1.8.1): ** set-program-arguments ** make-vtable +* Incompatible changes + +** The body of a top-level `define' no longer sees the binding being created + +In a top-level `define', the binding being created is no longer visible +from the `define' body. This breaks code like +"(define foo (begin (set! foo 1) (+ foo 1)))", where `foo' is now +unbound in the body. However, such code was not R5RS-compliant anyway, +per Section 5.2.1. + * Bugs fixed ** Fractions were not `equal?' if stored in unreduced form. @@ -276,8 +1253,6 @@ Changes in 1.8.1 (since 1.8.0): ** scm_exp - [C] ** scm_sqrt - [C] -* New `(ice-9 i18n)' module (see the manual for details) - * Bugs fixed ** Build problems have been fixed on MacOS, SunOS, and QNX.