NAME

       chibi-scheme - a tiny Scheme interpreter

SYNOPSIS

       chibi-scheme [options] [--] [script argument ...]

DESCRIPTION

       chibi-scheme  is  a  sample interactive Scheme interpreter for the chibi-scheme library.  It serves as an
       example of how to embed chibi-scheme in applications, and can be useful on its own  for  writing  scripts
       and interactive development.

       When  script  is given, it will be loaded with SRFI-22 semantics, calling the procedure main (if defined)
       with a single parameter as a list of the command-line arguments, beginning with the  script  name.   This
       works as expected with shell #! semantics.

       Otherwise,  if  no  script  given  and  no  -e or -p options are present, an interactive REPL is entered,
       reading, evaluating, and then printing expressions until EOF is  reached.   The  provided  REPL  is  very
       minimal.   For  a  more  sophisticated REPL with readline support, signal handling, module management and
       smarter read/write you may want to use the (chibi repl) module.  It can be  launched  automatically  with
       chibi-scheme -R.

       For  convenience  the  default  language is the (scheme small) module which includes every library in the
       R7RS small standard, and some other dependencies.  All of this together is actually quite large, so for a
       more  minimal  startup  language  you'll want to use the -xmodule option described below.  The get mostly
       R5RS-compatible language, use chibi-scheme -xscheme.r5rs, or to get  just  the  core  language  used  for
       bootstrapping, use chibi-scheme -xchibi (or its shortcut chibi-scheme -q).

OPTIONS

       Space  is  optional  between  options  and their arguments.  Options without arguments may not be chained
       together.

       To reduce the need for shell escapes, options with module arguments (-m, -x and -R) are  written  in  dot
       notation.  That is, spell module name (foo bar) as foo.bar on the command line.

       -V     Print the version information and exit immediately.

       -q     "Quick"  load, a shortcut for chibi-scheme -xchibi.  This is slightly different from (scheme base)
              -- which may load faster -- and is guaranteed to not load any additional shared libraries.

       -Q     "Extra quick" load, a shortcut for chibi-scheme -xchibi.primitive.  The resulting environment will
              only  contain  the  core  syntactic  forms  and  primitives  coded in C.  This is very fast and is
              guaranteed to not load any external files, but is also very limited.

       -r[main]
              Run the "main" procedure when the script finishes loading as in SRFI-22.

       -R[module]
              Load the given module and run the "main" procedure it defines (which need not be exported) with  a
              single  argument  of  the  list  of  command-line arguments as in SRFI-22.  The name "main" can be
              overridden with the -r option.  module may be omitted, in which case it defaults to  "chibi.repl".
              Thus chibi-scheme -R is the recommended way to get an advanced REPL.

       -s     Strict mode, treating warnings as fatal errors.

       -f     Enable case-folding of symbols by the reader as in R5RS.

       -T     Disable tail-call optimization.  This can be useful for debugging in some cases, but also makes it
              very easy to overflow the stack.

       -hsize[/max_size]
              Specify the initial size of the heap in bytes, optionally followed by the maximum  size  the  heap
              can  grow  up  to.  size can be any integer value, optionally suffixed with "K" for kilobytes, "M"
              for megabytes, or "G" for gigabytes (all powers of 1024).  -h must be specified before any options
              which load or evaluate Scheme code.

       -Ipath Insert path in front of the load path list.

       -Apath Append path to the load path list.

       -Dfeature
              Add feature to the feature list, useful for cond-expanding different library code.

       -mmodule

       -xmodule
              Import  module  as  if  "(import  module)" were evaluated.  If the -x version is used, then module
              replaces the current environment instead of extending it.

       -lfile Load Scheme code from file searched for in the default load path.

       -eexpr Evaluate Scheme expression expr.

       -pexpr Evaluate Scheme expression expr and print the result to stdout.

       -tmodule.id
              Enable tracing for the given identifier id in module.

       -dimage-file
              Dump the current Scheme heap to image-file and exit.

              This feature is experimental.

       -iimage-file
              Load the Scheme heap from image-file instead of compiling the init file on the fly.

              This feature is experimental.

ENVIRONMENT

       CHIBI_MODULE_PATH
              A colon-separated list of directories to search for  module  files,  inserted  before  the  system
              default load paths.  chibi-scheme searches for modules in directories in the following order:

              •   directories specified with the -I path option

              •   directories from CHIBI_MODULE_PATH

              •   system default directories

              •   directories specified with the -A path option

              If  CHIBI_MODULE_PATH  is  not  set,  directories  "./lib"  and "." are searched before the system
              defaults (in that order).

AUTHORS

       Alex Shinn

REPORTING BUGS

       Please report bugs on Github ⟨https://github.com/ashinn/chibi-scheme⟩.

SEE ALSO

       chibi-doc(1) chibi-ffi(1) snow-chibi(1)