NAME

       ozc - compile oz code

SYNOPSIS

       ozc [mode] options ...

       MODES

       The  `ozc'  compiler  can  operate in one of several mutually exclusive
       modes selected by the options below:

       -h, -?, --help
              Prints out information on all legal options, then exits

       -c, --dump
              `ozc -c FILE.oz' compiles and evaluates the expression  in  file
              FILE.oz,  then pickles the resulting value into the output file,
              FILE.ozf by default.

       -e, --feedtoemulator
              `ozc -e FILE.oz' compiles and executes  the  statement  in  file
              FILE.oz. This is the default mode of operation.

       -E, --core
              `ozc  -E  FILE.oz' translates the statement in file FILE.oz into
              the core language, then  writes  this  expanded  form  into  the
              output file, FILE.ozi by default.

       -S, --outputcode
              `ozc -S FILE.oz' compiles the statement in file FILE.oz into the
              assembly bytecode format, then writes it  to  the  output  file,
              FILE.ozm by default.

       -x, --executable
              `ozc  -x  FILE.oz'  much  like  -c,  compiles  and evaluates the
              expression in file FILE.oz, then writes the resulting value into
              the  output  file, by default: FILE (no extension) under Unix or
              FILE.exe under Windows. Additionally, it makes the  output  file
              executable.  Thus,  if  Foo.oz  contains an application functor:
              `ozc -x Foo.oz' creates the file Foo  (Foo.exe  under  Windows),
              which  is executable and can be invoked directly from the shell.
              However, you can always run an application functor  as  follows:
              `ozengine  url  args  ...'  where  url is a URL or pathname that
              references the application functor.

       OPTIONS

       Additionally, the compiler understands the following general options:

       -v, --verbose
              Display all compiler messages

       -q, --quiet
              Inhibit compiler messages

       -M, --makedepend
              Instead of executing, write a list of dependencies to stdout

       -o FILE, --outputfile=FILE
              Write output to FILE (- for stdout)

       --execheader=STRING
              When invoked with option -x the compiler first outputs a  header
              so  that  the  output  file  may be interpreted by the operating
              system as an executable. Under Unix, the default behaviour is to
              use the following as header:

              #!/bin/sh
              exec ozengine $0 "$@"

              The  --execheader  option  allows  you  to  specify  a different
              header.

       --execpath=STRING
              Uses the header given above in the description of  --execheader,
              except that ozengine is replaced by STRING.

       --execfile=FILE
              Reads  in  FILE  and  uses  this  as  header. Under Windows, the
              default   behaviour   is   to   use   the   file   provided   in
              ozhome/bin/ozwrapper.bin,  where ozhome is Mozart's installation
              folder. ozwrapper.bin is  a  Windows  executable  that  launches
              ozengine.

       --execwrapper=FILE
              Reads  in  ozhome/bin/FILE  and uses it as header for executable
              files. Apart from ozwrapper.bin, an ozwrapperw.bin  is  supplied
              that   launches  ozenginew  instead  of  ozengine.  This  option
              provides a convenient way to use this alternative wrapper.

       -z N, --compress=N
              Pickles may be written in a compressed format. By  default  they
              are  not compressed. `-z N' selects a compression level: N is an
              integer between 1  and  9.  Compressing  a  pickle  may  improve
              loading/downloading time.

       -D NAME, --define=NAME
              Define   macro   NAME.   Code  source  may  have  `\ifdef  NAME'
              conditional directives that tests whether macro NAME is defined.

       -U NAME, --undefine=NAME
              Undefines macro NAME

       -l MODULES, --environment=MODULES

              ozc -l Baz=$HOME/baz.ozf -c Foo.oz

              Makes  MODULES,  a  comma-separated  list  of   pairs   VAR=URL,
              available  in  the  environment.  For  each  VAR=URL, the module
              available through the functor at URL  is  obtained  and  VAR  is
              bound  to  it. The file Foo.oz being compiled can then reference
              variable VAR.

       -I DIR, --incdir=DIR
              Adds DIR to the head of OZPATH which is used to locate files  to
              \insert.

       --include=FILE
              Compile  and execute the statement in FILE before processing the
              remaining options.  This  can  be  used  e.  g.  to  extend  the
              compilation environment by executing a declare.

       --maxerrors=N
              Limit the number of errors reported to N.

       --baseurl=STRING
              Set  the  base  URL  to  resolve imports of computed functors to
              STRING.

       SWITCHES

       Finally, phases of the compiler  can  be  controlled  by  the  compiler
       switches below:

       -g, --(no)debuginfo
              Emits  code  with  debugging information. Use this option if you
              want to take advantage of The Mozart Debugger. The -g option  is
              actually    an    abbreviation    for    the    combination   of
              --controlflowinfo and --staticvarnames.

       --(no)controlflowinfo
              Include control flow information

       --(no)staticvarnames
              Include static variable name information

       -p, --(no)profile
              Emits code with profiling information. Use this  option  if  you
              want to take advantage of The Mozart Profiler.

       --(no)gump
              Allow Gump definitions.

       --(no)compilerpasses
              Show compiler passes.

       --(no)warnredecl
              Warn about top-level redeclarations.

       --(no)warnshadow
              Warn about all redeclarations.

       --(no)warnunused
              Warn about unused variables.

       --(no)warnunusedformals
              Warn about unused variables and formals.

       --(no)warnforward
              Warn about oo forward declarations.

       --(no)warnopt
              Warn about missed optimizations.

       --(no)expression
              Expect expressions, not statements.

       --(no)allowdeprecated
              Allow use of deprecated syntax.

       --(no)staticanalysis
              Run static analysis.

       --(no)realcore
              Output the real non-fancy core syntax.

       --(no)debugvalue
              Annotate variable values in core output.

       --(no)debugtype
              Annotate variable types in core output.

       --functionalpatterns
              Use functional pattern-matching.

                                                                        ozc(1)