Man Linux: Main Page and Category List

NAME

       scc - Scheme to C compiler

SYNTAX

       scc [ option ] ... file ...

DESCRIPTION

       The  scc  command  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 scc.  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,   libsc.a,   and   optionally
                         libsc_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
       /.../libsc.a        library
       /.../libsc_p.a      profiled library (optional)
       /.../scc            c-shell script
       /.../sccomp         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.

       sci(1)

QUESTIONS, COMMENTS, AND COMPLAINTS

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

                                     local