21. Bigloo -- Compiler description

21. Bigloo -- Compiler description

Browsing

Home: Bigloo
A ``practical Scheme compiler''
for Bigloo version 2.5a
April 2002

Previous chapter: DSSSL support
Next chapter: User Extensions


Compiler description

21.1 C requirement
21.2 JVM requirement
21.3 Linking
21.4 The compiler environment and options


Chapters

Copyright
Acknowledgements
1. Table of contents
2. Overview of Bigloo
3. Modules
4. Core Language
5. Standard Library
6. Pattern Matching
7. Object System
8. Threads
9. Regular parsing
10. Lalr(1) parsing
11. Errors and Assertions
12. Eval and code interpretation
13. Macro expansion
14. Command Line Parsing
15. Explicit typing
16. The C interface
17. The Java interface
18. Bigloo Libraries
19. SRFIs
20. DSSSL support
21. Compiler description
22. User Extensions
23. Bigloo Development Environment
24. Global Index
25. Library Index
Bibliography


21.1 C requirement

Instead of producing assembly code, Bigloo produces C code. This C code is ISO-C compliant [IsoC]. So, it is necessary to have an ISO-C compiler. The current version has been developed with gcc [Stallman95].


21.2 JVM requirement

In order to compile the Bigloo JVM back-end, you have to be provided with a JDK 1.2 or more recent (available at http://www.javasoft.com). The JVM must support for -noverify option because, by default, Bigloo produces JVM code that is not conform to the rules enforced by the Java byte code verifiers.


21.3 Linking

Only Bigloo can be used to link object files which have been compiled by Bigloo. An easy way to perform this operation is, after having compiled all the files using the -c option, to invoke Bigloo with the name of the compiled files.

When Bigloo is only given object file name as argument, it searches in the current directory and the directory named in the *load-path* list the Scheme source file in order to perform a correct link. Scheme source files are supposed to be ended by the suffix .scm. Additional suffixes can be added using the -suffix option. Hence, if source files are named foo1.sc and foo2.sc, a link command line could look like:

bigloo -suffix sc foo1.o foo2.o -o foo


21.4 The compiler environment and options

There are four ways to change the behaviour of Bigloo. Flags on the command line, the option module clause runtime-command file and environment variables See Modules. When the compiler is invoked, it first gets the environment variables, then it scans the runtime-command file and, at end, it parses the command line. If the same option is set many times, Bigloo uses the last one.

21.4.1 Efficiency

In order to get maximum speed, compile with the -Obench option. This will enable all compiler optimization options and disable dynamic type checks. To improve arithmetic performance see next section.


21.4.2 Stack allocation

When the -fstack flag is enabled, the compiler may automatically replace some heap allocations with stack allocations. This may improve performance because stack allocations are handled more efficiently than heap allocations. On some cases, -fstack may also cause slow down or memory extra retentions. In this last case, when compile using -fstack the program will consume more memory. Unfortunately, this is nasty phenomenon is unpredictable (it depends on the nature of the source file).


21.4.3 Genericity of arithmetic procedures

By default, arithmetic procedures are generic. This means that it is allowed to use them with flonum and fixnum. This feature, of course, implies performances penalty. To improve performance, you may use specialized procedures (such as +fx, =fx, ... or +fl, =fl, ...) but, it is possible to suppress the genericity and to make all generic arithmetic procedures (= for example) fixnum ones. For this you must use the compiler option -farithmetic, or add the following module clause (option (set! *genericity* #f)) in your module declaration.


21.4.4 Safety

It is possible to generate safe or unsafe code. The safety's scope is type, arity, version and range. Let's see an example:

(define (foo f v indice)
   (car (f (vector-ref v indice))))
In safe mode, the result of the compilation will be:

(define (foo f v indice)
  (let ((pair 
        (if (and (procedure? f)
              ;; type check
              (= (procedure-arity f) 1))
              ;; arity check
           (if (vector? v)
              ;; type check
              (if (and (integer? k)
                    ;; type check
                    (>= k 0)
                    ;; range check
                    (< k (vector-length v)))
                    ;; range check
                (f (vector-ref v indice))
                (error ...))
              (error ...))
           (error ...))))
    (if (pair? pair)
       ;; type check
       (car pair)
       (error ...))))
It is possible to remove some or all safe checks. For example, here is the result of the compilation where safe check on types have been removed:

(define (foo f v indice)
  (let ((pair (if (= (procedure-arity f) 1)
             ;; arity check
             (if (and (>= k 0)
                   ;; range check
                   (< k (vector-length v)))
                   ;; range check
                (f (vector-ref v indice))
                (error ...))
             (error ...))))
     (car pair)))


21.4.5 The runtime-command file

Each Bigloo's user can use a special configuration file. This file must be named ``.bigloorc'' or ``~/.bigloorc''. Bigloo tries to load one of these in this order. This file is a Scheme file. Bigloo exports variables which allow the user to change the behavior of the compiler. All these variables can be checked using the -help2 option.

The Bigloo's runtime command file is read before the arguments are parsed.


21.4.6 The Bigloo command line

If no input file is specified, Bigloo enters its interpreter. Here is the exhaustive list of Bigloo options and configuration variables:

usage: bigloo [options] [name.suf]


Misc:
   -                         --  Read source code on current input channel
   -help                     --  This help message
   -help2                    --  The exhaustive help message
   -help-manual              --  The help message formatted for the manual
   -o <dst>                  --  Name the output file <dst>
   --to-stdout               --  Write C code on current output channel
   -c                        --  Suppress linking and produce a .o file
   -suffix <suffix>          --  Recognize suffix as Scheme source
   -afile <file>             --  Set name of the access file (default .afile)
   -access <module> <file>   --  Set access between module and file
   -jfile <file>             --  Set name of the Jvm package file (default .jfile)
   -jadd <module> <qtype>    --  Set JVM qualifed type name for module
   -main <fun>               --  Set the main function
   -with <module>            --  Import addition module
   -multiple-inclusion       --  Enables multiple inclusion of the same Bigloo include
   -library <library>        --  Compile (and link) with additional library
   -dload-sym                --  Emit a Bigloo dynamic loading entry point
   -heapsize <size>          --  Set the initial heap size value (in megabyte)

Configuration and path:
   -version                  --  The current release
   -revision                 --  The current release (short format)
   -query                    --  Dump the current configuration
   -q                        --  Do not load any rc file
   -eval <string>            --  Evaluate <string>
   -I <name>                 --  Add <name> to the load path
   -lib-dir <name>           --  Set lib-path to <name>
   -L <name>                 --  Set additional library path
   -jvm-classpath <name>     --  Set the JVM classpath
   -jvm-directory <name>     --  Directory where to store class files.
   -jvm-jarpath <name>       --  Set the JVM classpath for the produced jar file

Dialect:
   -nil                      --  Evaluate '() as #f in `if' expression
   -call/cc                  --  Enable call/cc function
   -hygien                   --  Enable r5rs macros
   -fno-reflection           --  Disable reflection code production
   +fno-reflection           --  Enable reflection code production
   -farithmetic              --  Suppress genericity of arithmetic operators
   -fcase-sensitive          --  Case sensitive reader (default)
   -fcase-insensitive        --  Case insensitive reader (downcase symbols)

Back-end:
   -native                   --  Produce a native object file (via C)
   -jvm                      --  Produce JVM .class files instead of a C file
   -jvm-shell <shell>        --  Shell to be used for running JVM applications (either "sh" or "msdos")
   -jvm-purify               --  Produce byte code verifier compliant JVM code
   -no-jvm-purify            --  Don't care about JVM code verifier (default)
   -i                        --  Don't compile but interprete
   -target <lang>            --  DON'T USE, see -native or -jvm option

Optimization:
   -Obench                   --  Benchmarking mode
   -O[2..6]                  --  Optimization modes
   -fcfa-arithmetic          --  Enable arithmetic spec. (enabled from -O2)
   -fno-cfa-arithmetic       --  Disable arithmetic spec.
   -funroll-loop             --  Enable loop unrolling (enabled from -O3)
   -fno-unroll-loop          --  Disable loop unrolling
   -fno-loop-inlining        --  Disable loop inlining
   -floop-inlining           --  Enable loop inlining (default)
   -fno-inlining             --  Disable inline optimization
   -fno-user-inlining        --  Disable user inline optimization
   -fbeta-reduce             --  Enable simple beta reduction. (enable from -O3)
   -fno-beta-reduce          --  Disable simple beta reduction
   -fdataflow                --  Enable dataflow optimizations. (enable from -O)
   -fno-dataflow             --  Disable dataflow optimizations
   -fO-macro                 --  Enable Optimization macro (default)
   -fno-O-macro              --  Disable Optimization macro

Compilation modes:
   <-/+>rm                   --  Don't or force removing C file
   -extend <name>            --  Extend the compiler
   -fsharing                 --  Attempt to share constant data
   -fno-sharing              --  Do not attempt to share constant data
   -fmco                     --  Produce an .mco file
   -fmco-include-path <path> --  Add dir to mco C include path

Safety:
   -unsafe[atrsvl]           --  Don't check [type/arity/range/struct/version]

Debug:
   -gbdb-no-line             --  Don't emit Cpp # line directives
   -gbdb[23]                 --  Compile with bdb debug informations
   -gself                    --  Enables self compiler debug options
   -gheap                    --  Enables heap debugging (set with -gbdb2)
   -gmodule                  --  Debug module initialization
   -g[234]                   --  Produce Bigloo debug informations
   -cg                       --  Compile C files with debug option
   -export-all               --  Eval export-all all routines
   -export-exports           --  Eval export-exports all routines
   -export-mutable           --  Enables Eval redefinition of all routines

Profiling:
   -p[2]                     --  Compile files for profiling
   -pg                       --  Compile files with profiling option

Verbosity:
   -s                        --  Be silent and inhibit all warning messages
   -v[23]                    --  Be verbose
   -no-hello                 --  Dont' say hello even in verbose mode
   -w                        --  Inhibit all warning messages
   -wslots                   --  Inhibit overriden slots warning messages
   -Wall                     --  warn about all possible type errors

Native specific options:
   -cc <compiler>            --  Specify the C compiler
   -stdc                     --  Generate strict ISO C code
   -copt <string>            --  Invoke cc with <string>
   -ldopt <string>           --  Invoke ld with <string>
   --force-cc-o              --  Force the C compiler to use -o instead of mv
   -ld-relative              --  Link using -l notation for libraries
   -ld-absolute              --  Link using absolute path names for libraries
   -static-bigloo            --  Link with the static bigloo library
   -ld-libs1                 --  include once the user libraries when linking
   -ld-libs2                 --  include twice the user libraries when linking (default)
   -l<library>               --  Link with host library

Jvm specific options:
   -fjvm-inlining            --  Enable JVM back-end inlining
   -fjvm-constr-inlining     --  Enable JVM back-end inlining for constructors
   -fno-jvm-inlining         --  Disable JVM back-end inlining
   -fno-jvm-constr-inlining  --  Disable JVM back-end inlining for constructors
   -fjvm-peephole            --  Enable JVM back-end peephole
   -fno-jvm-peephole         --  Disable JVM back-end peephole
   -fjvm-branch              --  Enable JVM back-end branch
   -fno-jvm-branch           --  Disable JVM back-end branch
   -fjvm-fasteq              --  EQ? no longer works on integers (use =FX)
   -fno-jvm-fasteq           --  Disable JVM back-end fasteq transformation
   -jvm-env <var>            --  Make the shell variable visible to GETENV
   -jvm-jar                  --  Produce a JVM jar file when linking
   -no-jvm-jar               --  Don't produce a JVM jar file when linking (default)
   -jvm-java <string>        --  Use <file> as JVM
   -jvm-opt <string>         --  Invoke JVM with <string>

Traces:
   -t[2|3|4]                 --  Generate a trace file (*)
   +t<pass>                  --  Force pass to be traced
   -shape[mktalu]            --  Some debugging tools (private)

Compilation stages:
   -syntax                   --  Stop after the syntax stage (see -hygien)
   -expand                   --  Stop after the preprocessing stage
   -ast                      --  Stop after the ast construction stage
   -bdb-spread-obj           --  Stop after the bdb obj spread stage
   -trace                    --  Stop after the trace pass
   -callcc                   --  Stop after the callcc pass
   -bivalue                  --  Stop after the bivaluation stage
   -inline                   --  Stop after the inlining stage
   -inline+                  --  Stop after the 2nd inlining stage
   -fail                     --  Stop after the failure replacement stage
   -fuse                     --  Stop after the fuse stage
   -user                     --  Stop after the user pass
   -coerce                   --  Stop after the type coercing stage
   -effect                   --  Stop after the effect stage
   -effect+                  --  Stop after the 2nd effect stage
   -reduce                   --  Stop after the reduction opt. stage
   -reduce+                  --  Stop after the 2nd reduction opt. stage
   -assert                   --  Stop after the assertions stage
   -cfa                      --  Stop after the cfa stage
   -closure                  --  Stop after the globalization stage
   -recovery                 --  Stop after the type recovery stage
   -bdb                      --  Stop after the Bdb code production
   -cnst                     --  Stop after the constant allocation
   -integrate                --  Stop after the integration stage
   -hgen                     --  Produce a C header file with class definitions
   -cgen                     --  Do not C compile and produce a .c file
   -jvmas                    --  Produce a JVM .jas file instead of a C file
   -indent                   --  Produce an indented .c file
   -mco                      --  Stop after .mco production

Constant initialization:
   -init-<lib/read/intern>   --  Constants initialization mode

Bootstrap and setup:
   -mklib                    --  Compile a library module
   -mkaddlib                 --  Compile an additional library module
   -mkheap                   --  Build an heap file
   -mkaddheap                --  Build an additional heap file
   -mkdistrib                --  Compile a main file for a distribution
   -license                  --  Display the Bigloo license and exit
   -LICENSE                  --  Add the license to the generated C files
   -heap <name>              --  Specify an heap file (or #f to not load heap)
   -dump-heap                --  Dump the contains of a heap
   -dheap <name>             --  Dump the contains of a heap
   -addheap <name>           --  Specify an additional heap file
   -fread-internal           --  Read source from binary interned file
   -fread-plain              --  Read source from plain text file

 * : only available in developing mode
 . : option enabled from -O3 mode


Shell Variables:

   - TMPDIR
     tmp directory (default "/tmp")
   - BIGLOOLIB
     libraries' directory
   - BIGLOOHEAP
     the initial heap size in megabytes (4 MB by default)
   - BIGLOOSTACKDEPTH
     the error stack depth printing
   - BIGLOOLIVEPROCESS
     the maximum number of Bigloo live processes

Runtime Command file:
   - ~/.bigloorc

Bigloo Control Variables:
   All the Bigloo control variables can be changed from the
   interpreter, by the means of the `-eval' option, or using
   the module clause `option'. For instance the option
   "-eval '(set! *strip* #t)'" will set the variable
   `*strip*' to the value `#t'.
   These variables are:

   - *bigloo-version* : 
     The Bigloo major release number
     default: "2.5a"
   - *bigloo-name* : 
     The Bigloo name
     default: "Bigloo (2.5a)"
   - *bigloo-tmp* : 
     The tmp directory name
     default: "/users/serrano/tmp"
   - *bigloo-licensing?* : 
     Add the Bigloo license ?
     default: #f
   - *verbose* : 
     The verbosity level
     default: 0
   - *hello* : 
     Say hello (when verbose)
     default: #t
   - *src-files* : 
     The sources files
     default: ()
   - *dest* : 
     The target name
     default: #f
   - *shell* : 
     The shell to exec C compilations
     default: "/bin/sh"
   - *cc* : 
     The C compiler
     default: "gcc"
   - *cflags* : 
     The C compiler option
     default: ""
   - *cflags-optim* : 
     The C compiler optimization option
     default: "-O3 "
   - *cflags-prof* : 
     The C compiler profiling option
     default: "-pg -fno-inline "
   - *stdc* : 
     Shall we produced ISO C?
     default: #f
   - *cc-options* : 
     cc options
     default: ""
   - *rm-c-files* : 
     Shall we remove the C produced file?
     default: #t
   - *ld-options* : 
     ld options
     default: ""
   - *cc-move* : 
     Use mv or -o when C compiling
     default: #t
   - *ld-relative* : 
     Relative or absolute path names for libraries
     default: #f
   - *strip* : 
     Shall we strip the executable?
     default: #t
   - *default-lib-dir* : 
     The default lib dir path (without version)
     default: "/users/serrano/prgm/project/bigloo/lib/2.5a"
   - *lib-dir* : 
     The lib dir path
     default: ("." "/users/serrano/prgm/project/bigloo/lib/2.5a")
   - *lib-src-dir* : 
     The lib dir path
     default: "./runtime"
   - *bigloo-lib-base-name* : 
     The Bigloo library base name
     default: "bigloo"
   - *bigloo-lib* : 
     The Bigloo library
     default: "bigloo"
   - *gc-lib* : 
     The Gc library
     default: "gc"
   - *static-bigloo?* : 
     Do we use the static Bigloo library
     default: #f
   - *double-ld-libs?* : 
     Do we include twice the additional user libraries
     default: #t
   - *bigloo-user-lib* : 
     The user extra C libraries
     default: ("-lm")
   - *additional-bigloo-libraries* : 
     The user extra Bigloo libraries
     default: ()
   - *additional-bigloo-zips* : 
     The user extra Bigloo Zip files
     default: ()
   - *include-multiple* : 
     Enable/disable multiple inclusion of same file
     default: #f
   - *include-foreign* : 
     The C included files
     default: ("bigloo.h")
   - *additional-include-foreign* : 
     The additional C included files
     default: ()
   - *heap-base-name* : 
     The Bigloo heap base name
     default: "bigloo"
   - *heap-name* : 
     The Bigloo heap file name
     default: "bigloo.heap"
   - *heap-jvm-name* : 
     The Bigloo heap file name for the JVM backend
     default: "bigloo.jheap"
   - *heap-dump-names* : 
     The name of the heap to be dumped
     default: ()
   - *jvm-foreign-class-id* : 
     The identifier of the Jlib foreign class
     default: foreign
   - *jvm-foreign-class-name* : 
     The name of the Jlib foreign class
     default: "bigloo.foreign"
   - *additional-heap-name* : 
     A name of an additional heap file name to be build
     default: #f
   - *additional-heap-names* : 
     A list of Bigloo additional heap file name
     default: ()
   - *indent* : 
     The name of the C beautifier
     default: "stdindent"
   - *compiler-debug* : 
     Debugging level
     default: 0
   - *compiler-sharing-debug?* : 
     Compiler self sharing debug
     default: #f
   - *debug-module* : 
     Module initilazation debugging
     default: 0
   - *c-debug* : 
     C debugging mode?
     default: #f
   - *c-debug-option* : 
     cc debugging option
     default: "-g"
   - *jvm-debug* : 
     JVM debugging mode?
     default: #f
   - *bdb-debug* : 
     Bdb debugging mode
     default: 0
   - *heap-debug* : 
     Heap debugging mode
     default: 0
   - *heap-debug-copt* : 
     Heap debugging C flags
     default: "-DKEEP_BACK_PTRS"
   - *profile-mode* : 
     Bigloo profile mode
     default: 0
   - *prof-table-name* : 
     Bprof translation table file name
     default: "bmon.out"
   - *access-file* : 
     The access file name
     default: #f
   - *access-file-default* : 
     The default access file name
     default: ".afile"
   - *qualified-type-file* : 
     The qualifed-type association file name
     default: #f
   - *qualified-type-file-default* : 
     The qualifed-type association file name
     default: ".jfile"
   - *o-files* : 
     The additional obect files
     default: ()
   - *c-files* : 
     The C source files
     default: ()
   - *with-files* : 
     The additional modules
     default: ()
   - *interpreter* : 
     Shall we interprete the source file?
     default: #f
   - *startup-file* : 
     A startup file for the interpreter
     default: #f
   - *call/cc?* : 
     Shall we enable call/cc?
     default: #f
   - *reflection?* : 
     Shall we produce refection code for classes
     default: #t
   - *pass* : 
     Stop after the pass
     default: ld
   - *jvm-jar?* : 
     Enable/disable a JAR file production for the JVM back-end
     default: #f
   - *jvm-shell* : 
     Shell to be used when producing JVM run scripts
     default: "sh"
   - *jvm-java* : 
     JVM to be used to run Java programs
     default: "java"
   - *jvm-options* : 
     JVM options
     default: ""
   - *jvm-classpath* : 
     JVM classpath
     default: #f
   - *jvm-jarpath* : 
     JVM jarpath
     default: #f
   - *jvm-directory* : 
     JVM object directory
     default: #f
   - *module-checksum-object?* : 
     Produce a module checksum object (.mco)
     default: #f
   - *garbage-collector* : 
     The garbage collector
     default: boehm
   - *unsafe-type* : 
     Runtime type safety
     default: #f
   - *unsafe-arity* : 
     Runtime type arity safety
     default: #f
   - *unsafe-range* : 
     Runtime range safety
     default: #f
   - *unsafe-struct* : 
     Runtime struct range safety
     default: #f
   - *unsafe-version* : 
     Module version safety
     default: #f
   - *unsafe-library* : 
     Use the unsafe library version
     default: #f
   - *warning-overriden-slots* : 
     Set to #t to warn about virtual slot overriding
     default: #t
   - *profile-library* : 
     Use the profiled library version
     default: #f
   - *max-stack-alloc-size* : 
     Maximum size of stack allocated objects
     default: #f
   - *shared-cnst?* : 
     Shared constant compilation?
     default: #t
   - *lib-mode* : 
     Lib-mode compilation?
     default: #f
   - *init-mode* : 
     Module initialization mode
     default: read
   - *dlopen-init* : 
     Emit a standard Bigloo dynamic loading init entry point
     default: #f
   - *max-c-token-length* : 
     Max c token length
     default: 1024
   - *max-c-foreign-arity* : 
     Max C function arity
     default: 16
   - *trace-name* : 
     Trace file name
     default: "trace"
   - *trace-write-length* : 
     Trace dumping max level
     default: 80
   - *optim* : 
     Optimization level
     default: 0
   - *optim-stack?* : 
     Stack allocation optimization
     default: #unspecified
   - *optim-unroll-loop?* : 
     Loop unrolling optimization
     default: #unspecified
   - *optim-loop-inlining?* : 
     Loop inlining optimization
     default: #t
   - *optim-O-macro?* : 
     Enable optimization by macro-expansion
     default: #f
   - *optim-jvm-inlining* : 
     Enable JVM inlining
     default: 0
   - *optim-jvm-constructor-inlining* : 
     Enable JVM inlining for constructors
     default: 0
   - *optim-jvm-peephole* : 
     Enable JVM peephole optimization
     default: 0
   - *optim-jvm-branch* : 
     Enable JVM branch tensioning
     default: 0
   - *optim-jvm-fasteq* : 
     EQ? no longer works on integers (use =FX instead)
     default: #f
   - *jvm-purify* : 
     Produce byte code verifier compliant JVM code
     default: #f
   - *jvm-env* : 
     List of environment variables to be available in the compiled code
     default: ()
   - *optim-jvm* : 
     Enable optimization by inlining jvm code
     default: 0
   - *optim-cfa-arithmetic?* : 
     Enable refined arithmetic specialization
     default: #f
   - *optim-dataflow?* : 
     Enable simple dataflow optimization
     default: #f
   - *optim-reduce-beta?* : 
     Enable simple beta reduction
     default: #f
   - *inlining?* : 
     Inlining optimization
     default: #t
   - *user-inlining?* : 
     User inlining optimization
     default: #t
   - *inlining-kfactor* : 
     Inlining growth factor
     default: #<procedure:8050c30.1>
   - *inlining-reduce-kfactor* : 
     Inlinine growth factor reductor
     default: #<procedure:8050b80.1>
   - *extend-entry* : 
     Extend entry
     default: #f
   - *src-suffix* : 
     Scheme legal suffixes
     default: ("scm" "bgl")
   - *c-suffix* : 
     C legal suffixes
     default: ("c")
   - *obj-suffix* : 
     Object legal suffixes
     default: ("o")
   - *mco-suffix* : 
     Module checksum object legal suffixes
     default: ("mco")
   - *mco-include-path* : 
     Module checksum C include path
     default: (".")
   - *auto-mode* : 
     auto-mode (extend mode) list
     default: (("ml" . "caml") ("mli" . "caml") ("oon" . "meroon"))
   - *ast-case-sensitive* : 
     Case sensitivity
     default: #t
   - *user-heap-size* : 
     Heap size (in MegaByte) or #f for default value
     default: #f
   - *reader* : 
     The way the reader reads input file ('plain or 'intern)
     default: plain
   - *target-language* : 
     The target language (either C or JVM)
     default: native
   - *use-private?* : 
     Use private construction instead of pragma
     default: #f
   - *eval-options* : 
     A user variable to store dynamic command line options
     default: ()
   - *load-path* : 
     The load path
     default: ("." "/users/serrano/prgm/project/bigloo/lib/2.5a")
   - *user-pass* : 
     The user specific compilation pass
     default: #unspecified
   - *debug* : 
     The debugging level
     default: 0
   - *warning* : 
     The warning level
     default: #t
   - *hygien?* : 
     Hygienic r5rs macro expansion activation
     default: #f




This
Scribe page has been generated by scribeinfo.
Last update Thu Apr 25 09:40:15 2002