NAME

       s2cc - Scheme to C compiler

SYNTAX

       s2cc [ option ] ... file ...

DESCRIPTION

       The  s2cc  command (previously known as scc) invokes a Scheme compiler which accepts the language defined
       in the essential portions of Revised4 Report on the Algorithmic Language Scheme, with  minor  constraints
       and  some  additions.   The compiler produces C source files which are then compiled using the system's C
       compiler to produce conventional .o and a.out files.  The  C  code  produced  by  this  compiler  may  be
       intermixed with other C code or code written in other languages.

OPTIONS

       These  options  are  accepted  by  s2cc.   Other  options will be assumed to be options of the system's C
       compiler and they will be passed to it when it is invoked.

       -cc  C compiler   Compile the Scheme compiler produced C code with C  compiler.   If  this  flag  is  not
                         supplied, then the C compiler cc will be used.

       -C                Compile  the  Scheme programs found in the files source.sc and leave the resulting code
                         in source.c files.  No further operations are performed.

       -I  directory     Specifies a directory to be searched by include for source files.

       -f  symbol  value Define the compile-time constant symbol to value.  This is equivalent to the  construct
                         (define-constant symbol value) appearing in the Scheme source.

       -i                Combine  the  source  and  object files into a Scheme interpreter.  The module name for
                         each Scheme source file is  automatically  determined.   Module  names  for  previously
                         compiled modules must be specified using the -m option.

       -m  module-name   Specifies the name of a previously compiled module.  Note that the Scheme compiler will
                         downshift the alphabetic characters in the module-name.  Modules are initialized in the
                         order that the -m flags appear.

       -Ob               Optimize code by omitting bounds checks on vectors and strings.

       -Og               Optimize code by omitting stack trace-back code.

       -On               Optimize code by assuming that all numbers are fixed point.

       -Ot               Optimize code by omitting type error checks.

       -pg               Produce profiled code for run-time measurement using gprof(1).  The profiled library is
                         used in lieu of the standard Scheme library.

       -scgc   statflag  Enables garbage collection statistics.  If set to 1, then garbage collection statistics
                         will be printed.  The default is 0, that will result in no statistics.

       -sch  heap        Specifies  the  compiler's  initial  heap  size  in  megabytes.   The default is system
                         dependent.

       -scl percent      Specifies the percent of the heap allocated after  a  generational  garbage  collection
                         that will force a full collection.  The default is 40.

       -scmh  heap       Specifies the compiler's maximum heap size in megabytes.  The default is five times the
                         initial size of the heap.

       -LIBDIR  directory
                         Specifies a  directory  containing  the  files:  predef.sc,  objects.h,  libs2c.a,  and
                         optionally libs2c_p.a.

       -log              Logs  information  internal  to  the  compiler  to  the  C  source file produced by the
                         compiler.  Each type of information is controlled by a flag: -source, -macro,  -expand,
                         -closed,  -transform,  -lambda,  -tree,  -lap,  -peep.   The flag -log is equivalent to
                         specifying the flags: -source, -macro, -expand, -closed, -transform, -lambda, -tree.

ENVIRONMENT VARIABLES

       The items controlled by -sc.. flags can also be controlled by environment variables.  If  both  the  flag
       and the environment variable are provided, then the flag's value will be used.

       SCGCINFO          Controls the reporting of garbage collection statistics to the standard error file.  If
                         set to 1, then garbage collection statistics will be printed.  The default setting is 0
                         that will not print the statistics.

       SCHEAP            Specifies  the  initial size of the heap in megabytes.  The default heap size is system
                         dependent.

       SCLIMIT           Specifies the percent of the heap allocated after  a  generational  garbage  collection
                         that will force a full collection.  The default is 40.

       SCMAXHEAP         Specifies the maximum size of the heap in megabytes.

INPUT FILES

       Following the command options come one or more file names.

       name.sc           Scheme source.  Scheme source files will be compiled into C files with the name name.c.

       name.c            C source.

       name.s            Assembly language source.

       name.o            Object file which may have been generated by any compiler.

       name.a            Object file archive which may have been generated by any compiler.

DIAGNOSTICS

       The disgnostic messages produced by the compiler are printed on the standard error file.

FILES

       /.../schemetoc/...  source and documentation
       /.../libs2c.a       library
       /.../libs2c_p.a     profiled library (optional)
       /.../s2cc           shell script
       /.../s2ccomp        compiler
       /.../predef.sc      predefined functions
       /.../objects.h      definitions "#include'd" in the C code
       SC-TO-C.c           temporary C source file
       source.S2C          temporary C source file
       SC-TO-C.o           temporary object file

LIMITATIONS

       When the compiler is able to identify every call to a procedure, it is able to generate it "in-line", and
       perform tail calls by using "goto".  This analysis covers most loops, conditional expressions, and finite
       state  machines.   For  non-tail  recursive calls, the code generated by the compiler uses the standard C
       mechanisms for procedure call and return.  This therefore requires that each top-level Scheme  procedure,
       and  any  Scheme  procedure which has more than one call which is not tail-recursive be compiled into its
       own C procedure.  Calls to such procedures will be tail-recursive if and only  if  the  host  C  compiler
       optimizes tail-recursion.

SEE ALSO

       Harold  Abelson  and  Gerald  Jay  Sussman  with  Julie Sussman, Structure and Interpretation of Computer
       Programs, The MIT Press.

       William Clinger and Jonathan Rees (Editors), Revised4 Report on the  Algorithmic  Language  Scheme,  LISP
       Pointers, Volume IV, Number 3, July-September 1991.  PostScript for this file is included in the software
       distribution.

       Jerry D. Smith, An Introduction to Scheme, Prentice Hall, Inc.  Chapter notes for using  this  text  with
       Scheme->C are included in the software distribution.

       R. Kent Dybvig, The SCHEME Programming Language, Prentice Hall, Inc.

       Daniel P. Friedman and Matthias Felleisen, The Little LISPer, MIT Press.

       Joel F. Bartlett, Scheme->C  a Portable Scheme-to-C Compiler, WRL Research Report 89/1.

       Additional documentation is included in the software distribution.

       s2ci(1)

QUESTIONS, COMMENTS, AND COMPLAINTS

       http://alioth.debian.org/projects/scheme2c/

                                                      local                                              S2CC(1)