An implementation of Scheme in the C language
                             No right reserved
                                     or
                             No warranty given
                                     by
                 Kiyokazu SUTO <suto@merry.xmath.ous.ac.jp>

  This is an implementation of the programming language Scheme conforming to

             Revised^4 Report on the Algorithmic Language Scheme.

  All  the  features  but  the  procedure  `char-ready?' in  the report  are
implemented. (Anyone have any idea to implement `char-ready?' which works in
multi-byte character environments?)

  In addition, the following extensions are available:

support for multiple character encoding systems
    Codes for EUC and Shifted JIS (`c/euc.c' and `c/sjis.c') are included.

dynamic wind and exception handling
    For each feature, two  versions are  included: one  is compliant  to the
    proposals in

      ftp://ftp.cs.indiana.edu/pub/scheme-repository/doc/prop

    and  another  is  very  dependent of  my implementation.  The former  is
    written by making use of the latter.

package and multiple values
    They resemble those in Common Lisp, but are not exactly the same.

plug-in's
    Common Lisp  compatible logical  operations on  integers, interfaces  to
    GNU's regular expression library (regex),  and interfaces  to X  Toolkit
    Intrinsics and Athena widget set.

  $1. Files
  =========

readme.doc
    This file.

builtin.doc
    The list of built-in objects with brief expositions.

readme.sj
    More detailed document written in Japanese (encoded with so-called Shift
    JIS).

makefile.ux, makefile.dos
    Makefiles for UNIX and MS-DOS respectively.

c/
    Directory of C sources.

scm/
    Directory of Scheme sources.

scm/sys/
    Directory   of   Scheme   sources   using   implementation   dependent
    functionalities.

scm/sys/init.opt
    List of the scheme sources required for the 1st making  of a  dump file.
    As for the dump file, imagine a format file in type-setting by TeX.

  C sources are written for C compilers conforming to the  ANSI standard.  I
strongly recommend to use the GNU C complier (version 2.5.8  or higher)  and
the GNU make (version 3.71 or higher).

  $2. Installation
  ================

  In the following, the symbol `${TOP}' represents the  directory where  you
have extracted the files from the archive.

  First of all, make a directory  for binaries.  The name  of the  directory
must be equal to the value of `BIN' described below. If your  C compiler  is
djgpp (emx/gcc, or BC++, resp.), and if you chose any name other than `dj' (
`em',  or  `bc',  resp.) ,  you  need to  change the  corresponding part  of
${TOP}/c/makefile.dos.

  Then  copy  ${TOP}/makefile.{ux,dos}  to  ${TOP}/makefile, and  change the
definitions of variables in it according to your environment.

  The variables `BIN' (the directory for binaries),  `TOP' (the  top of  the
directory tree as noted above), and `BINDIR'  (see below)  must  be properly
re-defined.

  You can enable some optional features by defining the variable `EXDIRs' as
a  space-separated  list  of  subdirectories  (excluding  the last  `/')  of
${TOP}/c/. The possible choices at present are:

logop
    Logical operations on integers conforming to CLtL 2nd ed.
regex
    Interfaces to the GNU regular expression library (regex 0.12).
xt
    Interfaces to X Toolkit Intrinsics and Athena widget set.

  After you've modified the  definition of  `EXDIRs', you  have to  re-build
some makefiles and header files in  ${TOP}/c/ by  performing `make  config',
which requires perl.

  Then, following  the standard  procedure `make  all ;  make install',  you
shall have the binaries in the directory specified by `BINDIR'.

  $3. Command Line Options
  ========================

  The  following  command  line  options  are  encoded  in  the   C   source
${TOP}/c/init.c (the first line is what I've input at command line).

% bin/sick -?
bin/sick 3.05
@[<option file>]
!<token> : re-evaluate <token> in the command line
<variable>=[<value>] | {<variable>}=[<value>]
  : same as `(define <variable> "<value>")'
- : end of options
-stdout+ | -stdout- | -stdout <device> : open <device> as standard output
-stdin+ | -stdin- | -stdin <device> : open <device> as standard input
-myname <path> : use <path> as the name of the executable file
-dump+ | -dump- | -dump <file>
  : open <file> to make/read a dump file,
  : where the open mode is determined in the same way as
  : the Scheme procedure call
  : `(open <file> <the name of the executable file>)',
  : and the name `-' is interpreted as STDOUT/STDIN
-perm <permission>
  : <permission> must consist of
  :   `r' (to read a file),
  :   `w' (to write to a file or create a file),
  :  or
  :   `x' (to execute an external command)
-hello[-] : startup message
-bye[-] : shutdown message
-gcv[-] : gc verbose
-ov[-] : output verbose
-iv[-] : input verbose
-lv[-] : load verbose
-b[-] : batch mode
-h <heap size in bytes>
-s <stack size in bytes>
-hmax <heap size limit in bytes>
-smax <stack size limit in bytes>
-- : all options reset to default values
-? : display this message and immediately exit

  All  or  part  of  them  are  actually  recognized,   according   to   the
configurations for the binary.  Here are  additional expositions  about some
options.

@[<option file>]
    The contents of <option file> are embedded here.

<variable>=[<value>] | {<variable>}=[<value>]
  : same as `(define <variable> "<value>")'
    If you define a variable whose name includes the character  `=', enclose
    it with `{' and `}'.

-stdout+ | -stdout- | -stdout <device> : open <device> as standard output
-stdin+ | -stdin- | -stdin <device> : open <device> as standard input
    If these  options are  turned on,  the standard  output or  the standard
    input  is  always assumed  to be  tty, even  if <device>  is actually  a
    regular file. The string `-' as <device> implies the standard  output or
    standard input. `-stdout+' and `-stdin+' are  equivalent to  `-stdout -'
    and `-stdin -' respectively.

-dump+ | -dump- | -dump <file>
  : open <file> to make/read a dump file,
  : where the open mode is determined in the same way as
  : the Scheme procedure call
  : `(open <file> <the name of the executable file>)',
  : and the file name `-' is interpreted as STDOUT/STDIN
    The  file  name  and  open  modes  are recoded  in the  Scheme variables
    `dump-file-name',   `output-mode-for-dump-file',   and
    `input-mode-for-dump-file', respectively, in the following forms:

    dump-file-name
        File  name  (where  the  characters  indicating  the open  modes are
        removed) or `#f'.
    output-mode-for-dump-file
        `#t' (output to a file), `#\|' (output to a pipe), or `#f'.
    input-mode-for-dump-file
        `#t' (input from a file), `#\|' (input from a pipe), or `#f'.

    True value of the output mode implies batch mode (see `-b' option bellow).
    `-dump+'  is  equivalent  to  `-dump  <the   value  of   the   C   macro
    `DUMP_DEFAULT'>'. See also the  exposition for  the procedure  `open' in
    ${TOP}/builtin.doc.

-hello[-] : startup message
-bye[-] : shutdown message
-gcv[-] : gc verbose
-ov[-] : output verbose
-iv[-] : input verbose
-lv[-] : load verbose
    The last character `-' suppresses the corresponding message.

-b[-] : batch mode
    The session exits without entering the top-level loop.

-h <heap size in bytes>
-s <stack size in bytes>
    Since the stack is part of the heap, <stack size> must not  exceed <heap
    size>.

  $4. Acknowledgement
  ===================

  I'd like to express my hearty  thanks to  tadf <NAH02332@niftyserve.or.jp>
for his many valuable advises and detailed reports of bugs.