glenda.party
term% ls -F
term% pwd
$home/manuals/plan9_2nd/1/2c
term% cat index.txt
2C(1)                       General Commands Manual                      2C(1)

NAME
       2c, 6c, 8c, kc, vc, xc - C compilers

SYNOPSIS
       2c [ option ...  ] [ file ...  ]
       6c [ option ...  ] [ file ...  ]
       8c [ option ...  ] [ file ...  ]
       kc [ option ...  ] [ file ...  ]
       vc [ option ...  ] [ file ...  ]
       xc [ option ...  ] [ file ...  ]

DESCRIPTION
       2c,  6c,  8c,  kc,  vc,  and xc compile the named C files into MC68020,
       i960, i386, SPARC, MIPS, and ATT3210 object files.  The compilers  han‐
       dle  most  preprocessing directives themselves; a complete preprocessor
       is available in cpp(1), which must be run separately.

       Let the first letter of the compiler name be O= 2, 6, 8, k,  v,  or  x.
       The  output  object  files end in .O.  The letter is also the prefix of
       related programs: Oa is the assembler, Ol is  the  loader.   Associated
       with  each  compiler is a string objtype= 68020, 960, 386, sparc, mips,
       or 3210.  Plan 9 conventionally sets the $objtype environment  variable
       to  the objtype string appropriate to the current machine's type.  Plan
       9 also conventionally has /objtype  directories,  which  contain  among
       other  things:  include,  for machine-dependent include files; lib, for
       public object code libraries; bin, for public programs; and mkfile, for
       preconditioning mk(1).

       The compiler options are:

       -o obj    Place output in file obj (allowed only if there is  just  one
                 input  file).  Default is to take the last element of the in‐
                 put file name, strip any trailing .c, and append .O.

       -w        Print warning messages about unused variables, etc.

       -B        Accept functions without a new-style ANSI C  function  proto‐
                 type.   By default, the compilers reject functions used with‐
                 out a defined prototype, although ANSI C permits them.

       -Dname=def
       -Dname    Define the name to the preprocessor, as if by If  no  defini‐
                 tion is given, the name is defined as

       -Idir     An  file  whose name does not begin with slash or is enclosed
                 in double quotes is always sought first in the  directory  of
                 the file argument.  If this fails, or the name is enclosed in
                 <>,  it  is  then  sought in directories named in -I options,
                 then in /sys/include, and finally in /$objtype/include.

       -N        Suppress automatic registerization and optimization.

       -S        Print an assembly language version  of  the  object  code  on
                 standard output as well as generating the .O file.

       -a        Instead of compiling, print on standard output acid functions
                 (see acid(1)) for examining structures declared in the source
                 files.

       -aa       Like -a except suppress information about structures declared
                 in included header files.

       The compilers support several extensions to ANSI C:

       -      A  structure or union may contain unnamed substructures and sub‐
              unions.  The fields of the substructures or subunions  can  then
              be used as if they were members of the parent structure or union
              (the  resolution  of  a  name  conflict is unspecified).  When a
              pointer to the outer structure or union is  used  in  a  context
              that  is  only  legal for the unnamed substructure, the compiler
              promotes the type and adjusts the pointer value to point at  the
              substructure.   If  the  unnamed structure or union is of a type
              with a tag name specified by a typedef  statement,  the  unnamed
              structure or union can be explicitly referenced by <struct vari‐
              able>.<tagname>.

       -      A structure value can be formed with an expression such as
                  (struct S){v1, v2, v3}
              where the list elements are values for the fields of struct S.

       -      Array  initializers  can  specify  the  indices  of the array in
              square brackets, as
                  int a[] = { [3] 1, [10] 5 };
              which initializes the third and tenth elements of the eleven-el‐
              ement array a.

       -      Structure initializers can specify the structure element by  us‐
              ing the name following a period, as
                  int struct { int x; int y; } s = { .y 1, .x 5 };
              which initializes elements y and then x of the structure s.

       -      A global variable can be dedicated to a register by declaring it
              extern register in all modules and libraries.

       -      A #pragma of the form
                  #pragma lib "libbio.a"
              records  that  the  program  needs to be loaded with file /$obj‐
              type/lib/libbio.a;  such  lines,  typically  placed  in  library
              header  files,  obviate  the  -l option of the loaders.  To help
              identify files in  non-standard  directories,  within  the  file
              names  in  the #pragmas the string $M represents the name of the
              architecture (e.g., mips)  and  $O  represents  its  identifying
              character (e.g., v).

       -      The  C++  comment (// to end of line) is accepted as well as the
              normal convention of /* */.

       -      The compilers accept long long variables as a 64-bit type.   The
              standard  header  typedefs  this to vlong.  The vlong runtime is
              slow.

EXAMPLE
       For the 68020, produce a program prog from C files main.c and sub.c:

              2c -w main.c sub.c
              2l -o prog main.2 sub.2

FILES
       /sys/include
              system area for machine-independent #include directives.

       /$objtype/include
              system area for machine-dependent #include directives.

SOURCE
       /sys/src/cmd/cc
              machine-independent part

       /sys/src/cmd/2c, etc.
              machine-dependent part

SEE ALSO
       2a(1), 2l(1), cpp(1), mk(1), nm(1), pcc(1), db(1), acid(1),

       Rob Pike, ‘‘How to Use the Plan 9 C Compiler''

BUGS
       The i960 compiler has been used only to program one I/O controller  and
       is certainly buggy.

       The  preprocessor  only  handles  and For a full ANSI preprocessor, use
       cpp(1) on the files first.

                                                                         2C(1)