LIMBO(1E)                                               LIMBO(1E)

          limbo - Limbo compiler

          limbo [ option ... ] [ file ... ]

          Limbo compiles the named Limbo files into machine-
          independent object files for the Dis virtual machine.
          Depending on the options, the compiler may create output
          files or write information to its standard output.  Conven-
          tional files and their extensions include the following.

          file.b    Limbo source file.

          file.dis  Object code for the Dis virtual machine.

          file.m    Limbo source file for module declarations.

          file.s    Assembly code.

          file.sbl  Symbolic debugging information.

          With no options, limbo produces a .dis file for each source

          The compiler options are:

          -a        Print on standard output type definitions and call
                    frames useful for writing C language implementa-
                    tions of Limbo modules.  Suppresses normal output
                    file generation.

          -C        Mark the Dis object file to prevent run-time com-

          -c        Mark the Dis object file to guarantee run-time

          -D flags  Turn on debugging flags. Flags include A for
                    arrays, a for alt statements, b for booleans, C
                    for case body statements, c for case statements, D
                    for use descriptors, d for declarations, e for
                    expressions, E for extended expressions, F for
                    function information, f for constant folding, m
                    for modules, n for nil references, P for program
                    counter manipulations, r for reference types, S
                    for type signatures, s for a code generation sum-
                    mary, T for tuples, t for type checking, and v for
                    variable initialization.

     Page 1                       Plan 9             (printed 10/2/22)

     LIMBO(1E)                                               LIMBO(1E)

          -e        Increase the number of errors the compiler will
                    report before exiting.

          -G        Annotate assembly language output with debugging
                    information.  A no-op unless -S is set.

          -g        Generate debugging information for the input files
                    and place it in a file named by stripping any
                    trailing .b from the input file name and appending

          -i        Disable inlining of functions. Currently functions
                    containing a single return statement or two return
                    statements and an if clause are candidates for

          -I dir    An include file whose name does not begin with
                    slash is sought first relative to the working
                    directory, regardless of the source file argument.
                    If this fails, limbo sequences through directories
                    named in -I options, then searches in /module.  An
                    include file contains Limbo source code, normally
                    holding one or more module declarations.

          -o obj    Place output in file obj (allowed only if there is
                    a single input file). The output file will hold
                    either object or assembly code, depending on -S.
                    Default is to take the last element of the input
                    file name, strip any trailing .b, and append .dis
                    for object code and .s for assembly code.  Thus,
                    the default output file for dir/mod.b would be

          -S        Create assembly language output instead of object

          -T module Print on standard output C stub functions, useful
                    for implementing Limbo modules in the C language
                    for linkage with the interpreter.

          -t module Print on standard output a table of runtime func-
                    tions, to link C language implementations of mod-
                    ules with the Limbo interpreter.  Suppresses nor-
                    mal output file generation.

          -w        Print warning messages about unused variables,
                    etc.  More w's (e.g., -ww) increase the pedantry
                    of the checking.

          /module  directory for Limbo include modules

     Page 2                       Plan 9             (printed 10/2/22)

     LIMBO(1E)                                               LIMBO(1E)

          /appl/limbo  compiler source in Limbo
          /limbo       compiler source in C for host

          asm(1), emu(1), mk(10.1), intro(2), sys-intro(2), tk(2)

          ``The Limbo Programming Language''
          ``Program Development in Inferno''
          ``A Descent into Limbo''
          in Volume 2.

     Page 3                       Plan 9             (printed 10/2/22)