Home | Features | Download | Extensions | Document | Development -> Japanese | -> Practical Scheme

Older News


Gauche - minor bug fixes

Several bug fixes since, plus a couple of improvements. I made a new package since one bug caused build problems in certain settings, and having a fixed tarball saved lots of troubles.

  • Bug fixes:
    • If DESTDIR was set and the platform didn't have previous Gauche installed, make install failed saying something like "libgauche-0.9.so.0.3: cannot open shared object file: No such file or directory". The order of installation was adjusted to avoid it.
    • On FreeBSD, a bug in signal setup routine caused memory corruption.
    • every with more than one argument list didn't return the last return value of the predicate when all the arguments satisfied it, as specified in srfi-1 (it returned #t instead). It was also the case in stream-every. Both are fixed.
    • On MinGW, info command didn't work.
    • On MinGW, when you used non-console version gosh-noconsole.exe and tried to spawn a child process to communicate via pipes, gosh-noconsole.exe just died.
  • Improvements:
    • New procedure: string-scan-right
    • GC is now 7.2b


A documentation build problem was found when Gauche was configured to use native encoding other than utf-8. A follow-up release ( is put on the server. If you want to use Gauche wiht non-default encoding, grab the new release. You don't need to update as far as compiling with utf-8.


On Windows/MinGW, 0.9.3 release version had a problem to compile git HEAD version of Gauche. A fixed version ( is prepared. This problem won't affect other platforms.


Gauche 0.9.3

  • New Features
    • Lazy sequences: An efficient and seamless support of mixing lazy evaluation with ordinary list procedures. Forcing delayed evaluation is implicit, so you can pass lazy list to normal list procedures such as car or fold. See the manual entry for the details and examples.
    • gauche.generator: A general utilities for generators, a thunk that generates a value every time it is called. Lazy sequences are built on top of generators. See the manual entry for the details.
    • Threads are now supported on Windows/MinGW build. It is directly based on Win32 thread API instead of pthreads; but Scheme-level semantics are almost the same. The cond-expand conditions are slightly modified to accomodate both thread models--- see Threads for the details.
    • add-load-path macro now accepts an optional argument to make the given path relative to the currently loaded file. This is useful to distribute a script accompanied with library files; for example, specify (add-load-path "." :relative) in the script makes the library files searched from the same directory where the script exists. Then users can just copy the directory to anywhere and run the script.
    • A chained-application macro $: Incorporated the feature which has been experimented as gauche.experimental.app. This macro allows (f a b (g c d (h i j))) to be written as ($ f a b $ g c d $ h i j). Although it is slighly longer, it is sometimes work better with indentation of deeply nested function calls. See the manual entry for the full explanation.
    • A new gosh option -m module allows the main procedure to be searched in the specified module instead of the default user module. This allows a Scheme file to work both as a library module and an executable scripts (e.g. for running tests or demos); name the test program main but not export it, and it won't affect ordinary module users, but you can test the module by using -m option.
  • Incompatibile Changes
    • util.queue: Thread-safe queue can now be created with zero max-length, which is handy as a synchronization device. This is an incompatible change---previously, specyfing zero to :max-length means unlimited queue length. (Cf: Queue of zero length).
    • Fixed a regexp bug in treatment of BOL/EOL assertions (^, $) within the assetion blocks such as (?=...). Regarding BOL/EOL assertions, these assertion blocks are treated as if they're stand-alone. The fixed behavior is now compatible with Perl and Oniguruma. The code that counted on the previous (buggy) behavior may break by this change.
    • Removed gauche.auxsys module. This module contained several less-used system procedures; now they are in the core. The module was autoloaded, so not many code should be affected by this change. Only the code that explicitly refer to this module needs to be changed.
  • Improvements
    • Many frequently-used list procedures (all of util.list, and some of srfi-1) are now included in the core. The module util.list is no longer needed, although it is kept just for the backward compatibility. From srfi-1, the following procedures are now in the core: null-list?, cons*, last, member (extended one), take, drop, take-right, drop-right, take!, drop-right!, delete, delete!, delete-duplicates, delete-duplicates!, assoc (extended one), alist-copy, alist-delete, alist-delete!, any, every, filter, filter!, remove, remove!, filter-map, fold, fold-right, find, find-tail, split-at, split-at!, iota.
    • New macros and procedures: values->list, fold-left, regexp-num-groups, regexp-named-groups.
    • New procedure applicable? can be used to check object's applicability finer than procedure?. Related, a special class <bottom> is added, which behaves as a subtype of any classes.
    • Build process is overhauled to allow out-of-source-tree build.
    • Regular expression engine is slightly improved. For example, it now calculates the set of characters that can be a beginning of a part of regexp, and uses it to skip the input efficiently.
    • thread-terminate! now attempts to terminate the target thread gracefully, and only tries the forceful means when the gracefull termination fails.
    • open-input-file now accepts :encoding #t argument, which tells the procedure to use a coding-aware port. That is, it can recognize coding: ... specification in the beginning of the file. Useful to process source files.
    • map is now restart-safe, that is, saving continuations in middle of mapping and restarting it doesn't affect previous results. This is required in R6RS.
    • Various small improvements in the compiler and VM stack layout.
    • gauche.test: test-module now checks the number of arguments given to the global procedures. This is useful to catch careless mistakes. In rare cases that you do intend to pass number of arguments incompatible to the normal usage of the procedures, list such procedures in :bypass-arity-check keyword argument (It is possible because of the dynamic nature of the language---methods of a different signature may be added later, for example).
    • gauche.test: test-end has a keyword argument to exit with non-zero status if test failed. New function test-summary-check exits with non-zero status when the test record file indicates there have been failures. Both are useful to propagate test failure to upper levels such as continuous integration server.
    • srfi-42: Support :generator qualifier to allow using generator procedures in a sense of gauche.generator.
    • file.util: touch-file and touch-files takes various keyword arguments similar to touch(1) command.
    • rfc.http: A new parameter http-proxy allows to set the default http proxy. The https connection now uses a library bundled to Gauche, no longer requires external stunnel command.
    • GC is bumped to bdwgc 7.2-alpha6.
  • Bux fixes
    • Fixed an incorrect rounding bug when inexact numbers were given to div and mod.
    • Fixed another division bug in /., when both dividend and divisor are too big to be represented by floating-point numbers.
    • In quasiquote expander, unquote and unquote-splicing are recognized hygienically.
    • force is now thread-safe.
    • Fixed some MT-hazards in file loading/requiring. Thanks to Kirill Zorin for tracking those hard-to-find bugs.
    • Fixed a bug that made (regexp-compile '(alt)) Bus Error.
    • Fixed another regexp bug that didn't handle case-folding match beyond ASCII range. Patch from OOHASHI Daichi.
    • gauche.parameter: Accessing parameters created in unrelated threads used to raise an error. It was annoying, since such situation could occur inadvertently when autoload is involved. Now the parameters work regardless of where they are created.
    • rfc.json: Fixed a bug that produced incorrect JSON.
    • rfc.http: Fixed the behavior of redirection for 3xx responses. You can also customize the behavior.
    • gauche.threads: Fixed a bug in thread-sleep! when passed an exact rational number.
    • util.stream: stream-count didn't work.


Gauche 0.9.2 and Gauche-gl 0.5.1 are released.

Gauche 0.9.2:

  • New Features
    • Case mapping and character properties are fully supported, compatible to R6RS and R7RS draft (both based on Unicode standard). Character-wise case mapping (char-upcase etc.) and property queries (char-alphabetic?, char-general-category, etc.) are built-in. Context-aware string case mapping (string-upcase etc.) is provided in the new text.unicode module. (Note: srfi-13's string-upcase etc. are unchanged; they are defined to use simple case mappings.) The text.unicode module also provides conversion between utf-8/utf-16 and Unicode codepoints.
    • Windows binary distribution is now in MS installer (*.msi) format, created with WiX. It's safer than the previous *.exe format created by NSIS, which had a bug that smashes PATH settings when it is too long.
    • A convenient wrapper for atomic execution is added in gauche.threads. See this intro post.
    • Benchmarking utilities resembles to Perl's Benchmark module is now available in gauche.time. See this post for an introduction.
    • with-lock-file: A long-awaited feature to use lock files conveniently. It is in file.util module.
    • Added full support of srfi-60, integer bitwise operations.
    • gauche.cgen: Some API that Gauche uses to generate C code become public. See the manual for the details.
  • Incompatibile Changes
    • control.thread-pool: add-job! now takes timeout argument. If it is omitted and the job queue is full, add-job! blocks. It is a change from 0.9.1, in which add-job! returns immediately in such case. To get the same behavior, pass 0 explicitly to the timeout argument. The argument order of wait-all is also changed to take timeout optional argument first. In 0.9.1 it never timeouts.
    • If --enable-multibyte flag is given to ./configure without explicit encoding, we now assume utf-8. It used to be euc-jp. This is for the consistency. We don't think this change affects many, for the document has always been told to give explicit encoding name for this option.
    • The --enable-ipv6 configure option is turned on by default. It shouldn't cause problems on modern OSes. If you ever get a compile error in gauche.net module on a platform that lacks modern API, specify --disable-ipv6 option to ./configure.
    • (This is an internal change of undocumented feature. We mention it just in case if some extension packages depend on this.) In the initialization code generated by genstub or precomp, it used to be possible to refer to the current module by mod. Now you should use Scm_CurrentModule() instead. Also, gauche.cgen.unit now doesn't include <gauche.h> automatically.
  • Improvements
    • The compiler is improved to avoid creating a closure at execution time when it doesn't close local environment. For example, (map (^x (* x x)) lis) doesn't create a closure; instead, the internal lambda is compiled as if it is a toplevel-defined procedure. (Yeah, it's a simple lambda lifting. We didn't do it since it could slow down the compiler. Now the compiler is efficient enough to handle it.)
    • Supports zero or multi-argument unquote/unquote-splicing, as defined in R6RS.
    • sys-exec and sys-fork-and-exec now supports :detached keyword argument to make the child process detached from the parent's process group.
    • Buliltin reverse and reverse! takes optional list-tail argument.
    • A new builtin procedure map* that can deal with dotted list.
    • Common Lisp-like ecase macro is added.
    • The extended lambda formals (:key, :optional, etc) are now available in define-method as well.
    • New built-in function sys-clearenv, useful to fork subprocess securely.
    • rxmatch-case accepts (else => proc) form, just like case.
    • Socket address objects (e.g. <sockaddr-un>) can now be compared by equal? based on its content. Useful to put them in a hashtable, for example.
    • gauche.uvector: A new procedure uvector-copy! that can copy any type of uvectors.
    • gauche.test: A new test expected result constructor test-one-of allows to check if the test result matches any one of possible outcomes.
    • control.thread-pool: Now a pool raises <thread-pool-shut-down> condition if the pool has already be shut down and no longer accepting new jobs. terminate-all now takes :cancel-queued-jobs keyword argument to stop the pool immediately, instead of waiting for all the jobs to be finished. Canceled jobs are marked as killed. New APIs: thread-pool-results, thread-pool-shut-down?.
    • rfc.json: Allow construct-json to take optional output port for the consistency.
    • rfc.uri: A new procedure uri-merge that can be resolve a relative uri in regart to a base uri.
    • rfc.cookie: Recognize :http-only cookie attribute introduced in RFC6265.
    • Now the tilde `~' expansion of sys-normalize-pathname works on Windows as well to refer to the current user's home directory; it tries environment variables heuristically to find it. To refer to other user's home directory by ~user is still only available on Unix platforms, though.
    • util.combinations: combinations is optimized to handle leaf cases efficiently.
  • Bux fixes
    • Fixed a bug that the number parser hangs when reading 2.2250738585072012e-308.
    • Integer multiplication routine had a code that depended on undefined behavior of C; it worked on gcc but revealed the bug on clang-llvm.
    • Fixed a module bug on the visibility of bindings of extended modules.
    • gauche.parameter: Fixed a couple of bugs on parameter objects.
    • Numeric comparison procedures such as < didn't work correctly when more than four arguments were given. The bug was introduced by incorrect optimization.
    • Fixed bugs in lognot, logand, logior and logxor, which crashed when non-integer ratinoal numbers are passed.
    • port->string, port->string-list: These procedures returned prematurely when the input contains an illegal byte sequence for internal encoding. Now they return an incomplete string instead.
    • srfi-1: Some srfi-1 procedures that are built-in were not exported, causing errors when you wanted to import them selectively, e.g. (use srfi-1 :only (fold)).
    • util.queue: Fixed list->queue to work.
    • binary.pack: Fixed a bug that the result may be truncated if the input contains byte sequences that can be interpreted as invalid character multibyte sequences.
    • srfi-42: Fixed a hygiene bug; the previous versions failed when only toplevel macros are imported using :only import option.
    • rfc.json: Fixed a bug that didn't escape double-quotes in the string, and didn't handle empty array.
    • Coding-aware ports didn't count lines correctly in CR-only or CRLF line endings.
    • Fixed a problem that caused crash after changing metaclasses of a class metaobject. An additional protection mechanism is in place in the class metaobject so that it won't be in an inconsistent state unexpectedly.
    • Fixed sys-setenv in which you couldn't omit the overwrite argument, even if it was described optional.
    • Fixed build problem of gauche.net on Solaris.
    • Fixed a bug in gauche-package that caused an error when *load-path* contained a nonexistent path.
    • Fixed a bug in string comparison routine that surfaces in a special architecture.
    • The printed output of <time> was incorrect when its value was negative.
    • There was a bug in the reader it reads ().() incorrectly.
    • Fixed a bug in format to allow ~* to position after the last argument.
    • Fixed GC compliation problem on OSX Lion.

Gauche-gl 0.5.1: Small change to make it compile with Gauche 0.9.2.


We switched the developement repository from Subversion to Git. See Download for instructions to check out or browse.


It is reported that the Windows installer could smash the value of PATH, if adding the Gauche's path resulted the length of PATH to exceed a certain limit (it appears to be a known problem of NSIS, see a similar incindent in Winamp forum.) If your PATH is already close to about 1000 character long, please refrain from using the current Gauche-mingw-0.9.1.exe. We're looking at possible fixes.


We found a bug in gauche-config that can affect installation of extension packages. The 0.9.1 release has been replaced with the fix. Please check the md5sum of the packages if you've already downloaded them.

  6134e9c16aef2bc9fd3fa7e8fbebdd10  Gauche-0.9.1.tgz
  dce3a5f438506bfcbb63687e2debdeb1  Gauche-mingw-0.9.1.exe


Gauche 0.9.1: Major Feature Enhancements

  • New Features
    • Extended formals: Built-in lambda, define etc. can recognize optional and keyword arguments, a la Common Lisp. For example, you can now write
       (define (foo x :optional (y 0) (z 2)) ...)
      instead of
       (define (foo x . args)
         (let-optionals* args ((y 0) (z 2)) ...))      
      See the manual entry of lambda for the details. If you're writing a portable program and don't want to use this extended syntax accidentally, use syntactic bindings provided in the scheme module instead gauche module; syntactic keywords provided in the former raise an error if extended formals are used. See Extended formals about this decision. (Note: Currently define-method does not support extended formals due to a small technical obstacle. It should be addressed soon.)
    • Enhanced module mechanism: Now you can rename, choose, or add prefix to the symbols when importing other modules. See the "Using modules" section of the manual for the details. For the design decisions and implemtation details, see Import options: part one and Import options: part two.
    • Efficient record types: A new module gauche.record provides ERR5RS (srfi-99) compatible record types. It is also upper compatible to srfi-9 records. (cf. ERR5RS records and beyond).
    • More support for multithreaded applications: Thread-safe queue is added to util.queue (cf. Enhanced queue), and thread-pool feature is provided by the new module control.thread-pool. Continuations can be passed between threads; see below.
    • Partial continuations: Partial (delimited) continuations are supported natively in gauche.partcont module. Also, a (full or partial) continuation captured in one thread can now be invoked by different thread. If it is a full continuation, an error is thrown if the continuation tries to return to the original thread context. (cf. Partial continuations and a fun of stack fiddling).
    • Enhanced Windows support: On MinGW/MSYS build, non-console executable gosh-noconsole.exe is built as well as the ordinary gosh.exe. The former can be used to run Gauche scripts on Windows without creating a console window. If you install Gauche with the Windows binary installer, *.scm files will be associated with gosh-noconsole.exe. Windows binary installer also includes Gauche-gl by default. You can find some examples in C:\Program Files\Gauche\examples after installation. The os.windows module is added to provide Windows-specific interface. Currently it has MessageBox and Windows Console API (which was in gauche.termios before, but moved to os.windows). gauche-package compile is modified to work better on MinGW/MSYS environment. The directory argument for run-process (gauche.process) now works on Windows.
    • New module: crypt.bcrypt: A module for Blowfish password hashing.
    • New module: srfi-98: portable environment variable lookup support.
    • New module: gauche.mop.propagate: Making object composition simpler.
    • New module: rfc.json: JSON parsing and construction.
  • Changes
    • The directory structure for Gauche installation has changed so that we can keep binary compatibility for the extension modules throughout 0.9.x releases. See New directory structure for the details. The extension libraries you've installed for Gauche 0.9 should keep working without recompilation and reinstallation.
    • Now it is an error to pass a keyword argument that isn't expected by the callee. It used to be a warning.
    • Regular expression re{,M} now means the same as re{0,M}, which is compatible to Oniguruma. Note: It used to be comatible to Perl, that is, re{,M} didn't have special meaning and matched the string literally. Now it should be written as re\{,M} to mean the literal sequence of an open brace, comma, number and a close brace.
  • Improvements
    • The compiler and the runtime got optimized more. The compiler now knows more about built-in procedures, and tries compile-time constant folding and/or inlining more aggressively (cf. Some improvements of constant propagation). For example, sxml.ssax can parse XML document a lot faster.
    • ^ can be used in place of lambda, allowing more concise code. There's also convenience macros ^a, ^b, ... ^z and ^_ as abbreviations of lambda (a) etc. (cf. Shorter names)
    • ~ is added for universal accessing operator. (~ x y) is the same as (ref x y), and (~ x y z) is the same as (ref (ref x y) z), and so on. It can be used with generalized setter, e.g. (set! (~ array i) x). See "Universal accessor" section of the manual for more details.
    • define-syntax, let-syntax, and letrec-syntax are enhanced so that they can take a general expression in rhs, as far as it yields a syntactic transformer. This is a preparation to support different kind of macro transformers other than syntax-rules, although such alternative transformers are yet to be implemented. Cf. Supporting general transformers: Step 1.
    • gauche.process: I/O redirection handling in run-process becomes more flexible. Cf. More control on redirection in run-process.
    • rfc.http module now supports https connection (unix platforms only). Currently it relies on an external program (stunnel).
    • A new procedure current-load-path allows the program to know the file name it is being loaded from.
    • A new procedure .$ is introduced as an alternative name of compose.
    • Regular expressions now got read-write invariance. Some internal regexp routines are made public, giving users an easy way to construct and analyze regexp programatically. See the "Inspecting and assembling regular expressions" section of the manual. See also Regexp read-write invariance.
    • rfc.822: New procedure: rfc822-date->date.
    • file.util: The procedure temporary-directory now became a parameter so that you can switch it when necessary. The default value is taken from (sys-tmpdir), which determines temporary directory in the recommended way of the platform; esp., it works on Windows native platforms. home-directory works on Windows, too. Procedures null-device and console-device are added to make it easier to write portable script across Unix and Windows platforms.
    • util.queue: New proceduers: any-in-queue, every-in-queue.
    • gauche.parseopt: When let-args encounters a command-line option that doesn't match any spec, it now raises a condition of type <parseopt-error> instead of <error>. The application can capture the condition to handle invalid command-line arguments.
    • gauche.uvector: New procedure uvector-size to obtain number of octets actually to be written out when the given uvector is written out by write-block.
    • dbm: A new procedure dbm-type->class allows an application to load appropriate dbm implementation at runtime. Utility scripts dbm/dump and dbm/restore are provided for easier backup and migration. See the manual entry for the details.
    • Procedure slot-pop! is added for the consistency with other *-push!/pop! API pairs.
    • When ref is used for object slot access, it can take default value in case the slot is unbound.
    • Made (set! (ref list k) value) work.
    • New procedures delete-keywords, delete-keywords!, tree-map-map, tree-map-for-each.
    • unwind-protect allows multiple handlers, as in CL.
    • sqrt now returns an exact number if the argument is exact and the result can be computed exactly. Also, R6RS's exact-integer-sqrt is added. Cf. Exact sqrt.
    • gauche.parameter: Parameters can be used with generalized set!.
    • The default-endian parameter is moved from binary.io module to the core, so that this parameter controls default endian of binary I/O in general. For example, read-block! and write-block of the gauche.uvector module now uses the value of this parameter as the default. A new procedure native-endian is added to retrieve the platform's native endianness.
    • More R6RS procedures: inexact, exact, real-valued?, rational-valued?, integer-valued?, div, mod, div0, mod0.
  • Bug fixes
    • Fixed a bug that caused SEGV on some ARM processors, due to double precision floating-point number's alignment and endianness.
    • rfc.http: Fixed a bug that http-get etc. hanged waiting for message body even when the server returns 204 or 304 response, which doesn't have a body. Fixed a bug that extraneous headers appeared when some keyword arguments were given to http-get etc. Also fixed mime handling to respect the content-transfer-encoding keyword argument.
    • www.cgi: Fixed a bug in mime handling code that didn't parse option values in content-disposition header were unquoted. It caused a problem to dealing with Form POST data by certain clients.
    • util.match: match-let* didn't work because required identifiers weren't exported. Also fixed an issue that the match procedure took exponential time in certain patterns.
    • tree-map-pop-min! didn't update number of entries.
    • Fixed a bug in glob which failed if an intermediate directory in the fully-specified path was searchable but unreadable (i.e. the mode bits are --x).
    • In the VM, there was a code that violated strict aliasing rule of C, which yielded unintended optimization on some compilers. Thanks to NIIBE Yutaka for tracking down this subtle bug.
    • Built-in numeric comparison procedures behaved incorrectly when NaN was involved. Half-floats (f16) routines didn't handle NaN well.
    • char-set-complement had a bug when there was a single-character gap in the given charset.
    • gauche.net: Fixed the bug that make-server-sockets failed if it tried to bind both IPv6 and IPv4 sockets, when the system defaults v6 sockets to be dual-stack. If the system has dual-stack sockets, the procedure doesn't need to create v4 socket by itself.
    • gauche.dictionary: <bimap> was missing collection protocol.
    • gauche.collection: Fixed <tree-map> builder to allow :size keyword argument; without the fix, (coerce-to ...) complained.
    • write went to infinite recursion when it tried to print (cdr #1='#1#).
    • rational? now returns #f correctly for +inf.0, -inf.0 and +nan.0. These are the only numbers that are real but not rational.
    • with-signal-handlers had a bug that sometimes incorrectly resets the handler to SIG_DFL. Thanks to Enami for providing the solution.
    • srfi-19: updated to reflect new leap seconds.
    • sxml.sxpath: Reflect upstream fixes of txpath and sxpath.
    • rfc.ftp: A condition type <ftp-error> was documented but not exported.
    • A character literal reader had a bug that recognize character names just by prefix match.

Gauche-gl 0.5

  • Improved build process so that it can be easily compiled on MinGW/MSYS. The Windows binary installer includes precompiled Gauche-gl, with statically linked freeglut.
  • Glut can have callbacks for each GL window.
  • A module gl.simple-image is renamed to gl.simple.image. There's also a gl.simple.viewer module that provides simple skeleton of 3D viewer with camera control.
  • Added support for gl-active-texture, gl-client-active-texture, gl-index.
  • New procedures in module gl.math3d: vector4f-norm, vector4f-mul, vector4f-mul!, vector4f-div, matrix4f->translation, matrix4f->translation!, f32vector->matrix4f! vectors->quatf, vectors->quatf!, axes->quatf, axes->quatf!, quatf-conjugate!, quatf-set4!.
  • gl-tex-image-2d can now take #f in place of texels array; it only allocates texture memory but not initialize it. It is useful when you want to render to the texture.


It is reported that a few Windows antivirus software heuristically flags Gauche 0.9 windows binary distribution as a dropper type virus. We believe this is a false positive; the current binary distribution on SourceForge.net is built on our developer's machine which is regularly scanned by antivirus software. Here's md5sum of the original packages:

5801c5a91a8e1c09e0a4b1ec30d37dee        Gauche-mingw-0.9.exe
0a1470b3a96e658c8e3c812aca880ffd        Gauchebox-0.9-box1.exe


Gauche 0.9: Major Feature Enhancements

  • C API incompatible changes: Several incompatible C API changes are introduced, which may cause some extension to fail to compile. See API Changes in 0.9 for the details.
  • New features
    • New module: rfc.zlib: Zlib compression/decompression.
    • New module: rfc.sha: SHA2 support. rfc.sha1 is superseded by this module.
    • New module: util.sparse: Sparse vectors backed up by space-efficient trie, and hash-tables implemented on top of sparse vectors. They are memory efficient than the builtin hash tables when you want to keep tens of millions of entries.
    • Autoprovide: You no longer need 'provide' form for most of times. If (require "X") successfully loads X.scm and it doesn't have a provide form, the feature "X" is automatically provided. See the "Require and provide" section of the reference for more details.
    • Module gauche.test: Improved testing for exceptions. You can now test whether a specific type of condition is thrown by giving (test-error condition-type) as the expected result. See the manual entry for more details.
    • Module rfc.http: Now handles proxy by :proxy keyword argument. You can also easily compose application/x-www-form-urlencoded and multipart/form-data message to send form parameters. New procedures: http-put and http-delete.
    • Module rfc.mime: Added support of composing a MIME message.
    • Module gauche.threads: New procedures: thread-stop!, thread-cont!, thread-state.
    • Module gauche.termios: On Windows native support, this module provides Windows Console API instead of POSIX termios API, since emulationg POSIX termios on Windows is too much. A set of common high-level API that can be used on both POSIX and Windows are also added.
    • Module gauche.dictionary provides a bidirectional map, <bimap>.
    • run-process in module gauche.process, and builtin sys-exec and sys-fork-and-exec support :directory keyword argument to specify the working directory of the executed process.
    • Module file.util provides create-directory-tree and check-directory-tree.
    • Module gauche.net provides low-level socket operations: socket-sendmsg, socket-buildmsg, and socket-ioctl. Call-with-client-socket takes new keyword args to specify buffering mode for the socket.
    • Module www.cgi: cgi-main switches the buffering mode of stderr to line, so that the httpd log can record error messages line-by-line (much less clutter than before).
  • Major fixes and improvements
    • Fixed build problem on OSX 10.6 (Snow Leopard).
    • Performance is greatly improved on floating point number arithmetics, optional argument handling of builtin procedures, and case-lambda.
    • Now all whitespace characters defined in R6RS works as intertoken spaces in the source code.
    • A warning message is printed when a thread exits with an error and no other thread retrieve its status by thread-join! before the thread is GC-ed. This helps troubleshooting. Since thread-join! is the only way to know if the thread exitted by an error, you have either to call thread-join! to make sure to check the status, or to write the thread thunk to catch all errors and handle them properly.
    • Anonymous module name is #f now, instead of (somewhat arbitrarily chosen) |#|.
    • Some enhancements on symbols: 'uninterned' symbos are officially supported (symbols generated by gensym have been uninterned, but never been documented officially.) Uninterned symbols are written as #:symbol a la CommonLisp. Uninterned symbols are not registered to the internal symbol table, so there's no worry about name crash. The only way to refer to the same uninterned symbol from more than one place in the source code is to use srfi-38 notation (#n= and #n#). You can create uninterned symbol by string->uninterned-symbol and check whether a symbol is interned or not by symbol-intened?. There is also a new procedure, symbol-sans-prefix.
  • Windows support
    • Precompiled binary installer for Windows is now available. Get Gauche-mingw-0.9.exe. It is supported on Windows NT 3.5 and later (sorry, no support for Win9x.)
    • Precompiled binary does not include thread and gdbm support (yet). It is compiled to use utf-8 internal encoding.
    • Some Unix-specific system functions are not available, or have slightly different semantics because they are emulated via Windows API. If a function is not available on Windows, the reference manual says so. Windows version hasn't be used heavily, so expect bugs.
    • Large character set support on Windows Console is pretty limited. It is recommended to run gosh under Emacs for interactive use. See WindowsConsole for the details.


Gauche 0.8.14: Maintenance release.

  • Bug fixes
    • In some cases, an argument list passed to apply wasn't copied.
    • On some platforms, signal mask of threads could be altered inadvertently by exception handling due to the different behavior of sigsetjmp.
    • format now raises an error if there's an incomplete tilde sequence in the given format string.
    • Internal parameter (gauche.parameter) code had a bug that allocates not enough storage.
    • There was a couple of bugs in dynamic-load that could cause dead lock or leaving internal state inconsistent.
    • Module rfc.http: The 'host' field became inconsistent when redirection happened.
  • R6RS-ish extensions
    • R6RS reader directive #!r6rs, #!fold-case and #!no-fold-case are recognized now. The latter two can be used to change case-folding mode of the reader in the middle of the source code. See the manual for the details.
    • New core procedures: finite?, infinite?, nan?, eof-object.
    • Two argument version of log: (log z b) is for base-b logarithm of z.
  • Extension-building improvements
    • gauche-config script provides --rpath-flag option to retrieve platform-specific rpath link option (e.g. "-Wl,--rpath -Wl,").
    • gauche-package script accepts --local option to the 'compile' and 'install' command to add local include paths and local library search paths conveniently. Basically, gauche-package compile --local=DIR package.tgz causes -IDIR/include and -LDIR/lib to be added to the actual compile and link command lines. To give more than one directory, say --local=DIR1:DIR2:....
    • A stub generator and ahead-of-time compiler (the facility to pre-compile Scheme code into VM instruction array as static C data) is integrated, allowing C and Scheme code to be mixed in the same source; this feature is not yet documented and the details are subject to change, but the curious mind can take a look at ext/dbm/*, which were much simpler than the previous version.
  • Additional improvements, new procedures & macros
    • GC is now Boehm GC 7.1.
    • Large part of VM code is rewritten for better performance and maintainability.
    • New procedure: hash-table-copy.
    • New convenience macros: rlet1 and if-let1.
    • You can now hook exit operation by the exit-handler parameter. See the "Program termination" section of the manual for the detailed description of this feature.
    • Made sys-lstat work like sys-stat on Windows platform; one less headache to write cross-platform code.
    • Module gauche.net: Constants SHUT_RD, SHUT_WR and SHUT_RDWR are defined to pass to socket-shutdown.
    • Module file.util: New convenience procedures: copy-directory*, touch-files, remove-files, delete-files.
    • Module dbm.*: Renamed dbm-rename to dbm-move for the consistency. (The old name is kept as alias for the backward compatibility). Added dbm-copy and dbm-move missing from dbm.fsdbm. Also properly detects variations of suffixes of ndbm-compatible database at configuration time.
    • Module www.cgi: :mode option is added to the MIME part handler passed to get-mime-parts to specify the permissions of the saved file.
    • Module rfc.ip: New procedure: ipv4-global-address?.


Gauche 0.8.13: Lots of small improvements

  • Bug fixes
    • Module rfc.http: fixed a bug that didn't pass the port number in the host header field.
    • rxmatch-num-matches: returns 0 if #f is given, as described in the manual.
    • asin, asinh: fixed a problem of the code to avoid numerical instability.
    • Module slib: fixed to work with the newest slib release.
    • Module gauche.process: on-error-exit handler was errneously called even when the process' exit status was zero.
    • Module file.util: Fixed a bug in copy-file that didn't preserve the mode of the desination file in certain cases.
    • Module gauche.parseopt: Fixed a problem that regexp ran out of stack when very long option argument was given.
    • Fixed a problem of make uninstall that might remove libgc.a which wasn't installed by Gauche.
    • Module gauche.test: test-module have missed to check some of the internal definitions. Now it is fixed, and it may find references to undefined variables that haven't been spotted before.
    • Fixed an autoload bug which caused malfunction when mulitple threads tried to resolve the same autoload simultaneously.
  • Improvements in the core
    • Improved argument handling in apply: It used to push each arument in the argument list onto the VM stack, so when you applied long argument list that wouldn't fit the VM stack it failed. Now apply only expands the argument list as much as it needs. This eliminates the limitation of the length of argument list in almost all cases. For example, you can now do this:
        (apply list (iota 50000)) 
    • Better support of cross compilation (patch from YOKOTA Hiroshi).
    • New procedures: fixnum-width, greatest-fixnum, least-fixnum (as defined in R6RS).
    • String literals allow R6RS-style line breaking---a sequence of a backslash, zero or more whitespaces, newline, and zero or more whitespaces, are ignored in a string literal. You can write
       "Suppose this is very very long line." 
       "Suppose this is very \ 
        very long line."
      for example.
  • Improvements in the system interface
    • Now Gauche uses 64bit file offsets, enabling to handle >2GB files. (On Linux, including <gauche.h> defines _FILE_OFFSET_BITS to 64. If you link libgauche with other libraries and passes around file offset value or struct stat, make sure the other libraries are also compiled with the same _FILE_OFFSET_BITS).
    • glob and glob-fold now supports '**' wildcard that matches multiple levels of directories.
    • New system functions: sys-getrlimit and sys-setrlimit.
    • <time> can now represent a time after the year 2038.
    • The default buffering mode of stdout is changed to full when it is not connected to the terminal (it remains line if it outputs to the terminal). This improves output performance quite a bit when you redirect the large output to a file or a pipe. Note: This may break programs that forgot to call (flush) when the output is piped.
  • Improvements in regexp
    • Regexp has now read/write invariance, except when it is created by string->regexp from a string with weird characters.
    • New procedure: rxmatch->string.
    • In regexp-replace family functions, you can now use names of named capturing groups to refer to the captured substring, as well as their indexes.
  • Improvements in other libraries
    • Module rfc.base64 and rfc.quoted-printable: The encoding routines now takes :line-width keyword arguments to insert line breaks in the output.
    • Module rfc.822: Added rfc822-write-headers, a generic message header generation routine. For the symmetry with it, rfc822-header->list is renamed to rfc822-read-headers. The old name is kept for the compatibility.
    • New tree-map search functions: tree-map-floor, tree-map-floor-key, tree-map-floor-value, tree-map-ceiling, tree-map-ceiling-key, tree-map-ceiling-value, tree-map-predecessor, tree-map-predecessor-key, tree-map-predecessor-value, tree-map-successor, tree-map-successor-key, tree-map-successor-value.
    • Module srfi-19: Julian day and modified julian day are now calculated by exact integers, avoiding rounding errors.
    • Module gauche.sequence: Officially supports methods to shuffle and permute the sequence content: permute, permute!, permute-to, shuffle, shuffle!, shuffle-to. These are already in since 0.8.12, but weren't documented.


Gauche 0.8.12: Maintenance release

  • Bug fixes
    • Module gauche.net: Important: Socket port buffering mode was set incorrectly in the release 0.8.11, making network applications behave erroneously.
    • Numeric comparison routine could return incorrect result when comparing ratnums in special cases.
    • Module file.util: file->string etc. now handles :if-does-not-exist argument properly, and returns #f if the file doesn't exist and :if-does-not-exist #f is specified.
    • Regmatch objects had a bug that returns "" for failed submatch, which should be #f.
    • Module dbm.gdbm: gdbm-errno and GDBM_SYNCMODE weren't exported.
  • Other improvements
    • The `glob' functionality is reimplemented in Scheme instead of calling libc's glob so that we can have the consistent behavior across platforms. The sys-glob function is renamed to glob, with additional features (the old name is kept for the backward compatibility). See the reference manual for the details.
    • New system functions: sys-environ and sys-environ->alist, to get all environment variables.
    • Infinities and NaNs are now read and written as +inf.0, -inf.0 and +nan.0, following R6RS syntax. The old notations like #i+1/0 etc. are also recognized for the backward compatibility.
    • Module text.progress: Allow to change header string dynamically, and also added a miscellaneous information field.


Gauche 0.8.11: Maintenance release

  • Important change
    • If --enable-threads argument is not given to the configure script, pthreads is automatically enabled when it is available on the platform. So you don't usually need to specify that option anymore. If you want to disable pthreads support explicitly, specify --enable-threads=none.
  • Bug fixes
    • Fixed a long standing bug that the autoload wasn't resolved when define-method was evaluated on the autoloaded symbol.
    • gauche.uvector: write-block output extra octets when byte swapping was enabled.
    • srfi-13: string-upcase! etc. didn't work without giving all the arguments, including the ones that were supposed to be optional.
    • rfc.ftp: ftp-put-unique now returns two values, the server's response and the remote file name created by the action; without the remote file name, it was pretty much useless. Also call-with-ftp-connection was passing a wrong keyword argument to ftp-login.
    • rfc.http: Keyword arguments :sink and :flusher were ignored by http-get.
    • slib: force-output didn't work.
    • srfi-1: lset= didn't work if more than two lists were given.
    • Gauche was SEGVed when cond or case with a dotted list in their clauses were given.
    • Gauche was SEGVed when a circular structure was passed to error or errorf.
    • Gauche was SEGVed when it tried to coerce some rational numbers with huge denominator/numerator into flonum.
    • Gauche was SEGVed when non-string key was given to a string hash table.
    • Comparing a small rational number with a big denominator against fixnum yielded a wrong result.
    • Double flonum to half float conversion routine had a little error in LP64 machines.
    • Fixed a problem of "port table full" when too many ports were opened and closed in a short time span.
    • There was a possibility of precision loss in conversion of exact integer to flonum, due to double rounding.
    • When gosh was run with a script and an error occurred, stack trace wasn't shown.
    • String interpolation didn't recognize '[]' as '()'.
    • sys-realpath was unusable due to typo.
    • Fixed a compile problem on Solaris regarding sigwait() incompatibility.
  • New modules, procedures and macros:
    • New generic functions in gauche.collection: find-min, find-max, and find-min&max.
    • port-fd-dup!: An interface to the dup(2) system call.
    • hash-table-clear! added.
    • sys-umask can now be called without arguments to obtain the current umask settings without changing it.
  • Other changes:
    • Template Makefile for extensions now honors separate builddir.
    • gauche.test: test-end procedure now returns the number of failed tests.


Gauche-gl-0.4.4: Minor maintenance release. Fixed a problem on cygwin that prohibited using GL extensions. (Patch from Takashi Ishizaki).


Gauche 0.8.10: Major feature upgrade

  • Important changes
    • Now the keyword argument handling macros (let-keywords* and let-keywords; the latter is a new addition) warn if unrecognized keyword argument is given. Before 0.8.10 unrecognized keyword arguments are silently ignored, which caused careless typos unnoticed. You can still specify to allow unrecognized keywords explicitly (the same effect as &allow-other-keys in Common Lisp, but in the different syntax; see the manual entry of let-keywords for the details). We eventually make unrecognized keywords an error, so if your code conuts on the behavior of unrecognized keywords being ignored, update the code soon. (Procedures defiend in stub files are also subject to this check; see "C API changes" below).
    • In module gauche.process: call-with-input-process etc. checks if the child process' exits abnormally (exit with non-zero status) and raises <process-abnormal-exit> condition. This changes the default behavior of process port procedures, which used to ignore nonzero exit status, now raises an error. To get the old behavior, add :on-abnormal-exit :ignore to the call of those procedures.
    • Also in module gauche.process: The API of run-process is changed for the consistency. Old API is still recognized and supported, but it is recommended to move to the new API; see the reference manual for the details. Besides, run-process now accepts :host argument that allows to run process on remote machine (using ssh).
    • Module www.cgi-test is renamed to www.cgi.test. Old name is kept for compatibility, but the application is recommended to use the new name.
    • Module gauche.test: If an environment variable GAUCHE_TEST_RECORD_FILE is set, test processes accumulates the test statistics to the file named by the variable. The result is a summary line you can see after running "make check" after buiding Gauche. See src/Makefile for how to use this feature.
    • Module gauche.uvector and binary.io: Support of 16-bit floating point number is added. Sometimes called 'half', the format consists of 1 sign bit, 5 exponent bits and 10 mantissa bits, and often used in image format.
    • Also in module binary.io: Renamed functions for brevity and consistency to the uniform vectors. Old function names are still supported but deprecated.
    • Also in module binary.io: A new parameter default-endian is added, so that the program can switch the default endianness.
    • Module rfc.uri: Support :encoding keyword argument in uri-encode-string and uri-decode-string. Export two character sets, defined 'unreserved' in RFC2396 and RFC3986, as *rfc2396-unreserved-char-set* and *rfc3986-unreserved-char-set*.
    • Module gauche.net: Added socket-recv! and socket-recvfrom! that receive packets into provided uniform-vector buffer (thus avoid allocation). Uniform vectors are now also allowed in socket-send, socket-sendto, and socket-setsockopt as buffers. Using strings for those binary data packets is not recommended now; use u8vector instead. Uniform vector is also allowed as IP addresses to the :host initializer argument to <sockaddr-in> and <sockaddr-in6>.
    • Also module gauche.net: Added utility routines inet-checksum, inet-string->address and inet-address->string.
    • Add various feature identifiers according to the compile-time configuration. See 'Platform-dependent features' section of the manual for the details.
  • Bug fixes
    • Fixed a compiler optimizer bug that emitted incorrect local variable reference.
    • Fixed a couple of bugs in character/character-set printing.
    • In module gauche.uvector: call-with-iterator for uniform vector classes didn't recognize :size keyword.
    • Fixed a bug that SRFI-10 sharp-comma expresions were evaluated even if they were in an expression commented out by SRFI-62 S-expression comment.
    • Fixed a bug in math.mt-random that didn't set a seed correctly if the seed value is a bignum and given by :seed initialization argument.
    • Fixed a bug in vector-ref that raises an error if given index is a bignum---when fallback arugment is given, it shouldn't have raised an error.
    • Fixed a memory leak of sys-putenv in most cases, using setenv if the system provides it.
    • In module rfc.http: Fixed a bug in the case of HTTP request being redirected. Also a new condition type <http-error> is provided to signal lost connection or invalid message headers.
    • Module www.cgi: Fixed a bug that hangs when Content-Length is zero.
    • Module gauche.config: Now the configuraiton parameters are embedded in this module, so that it doens't need to run gauche-config program in run-time.
    • Module srfi-19: Fix date formats of date->string to make them ISO-8601 compliant.
    • Module gauche.charconv: Converting characters between U+0080 and U+009f to EUC-JP yielded invalid EUC characters.
  • New modules, procedures and macros:
    • A new builtin object: tree maps. Using a balanced tree internally, it provides a map object with ordered keys. Red-black tree (util.rbtree module) is reimplemented by tree maps.
    • New procedures to do inexact arithmetics explicitly: +., -., *. and /.. These procedures coerces its argument to inexact before calculation. They are useful if you know you don't need exact calculation; using these procedures, you can avoid accidental use of exact rational numbers, whose calculation is much slower than inexact calculations (and sometimes annoying).
    • New procedures round->exact, floor->exact, ceiling->exact, and truncate->exact. These covers the popular patterns to get an exact integer from inexact numbers.
    • New procedure sys-fdset: A convenient constructor of <sys-fdset>.
    • A new macro unwind-protect is added, taken from Common Lisp.
    • New module rfc.ftp, based on the contribution from OOHASHI Daichi.
    • New module gauche.dictionary, providing generic functions for hash tables and tree maps.
    • New module text.progress: Shows progress bar on text terminals.
    • New module rfc.ip and rfc.icmp.
  • C API changes:
    • API related to hash tables, string ports, load and require are changed. The change breaks compatibility, so by default they are invisible. See Gauche:APIUpdate for the detailed description of changes, and how to update your C extension code.
    • When a C-defined procedure (defined by define-cproc etc. in the stub files) takes keyword arguments by &keyword directive, it now warns if it sees unrecognized keyword arguments. If you want it to ignore unrecognized keyword arguments as in the previous versions, add &allow-other-keys to the argument list.


Gauche 0.8.9: Major maintenance release

  • Bug fixes
    • As described in the previous news, 0.8.8 had a bug that a script exits with no messages when it is terminated by an uncaptured error.
    • Signal handling is revised, eliminating possible race conditions. You can now give a signal mask to the Scheme-level signal handlers so that you can make sure the handler won't be interrupted by a signal. We also set a limit in the number of unhandled signals of the same kind; if the same kind of signals are sent more than that limit, Gauche aborts the process. It is a kind of emergency escape. You can change or remove this limit from the program. See Handling Singals section of the manual for the details.
    • A new thread created by make-thread should inherit current input/output/error port at the moment when it is created, but it didn't.
    • error had a bug when the raised error class had a name without '<' and '>'.
    • C API Scm_EvalCString was incorrectly spelled as Scm_EvalRecCString in 0.8.8.
    • The class <rational> wasn't initialized properly.
    • There was a bug in string handling routine that may access one element beyond the allocated memory, causing SEGV.
    • Eqv hash table didn't handle rational numbers properly.
    • apply wasn't tail-recursive as specified in R5RS.
    • A bug in the class handling routine prevented the program from subclassing some C-defined base classes. One of such cases was to define a condition type inheriting <port-error>.
    • Module dbi: The compatibiliy API wasn't working.
    • Module gauche.process: fixed a leak that didn't delete a process from the active process list if :wait #t was given.
    • Module gauche.listener: fixed a bug that caused the listener to exit when an error was siganlled during evaluation.
    • Module srfi-19: Reverted julian day and modified julian day calculation in inexact numbers to avoid the large overhead of rational arithmetics.
  • Miscellaneous improvements:
    • Slib 3a4 and later is supported.
    • srfi-61 and srfi-87 are suppored natively.
    • define-condition-type automatically adds :init-keyword option to the slot so that the slots can be initialized using the convenient procedures such as error.
    • substring and rxmatch-substrinc etc. are improved for better performance on long multibyte strings.
    • inexact->exact raises an error if NaN or infinite is given.
    • New procedures: sys-sigwait, sys-fchmod.
  • C API Compatibility note:
    • We extended the transition period of the changes of Scm_Eval, Scm_EvalCString and Scm_Apply APIs. By default, these are macros expanded to the API Scm_EvalRec etc. The extention writers need to change Scm_Eval etc. to the "Rec" version soon. Once the transition period ends, we'll enable the new APIs of Scm_Eval, Scm_EvalCString and Scm_Apply, which have different signatures. You can start using the new APIs by defining GAUCHE_API_0_8_8 cpp symbol before including gauche.h.

Gauche-gl 0.4.3: Minor maintenance release. Fixed bugs in the finalizers of GLU objects.


Gauche 0.8.8 important patch: There is a bug in main.c that makes gosh exits silently without reporting errors when a Scheme script raised an unhandled error. Please apply the patch shown in the following message: http://sourceforge.net/mailarchive/forum.php?thread_id=30949517&forum_id=2043


Gauche 0.8.8: Major maintenance release

  • Important Changes:
    • Exact rational number is supported; now you get 1/3 from (/ 1 3). To obtain inexact number from division of two exact numbers, you have to use exact->inexact explicitly. With this change you can get more exact result, but if your code has relied on the old Gauche behavior that automatically converts rationals to inexact reals, your code may run very slowly in this release of Gauche (since exact rational arithmetic is much slower than flonum arithmetic). For the smooth transition, a compatibility module compat.norational is provided, which makes the / operator behaves like before. See the manual entry for the details.
    • The reader is more strict about utf-8 encoding. Consequently, some source files in other encoding that happened to be accepted by previous versions of Gauche may no longer work. If you get an error, either convert the encoding of the source, or use "coding:" magic comment (See "Multibyte scripts" section of the reference manual).
    • The test-module routine in gauche.test is fixed so that it detects more references to undefined global variables that have been overlooked. You may get an error something like "symbols referenced but not defined: ...". In most cases, they are from typos. See the manual entry of gauche.test - Unit testing for the details.
    • New modules:
      • sxml.serializer: Generic routine to convert SXML to other formats like XML or HTML. Written by Dmitry Lizorkin and ported to Gauche by Leonardo Boiko.
      • util.trie: Implementation of Trie. Originally by OOHASHI Daichi, and hacked by numerous Gauche hackers.
      • util.rbtree: Implementation of Red-Black Tree. Written by Rui Ueyama.
    • A bug in port locking routine, that caused a race condition on multiprocessor machine, is fixed. As a side effect, port lock operation became a bit faster.
    • C API prospected change: Scm_Eval, Scm_EvalCString, and Scm_Apply will have different API in the next release. The current API is kept under a different name, Scm_EvalRec, Scm_EvalCStringRec, and Scm_ApplyRec. If you are using those functions, please make changes until the next release.
  • Miscellaneous fixes and improvements:
    • GC is updated to Boehm GC 6.8, with the patch for Xcode-2.4/OSX.
    • Port cleanup & gc routines are fixed so that you won't get "port vector full" error easily. Also fixed thread-unsafe code in Scm_FlushAllPorts.
    • The behavior of guard is now consistent with srfi-34; the handler clauses are evaluated with the same dynamic environment of guard form itself. That is, the dynamic environment inside guard's body is rewound before the handler clauses are evaluated.
    • Bugs in edge cases of the numeric literal parser are fixed.
    • Bugs of mutex in class redefinition is fixed.
    • string-incomplete->complete can now omit or replace illegal byte sequences in an incomplete string.
    • Module gauche.logger: The file locking strategy is now set at runtime by checking availability of fcntl lock.
    • Module gauche.sequence: Added a generic version of fold-right.
    • Module util.match: Fixed multiple value handling bug.
    • Module file.util: Fixed directory-fold to make lister returns new seed value as well as directory contents, so that it can process directory pathnames.
    • Module rfc.822: Fixed treatment of sub-hour timezone value.
    • Module gauche.charconv: Fixed file descriptor leak.
    • Module gauche.net: Fixed a bug that didn't retrieve sender's sockaddr correctly. There are also some typo fixes and new socket option constants.
    • Module gauche.threads: Fixed a bug that caused to consume large memory on OSX.
    • Module sxml.sxpath and sxml.tools: fixed references to undefined functions.
    • Module dbi: fixed a bug that dbi-make-driver loads the specified dbd module every time it is called, instead of just once.
    • Regular expression engine had a bug that caused regexp compilation error.
    • Module rfc.http: (send-request) fixed not to send CRLF after request body (RFC2616 sec. 4.1.)
    • gauche-package, gauche-config: Removed quotes around command names and include directories, for they interfere with shell. This prevents Gauche from being installed under directorys whose name contains whitespaces, but such directory names also cause all sorts of troubles with unix-oriented tools. We'll think other means to support such directories.
    • Fixed digit->integer bug: (digit->integer #\2 2) yielded 2, should be #f.

Gauche-gl 0.4.2: Minor maintenance release. Fixed a few build problems.


Gauche 0.8.7: Major maintenance release

  • Bug fixes:
    • read-block had a bug that causes invalid memory write. (thanks to Tatsuya BIZENN for tracking this down).
    • sys-dirname didn't work on an items directly below the root directory.
    • Built-in write routine had a bug that could cause infinite loop on circular structure even when it was called with the mode that detects circular structures.
    • The compiler had a bug that caused an internal compiler error when local function inline expansion happens recursively. Thanks to Jun Inoue for tracking this down. A couple of other bugs that caused compiler internal were also fixed.
    • Dynamic handlers didn't properly invoked when error occurred during reinstallation of dynamic handlers via call/cc.
    • A couple of bugs in Windows pathname handling on MinGW version were fixed.
    • Dividing a bignum by zero wasn't handled properly.
    • util.stream: stream-filter had a bug to try to evaluate one extra element in a stream, causing an error at the end of the stream. There were a few undefined function references in the module. The expansion of stream-cons made the second argument evaluated twice within delay, causing incorrect behavior if the evaluation had side effects, and performance loss in general.
    • gauche.collection, gauche.sequence: (map-to, map-to-with-index) Size estimation was wrong when multiple collections of uneven lengths were given.
    • util.relation: the API relation-rows wasn't exported.
    • ext.net: assertion failure caused when input/output ports were created on closed socket and used.
    • sys-wait, sys-waitpid: system call wasn't restarted when it was interrupted, leaving child processes uncollected.
    • text.sql: sql-tokenize caused regexp stack overflow when very long input is given.
    • dbi: fixed a bug that references out-of-scope variable.
    • srfi-13: fixed argument range check bug in string-copy!.
    • Build process could generate an invalid shell script on some platforms.
    • www.cgi: cgi-header: changed line terminators to CRLF.
    • genstub: define-cgeneric didn't work with setter definitions.
    • method-more-specific?: The default built-in method didn't handle the case when both methods have rest arg.
    • Internal class structure was using pthread mutex potentially uninitialized, causing errors on some platforms.
    • dbi: the adapter to the legacy dbd interface now uses pass-through option for compatibility.
    • gauche-install: made mode/owner/group specifying option work with -d option.
    • The Japanese info document is back to euc-jp, for some tools for documentation generation aren't ready for utf-8.
  • Improvements:
    • Important: test-module of gauche.test now tests whether the module refers to undefined global variables, and reports error if it finds any. This is very useful to catch typo in identifiers. (There can be a case that this test raises false positives. See the manual entry for the detailed discussion.)
    • Adopted Boehm GC 6.7.
    • New module: binary.io: Primitive functions to perform binary I/O. This has been included as a basis of binary.pack for some time, but now it becomes 'official'.
    • Some more commonly used libraries, such as gauche.collection, are pre-compiled, which reduces loading time.
    • A new command-line profiler option, -pload, is added to measure the loading time of each module. This helps to see which module is taking time at script's starting up.
    • Regular expression engine now supports backreferences, named captures, and lookback assertions. Contribution from Rui Ueyama.
    • gauche.process: run-process now accepts :sigmask keyword argument to specify the signal mask of the child process without hazard.
    • A new condition class <unhandled-signal-error> is added; it is thrown by the default signal handler.
    • gauche.net: make-server-socket now takes :backlog keyword argument to specify backlog number. A constant SOMAXCONN is also added.
    • Built-in printer for a class now shows whether the class object is redefined, which helps debugging.
    • text.sql: sql-tokenize: Changed to return SQL unquoted identifiers as strings, instead of symbols, since sometimes we want to preserve the case of SQL identifiers for the compatibility of back-end databases.
    • The compiler now recognizes ((with-module foo bar) ...) as a macro call if bar is defined as a syntax in the module foo. This is useful when you want to redefine existing syntax to extend it.
    • global-variable-ref: added a second optional argument to limit lookup within the module.
    • gauche.termios: new procedure: sys-forkpty-and-exec.
    • sys-sigmask now allows #f as the newmask argument to obtain the current mask without modifying it.
    • The display width of debug-print (or #?=) can be adjusted by the parameter debug-print-width.
    • New built-in procedure: complement, with-ports


Gauche 0.8.6: Major feature enhancement.

  • NOTICE: The default internal encoding, used when you don't specify --enable-mutibyte option at the configuration time, is changed from EUC-JP to UTF-8. If you've been compiled Gauche with EUC-JP encoding, you need to configure the new Gauche with explicit --enable-multibyte=euc-jp option.
  • New features:
    • New modules:
      • dbi: Database independent access layer, providing unified access to various relational databases. You need separate "driver" packages to access the actual RDBMS. There are a few driver packages available at http://www.kahua.org/cgi-bin/kahua.fcgi/kahua-web/show/dev/DBI/.
        Note: If you have been using the separate dbi module, make sure you remove it before using the new dbi and dbd modules. You can find the old dbi.scm under somewhere like /usr/local/share/gauche/site/lib (the actualy directory depends on the configuration when you've installed the dbi module).
      • util.relation: A framework to work with relations (as defined by Codd). The result of database access via dbi is represened as a relation.
      • text.sql: SQL parser/constructor. Full features are not implemented yet, but used in dbi module for prepared queries.
    • New SRFIs:
      • SRFI-40 (Library of streams) as util.stream.
      • SRFI-43 (vector library) as srfi-43.
      • SRFI-45 (Primitives for Expressing Iterative Lazy Algorithms) : built-in.
    • gauche-package is extended, having the generate command that creates skeleton source files for Gauche extension modules. The template configure.ac for extensions is revised not to include any Gauche-specific m4 macros, so you no longer need to tell extra paths to autoconf to generate configure.
    • Some of commonly used modules such as srfi-1 are now compiled as extensions, greatly shortening the loading time.
    • error and errorf procedures are extended so that you can throw not only <error> but also user-defined conditions.
    • New built-in proceduers global-variable-bound? and glboal-variable-ref. The former supersedes symbol-bound? ( symbol-bound? is now deprecated and will go away in the future releases. Code that uses symbol-bound? should change it to global-variable-bound?. ). The latter removes some need of using eval just to peek the value of the global variable.
    • New regexp procedures: regexp-replace*, regexp-replace-all*, regexp-case-fold?.
    • Most typical unix error numbers are now pre-defined as a constant (e.g. EINTR). A new built-in procedure sys-strerror can be used to obtain description of the Unix errno.
    • In Gauche C API, a foreign pointer object is introduced, with which you can expose objects defined in C world more easily.
    • Stack overflow handling is largely improved. You can see better performance if your script frequently oveflows the stack.
  • Bug fixes:
    • Some important memory-related problems that could have caused SEGVs were identified and fixed.
    • www.cgi: the file uploading part didn't preserve the original filename sent from Internet Explorer.
    • The autoload routine had a bug that initiated loading within the module where autoload was triggered, instead of the module where the initial autoload was defined. This caused some problems if autoload was triggered within a sandbox module, for example.
    • Fixed a long standing bug of the object system that caused an accessor method of the base class accesses to the wrong slot of the derived class when some conditions are met. (Check out test/object.scm "module and accessor" section for the details).
    • srfi-13: string-prefix didn't return a correct index when the first string was longer than the second.
    • The comparison function of <time> and <char-set> are now implemented, so that you can use equal? on these objects.
    • sys-basename, sys-dirname, sys-normalize-pathname: These were broken when the internal encoding was Shift JIS. sys-normalize-pathname also had a bug that may corrupt memory.
    • Changed internal representation of strings, for the old one had hazards in multi-threaded environment.
    • srfi-19: There was a typo in string->date routine.
    • The profiler API had some problems when you stop and restart it.
    • rfc.http: Made more robust for malformed MIME data.
    • file.util: Now recognizes pathnames beginning with '~' as relative pathnames (if necessary, tilde expansion is supposed to be done before any other pathname tweaking).
    • gauche.net: socket-status returned symbols in upper case, contrary to the description of the manual.
    • The module export mechanism is revised for better performance and more precise control. As a side effect, the 'export' syntax is now interpreted in more strict way; specifically, you shouldn't export a symbol which you don't define in the module. It used to be ignored, but now it shadows the earlier binding of the symbol.
    • The floating-point number literal in the IEEE denormalized floating point range caused an error.
    • The spec of hash-table-update! was broken. PROC should be called with the default value, when the given key hasn't been in the table.
    • util.isomorph: didn't work for user-defined objects.
    • A VM bug caused the number of values to propagate incorrectly in some cases.
  • Miscellaneous changes
    • binary.pack: handles signed integer with explicit endianness (n!, N!, v!, and V! directives).
    • gauche.vport: the virtural buffered port constructor now accepts :buffer-size keyword argument for the caller to specify the buffer size.
    • gauche.net: New procedures, sys-htonl, sys-htons, sys-ntohl, and sys-ntohs are added.
    • util.queue: copy-queue is added.
    • gauche.let-opt, gauche.singleton, gauce.validator: These modules have been obsoleted for long, so now we issue warning if they are used.
    • math.mt-random: you can now give a u32vector to :seed argument when constructing <mt-random> object.
    • gauche.logger: The default log drain is exposed using a parameter log-default-drain.
    • Built-in macros while and until are officially supported.
    • The module srfi-1 used to include Gauche-specific procedures such as fold$. Now they are in autoloaded module. The client code doesn't need to be changed.
    • slib: adapted to SLIB3.
    • GC is upgraded to Boehm GC 6.5.


Gauche 0.8.5: Maintenance release

This release fixes a few critical bugs. Upgrading is recommended.

  • Bug fixes:
    • 0.8.4's compiler had a serious bug in the constant expression folding routine, yielding an incorrect value.
    • Fixed automatically generated C sources that had problems with gcc-4 before.
    • <time>: Fixed an error message bug that caused double fault when setting invalid value to nsec slot.
    • 0.8.4's and-let* didn't handle the case when a single variable is used for test.
    • with-signal-handlers changed SIGCHLD handler setting incorrectly.
    • www.cgi: cgi-main now flushes the output each time when output character conversion port is inserted.
    • Windows/MinGW support is improved: Now pathname utilities such as sys-normalize-pathname, sys-dirname, and build-path in file.util, handle Windows-style pathnames. The auxiliary scripts such as gauche-config and gauche-install start working.
  • Miscellaneous change
    • Dividing by zero now yields infinity instead of raising an error. Positive and negative infinities are provisionally noted as #i1/0 and #i-1/0, respectively. We are waiting for final srfi-70 to decide the external representation (though these notations remains recognizable by the reader). Quotient, remainder and modulo still raise an error if the denominator is zero. Note that the code to handle infinities isn't mature yet, and there are some operations that yields an infinity where it should yield NaN.

Gauche-gl 0.4: Major feature upgrade

  • Gauche-gl now supports quite a few advanced OpenGL features, including programmable shader API.
  • Availability of advanced GL features and extensions are now queried at runtime, instead of statically determined at the compile time. So you don't need to recompile just because you changed your video card and driver.
  • Issac Trotts contributed the binding to NVidia's Cg Toolkit. If you have it on your machine, configure Gauche-gl with --enable-cg.


Gcc-4 complains a lot when compiling Gauche 0.8.4. If you stumble on the problem, grab the following files and replace the files of the same name under src/, then recompile Gauche.



Gauche 0.8.4:

The compiler and VM have been rewritten. Now Gauche runs faster with less memory (as fast as 1.9x, or cosumes 0.7x memory, in best cases of our tests. But your mileage may vary.) The compiler now does simple closure optimization, so the typical loop-by-local-closure style code will get the advantage. On the other hand, you won't see much gain in OO-heavy or library-heavy programs.

As an outcome of better closure analysis, Gauche now finds a bug of calling local functions with wrong number of arguments at compile time, instead of runtime. This makes existing program cease to work, if such a bug has been hidden in rarely executed code path. We think it's better to find it early, rather than getting bitten unexpectedly at a later time.

Another outcome, rather undesirable, is that Gauche may take longer to load the program, since the compiler takes more time for optimization. The load time may increase around 70%. We're planning to improve it in next several releases, so please be patient. If it becomes a real problem for your application, try using autoloads to delay loading less used functionalities.

The error messages (both compile-time and runtime errors) are not as good as it should be. It'll also be improved in next few releases, we hope.

Other changes:

  • New features:
    • srfi-42 (Eager comprehension) is supported.
    • srfi-55 (require-extension) is supported.
    • A simple sampling profiler is implemented to help tuning programs. Check out "Profiling and tuning" section of the reference manual. The profiler may not be available on all platforms.
    • We provide an experimenal Windows/MinGW binary package for the convenience. See download page.
  • Improvements:
    • ARM processor support is added.
    • Regexp now recognizes Perl-style positive/negative lookahead assertion.
    • util.queue: Added queue-push-unique! and enqueue-unique!.
    • gauche.collection: Added fold2, fold3, map-accum, group-collection.
    • gauche.sequence: Added group-sequence.
    • rfc.md5, rfc.sha1: Changed to use u8vector instead of string as a buffer, for better performance.
    • file.util: Added decompose-path, path-extension, path-sans-extension, and path-swap-extension.
    • gauche.net: make-server-socket(s) now takes :sock-init keyword argument for customizing server sockets.
    • hash-table-update! is added.
    • srfi-2: and-let* is now supported natively, so you need no longer to say (use srfi-2).
    • Disassembler is now official, and built-in. Check disasm.
    • compose now allows zero or one argument, as well as two or more.
  • Bug fixes:
    • A build problem on some x86 platforms that gcc complained about registers was fixed.
    • A bug that caused SEGV when stack overflow occues during error handlers was fixed.
    • (use slib) used to trigger loading all availabile srfis, resulting Gauche's built-in format shadowed by incompatible srfi-29's format. Now (use slib) doesn't load srfis so it won't happen (you have to load individual srfis if necessary).
    • dbm.gdbm: dbm-db-copy and dbm-db-rename were broken.
    • gauche.uvector: some linear-updating binop didn't reuse the passed argument.
    • Regexp engine broke on extremely large regexp. Now it signals an appropriate error.
    • gauche.threads: fixed a bug that could leave a mutex in locked state when the lock owner thread was killed.
    • srfi-19: string->date was broken on long month names.
    • A build problem on NetBSD, when older version of Gauche is installed, was fixed.
    • stable-sort!: fixed a bug when sorting vectors.
    • The definition of object-apply for <condition-type> became built-in, so that it will work even if other condition support functions aren't autoloaded.
    • load wasn't complain when it couldn't find the specified file.
    • string-suffix-length was broken.


Gauche 0.8.3: Bug fix release

It turned out that 0.8.2's source-code encoding detection feature had a bug; if you're using Windows-style (CRLF) line-separator, the coding-aware port repeats one character at the beginning of the second line. It doesn't do any harm if first few lines of your code are comments, but it's annoying when you stumbled on it, so I decided to release a fixed version.

This release also includes a couple of improvements: The coding-aware ports recognizes Emacs-style coding name (e.g. euc-jp-unix) and just ignores the Emacs-specific suffix (e.g. -unix). And external representations of f32vector and f64vector are now accurate.


Gauche 0.8.2: Major revision of infrastructure.

  • New features
    • A condition (exception) system a la srfi-35 and (part of) srfi-36 is supported. Used with guard (srfi-34), now it is possible to handle exceptions in more comprehensive way. See the "Exception" section of the manual, which has been rewritten accordingly.
    • Source-code encoding detection. Now Gauche recognizes a special comment like "coding: utf-8" near the beginning of the source file, and use appropriate conversion to load the source file. See "Multibyte Script" section of the manual for the details. This feature alone can be used independently from loading programs, via coding-aware ports, so the programs that processes Scheme scripts can also recognize the special comments.
    • Virtual ports are supported. Virtual ports are the ports whose behavior can be customized in Scheme. See the description of gauche.vport module in the manual for the details.
  • Improvements
    • Updated GC to Boehm GC 6.3. It fixes some GC-related problems on 64bit architectures.
    • gauche.fcntl: F_GETOWN and F_SETOWN are supported, if the system provides them.
    • gauche.termios: c_cc field of struct termios is now accessible from Scheme. (Thanks to Kogule Ryo).
    • gauche.uvector: Added string->s8vector! and string->s8vector!. TAGvector-copy!'s API is changed so that it matches with srfi-13's string-copy! and srfi-43's vector-copy!.
    • Port implementation is cleaned up. Now line count is available not only for file ports but any ports (as far as it's doing character I/O). byte-ready? is added for binary I/O polling.
    • text.csv: quote character is customizable.
  • Bug fixes
    • INCOMPATIBLE CHANGE: The previous version's rfc.mime's API was broken. It couldn't handle MIME part whose message was non-encoded binary. Now MIME part stream parser is re-implemented using virtual ports, and the reader argument passed to the MIME part handler is dropped. www.cgi is also affected if you're using customized handler for file uploads. See the reference manual for the new API.
    • SONAME of the library is now set, if the platform supports it.
    • gauche.array: Some functions were not exported, although they were mentioned in the manual.
    • gauche.charconv: Fixed a bug in converting 2nd plane of JIS.
    • gauche.regexp: regexp-replace-all looped infinitely for some patterns. Now it raises an error.
    • dbm.fsdbm: It couldn't store binary data.
    • rfc.822: rfc822-parse-date returned wrong month number (off by one).
    • util.match: Fixed a bug in quasipattern. The description of quasipatterns in the reference manual is also revised to explain it better.
    • srfi-19: date->julian-day didn't recognize tz-offset.
    • Some bugs in numeric code are fixed.
    • let-args had a bug in parameter handling of 'else' clause.
    • directory-list: when :filter-add-path? is true, there was a bug that "." and ".." were included in the results even :children? argument was true.
    • There was a bug that causes an infinite loop during class redefinition.
    • let-keywords*: fixed a bug that corrupts expansion when used in r5rs macro.
  • C API Change
    • Class initialization API is overhauled. Scm_InitBuiltinClass is obsoleted; use Scm_InitStaticClass instead.
    • Port structure is changed quite a bit.
    • Functions to convert Scheme integers to C integers are revised, to handle out-of-range error in more flexible way.
    • API of Scm_Load, Scm_LoadFromPort and related functions are changed to support more flags.


Gauche 0.8.1: Maintenance release

  • Improvements
    • www.cgi: Now it handles file uploads (i.e. the form data posted as multipart/form-data).
    • rfc.uri: Added uri-parse procedure. Also changed uri-decompose-hierarchical and uri-decompose-authority to allow #f as an argument for the convenience.
    • Regexp objects can be compared by equal?.
    • Files in examples/spigot reflect the recent conventions.
  • Bug fixes
    • Macro-related bugs:
      • Internal defines generated as a result of macro expansion are recognized now.
      • 'Case' didn't work when it appeared in a macro-expanded form.
      • Macro output was broken when an expanded syntax had a quoted vector.
      • macroexpand didn't recognize autoloaded macros.
    • Cleaned up the build process, so that the symbolic links of the shared libraries would follow the convention, i.e. libgauche.so is a symlink to libgauche.so.0.8.1.
    • Division (/) signalled an error when more than two arguments that included bignums and/or complex numbers were given. There was also a bug in the bignum division routine that produced a wrong result in some rare situations.
    • gauche.parameter: fixed a bug that allowed a thread to peek a parameter that the thread didn't own in a certain occasion.
    • gauche.net: Fixed compilation problems on NetBSD (Patch from MINOURA Makoto). Improved the error message of make-sockaddrs.
    • util.match: fixed a bug that reused a temporary variable for intermediate match, which confused the match optimizer.
    • file.util: On some platforms, make-directory* had a problem dealing with pathnames with trailing '/'.
    • sxml.ssax: Macro output of ssax:make-parser contains a reference to other modules, so it required the caller of the macro to import these modules. Now sxml.ssax extends those modules, so a client doesn't need to use them.
    • gauche-cesconv: fixed --help option to work.
    • Fixed apropos to search ancestors of imported modules.
    • write/ss: fixed a bug that flonums were written by srfi-38 notation.
    • Autoload had a bug that caused an assertion failure if the autoloaded file defines the binding in a different module.
    • The implementation of sys-glob had a potential memory leak.

Also Gauche-kakasi-0.1, a binding module for Japanese morphological analysis library Kakasi, is released. It fixes a few problems when compiled with recent Gauche.


Gauche-gtk 0.4.1:

  • Better integration to gauche-package mechanism. After installation, you can retrieve the configure options by 'gauche-package reconfigure Gauche-gtk'. And if you recompile and reinstall Gauche-gtk package with the same configure options, you can use 'gauche-package install -r Gauche-gtk-x.x.x.tgz'.
  • More API support, including pango and gdk-pixbuf.
  • The distributed tarball now compiles with both Gtk-2.2 and Gtk-2.4.


Gauche 0.8:

  • New Features
    • Auxiliary scripts: Gauche now installs a few scripts that help to build and install extension packages. The gauche-package script handles download, unpacking, configuration, building and installation in one command invocation. See the description of "Using extension packages" section of the manual. (NB: this feature is still new and may have problems, but hey, let's give a try.) A couple of auxiliary scripts, gauche-cesconv and gauche-install can be called from Makefile. They don't have documentation yet, but try --help option for these scripts.
    • Module util.match: Andrew Wright's match macro is bundled. It is modified to handle Gauche's object system.
  • Improvements
    • A couple of performance tuning were done for I/O and loading Scheme files.
    • Now you can subclass <error> class as well as <exception> class to define your own error type. A new built-in macro guard, which is SRFI-34 compliant, can be used to handle errors selectively. Eventually the errors from built-in procedures will have more structured exception hierarchy.
    • New built-in system procedures: sys-lchown, sys-realpath.
    • Built-in sort routines now have stable versions, stable-sort and stable-sort!.
    • New built-in macro: let/cc.
    • New built-in keyword procedures: delete-keyword, delete-keyword!.
    • New built-in regexp procedure: rxmatch-num-matches.
    • Module file.util: new procedures: file-is-symlink?, file->string, file->string-list, file->list, file->sexp-list.
    • Module gauche.net: documented the previously experimental procedures: socket-send, socket-sendto, socket-recv, socket-recvfrom, socket-getpeername, socket-getsockname. Now these are official procedures.
    • Module gauche.process: process-command wasn't exported, even though it was documented.
    • Module gauche.test: you can control whether the error in the test procedure is reported or not by an envioronment variable GAUCHE_TEST_REPORT_ERROR and a global variable *test-report-error*. Useful to find a problem during testing.
    • Module www.cgi: new procedure cgi-get-metavariables; allows the user routine to take metavariables via cgi-metavariables parameter, so that cgi scripts can be easily modularized.
    • Module gauche.parseopt: support of "optional option-argument" is added.
    • Module gauche.array: homogeneous numeric array types are added.
    • Module text.html-lite: added frame-related tags.
  • Bug Fixes
    • Module gauche.charconv: Character-code guessing routine now returns IAEA-compliant CES name.
      The extended call-with-input-file procedure and its brothers now works with :if-does-not-exist #f.
    • Application of the user-defined subclass of <generic> now works. define-generic accepts :class keyword argument so that you can define a customized generic function conveniently.
    • srfi-13: Return value of string-contains was wrong when optional argument was given.
    • Source line information in the error message was off, since comment lines were not counted. This bug was introduced in but now it is fixed.
    • Gauche doesn't trust environment variables only if setugid'd. (Previously env var was ignored if you're root). This change allows the superuser to set his own GAUCHE_LOAD_PATH or GAUCHE_DYNLOAD_PATH.
    • port-seek didn't work if the port had a prefetched character.
    • The optional argument of add-load-path has been missing for the last several releases; now it is re-added.
    • Non-toplevel define-in-constant is now rejected. Non-toplevel define-in-module should also be invalid, but there may be a code that inadvertently relies on this buggy behavior, so this version just warns such usage.


Gauche-gtk 0.4:

  • An initial version of GLGD (GL graph draw) widget is included. If enabled at the configuration time, it allows applications to write a graph in gtk widget. Requires OpenGL and GtkGLExt. See glgd/README in the tarball for the details.
  • Lots of Pango APIs and some of Gdk APIs are added.


Release This release fixes a bug related to class redefinition. The bug caused the re-redefined class to lose methods defined to the original classes. Unless you're using class redefinition mechanism heavily, this bug won't bother you much. You can wait for the next release.

Other minor bug fixes:

  • string-concatenare-reverse now takes optional arguments as specified in SRFI-13.
  • If a thread terminated by an uncaught exception error, a stack trace of the terminated thread is now shown by default. Note that if another thread is waiting the terminated thread by thread-join, it is also get uncaught-exception exception; so if you do nothing to handle errors, you'll see two stack traces, one from terminated thread and the other from waiting thread.
  • Module www.cgi: cgi-get-query behaved weird when used interactively (Patch from Grzegorz Chrupala).
  • Module srfi-1: fixed a bug in lset-xor and lset-xor!, carried from srfi-1 reference implementation. (pointed out by Ueyama Rui).
  • Module sxml.sxpath: fixed a bug that prevented from using certain sxpath syntax.


Release 0.7.4 had a problem in dbm.fsdbm that its database format was incompatible to the previous versions. New release,, fixes the problem.


Gauche release 0.7.4:

  • Important change
    • util.list no longer extends srfi-1. Extending srfi-1 caused unexpected behavior when util.list was used with gauche.collection (if util.list was used after gauche.collection, it shadowed gauche.collection's extended methods like fold by the original srfi-1, which wasn't obvious). If you get an error that says some srfi-1 functions are undefined, add (use srfi-1) to the script. I hope most scripts already have it.
  • New Features
    • Added srfi-5 (extended let)
    • Added srfi-7 (program configuration langauge)
    • Added srfi-16 (case-lambda)
    • Added srfi-29 (localization)
    • Added srfi-38 (external format of shared structures)
    • Officially support text.gettext, a gettext-compatible module written by Alex Shinn.
    • Module www.cgi-test: CGI script testing framework.
    • New procedure sys-fork-and-exec for multithreaded applications to fork and exec more safely.
    • New builtin procedures: hash-table-num-entries, promise?
  • Improvements
    • VM stack handling is improved to fix the problem that made deep recursion very slow.
    • List handling code in C becomes more robust for very long lists.
    • Standard repl now uses write/ss (write with shared structure) by default, so it can print the result properly even if it contains cyclic structure. Error, debug and test messages also use it.
  • Bug Fixes
    • sys-glob raised spurious error on some platforms.
    • rfc.822, rfc.mime: were fragile for illegal character sequences.
    • Fixed the hang problem on FreeBSD w/pthreads.
    • gauche.net: keyword arguments for buffering was inconsistent to the spec.
    • rfc.uri: userinfo in the server name wasn't parsed correctly.
    • read-block couldn't handle request of length 0.
    • Configure couldn't handle colon-separated directories given to --with-local option.


Gauche release 0.7.3:

(This release changes C library API a bit, which potentially breaks existing C applications that uses gauche as a library. See 'C API change' below.)

  • New Features
    • Class redefinition is supported. You can now redefine a class definition and update existing instances of the class without changing instances' identity. The redefinition and update protocol is described in the "Object System" section of the reference manual.
    • You can also change the classes of an existing instance.
    • Slot access customization protocol is revised, so that a procedural slot can respond slot-bound?. For example, you can specify slot-bound? slot option for virtual slots to customize the behavior.
    • Regexp now supports non-greedy match (*?, +?, ??, {n,m}?).
    • New module: rfc.mime: parsing MIME (RFC2045) messages.
    • Built-in hash table hash functions eq-hash and eqv-hash are now available from Scheme.
  • Improvements
    • Documentation of the object system is added to the reference manual.
    • Interrupted system calls are now restarted by Gauche, when a signal handler returns. So you can now use alarm timer without worrying about interrupting system calls, for example. Note that if a signal handler throws an error (the default behavior) or invokes a continuation, the system call is not restarted.
    • make install installs autoconf macro file gauche.m4 under $(datadir)/aclocal.
    • gauche.net: sockaddr-addr and sockaddr-port are added.
    • gauche.charconv: with-input-conversion and with-output-conversion are added.
    • gauche.process: process-wait now accepts nohang optional argument, so the parent process can just check children's exit status without being suspended. Also added process-wait-any for convenience.
    • read-line now takes optional allow-byte-string flag argument, which allows read-line to read a byte string; it can be used to read from a port whose character encoding is unknown.
    • For input string ports, a procedure get-remaining-input-string is added.
    • The number reader now recognizes '#' padding of inexact numbers.
    • In the interactive mode, gosh loads a file ~/.gaucherc if it exists. This feature has been silently in Gauche for a while, but now officialy supported. Note that non-interactive use of gosh no longer loads .gaucherc.
    • gauche-init.scm is much lighter now, improving start-up time of gosh.
    • rfc.822: more parsing APIs are added.
    • text.html-lite: html-doctype is now capable to handle XHTML doctype as well. html-escape-string calls x->string on the argument.
    • On cygwin, load now recognizes DOS drive letter (yuck!).
  • Bug Fixes
    • Buffered port flushing protocol didn't work in some cases, causing gauche.charconv to chop the conversion output.
    • Macro expander had a bug that entered an infinite loop when ellipsis was used in incorrect level.
    • gauche.charconv: utf8->eucjp conversion routine incorrectly rejected 2-byte utf8 sequences which end with 0xbf. Also some cases of conversions from/to "none" encoding didn't handled properly.
    • gauche.parameter: there was a nasty bug that potentially corrupted memory.
    • gauche.selector: selector-delete! raised an error when only a procedure was specified.
    • slib: (require 'format) now uses SLIB format. Missing system was added, and slib:error now works correctly.
    • srfi-1: list= was missing from the autoload list.
    • srfi-14: ucs-range->char-set! didn't work for large charset.
    • srfi-37: Fixed a typo in the export list.
    • sxml.*: added missing APIs to export list, corrected misspelling of exported functions, and fixed a bug in make-char-quotator.
    • dbm: Custom accessor specification didn't handled well. Also there were some APIs missing in the export list.
    • dbm.fsdbm: dbm-fold passed a bogus key to the iteratee procedure.
    • A regexp optimizer bug prevented a specific pattern from working correctly. The affected pattern is the ones contain "a repeat of complemented charset followed by something except a char or a charset".
    • math.mt-random: (random-integer 1) didn't work.
    • text.tr: build-transliterator incorrectly used current-i/o ports when a transliterator was built; it should've used current-i/o ports when a transliterator was called.
    • util.lcs: lcs-with-positions didn't work when both sequences were empty.
    • util.queue: remove-from-queue! incorrectly raised an error when the only element in the queue was removed.
  • C API Change
    • Scm_Init now takes a 'signature' argument. The caller should pass GAUCHE_SIGNATURE. It is used to detect version mismatch between a main program and libgauche.so.
    • C-defined class categories are revised. See 'Class categories' comment in gauche.h. Changes are hidden within a macro, except that instances of a C-defined class which is intended to be subclassed by Scheme (i.e. SCM_CLASS_BASE category) have to have SCM_INSTANCE_HEADER instead of SCM_HEADER in them.

Gauche-gl release 0.3.1: Fixed bugs in matrix decomposition routine and configuration process. Adapted to Gauche-0.7.3.

Gauche-gtk release 0.3.2: Fixed a compilation problem on recent Gtk-2.2 releases. Added gtk-accel-group support and gtk-window-get-size (Patch from Michal Maruska).


Gauche release 0.7.2:

  • New Features
    • New module dbm.fsdbm: a dbm implementation that uses individual file to store each record.
    • Now a hash function can be defined to user-defined objects, by the object-hash generic function. Used with object-equal?, you can store user-defined objects in equal? hash table.
    • gauche.charconv: new procedures: call-with-input-conversion, call-with-output-conversion.
    • gauche.process: Enhanced process ports.
      • Incompatible Change: open-input-process-port and open-output-process-port now returns two values, the port and the process object. I found they are pretty much useless without returning the process object.
      • Process port functions now take various keyword arguments to support character encoding conversion and/or redirections.
      • Subprocess' error message goes to the stderr of current process unless redirected explicitly. (It used to go to /dev/null).
    • New module util.record: SCM compatible record library.
    • New procedures library-exists?, library-fold, library-map, library-for-each, library-has-module?: utility to query installed libraries.
  • Improvements
    • gauche.net:
      • Added make-server-sockets and make-sockaddrs in order to handle sockets under multiple protocols (such as ipv4 and ipv6). Patch provided by Kimura Fuyuki.
      • Now socket-close does not shutdown the connection, since other forked process may still be using it.
    • Improved performance of read-line, lcs-with-positions, sort, and sort!
    • Removed with-module and select-module from the null and scheme module---so that these modules, which are returned by null-environment and scheme-report-environment, will contain only the bindings given in R5RS.
    • www.cgi: let cgi-parse-parameters accept ';' as well as '&' as a parameter separator.
    • gauche.reload module is now autoloaded when gosh is started interactively.
  • Bug Fixes
    • gauche.charconv: fixed a bug that caused a buffer overflow and/or premature conversion under certain conditions.
    • Fixed a problem that caused pthread-cond_wait hang in RedHad9 NPTL.
    • Fixed a GC problem on Cygwin.
    • string-split now raises an error if the given splitter matches null string.
    • gauche.fcntl: constant F_SETFD wasn't exported (patch from Kimura Fuyuki).
    • math.mt-random: (random-integer (expt 2 16)) didn't work. Patch provided by Alex Shinn.
    • srfi-1: fixed typo, and changed the usage of (not (pair? ...)) to (null-list? ...). (Patch from Grzegorz Chrupala).
    • list-tail, quotient, modulo: fixed weird error messages.
    • sxml.sxpath: added missing sources and fixed export list (Patch from Hisazumi Kenji, Makoto Satoh).
    • Some extension libraries used memset incorrectly.
    • Revised build process so that gosh can be used fron build tree without installation. It would make packaging easier (esp. when you need to create 'slibcat' without installing the whole thing).
    • rfc.url (bug fix): improved uri-decode to handle some edge cases gracefully.

Gauche-gl release 0.3: Now it runs on Cygwin (with OpenGL 1.1.0-6, but without X).

Gauche-gtk release 0.3.1: Adapted to gtk-2.2.


Gauche release 0.7.1:

  • SXML framework is integrated to the main distribution; it includes SSAX XML parser, SXPATH query language, and Kirill Lisovsky and Dmitry Lizorkin's sxml-tools.
  • Updated to Boehm GC 6.2.
  • Added fluid-let macro (thanks to Dorai Sitaram).
  • Added an example source of Gauche extension in example/spigot directory.
  • text.html-lite now generates "<tag />" for empty elements, to be XHTML friendly.
  • www.cgi: cgi-header now accepts arbitrary keyword argument to add extra headers. :location argument no longer suppresses set-cookie header.
  • Variable *program-name* and *argv* are now set up before evaluating -u, -l, and -e options, so that the files loaded by these options can refer to these variables.
  • Bug fix: Polar notation of complex number (such as 1@1.57) might have not yielded exactly the same value as (make-polar 1.0 1.57) depending on the compiler's optimization strategy.
  • Bug fix: Renamed the field name 'private' in ScmPortRec to 'priv', to be C++ friendly.
  • Bug fix: Recover the rule to create slibcat after installation for SLIB.
  • Bug fix: in rfc.http, added fallback case when neither content-length nor transfer-encoding is provided by the server.
  • Bug fix: made char-ready?'s argument optional to comply R5RS.
  • Bug fix: in dbm.gdbm, value converter was used wrongly. (Thanks to Alex Shinn for a patch).
  • Bug fix: when compiled with --enable-multibyte=none, sometimes a character larger than #\x80 became wrong value. (due to signed-char/unsigned-char conversion).
  • Bug fix: installation process now honors DESTDIR variable, to make packaging easier. (Thanks to Kogule Ryo for a patch).
  • Bug fix: removed spurious -lgauche-uvector flag from gauche-config.


Gauche release 0.7:

  • New module: util.lcs and text.diff, finding the longest common sequence.
  • New module: binary.pack, Perl-like binary pack/unpack procedures.
  • Associative list library functions are added to util.list module.
  • let-args, a convenient macro to parse command-line arguments, is added in module gauche.parseopt.
  • Experimental IPv6 support is added by Kimura Fuyuki. If your platform provides IPv6, you can enable IPv6 support by configuring with --enable-ipv6. See INSTALL for the details.
  • Bug fix: certain floating-point numbers are printed incorrectly.
  • Bug fix: module gauche.array used nonexistent procedure.
  • Fixed a problem of dynamic loading on MacOS X with newer dlcompat library.
  • On cygwin, procedures in math.mt-random that requires gauche.uvector are now supported.


Gauche release 0.6.8: Maintenance release

  • Regexp engine improvement: now it is almost compatible to POSIX extended regexp, with Perl-like extensions such as non-capturing clustering and word-boundary assertion. See "Regular expression" section of the reference manual for the details.
  • '\w' in char-set and regular expression now includes underscore, following Perl and Ruby's convention.
  • Integrated a patch from HISAZUMI Kenji to enable pthreads on MacOS X.
  • Bug fix: made gauche.net thread-safe.
  • Bug fix: made autoload thread-safe.
  • Bug fix: made make-time in srfi-19 match the spec.
  • Bug fix: case-folding char-set didn't work for 'z' and 'Z'.
  • Bug fix: multibyte string-pointer operation failed in some cases.
  • Bug fix: fixed hash table's generic iterator (Patch from Kimura Fuyuki).
  • Bug fix: define-in-module SEGV-ed when non-existent module was given (Patch from Kimura Fuyuki).
  • Bug fix: next-token in text.parse module (Patch from Grzegorz Chrupala).
  • Bug fix: rfc822-parse-date didn't recognize some date format (Patch from OGURISU Osamu).
  • Bug fix: bignum operation behaved weird when an extremely large bignum was created. Now Gauche reports an error if a bignum exceeds the system limit.
  • Bug fix: reset # of values for each REPL.
  • Added a procedure intersperse in util.list. Also made util.list inherit srfi-1, so that it can be used as an extended srfi-1.


Gauche-gl release 0.2.2

  • New procedures are added to gl.math3d.
  • Fixed a problem that caused glut to eat CPU time. (Patch from Yokota Hiroshi).
  • Added glut example of gears.scm (Ported by Yokota Hiroshi).

Gauche-gtk release 0.3

  • Enabled Scheme to create a class inheriting <gtk-widget>. You can also create gtk widgets using standard make method, e.g. (make <gtk-window>)
  • Cleaned up memory management code. See README for details.
  • Adapted to Gtk 2.2 (Patch from Alex Shinn).
  • Adapted to gtkglext 0.6 and 0.7.
  • Fixed some problems in examples and in the code that caused compiler warnings (Patch from Yokota Hiroshi).
  • Added missing gdklib initialization (Patch from Kimura Fuyuki).

See the Packages page for the details.


Two bugs are found in 0.6.7, which can cause inconvenience in some applications. So the patched version,, is released. Fixed bugs are the following two:

  • copy-port fails when an integer number is given as the buffer size (:unit argument).
  • When ces-convert tries to convert an euc-jp or shift_jis string that consists of only one Kanji character to utf-8, it returns null string.


Gauche release 0.6.7 : more features.

  • New modules and extended features:
    • New module srfi-37: A yet another command-line argument processor.
    • New module util.combinations: Useful procedures for combinations, permutations, etc. Contributed from Alex Shinn.
    • New module util.list: additional list library.
    • Extended gauche.test: The default `test' procedure now catches an error in the test procedure. The new *test-error* variable is bound to a special "error value" which is returned when test catches an error, so that you can test a situation that should report an error. A macro `test*' is added which makes writing test cases a bit easier. A new test-module procedure tests module's consistency among autoloaded, exported, and defined bindings in it.
    • Extended gauche.charconv: Conversion procedures now accept symbols, as well as strings, as CES name; so you can pass the return value of gauche-character-encoding. Added ces-equivalent? and ces-upper-compatible? procedures to check CES compatibility. New procedures wrap-with-input-conversion and wrap-with-output-conversion only create conversion port when necessary. Semantics of CES name "none" is cleared.
    • Extended gauche.sequence: new iterators are added: fold-with-index, map-with-index, map-to-with-index, for-each-with-index, find-index and find-with-index.
    • Extended www.cgi: cgi-main can convert output character encoding.
    • Enhanced port operations: Improved performance of port->string family. A new procedure with-port-locking is added to improve I/O performance by locking the port. Added peek-byte.
    • sort and sort! can now sort vectors as well.
    • Added creation of modules dynamically by make-module. Anonymous, garbage-collectable module is now supported. It is useful for server applications.
    • load and load-from-port now accept :environment keyword argument to specify the module where the loaded code is evaluated.
    • Added hash-table (hash table construction procedure), and hash-table-fold.
    • directory-list in file.util now accepts :filter-add-path? keyword argument.
  • Bug fixes:
    • string=? signalled an error when complete and incomplete strings were given. Now it returns #f.
    • equal? didn't return #t even the given arguments were eq?, when the given arguments were user-defined objects but didn't have object-equal? method.
    • gauche.regexp: rxmatch-case might cause an infinite loop. (Patch from Kimura Fuyuki).
    • math.mt-random: mt-set-random-seed! always set the same value if a bignum was given.
    • text.csv: fixed a problem that consecutive tabs were coerced if a separater was a tab character.
    • rfc.uri: uri-encode had a problem with different character set from the native encoding was used.
    • gauche.net: applied a patch from John Kilburg to support datagram sockets.
    • gauche.net: fixed a problem that a socket could be garbage-collected before associated ports were released.
    • hash-table-map: fixed a problem when the hash table had an entry with #<eof> as a key.
    • srfi-1, srfi-13: added some missing autoloads. (Patch from Kimura Fuyuki).
    • Strings passed to sys-putenv were garbage-collected prematurely.
  • Other changes:
    • Literal uniform vectors in source code become immutable.


Gauche release 0.6.6 : lots of bug fixes and feature enhancements.

  • Bug fixes:
    • gauche.net had a nasty bug that caused memory corruption.
    • file.util: file-mtime=? etc. didn't work when string filename was given.
    • gosh sometimes crashed when call/cc is called inside do form.
    • make-string failed when negative length is given.
    • slot-missing and slot-unbound methods had a problem that caused infinite loop if they were called from write-object method.
    • srfi-19: fixed a bug in locale-dependent date reader (patch from Shin-ichi Hirata).
    • rfc.822: fixed handling of empty message header.
    • rfc.cookie: fixed old-style cookie formatting bug. (patch from KIMURA Shigenobu).
    • gauche.time: fixed typo (patch from Kimura Fuyuki).
    • Lots of patches for documentation: thanks to Kimura Fuyuki, Jiro KANAYAMA, KIMURA Shigenobu.
    • Made string interpolation syntax be expanded in reader, so that it works properly when used inside hygienic macro.
    • Multibyte character in regexp sometimes didn't work if the native encoding is UTF-8.
    • Fixed an inline assembly code of UADD that failed on FreeBSD with some intel-compatible processors.
    • Fixed SRFI-30 multiline comment reader.
    • Fixed hash-table iterater (patch from Kimura Fuyuki).
  • New modules and procedures:
    • util.digest, rfc.md5, rfc.sha1, rfc.hmac: message digesting and hashing modules, contributed from Kimura Fuyuki.
    • srfi-31: support of SRFI-31 (`rec' macro) is added by an autoloading macro.
    • gauche.hook: implements `hook' with Guile-compatible API.
    • gauche.parameter: parameters finally became thread-local, as in PLT Scheme. Also parameters can have hooks now.
    • You can now change the read/write pointer of the ports by port-seek and port-tell.
    • Added make-byte-string procedure.
    • Added has-setter? procedure.
  • Other changes:
    • string-split can now take not only a character but also a char-set, a string, a regexp or a predicate as a splitter.
    • srfi-14: ucs-range->char-set now works on non-ASCII characters.
    • open-output-file now accepts :overwrite for if-exists keyword argument, to specify overwriting file (without truncation) if the opened file already exists. Useful when used with port-seek.
    • gauche.logger: `lock-policy' slot is added to the log drain class, and it now works on MacOSX.
    • Removed gosh's feature to add the current directory and ../lib implicitly when it is invoked within the compiled source tree; now you need to give -ftest option in order to run gosh without installing it.

Gauche-gl release 0.2.1 : This release fixes build problem on FreeBSD (see INSTALL), and a couple of fixes in gl.math3d module.

Gauche-gtk release 0.2.4 : Added gtk-text-view and gtk-tree-model APIs. Fixed gtk-tree-view-set-cursor. The interactive listener can be set so that reading EOF will exits the application.


Gauche-gtk release 0.2.3 : Fixed a bug that the Scheme-level constructor created each widget twice. Support of gtk-dialog-new-with-buttons is added, too.


Gauche release 0.6.5 : various bug fixes and feature enhancements.

  • New Modules
    • rfc.http - http client methods.
    • gauche.reload - convenient routines for developers to reload modules.
    • gauche.listener - convenient routine to implement listeners (concurrent read-eval-print loop) in the conventional single-threaded application.
    • gauche.config - obtain configuration information of Gauche in the running Gauche script.
  • Helper macro let-optionals* is officially supported. Also added let-keywords*, get-optional, and get-keyword*.
  • Added uri-compose in rfc.uri.
  • New combinators: any-pred, every-pred
  • GC is updated to Boehm gc 6.1.
  • Fixed compliation problem of ext/uvector on some platforms.
  • Fixed sys-times that failed on some platforms.
  • Fixed object system to allow methods without required arguments.
  • Fixed a bug in string.c that didn't handle multi-byte string concatenation properly in certain situation. This also fixes the format problem that maxcol parameter of ~s directive didn't work well for multi-byte strings.
  • Fixed a bug in gauche.charconv that sometimes raised spurious errors.
  • Bug fix in gauche.procedure (arity-at-least-value)
  • Fixed VM to check the length of argument list passed to apply; it caused SEGV.
  • Improved performance of copy-port.
  • Use of syntax #"..." for incomplete strings is officially obsoleted; now it signals an error.
  • Unofficial port.* modules are moved to compat.*.
  • gauche-config script takes --mandir and --infodir now.
  • Module gauche.singleton and gauche.validator are renamed to gauche.mop.singleton and gauche.mop.validator. The original names still work for compatibility, but will eventually go away.

Gauche-gtk 0.2.2: You can now have interactive prompt even while gtk-main is running. It is implemented in gauche.listener. See README file for details. Lots of previously missing APIs are added, including support for GtkTreeStore, GtkTreePath, and GtkTreeSelection.


Gauche release 0.6.4 : minor bug fixes and feature enhancements.

  • Enhanced gauche.uvector: Added functions to do binary block I/O (read-block!, write-block), storage sharing (uvector-alias), conversion from/to strings (u8vector->string etc). The internal structure of uvector is changed to have data storage separate from the object header.
  • New module gauche.time: to measure timings of execution.
  • Command-line argument processing of gosh is fixed so that the stateful options such as -I, -e, -l, and -u can take effect in the order of appearance. (It used to group each type of option before process them). Also the new option -A (append load path after the current paths) and -E (evaluate expression, adding parenthesis around the given command) are added.
    Note that this change makes the initialization file gauche-init.scm to be read before any -I or -A option is processed. If you want to use non-standard initialization file, you have to specify it explicitly, as the followings:
                gosh -q -Imy/local/directory -lgauche-init
  • Enhanced gauche.sequence: inherits gauche.collection. Setter of subseq is added.
  • Added home-directory procedure to file.utils.
  • Performance improvements of some SRFI-1 procedures and port->string.
  • Bug fix in gauche.charconv that sometimes hang gosh when conversion of "iso-2022-jp" is used.
  • The default installation paths of info documents and manpages are reverted to the autoconf's default, ${prefix}/man and ${prefix}/info, which used to be ${prefix}/share/man and ${prefix}/share/info in the recent releases. You can change them by --mandir and --infodir configure options.

Gauche-gl release 0.2 : Added gl.math3d module that implements vector and matrix arithmetics for 3D homogeneous coordinates and quaternion arithmetics.


Gauche-gl release 0.1.6 : Added texture-related functions, gl-select-buffer and gl-feedback-buffer. Modified gl-call-lists to allow to take a string as either signed or unsigned byte-array. Added more examples. See Extension Packages.

Gauche-gtk release 0.2.1 : Applied the patch from TAGA Yoshitaka to fix compilation problem in UTF-8 encoding. Added gtk-radio-menu-item support. Extension Packages.

The last few releases of Gauche didn't include INSTALL file due to my mistake. This is the installaion insturuciton.


Gauche release 0.6.3 :

  • Improved the compiler and the VM. Call-intensive applications may observe 5%-10% performance improvement.
  • Object-apply hook: if non-procedure object is 'applied', a generic method object-apply is implicitly invoked. For example, if you define the following method:
        (define-method object-apply ((s <string>) (i <integer>))
          (string-ref s i))
    Then the call ("abcde" 2) evaluates to #\c. This works almost all the place where a procedure is allowed. For example, (map "abcde" '(1 2 3)) => '(#\b #\c #\d). See "applicable objects" section of the reference manual.
  • Regexp improvements:
    • <regexp> and <regmatch> objects become 'applicable', using the object-apply hook described above. This enables very compact notation. When a regexp object is applied to a string, it works as if rxmatch is called with the regexp and the string. When a regmatch object is applied to an integer, it works as if rxmatch-substring is called with the regmatch and the integer. A symbol before and after can be passed to regmatch object and they work as if rxmatch-before and rxmatch-after are called, respectively.
          (define m (#/(\d+) (\d+:\d+:\d+)/ "Sep 22 00:01:02 2002"))
          m           =>  #<regmatch>
          (m)         =>  "22 00:01:02"
          (m 1)       =>  "22"
          (m 2)       =>  "00:01:02"
          (m 'before) =>  "Sep "
          (m 'after)  =>  " 2002"
    • Case-folding regexp object, which uses case-insensitive match, can be created. For literal regexp, a suffix 'i' indicates case-folding regexp, e.g. #/abc/i. To create a case-folding regexp from a string, give a true value to the keyword argument case-fold of string->regexp. (Currently, case-folding only works in ASCII ranges; other characters match as they are).
    • POSIX character class notations, such as [:alpha:], is recognized in the regexp pattern.
    • Added procedures: regexp->string, regexp?.
  • Charset reader improvement: you can include POSIX character class notations, such as [:alpha:], in the literal character set, e.g. #[[:alpha:]].
  • Syntax for literal incomplete strings are changed from #"..." to #*"...". The old one is still recognized, but its use is deprecated; eventually the #"..." syntax will be taken by string interpolation feature, so please move to the new syntax if you're using the old one.
  • Added module: gauche.syslog - syslog(3) API.
  • gauche.logger improvements: now <log-drain> object accepts procedures to generate prefix. The log can be directed to system logger by specifying symbol syslog as the logfile path.
  • Bug fix in file.util: directory-fold signalled an error when the directory had a dangling symlink.
  • Added module: rfc.quoted-printable
  • Bug fix in math.mt-random: the DSO file is linked with :export-symbols #t, so that other extension modules that use C API of math.mt-random can work.
  • Bug fix in configure.in : changed autoconf variable GZIP to GZIP_PROGRAM, for the former interferes gzip's operation.


Japanese mailing list is moved from sourceforge.net to sourceforge.jp


There is a bug in Gauche-gtk that makes compiling fail if you're using Gauche in UTF-8 native encoding. A patch is provided by TAGA Yoshitaka.


Gauche-gtk 0.2 : Added GtkGLExt binding, <g-timer> support, <pango-font-description> support, and GDK keysyms support. See the Extensions page for the download instruction.


Gauche-gtk 0.1 : This is an initial release of GTK2 binding of Gauche. There are lots of missing APIs; try this and report bugs! See the Extensions page for the download instruction.


Gauche release 0.6.2 :

  • Module inheritance: modules can be inherited now. You can extend the existing modules, or bind them togehter into one module, using module inheritance. See the extended "Modules" section of the reference manual.
  • Added nested block comment #| ... |#. This is defined in SRFI-30 and compatible among lots of popular Scheme implementations.
  • Added debug stub feature (#?=). See "Debugging" section of the reference manual.
  • Bug fix: when SIGINT handler was installed and read was interrupted, the read procedure returned EOF. (Thanks to Julian Fondren for reporting this).
  • Bug fix: enable-debug hasn't been working for some time.
  • Bug fix: regexp worked incorrectly for patterns like #/a|(b)|c/ (thanks to Alex Shinn for reporting this).
  • The default signal handler for SIGHUP, SIGQUIT and SIGTERM now terminates the interpreter. So gosh terminates properly when run under Emacs and the Scheme buffer is killed.
  • New procedures: fixnum?, bignum?, string-pointer-copy, string-pointer-byte-index (these two are contributed by Alex Shinn), keyword->string, read-eval-print-loop, sys-nanosleep.
  • New procedures in util.queue: queue-length, list->queue, queue->list, find-in-queue, remove-from-queue!.

Gauche-gl release 0.1.5:

  • Now it runs on MacOS X, thanks to KIMURA Shigenobu for a patch.
  • Fixed a bug in glut-init.
  • Added gl-call-lists, and some GL1.2 extension procs.
  • Added some more examples.


Release 0.6.1 : minor fixes.

  • Bug fix: fixed the stack trace in the default error message which was broken since the last release.
  • Bug fix: gosh sometimes went into an infinite loop or dumped core when used as a slave process of Emacs and the Emacs is killed. (Thanks to Sakae for pointing this out).
  • The stub generator script is improved. The new format allows more compact notation. It is not fully compatible with the older versions.
  • Gauche-gl 0.1.4 is also available. Just changed the stub file format to the new ones.


Release 0.6

  • Multithread support: Thread library is available on top of pthreads, if the platform supports it. Scheme-level API is SRFI-18 compatible. You need to configure Gauche with '--enable-threads=pthreads' option to enable thread support; see the INSTALL file in the distrubution for details. See also the list of platforms the author checked on which threads can be used.
  • Now info documents are created and installed by default.
  • On-line documentation. In the interactive mode, you can browse info file entry of a procedure or a macro by info procedure, if info file is installed. Try (info 'info), for example. See the manual entry of gauche.interactive module. This is an experimental feature to see if it's useful or not; give me your feedback.
  • Several bug fix and cleanup in signal handling. Added set-signal-handler!, get-signal-handler and get-signal-handlers. Added sys-sigmask and sys-sigsuspend. Fixed sys-pause that had missed some signals to catch.
  • In gauche.net module, allow socket-bind and make-server-socket to accept 0 as port number and let the system assign the port. (Thanks to ODA Hideo for a patch).
  • Bug fix in eqv? and equal? : (eqv? 1 1.0) should be #f, but it returned #t. So as equal?.
  • Bug fix in call/cc and dynamic-wind handling. When you assigned continuation to the top-level variable and re-invoked it later, dynamic-wind stack wasn't called properly in certain situations.
  • Bug fix in reading library path from the environment variable (thanks to Alex Shinn).
  • Bug fix in gauche.uvector code that caused random crash with s64vector/u64vector.
  • Bug fix in gosh that didn't flush buffered ports when it is used non-interactively and Scheme's main function returns. (thanks to Fujii-san).


Release 0.5.7

  • Updated Boehm GC to version 6.1alpha5.
  • Characters can be written in Unicode, as #\uXXXX or #\uXXXXXXXX, or embedded in literal strings as \uXXXX or \UXXXXXXXX. If Gauche's internal character encoding is not UTF-8, they are converted to internal encoding by the reader. Procedures char->ucs and ucs->char are also provided.
  • Added SRFI-25 (multi-dimensional arrays) support as gauche.array module. See "Arrays" section of the reference manual for details.
  • Added SRFI-26 (cut and cute macros for specializing parameters) support. See "Making procedures" section of the reference manual.
  • Added SRFI-28 (basic format strings) support by simply extending the existing format to allow to omit the port argument.
  • Renamed module srfi-4 to gauche.uvector and added lots of arithmetic operations on the homogeneous numeric vectors. The old module srfi-4 still works as an alias of gauche.uvector.
  • Fixed a bug in the UTF8 to EUC_JP conversion routine in gauche.charconv module.
  • Added make target 'uninstall'.


Release 0.5.6 : Bug fix and feature enchancements.

  • Supports JIS X 0213:2000 japanese character set. Conversion between EUC_JP, Shift JIS, UTF-8 and ISO2022JP(-n) is handled in Gauche's internal routine instead of iconv(). So you can use Japanese no matter whether the platform has proper iconv() or not. See gauche.charconv section of the reference manual for details.
  • SRFI-27 (Source of random bits) is supported.
  • Added macro dolist; I couldn't regist the temptation.
  • Fixed a bug that caused active objects in DLL to be garbage-collected on cygwin platform.
  • Fixed a bug that char->integer returned wrong number (thanks for Sven Hartrumpf).
  • Fixed gosh's usage message (thanks for Sven Hartrumpf).
  • vector-fill! takes optional start/end argument (parallel to SRFI-13 string-fill!).


Release 0.5.5 : Feature enchancements.

  • New module math.mt-random : implements Mersenne-Twister random number generator.
  • New module srfi-19: supports SRFI-19 (Time data types and procedures).
  • New procedure pa$ (partial apply), compose, and some combinator-like procedures like map$, for-each$. See "Combinators" section of the reference manual for details. For example, you can program like:
           (define map2* (map$ (pa$ * 2)))
           (map2* '(1 2 3)) => (2 4 6)
           (define dot-product (compose (apply$ +) (map$ *)))
           (dot-product '(1 2 3) '(4 5 6)) => 32
  • New procedures copy-file, move-file, touch-file and find-file-in-paths in file.util module.
  • New procedures arity, procedure-arity-includes?, arity-at-least-value to query procedure's arity. See "Procedure arity" section of the reference manual.
  • New syntax define-constant, set!-values, begin0, let1.
  • New module math.const : provides some useful constants like pi and e.
  • New system procedure sys-utime.
  • New built-in type <time>, a SRFI-compatible time representation. SRFI-18 procedures current-time, time->seconds and seconds->time are also provided.
  • Built-in sort function is improved for the worst case.


Release 0.5.4 : Feature enhancement, mostly on I/O.

  • Buffered port routine is rewritten to use Gauche's own buffering code instead of stdio. This improves I/O performance, reduces code size, and allow programmers to control buffering behavior in detail. This also causes the following changes.
    • char-ready? works on buffered port.
    • File port routines (such as open-{in|out}put-file, also socket-{in|out}put-port) takes the buffering keyword argument to customize buffering behavior. See "File ports" section of the reference manual for details.
    • The behavior when you mix character I/O and byte I/O is fixed.
    • flush-all-ports is added.
    • open-input-fd-port and open-output-fd-port are added to open buffered file port around a file descriptor.
  • Lots of high-level file/directory utility functions are added as file.util module.
  • Added weak vector. See "Weak pointer" section of the reference manual.
  • Added parameters. See gauche.parameter section of the reference manual.
  • Added pseudo tty interface, sys-openpty and sys-forkpty. See "Termios" section of the reference manual.
  • Added define-values.
  • Added port?.
  • System objects, such as <sys-stat>, <sys-group> and <sys-passwd>, are integrated to the object system. Information of these objects can now be accessed via slots, instead of individual procedures.
  • Improved dynamic string handling performance.
  • Fixed a nasty bug in metaobject protocol handling code that corrupted memory.
  • Fixed a compiler bug that prevented proper tail recursion in some cases.


Release 0.5.3 : bug fixes.

  • Number I/O routine is rewritten. Now it reads and writes floating-point numbers almost accurately. It reads exactness prefix and radix prefix correctly, recognizes rational number syntax (it is coerced to real numbers) and magnitude@angle notation of complex numbers.
  • Fix: module slib now works with slib2d3, and install process generates the slib catalog file (slibcat).
  • Fix: (write* '#()) was broken.
  • Fix: compiles a let* form with more than one variable of the same name, like (let* ((x 1) (x (+ x 1))) x).
  • Added procedures: print, decode-float, min&max.


Gauche reports an error when you try to use slib2d3. To avoid this, please alter the definition of 'use' macro in src/gauche-init.scm for the following code.

    (define-macro (use module)
      (let* ((mod  (cond ((symbol? module) module)
                         ((identifier? module) (identifier->symbol module))
                         (else (error "use: symbol required:" module))))
             (path (string-join (string-split (symbol->string mod) #.) "/")))
        `(begin (with-module gauche (require ,path))
                (import ,mod)))


Release 0.5.2 : bug fixes and minor feature enhancements.

  • New feature : String interpolation. A reader syntax #`"..." is expanded to a form that evaluates to a string interpolating embedded Scheme exressions. For example, #`"The result is ,(+ 2 3)" evaluates to "The result is 5". See String Interpolation secion of the reference manual for details.
  • Bug fix in the legacy macro expander.
  • Bug fix: sys-mkstemp wasn't working.
  • Bug fix: the implementation of call-with-input-file etc. was incorrect; it didn't work when a continuation captured inside the dynamic environment of the function was restarted.
  • Bug fix: text.html-lite escaped backslashes in parameters incorrectly.
  • Fix the build problem on Cygwin.
  • Supports more POSIX and other C compatibility functions.
  • New module: file.filter
  • Added manpages.
  • RPM packages are created.


Patch for 0.5.1 is available. It fixes two problems.

  • MacOS X (Darwin kernel version 5.2): 0.5.1 failed to build extensions.
  • Cygwin: 'configure' sometimes fails to generate necessary files for extensions.

You don't need this patch for other platforms.


Release 0.5.1 : ports and fixes

  • Ported to Cygwin: DLLs and dynamic loadable extensions now works on Windows 2000/Cygwin 1.3.9.
  • Ported to HP-UX 11.0 and back-ported to FreeBSD 2.x : thanks for Abe Hiroshi, Gauche works on these platforms as well.
  • Bug fix (Incompatible change): The way gosh passes command-line argument to main is changed in order to conform finalized SRFI-22. Older Gauche scripts may not work because of this change. See "Script compatibility before release 0.5" for details.
  • Bug fix: some numeric functions and uniform vector accessors didn't work for out-of-range argument. (Patch provided from Abe Hiroshi).
  • Bug fix: read-byte returned EOF on some platforms when it reads the byte larger than 0x7f. (Patch provided from Abe Hiroshi).
  • Bug fix: apply didn't work when VM instructions were passed. (Patch provided from Abe Hiroshi).
  • Bug fix: cond-expand (srfi-0) didn't work at all. Now it works, and it is autoloaded. A feature id 'gauche' is recognized, so you can write a portable script by putting Gauche specific forms inside (cond-expand (gauche ...)).
  • Fix: when given a script file in relative pathname, gosh searches it from the current directory first, even the current directory is not in the load path. This is consistent for other script interpreters, and doesn't introduce vulnerability of adding "." to the load path.
  • Fix: character mnemonics (such as #\newline) are recognized in case-insensitive way even if the reader is case-sensitive mode.
  • gosh supports -l(load) and -e(eval) options. The load option loads the file, and the eval option evaluates the given expression in the command line.
  • gauche-config supports --ac and --reconfigure options; try gauche-config --help for details.
  • Added gauche.version module.
  • XML parser module is available as an external package. See packages.


Fixed a link to the Japanese manuals in the Document page.


Release 0.5

  • Signal handling support is added. You can handle signals in Scheme script by with-signal-handlers macro. See the 'Signals' section of the reference manual for details.
  • Important Change: Gauche now reads symbols in case-sensitive way by default. A command-line option is provided to preserve R5RS conforming case-insensitive reader. See the 'Case-sensitivity' section of the reference manual for details.
  • Bug fix: a compier optimizer's bug made VM calculate (+ 1 (if 0 1)) incorrectly.
  • Bug fix: exit rewinds dynamic handlers.


Release 0.4.12: maintenance release

  • Bug fix: SJIS and UTF-8 supports have been broken. The test case is created for both, and now they work.
  • Bug fix: the legacy macro expander works incorrectly when defined as (define-macro foo (lambda (arg ...) body ...)).
  • Bug fix: eval now recognizes its second argument.
  • Bug fix: some fixes in the debugger.

It is reported that gauche.charconv module may have a problem with libiconv 2.x on FreeBSD 4.4 (in /usr/local). It appears that GNU libiconv works instead. See INSTALL in the tarball for details.


Patch: release 0.4.11 has a bug that the stack is not reset on error in the interactive environment, and makes subsequent error messages messy. Patch is available at ../vault/Gauche-0.4.11.patch.


Release 0.4.11:

  • Important change: the current directory ``.'' is no longer included in *load-path* by default. You should give -I. command-line flag or use add-load-path form explicitly to include ``.'' in the load path if you want.
  • Autoload feature is extended. Now you can set autoload for macros, and you can autoload modules as well as files. The gauche.regexp module is set to be autoloaded so that you don't need to use it explicitly.
  • Stack trace on error now shows source file info if available.
  • An experimental debugger is added. Evaluate (enable-debug) on top level sets the debugger hook, and after that, an interactive debugger is activated on error. You can't do much yet; just examine environment and stack frames. (disable-debug) disables the debugger.
  • A SRFI-18 style low-level exception handling mechanism is integrated to the higher-level error handling mechanism. See ``Exceptions'' section of the reference manual.
  • A command line argument -fload-verbose makes gosh report whenever it loads files. Useful to check which file it is loading.
  • Format directive ~a and ~s are extended so that you can specify maximum columns to be used as well.
  • Bug fix: dynamic-wind now returns multiple values correctly.
  • Bug fix: r5rs macro expander handles a template (?x ... . ?y) correctly when ?x ... is empty.


Release 0.4.10:

  • Implemented a framework for generic iteration over collection-type classes. Using gauche.collection module, iterative procedures such as map or find became a generic function and work on any collections/sequences.
            (fold + 0 '#(1 2 3 4)) => 10
            (map-to <vector> + '#(1 2 3) '#(4 5 6)) => #(5 7 9)
            (subseq '#(a b c d e) 1 4) => #(b c d)
    See the reference manual for details.
  • Most of built-in classes have its own metaclass. This allows you to define ``class methods''.
  • New modules that uses metaobject protocol: gauche.singleton and gauche.validator. The latter allows you to define a class that can check validity of slot values when it is modified.
  • (write '(quote a)) writes 'a.
  • Handling of internal classes and slots are cleaned up.
  • Bug fix: is-a? signalled an error when the second argument is not <class> but its subclass.
  • Bug fix: (list-ref '(a b c) 3) caused SEGV. Yuck.
  • Bug fix: srfi-1 had a bug in assoc-delete!
  • Bug fix: www.cgi module had bad procedure call for default error page generation.
  • Bug fix: metaobject protocol compute-get-n-set was incompatible with STklos.
  • Bug fix: character conversion port failed to open empty string.
  • Bug fix: eqv?-type has had wrong type value.


Release 0.4.9: library enhancement and bug fixes, again

  • Module enhancement for CGI script writing. Several procedures are added to www.cgi. New module text.html-lite and text.tree help to build HTML document quickly and easily.
  • New module: util.queue - Fast queue library
  • Feature addition: call-with-{input|output}-file and with-{input-from|output-to}-file now takes keyword arguments as open-{input|output}-file.
  • Bug fix: There was a serious bug in the metaobject protocol implementation that caused SEGV.
  • Bug fix: read-line recognizes various line terminators (\n, \r, and \r\n).
  • Bug fix: #[] is correctly read as an empty charset.
  • Bug fix in regexp.


Release 0.4.8: Yet another round of library enhancement and bug fixes

  • GC code now uses Boehm GC version 6.0. It seems that the problem on FreeBSD is fixed. (Can somebody test on NetBSD?).
  • Incompatible change: module w3c.cgi is renamed to www.cgi
  • DBM interface is added: dbm, dbm.gdbm, dbm.ndbm and dbm.odbm modules. See the reference manual for details.
  • New modules: util.isomorph, util.toposort, text.tree. Please see the reference manual for details.
  • Bug fix: string-substitute! corrupted memory.
  • Bug fix: autoload now properly treats reference of variables that is set to be autoloaded.
  • Bug fix: equal?-hashtable didn't work at all.
  • Bug fix: string-index (SRFI-13) now works correctly with start/end optional arguments.


Release 0.4.7: Another round of library enhancement and bug fixes

  • Added CL-like macros: dotimes, push!, pop!, inc!, dec!.
  • Extended list-ref, vector-ref and string-ref to take an optional argument.
  • Extended logand, logior and logxor to take more than two arguments.
  • Fixed a problem of gosh command-line processing code that intercepted the options given to the script, not to gosh itself.
  • Added a input stream parsing library text.parse, which is API-compatible to Oleg Kiselyov's input-parse.scm.
  • Bug fixes. (thanks to TAGA Yoshitaka).
  • Japanese version of reference manual is available.
Also releasing Gauche-gl 0.1, an OpenGL binding of Gauche, in a separate package. It covers most of OpenGL 1.0/1.1 functions and some of GLU and GLUT functions. It run with Mesa as well.


Release 0.4.6:

  • Incompatible change: system constants (such as R_OK for access(2)) are now all uppercase, and needed to be escaped (e.g. |R_OK|) in the source code. This change is for consistency. There are several definitions to maintain compatibility of old code, but it will be removed soon.
  • Various library modules are added: character transliteration (text.tr), CSV parsing (text.csv), CGI utilities (w3c.cgi), URI parsing (rfc.uri), HTTP cookie parsing (rfc.cookie), etc.
  • Added useful file-related utilities: file-exists?, file-is-directory?, file-is-regular?.
  • VM now prints meaningful stack trace on error.
  • regexp-replace[-all] is implemented in gauche.regexp.
  • A built-in function string-scan for efficient parsing.


Release 0.4.5:

  • Important bug fix: the previous version reported ``assertion failed'' when an error occured during executing scripts non-interactively.
  • Added SRFI-10, sharp-comma syntax support.
  • Added keyword arguments such as :if-exists and :if-does-not-exist to open-input-file and open-output-file, allowing finer control over file operation.
  • Added fcntl support in the module gauche.fcntl.
  • gauche.logger module, simple user-level logging functions.
  • A couple of bugs fixed in regexp
  • Several bugs that caused problems on LP64 architectures fixed thanks to Abe Hiroshi.


Release 0.4.4:

  • Error handling mechanism is added. VM structure is changed to support it efficiently. See "Exceptions" section of the reference manual.
  • termios support. See gauche.termios section of the reference manual.
  • Added gauche.selector, simple event dispatcher based on select(2).
  • Added process-output->string and process-output->string-list to gauche.process module, which invoke subprocess and return its output.
  • Added an appendix to the reference manual describing correspondence of C library and Scheme functions.


Release 0.4.3: Maintenance release. I won't be able to do much on Gauche for a few weeks more, so decided to wrap up changes and bug fixes. The reader is now less strict than R5RS, accepting symbols and numbers widely used but not strictly R5RS (e.g. ".12" is read as an inexact number 0.12). It also recognizes |-escape for symbols with special characters. "Apropos" is extended. A couple of bugs in VM are also fixed. Adapted to autoconf-2.52.


Release 0.4.2:

  • Applied a patch by KIMURA Shigenobu for MacOS X port.
  • SRFI-9 (record type) is supported
  • Improved format function. Now it supports ~d, ~o, ~x and ~b format directives, and supports parameters and flags like CommonLisp.
  • Fixed a bug in macro expansion, character reader, number printer, and compiler for case form.


Release 0.4.1:

  • Finally, the code to handle VM stack overflow is implemented.
  • A command-line option parser gauche.parseopt is added. See the reference manual for details.
  • Fixed a bug in ext/net, and a few configuration problems.


Release 0.4: Several incompatible changes for the consistency of the design. A few bugs are corrected as well.

  • error procedure is compatible with SRFI-23, i.e. it doesn't call format any longer, but just prints out its argument. Lots of other Scheme implementations have the same API. The old version of the function that uses format is renamed to errorf.
  • When invoked as a script interpreter, gosh calls a function main if it is defined, and if it returns an integer, gosh uses the value as the exit status of the script. This behavior is upper-compatible with SRFI-22 draft.
  • sys-pipe and sys-wait returns multiple values instead of a cons of them.
  • Changed the install location of site specific extension modules (Gauche's version number is included in the pathname).
  • Undocumented macro let-optional* is renamed to let-optionals*, compatible with scsh.
  • sockaddr-family now returns a symbol instead of a keyword.
  • call-with-io-process is renamed to call-with-process-io
  • Fixed a couple of bugs in make-server-socket.


Notice: dynamic loading extensions doesn't work on NetBSD/i386 and FreeBSD/i386. Needs to fix GC stuff, which will take some time.


Notice: on some OS, building ext/net/libnet.so fails for an error like "gethostbyname_r undefined". If so, obtain Gauche-0.3.15.patch from the archive. Apply it under the ``Gauche'' directory that is created by expanding Gauche-0.3.15.tgz.


Release 0.3.15:

  • Added networking module ``gauche.net'', that provides socket-based interface API. See the description of gauche.net module in the reference manual.
  • When gosh is invoked with a Scheme script that defines a procedure named `main', gosh calls the procedure with command-line arguments after the script is loaded. This behavior is in proposed draft SRFI-22, and makes writing scripts easier. (SRFI-22 is still in draft, and this behaviro may change later.)
  • Added more system functions, such as select(2) interface.
  • Added process ports, an easy API to communicate with subprocesses.
  • The internal C API of class objects are changed a lot.


Release 0.3.14: Added a character encoding conversion module ``gauche.charconv''. It uses iconv() to convert various character encodings, as well as providing a functionality to guess the encoding of data stream. For details, see the description of gauche.charconv module in the reference manual.

Also several bugs in port and regexp code are fixed.


The online reference manual is available from the document page. It is not finished yet; it's more like a list of available Scheme functions.


Release 0.3.13: Maintenance release: fixed a problem in the release 0.3.12 that compilation fails if you don't have iconv. Some bugs in uvector, bignum and dynamic loading are also fixed.


Release 0.3.12:

  • Ported to NetBSD, by a patch from MINOURA Makoto.
  • Adapted to a portable Scheme library, SLIB Say (use slib) and you can use slib features. See INSTALL for details.
  • sys-time returns # of seconds from Epoch.
  • Started to write a reference manual. You'll find texinfo and html documents under doc/ of in the distribution. Right now it just lists the names of the function, though.


Release 0.3.11: This release is one step before the character conversion support. Improved code in string.c to support "incomplete strings", i.e. strings that don't consist valid multibyte sequences. The concept of immutable strings is implemented; literal strings are immutable now, and it is an error to modify such strings. String API is changed in incompatible way.

Literal incomplete string is denoted as #"...". Reader and printer are modified to handle it.

Also some logical (bitwise) operations are added to number.c.


Release 0.3.10: Numerical code revisited. Analytical functions start working on complex numbers. Now Gauche can plot the figures in "Common Lisp, the Language 2nd Edition", section "Numbers". (The Scheme program ported from the code shown in pp.339-349 of CLtL2 is not included in the distribution, but if you're curious, drop me an e-mail).

Also several bugs around VM and numeric code are fixed.


Release 0.3.9: Added almost complete set of SRFI-13, a rich string library. And now Gauche supports UTF-8, Shift-JIS and no multibyte (8bit fixed) character strings, as well as EUC-JP (though they're not tested very well except EUC-JP).. It's a configure-time choice. See INSTALL for details.


Release 0.3.8: Number of bugs around division of bignums are fixed. Finally gcd and lcm are implemented. Three R5RS string routines are extended as in SRFI-13.


Release 0.3.7: Numeric code is overhauled; number of bugs around input/output of integers, inlined numeric calculation code, and addition/subtraction/multiplication of bignums are fixed. Regexp now recognizes \s, \S, \d, \D, \w, \W. Reader recognizes #[...] as a literal character set.


Release 0.3.6


Release 0.3.5