acpp(5)
acpp - the ANSI C language preprocessor
As shipped in IRIX 6.5. First release of IRIX 6.5.
NAME acpp - the ANSI C language preprocessor DESCRIPTION The ANSI C language preprocessor, acpp, is invoked as the first pass of any ANSI C compilation when the cc(1) command is issued with the -acpp or -oldcpp option. Thus, acpp's output is designed to be in a form acceptable as input to the next pass of the C compiler. The use of the acpp command is not recommended, since the functionality of acpp has been moved into the C front-end and acpp may not be supported in future releases. See m4(1) for a general macro processor. This preprocessor is a version of GNU cpp. To see which version, use acpp -v. The source code to the preprocessor is distributed in 4Dgifts. This is intended only as a general statement of the preprocessor's capabilities. For a more precise statement, see the C language standard (reference cited at the end of this manual page). The following options are recognized directly by acpp: -P Preprocess the input without producing the line control information used by the next pass of the C compiler. The compiler driver, cc defines appropriate symbols. -Dname -Dname=def Define name with value def as if by a #define. If no =def is given, name is defined with value 1. The -D option has lower precedence than the -U option. That is, if the same name is used in both a -U options and a -D option, the name will be undefined regardless of the order of the options. -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 "" will be searched for first in the directory of the file with the #include line, then in the directories named in -I options, and last in directories on a standard list. For #include files whose names are enclosed in <>, the directory of the file with the #include line is not searched. If -I is given with no dir, acpp is instructed to suppress the search of the standard list of include directories (this form is obsolete, use -nostdinc instead)). This standard list consists only of /usr/include. -Uname undefines name, which is only useful if name is defined via -D or is a predefined name. The order of the -D and -U options is not significant: the undefines are done after all the -D's and predefines are applied. -pedantic All ANSI constraints are obeyed when this is supplied. Howver, only one #else, or #endif with extra tokens after the name is reported per included file to reduce the number of error reports on older header files. -traditional Allows dollar($) in identifiers and makes acpp behave like a traditional C preprocessor as defined in The C Reference Manual. -M The names of directly included files are printed on standard output. -C Comments are retained in the output of acpp. -nostdinc The standard places are not searched for include files. Use -I to specify directories to search. Ordinarily, only options mentioned on the cc(1) man page are of interest. However acpp has the following options not recognized by cc which can be applied with the cc flag prefix -Wp,. For example, to apply the acpp-only option -Wall, use cc -Wp,-Wall. -p All ANSI C constraints are obeyed. If supplied twice, #ident preprocessing directives produce a warning. Any option starting with -p is considered to mean -pedantic (see above). -o out_fname The output is written to out_fname instead of stdout. -traditional Allows dollar($) in identifiers and makes acpp behave like a traditional C preprocessor as defined in Kernighan & Ritchie, First Edition. -trigraphs Turns on processing of trigraphs. -B Means there is a different, longer, list of default directories to search. And C++ // is understood as a introducing a comment. -+ Means there is a different, longer, list of default directories to search. And C++ // is understood as a introducing a comment. -Wtrigraphs Warns if any trigraphs are encountered in the text. -Wcomments Warns if a comment start is found within a comment. -Wcomment Warns if a comment start is found within a comment. -Wall is the same as having both -Wtrigraphs and -Wcomments. -M The names of directly included files are printed on standard output. -MM The names of included files at all nesting levels are printed on standard output. -d Instead of writing the preprocessed file out, write the names and values of all preprocessor macros defined. -v prints the GNU CPP version number. -C Comments are retained in the output of acpp. -$ Dollar signs are allowed in identifiers. -nosplice Turn backslash newline into newline when outputting defines, but don't consider them to end the macro definition. -nostdinc The standard places are not searched for include files. Use -I to specify directories to search. -u Inhibits predefinition of values. If not supplied, the names mips and unix are predefined. cc -ansi passes -u to acpp. -w Turns off warning messages. -showdefines Show each #define (#undef) followed by the line number and file name where it is appears. The first few defines shown are the predefines built-in to cpp and passed on the command line (for these the line number and file name are meaningless). This facility is to assist you in the special situation where you have a #define (#undef) and you are having difficulty determining which source file the it is in. Use any standard text tool to inspect the result file. Example: cc -ansi -E -Imyincludedir -Wp,-showdefines myfile.c >myresult - As a file name, - is treated as a file name (stdin or stdout). Some special names are understood by acpp. The name __LINE__ is defined as the current line number (as a decimal integer) as known by acpp, and __FILE__ is defined as the current file name (as a C string) as known by acpp. The name __DATE__ is defined as the date of translation of the source file (a character string literal of the form the names of the months are the same as those generated by the asctime(3) function, and the first character of dd is a space character if the value is less than 10). The name __TIME__ is defined as the time of translation of the source file (a character string literal of the form generated by the asctime(3) function). They can be used anywhere (including in macros) just as any other defined name. To distinguish itself from cpp(1), acpp defines the macro __ANSI_CPP__, setting its value to one. All acpp directive lines start with any number of blanks and tabs followed 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. #define name( arg, ..., arg ) token-string Notice that there can be no space between name and the (. Replace subsequent instances of name followed by a (, a list of comma- separated sets of tokens, and a ) followed 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, acpp re-starts its scan for names to expand at the beginning of the newly created token-string. The # preprocessing token turns the immediately following argument in token-string into a string literal (i.e., enclosed in double quotes) which contains the spelling of the argument (see the example below). The ## preprocessing token causes the preceeding preprocessing token to be concatenated with the following preprocessing token into a single preprocessing token available for further replacement. Either or both of the preprocessing tokens may be substituted macro arguments. As an example of the # and ## operators, the sequence #define quote(arg) # arg #define glue_to_b(a) a ## b quote(foo) glue_to_b(b_follows_me) creates the output "foo" b_follows_meb #undef name Cause the definition of name (if any) to be forgotten from now on. No additional tokens are permitted on the directive line after name. #ident "string" The string and the directive are silently swallowed. No output is produced for this directive. #pragma The directive and whatever follows it on the line is passed to the output in a slightly modified form which is not documented. The form may change in a future release. #pragma once If this directive appears in an included file, the file will never be included again, even if there is another #include of this file. No tokens or comments are permitted after the ``once'' keyword. Using #pragma once is more efficient than using macro wrappers, because the included file is not rescanned, but it may not be portable to third-party preprocessors. #include "filename" #include <filename> Include at this point the contents of filename (which will then be run through acpp). When the <filename> notation is used, filename is only searched for in the standard places. See the -I option above for more detail. No additional tokens are permitted on the directive line after the final " or >. #line integer-constant filename Causes acpp 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 from which it comes. If "filename" is not given, the current file name is unchanged. No additional tokens are premitted on the directive line after the optional filename. #endif Ends a section of lines begun by a test directive (#if, #ifdef, or #ifndef). Each test directive must have a matching #endif. No additional tokens are permitted on the directive line. To reduce the volume of error reports on older header files, acpp reports only one instance of additional tokens per included file. #ifdef name The lines following will 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. No additional tokens are permitted on the directive line after name. #ifndef name The lines following will appear in the output if and only if name has not been the subject of a previous #define. No additional tokens are permitted on the directive line after name. #if constant-expression Lines following will appear in the output if and only if the constant-expression evaluates to non-zero. All binary non- assignment 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 utility of #ifdef and #ifndef in a #if directive. Only these operators, integer constants, and names which are known by acpp should be used in constant-expression. In particular, the sizeof operator is not available. To test whether either of two symbols, foo and fum, are defined, use: #if defined(foo) || defined(fum) #elif constant-expression This is equivalent to a #else with a #if expression, and is often more convenient than a nested #else #if constant-expression #endif #endif. #else The lines following will appear in the output if and only if the preceding test directive evaluates to zero. No additional tokens are permitted on the directive line. To reduce the volume of error reports on older header files, acpp reports only one instance of additional tokens per included file. The test directives and the possible #else directives can be nested. #error preprocessing-tokens The preprocessing tokens are emitted and an error is signaled to cc. #ident This System V directive is silently accepted and ignored unless -pedantic is supplied twice, in which case a warning is issued for each #ident encountered. #sccs This is a BSD-only directive. Use of it is an error. FILES standard directory list for #include files, /usr/include NOTES Two often-used capabilities of the older C preprocessor cpp(1) have a different syntax in acpp(5). These are enclosing a macro argument in double-quotes, and concatenating tokens. See the discussion of #define for the new syntax. SEE ALSO cc(1), line(1), m4(1), cpp(1) American National Standard for Information Systems - Programming Language - C, ANSI X3.159-1989.