f78 Index Contents

Index

A B C D E G H I K L M N O P Q R S T U V W
"  #  -  $  /  ?  \  _  <

The following index terms are followed by the page to which discussion of its topic resides.

"

"(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 directiv ffb e
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
ffb 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
ffb 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 fil ffb es
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 ffb 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
Macros with arguments
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 ffb
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
ffb 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
In ffb voking the C preprocessor
Objective C extensions
Invoking the C preprocessor
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
ffb
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
0