man(1) Manual page archive

     CC(1)                        (PDP11)                        CC(1)

          cc, pcc - C compiler

          cc [ option ] ... file ...

          pcc [ option ] ... file ...

          Cc is the UNIX C compiler.  It accepts several types of

          Arguments whose names end with `.c' are taken to be C source
          programs; they are compiled, and each object program is left
          on the file whose name is that of the source with `.o' sub-
          stituted for `.c'.  The `.o' file is normally deleted, how-
          ever, if a single C program is compiled and loaded all at
          one go.

          In the same way, arguments whose names end with `.s' are
          taken to be assembly source programs and are assembled, pro-
          ducing a `.o' file.

          The following options are interpreted by cc. See ld(1) for
          load-time options.

          -c      Suppress the loading phase of the compilation, and
                  force an object file to be produced even if only one
                  program is compiled.

          -p      Arrange for the compiler to produce code which
                  counts the number of times each routine is called;
                  also, if loading takes place, replace the standard
                  startup routine by one which automatically calls
                  monitor(3) at the start and arranges to write out a
                  mon.out file at normal termination of execution of
                  the object program.  An execution profile can then
                  be generated by use of prof(1).

          -f      In systems without hardware floating-point, use a
                  version of the C compiler which handles floating-
                  point constants and loads the object program with
                  the floating-point interpreter.  Do not use if the
                  hardware is present.

          -O      Invoke an object-code optimizer.

          -S      Compile the named C programs, and leave the
                  assembler-language output on corresponding files
                  suffixed `.s'.

     CC(1)                        (PDP11)                        CC(1)

          -P      Run only the macro preprocessor and place the result
                  for each `.c' file in a corresponding `.i' file and
                  has no `#' lines in it.

          -E      Run only the macro preprocessor and send the result
                  to the standard output.  The output is intended for
                  compiler debugging; it is unacceptable as input to

          -o output
                  Name the final output file output. If this option is
                  used the file `a.out' will be left undisturbed.

          -Dname  Define the name to the preprocessor, as if by
                  `#define'.  If no definition is given, the name is
                  defined as 1.

          -Uname  Remove any initial definition of name.

          -Idir   `#include' files whose names do not begin with `/'
                  are always sought first in the directory of the file
                  argument, then in directories named in -I options,
                  then in directories on a standard list.

                  Find substitute compiler passes in the files named
                  string with the suffixes cpp, c0, c1 and c2.  If
                  string is empty, use a standard backup version.

                  Find only the designated compiler passes in the
                  files whose names are constructed by a -B option.
                  In the absence of a -B option, the string is taken
                  to be `/usr/c/'.

          Other arguments are taken to be either loader option argu-
          ments, or C-compatible object programs, typically produced
          by an earlier cc run, or perhaps libraries of C-compatible
          routines.  These programs, together with the results of any
          compilations specified, are loaded (in the order given) to
          produce an executable program with name a.out.

          The major purpose of the `portable C compiler', pcc, is to
          serve as a model on which to base other compilers.  Pcc does
          not support options -f, -E, -B, and -t.  It provides, in
          addition to the language of cc, unsigned char type data and
          initialized bit fields.

          file.c          input file
          file.o          object file

     CC(1)                        (PDP11)                        CC(1)

          a.out           loaded output
          /tmp/ctm?       temporaries for cc
          /lib/cpp        preprocessor
          /lib/c[01]      compiler for cc
          /usr/c/oc[012]  backup compiler for cc
          /usr/c/ocpp     backup preprocessor
          /lib/fc[01]     floating-point compiler
          /lib/c2         optional optimizer
          /lib/crt0.o     runtime startoff
          /lib/mcrt0.o    startoff for profiling
          /lib/fcrt0.o    startoff for floating-point interpretation
          /lib/libc.a     standard library, see intro(3)
          /usr/include    standard directory for `#include' files
          /tmp/pc*        temporaries for pcc
          /usr/lib/ccom   compiler for pcc

          B. W. Kernighan and D. M. Ritchie, The C Programming
          Language, Prentice-Hall, 1978
          D. M. Ritchie, C Reference Manual
          monitor(3), prof(1), adb(1), ld(1)

          The diagnostics produced by C itself are intended to be
          self-explanatory.  Occasional messages may be produced by
          the assembler or loader.  Of these, the most mystifying are
          from the assembler, as(1), in particular `m', which means a
          multiply-defined external symbol (function or data).

          Pcc is little tried on the PDP11; specialized code generated
          for that machine has not been well shaken down.  The -O
          optimizer was designed to work with cc; its use with pcc is