Older News

2007/4/18

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.

2007/1/17

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.

2006/11/18

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

2006/11/11

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.

2006/4/12

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

2005/11/4

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.

2005/6/30

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.

2005/6/6

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.

http://practical-scheme.net/vault/autoloads.c
http://practical-scheme.net/vault/compile.c
http://practical-scheme.net/vault/scmlib.c
http://practical-scheme.net/vault/objlib.c

2005/5/31

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.

2004/12/2

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.

2004/11/29

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.

2004/8/2

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.

2004/6/26

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.

2004/5/22

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 0.7.4.2 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.

2004/3/18

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.

2004/2/26

Release 0.7.4.2: 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.

2004/2/4

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

2004/2/3

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.

2003/12/16

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).

2003/10/4

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.

2003/7/23

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.

2003/5/30

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.

2003/3/30

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.

2003/2/10

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.

2003/2/7

Two bugs are found in 0.6.7, which can cause inconvenience in some applications. So the patched version, 0.6.7.1, 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.

2003/2/6

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.

2002/12/15

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.

2002/11/20

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.

2002/11/14

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.

2002/10/14

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.

2002/9/24

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.

2002/9/21

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.

2002/9/17

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

2002/9/14

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.

2002/9/12

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.

2002/9/6

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.

2002/9/2

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.

2002/7/31

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.

2002/7/18

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).

2002/6/30

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'.

2002/6/14

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!).

2002/5/27

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.

2002/5/4

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.

2002/4/15

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.

2002/3/30

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)))
      )
    

2002/3/8

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.

2002/2/16

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.

2002/2/14

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.

2002/2/2

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

2002/1/30

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.

2002/1/7

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.

2001/12/21

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.

2001/12/20

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.

2001/12/2

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.

2001/11/14

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.

2001/11/1

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.

2001/10/14

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.

2001/9/29

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.

2001/9/17

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 oper