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].
 
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.
 
It is easier to use Bigloo for linking 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
 | 
Note: In order to understand how the Bigloo linkers operates and which
libraries it uses, it might be useful to  use the 
-v2 option
which unveil all the details of the compilation and the link.
 
| 32.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.
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.
 
| 32.4.2 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.
 
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)))
 | 
 
| 32.4.4 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.
 
| 32.4.5 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,--help                       This help message
   -help2                             The exhaustive help message
   -help-manual                       The help message formatted for the manual
   -o FILE                            Name the output FILE
   --to-stdout                        Write C code on current output channel
   -c                                 Suppress linking and produce a .o file
   -y                                 Generate a shared library
   -suffix SUFFIX                     Recognize suffix as Scheme source
   -afile FILE                        Name of the access file
   -access MODULE FILE                Set access between module and file
   -jfile FILE                        Name of the Jvm package file
   -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 inclusions of the Bigloo includes
   -library LIBRARY                   Compile/link with additional Bigloo library
   -srfi SRFI                         Declares srfi support
   -dload-sym                         Emit a Bigloo dynamic loading entry point
   -dload-init-sym NAME               Emit a Bigloo dynamic loading entry point, named NAME
   -dload-init-gc                     For GC initialization for dynamic code
   -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 before compiling
   -load FILE                         Load FILE before compiling
   -I DIR                             Add DIR to the load path
   -lib-dir DIR                       Set lib-path to DIR
   -L NAME                            Set additional library path
   -lib-version VERSION               Set the Bigloo library version
   -libgc-version VERSION             Set the Bigloo GC library version
   -libgc GC                          Use the given GC library
 
 Back-end:
   -native                            Compile module to native object file (via C)
   -jvm                               Compile module to JVM .class files
   -saw                               Cut the AST in the saw-mill
   -no-saw                            Disable saw back-ends
   -i                                 Interprete module
 
 Dialect:
   -snow                              Compiles a snow source code
   -scmpkg,-spi                       Compiles a ScmPkg source code
   -nil                               Evaluate '() as #f in `if' expression
   -call/cc                           Enable call/cc function
   -hygien                            Obsolete (R5rs macros are always supported)
   -fidentifier-syntax SYNTAX         Identifiers syntax "r5rs" (default) or "bigloo"
   -fno-reflection                    Deprecated
   +fno-reflection                    Deprecated
   -fclass-nil                        Deprecated
   -fno-class-nil                     Deprecated
   -farithmetic                       Suppress genericity of arithmetic operators
   -farithmetic-overflow              Suppress arithmetic overflow checks
   -fno-arithmetic-overflow           Enable arithmetic overflow checks
   -fcase-sensitive                   Case sensitive reader (default)
   -fcase-insensitive                 Case insensitive reader (downcase symbols)
   -fallow-type-redefinition          allow type redifinition
 
 Optimization:
   -Obench                            Benchmarking mode
   -O[0..6]                           Optimization modes
   -ftagged-fxop                      Enable tagged fix-ops optimization
   -fno-tagged-fxop                   Disable tagged fix-ops optimization
   -fcfa                              Enable CFA
   -fno-cfa                           Disable CFA
   -fcfa-arithmetic                   Enable arithmetic spec. (see -farithmetic-overflow)
   -fno-cfa-arithmetic                Disable arithmetic spec.
   -fcfa-arithmetic-fixnum            Enable fixnum arithmetic spec.
   -fno-cfa-arithmetic-fixnum         Disable fixnum arithmetic spec.
   -fcfa-arithmetic-flonum            Enable flonum arithmetic spec. (enabled from -O2)
   -fno-cfa-arithmetic-flonum         Disable flonum arithmetic spec. 
   -fcfa-tracking                     Enable CFA tracking (enabled from -O2)
   -fno-cfa-tracking                  Disable CFA tracking
   -fcfa-pair                         Enable CFA pairs approximations
   -fno-cfa-pair                      Disable CFA pairs approximations
   -fcfa-unbox-closure-args           Enable CFA unboxed closure args (enabled from -O2)
   -fno-cfa-unbox-closure-args        Disable CFA unboxed closure args
   -fno-cfa-local-function            Disable CFA local function tracking
   -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
   -fisa                              Inline isa? type predicate
   -fno-isa                           Inline isa? type predicate
   -fbeta-reduce                      Enable simple beta reduction (enabled from -O2)
   -fno-beta-reduce                   Disable simple beta reduction
   -fdataflow                         Enable dataflow optimizations (enabled from -O)
   -fno-dataflow                      Disable dataflow optimizations
   -fdataflow-for-errors              Enable dataflow optimizations for improviing type error messages
   -fno-dataflow-for-errors           Disable dataflow optimizations for improviing type error messages
   -fdataflow-types                   Enable type dataflow optimizations (enabled from -O2)
   -fno-dataflow-types                Disable type dataflow optimizations
   -finitflow                         Enable init flow
   -fno-initflow                      Disable init flow
   -fsync-failsafe                    Enable failsafe synchronize optimization
   -fno-sync-failsafe                 Disable failsafe synchronize optimization
   -fO-macro                          Enable Optimization macro (default)
   -fno-O-macro                       Disable Optimization macro
   -fglobal-tailc                     Enable global tail-call optimization
   -fno-global-tailc                  Disable global tail-call optimization
   -freturn                           Enable set-exit replacement with return
   -fno-return                        Disable set-exit replacement
   -freturn-goto                      Enable local set-exit replacement with return
   -fno-return-goto                   Disable local set-exit replacement
   -fsaw-realloc                      Enable saw register re-allocation
   -fsaw-regalloc                     Enable saw register allocation
   -fno-saw-regalloc                  Disable saw register allocation
   -fsaw-bbv                          Enable saw basic-blocks versionning
   -fno-saw-bbv                       Disable saw basic-blocks versionning
   -fsaw-regalloc-msize SIZE          Set the register allocation body size limit
   -fsaw-regalloc-fun NAME            Allocate registers on this very function
   -fno-saw-regalloc-fun NAME         Don't allocate registers on this very function
   -fsaw-regalloc-onexpr              Allocate registers on expressions
   -fno-saw-regalloc-onexpr           Don't allocate registers on expressions
   -fsaw-spill                        Enable saw spill optimization
 
 Safety:
   -unsafe[atrsvleh]                  Don't check [type/arity/range/struct/version/library/eval/heap]
   -safe[atrsvle]                     Enforce check [type/arity/range/struct/version/library/eval]
 
 Debug:
   -glines                            Emit # line directives
   -gbdb-no-line                      Don't emit # line directives
   -gbdb[23]                          Compile with bdb debug informations
   -gself                             Enables self compiler debug options
   -gmodule                           Debug module initialization
   -gerror-localization               Localize error calls in the source code
   -gno-error-localization            Don't localize error calls in the source code
   -gjvm                              Annote JVM classes for debug
   -gtrace[12all]                     Instrument for stack tracing
   -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 "::obj" routines
 
 Profiling:
   -p[2g]                             Compile for cpu profiling
   -pmem[level]                       Compile for memory profiling
   -psync                             Profile synchronize expr (see $exitd-mutex-profile)
 
 Verbosity:
   -s                                 Be silent and inhibit all warning messages
   -v[23]                             Be verbose
   -hello                             Say hello
   -no-hello                          Dont' say hello even in verbose mode
   -w                                 Inhibit all warning messages
   -wslots                            Inhibit overriden slots warning messages
   -Wvariables                        Enable overriden variable warning messages
   -Wtypes                            Enable type check warning messages
   -Wslot                             Enable default slot value warning messages
   -Wno-slot                          Disable default slot value warning messages
   -Wall                              Warn about all possible type errors
   -Werror=type                       Treat type warnings as error
 
 Compilation modes:
   <-/+>rm                            Don't or force removing .c or .il files
   -extend NAME                       Extend the compiler
   -extend-module EXP                 Extend the module syntax
   -fsharing                          Attempt to share constant data
   -fno-sharing                       Do not attempt to share constant data
   -fmco                              Produce an .mco file
   -fmco-include-path DIR             Add dir to mco C include path
 
 Native specific options:
   -cc COMPILER                       Specify the C compiler
   -stdc                              Generate strict ISO C code
   -copt STRING                       Invoke cc with STRING
   -cheader STRING                    C header
   -cfoot STRING                      C foot
   -rpath PATH                        Add C runtime-path (rpath)
   -ldopt STRING                      Invoke ld with STRING
   -ldpostopt STRING                  Invoke ld with STRING (end of arguments)
   --force-cc-o                       Force the C compiler to use -o instead of mv
   -ld-relative                       Link using -l notation for libraries (default)
   -ld-absolute                       Link using absolute path names for libraries
   -static-bigloo                     Link with the static bigloo library
   -static-all-bigloo                 Link with static version of all bigloo libraries
   -ld-libs1                          Add once user libraries when linking
   -ld-libs2                          Add twice user libraries when linking (default)
   -lLIBRARY                          Link with host library
   -auto-link-main                    Enable main generation when needed for linking
   -no-auto-link-main                 Disable main generation
   --force-gc-roots                   Register global variables as GC roots
 
 Jvm specific options:
   -jvm-shell SHELL                   Shell for JVM scripts ("sh", "msdos")
   -jvm-purify                        Produce byte code verifier compliant JVM code (default)
   -no-jvm-purify                     Don't care about JVM code verifier
   -jvm-mainclass CLASS               JVM main class
   -jvm-classpath PATH                JVM application classpath
   -jvm-bigloo-classpath P            JVM Bigloo rts classpath
   -jvm-path-separator SEP            Set the JVM classpath separator
   -jvm-directory NAME                Directory where to store class files.
   -jvm-catch-errors                  Catch internal JVM errors
   -no-jvm-catch-errors               Don't catch internal JVM errors
   -jvm-jarpath NAME                  Set the JVM classpath for the produced jar file
   -jvm-cinit-module                  Enable JVM class constructors to initiliaze bigloo modules
   -no-jvm-cinit-module               Disable JVM class constructors to initiliaze bigloo modules
   -jvm-char-info                     Generate char info for the debugger (in addition to line info)
   -no-jvm-char-info                  Do not generate char info for the debugger
   -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                           Enable JVM jar files generation
   -no-jvm-jar                        Disable JVM jar files generation (default)
   -jvm-java FILE                     Use FILE as JVM
   -jvm-opt STRING                    JVM invocation option
 
 Traces:
   -t[2|3|4]                          Generate a trace file (*)
   +tPASS                             Force pass to be traced
   -shape[mktTalun]                   Some debugging tools (private)
 
 Compilation stages:
   -mco                               Stop after .mco production
   -syntax                            Stop after the syntax stage (see -hygiene)
   -expand                            Stop after the preprocessing stage
   -expand-module                     Produce the expanded module clause
   -ast                               Stop after the ast construction stage
   -syntax-check                      Stop after checking syntax
   -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
   -beta                              Stop after the constant beta reduction stage
   -fail                              Stop after the failure replacement stage
   -abound                            Stop after the array bound checking stage
   -initflow                          Stop after the type initflow stage
   -narrow                            Stop after the scope narrowing stage
   -tlift                             Stop after the type lifting stage
   -dataflow                          Stop after the type dataflow stage
   -dataflow+                         Stop after the second type dataflow stage
   -dataflow++                        Stop after the third type dataflow stage
   -fuse                              Stop after the fuse stage
   -user                              Stop after the user pass
   -fxop                              Stop after the fx-ops optimization
   -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
   -reduce-                           Stop after the very first reduction 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
   -tailc                             Stop after the tailc stage
   -return                            Stop after the return stage
   -isa                               Stop after the isa stage
   -init                              Stop after the initialization construction stage
   -classgen                          Produce an include file for class accessors
   -egen                              Produce an include file for effects (requires -saw)
   -hgen                              Produce a C header file with class definitions
   -cgen                              Do not C compile and produce a .c file
   -indent                            Produce an indented .c file
   -jvmas                             Produce a JVM .jas file
 
 Constant initialization:
   -init-[lib|read|intern]            Constants initialization mode
   -init-object-[legacy|staged]       Object system initialization
 
 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)
   -heap-library LIB                  The library the heap belongs to
   -dump-heap NAME                    Dump the content of a heap
   -addheap NAME                      Specify an additional heap file
   -fread-internal                    Read source from binary interned file
   -fread-internal-src                Read source only from binary interned file
   -fread-internal-src-file-name NAME Set fake source file name
   -fread-plain                       Read source from plain text file
   -target LANG                       DON'T USE, (see -native, -jvm)
 
 Shell Variables:
   - TMPDIR
     temporary 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
   - BIGLOOTRACE
     list of active traces
 
 Runtime Command file:
   - ~/.bigloorc
 
 
 ------------
 * : only available in developing mode
 . : option enabled from -O3 mode
 
 
 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:
 
 - *access-file-default* : 
     The default access file name
     default: ".afile"
   - *access-files* : 
     The access file names
     default: ()
   - *additional-bigloo-libraries* : 
     The user extra Bigloo libraries
     default: ()
   - *additional-bigloo-zips* : 
     The user extra Bigloo Zip files
     default: ()
   - *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: ()
   - *additional-include-foreign* : 
     The additional C included files
     default: ()
   - *allow-type-redefinition* : 
     If true, allow type redefinitions
     default: #f
   - *ast-case-sensitive* : 
     Case sensitivity
     default: #t
   - *auto-link-main* : 
     Enable automatically a main generation when linking
     default: #t
   - *auto-mode* : 
     auto-mode (extend mode) list
     default: (("ml" . "caml") ("mli" . "caml") ("oon" . "meroon") ("snow" . "snow") ("spi" . "pkgcomp"))
   - *bdb-debug* : 
     Bdb debugging mode
     default: 0
   - *bigloo-abort?* : 
     Do we have the bigloo-abort function in executables?
     default: #f
   - *bigloo-lib* : 
     The Bigloo library
     default: bigloo
   - *bigloo-libraries-c-setup* : 
     A list of C functions to be called when starting the application
     default: ()
   - *bigloo-licensing?* : 
     Add the Bigloo license ?
     default: #f
   - *bigloo-name* : 
     The Bigloo name
     default: "Bigloo (4.3h)"
   - *bigloo-specific-version* : 
     The Bigloo specific version
     default: ""
   - *bigloo-tmp* : 
     The tmp directory name
     default: "/tmp"
   - *bigloo-user-lib* : 
     The user extra C libraries
     default: ("-ldl" "-lresolv" "-lunistring" "-lpcre" "-lgmp" "-lm")
   - *bigloo-version* : 
     The Bigloo major release number
     default: "4.3h"
   - *bmem-profiling* : 
     Instrument code for bmem profiling
     default: #f
   - *c-debug* : 
     C debugging mode?
     default: #f
   - *c-debug-lines-info* : 
     Emit # line directives
     default: #f
   - *c-debug-option* : 
     cc debugging option
     default: "-g"
   - *c-files* : 
     The C source files
     default: ()
   - *c-object-file-extension* : 
     The C object file extension
     default: "o"
   - *c-split-string* : 
     C split long strings
     default: #f
   - *c-suffix* : 
     C legal suffixes
     default: ("c")
   - *c-user-foot* : 
     C foot
     default: ()
   - *c-user-header* : 
     C header
     default: ()
   - *call/cc?* : 
     Shall we enable call/cc?
     default: #f
   - *cc* : 
     The C compiler
     default: "gcc"
   - *cc-move* : 
     Use mv instead of -o when C compiling
     default: #t
   - *cc-o-option* : 
     The C compiler -o option
     default: "-o "
   - *cc-options* : 
     cc options
     default: ("")
   - *cc-style* : 
     The C compiler style
     default: "gcc"
   - *cflags* : 
     The C compiler option
     default: " -Wpointer-arith -Wswitch -Wtrigraphs -DBGL_BOOTCONFIG "
   - *cflags-optim* : 
     The C compiler optimization option
     default: "-O3"
   - *cflags-prof* : 
     The C compiler profiling option
     default: "-pg -fno-inline  -Wpointer-arith -Wswitch -Wtrigraphs -DBGL_BOOTCONFIG "
   - *cflags-rpath* : 
     The C compiler rpath option
     default: ("/home/serrano/prgm/project/bigloo/bigloo/lib/bigloo/4.3h")
   - *compiler-debug* : 
     Debugging level
     default: 0
   - *compiler-debug-trace* : 
     Debugging trace level
     default: 0
   - *compiler-sharing-debug?* : 
     Compiler self sharing debug
     default: #f
   - *compiler-stack-debug?* : 
     Compiler self stack trace debug
     default: #f
   - *compiler-type-debug?* : 
     Compiler self type debug
     default: #f
   - *csharp-suffix* : 
     C# legal suffixes
     default: ("cs")
   - *debug-module* : 
     Module initilazation debugging
     default: 0
   - *default-lib-dir* : 
     Depreacted, don't use
     default: "/home/serrano/prgm/project/bigloo/bigloo/lib/bigloo/4.3h"
   - *dest* : 
     The target name
     default: #f
   - *dlopen-init* : 
     Emit a standard Bigloo dynamic loading init entry point
     default: #f
   - *dlopen-init-gc* : 
     Emit a standard GC init call when initialization the module
     default: #f
   - *double-ld-libs?* : 
     Do we include the additional user libraries twice?
     default: #t
   - *error-localization* : 
     Localize error calls in the source code
     default: #f
   - *eval-options* : 
     A user variable to store dynamic command line options
     default: ()
   - *extend-entry* : 
     Extend entry
     default: #f
   - *garbage-collector* : 
     The garbage collector
     default: boehm
   - *gc-custom?* : 
     Are we using a custom GC library?
     default: #t
   - *gc-force-register-roots?* : 
     Force GC roots registration for global variables (for experts only)
     default: #t
   - *gc-lib* : 
     The Gc library
     default: bigloogc
   - *global-tail-call?* : 
     Do we apply the self-global-tail-call stage?
     default: #f
   - *heap-base-name* : 
     The Bigloo heap base name
     default: "bigloo"
   - *heap-dump-names* : 
     The name of the heap to be dumped
     default: ()
   - *heap-jvm-name* : 
     The Bigloo heap file name for the JVM backend
     default: "bigloo.jheap"
   - *heap-library* : 
     The library the heap belongs to
     default: bigloo
   - *heap-name* : 
     The Bigloo heap file name
     default: "bigloo.heap"
   - *hello* : 
     Say hello (when verbose)
     default: #f
   - *include-foreign* : 
     The C included files
     default: ("bigloo.h")
   - *include-multiple* : 
     Enable/disable multiple inclusion of same file
     default: #f
   - *indent* : 
     The name of the C beautifier
     default: "indent -npro -bap -bad -nbc -bl -ncdb -nce -nfc1 -ip0 -nlp -npcs -nsc -nsob -cli0.5 -di0 -l80 -d1 -c0 -ts2 -st"
   - *init-mode* : 
     Module initialization mode
     default: read
   - *inlining-kfactor* : 
     Inlining growth factor
     default: #<procedure:562ec58c8c60.1>
   - *inlining-reduce-kfactor* : 
     Inlinine growth factor reductor
     default: #<procedure:562ec58c8ba0.1>
   - *inlining?* : 
     Inlining optimization
     default: #t
   - *interpreter* : 
     Shall we interprete the source file?
     default: #f
   - *jvm-bigloo-classpath* : 
     JVM Bigloo classpath
     default: #f
   - *jvm-catch* : 
     Catch internal errors
     default: #t
   - *jvm-cinit-module* : 
     Enable JVM class constructors to initiliaze bigloo modules
     default: #f
   - *jvm-classpath* : 
     JVM classpath
     default: "."
   - *jvm-debug* : 
     JVM debugging mode?
     default: #f
   - *jvm-directory* : 
     JVM object directory
     default: #f
   - *jvm-env* : 
     List of environment variables to be available in the compiled code
     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"
   - *jvm-jar?* : 
     Enable/disable a JAR file production for the JVM back-end
     default: #f
   - *jvm-jarpath* : 
     JVM jarpath
     default: #f
   - *jvm-java* : 
     JVM to be used to run Java programs
     default: "java"
   - *jvm-mainclass* : 
     JVM main class
     default: #f
   - *jvm-options* : 
     JVM options
     default: ""
   - *jvm-path-separator* : 
     JVM classpath
     default: #f
   - *jvm-shell* : 
     Shell to be used when producing JVM run scripts
     default: "sh"
   - *ld-debug-option* : 
     The C linker debugging option
     default: "-g "
   - *ld-library-dir* : 
     Depreacted, don't use
     default: "/home/serrano/prgm/project/bigloo/bigloo/lib/bigloo/4.3h"
   - *ld-o-option* : 
     The C linker -o option
     default: "-o "
   - *ld-optim-flags* : 
     The C linker optimization flags
     default: ""
   - *ld-options* : 
     ld options
     default: " "
   - *ld-post-options* : 
     ld post options
     default: ("")
   - *ld-relative* : 
     Relative or absolute path names for libraries
     default: #t
   - *ld-style* : 
     ld style
     default: "gcc"
   - *lib-dir* : 
     The lib dir path
     default: ("." "/home/serrano/prgm/project/bigloo/bigloo/lib/bigloo/4.3h")
   - *lib-mode* : 
     Lib-mode compilation?
     default: #f
   - *lib-src-dir* : 
     The lib dir path
     default: "runtime"
   - *load-path* : 
     The load path
     default: ("." "/home/serrano/prgm/project/bigloo/bigloo/lib/bigloo/4.3h")
   - *max-c-foreign-arity* : 
     Max C function arity
     default: 16
   - *max-c-token-length* : 
     Max C token length
     default: 1024
   - *mco-include-path* : 
     Module checksum C include path
     default: (".")
   - *mco-suffix* : 
     Module checksum object legal suffixes
     default: ("mco")
   - *module-checksum-object?* : 
     Produce a module checksum object (.mco)
     default: #f
   - *multi-threaded-gc?* : 
     Are we using a multi-threaded GC?
     default: #f
   - *o-files* : 
     The additional obect files
     default: ()
   - *obj-suffix* : 
     Object legal suffixes
     default: ("o" "a" "so")
   - *object-init-mode* : 
     Object initialization mode
     default: stagged
   - *optim* : 
     Optimization level
     default: 0
   - *optim-O-macro?* : 
     Enable optimization by macro-expansion
     default: #f
   - *optim-atom-inlining?* : 
     Skip atom in inlining parameter counting
     default: #t
   - *optim-cfa-apply-tracking?* : 
     Track values across apply
     default: #f
   - *optim-cfa-fixnum-arithmetic?* : 
     Enable refined fixnum arithmetic specialization
     default: #f
   - *optim-cfa-flonum-arithmetic?* : 
     Enable refined flonum arithmetic specialization
     default: #f
   - *optim-cfa-force-loose-local-function?* : 
     Force loosing local function approximations (for debugging)
     default: #f
   - *optim-cfa-free-var-tracking?* : 
     Enable closure free-variables specialization
     default: #f
   - *optim-cfa-pair-quote-max-length* : 
     Maximum length for pair literal tracking
     default: 4
   - *optim-cfa-pair?* : 
     Track values across pairs
     default: #f
   - *optim-cfa-unbox-closure-args* : 
     Unbox closure arguments
     default: #f
   - *optim-cfa?* : 
     Enable CFA
     default: #t
   - *optim-dataflow-for-errors?* : 
     Enable simple dataflow optimization for eliminating bad error messages
     default: #t
   - *optim-dataflow-types?* : 
     Enable dataflow optimization for types
     default: #f
   - *optim-dataflow?* : 
     Enable simple dataflow optimization
     default: #f
   - *optim-initflow?* : 
     Enable initflow optimization for global variables
     default: #f
   - *optim-integrate?* : 
     Enable function integration (closure analysis)
     default: #t
   - *optim-isa?* : 
     Enable isa type tests optimization (inlining)
     default: #f
   - *optim-jvm* : 
     Enable optimization by inlining jvm code
     default: 0
   - *optim-jvm-branch* : 
     Enable JVM branch tensioning
     default: 0
   - *optim-jvm-constructor-inlining* : 
     Enable JVM inlining for constructors
     default: 0
   - *optim-jvm-fasteq* : 
     EQ? no longer works on integers (use =FX instead)
     default: #f
   - *optim-jvm-inlining* : 
     Enable JVM inlining
     default: 0
   - *optim-jvm-peephole* : 
     Enable JVM peephole optimization
     default: 0
   - *optim-loop-inlining?* : 
     Loop inlining optimization
     default: #t
   - *optim-reduce-beta?* : 
     Enable simple beta reduction
     default: #f
   - *optim-return-goto?* : 
     Optimize set-exit by enabling local return
     default: #f
   - *optim-return?* : 
     Optimize set-exit used as return
     default: #f
   - *optim-symbol-case* : 
     Optimize case forms descrimining on symbols only
     default: #f
   - *optim-sync-failsafe?* : 
     Enable failsafe synchronize optimization
     default: #f
   - *optim-tagged-fxop?* : 
     Optimize tagged fixnum operations
     default: #f
   - *optim-unroll-loop?* : 
     Loop unrolling optimization
     default: #unspecified
   - *pass* : 
     Stop after the pass
     default: ld
   - *pre-processor* : 
     An optional function that pre-processes the source file
     default: #<procedure:562ec58c74f0.1>
   - *prof-table-name* : 
     Bprof translation table file name
     default: "bmon.out"
   - *profile-library* : 
     Use the profiled library version
     default: #f
   - *profile-mode* : 
     Bigloo profile mode
     default: 0
   - *purify* : 
     Produce byte code verifier compliant JVM code
     default: #t
   - *qualified-type-file* : 
     The qualifed-type association file name
     default: #f
   - *qualified-type-file-default* : 
     The qualifed-type association file name
     default: ".jfile"
   - *reader* : 
     The way the reader reads input file ('plain or 'intern)
     default: plain
   - *rm-tmp-files* : 
     Shall the .c and .il produced files be removed?
     default: #t
   - *saw* : 
     Do we go to the saw-mill?
     default: #f
   - *saw-bbv?* : 
     Enable/disable saw basic-blocks versionning
     default: #f
   - *saw-no-register-allocation-functions* : 
     The list of functions disabling register allocation
     default: ()
   - *saw-register-allocation-functions* : 
     The list of functions allowing register allocation
     default: ()
   - *saw-register-allocation-max-size* : 
     Max function size for optimizing the register allocation
     default: 4000
   - *saw-register-allocation-onexpression?* : 
     Enable/disable saw register allocation on expression
     default: #f
   - *saw-register-allocation?* : 
     Enable/disable saw register allocation
     default: #f
   - *saw-register-reallocation?* : 
     Enable/disable saw register re-allocation
     default: #f
   - *saw-spill* : 
     Enable saw spill optimization
     default: #f
   - *shared-cnst?* : 
     Shared constant compilation?
     default: #t
   - *shell* : 
     The shell to exec C compilations
     default: "/bin/sh"
   - *src-files* : 
     The sources files
     default: ()
   - *src-suffix* : 
     Scheme legal suffixes
     default: ("scm" "bgl")
   - *startup-file* : 
     A startup file for the interpreter
     default: #f
   - *static-all-bigloo?* : 
     Do we use the static version of all Bigloo libraries?
     default: #f
   - *static-bigloo?* : 
     Do we use the static Bigloo library
     default: #f
   - *stdc* : 
     Shall we produce ISO C?
     default: #f
   - *strip* : 
     Shall we strip the executable?
     default: #t
   - *sync-profiling* : 
     Instrument code for synchronize profiling
     default: #f
   - *target-language* : 
     The target language (either c, c-saw, jvm, or .net)
     default: native
   - *trace-name* : 
     Trace file name
     default: "trace"
   - *trace-write-length* : 
     Trace dumping max level
     default: 80
   - *unsafe-arity* : 
     Runtime type arity safety
     default: #f
   - *unsafe-eval* : 
     Disable type checking for eval functions
     default: #f
   - *unsafe-heap* : 
     Disable heap version checking
     default: #f
   - *unsafe-library* : 
     Use the unsafe library version
     default: #f
   - *unsafe-range* : 
     Runtime range safety
     default: #f
   - *unsafe-struct* : 
     Runtime struct range safety
     default: #f
   - *unsafe-type* : 
     Runtime type safety
     default: #f
   - *unsafe-version* : 
     Module version safety
     default: #f
   - *user-heap-size* : 
     Heap size (in MegaByte) or #f for default value
     default: 0
   - *user-inlining?* : 
     User inlining optimization
     default: #t
   - *user-pass* : 
     The user specific compilation pass
     default: #unspecified
   - *verbose* : 
     The verbosity level
     default: 0
   - *warning-default-slot-value* : 
     Set to #t to warn about non-inlinable default slot values
     default: #f
   - *warning-overriden-slots* : 
     Set to #t to warn about virtual slot overriding
     default: #t
   - *warning-overriden-variables* : 
     Set to #t to warn about variable overriding
     default: #f
   - *warning-type-error* : 
     Set to #t to treat type warnigns as error
     default: #f
   - *warning-types* : 
     Set to #t to warn about type checks
     default: #f
   - *with-files* : 
     The additional modules
     default: ()
 |