cpp(1) General Commands Manual cpp(1)
Name
cpp - the C language preprocessor
Syntax
/lib/cpp [ option ... ] [ ifile [ ofile ] ]
Description
The command is the C language preprocessor which is invoked as the first pass of any C compilation using the command. Thus, the output of
is designed to be in a form acceptable as input to the next pass of the C compiler.
The preferred way to invoke however, is through the command. See for a general macro processor.
Arguments
The command optionally accepts two file names as arguments. The ifile and ofile are, respectively, the input and output for the preproces-
sor. They default to standard input and standard output if no argument is supplied.
Options
-B Strips C++-style comments (begin with // and end with newline).
-C Passes along all comments, except those found on directive lines. By default, strips C-style comments.
-M Generates dependency lists suitable for use with instead of the normal output.
-P Preprocesses the input without producing the line control information used by the next pass of the C compiler.
-R Permits recursion when a macro is expanded.
-Uname Removes any initial definition of name, where name is a reserved symbol that is predefined by the preprocessor. The
symbols predefined by this implementation are bsd4_2, ultrix, unix, mips, host_mips, and MIPSEL.
-Dname
-Dname=def Defines name as if by a #define directive. If no =def is given, name is defined as 1. The -D option has lower prece-
dence than the -U option. That is, if the same name is used in both a -U option and a -D option, the name remains
undefined regardless of the order of the options.
-Idir Changes the algorithm for searching for #include files whose names do not begin with a slash ( / ) to look in dir
before looking in the directories on the standard list. Thus, #include files whose names are enclosed in quotes ( "" )
will be searched for first in the directory of the file with the #include line, then in directories named in -I
options, and, finally, in directories on a standard list. For #include files whose names are enclosed in angle brack-
ets (<>), the directory of the file with the #include line is not searched.
Directives
All directives start with lines that begin with a pound sign (#). Any number of blanks and tabs are allowed between the pound signs and
the directive. The following is a list of the directives:
#define name(arg, ...,arg ) token-string
Replaces subsequent instances of name and the following set of tokens that is enclosed in parentheses by token-string.
Each occurrence of an arg in the token-string is replaced by the corresponding set of tokens in the comma-separated
list. Note that spaces between name and the left parenthesis (() are not allowed. When a macro with arguments is
expanded, the arguments are placed unchanged into the expanded token-string . After the entire token-string has been
expanded, re-starts its scan for names to expand at the beginning of the newly created token-string.
#undef name Causes the definition of name (if any) to be forgotten.
#include "filename"
#include <filename> Includes the contents of filename , which will then be run through When the <filename> notation is used, filename is
searched for in the standard places. See the -I option above for more detail.
#line integer-constant "filename"
Causes to generate line control information for the next pass of the C compiler. Integer-constant is the line number
of the next line and filename is the file that it comes from. If "filename" is not given, the current file name is
unchanged.
#endif
Ends a section of lines begun by a test directive (#if, #ifdef, or #ifndef). Each test directive must have a matching
#endif.
#ifdef name Defines text that will appear in the output if name has been the subject of a previous #define without being the sub-
ject of an intervening #undef.
#ifndef name Defines text that will not appear in the output if name has been the subject of a previous #define without being the
subject of an intervening #undef.
#if constant-expression
Defines text that will appear in the output if constant-expression is not zero. All binary non-assignment C operators,
which include the ?: , en dash (-), exclamation mark (!), and tilde (~) are legal in constant-expression. The prece-
dence of the operators is the same as defined by the C language. There is also a unary operator defined, which can be
used in constant-expression in these two forms: defined ( name ) or defined name. This allows the utility of #ifdef
and #ifndef in a #if directive. Only these operators, integer constants, and names which are known by should be used
in constant-expression. In particular, the sizeof operator is not available.
#else Reverses the notion of the test directive which matches this directive. So if lines prior to this directive are
ignored, the following lines will appear in the output. The reverse is also true.
#elif constant-expression
Defines text that will appear in the output if the preceding test directive and all intervening #elif directives
equalled zero and the constant-expression did not equal zero. The rules for constant-expression are the same as for
the #if directive.
The test directives and the possible #else and #elif directives can be nested.
In addition to these directives, the System V #ident directive is recognized and ignored.
Two special names are understood by __LINE__ is defined as the current line number (as a decimal integer) and __FILE__ is defined as the
current file name (as a C string). They can be used in any situations where you would use other defined names, including in macros.
Diagnostics
The error messages produced by are self-explanatory. The line number and filename where the error occurred are printed along with the
diagnostic.
Files
/usr/include standard directory for #include files
See Also
cc(1), m4(1)
RISC cpp(1)