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)