




Command:   cc - C compiler
Syntax:    cc  [-STOUfcimos]  [-w[aos]]   [-v[n]]   [-Dname]*   [-Idir]*
                [-Ldir]* file+ [-lname]*
Flags:     -D  The flag -Dx[=y] defines a macro x with (optional)  value
               y
           -I  -Idir searches dir for include files
           -L  -Ldir searches dir for -lname libraries
           -O  Optimize the code
           -S  Produce an assembly code file, then stop
           -T  The flag -Tdir tells cc and as to use dir  for  temporary
               files
           -U  Undefine a macro
           -E  Preprocess to standard output
           -c  Compile only.  Do not link
           -f  Link with floating point emulation library
           -i  Use separate I & D space (64K + 64K) (MINIX-PC only)
           -l  The flag -lname causes the library libname.a to be linked
           -m  Remove unnecessary prototypes after preprocessing (MINIX-
               PC only)
           -o  Put output on file named by next arg
           -s  Strip the symbol-table from executable file
           -v  Verbose; print pass names
           -vn Verbose; print pass names but do not run them
           -w  Suppress warning messages
           -ws Suppress strict messages
           -wa Suppress all warning and strict messages
           -wo Suppress messages about old-style
           -.o Do not link the default run-time start-off
Examples:  cc -c file.c             # Compile file.c
           cc -DFOO file.c          # Treat the symbol FOO as defined
           cc -wo -o out file.c     # Compile old-style code; output  to
                                      out

     This is the C compiler.  It has eight passes, as follows:

   Program   Input   Output   Operation performed
   lib/ncpp  prog.c  prog.i   C preprocessor: #include, #define, #ifdef
   lib/irrel prog.i  prog.i   Removal of unnecessary prototypes
   lib/ncem  prog.i  prog.k   Parsing and semantic analysis
   lib/nopt  prog.k  prog.m   Optimization of the intermediate code
   lib/ncg   prog.m  prog.s   Code generation
   bin/as    prog.s  prog.o   Assembly
   lib/ld    prog.o  prog.out Linking
   lib/cv    prog.out a.out   Conversion to MINIX a.out format

In the 68000 versions of MINIX , the preprocessor is  not  called  since
the  front-end  contains  the  preprocessor.  This increases compilation
speed.

     The main program, cc,  forks  appropriately  to  call  the  passes,
transmitting  flags  and arguments.  The -v flag causes the passes to be
listed as they are called, and the -vn flag  causes  the  passes  to  be
listed but not called.





                                                                        



                                                                        


     The libraries should be made with aal (which is the same as  ar  on
the  68000  versions),  and  consist of .o files.  The internal order of
files inside the library is unimportant, but  the  order  in  which  the
libraries are specified is.

     When -T is used, the intermediate files end  up  in  the  directory
specified.   Otherwise,  /tmp  is  used.   When available memory is very
limited (e.g., a 512K machine), it may be  necessary  to  run  chmem  to
reduce the sizes of the compiler passes that do not fit, typically ncem.

     On the other hand,  if  the  compiler  (or,  in  fact,  almost  any
program)  begins  acting strange, it is almost always due to its running
out of space, either stack space or scratch file  space.   The  relevant
pass  can be given more stack space using chmem.  More space for scratch
files can be obtained by removing other files on the device.

     If the compiler runs out of memory, it may be necessary to use  the
-m  flag.   This  causes  irrel  to  be  run,  which removes unnecessary
prototypes and thus frees up extra  table  space  within  the  compiler.
Beware,  however,  that  running this pass may cause strictly conforming
programs to become non-conforming and vice versa, so you should only run
this pass as a last resort.

     The compiler is derived from the  ACK  system  (Tanenbaum  et  al.,
Communications  of  the  ACM,  Sept. 1983), not from the AT&T portable C
compiler.  It has  been  shoehorned  onto  the  PC  with  some  loss  of
performance.































                                                                        

