The compilers handle 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= 0, 1, 2, 5, 6,
8, k, q, or v. The output object files end in .O. The letter is
also the prefix of related programs: Oa is the assembler, Ol is
the loader. 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:
–oobj Place output in file obj (allowed only if there is just one
input file). Default is to take the last element of the input
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 prototype.
By default, the compilers reject functions used without a defined
prototype, although ANSI C permits them.
–Dname=def
–DnameDefine the name to the preprocessor, as if by #define. If
no definition is given, the name is defined as 1.
–F Enable type–checking of calls to print(2) and other formatted
print routines. See the discussion of extensions, below.
–Idir An #include 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, the –. flag is given 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.
–

. Suppress the automatic searching for include files in the directory
of the file argument.
–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.
–T Pass type signatures on all external and global entities. The
signature is based on the C signof operator.
–V By default, the compilers are non–standardly lax about type equality
between void* values and other pointers; this flag requires ANSI
C conformance.
–p Invoke a standard ANSI C preprocessor before compiling.
–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.
–n When used with –a or –aa, places acid functions in file.acid for
input file.c, and not on standard output.

The compilers support several extensions to ANSI C:
– A structure or union may contain unnamed substructures and subunions.
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
variable>.<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–element
array a.
–

Structure initializers can specify the structure element by using
the name following a period, as

struct { int x; int y; } s = { .y 1, .x 5 };

which initializes elements y and then x of the structure s. These
forms also accept the new ANSI C notation, which includes an equal
sign:

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 /$objtype/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).
–

A #pragma of the form

#pragma varargck argpos error 2

tells the compiler that the second argument to error is a print–like
format string (see print(2)) that identifies the handling of subsequent
arguments. The #pragma

#pragma varargck type "s" char*

says that the format verb s processes an argument of type char*.
The #pragma

#pragma varargck flag 'c'

says that c is a flag character. These #pragmas are used, if the
–F option is enabled, to type–check calls to print and other such
routines.
–

where type is a typedef'd name for a structure or union type,
and tag is a structure or union tag, tells the compiler that the
corresponding type should have its signature calculated as an
incomplete type even if it is subsequently fully defined. This
allows the type signature mechanism to work in the presence of
opaque types declared in header files, with their full definitions
visible only to the code which manipulates them. With some imported
software it might be necessary to turn off the signature generation
completely for a large body of code (typically at the start and
end of a particular include file). If type is the word
_off_, signature generation is turned off; if type is the word
_on_, the compiler will generate signatures.
–

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. Arithmetic on vlong values
is usually emulated by a run–time library, though in at least 8c,
only division and modulus use the run–time library and the other
operators generate in–line code (and uvlong–

expression division–or–modulus

(1<<constant) will turn into in–line bit operations, as is done
for shorter unsigned expressions).

Other differences with ANSI C include
– The compilers use the original "unsigned preserving", rather than
ANSI C "value preserving" rules, which means that, e.g., unsigned
char gets promoted to unsigned int rather than int.
– Parameters in macros are substituted inside of strings.

EXAMPLE

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

2c –FVw 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.