@c -- The Bigloo command line -------------------------------------- @c
@subsection The Bigloo command line
@cindex compiler options

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

@display

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

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
   -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-clr FILE         Use FILE as .NET CLR
   -dotnet-clr-style S      Use CLR invokation style
   -dotnet-clr-opt FILE     Use FILE as .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

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
   -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.6b")
   - *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.6b)"
   - *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.6b"
   - *bigloo-vlib* : 
     The Bigloo library
     default: ("bigloo" . "2.6b")
   - *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-2.95"
   - *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: " -Wpointer-arith -Wswitch -Wtrigraphs"
   - *cc-style* : 
     The C compiler style
     default: "gcc"
   - *cflags* : 
     The C compiler option
     default: " -Wpointer-arith -Wswitch -Wtrigraphs"
   - *cflags-optim* : 
     The C compiler optimization option
     default: "-O3  -Wpointer-arith -Wswitch -Wtrigraphs"
   - *cflags-prof* : 
     The C compiler profiling option
     default: "-pg -fno-inline  -Wpointer-arith -Wswitch -Wtrigraphs"
   - *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: "/users/serrano/prgm/project/bigloo/lib/2.6b"
   - *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: "ilrun"
   - *dotnet-clr-opt* : 
     CLR extra options to be used to run .NET programs
     default: "-S 4096 -C 256"
   - *dotnet-clr-style* : 
     CLR style to be used to run .NET programs
     default: "pnet"
   - *dotnet-dll-path* : 
     Bigloo.dll path
     default: #f
   - *dotnet-external-asm* : 
     Force using and external assembler for .NET code
     default: "ilasm"
   - *dotnet-external-asm-style* : 
     Force using and external assembler for .NET code
     default: pnet
   - *dotnet-ld* : 
     .NET object file linker
     default: "cscc"
   - *dotnet-ld-style* : 
     .NET object file linker style
     default: "pnet"
   - *dotnet-shell* : 
     .NET object file linker
     default: "sh"
   - *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
   - *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.6b")
   - *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:8052274.1>
   - *inlining-reduce-kfactor* : 
     Inlinine growth factor reductor
     default: #<procedure:80521a4.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-purify* : 
     Produce byte code verifier compliant JVM code
     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: "/users/serrano/prgm/project/bigloo/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: ("." "/users/serrano/prgm/project/bigloo/lib/2.6b")
   - *lib-mode* : 
     Lib-mode compilation?
     default: #f
   - *lib-src-dir* : 
     The lib dir path
     default: "./runtime"
   - *load-path* : 
     The load path
     default: ("." "/users/serrano/prgm/project/bigloo/lib/2.6b")
   - *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
   - *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 refection 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: ()
@end display

