cpp - The C Preprocessor
SYNOPSIS
cpp [-P] [-C] [-gcc] [-traditional]
[-undef] [-trigraphs] [-pedantic]
[-Wwarn...] [-Idir...]
[-Dmacro[=defn]...] [-Umacro]
[-Apredicate(answer)]
[-M|-MM][-MG][-MFfilename]
[-MP][-MQtarget...][-MTtarget...]
[-x language] [-std=standard]
infile outfile
Only the most useful options are listed here; see below
for the remainder.
DESCRIPTION
The C preprocessor is a macro processor that is used auto
matically by the C compiler to transform your program
before actual compilation. It is called a macro processor
because it allows you to define macros, which are brief
abbreviations for longer constructs.
The C preprocessor is intended only for macro processing
of C, C++ and Objective C source files. For macro pro
cessing of other files, you are strongly encouraged to use
alternatives like M4, which will likely give you better
results and avoid many problems. For example, normally
the C preprocessor does not preserve arbitrary whitespace
verbatim, but instead replaces each sequence with a single
space.
For use on C-like source files, the C preprocessor pro
vides four separate facilities that you can use as you see
fit:
· Inclusion of header files. These are files of decla
rations that can be substituted into your program.
· Macro expansion. You can define macros, which are
abbreviations for arbitrary fragments of C code, and
then the C preprocessor will replace the macros with
their definitions throughout the program.
· Conditional compilation. Using special preprocessing
directives, you can include or exclude parts of the
program according to various conditions.
· Line control. If you use a program to combine or
rearrange source files into an intermediate file which
is then compiled, you can use line control to inform
the compiler of where each source line originally came
from.
cusses the GNU C preprocessor, which provides a small
superset of the features of ISO Standard C.
In its default mode, the GNU C preprocessor does not do a
few things required by the standard. These are features
which are rarely, if ever, used, and may cause surprising
changes to the meaning of a program which does not expect
them. To get strict ISO Standard C, you should use the
-std=c89 or -std=c99 options, depending on which version
of the standard you want. To get all the mandatory diag
nostics, you must also use -pedantic.
OPTIONS
The C preprocessor expects two file names as arguments,
infile and outfile. The preprocessor reads infile
together with any other files it specifies with #include.
All the output generated by the combined input files is
written in outfile.
Either infile or outfile may be -, which as infile means
to read from standard input and as outfile means to write
to standard output. Also, if either file is omitted, it
means the same as if - had been specified for that file.
Here is a table of command options accepted by the C pre
processor. These options can also be given when compiling
a C program; they are passed along automatically to the
preprocessor when it is invoked by the compiler.
-P Inhibit generation of #-lines with line-number infor
mation in the output from the preprocessor. This
might be useful when running the preprocessor on some
thing that is not C code and will be sent to a program
which might be confused by the #-lines.
-C Do not discard comments. All comments are passed
through to the output file, except for comments in
processed directives, which are deleted along with the
directive. Comments appearing in the expansion list
of a macro will be preserved, and appear in place
wherever the macro is invoked.
You should be prepared for side effects when using -C;
it causes the preprocessor to treat comments as tokens
in their own right. For example, macro redefinitions
that were trivial when comments were replaced by a
single space might become significant when comments
are retained. Also, comments appearing at the start
of what would be a directive line have the effect of
turning that line into an ordinary source line, since
the first token on the line is no longer a #.
Try to imitate the behavior of old-fashioned C, as
opposed to ISO C.
· Traditional macro expansion pays no attention to
single-quote or double-quote characters; macro
argument symbols are replaced by the argument val
ues even when they appear within apparent string
or character constants.
· Traditionally, it is permissible for a macro
expansion to end in the middle of a string or
character constant. The constant continues into
the text surrounding the macro call.
· However, traditionally the end of the line termi
nates a string or character constant, with no
error.
· In traditional C, a comment is equivalent to no
text at all. (In ISO C, a comment counts as
whitespace.)
· Traditional C does not have the concept of a
``preprocessing number''. It considers 1.0e+4 to
be three tokens: 1.0e, +, and 4.
· A macro is not suppressed within its own defini
tion, in traditional C. Thus, any macro that is
used recursively inevitably causes an error.
· The character # has no special meaning within a
macro definition in traditional C.
· In traditional C, the text at the end of a macro
expansion can run together with the text after the
macro call, to produce a single token. (This is
impossible in ISO C.)
· None of the GNU extensions to the preprocessor are
available in -traditional mode.
Use the -traditional option when preprocessing Fortran
code, so that single-quotes and double-quotes within
Fortran comment lines (which are generally not recog
nized as such by the preprocessor) do not cause diag
nostics about unterminated character or string con
stants.
However, this option does not prevent diagnostics
about unterminated comments when a C-style comment
appears to start, but not end, within Fortran-style
commentary.
with -traditional:
C This isn't an unterminated character constant
C Neither is "20000000000, an octal constant
C in some dialects of Fortran
However, this type of comment line will likely produce
a diagnostic, or at least unexpected output from the
preprocessor, due to the unterminated comment:
C Some Fortran compilers accept /* as starting
C an inline comment.
Note that "g77" automatically supplies the -tradi
tional option when it invokes the preprocessor. How
ever, a future version of "g77" might use a different,
more-Fortran-aware preprocessor in place of "cpp".
-trigraphs
Process ISO standard trigraph sequences. These are
three-character sequences, all starting with ??, that
are defined by ISO C to stand for single characters.
For example, ??/ stands for \, so '??/n' is a charac
ter constant for a newline. By default, GCC ignores
trigraphs, but in standard-conforming modes it con
verts them. See the -std option.
The nine trigraph sequences are
??( -> [
??) -> ]
??< -> {
??> -> }
??= -> #
??/ -> \
??' -> ^
??! -> |
??- -> ~
Trigraph support is not popular, so many compilers do
not implement it properly. Portable code should not
rely on trigraphs being either converted or ignored.
-pedantic
Issue warnings required by the ISO C standard in
follows #else or #endif.
-pedantic-errors
Like -pedantic, except that errors are produced rather
than warnings.
-Wcomment
-Wcomments
(Both forms have the same effect). Warn whenever a
comment-start sequence /* appears in a /* comment, or
whenever a backslash-newline appears in a // comment.
-Wtrigraphs
Warn if any trigraphs are encountered. This option
used to take effect only if -trigraphs was also speci
fied, but now works independently. Warnings are not
given for trigraphs within comments, as we feel this
is obnoxious.
-Wwhite-space
Warn about possible white space confusion, e.g. white
space between a backslash and a newline.
-Wall
Requests -Wcomment, -Wtrigraphs, and -Wwhite-space
(but not -Wtraditional or -Wundef).
-Wtraditional
Warn about certain constructs that behave differently
in traditional and ISO C.
-Wundef
Warn if an undefined identifier is evaluated in an #if
directive.
-I directory
Add the directory directory to the head of the list of
directories to be searched for header files. This can
be used to override a system header file, substituting
your own version, since these directories are searched
before the system header file directories. If you use
more than one -I option, the directories are scanned
in left-to-right order; the standard system directo
ries come after.
-I- Any directories specified with -I options before the
-I- option are searched only for the case of #include
"file"; they are not searched for #include <file>.
If additional directories are specified with -I
options after the -I-, these directories are searched
for all #include directives.
current directory as the first search directory for
#include "file". Therefore, the current directory is
searched only if it is requested explicitly with -I..
Specifying both -I- and -I. allows you to control
precisely which directories are searched before the
current one and which are searched after.
-nostdinc
Do not search the standard system directories for
header files. Only the directories you have specified
with -I options (and the current directory, if appro
priate) are searched.
By using both -nostdinc and -I-, you can limit the
include-file search path to only those directories you
specify explicitly.
-nostdinc++
Do not search for header files in the C++-specific
standard directories, but do still search the other
standard directories. (This option is used when
building the C++ library.)
-remap
When searching for a header file in a directory, remap
file names if a file named header.gcc exists in that
directory. This can be used to work around limita
tions of file systems with file name restrictions.
The header.gcc file should contain a series of lines
with two tokens on each line: the first token is the
name to map, and the second token is the actual name
to use.
-D name
Predefine name as a macro, with definition 1.
-D name=definition
Predefine name as a macro, with definition definition.
There are no restrictions on the contents of defini
tion, but if you are invoking the preprocessor from a
shell or shell-like program you may need to use the
shell's quoting syntax to protect characters such as
spaces that have a meaning in the shell syntax. If
you use more than one -D for the same name, the right
most definition takes effect.
Any -D and -U options on the command line are pro
cessed in order, and always before -imacros file,
regardless of the order in which they are written.
-U name
Do not predefine name.
cessed in order, and always before -imacros file,
regardless of the order in which they are written.
-undef
Do not predefine any nonstandard macros.
-gcc
Define the macros __GNUC__, __GNUC_MINOR__ and
__GNUC_PATCHLEVEL__. These are defined automatically
when you use gcc -E; you can turn them off in that
case with -no-gcc.
-A predicate=answer
Make an assertion with the predicate predicate and
answer answer. This form is preferred to the older
form -A predicate(answer), which is still supported,
because it does not use shell special characters.
-A -predicate=answer
Disable an assertion with the predicate predicate and
answer answer. Specifying no predicate, by -A- or -A
-, disables all predefined assertions and all asser
tions preceding it on the command line; and also unde
fines all predefined macros and all macros preceding
it on the command line.
-dM Instead of outputting the result of preprocessing,
output a list of #define directives for all the macros
defined during the execution of the preprocessor,
including predefined macros. This gives you a way of
finding out what is predefined in your version of the
preprocessor; assuming you have no file foo.h, the
command
touch foo.h; cpp -dM foo.h
will show the values of any predefined macros.
-dD Like -dM except in two respects: it does not include
the predefined macros, and it outputs both the #define
directives and the result of preprocessing. Both
kinds of output go to the standard output file.
-dN Like -dD, but emit only the macro names, not their
expansions.
-dI Output #include directives in addition to the result
of preprocessing.
-M Instead of outputting the result of preprocessing,
output a rule suitable for "make" describing the
dependencies of the main source file. The preproces
sor outputs one "make" rule containing the object file
all the included files, including those coming from
-include or -imacros command line options. If there
are many included files then the rule is split into
several lines using \-newline.
-MM Like -M, but mention only the files included with
#include "file" or with -include or -imacros command
line options. System header files included with
#include <file> are omitted.
-MF file
When used with -M or -MM, specifies a file to write
the dependencies to. This allows the preprocessor to
write the preprocessed file to stdout normally. If no
-MF switch is given, CPP sends the rules to stdout and
suppresses normal preprocessed output.
-MG When used with -M or -MM, -MG says to treat missing
header files as generated files and assume they live
in the same directory as the source file. It sup
presses preprocessed output, as a missing header file
is ordinarily an error.
This feature is used in automatic updating of make
files.
-MP This option instructs CPP to add a phony target for
each dependency other than the main file, causing each
to depend on nothing. These dummy rules work around
errors "make" gives if you remove header files without
updating the "Makefile" to match.
This is typical output:-
/tmp/test.o: /tmp/test.c /tmp/test.h
/tmp/test.h:
-MQ target
-MT target
By default CPP uses the main file name, including any
path, and appends the object suffix, normally ``.o'',
to it to obtain the name of the target for dependency
generation. With -MT you can specify a target your
self, overriding the default one.
If you want multiple targets, you can specify them as
a single argument to -MT, or use multiple -MT options.
The targets you specify are output in the order they
appear on the command line. -MQ is identical to -MT,
except that the target name is quoted for Make, but
gives
$(objpfx)foo.o: /tmp/foo.c
but -MQ '$(objpfx)foo.o' gives
$$(objpfx)foo.o: /tmp/foo.c
The default target is automatically quoted, as if it
were given with -MQ.
-H Print the name of each header file used, in addition
to other normal activities.
-imacros file
Process file as input, discarding the resulting out
put, before processing the regular input file.
Because the output generated from file is discarded,
the only effect of -imacros file is to make the macros
defined in file available for use in the main input.
-include file
Process file as input, and include all the resulting
output, before processing the regular input file.
-idirafter dir
Add the directory dir to the second include path. The
directories on the second include path are searched
when a header file is not found in any of the directo
ries in the main include path (the one that -I adds
to).
-iprefix prefix
Specify prefix as the prefix for subsequent -iwithpre
fix options. If the prefix represents a directory,
you should include the final /.
-iwithprefix dir
Add a directory to the second include path. The
directory's name is made by concatenating prefix and
dir, where prefix was specified previously with
-iprefix.
-isystem dir
Add a directory to the beginning of the second include
path, marking it as a system directory, so that it
gets the same special treatment as is applied to the
standard system directories.
-x c
-x c++
-x assembler-with-cpp
Specify the source language: C, C++, Objective-C, or
assembly. This has nothing to do with standards con
formance or extensions; it merely selects which base
syntax to expect. If you give none of these options,
cpp will deduce the language from the extension of the
source file: .c, .cc, .m, or .S. Some other common
extensions for C++ and assembly are also recognized.
If cpp does not recognize the extension, it will treat
the file as C; this is the most generic mode.
Note: Previous versions of cpp accepted a -lang option
which selected both the language and the standards
conformance level. This option has been removed,
because it conflicts with the -l option.
-std=standard
-ansi
Specify the standard to which the code should conform.
Currently cpp only knows about the standards for C;
other language standards will be added in the future.
standard may be one of:
"iso9899:1990"
"c89"
The ISO C standard from 1990. c89 is the custom
ary shorthand for this version of the standard.
The -ansi option is equivalent to -std=c89.
"iso9899:199409"
The 1990 C standard, as amended in 1994.
"iso9899:1999"
"c99"
"iso9899:199x"
"c9x"
The revised ISO C standard, published in December
1999. Before publication, this was known as C9X.
"gnu89"
The 1990 C standard plus GNU extensions. This is
the default.
"gnu99"
"gnu9x"
The 1999 C standard plus GNU extensions.
-ftabstop=NUMBER
Set the distance between tab stops. This helps the
preprocessor report correct column numbers in warnings
or errors, even if tabs appear on the line. Values
default is 8.
-$ Forbid the use of $ in identifiers. The C standard
allows implementations to define extra characters that
can appear in identifiers. By default the GNU C pre
processor permits $, a common extension.
SEE ALSO
gcc(1), as(1), ld(1), and the Info entries for cpp, gcc,
and binutils.
COPYRIGHT
Copyright (c) 1987, 1989, 1991, 1992, 1993, 1994, 1995,
1996, 1997, 1998, 1999, 2000, 2001 Free Software Founda
tion, Inc.
Permission is granted to make and distribute verbatim
copies of this manual provided the copyright notice and
this permission notice are preserved on all copies.
Permission is granted to copy and distribute modified ver
sions of this manual under the conditions for verbatim
copying, provided also that the entire resulting derived
work is distributed under the terms of a permission notice
identical to this one.
Permission is granted to copy and distribute translations
of this manual into another language, under the above con
ditions for modified versions.
Man(1) output converted with
man2html