cc, pc, m2 - Minix C, Pascal, and Modula-2 compilers

     cc|pc|m2 [-D  name[=value]]  ...   [-U  name]  ...   [-I  directory]  ...
           [-.suffix]  ...   [-c]  [-E]  [-P]  [-S] [-c.suffix] [-O] [-Olevel]
           [-OS] [-OT] [-g] [-n] [-a] [-R] [-A] [-s]  [-fsoft]  [-fnone]  [-w]
           [-wo]  [-ws]  [-wa]  [-3]  [-_]  [-Wname-option]  ...  [-march] [-o
           outfile] [-L directory] ...  [-i] [-sep] [-com] [-r] [-stack  size]
           operand ...

     (Minix-86 subset:)
     cc|pc|m2 [-Dname[=value]] ...  [-Uname] ...  [-Idirectory] ...  [-.o] ...
           [-c]  [-E] [-P] [-S] [-c.suffix] [-O] [-Olevel] [-n] [-a] [-R] [-A]
           [-s] [-f] [-w] [-wo] [-ws] [-wa] [-3] [-_] ...  [-m]  [-o  outfile]
           [-Ldirectory] ...  [-i] [-sep] [-com] operand ...

     Cc, pc, and m2 are the call names of the Minix C,  Pascal,  and  Modula-2
     compilers from the Amsterdam Compiler Kit (ACK).

     All these call names are links to the acd driver program.  Acd  uses  the
     driver description file /usr/lib/descr that describes the steps necessary
     to compile a source file.  The acd(1) manual page describes  a  few  more
     flags, like -v, that may be useful for debugging compiler problems.

     Minix-86 uses a C program as the compiler driver.  This driver is not  as
     flexible as the one implemented with the acd driver, and offers a smaller
     number of options.  The second line  of  the  synopsis  above  shows  the
     options  that the Minix-86 driver supports.  The rest of this manual page
     is geared towards the acd driver.  People writing software for  Minix-86,
     or  that  should  be  portable  to all Minix versions should stick to the
     options listed under the Minix-86 compiler.

     The transformations done by the compiler are modified  by  the  following
     options.   They are a superset of the options required by POSIX, with the
     Minix or compiler specific ones are marked  as  such.   Options  for  one
     specific  compiler  are  ignored for others.  Read the OPTIONS section of
     acd(1) for the driver specific options.

     -D name[=value]
          Same as if #define name value had been given.  1 is assumed if value
          is omitted.  This argument, like all the other double arguments, may
          also be given as a single argument.   (I.e.  either  as  -D name  or
          -Dname.)   (The  Minix-86 driver is not so flexible, the proper form
          can be seen in the synopsis.)

     -U name
          Undefine the pre-defined symbol name.

     -I directory
          Extend the include directory path with the given  directory.   These
          directories are searched for include files in the given order before
          the standard places.  The standard  place  for  the  C  compiler  is
          /usr/include, and for the Modula-2 compiler it is /usr/lib/m2.

          Act as if a source file with the given  suffix  is  present  on  the
          command  line.   For  each  language  found  on the command line the
          appropriate libraries are selected.  The  first  language  mentioned
          selects  the  runtime  startoff.   The  call name of the driver also
          chooses the language,  so  cc  is  an  implicit  -.c.   The  runtime
          startoff can be omitted by specifying -.o for those rare cases where
          you want to supply your own startoff.  (Minix)

     -c   Transform the input files to object files and stop.  The  -o  option
          may be used under Minix to set the name of the object file.  Make(1)
          likes this, because cc -c dir/file.c  puts  file.o  in  the  current
          directory, but cc -c dir/file.c -o dir/file.o puts the .o file where
          make expects it to be by its builtin .c.o rule.  (Minix-86 can  only
          use -o to name an executable.)

     -E   Run the preprocessor over the input files and  send  the  result  to
          standard  output or the file named by -o.  Standard input is read if
          an input file is named "-".

     -P   Run the preprocessor over the input files  and  put  the  result  to
          files  with  the  suffix  .i.   File  and line number information is
          omitted from the output.  Use -P -E under Minix to  omit  this  info
          for -E too.

     -S   Transform the input files to assembly files with suffix .s.

          Transform the input files to files with the given suffix.  This  can
          only  succeed if there is a valid transformation from the input file
          to the given suffix.  The same goes for -c and  other  options  that
          are just special cases of this option, except for -P, -c.i keeps the
          line number info.  The option -c.a makes the  driver  transform  the
          input  files  to object files and add them to a library.  (So you do
          not need to know how the archiver works.)  Note  that  you  need  to
          give  object  files  as  arguments if you want to replace old object
          files.  Transformed files are added under a (unique) temporary name.
          With  -o  you  can  name  the  library.  (Minix)  (Minix-86 can't do

     -O   Optimize code.  This option is a no-op, because  all  the  compilers
          already  use  the  -O1  optimization level to get code of reasonable
          quality.  Use -O0 to turn off optimization to speed  up  compilation
          at debug time.

          Compile with the given optimization level.  (Minix)

          Optimize for space or for time.  (Minix)

     -g   Compile the C source with debugging information.  (The  way  -g,  -s
          and -O interact is left unspecified.)

     -n   Omit the file and line number tracking  that  is  used  for  runtime
          error  reports  from  Pascal  or  Modula-2 programs.  The -n flag is
          normally used to compile library modules, but may also be useful  to
          make  a program smaller and faster once debugged.  (Pascal & Modula-

     -a   Enable assertions, i.e. statements  of  the  form  assert test  that
          cause  a  descriptive  runtime  error if the boolean expression test
          evaluates false.  (Pascal & Modula-2)

     -R   Disable runtime checks like overflow checking.  (Pascal & Modula-2)

     -A   Enable array bound checks.  (Pascal & Modula-2)

     -s   Strip the resulting executable of its symbol table.

          Use software floating point  instead  of  hardware  floating  point.
          This  is  a  loader  flag, but in general it is best to specify this
          flag in all phases of the compilation.  (Minix)

          Ignored.    Used   under   Minix-vmd   to   omit   floating    point
          printing/scanning  code.   The  standard Minix compiler figures this
          out automatically using a special loader trick.  (Minix)

     -w   Do  not  produce  warnings  about  dubious  C  language  constructs.
          Normally  the  compiler  is  configured  to do the maximum amount of
          checking without being too annoying.  (Minix)

     -wo  Omit warnings about old (K&R) style.  (Minix)

     -ws  Omit strict warnings.  (Minix)

     -wa  Omit all warnings.  (Minix)

     -3   Only accept 3rd edition Modula-2.  (Modula-2)

     -_   Allow underscores in Pascal or Modula-2 identifiers, but not at  the
          beginning of an identifier.  (Pascal & Modula-2)

          If name is the name of the compiler this driver is working for, then
          option is activated for that compiler.  See below for a per-compiler
          list.  Any other -W option is ignored.  (-W is described by POSIX as
          an  optional  flag  to send options to the different compiler passes
          with a totally different (and nicely ignored)  syntax  as  described
          here.)  (Minix-86 ignores any -W flag.)

     -m   Under Minix-86 this  option  transforms  the  function  declarations
          (prototypes)  to  the  old K&R form, i.e. the arguments declarations
          are removed.  This saves a lot of memory in  the  compiler  and  may
          allow  a  large  program  to  be  compiled.  One must make sure that
          function arguments are properly type-cast where necessary.  (Minix)

          Set the target architecture for  a  cross  compiler.   Normally  the
          compiler  produces  code  for  the  same  architecture  it itself is
          compiled for.  The ARCH environment variable may also be used to set
          the  architecture.   Architectures  names  are:  i86 (Intel 8086 and
          286), i386  (Intel  386,  486,  ...),  m68000  (Motorola  MC68000  &
          MC68010,  16-bit  ints),  m68010 (Motorola MC68000 & MC68010, 32-bit
          ints), m68020 (Motorola MC68020, 32-bit ints),  sparc  (Sun  SPARC).
          (Minix)  (Ignored under Minix-86.)

     -o outfile
          Set the output file for the -c, -c.a, and -E options, or choose  the
          executable  name  instead  of the default a.out.  (Minix-86 can only
          choose the executable name.)

     -L directory
          Extend the library search path with  directory.   These  directories
          are searched for libraries named by -l in the given order before the
          standard  places.   The   standard   places   are   /lib/arch,   and
          /usr/lib/arch.  The search for libaries in directories added with -L
          looks in directory/arch and directory itself.  (Arch is the  machine
          architecture  name.   This  is  Minix  dependent, compilers on other
          systems usually only look in directory.)  (Minix-86  only  has  /lib
          and /usr/lib as the standard places.)

          Create a Separate I&D or a common I&D executable.  The text  segment
          of a separate I&D executable is read-only and shareable.  For an i86
          binary this also means that the text and data segment can each be 64
          kilobytes large instead of just 64 kilobytes together.  Separate I&D
          is the  default.   Common  I&D  is  probably  only  useful  for  the
          bootstraps.   The -i option has the same meaning as -sep, but should
          no longer be used.  (Minix)

     -r   Makes the loader produce a relocatable object file, i.e. a file that
          may be loaded again.  The runtime startoff and the default libraries
          are omitted, only the files mentioned are combined.  (Minix)

     -stack size
          Allow the process size bytes of heap and stack.  Size is  a  C-style
          decimal,  octal,  or  hexadecimal number, optionally followed by the
          multipliers m, k, w, and b for mega (1024*1024), kilo (1024), "word"
          (2 or 4), and byte (1).  Uppercase letters are accepted too.  A size
          of 32kw is used by default, translating to 64k for i86, and 132k for
          other  architectures.   Too large a size is rounded down to keep the
          data segment within 64 kilobytes for the i86.  (Minix)

     All leftover operands are treated as  files  to  be  compiled,  with  one
     exception.  The construct -l library is used to denote a library, usually
     liblibrary.a, that is to be searched in the directories mentioned with -L
     or  the  standard  places.   These  libraries  keep their place among the
     (transformed) input files when presented to the loader.  (It is a  common
     mistake to write cc -lcurses x.c instead of cc x.c -lcurses.)

     The Minix compiler implementation uses the ACK compilers adapted for  use
     under   Minix   as  described  below.   Read  ACK(7)  for  more  detailed
     information on the ACK compilers themselves.

  Feature test macros
     The preprocessors are  given  these  arguments  to  define  feature  test
     macros:   -D__ACK__  tells  what  compiler is used.  -D__minix tells that
     this is Minix.   -D__arch  tells  the  architecture.   (More  macros  are
     defined, but they are only to be used in the include files.)

     The symbols above are predefined by the preprocessor so that your program
     is  able  to  "sense"  the environment it is in.  It is also possible for
     your program to do the opposite, to tell  what  kind  of  environment  it
     likes  to  have.   By  default, cc compiles a standard C program.  If you
     want the extensions described in POSIX.1 to become visible, then you have
     to  set  _POSIX_SOURCE to 1 at the start of your program.  To enable UNIX
     or Minix extensions you need to also set _MINIX to 1.  If you don't  want
     to  clutter  your  source  files  with  these symbols then you can use cc
     -D_MINIX -D_POSIX_SOURCE to get the POSIX.1 and the Minix extensions.

     Pascal,  Modula-2,  EM  source  (see  below),  and  Assembly  source  are
     preprocessed  by  the  C  preprocessor if the very first character in the
     file is a '#' character.

  Assembly dialects
     No two compilers use the same assembly language.  To be able to  use  the
     same  assembly  dialect  for  the  low level support routines an assembly
     converter is provided.  The input of this converter can be of  type  ack,
     ncc,  or bas, and the output can be of type ack, ncc, or gnu.  The suffix
     of the file tells the assembly dialect (see below), or one  can  use  the
     option  -Was-dialect  to  tell  the driver what the dialect of a plain .s
     file is.  The assembly converter is not as smart as  the  assembler,  the
     translation  is  more  or  less  a text substitution.  It leaves a lot of
     checking to the target assembler.  You have to  restrict  yourself  to  a
     subset  that  is  understood  by  both assemblers.  The ACK assembler for
     instance doesn't care if you use `ax' or `eax' for a 32 bit register,  it
     looks  at  the instruction type.  The GNU assembler doesn't like this, so
     you have to use the proper register name in ACK assembly that  is  to  be
     translated to GNU assembly.  Expressions are converted as is, even if the
     operator precedence rules of the two assembly languages differ.   So  use
     parentheses.   The  converter does promise one thing: compiler output can
     be properly translated.  (Note that under Minix-86 -W  is  ignored.   All
     assembly should therefore be in the "ncc" dialect.)


               The compiler description file.

     .c        Suffix of a C source file.

     .mod      Modula-2.

     .p        Pascal.

     .i        Preprocessed C source.

     .k        ACK machine independent compact EM  code  produced  by  the  C,
               Pascal,  or  Modula-2  front  end (or any other ACK front end.)
               The ACK compilers are based on the  UNCOL  idea  where  several
               front  ends  compile  to  a  common  intermediate language, and
               several back ends transform the intermediate  language  to  the
               target  machine  language.   The  ACK  intermediate language is
               named "EM".

     .m        Peephole optimized EM.

     .gk       Result of the (optional) EM global optimizer.

     .g        Result of the second  EM  peephole  optimizer  used  after  the
               global optimizer.

     .e        Human readable EM.  (Human created or decoded compact EM.)

     .s        Target machine assembly.  (Current compiler dialect.)

     .ack.s    ACK assembly.

     .ncc.s    ACK Xenix style assembly.  This dialect is used by the  16  bit
               ACK ANSI C compiler.

     .gnu.s    GNU assembly.

     .bas.s    BCC assembly.  (Used by the Bruce Evans' BCC compiler, for many
               years the compiler for Minix-386.)

     .o        Object code.

     .a        Object code library.

     a.out     Default output executable.

     acd(1), ACK(7).

     Kees J. Bot (