1CPP(1)                                GNU                               CPP(1)
2
3
4

NAME

6       cpp - The C Preprocessor
7

SYNOPSIS

9       cpp [-Dmacro[=defn]...] [-Umacro]
10           [-Idir...] [-iquotedir...]
11           [-Wwarn...]
12           [-M|-MM] [-MG] [-MF filename]
13           [-MP] [-MQ target...]
14           [-MT target...]
15           [-P] [-fno-working-directory]
16           [-x language] [-std=standard]
17           infile outfile
18
19       Only the most useful options are listed here; see below for the
20       remainder.
21

DESCRIPTION

23       The C preprocessor, often known as cpp, is a macro processor that is
24       used automatically by the C compiler to transform your program before
25       compilation.  It is called a macro processor because it allows you to
26       define macros, which are brief abbreviations for longer constructs.
27
28       The C preprocessor is intended to be used only with C, C++, and
29       Objective-C source code.  In the past, it has been abused as a general
30       text processor.  It will choke on input which does not obey C's lexical
31       rules.  For example, apostrophes will be interpreted as the beginning
32       of character constants, and cause errors.  Also, you cannot rely on it
33       preserving characteristics of the input which are not significant to
34       C-family languages.  If a Makefile is preprocessed, all the hard tabs
35       will be removed, and the Makefile will not work.
36
37       Having said that, you can often get away with using cpp on things which
38       are not C.  Other Algol-ish programming languages are often safe
39       (Pascal, Ada, etc.) So is assembly, with caution.  -traditional-cpp
40       mode preserves more white space, and is otherwise more permissive.
41       Many of the problems can be avoided by writing C or C++ style comments
42       instead of native language comments, and keeping macros simple.
43
44       Wherever possible, you should use a preprocessor geared to the language
45       you are writing in.  Modern versions of the GNU assembler have macro
46       facilities.  Most high level programming languages have their own
47       conditional compilation and inclusion mechanism.  If all else fails,
48       try a true general text processor, such as GNU M4.
49
50       C preprocessors vary in some details.  This manual discusses the GNU C
51       preprocessor, which provides a small superset of the features of ISO
52       Standard C.  In its default mode, the GNU C preprocessor does not do a
53       few things required by the standard.  These are features which are
54       rarely, if ever, used, and may cause surprising changes to the meaning
55       of a program which does not expect them.  To get strict ISO Standard C,
56       you should use the -std=c90, -std=c99 or -std=c11 options, depending on
57       which version of the standard you want.  To get all the mandatory
58       diagnostics, you must also use -pedantic.
59
60       This manual describes the behavior of the ISO preprocessor.  To
61       minimize gratuitous differences, where the ISO preprocessor's behavior
62       does not conflict with traditional semantics, the traditional
63       preprocessor should behave the same way.  The various differences that
64       do exist are detailed in the section Traditional Mode.
65
66       For clarity, unless noted otherwise, references to CPP in this manual
67       refer to GNU CPP.
68

OPTIONS

70       The C preprocessor expects two file names as arguments, infile and
71       outfile.  The preprocessor reads infile together with any other files
72       it specifies with #include.  All the output generated by the combined
73       input files is written in outfile.
74
75       Either infile or outfile may be -, which as infile means to read from
76       standard input and as outfile means to write to standard output.  Also,
77       if either file is omitted, it means the same as if - had been specified
78       for that file.
79
80       Unless otherwise noted, or the option ends in =, all options which take
81       an argument may have that argument appear either immediately after the
82       option, or with a space between option and argument: -Ifoo and -I foo
83       have the same effect.
84
85       Many options have multi-letter names; therefore multiple single-letter
86       options may not be grouped: -dM is very different from -d -M.
87
88       -D name
89           Predefine name as a macro, with definition 1.
90
91       -D name=definition
92           The contents of definition are tokenized and processed as if they
93           appeared during translation phase three in a #define directive.  In
94           particular, the definition will be truncated by embedded newline
95           characters.
96
97           If you are invoking the preprocessor from a shell or shell-like
98           program you may need to use the shell's quoting syntax to protect
99           characters such as spaces that have a meaning in the shell syntax.
100
101           If you wish to define a function-like macro on the command line,
102           write its argument list with surrounding parentheses before the
103           equals sign (if any).  Parentheses are meaningful to most shells,
104           so you will need to quote the option.  With sh and csh,
105           -D'name(args...)=definition' works.
106
107           -D and -U options are processed in the order they are given on the
108           command line.  All -imacros file and -include file options are
109           processed after all -D and -U options.
110
111       -U name
112           Cancel any previous definition of name, either built in or provided
113           with a -D option.
114
115       -undef
116           Do not predefine any system-specific or GCC-specific macros.  The
117           standard predefined macros remain defined.
118
119       -I dir
120           Add the directory dir to the list of directories to be searched for
121           header files.
122
123           Directories named by -I are searched before the standard system
124           include directories.  If the directory dir is a standard system
125           include directory, the option is ignored to ensure that the default
126           search order for system directories and the special treatment of
127           system headers are not defeated .  If dir begins with "=", then the
128           "=" will be replaced by the sysroot prefix; see --sysroot and
129           -isysroot.
130
131       -o file
132           Write output to file.  This is the same as specifying file as the
133           second non-option argument to cpp.  gcc has a different
134           interpretation of a second non-option argument, so you must use -o
135           to specify the output file.
136
137       -Wall
138           Turns on all optional warnings which are desirable for normal code.
139           At present this is -Wcomment, -Wtrigraphs, -Wmultichar and a
140           warning about integer promotion causing a change of sign in "#if"
141           expressions.  Note that many of the preprocessor's warnings are on
142           by default and have no options to control them.
143
144       -Wcomment
145       -Wcomments
146           Warn whenever a comment-start sequence /* appears in a /* comment,
147           or whenever a backslash-newline appears in a // comment.  (Both
148           forms have the same effect.)
149
150       -Wtrigraphs
151           Most trigraphs in comments cannot affect the meaning of the
152           program.  However, a trigraph that would form an escaped newline
153           (??/ at the end of a line) can, by changing where the comment
154           begins or ends.  Therefore, only trigraphs that would form escaped
155           newlines produce warnings inside a comment.
156
157           This option is implied by -Wall.  If -Wall is not given, this
158           option is still enabled unless trigraphs are enabled.  To get
159           trigraph conversion without warnings, but get the other -Wall
160           warnings, use -trigraphs -Wall -Wno-trigraphs.
161
162       -Wtraditional
163           Warn about certain constructs that behave differently in
164           traditional and ISO C.  Also warn about ISO C constructs that have
165           no traditional C equivalent, and problematic constructs which
166           should be avoided.
167
168       -Wundef
169           Warn whenever an identifier which is not a macro is encountered in
170           an #if directive, outside of defined.  Such identifiers are
171           replaced with zero.
172
173       -Wunused-macros
174           Warn about macros defined in the main file that are unused.  A
175           macro is used if it is expanded or tested for existence at least
176           once.  The preprocessor will also warn if the macro has not been
177           used at the time it is redefined or undefined.
178
179           Built-in macros, macros defined on the command line, and macros
180           defined in include files are not warned about.
181
182           Note: If a macro is actually used, but only used in skipped
183           conditional blocks, then CPP will report it as unused.  To avoid
184           the warning in such a case, you might improve the scope of the
185           macro's definition by, for example, moving it into the first
186           skipped block.  Alternatively, you could provide a dummy use with
187           something like:
188
189                   #if defined the_macro_causing_the_warning
190                   #endif
191
192       -Wendif-labels
193           Warn whenever an #else or an #endif are followed by text.  This
194           usually happens in code of the form
195
196                   #if FOO
197                   ...
198                   #else FOO
199                   ...
200                   #endif FOO
201
202           The second and third "FOO" should be in comments, but often are not
203           in older programs.  This warning is on by default.
204
205       -Werror
206           Make all warnings into hard errors.  Source code which triggers
207           warnings will be rejected.
208
209       -Wsystem-headers
210           Issue warnings for code in system headers.  These are normally
211           unhelpful in finding bugs in your own code, therefore suppressed.
212           If you are responsible for the system library, you may want to see
213           them.
214
215       -w  Suppress all warnings, including those which GNU CPP issues by
216           default.
217
218       -pedantic
219           Issue all the mandatory diagnostics listed in the C standard.  Some
220           of them are left out by default, since they trigger frequently on
221           harmless code.
222
223       -pedantic-errors
224           Issue all the mandatory diagnostics, and make all mandatory
225           diagnostics into errors.  This includes mandatory diagnostics that
226           GCC issues without -pedantic but treats as warnings.
227
228       -M  Instead of outputting the result of preprocessing, output a rule
229           suitable for make describing the dependencies of the main source
230           file.  The preprocessor outputs one make rule containing the object
231           file name for that source file, a colon, and the names of all the
232           included files, including those coming from -include or -imacros
233           command line options.
234
235           Unless specified explicitly (with -MT or -MQ), the object file name
236           consists of the name of the source file with any suffix replaced
237           with object file suffix and with any leading directory parts
238           removed.  If there are many included files then the rule is split
239           into several lines using \-newline.  The rule has no commands.
240
241           This option does not suppress the preprocessor's debug output, such
242           as -dM.  To avoid mixing such debug output with the dependency
243           rules you should explicitly specify the dependency output file with
244           -MF, or use an environment variable like DEPENDENCIES_OUTPUT.
245           Debug output will still be sent to the regular output stream as
246           normal.
247
248           Passing -M to the driver implies -E, and suppresses warnings with
249           an implicit -w.
250
251       -MM Like -M but do not mention header files that are found in system
252           header directories, nor header files that are included, directly or
253           indirectly, from such a header.
254
255           This implies that the choice of angle brackets or double quotes in
256           an #include directive does not in itself determine whether that
257           header will appear in -MM dependency output.  This is a slight
258           change in semantics from GCC versions 3.0 and earlier.
259
260       -MF file
261           When used with -M or -MM, specifies a file to write the
262           dependencies to.  If no -MF switch is given the preprocessor sends
263           the rules to the same place it would have sent preprocessed output.
264
265           When used with the driver options -MD or -MMD, -MF overrides the
266           default dependency output file.
267
268       -MG In conjunction with an option such as -M requesting dependency
269           generation, -MG assumes missing header files are generated files
270           and adds them to the dependency list without raising an error.  The
271           dependency filename is taken directly from the "#include" directive
272           without prepending any path.  -MG also suppresses preprocessed
273           output, as a missing header file renders this useless.
274
275           This feature is used in automatic updating of makefiles.
276
277       -MP This option instructs CPP to add a phony target for each dependency
278           other than the main file, causing each to depend on nothing.  These
279           dummy rules work around errors make gives if you remove header
280           files without updating the Makefile to match.
281
282           This is typical output:
283
284                   test.o: test.c test.h
285
286                   test.h:
287
288       -MT target
289           Change the target of the rule emitted by dependency generation.  By
290           default CPP takes the name of the main input file, deletes any
291           directory components and any file suffix such as .c, and appends
292           the platform's usual object suffix.  The result is the target.
293
294           An -MT option will set the target to be exactly the string you
295           specify.  If you want multiple targets, you can specify them as a
296           single argument to -MT, or use multiple -MT options.
297
298           For example, -MT '$(objpfx)foo.o' might give
299
300                   $(objpfx)foo.o: foo.c
301
302       -MQ target
303           Same as -MT, but it quotes any characters which are special to
304           Make.  -MQ '$(objpfx)foo.o' gives
305
306                   $$(objpfx)foo.o: foo.c
307
308           The default target is automatically quoted, as if it were given
309           with -MQ.
310
311       -MD -MD is equivalent to -M -MF file, except that -E is not implied.
312           The driver determines file based on whether an -o option is given.
313           If it is, the driver uses its argument but with a suffix of .d,
314           otherwise it takes the name of the input file, removes any
315           directory components and suffix, and applies a .d suffix.
316
317           If -MD is used in conjunction with -E, any -o switch is understood
318           to specify the dependency output file, but if used without -E, each
319           -o is understood to specify a target object file.
320
321           Since -E is not implied, -MD can be used to generate a dependency
322           output file as a side-effect of the compilation process.
323
324       -MMD
325           Like -MD except mention only user header files, not system header
326           files.
327
328       -x c
329       -x c++
330       -x objective-c
331       -x assembler-with-cpp
332           Specify the source language: C, C++, Objective-C, or assembly.
333           This has nothing to do with standards conformance or extensions; it
334           merely selects which base syntax to expect.  If you give none of
335           these options, cpp will deduce the language from the extension of
336           the source file: .c, .cc, .m, or .S.  Some other common extensions
337           for C++ and assembly are also recognized.  If cpp does not
338           recognize the extension, it will treat the file as C; this is the
339           most generic mode.
340
341           Note: Previous versions of cpp accepted a -lang option which
342           selected both the language and the standards conformance level.
343           This option has been removed, because it conflicts with the -l
344           option.
345
346       -std=standard
347       -ansi
348           Specify the standard to which the code should conform.  Currently
349           CPP knows about C and C++ standards; others may be added in the
350           future.
351
352           standard may be one of:
353
354           "c90"
355           "c89"
356           "iso9899:1990"
357               The ISO C standard from 1990.  c90 is the customary shorthand
358               for this version of the standard.
359
360               The -ansi option is equivalent to -std=c90.
361
362           "iso9899:199409"
363               The 1990 C standard, as amended in 1994.
364
365           "iso9899:1999"
366           "c99"
367           "iso9899:199x"
368           "c9x"
369               The revised ISO C standard, published in December 1999.  Before
370               publication, this was known as C9X.
371
372           "iso9899:2011"
373           "c11"
374           "c1x"
375               The revised ISO C standard, published in December 2011.  Before
376               publication, this was known as C1X.
377
378           "gnu90"
379           "gnu89"
380               The 1990 C standard plus GNU extensions.  This is the default.
381
382           "gnu99"
383           "gnu9x"
384               The 1999 C standard plus GNU extensions.
385
386           "gnu11"
387           "gnu1x"
388               The 2011 C standard plus GNU extensions.
389
390           "c++98"
391               The 1998 ISO C++ standard plus amendments.
392
393           "gnu++98"
394               The same as -std=c++98 plus GNU extensions.  This is the
395               default for C++ code.
396
397       -I- Split the include path.  Any directories specified with -I options
398           before -I- are searched only for headers requested with
399           "#include "file""; they are not searched for "#include <file>".  If
400           additional directories are specified with -I options after the -I-,
401           those directories are searched for all #include directives.
402
403           In addition, -I- inhibits the use of the directory of the current
404           file directory as the first search directory for "#include "file"".
405
406           This option has been deprecated.
407
408       -nostdinc
409           Do not search the standard system directories for header files.
410           Only the directories you have specified with -I options (and the
411           directory of the current file, if appropriate) are searched.
412
413       -nostdinc++
414           Do not search for header files in the C++-specific standard
415           directories, but do still search the other standard directories.
416           (This option is used when building the C++ library.)
417
418       -include file
419           Process file as if "#include "file"" appeared as the first line of
420           the primary source file.  However, the first directory searched for
421           file is the preprocessor's working directory instead of the
422           directory containing the main source file.  If not found there, it
423           is searched for in the remainder of the "#include "..."" search
424           chain as normal.
425
426           If multiple -include options are given, the files are included in
427           the order they appear on the command line.
428
429       -imacros file
430           Exactly like -include, except that any output produced by scanning
431           file is thrown away.  Macros it defines remain defined.  This
432           allows you to acquire all the macros from a header without also
433           processing its declarations.
434
435           All files specified by -imacros are processed before all files
436           specified by -include.
437
438       -idirafter dir
439           Search dir for header files, but do it after all directories
440           specified with -I and the standard system directories have been
441           exhausted.  dir is treated as a system include directory.  If dir
442           begins with "=", then the "=" will be replaced by the sysroot
443           prefix; see --sysroot and -isysroot.
444
445       -iprefix prefix
446           Specify prefix as the prefix for subsequent -iwithprefix options.
447           If the prefix represents a directory, you should include the final
448           /.
449
450       -iwithprefix dir
451       -iwithprefixbefore dir
452           Append dir to the prefix specified previously with -iprefix, and
453           add the resulting directory to the include search path.
454           -iwithprefixbefore puts it in the same place -I would; -iwithprefix
455           puts it where -idirafter would.
456
457       -isysroot dir
458           This option is like the --sysroot option, but applies only to
459           header files (except for Darwin targets, where it applies to both
460           header files and libraries).  See the --sysroot option for more
461           information.
462
463       -imultilib dir
464           Use dir as a subdirectory of the directory containing target-
465           specific C++ headers.
466
467       -isystem dir
468           Search dir for header files, after all directories specified by -I
469           but before the standard system directories.  Mark it as a system
470           directory, so that it gets the same special treatment as is applied
471           to the standard system directories.
472
473           If dir begins with "=", then the "=" will be replaced by the
474           sysroot prefix; see --sysroot and -isysroot.
475
476       -iquote dir
477           Search dir only for header files requested with "#include "file"";
478           they are not searched for "#include <file>", before all directories
479           specified by -I and before the standard system directories.
480
481           If dir begins with "=", then the "=" will be replaced by the
482           sysroot prefix; see --sysroot and -isysroot.
483
484       -fdirectives-only
485           When preprocessing, handle directives, but do not expand macros.
486
487           The option's behavior depends on the -E and -fpreprocessed options.
488
489           With -E, preprocessing is limited to the handling of directives
490           such as "#define", "#ifdef", and "#error".  Other preprocessor
491           operations, such as macro expansion and trigraph conversion are not
492           performed.  In addition, the -dD option is implicitly enabled.
493
494           With -fpreprocessed, predefinition of command line and most builtin
495           macros is disabled.  Macros such as "__LINE__", which are
496           contextually dependent, are handled normally.  This enables
497           compilation of files previously preprocessed with "-E
498           -fdirectives-only".
499
500           With both -E and -fpreprocessed, the rules for -fpreprocessed take
501           precedence.  This enables full preprocessing of files previously
502           preprocessed with "-E -fdirectives-only".
503
504       -fdollars-in-identifiers
505           Accept $ in identifiers.
506
507       -fextended-identifiers
508           Accept universal character names in identifiers.  This option is
509           experimental; in a future version of GCC, it will be enabled by
510           default for C99 and C++.
511
512       -fno-canonical-system-headers
513           When preprocessing, do not shorten system header paths with
514           canonicalization.
515
516       -fpreprocessed
517           Indicate to the preprocessor that the input file has already been
518           preprocessed.  This suppresses things like macro expansion,
519           trigraph conversion, escaped newline splicing, and processing of
520           most directives.  The preprocessor still recognizes and removes
521           comments, so that you can pass a file preprocessed with -C to the
522           compiler without problems.  In this mode the integrated
523           preprocessor is little more than a tokenizer for the front ends.
524
525           -fpreprocessed is implicit if the input file has one of the
526           extensions .i, .ii or .mi.  These are the extensions that GCC uses
527           for preprocessed files created by -save-temps.
528
529       -ftabstop=width
530           Set the distance between tab stops.  This helps the preprocessor
531           report correct column numbers in warnings or errors, even if tabs
532           appear on the line.  If the value is less than 1 or greater than
533           100, the option is ignored.  The default is 8.
534
535       -fdebug-cpp
536           This option is only useful for debugging GCC.  When used with -E,
537           dumps debugging information about location maps.  Every token in
538           the output is preceded by the dump of the map its location belongs
539           to.  The dump of the map holding the location of a token would be:
540
541                   {"P":F</file/path>;"F":F</includer/path>;"L":<line_num>;"C":<col_num>;"S":<system_header_p>;"M":<map_address>;"E":<macro_expansion_p>,"loc":<location>}
542
543           When used without -E, this option has no effect.
544
545       -ftrack-macro-expansion[=level]
546           Track locations of tokens across macro expansions. This allows the
547           compiler to emit diagnostic about the current macro expansion stack
548           when a compilation error occurs in a macro expansion. Using this
549           option makes the preprocessor and the compiler consume more memory.
550           The level parameter can be used to choose the level of precision of
551           token location tracking thus decreasing the memory consumption if
552           necessary. Value 0 of level de-activates this option just as if no
553           -ftrack-macro-expansion was present on the command line. Value 1
554           tracks tokens locations in a degraded mode for the sake of minimal
555           memory overhead. In this mode all tokens resulting from the
556           expansion of an argument of a function-like macro have the same
557           location. Value 2 tracks tokens locations completely. This value is
558           the most memory hungry.  When this option is given no argument, the
559           default parameter value is 2.
560
561           Note that -ftrack-macro-expansion=2 is activated by default.
562
563       -fexec-charset=charset
564           Set the execution character set, used for string and character
565           constants.  The default is UTF-8.  charset can be any encoding
566           supported by the system's "iconv" library routine.
567
568       -fwide-exec-charset=charset
569           Set the wide execution character set, used for wide string and
570           character constants.  The default is UTF-32 or UTF-16, whichever
571           corresponds to the width of "wchar_t".  As with -fexec-charset,
572           charset can be any encoding supported by the system's "iconv"
573           library routine; however, you will have problems with encodings
574           that do not fit exactly in "wchar_t".
575
576       -finput-charset=charset
577           Set the input character set, used for translation from the
578           character set of the input file to the source character set used by
579           GCC.  If the locale does not specify, or GCC cannot get this
580           information from the locale, the default is UTF-8.  This can be
581           overridden by either the locale or this command line option.
582           Currently the command line option takes precedence if there's a
583           conflict.  charset can be any encoding supported by the system's
584           "iconv" library routine.
585
586       -fworking-directory
587           Enable generation of linemarkers in the preprocessor output that
588           will let the compiler know the current working directory at the
589           time of preprocessing.  When this option is enabled, the
590           preprocessor will emit, after the initial linemarker, a second
591           linemarker with the current working directory followed by two
592           slashes.  GCC will use this directory, when it's present in the
593           preprocessed input, as the directory emitted as the current working
594           directory in some debugging information formats.  This option is
595           implicitly enabled if debugging information is enabled, but this
596           can be inhibited with the negated form -fno-working-directory.  If
597           the -P flag is present in the command line, this option has no
598           effect, since no "#line" directives are emitted whatsoever.
599
600       -fno-show-column
601           Do not print column numbers in diagnostics.  This may be necessary
602           if diagnostics are being scanned by a program that does not
603           understand the column numbers, such as dejagnu.
604
605       -A predicate=answer
606           Make an assertion with the predicate predicate and answer answer.
607           This form is preferred to the older form -A predicate(answer),
608           which is still supported, because it does not use shell special
609           characters.
610
611       -A -predicate=answer
612           Cancel an assertion with the predicate predicate and answer answer.
613
614       -dCHARS
615           CHARS is a sequence of one or more of the following characters, and
616           must not be preceded by a space.  Other characters are interpreted
617           by the compiler proper, or reserved for future versions of GCC, and
618           so are silently ignored.  If you specify characters whose behavior
619           conflicts, the result is undefined.
620
621           M   Instead of the normal output, generate a list of #define
622               directives for all the macros defined during the execution of
623               the preprocessor, including predefined macros.  This gives you
624               a way of finding out what is predefined in your version of the
625               preprocessor.  Assuming you have no file foo.h, the command
626
627                       touch foo.h; cpp -dM foo.h
628
629               will show all the predefined macros.
630
631               If you use -dM without the -E option, -dM is interpreted as a
632               synonym for -fdump-rtl-mach.
633
634           D   Like M except in two respects: it does not include the
635               predefined macros, and it outputs both the #define directives
636               and the result of preprocessing.  Both kinds of output go to
637               the standard output file.
638
639           N   Like D, but emit only the macro names, not their expansions.
640
641           I   Output #include directives in addition to the result of
642               preprocessing.
643
644           U   Like D except that only macros that are expanded, or whose
645               definedness is tested in preprocessor directives, are output;
646               the output is delayed until the use or test of the macro; and
647               #undef directives are also output for macros tested but
648               undefined at the time.
649
650       -P  Inhibit generation of linemarkers in the output from the
651           preprocessor.  This might be useful when running the preprocessor
652           on something that is not C code, and will be sent to a program
653           which might be confused by the linemarkers.
654
655       -C  Do not discard comments.  All comments are passed through to the
656           output file, except for comments in processed directives, which are
657           deleted along with the directive.
658
659           You should be prepared for side effects when using -C; it causes
660           the preprocessor to treat comments as tokens in their own right.
661           For example, comments appearing at the start of what would be a
662           directive line have the effect of turning that line into an
663           ordinary source line, since the first token on the line is no
664           longer a #.
665
666       -CC Do not discard comments, including during macro expansion.  This is
667           like -C, except that comments contained within macros are also
668           passed through to the output file where the macro is expanded.
669
670           In addition to the side-effects of the -C option, the -CC option
671           causes all C++-style comments inside a macro to be converted to
672           C-style comments.  This is to prevent later use of that macro from
673           inadvertently commenting out the remainder of the source line.
674
675           The -CC option is generally used to support lint comments.
676
677       -traditional-cpp
678           Try to imitate the behavior of old-fashioned C preprocessors, as
679           opposed to ISO C preprocessors.
680
681       -trigraphs
682           Process trigraph sequences.
683
684       -remap
685           Enable special code to work around file systems which only permit
686           very short file names, such as MS-DOS.
687
688       --help
689       --target-help
690           Print text describing all the command line options instead of
691           preprocessing anything.
692
693       -v  Verbose mode.  Print out GNU CPP's version number at the beginning
694           of execution, and report the final form of the include path.
695
696       -H  Print the name of each header file used, in addition to other
697           normal activities.  Each name is indented to show how deep in the
698           #include stack it is.  Precompiled header files are also printed,
699           even if they are found to be invalid; an invalid precompiled header
700           file is printed with ...x and a valid one with ...! .
701
702       -version
703       --version
704           Print out GNU CPP's version number.  With one dash, proceed to
705           preprocess as normal.  With two dashes, exit immediately.
706

ENVIRONMENT

708       This section describes the environment variables that affect how CPP
709       operates.  You can use them to specify directories or prefixes to use
710       when searching for include files, or to control dependency output.
711
712       Note that you can also specify places to search using options such as
713       -I, and control dependency output with options like -M.  These take
714       precedence over environment variables, which in turn take precedence
715       over the configuration of GCC.
716
717       CPATH
718       C_INCLUDE_PATH
719       CPLUS_INCLUDE_PATH
720       OBJC_INCLUDE_PATH
721           Each variable's value is a list of directories separated by a
722           special character, much like PATH, in which to look for header
723           files.  The special character, "PATH_SEPARATOR", is target-
724           dependent and determined at GCC build time.  For Microsoft Windows-
725           based targets it is a semicolon, and for almost all other targets
726           it is a colon.
727
728           CPATH specifies a list of directories to be searched as if
729           specified with -I, but after any paths given with -I options on the
730           command line.  This environment variable is used regardless of
731           which language is being preprocessed.
732
733           The remaining environment variables apply only when preprocessing
734           the particular language indicated.  Each specifies a list of
735           directories to be searched as if specified with -isystem, but after
736           any paths given with -isystem options on the command line.
737
738           In all these variables, an empty element instructs the compiler to
739           search its current working directory.  Empty elements can appear at
740           the beginning or end of a path.  For instance, if the value of
741           CPATH is ":/special/include", that has the same effect as
742           -I. -I/special/include.
743
744       DEPENDENCIES_OUTPUT
745           If this variable is set, its value specifies how to output
746           dependencies for Make based on the non-system header files
747           processed by the compiler.  System header files are ignored in the
748           dependency output.
749
750           The value of DEPENDENCIES_OUTPUT can be just a file name, in which
751           case the Make rules are written to that file, guessing the target
752           name from the source file name.  Or the value can have the form
753           file target, in which case the rules are written to file file using
754           target as the target name.
755
756           In other words, this environment variable is equivalent to
757           combining the options -MM and -MF, with an optional -MT switch too.
758
759       SUNPRO_DEPENDENCIES
760           This variable is the same as DEPENDENCIES_OUTPUT (see above),
761           except that system header files are not ignored, so it implies -M
762           rather than -MM.  However, the dependence on the main input file is
763           omitted.
764

SEE ALSO

766       gpl(7), gfdl(7), fsf-funding(7), gcc(1), as(1), ld(1), and the Info
767       entries for cpp, gcc, and binutils.
768
770       Copyright (c) 1987-2015 Free Software Foundation, Inc.
771
772       Permission is granted to copy, distribute and/or modify this document
773       under the terms of the GNU Free Documentation License, Version 1.3 or
774       any later version published by the Free Software Foundation.  A copy of
775       the license is included in the man page gfdl(7).  This manual contains
776       no Invariant Sections.  The Front-Cover Texts are (a) (see below), and
777       the Back-Cover Texts are (b) (see below).
778
779       (a) The FSF's Front-Cover Text is:
780
781            A GNU Manual
782
783       (b) The FSF's Back-Cover Text is:
784
785            You have freedom to copy and modify this GNU Manual, like GNU
786            software.  Copies published by the Free Software Foundation raise
787            funds for GNU development.
788
789
790
791gcc-4.8.5                         2015-06-23                            CPP(1)
Impressum