# cc(1)

## NAME

         cc - C compiler

## SYNOPSIS

         cc [-STOUfcimos] [-w[aos]]  [-v[n]]  [-Dname]*  [-Idir]*  [-Ldir]*  file+
         [-lname]*

## OPTIONS

         -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) ( only)

         -l   The flag -lname causes the library libname.a to be linked

         -m   Remove unnecessary prototypes after preprocessing ( 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

## DESCRIPTION

         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.

## SEE ALSO

         make(1).