Contents
Index


























" # - $ / ? \ _ <
"
- "(quotes), in #include statements
- The #include
Directive
#
- #
- Assertions
- # character:in macros
- Invoking
the C Preprocessor
- ##, concatenating
- Concatenation
- ##, in a macro definition, in arguments
- Concatenation
- #, directives in programs
- Preprocessing
Directives
- #assert
- Assertions
- #define
- Simple Macros
- Invoking
the C Preprocessor
- Preprocessing
Directives
- #define directive
- Simple Macros
- #elif directive
- The #elif Directive
- #else
- Invoking
the C Preprocessor
- #else directive
- The #else Directive
- #endif
- The #elif Directive
- Invoking
the C Preprocessor
- The #if Directive
- #error directive
- The
#error and #warning Directives
- #error directive:inside of conditionals
- The
#error and #warning Directives
- #foo
- Preprocessing
Directives
- #ident directive
- Miscellaneous
Preprocessing Directives
- #if
- Keeping
Deleted Code for Future Reference
- #if directive
- The #if Directive
- #if, #ifdef or #ifndef
- Syntax of Conditionals
- #ifndef
- Once-Only Include
Files
- #import
- Once-Only Include
Files
- #import directive
- Invoking
the C Preprocessor
- #include
- The #include
Directive
- Header Files
- #include \
- Inheritance
and Header Files
- Invoking
the C Preprocessor
- #include <file>
- Invoking
the C Preprocessor
- #include directive
- How #include Works
- #include, use of conditionals
- Combining Source
Files
- #include:variants
- The #include
Directive
- #include_next
- Inheritance
and Header Files
- #line
- Combining Source
Files
- #line directive
- Combining Source
Files
- #pragma directive
- Miscellaneous
Preprocessing Directives
- #pragma once
- Miscellaneous
Preprocessing Directives
- #system
- Assertions
- #system (mvs)
- Assertions
- #system (vms)
- Assertions
- #unassert
- Assertions
- #undef directive
- Undefining Macros
-
- -$
- Invoking
the C Preprocessor
$
- $, in identifiers
- Invoking
the C Preprocessor
/
- /* and */
- Keeping
Deleted Code for Future Reference
- /* within a comment
- Invoking
the C Preprocessor
- // comments
- Invoking
the C Preprocessor
?
- ??/, in trigraph sequences
- Invoking
the C Preprocessor
\
- \
- Inheritance
and Header Files
- \, inside a macro
- Invoking
the C Preprocessor
__
- _, underscores in macro names
- Once-Only Include
Files
- __BASE_FILE__
- Standard
Predefined Macros
- __CHAR_UNSIGNED__
- Standard
Predefined Macros
- __cplusplus
- Standard
Predefined Macros
- __DATE__
- Standard
Predefined Macros
- __FILE__
- Standard
Predefined Macros
- __GNUC__
- Standard
Predefined Macros
- __GNUC_MINOR__
- Standard
Predefined Macros
- __GNUG__
- Standard
Predefined Macros
- __INCLUDE_LEVEL__
- Standard
Predefined Macros
- __LINE__
- Standard
Predefined Macros
- __OPTIMIZE__
- Standard
Predefined Macros
- __REGISTER_PREFIX__
- Standard
Predefined Macros
- __STDC__
- Standard
Predefined Macros
- __STDC_VERSION__
- Standard
Predefined Macros
- __STRICT_ANSI__
- Standard
Predefined Macros
- __TIME__
- Standard
Predefined Macros
- __USER_LABEL_PREFIX__
- Standard
Predefined Macros
- __VERSION__
- Standard
Predefined Macros
- _command, used with naming
- Concatenation
<
- < (angle brackets), in #include statements
- The #include
Directive
A
- angle braces
- The #include
Directive
- -ansi
- Nonstandard
Predefined Macros
- -A
- Invoking
the C Preprocessor
- ANSI C standard:comments = whitespace
- Invoking
the C Preprocessor
- ANSI C standard:exceptions with using backslash
- The #include
Directive
- ANSI C standard:naming definitions
- Nonstandard
Predefined Macros
- ANSI C standard:requirements
- Transformations
Made Globally
- ANSI C Standard:string constants
- Stringification
- ANSI C Standard:using -trigraphs
- Invoking
the C Preprocessor
- ANSI conformance
- Invoking
the C Preprocessor
- ANSI Standard C requirements
- Overview
of the C Preprocessor
- answer
- Assertions
- arguments:with braces
- Macros with
Arguments
- arguments:with brackets
- Macros with
Arguments
- arguments:with commas
- Macros with
Arguments
- arithmetic operators
- The #if Directive
- array
- Concatenation
- assembler code:labels
- Standard
Predefined Macros
- assertion:named question, predicate
- Assertions
- Assertions
- Assertions
- assertions, predefined
- Assertions
- assertions:cpu
- Assertions
- assertions:machine
- Assertions
- assertions:system
- Assertions
- assertions:testing
- Assertions
B
- backslashes
- Stringification
- backslashes in string and character constants
- Stringification
- backslash-newline
- Transformations
Made Globally
- bison parser generator
- Combining Source
Files
- braces
- The #include
Directive
- BUFSIZE
- Cascaded Use
of Macros
C
- C code
- Combining Source
Files
- C expression: arithmetic operators
- The #if Directive
- C expression: character constants
- The #if Directive
- C expression: identifiers
- The #if Directive
- C expression:integer constants
- The #if Directive
- C Preprocessor Output
- C Preprocessor
Output
- C preprocessor:#include
- Header Files
- C preprocessor:changes to input:deleted backslash-newline sequences
- Transformations
Made Globally
- C preprocessor:changes to input:exceptions
- Transformations
Made Globally
- C preprocessor:changes to input:replaced predefined macro names
- Transformations
Made Globally
- C preprocessor:changes to input:spaces
- Transformations
Made Globally
- C preprocessor:conditional compilation
- Overview
of the C Preprocessor
- C preprocessor:CPP_PREDEFINES
- Nonstandard
Predefined Macros
- C preprocessor:definition
- Overview
of the C Preprocessor
- C preprocessor:directives to activate
- Transformations
Made Globally
- C preprocessor:header files
- Header Files
- C preprocessor:header files, including
- Overview
of the C Preprocessor
- C preprocessor:infile, outfile arguments
- Invoking
the C Preprocessor
- C preprocessor:invoking
- Invoking
the C Preprocessor
- C preprocessor:line control
- Overview
of the C Preprocessor
- C preprocessor:macro
- Overview
of the C Preprocessor
- C preprocessor:macro definitions
- Simple Macros
- C preprocessor:macro expansion
- Overview
of the C Preprocessor
- C preprocessor:necessity of -trigraphs
- Invoking
the C Preprocessor
- C preprocessor:output
- C Preprocessor
Output
- C preprocessor:parsing
- Transformations
Made Globally
- C preprocessor:recognizing directives
- Transformations
Made Globally
- C preprocessor:source file requirements
- Uses of Header
Files
- C preprocessor:source files, combining
- Combining Source
Files
- C preprocessor:stringification
- Stringification
- C preprocessor:variants of #include
- The #include
Directive
- C++
- Standard
Predefined Macros
- C++ comments
- Invoking
the C Preprocessor
- Cascaded Use of Macros
- Cascaded Use
of Macros
- ceil_div
- Unintended
Grouping of Arithmetic
- character constants
- The #if Directive
- Combining Source Files
- Combining Source
Files
- commas in arguments
- Macros with
Arguments
- comment delimiters
- Keeping
Deleted Code for Future Reference
- comments
- Redefining Macros
- comments, embedded
- Invoking
the C Preprocessor
- concatenation
- Concatenation
- concatenation of names, of numbers
- Concatenation
- conditional compilation
- Overview
of the C Preprocessor
- conditionals
- Once-Only Include
Files
- The #if Directive
- Conditionals
- Conditionals and Macros
- Conditionals
and Macros
- consecutive string constants
- Stringification
- CPP_PREDEFINES
- Nonstandard
Predefined Macros
- -D
- Conditionals
and Macros
- -D options
- Nonstandard
Predefined Macros
- -dD
- Invoking
the C Preprocessor
D
- debugging
- Why Conditionals
are Used
- decimal integer constants
- Combining Source
Files
- declarations as header files
- Overview
of the C Preprocessor
- definition
- Undefining Macros
- differentiating
- Macros with
Arguments
- dir
- Invoking
the C Preprocessor
- directive names, defined
- Preprocessing
Directives
- directives, miscellaneous
- Miscellaneous
Preprocessing Directives
- -dM
- Invoking
the C Preprocessor
- do...while statement
- Swallowing
the Semicolon
- double scan
- Separate
Expansion of Macro Arguments
- doublequote characters
- Stringification
- Duplication of Side Effects
- Duplication
of Side Effects
E
- else statements
- Swallowing
the Semicolon
- expression, as C expression
- The #if Directive
G
- gcc:invoking with file
- Invoking
the C Preprocessor
- GDB:source files, debugging
- Combining Source
Files
- grouping
- Unintended
Grouping of Arithmetic
H
- header file
- Header Files
- header files
- Overview
of the C Preprocessor
- Header Files
- header files, with redefinition
- Redefining Macros
- header files:base header files
- Inheritance
and Header Files
- header files:inheritance
- Inheritance
and Header Files
- header files:missing
- Invoking
the C Preprocessor
- header files:with #ident
- Miscellaneous
Preprocessing Directives
- header.h
- How #include Works
- How #include Works
- How #include Works
- -I-
- Invoking
the C Preprocessor
- -I directory
- Invoking
the C Preprocessor
- -I.
- Inheritance
and Header Files
I
- identifiers
- The #if Directive
- -idirafter dir
- Invoking
the C Preprocessor
- Improperly Nested Constructs
- Improperly
Nested Constructs
- infinite recursion
- Inheritance
and Header Files
- Inheritance and Header Files
- Inheritance
and Header Files
- inheritance in header files
- Inheritance
and Header Files
- int
- Duplication
of Side Effects
- Conditionals
and Macros
- integer constants
- The #if Directive
- invalid C code
- Swallowing
the Semicolon
- Invoking the C Preprocessor
- Invoking
the C Preprocessor
- -iprefix prefix
- Invoking
the C Preprocessor
- -isystem dir
- Invoking
the C Preprocessor
- -iwithprefix dir
- Invoking
the C Preprocessor
K
- Keeping Deleted Code for Future Reference
- Keeping
Deleted Code for Future Reference
- -lang-c
- Invoking
the C Preprocessor
- -lang-c:default source language
- Invoking
the C Preprocessor
- -lang-c++
- Invoking
the C Preprocessor
- -lang-c89
- Invoking
the C Preprocessor
- -lang-objc
- Invoking
the C Preprocessor
- -lang-objc++
- Invoking
the C Preprocessor
L
- lexical units, valid usage
- Concatenation
- limit.h
- Standard
Predefined Macros
- line control
- Overview
of the C Preprocessor
- -lint
- Invoking
the C Preprocessor
- local version of applications
- Inheritance
and Header Files
- long
- The #if Directive
- -M [-MG]
- Invoking
the C Preprocessor
M
- Mach
- Invoking
the C Preprocessor
- macro calls
- The #if Directive
- macro, substituted arguments
- Separate
Expansion of Macro Arguments
- macro:arguments, expecting
- Macros with
Arguments
- macro:concatenation
- Concatenation
- macro:definitions
- Macros with
Arguments
- macro:double scan
- Separate
Expansion of Macro Arguments
- macro:expansion text
- Macros with
Arguments
- macro:min
- Duplication
of Side Effects
- macro:names, functions
- Macros with
Arguments
- macro:stringification
- Stringification
- macro:using parentheses
- Macros with
Arguments
- macro:using spaces
- Macros with
Arguments
- macros
- Macros
- Macros with Arguments
- Macros with
Arguments
- macros, predefined, on Vax
- Conditionals
and Macros
- macros: input:string, character constants
- C Preprocessor
Output
- macros:AM29000K series
- Nonstandard
Predefined Macros
- macros:appending
- Macros with
Arguments
- macros:arguments
- Macros with
Arguments
- macros:assertions
- Conditionals
and Macros
- macros:calls, substituted
- Separate
Expansion of Macro Arguments
- macros:combining source files
- Combining Source
Files
- macros:compound statements
- Swallowing
the Semicolon
- macros:conditionals
- Conditionals
and Macros
- macros:conditionals as directives
- Conditionals
- macros:controlling file names
- The #include
Directive
- macros:customizing a program
- Conditionals
and Macros
- macros:defining
- Overview
of the C Preprocessor
- macros:errors
- Invoking
the C Preprocessor
- Newlines
in Macro Arguments
- macros:expansion
- Separate
Expansion of Macro Arguments
- macros:for Motorola
- Nonstandard
Predefined Macros
- macros:for Vax
- Nonstandard
Predefined Macros
- macros:function-like
- Macros with
Arguments
- macros:long definitions
- Simple Macros
- macros:M68000 series
- Nonstandard
Predefined Macros
- macros:m68k
- Nonstandard
Predefined Macros
- macros:names
- Simple Macros
- macros:nested calls
- Separate
Expansion of Macro Arguments
- macros:nested constructs
- Improperly
Nested Constructs
- macros:newlines
- Newlines
in Macro Arguments
- macros:ns 32000 series
- Nonstandard
Predefined Macros
- macros:parentheses
- Improperly
Nested Constructs
- macros:pitfalls, subtleties
- Pitfalls
and Subtleties of Macros
- macros:predefined
- Predefined Macros
- Invoking
the C Preprocessor
- macros:predefined, non-standard
- Nonstandard
Predefined Macros
- macros:predefined, non-standard:Pyramid
- Nonstandard
Predefined Macros
- macros:predefined, non-standard:Sequent
- Nonstandard
Predefined Macros
- macros:predefined, non-standard:Sun
- Nonstandard
Predefined Macros
- macros:pre-scan
- Separate
Expansion of Macro Arguments
- macros:quote characters
- Invoking
the C Preprocessor
- macros:recursive
- Invoking
the C Preprocessor
- macros:redefining
- Redefining Macros
- macros:self-referential
- Self-Referential
Macros
- macros:simple
- Simple Macros
- macros:source files
- Invoking
the C Preprocessor
- macros:standard
- Predefined Macros
- macros:string or character constants
- Invoking
the C Preprocessor
- macros:stringified, concatenated
- Separate
Expansion of Macro Arguments
- macros:system-specific
- Predefined Macros
- macros:undefined
- Undefining Macros
- macros:unintended grouping
- Unintended
Grouping of Arithmetic
- macros:using assertions
- Assertions
- macros:using parentheses
- Simple Macros
- macros:variables, functions
- Undefining Macros
- macros:with #
- Invoking
the C Preprocessor
- macros:with side effect
- Duplication
of Side Effects
- macros:with text after
- Invoking
the C Preprocessor
- makefiles, automatic updating
- Invoking
the C Preprocessor
- matching quote characters
- Simple Macros
- -MD file
- Invoking
the C Preprocessor
- min, unsafe macro
- Duplication
of Side Effects
- miscellaneous preprocessing directives
- Miscellaneous
Preprocessing Directives
- -MM [-MG]
- Invoking
the C Preprocessor
- -MMD file
- Invoking
the C Preprocessor
- Motorola
- Nonstandard
Predefined Macros
N
- nested conditionals
- The #elif Directive
- Newlines in Macro Arguments
- Newlines
in Macro Arguments
- Nonstandard Predefined Macros
- Nonstandard
Predefined Macros
- -nostdinc
- The #include
Directive
- ns16000
- Conditionals
and Macros
- null directive
- Miscellaneous
Preprocessing Directives
- null statements
- Swallowing
the Semicolon
O
- Objective C
- Invoking
the C Preprocessor
- Objective C extensions
- Invoking
the C Preprocessor
- once-only include files
- Once-Only Include
Files
- Once-Only Include
Files
- Overview of the C Preprocessor
- Overview
of the C Preprocessor
P
- parentheses
- Simple Macros
- Unintended
Grouping of Arithmetic
- parenthesis
- Improperly
Nested Constructs
- parser files
- Combining Source
Files
- parsing
- Transformations
Made Globally
- -pedantic
- Overview
of the C Preprocessor
- Invoking
the C Preprocessor
- -pedantic-errors
- Invoking
the C Preprocessor
- Pitfalls and Subtleties of Macros
- Pitfalls
and Subtleties of Macros
- porting
- The #include
Directive
- Predefined Macros
- Predefined Macros
- prefix
- Invoking
the C Preprocessor
- preprocessing conditionals
- Why Conditionals
are Used
- preprocessing directives
- The #if Directive
- Preprocessing
Directives
- preprocessing number
- Invoking
the C Preprocessor
- pre-scan
- Separate
Expansion of Macro Arguments
- pre-scan:nested calls
- Separate
Expansion of Macro Arguments
- pre-scan:self-referent macros
- Separate
Expansion of Macro Arguments
- pre-scan:unshielded commas
- Separate
Expansion of Macro Arguments
- program checker
- Invoking
the C Preprocessor
- program.c
- How #include Works
- Pyramid
- Nonstandard
Predefined Macros
Q
- quotes
- The #include
Directive
- quotes, balancing
- Simple Macros
R
- Redefining Macros
- Redefining Macros
- redefining macros (with #define)
- Redefining Macros
- redefinition
- Redefining Macros
S
- self-reference, indirect
- Self-Referential
Macros
- Self-Referential Macros
- Self-Referential
Macros
- self-referents
- Self-Referential
Macros
- semicolon, swallowing
- Swallowing
the Semicolon
- Separate Expansion of Macro Arguments
- Separate
Expansion of Macro Arguments
- Sequent
- Nonstandard
Predefined Macros
- side effect
- Duplication
of Side Effects
- signal.h
- Inheritance
and Header Files
- Simple Macros
- Simple Macros
- sizeof
- Conditionals
and Macros
- SKIP_SPACES
- Swallowing
the Semicolon
- source file
- Undefining Macros
- specify -ansi
- Invoking
the C Preprocessor
- Standard Predefined Macros
- Standard
Predefined Macros
- string constants
- Stringification
- Transformations
Made Globally
- Combining Source
Files
- string or character constants
- C Preprocessor
Output
- stringification
- Stringification
- structure types, defining
- Once-Only Include
Files
- structures, arraying
- Concatenation
- Sun
- Nonstandard
Predefined Macros
- swallowing the semicolon
- Stringification
- Swallowing
the Semicolon
- Syntax of Conditionals
- Syntax of Conditionals
- sys/signal.h
- Inheritance
and Header Files
T
- The #if Directive
- The #if Directive
- The #elif Directive
- The #elif Directive
- The #else Directive
- The #else Directive
- The #error and #warning Directives
- The
#error and #warning Directives
- The #include Directive
- The #include
Directive
- tm.h
- Nonstandard
Predefined Macros
- tokens, syntactic
- Concatenation
- Transformations Made Globally
- Transformations
Made Globally
- trigraphs
- Transformations
Made Globally
- -trigraphs
- Invoking
the C Preprocessor
- Overview
of the C Preprocessor
- trigraphs:enabling
- Transformations
Made Globally
- typedefs
- Once-Only Include
Files
- -U
- Conditionals
and Macros
- -U and -D
- Invoking
the C Preprocessor
- -undef
- Invoking
the C Preprocessor
- Overview
of the C Preprocessor
U
- undefined macros
- Undefining Macros
- Undefining Macros
- Undefining Macros
- undefinition
- Undefining Macros
- Unintended Grouping of Arithmetic
- Unintended
Grouping of Arithmetic
- unsigned long
- The #if Directive
- uppercase usage in macro names
- Simple Macros
- Uses of Header Files
- Uses of Header
Files
V
- variables in macros
- Self-Referential
Macros
- vax
- Nonstandard
Predefined Macros
- Conditionals
and Macros
- Vax computers
- Nonstandard
Predefined Macros
- -Wall
- Invoking
the C Preprocessor
W
- WARN_IF
- Stringification
- warnings
- Invoking
the C Preprocessor
- -Wcomment
- Invoking
the C Preprocessor
- whitespace
- Swallowing
the Semicolon
- Stringification
- whitespace, exceptions
- Redefining Macros
- whitespace, in input
- C Preprocessor
Output
- Why Conditionals are Used
- Why Conditionals
are Used
- -Wtraditional
- Invoking
the C Preprocessor
- -Wtrigraphs
- Invoking
the C Preprocessor