|
» |
|
|
|
NAMEcpp — the C language preprocessor SYNOPSIS/usr/ccs/lbin/cpp
[option]... [ifile
[ofile]] DESCRIPTIONcpp
is the C language preprocessor which is invoked as the
first pass of any C compilation using the
cc
command (see
cc(1)).
Its purpose is to process
#include
and conditional compilation instructions and macros.
Thus the output of
cpp
is designed to be in a form acceptable as input
to the next pass of the C compiler.
As the C language evolves,
cpp
and the rest of the C compilation package will be
modified to follow these changes.
Therefore, the use of
cpp
in other than this framework is not suggested.
The preferred way to invoke
cpp
is through the
cc
command, since the functionality of
cpp
may someday be moved elsewhere.
See
m4(1)
for a general macro processor. cpp
optionally accepts two file names as arguments.
ifile
and
ofile
are respectively the input and output for the preprocessor.
They default to standard input and standard output if not specified. OptionsThe following options are recognized by
cpp:
- -A
Remove all predefined symbols that begin with a letter and
_HPUX_SOURCE.
The user is expected to define
_POSIX_SOURCE
or
_XOPEN_SOURCE
when using this option. - -C
By default,
cpp
strips C-style comments.
If the
-C
option is specified, all comments (except those found on
cpp
directive lines) are passed along. - -Dname
- -Dname=def
Define
name
as if by a
#define
directive.
If no
=def
is given,
name
is defined as
1.
The
-D
option has lower precedence than the
-U
option.
Thus, if the same name is used in both a
-U
option and a
-D
option, the name is undefined
regardless of the order of the options. - -Hnnn
Change the internal macro definition table to be
nnn
bytes in size.
The default buffer size is at least 8188 bytes.
This option serves to eliminate
"Macro param too large", "Macro invocation too large",
"Macro param too large after substitution",
"Quoted macro param too large", "Macro buffer too small",
"Input line too long", and "Catenated input line too long"
errors. - -h[inclfile]
Generates included files and sents the results to the file
inclfile.
If the argument
inclfile
is omitted, the result is sent to the standard error. - -Idir
Change the algorithm for searching for
#include
files whose names do not begin with
/
to look in
dir
before looking in the directories on the standard list.
Thus,
#include
files whose names are enclosed in double quotes
("")
are searched for first in the directory of the file containing the
#include
line, then in directories named in
-I
options in left-to-right order,
and last in directories on a standard list.
For
#include
files whose names are enclosed in angle brackets
(<>),
the directory of the file containing the
#include
line is not searched.
However, directory
dir
is still searched. - -M[makefile]
Generates makefile dependencies and sends the results to the file
makefile.
If the argument
makefile
is omitted, the result is sent to the standard error. - -P
Preprocess the input
without producing the line-control information
used by the next pass of the C compiler. - -T
HP-UX
no longer restricts preprocessor symbols to eight characters.
The
-T
option forces
cpp
to use only the first eight characters for distinguishing
different preprocessor names.
This behavior is the same as preprocessors on some other systems
with respect to the length of names,
and is included for backward compatibility. - -Uname
Remove any initial definition of
name,
where
name
is a reserved symbol that is predefined by the particular preprocessor.
The current list of these symbols includes:
- Operating system:
unix
__unix - Hardware:
hp9000s200
hp9000s300
__hp9000s300
hp9000s500
hp9000s800
__hp9000s800
hp9000ipc
hppa
__hppa
_PA_RISC1_0
_PA_RISC1_1
_SIO
_WSIO - UNIX systems variant:
hpux
__hpux
_HPUX_SOURCE
PWB
_PWB - lint(1):
lint
__lint
In addition, all symbols that begin with an underscore and either an
upper-case letter or another underscore are reserved.
Other symbols may be defined by the
CCOPTS
variable or other command-line options to the C compiler
at compile time (see
cc(1)).
All
HP-UX
systems have the symbols
PWB,
hpux,
unix,
_PWB,
__hpux,
and
__unix
defined.
Each system defines at least one hardware variant, as appropriate.
The lint symbols are defined when
lint(1)
is running.
See
DEPENDENCIES.
Two special names are understood by
cpp.
__LINE__
is defined as the current line number
(as a decimal integer) as counted by
cpp.
__FILE__
is defined as the current file name (as a C string) as known by
cpp.
They can be used anywhere (including in macros)
just as any other defined names. DirectivesAll
cpp
directives start with lines begun by
#.
Any number of blanks and tabs are allowed between the
#
and the directive.
The directives are:
- #define name token-string
Replace subsequent instances of
name
with
token-string.
token-string
can be null. - #define name(arg, ... , arg) token-string
Replace subsequent instances of
name
followed by a
(,
a list of comma-separated set of arguments, and a
)
by
token-string,
where each occurrence of an
arg
in the
token-string
is replaced by the corresponding set of tokens in the comma-separated list.
When a macro with arguments is expanded,
the arguments are placed into the expanded
token-string
unchanged.
After the entire
token-string
has been expanded,
cpp
restarts its scan for names to expand at the beginning of the newly created
token-string. Notice that there can be no space between
name
and the
(. - #endif [text]
Ends a section of lines begun by a test directive
(#if,
#ifdef,
or
#ifndef).
Each test directive must have a matching
#endif.
Any
text
occurring on the same line as the
#endif
is ignored and thus may be used to mark matching
#if-#endif
pairs.
This makes it easier, when reading the source, to match
#if,
#ifdef,
and
#ifndef
directives with their associated
#endif
directive. - #elif constant-expression
Equivalent to:
#else
#if constant-expression - #else
Reverses the notion of the test directive that matches this directive.
Thus, if lines previous to this directive are ignored,
the following lines appear in the output, and vice versa. - #if constant-expression
The lines following appear in the output if and only if the
constant-expression
evaluates to nonzero.
All binary nonassignment C operators, the
?:
operator, the unary
-,
!,
and
~
operators are all legal in
constant-expression.
The precedence 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 use of
#ifdef
and
#ifndef
in an
#if
directive. Only these operators, integer constants, and names that
are known by
cpp
should be used in
constant-expression.
In particular, the
sizeof
operator is not available. - #ifdef name
The lines following appear in the output if and only if
name
has been the subject of a previous
#define
without being the subject of an intervening
#undef. - #ifndef name
The lines following do not appear in the output if and only if
name
has been the subject of a previous
#define
without being the subject of an intervening
#undef. - #include "filename"
- #include <filename>
Include at this point the contents of
filename
(which are then run through
cpp).
See the
-I
option above for more detail. - #line integer-constant "filename"
Causes
cpp
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 where it comes from.
If
filename
and the quotation marks are omitted, the current file name is unchanged. - #undef name
Cause the definition of
name
(if any) to be forgotten from now on.
The test directives and the possible
#else
directives can be nested.
cpp
supports names up to 255 characters in length. NotesThe macro substitution scheme has been changed. Previous versions of
cpp
saved macros in a macro definition table whose table size is 128000
bytes by default.
The current version of
cpp
replaces this macro definition table with several small buffers.
The default size of the small buffers is 8188 bytes. EXTERNAL INFLUENCESEnvironment VariablesLC_CTYPE
determines the interpretation of comments and
string literals as single- or multibyte characters. LANG
determines the language in which messages are displayed. If
LC_CTYPE
is not specified in the environment or is set to
the empty string, the value of
LANG
is used as a default for each
unspecified or empty variable.
If
LANG
is not specified or is
set to the empty string, it defaults to "C" (see
lang(5)).
If any internationalization variable contains an invalid setting,
cpp
behaves as if all internationalization variables are set to "C".
See
environ(5). International Code Set SupportSingle- and multibyte character code sets are supported. DIAGNOSTICSError messages produced by
cpp
are intended to be self-explanatory.
The line number and filename where the error occurred
are printed along with the diagnostic. WARNINGSWhen newline characters were found in argument lists for macros
to be expanded, previous versions of
cpp
put out the newlines as they were found and expanded.
The current version of
cpp
replaces these newlines with blanks to alleviate problems that the
previous versions had when this occurred. DEPENDENCIESWorkstationThe symbols
hp9000s700
and
__hp9000s700
are not reserved symbols recognized by the
-U
option.
They are supplied to
cpp
either automatically by the compiler,
or by the use of a compiler option.
For example, on a Series 700 system, the command:
produces:
/usr/ccs/lbin/cpp t.c /var/tmp/ctmAAAa29220 -D__hp9000s700 -D__hp9000s800 ... (Also see the
-D
option of the
cc
command.) FILES- /usr/include
Standard directory for
#include
files
STANDARDS CONFORMANCEcpp: SVID2, SVID3, XPG2
|