22. Bigloo -- Compiler description

22. Bigloo -- Compiler description

Browsing

Home: Bigloo
A ``practical Scheme compiler''
User manual for version 2.6c
March 2004

Previous chapter: DSSSL support
Next chapter: User Extensions

Compiler description

22.1 C requirement
22.2 JVM requirement
22.3 Linking
22.4 The compiler environment and options
  22.4.1 Efficiency
  22.4.2 Stack allocation
  22.4.3 Genericity of arithmetic procedures
  22.4.4 Safety
  22.4.5 The runtime-command file
  22.4.6 The Bigloo command line

Chapters

  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. Extending the Runtime System
20. SRFIs
21. DSSSL support
22. Compiler description
23. User Extensions
24. Bigloo Development Environment
25. Global Index
26. Library Index
  Bibliography

22.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].

22.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.

22.3 Linking

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.

22.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.

22.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.

22.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).

22.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.

22.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)))

22.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.

22.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,--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
   -suffix SUFFIX            Recognize suffix as Scheme source
   -afile FILE               Name of the access file (default .afile)
   -access MODULE FILE       Set access between module and file
   -jfile FILE               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 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
   -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 DIR                    Add DIR to the load path
   -lib-dir DIR              Set lib-path to DIR
   -lib-version VERSION      Set the version of the libraries
   -L NAME                   Set additional library path

Back-end:
   -native                   Compile module to native object file (via C)
   -jvm                      Compile module to JVM .class files
   -dotnet                   Compile module to .NET object files
   -saw                      Cut the AST in the saw-mill
   -no-saw                   Disable saw back-ends
   -i                        Interprete module

Dialect:
   -nil                      Evaluate '() as #f in `if' expression
   -call/cc                  Enable call/cc function
   -hygien                   Obsolete (R5rs macros are always supported)
   -fno-reflection           Disable reflection code production
   +fno-reflection           Enable reflection code production
   -fclass-nil               Enables generation of "class-nil" function
   -fno-class-nil            Disables generation of "class-nil" function
   -farithmetic              Suppress genericity of arithmetic operators
   -fcase-sensitive          Case sensitive reader (default)
   -fcase-insensitive        Case insensitive reader (downcase symbols)

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
   -fglobal-tailc            Enable global tail-call optimization (default with -saw)
   -fno-global-tailc         Disable global tail-call optimization

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

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
   -gheap                    Enables heap debugging (set with -gbdb2)
   -gmodule                  Debug module initialization
   -gerror-localization      Localize error calls in the source code
   -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[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

Compilation modes:
   <-/+>rm                   Don't or force removing .c or .il files
   -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 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
   -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
   -ld-libs1                 Add once user libraries when linking
   -ld-libs2                 Add twice user libraries when linking (default)
   -lLIBRARY                 Link with host library

Jvm specific options:
   -jvm-shell SHELL          Shell for JVM scripts ("sh", "msdos")
   -jvm-purify               Produce byte code verifier compliant JVM code
   -no-jvm-purify            Don't care about JVM code verifier (default)
   -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
   -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

.NET specific options:
   -dotnet-managed           Produce byte code verifier compliant .NET code
   -dotnet-unmanaged         Don't care about .NET code verifier (default)
   -dotnet-clr FILE          Use FILE as .NET CLR
   -dotnet-clr-style S       Use CLR invokation style
   -dotnet-clr-opt S         Set the .NET CLR options
   -dotnet-ld FILE           Use FILE as .NET LD
   -dotnet-ld-style STRING   Use LD invokation style
   -dotnet-dll-path NAME     Set the .NET DLL search path
   -dotnet-external-asm      Enable external assembler (default)
   -no-dotnet-external-asm   Disable external assembler
   -ilasm ASM                Specify external IL assembler
   -fdotnet-tailc            Flag tail calls for inside module calls
   -fno-dotnet-tailc         Don't flag tail calls
   -fdotnet-tailc-full       Flag tail calls everywhere
   -fdotnet-tailc-module     Flag tail calls across modules
   -fno-dotnet-tailc-module  Don't flag tail calls across modules
   -fdotnet-tailc-funcall    Flag tail calls for funcalls
   -fno-dotnet-tailc-funcall Don't flag tail call for funcalls
   -dotnet-mono-workaround   Workaround Mono 0.29 .NET buts (switch)
   -dotnet-pnet-workaround   Workaround pnet swich bug

Traces:
   -t[2|3|4]                 Generate a trace file (*)
   +tPASS                    Force pass to be traced
   -shape[mktTalu]           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
   -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
   -tailc                    Stop after the tailc stage
   -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
   -il                       Produce a .NET .asm file

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
   -target LANG              DON'T USE, (see -native, -jvm, -dotnet)

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


------------
 * : 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* : 
     The access file name
     default: #f
   - *access-file-default* : 
     The default access file name
     default: ".afile"
   - *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: ()
   - *ast-case-sensitive* : 
     Case sensitivity
     default: #t
   - *auto-mode* : 
     auto-mode (extend mode) list
     default: (("ml" . "caml") ("mli" . "caml") ("oon" . "meroon"))
   - *bdb-debug* : 
     Bdb debugging mode
     default: 0
   - *bigloo-abort?* : 
     Do we have the bigloo-abort function in executables?
     default: #f
   - *bigloo-lib-base-name* : 
     The Bigloo library base name
     default: ("bigloo" . "2.6c")
   - *bigloo-libraries-translation-table* : 
     An assoc table between symbolic lib names and native lib names
     default: ()
   - *bigloo-licensing?* : 
     Add the Bigloo license ?
     default: #f
   - *bigloo-name* : 
     The Bigloo name
     default: "Bigloo (2.6c)"
   - *bigloo-specific-version* : 
     The Bigloo specific version
     default: ""
   - *bigloo-strict-r5rs-strings* : 
     Disables/enables non R5Rs string escape sequences
     default: #f
   - *bigloo-tmp* : 
     The tmp directory name
     default: "/tmp"
   - *bigloo-user-lib* : 
     The user extra C libraries
     default: ("-lm")
   - *bigloo-version* : 
     The Bigloo major release number
     default: "2.6c"
   - *bigloo-vlib* : 
     The Bigloo library
     default: ("bigloo" . "2.6c")
   - *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")
   - *call/cc?* : 
     Shall we enable call/cc?
     default: #f
   - *cc* : 
     The C compiler
     default: "gcc"
   - *cc-move* : 
     Use mv or -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: ""
   - *cflags-optim* : 
     The C compiler optimization option
     default: "-O3 "
   - *cflags-prof* : 
     The C compiler profiling option
     default: "-pg -fno-inline "
   - *class-nil?* : 
     Shall we produce class-nil function for classes
     default: #t
   - *compiler-debug* : 
     Debugging level
     default: 0
   - *compiler-sharing-debug?* : 
     Compiler self sharing debug
     default: #f
   - *csharp-suffix* : 
     C# legal suffixes
     default: ("cs")
   - *debug* : 
     The debugging level
     default: 0
   - *debug-module* : 
     Module initilazation debugging
     default: 0
   - *default-lib-dir* : 
     The default lib dir path (without version)
     default: "/usr/lib/bigloo/2.6c"
   - *dest* : 
     The target name
     default: #f
   - *dlopen-init* : 
     Emit a standard Bigloo dynamic loading init entry point
     default: #f
   - *dotnet-clr* : 
     CLR to be used to run .NET programs
     default: ""
   - *dotnet-clr-opt* : 
     CLR extra options to be used to run .NET programs
     default: ""
   - *dotnet-clr-style* : 
     CLR style to be used to run .NET programs
     default: ""
   - *dotnet-dll-path* : 
     Bigloo.dll path
     default: #f
   - *dotnet-external-asm* : 
     Force using and external assembler for .NET code
     default: ""
   - *dotnet-external-asm-style* : 
     Force using and external assembler for .NET code
     default: pnet
   - *dotnet-ld* : 
     .NET object file linker
     default: ""
   - *dotnet-ld-style* : 
     .NET object file linker style
     default: ""
   - *dotnet-mono-workaround-switch* : 
     Workaround mono 0.23..0.29 bug
     default: #f
   - *dotnet-pnet-workaround-switch* : 
     Workaround pnet switch bug
     default: #f
   - *dotnet-shell* : 
     .NET object file linker
     default: ""
   - *dotnet-tail* : 
     Enable/disable tail call generations
     default: #f
   - *dotnet-tail-across-modules* : 
     Enable/disable tail call generations across modules
     default: #f
   - *dotnet-tail-funcall* : 
     Enable/disable tail call generations for funcall
     default: #f
   - *dotnet-use-external-asm* : 
     Force using and external assembler for .NET code
     default: #t
   - *double-ld-libs?* : 
     Do we include twice the additional user libraries
     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-lib* : 
     The Gc library
     default: ("bigloogc" . "2.6c")
   - *global-tail-call?* : 
     Do we apply the self-global-tail-call stage?
     default: #unspecified
   - *heap-base-name* : 
     The Bigloo heap base name
     default: "bigloo"
   - *heap-debug* : 
     Heap debugging mode
     default: 0
   - *heap-debug-copt* : 
     Heap debugging C flags
     default: "-DKEEP_BACK_PTRS"
   - *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-name* : 
     The Bigloo heap file name
     default: "bigloo.heap"
   - *hello* : 
     Say hello (when verbose)
     default: #t
   - *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: ""
   - *init-mode* : 
     Module initialization mode
     default: read
   - *inlining-kfactor* : 
     Inlining growth factor
     default: #<procedure:805ee70.1>
   - *inlining-reduce-kfactor* : 
     Inlinine growth factor reductor
     default: #<procedure:805ee90.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-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* : 
     The ld lib dir path (without version)
     default: "/usr/lib"
   - *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: ("." "/usr/lib/bigloo/2.6c")
   - *lib-mode* : 
     Lib-mode compilation?
     default: #f
   - *lib-src-dir* : 
     The lib dir path
     default: "./runtime"
   - *load-path* : 
     The load path
     default: ("." "/usr/lib/bigloo/2.6c")
   - *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")
   - *optim* : 
     Optimization level
     default: 0
   - *optim-O-macro?* : 
     Enable optimization by macro-expansion
     default: #f
   - *optim-cfa-arithmetic?* : 
     Enable refined arithmetic specialization
     default: #f
   - *optim-dataflow?* : 
     Enable simple dataflow optimization
     default: #f
   - *optim-integrate?* : 
     Enable function integration (closure analysis)
     default: #t
   - *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-unroll-loop?* : 
     Loop unrolling optimization
     default: #unspecified
   - *pass* : 
     Stop after the pass
     default: ld
   - *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: #f
   - *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
   - *reflection?* : 
     Shall we produce reflection code for classes
     default: #t
   - *rm-tmp-files* : 
     Shall the .c and .il produced files be removed?
     default: #t
   - *saw* : 
     Do we go to the saw-mill?
     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-bigloo?* : 
     Do we use the static Bigloo library
     default: #f
   - *stdc* : 
     Shall we produced ISO C?
     default: #f
   - *strip* : 
     Shall we strip the executable?
     default: #t
   - *target-language* : 
     The target language (either C, 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-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
   - *use-private?* : 
     Use private construction instead of pragma
     default: #f
   - *user-heap-size* : 
     Heap size (in MegaByte) or #f for default value
     default: #f
   - *user-inlining?* : 
     User inlining optimization
     default: #t
   - *user-pass* : 
     The user specific compilation pass
     default: #unspecified
   - *verbose* : 
     The verbosity level
     default: 0
   - *warning* : 
     The warning level
     default: #t
   - *warning-overriden-slots* : 
     Set to #t to warn about virtual slot overriding
     default: #t
   - *with-files* : 
     The additional modules
     default: ()

This Scribe page has been generated by scribeinfo.
Last update Tue Mar 16 17:05:46 2004