Index
Prev   

Index

! operator
Unary ! and ~ Operators

!= operator
Equality Operators

#pragma critical
Parallel Regions

#pragma directives
changes from Fortran directives
Coding Rules of #pragma Directives
coding rules
Coding Rules of #pragma Directives

#pragma enter gate
Parallel Regions

#pragma exit gate
Parallel Regions

#pragma independent
Parallel Regions

#pragma parallel
Parallel Regions

#pragma pfor
Parallel Regions
restrictions
Restrictions on pfor

#pragma synchronize
Parallel Regions

% operator
Multiplicative Operators

%p conversion
in fprintf function
Streams and Files
in fscanf function
Streams and Files

& operator
Address-of and Indirection Operators
Bitwise AND Operator
fields and
Bitfields

&& operator
Logical AND Operator

&space
Meaning of Declarators

> operator
Relational Operators

>> operator
Shift Operators

>= operator
Relational Operators

< operator
Relational Operators

<< operator
Shift Operators

<= operator
Relational Operators

* operator
Multiplicative Operators

+ operator
Unary + and - Operators
Additive Operators

++ operator
Prefix ++ and - - Operators

++operator
postfix ++ and postfix - -

+= operator
Compound Assignment

32-bit ABI
Preprocessor Changes

32-bit mode
diagnostics
Translation (F.3.1)
double-word boundary
Structures, Unions, Enumerations, and Bitfields (F.3.9)
integer
Arrays and Pointers (F.3.7)
integer sizes
Integers (F.3.5)
long double
Structures, Unions, Enumerations, and Bitfields (F.3.9)
LONGLONG macro
Integers (F.3.5)
pointers
Additive Operators
Arrays and Pointers (F.3.7)
register specifier
Registers (F.3.8)
sizeof
sizeof Unary Operator
type differences
Integer and Floating Point Types
unions
Structures, Unions, Enumerations, and Bitfields (F.3.9)

64-bit mode
Cast Operators
diagnostics
Translation (F.3.1)
integer
Arrays and Pointers (F.3.7)
integer sizes
Integers (F.3.5)
long double
Structures, Unions, Enumerations, and Bitfields (F.3.9)
pointers
Additive Operators
Arrays and Pointers (F.3.7)
quad-word boundary
Structures, Unions, Enumerations, and Bitfields (F.3.9)
register specifier
Registers (F.3.8)
sizeof
sizeof Unary Operator
type differences
Integer and Floating Point Types
unions
Structures, Unions, Enumerations, and Bitfields (F.3.9)

= operator
Assignment Using = (Simple Assignment)
Compound Assignment

== operator
Equality Operators

? operator
Conditional Operator

^ operator
Bitwise Exclusive OR Operator

__builtin_alloca
Built-in Functions

__builtin_cast_d2ll
Built-in Functions

__builtin_cast_dhi2i
Built-in Functions

__builtin_cast_dlo2i
Built-in Functions

__builtin_cast_f2i
Built-in Functions

__builtin_cast_i2dhi
Built-in Functions

__builtin_cast_i2dlo
Built-in Functions

__builtin_cast_i2f
Built-in Functions

__builtin_cast_ll2d
Built-in Functions

__builtin_dabs
Built-in Functions

__builtin_fabs
Built-in Functions

__builtin_fsqrt
Built-in Functions

__builtin_sqrt
Built-in Functions

__DATE__
Preprocessing Directives (F.3.13)

__high_multiply
Built-in Functions

__restrict type qualifier
Qualifiers and Pointers
example
Qualifiers and Pointers

__TIME__
Preprocessing Directives (F.3.13)

abort function
effect on temporary files
abort Function

acpp
changes
Preprocessor Changes

Additive operators
pointers and
Additive Operators

Address constant
Constant Expressions

Address-of operator
Address-of and Indirection Operators
fields and
Bitfields

AND operator
bitwise
Bitwise AND Operator
logical
Logical AND Operator

ANSI C
allocating storage
Changes in the Linkage of Identifiers
conversion rules
Integral Promotions
ANSI C Conversion Rules
disambiguating identifiers
Changes in Disambiguating Identifiers
floating point
Conversions of Float and Double
fucntion prototype scope
Scoping Differences
function prototype error
Function Prototypes
guidelines
Guidelines for Using ANSI C
identifiers
Meaning of Identifiers
libraries
Guidelines for Using ANSI C
linkage discrepancies
Linkage Discrepancies Between Traditional and ANSI C
linker
warnings
Changes in the Linkage of Identifiers
lint
Guidelines for Using ANSI C
macro replacement
Replacement of Macro Arguments in Strings
name space
Name Space Changes
name space discrepancies
Name Space Discrepancies Between Traditional and ANSI C
name spaces
Name Spaces
Name Spaces
preprocessor
Preprocessor Changes
Preprocessor Changes
scoping differences
Scoping Differences
strictly conforming programs
ANSI C
string literals
Replacement of Macro Arguments in Strings
switches
Compiling ANSI Programs
trigraph sequences
Trigraph Sequences (ANSI C Only)
value preserving integer promotion
Conversions of Characters and Integers
warnings
Guidelines for Using ANSI C

ANSI C standard header files
Standard Headers

-ansi compiler option
external names and
Data Area Name Changes
macros
Replacement of Macro Arguments in Strings
string literals
Replacement of Macro Arguments in Strings
tokens
Token Concatenation

-ansi switch
Compiling ANSI Programs

Append mode stream
initial file position
Streams and Files

Application Program Interface
See API

Argument promotions
Function Calls

Argument type promotions
changes
Argument Type Promotions

Arguments
passing
Function Calls

Arithmetic constant expressions
Constant Expressions

Arithmetic conversions
Arithmetic Conversions
Usual Arithmetic Conversions

Arithmetic expressions
Type Promotion in Arithmetic Expressions

Arithmetic types
Derived Types

Arithmetic value
64-bit mode
Cast Operators

Array
type required to hold maximum size
Arrays and Pointers (F.3.7)

Array declarators
Array Declarators

Arrays
variable length
Array Declarators

asm keyword
asm Keyword (F.5.10)

Assert
Library Functions (F.3.14)
diagnostic
Library Functions (F.3.14)

Assignment operators
Assignment Operators
+=
Compound Assignment
=
Assignment Using = (Simple Assignment)
Compound Assignment

Associativity
examples
Precedence and Associativity Rules in C

atan2
Library Functions (F.3.14)

atan2f
Library Functions (F.3.14)

Atomic compare-and-swap operation
Atomic compare-and-swap Operation

Atomic fetch-and-op operations
Atomic fetch-and-op Operations

Atomic lock and unlock operations
Atomic lock-test-and-set Operation

Atomic lock-release operation
Atomic lock-release Operation

Atomic lock-test-and-set operation
Atomic lock-test-and-set Operation

Atomic op-and-fetch operations
Atomic op-and-fetch Operations

Atomic synchronize operation
Atomic synchronize Operation

auto
Storage Class Specifiers

Auto keyword
Storage Class Specifiers

Auto storage class
Storage Class Specifiers

Autoblocking
MP_SET_NUMTHREADS, MP_BLOCKTIME, MP_SETUP

Automatic storage duration
Storage Duration

barrier
mp_setlock, mp_unsetlock, mp_barrier

Barrier function
mp_setlock, mp_unsetlock, mp_barrier

Behavior
locale-specific
Locale-Specific Behavior (F.4)

Binary streams
null characters in
Streams and Files

Bitfield
diagnostics
Non-int Bit-Field Types (F.5.8)
integral type
Non-int Bit-Field Types (F.5.8)

Bitfields
Bitfields
Structures, Unions, Enumerations, and Bitfields (F.3.9)
integer types
Recommended Practices
order of allocation
Structures, Unions, Enumerations, and Bitfields (F.3.9)
signedness of
Structures, Unions, Enumerations, and Bitfields (F.3.9)
spanning unit boundary
Bitfields
straddling int boundaries
Structures, Unions, Enumerations, and Bitfields (F.3.9)

Bits
bitfields
Bitfields

Bits per character
Characters (F.3.4)

Bitwise and operator
Bitwise AND Operator

Bitwise not operator
Unary ! and ~ Operators

Bitwise operations
signed integers
Integers (F.3.5)

Bitwise or operator
exclusive
Bitwise Exclusive OR Operator
inclusive
Bitwise Inclusive OR Operator

Blanks
Lexical Conventions

Block scope
definition
Block Scope

Block statements
Compound Statement or Block

Blocking
automatic
mp_blocktime

Blocking slave threads
mp_block and mp_unblock

blockproc
mp_blocktime

break statements
break Statement

Built-in functions
Built-in Functions
__builtin_alloca
Built-in Functions
__builtin_cast_d2ll
Built-in Functions
__builtin_cast_dhi2i
Built-in Functions
__builtin_cast_dlo2i
Built-in Functions
__builtin_cast_f2i
Built-in Functions
__builtin_cast_i2dhi
Built-in Functions
__builtin_cast_i2dlo
Built-in Functions
__builtin_cast_i2f
Built-in Functions
__builtin_cast_ll2d
Built-in Functions
__builtin_dabs
Built-in Functions
__builtin_fabs
Built-in Functions
__builtin_fsqrt
Built-in Functions
__builtin_sqrt
Built-in Functions
__high_multiply
Built-in Functions

calloc
Memory Allocation

Case distinctions
in identifiers
Identifiers (F.3.3)

case label
switch Statement

case labels
Labeled Statements

Case values
maximum number of
Statements (F.3.12)

Cast operators
Cast Operators

Casting
pointer to a function
Function Pointer Casts (F.5.7)

-cckr compiler option
Replacement of Macro Arguments in Strings
external names and
Data Area Name Changes
tokens
Token Concatenation

cConversions
void
Conversion of void Objects

char
Character Types
default sign
Characters (F.3.4)
unsigned vs. "plain"
Characters (F.3.4)

- character
in fscanf function
Streams and Files
white space
Translation (F.3.1)

Character constant
Preprocessing Directives (F.3.13)

Character constants
Character Constants
wide
Character Constants

Character set
Characters (F.3.4)

Character types
Character Types

Characters
Characters (F.3.4)
conversions to integer
Conversions of Characters and Integers
integer constants
Characters (F.3.4)
multibyte
Character Types
Characters (F.3.4)
Characters (F.3.4)
nongraphic
Special Characters
number of bits
Characters (F.3.4)
shift states
Characters (F.3.4)
source set vs. execution set
Characters (F.3.4)
special
Special Characters
wide
Characters (F.3.4)
initialization
Initialization of Aggregates

CHRCLASS environment variable
Library Functions (F.3.14)

CHUNK
MP_SCHEDTYPE, CHUNK

clock function
Time Zones and the clock Function

Coding rules
#pragma directives
Coding Rules of #pragma Directives

Comma operator
Comma Operator

Comments
Comments

-common compiler option
Changes in the Linkage of Identifiers

Communication
between processors
Communicating Between Threads Through Thread Local Data

compare-and-swap operation
Atomic compare-and-swap Operation

Compatible types
Compatible Types

Compilation
Compiling ANSI Programs

Compilation mode
effect on names
Data Area Name Changes

Compiler restrictions
Restrictions for the C++ Compiler
exception handling
Restrictions on Exception Handling
on #pragma pfor
Restrictions on pfor
scoping
Scoping Restrictions

Compound assignment
Compound Assignment

Compound statements
Compound Statement or Block
scope of declarations
Compound Statement or Block

Conditional operator
Conditional Operator

const object
Recommended Practices

const type qualifier
qualifiers
const
Type Qualifiers

Constant expression
Preprocessing Directives (F.3.13)
arithmetic
Constant Expressions

Constant expressions
Constants
Constant Expressions
address constant
Constant Expressions
integral
Constant Expressions

Constants
Primary Expressions
character
Character Constants
enumeration
Enumeration Constants
floating
Floating Constants
integer
Integer Constants
long double precision
Conversions of Float and Double
types of
Constants
wide character
Character Constants

continue statements
for Statement
continue Statement

Controlling expression
definition
Selection Statements

Conversions
Operator Conversions
arithmetic
Arithmetic Conversions
Usual Arithmetic Conversions
character
Conversions of Characters and Integers
floating-point
Conversions of Float and Double
function designators
Conversion of lvalues and Function Designators
integer
Conversion of unsigned Integers
promotions
Integral Promotions
lvalues
Conversion of lvalues and Function Designators
pointer
Conversion of Pointers and Integers
pointers
Conversion of Pointers
rules
ANSI C
ANSI C Conversion Rules
Traditional C
Traditional C Conversion Rules

cpp
changes
Preprocessor Changes

Data area names changes
Data Area Name Changes

Date
availability
Preprocessing Directives (F.3.13)

Daylight saving time
Time Zones and the clock Function

Declarations
as definitions
Declarations
enumerations
Enumeration Declarations
implicit
Implicit Declarations
multiple
Declarations
structure
Structure and Union Declarations
union
Structure and Union Declarations

Declarators
array
Array Declarators
definition
Meaning of Declarators
maximum number of
Declarators (F.3.11)
pointer
Pointer Declarators
restrictions
Restrictions on Declarators
syntax
Declarators

Decrement operator
Prefix ++ and - - Operators

Default argument promotions
Function Calls

Default labels
switch Statement
Labeled Statements

Definition
declaration
Declarations

Definitions
external
External Definitions

Denoting a bitfield
sizeof Unary Operator

Derived types
Derived Types

Device
interactive
Environment (F.3.2)

Diagnostics
classes
Translation (F.3.1)
Translation (F.3.1)
control
Translation (F.3.1)
identification errors
Translation (F.3.1)
return codes
Translation (F.3.1)
Translation (F.3.1)

Directives
#pragma
coding rules
Coding Rules of #pragma Directives
#pragma critical
Parallel Regions
#pragma enter gate
Parallel Regions
#pragma exit gate
Parallel Regions
#pragma independent
Parallel Regions
#pragma parallel
Parallel Regions
#pragma pfor
Parallel Regions
#pragma synchronize
Parallel Regions
multiprocessing
OpenMP C/C++ API Multiprocessing Directives
OpenMP
OpenMP C/C++ API Multiprocessing Directives
preprocessing
Preprocessing Directives (F.3.13)

Disambiguating identifiers
Changes in Disambiguating Identifiers

Disambiguating names
Disambiguating Names

Division
integer
Multiplicative Operators
sign of remainder
Integers (F.3.5)

Division by zero
Multiplicative Operators
Integer and Floating Point Exceptions

do statements
do Statement

Domain errors
return values
Library Functions (F.3.14)

double
Integer and Floating Point Types
Floating Point (F.3.6)
representation of
Floating Point (F.3.6)

Double precision
Conversions of Float and Double

else statements
if Statement

enum
Structure and Union Declarations
changes
Name Space Changes

Enumeration constants
Enumeration Constants
Integer and Floating Point Types
Enumeration Declarations
changes
Name Space Changes

Enumeration types
type of int used
Structures, Unions, Enumerations, and Bitfields (F.3.9)

Enumeration variables
Enumeration Declarations

Enumerations
Structures, Unions, Enumerations, and Bitfields (F.3.9)

Environment
altering
getenv Function
names
getenv Function
variables
getenv Function

Environment variables
CHRCLASS
Library Functions (F.3.14)
CHUNK
MP_SCHEDTYPE, CHUNK
gang scheduling
MPC_GANG
MP_BLOCKTIME
MP_SET_NUMTHREADS, MP_BLOCKTIME, MP_SETUP
MP_SET_NUMTHREADS, MP_BLOCKTIME, MP_SETUP
MP_SCHEDTYPE
MP_SCHEDTYPE, CHUNK
MP_SET_NUMTHREADS
MP_SET_NUMTHREADS, MP_BLOCKTIME, MP_SETUP
MP_SET_NUMTHREADS, MP_BLOCKTIME, MP_SETUP
MP_SETUP
MP_SET_NUMTHREADS, MP_BLOCKTIME, MP_SETUP
MP_SLAVE_STACKSIZE
MP_SLAVE_STACKSIZE
MP_SUGNUMTHD
MP_SUGNUMTHD, MP_SUGNUMTHD_MIN, MP_SUGNUMTHD_MAX, MP_SUGNUMTHD_VERBOSE
MP_SUGNUMTHD_MAX
MP_SUGNUMTHD, MP_SUGNUMTHD_MIN, MP_SUGNUMTHD_MAX, MP_SUGNUMTHD_VERBOSE
MP_SUGNUMTHD_MIN
MP_SUGNUMTHD, MP_SUGNUMTHD_MIN, MP_SUGNUMTHD_MAX, MP_SUGNUMTHD_VERBOSE
MP_SUGNUMTHD_VERBOSE
MP_SUGNUMTHD, MP_SUGNUMTHD_MIN, MP_SUGNUMTHD_MAX, MP_SUGNUMTHD_VERBOSE
MPC_GANG
MPC_GANG

Environments
Environment (F.3.2)
freestanding
Environment (F.3.2)

Equality operators
Equality Operators

ERANGE macro
Library Functions (F.3.14)

errno
Library Functions (F.3.14)

errno macro
errno and perror

Escape sequences
Characters (F.3.4)
hexadecimal
Special Characters

Exception handling
Integer and Floating Point Exceptions

Exception handling restrictions
Restrictions on Exception Handling

Exclusive or operator
Bitwise Exclusive OR Operator

exit function
exit Function

Expression statements
Expression Statement

Expressions
++
postfix ++ and postfix - -
constant
Constant Expressions
postfix
Postfix Expressions
function calls
Function Calls
structure references
Structure and Union References
subscripts
Subscripts
union references
Structure and Union References
primary
Primary Expressions

Extensions
Compiling ANSI Programs
Common Extensions (F.5)
arithmetic types
Other Arithmetic Types (F.5.6)
asm keyword
asm Keyword (F.5.10)
bitfield types
Non-int Bit-Field Types (F.5.8)
defined file position indicator
Defined File Position Indicator (F.5.16)
empty macro arguments
Empty Macro Arguments (F.5.12)
environment arguments
Environment Arguments (F.5.1)
external definitions
Multiple External Definitions (F.5.11)
fortran keyword
fortran Keyword (F.5.9)
function pointer casts
Function Pointer Casts (F.5.7)
identifiers
Lengths and Cases of Identifiers
predefined macro names
Predefined Macro Names (F.5.13)
scopes
Scopes of Identifiers (F.5.4)
signal handlers
Extra Arguments for Signal Handlers (F.5.14)
specialized identifiers
Specialized Identifiers
stream types
Additional Stream Types and File-Opening Modes (F.5.15)
writable string literals
Writable String Literals (F.5.5)

extern
Storage Class Specifiers
definitions
Changes in the Linkage of Identifiers
function definitions
External Function Definitions

External definitions
External Definitions

External function definitions
External Function Definitions

External linkage
Linkage of Identifiers

External names
External Name Changes
compiler options and
Data Area Name Changes

External object definitions
External Object Definitions

fetch-and-op operations
__fetch_and_add
Atomic fetch-and-op Operations
__fetch_and_and
Atomic fetch-and-op Operations
__fetch_and_max
Atomic fetch-and-op Operations
__fetch_and_min
Atomic fetch-and-op Operations
__fetch_and_mpy
Atomic fetch-and-op Operations
__fetch_and_nand
Atomic fetch-and-op Operations
__fetch_and_or
Atomic fetch-and-op Operations
__fetch_and_sub
Atomic fetch-and-op Operations
__fetch_and_xor
Atomic fetch-and-op Operations

fgetpos function
errno on failure
errno and perror

File buffering
Streams and Files

File position indicator
initial position
Streams and Files

filenames
Streams and Files

files
opening multiple times
Streams and Files
remove on an open file
Streams and Files
renaming
Streams and Files
temporary
abort Function
Temporary Files
valid names
Streams and Files
zero-length
Streams and Files

float
Integer and Floating Point Types
representation of
Floating Point (F.3.6)

-float compiler option
Conversions of Float and Double
effect on conversions
Conversions of Float and Double
type promotions
Type Promotion in Arithmetic Expressions

float variables
Types and Type Compatibility

floating constants
definition
Floating Constants

Floating point constants
Type Promotion and Floating Point Constants

Floating point conversions
Type Promotion and Floating Point Constants

Floating types
Derived Types

Floating-point
conversions
Conversions of Float and Double
exception handling
Integer and Floating Point Exceptions
sizes
Integer and Floating Point Types
types
Floating Point (F.3.6)

fmod
Library Functions (F.3.14)

for statements
for Statement

fortran keyword
fortran Keyword (F.5.9)

fprintf
Streams and Files

fscanf
Streams and Files

ftell function
errno on failure
errno and perror

-fullwarn compiler option
scope
Scoping Differences

Function definitions
External Function Definitions

Function names
changes
Changes in Function Names

Function pointer casts
Function Pointer Casts (F.5.7)

Function prototype scope
Scoping Differences
Function Prototype Scope

Function prototypes
Function Prototypes
incompatible types
Function Prototypes
inconsistent
Function Prototypes

Function scope
Scoping Differences
Function Scope

Functions
built-in
See Built-in functions
calls
Function Calls
declarators
Function Declarators and Prototypes
designators
conversions
Conversion of lvalues and Function Designators
external
definition
External Function Definitions
mixed use
Mixed Use of Functions
nonprototyped
Function Calls
non-void
Recommended Practices
prototyped
Function Calls
prototypes
Function Declarators and Prototypes
Prototyped Functions Summarized
storage-class specifiers
External Function Definitions
type
External Function Definitions

Gang scheduling
MPC_GANG

getenv function
getenv Function

goto statements
goto Statement

Header files
changes
Standard Headers

Headers
standard
Standard Headers

Hexadecimal escape sequences
Special Characters

Hints
Helpful Programming Hints

-I compiler option
Preprocessing Directives (F.3.13)

Identifiers
Identifiers
Identifiers (F.3.3)
case distinctions
Identifiers (F.3.3)
definition
Identifiers
disambiguating
Changes in Disambiguating Identifiers
linkage
Changes in the Linkage of Identifiers
Linkage of Identifiers
scope
Scoping Differences

IEEE
floating point
Conversion of Floating and Integral Types

if statements
Selection Statements
if Statement

iIntegers
sizes
Integers (F.3.5)

Implicit declarations
Implicit Declarations

Include files
Preprocessing Directives (F.3.13)
maximum nesting depth
Preprocessing Directives (F.3.13)
quoted names
Preprocessing Directives (F.3.13)

Inclusive or operator
Bitwise Inclusive OR Operator

Incompatible types
function prototypes and
Function Prototypes

Increment operator
Prefix ++ and - - Operators

Indirect references
Indirect Structure and Union References

Indirection operator
Address-of and Indirection Operators

init-declarator-list
definition
Declarations

Initialization
Initialization
aggregates
Initialization of Aggregates
and storage duration
Storage Class Specifiers
examples
Examples of Initialization
structs
Initialization of Aggregates
unions
Initialization of Aggregates

int
Integer and Floating Point Types
pointer conversion
Cast Operators

Integer
conversions to character
Conversions of Characters and Integers
divide-by-zero
Integer and Floating Point Exceptions
sizes
Integer and Floating Point Types

Integer character constants
Characters (F.3.4)

Integer constants
Integer Constants

Integer division
Multiplicative Operators
sign of remainder
Integers (F.3.5)

Integers
bitwise operations
Integers (F.3.5)
conversions
Integers (F.3.5)
exception conditions
Integer and Floating Point Exceptions
pointers
Conversion of Pointers and Integers
ranges
Integers (F.3.5)
representations
Integers (F.3.5)
unsigned
conversions
Conversion of unsigned Integers

Integral constant expressions
Constant Expressions

Integral promotions
Integral Promotions
Traditional C Conversion Rules

Integral types
Derived Types

Interactive device
Environment (F.3.2)

Internal linkage
Linkage of Identifiers

Intrinsics
example
Example of Implementing a Pure Spin-Wait Lock
memory barrier
Synchronization Intrinsics
synchronization
Synchronization Intrinsics

isalnum
Library Functions (F.3.14)

isalpha
Library Functions (F.3.14)

iscntrl
Library Functions (F.3.14)

islower
Library Functions (F.3.14)

isprint
Library Functions (F.3.14)

isupper
Library Functions (F.3.14)

Iteration statements
Iteration Statements
controlling expression
Iteration Statements
flow of control
Iteration Statements

Jump statements
Jump Statements

Keywords
list of
Keywords

Labeled statements
Labeled Statements

Labels
case
switch Statement
default
switch Statement
name spaces
Labeled Statements

libmalloc.a
Memory Allocation

Libraries
C
Guidelines for Using ANSI C
Math
Guidelines for Using ANSI C
shared
Guidelines for Using ANSI C

Library functions
Library Functions (F.3.14)
prototypes
Standard Headers

Linkage
Storage Class Specifiers
determination of
Linkage of Identifiers
discrepancies
Linkage Discrepancies Between Traditional and ANSI C
external
Linkage of Identifiers
identifiers
Linkage of Identifiers
internal
Linkage of Identifiers
none
Linkage of Identifiers

Linker-defined names
Changes in Linker-Defined Names

lint
Guidelines for Using ANSI C

lint-style comments
lint-style Comments
/*ARGUSED*/
lint-style Comments
/*NOTREACHED*/
lint-style Comments
/*PRINTFLIKE*/
lint-style Comments
/*REFERENCED*/
lint-style Comments
/*SCANF like*/
lint-style Comments
/*VARARGS*/
lint-style Comments

Literals
String Literals

Local time
Time Zones and the clock Function

Locale-specific behavior
Locale-Specific Behavior (F.4)

lock and unlock operations
Atomic lock-test-and-set Operation

Lock example
Example of Implementing a Pure Spin-Wait Lock

lock-release operation
Atomic lock-release Operation

lock-test-and-set operation
Atomic lock-test-and-set Operation

Logical operators
AND
Logical AND Operator
OR
Logical OR Operator

long
Integer and Floating Point Types

long double
Floating Constants
Integer and Floating Point Types
Integer and Floating Point Types
Floating Point (F.3.6)

long double precision
Conversions of Float and Double

long long
Integer and Floating Point Types
Integer and Floating Point Types

LONGLONG macro
Integers (F.3.5)

lvalue
conversions
Conversion of lvalues and Function Designators
definition
Objects and lvalues

lvalues
sizeof Unary Operator

Macros
in -ansi mode
Replacement of Macro Arguments in Strings
in -cckr mode
Replacement of Macro Arguments in Strings
LONGLONG
Integers (F.3.5)

main
arguments to
Environment (F.3.2)

malloc
Memory Allocation

Mapping
character sequences
Preprocessing Directives (F.3.13)

Mathematics functions
domain errors
Library Functions (F.3.14)
underflow range errors
Library Functions (F.3.14)

Memory
acquire barrier
Synchronization Intrinsics
allocation
Memory Allocation
full barrier
Synchronization Intrinsics
release barrier
Synchronization Intrinsics

Memory barrier
Synchronization Intrinsics

Message passing
Communicating Between Threads Through Thread Local Data

Message Passing Tookit (MPT)
Communicating Between Threads Through Thread Local Data

Messages
diagnostic
Translation (F.3.1)
error
Translation (F.3.1)
multiple definition
Changes in the Linkage of Identifiers

minus
Prefix ++ and - - Operators
Prefix ++ and - - Operators
prefix
Prefix ++ and - - Operators

mp_barrier
mp_setlock, mp_unsetlock, mp_barrier

mp_block
mp_block and mp_unblock

mp_blocktime
mp_blocktime
MP_SET_NUMTHREADS, MP_BLOCKTIME, MP_SETUP
MP_SET_NUMTHREADS, MP_BLOCKTIME, MP_SETUP

mp_create
mp_setup, mp_create, and mp_destroy

mp_destroy
mp_setup, mp_create, and mp_destroy

mp_my_threadnum
mp_my_threadnum

mp_numthreads
mp_numthreads, mp_suggested_numthreads , mp_set_numthreads

MP_SCHEDTYPE
MP_SCHEDTYPE, CHUNK

mp_set_numthreads
mp_setup, mp_create, and mp_destroy
mp_numthreads, mp_suggested_numthreads , mp_set_numthreads
MP_SET_NUMTHREADS, MP_BLOCKTIME, MP_SETUP
MP_SET_NUMTHREADS, MP_BLOCKTIME, MP_SETUP

mp_set_slave_stacksize
mp_set_slave_stacksize

mp_setlock
mp_setlock, mp_unsetlock, mp_barrier

mp_setup
mp_setup, mp_create, and mp_destroy
mp_numthreads, mp_suggested_numthreads , mp_set_numthreads
MP_SET_NUMTHREADS, MP_BLOCKTIME, MP_SETUP

mp_shmem
Communicating Between Threads Through Thread Local Data

MP_SLAVE_STACKSIZE
MP_SLAVE_STACKSIZE

mp_suggested_numthreads
mp_numthreads, mp_suggested_numthreads , mp_set_numthreads

MP_SUGNUMTHD
MP_SUGNUMTHD, MP_SUGNUMTHD_MIN, MP_SUGNUMTHD_MAX, MP_SUGNUMTHD_VERBOSE

MP_SUGNUMTHD_MAX
MP_SUGNUMTHD, MP_SUGNUMTHD_MIN, MP_SUGNUMTHD_MAX, MP_SUGNUMTHD_VERBOSE

MP_SUGNUMTHD_MIN
MP_SUGNUMTHD, MP_SUGNUMTHD_MIN, MP_SUGNUMTHD_MAX, MP_SUGNUMTHD_VERBOSE

MP_SUGNUMTHD_VERBOSE
MP_SUGNUMTHD, MP_SUGNUMTHD_MIN, MP_SUGNUMTHD_MAX, MP_SUGNUMTHD_VERBOSE

mp_unblock
mp_block and mp_unblock

mp_unsetlock
mp_setlock, mp_unsetlock, mp_barrier

MPC_GANG
MPC_GANG

Multibyte characters
Character Types
Characters (F.3.4)
Characters (F.3.4)

Multiple definition messages
Changes in the Linkage of Identifiers

Multiplicative operators
Multiplicative Operators

Multiprocessing directives
OpenMP C/C++ API Multiprocessing Directives

Name
definition
Identifiers

Name spaces
Name Spaces
Name Spaces
changes
Name Space Changes
discrepancies
Name Space Discrepancies Between Traditional and ANSI C
labels
Labeled Statements

Names
compilation mode effect on
Data Area Name Changes
data area
Data Area Name Changes
external
External Name Changes
functions
changes
Changes in Function Names
linker-defined
Changes in Linker-Defined Names

Negation
Unary + and - Operators

Negative integers
right shift on
Integers (F.3.5)

newline
in text streams
Streams and Files

Newlines
Lexical Conventions

Non-ANSI C
compilation mode
Compiling Traditional C Programs

Nongraphic characters
Special Characters

Nonprototyped function declarations
Function Calls

Non-void function
Recommended Practices

-nostdinc compiler option
Preprocessing Directives (F.3.13)

NUL character
Special Characters

Null
Special Characters

Null characters
in binary streams
Streams and Files

NULL pointer
Library Functions (F.3.14)

NULL pointer constant
Conversion of Pointers

Null statement
Expression Statement

NUM_THREADS
MP_SET_NUMTHREADS, MP_BLOCKTIME, MP_SETUP

Object
definition
Objects and lvalues

Objects
definitions
external
External Object Definitions
external
External Object Definitions
types
Object Types

offsetof() macro
Recommended Practices

op-and-fetch operations
__add_and_fetch
Atomic op-and-fetch Operations
__and_and_fetch
Atomic op-and-fetch Operations
__max_and_fetch
Atomic op-and-fetch Operations
__min_and_fetch
Atomic op-and-fetch Operations
__mpy_and_fetch
Atomic op-and-fetch Operations
Atomic op-and-fetch Operations
__nand_and_fetch
Atomic op-and-fetch Operations
__or_and_fetch
Atomic op-and-fetch Operations
__sub_and_fetch
Atomic op-and-fetch Operations
__xor_and_fetch
Atomic op-and-fetch Operations

OpemMP
multiprocessing directives
OpenMP C/C++ API Multiprocessing Directives

- - operator
postfix ++ and postfix - -
Unary + and - Operators
Prefix ++ and - - Operators
Multiplicative Operators
Additive Operators
bitwise not
Unary ! and ~ Operators

Operators
!
Unary ! and ~ Operators
%
Multiplicative Operators
&
Bitwise AND Operator
>>
Shift Operators
<<
Shift Operators
*
Multiplicative Operators
+
Additive Operators
++
prefix
Prefix ++ and - - Operators
additive
Additive Operators
address-of
Address-of and Indirection Operators
AND
Bitwise AND Operator
assignment
Assignment Operators
+=
Compound Assignment
=
Assignment Using = (Simple Assignment)
Compound Assignment
associativity
Precedence and Associativity Rules in C
Precedence and Associativity Rules in C
bitwise
AND
Bitwise AND Operator
cast
Cast Operators
comma
Comma Operator
conditional
Conditional Operator
conversions
Operator Conversions
equality
Equality Operators
evaluation
Precedence and Associativity Rules in C
exclusive or
Bitwise Exclusive OR Operator
grouping
Precedence and Associativity Rules in C
inclusive OR
Bitwise Inclusive OR Operator
indirection
Address-of and Indirection Operators
list of
Operators
logical
minus
Prefix ++ and - - Operators
multiplicative
Multiplicative Operators
OR
exclusive
Bitwise Exclusive OR Operator
inclusive
Bitwise Inclusive OR Operator
logical
Logical OR Operator
order of evaluation
Precedence and Associativity Rules in C
precedence
Precedence and Associativity Rules in C
relational
Relational Operators
shift
Shift Operators
sizeof
sizeof Unary Operator
unary
Unary Operators
~
Unary ! and ~ Operators

-OPT
alias=disjoint
Pointer-related Command Options
alias=restrict
Pointer-related Command Options

OR operator
exclusive
Bitwise Exclusive OR Operator
inclusive
Bitwise Inclusive OR Operator
logical
Logical OR Operator

Order of evaluation
operators
Precedence and Associativity Rules in C

Overflow handling
Integer and Floating Point Exceptions

Parallel computing forum (PCF)
Coding Rules of #pragma Directives

Parallel Fortran
communication between threads
Communicating Between Threads Through Thread Local Data

Parallel reduction operations
Parallel Reduction Operations in C and C++

Parallel regions
Using Parallel Regions
work-sharing constructs
Parallel Regions

Parameter list
Function Declarators and Prototypes

Parenthesized expressions
Primary Expressions

Passing arguments
Function Calls

perror function
errno and perror

pointer
Integer and Floating Point Types
convert to int
Cast Operators
truncation of value
Cast Operators

Pointer constant
NULL
Conversion of Pointers

Pointer declarators
Pointer Declarators

Pointers
additive operators on
Additive Operators
casting to int
Arrays and Pointers (F.3.7)
command options
Pointer-related Command Options
conversion to int
Arrays and Pointers (F.3.7)
conversions
Conversion of Pointers
differences of
Arrays and Pointers (F.3.7)
integer additions and
Conversion of Pointers and Integers
qualifiers
Qualifiers and Pointers
restricted
Qualifiers and Pointers
to qualified types
Qualifiers and Pointers
to void
Conversion of Pointers

Postfix expressions
Postfix Expressions
postfix ++ and postfix - -
++
postfix ++ and postfix - -
function calls
Function Calls
indirect references
Indirect Structure and Union References
structure references
Structure and Union References
subscripts
Subscripts
union references
Structure and Union References

pow
Library Functions (F.3.14)

powf
Library Functions (F.3.14)

Precedence
examples
Precedence and Associativity Rules in C

Precedence of operators
Precedence and Associativity Rules in C

Precision
Floating Constants

Preprocessing directives
Preprocessing Directives (F.3.13)

Preprocessor
changes
Preprocessor Changes

Primary expressions
Primary Expressions

Programming hints
Helpful Programming Hints

Promotions
arguments
Function Calls
arithmetic expressions
Type Promotion in Arithmetic Expressions
floating-point
Type Promotion in Arithmetic Expressions
integral
Type Promotion in Arithmetic Expressions
Integral Promotions

Prototyped function declarations
Function Calls

Prototyped functions
Prototyped Functions Summarized

Prototypes
Function Declarators and Prototypes
function
Function Prototypes
incompatible types
Function Prototypes
inconsistent
Function Prototypes

ptrdiff_t
Arrays and Pointers (F.3.7)

Punctuators
definition
Punctuators
list of
Punctuators

putenv function
getenv Function

Quad precision
Floating Point (F.3.6)

Qualified objects
Recommended Practices

Qualifiers
Type Qualifiers
access to volatile
Qualifiers (F.3.10)
volatile
Type Qualifiers

Ranges
floating points
Floating Point (F.3.6)
integers
Integers (F.3.5)

realloc
Memory Allocation

Recommendations
coding practices
Recommended Practices
things to avoid
Practices to Avoid

Reduction
example
Reduction Example
on user-defined type in C++
Reduction on User-Defined Types in C++

reduction clause
Restrictions on the Reduction Clause

Reduction operations
Parallel Reduction Operations in C and C++

Register
Function Declarators and Prototypes
-32 mode
Registers (F.3.8)
function declaration lists
External Function Definitions
optimized code
Registers (F.3.8)

Register keyword
Storage Class Specifiers

Register storage-class specifier
Registers (F.3.8)

Registers
Registers (F.3.8)

Relational operators
Relational Operators

Remainder
sign of
Integers (F.3.5)

remove function
on an open file
Streams and Files

rename function
Streams and Files

Reserved keywords
Keywords

Result type
definition
Usual Arithmetic Conversions

return statements
return Statement

Right shift
on negative integers
Integers (F.3.5)

Rounding
type used
Floating Point (F.3.6)

Routines
mp_setlock, mp_unsetlock, mp_barrier
barrier
mp_setlock, mp_unsetlock, mp_barrier
mp_barrier
mp_setlock, mp_unsetlock, mp_barrier
mp_block
mp_block and mp_unblock
mp_blocktime
mp_blocktime
mp_create
mp_setup, mp_create, and mp_destroy
mp_destroy
mp_setup, mp_create, and mp_destroy
mp_my_threadnum
mp_my_threadnum
mp_numthreads
mp_numthreads, mp_suggested_numthreads , mp_set_numthreads
mp_set_numthreads
mp_setup, mp_create, and mp_destroy
mp_numthreads, mp_suggested_numthreads , mp_set_numthreads
mp_set_slave_stacksize
mp_set_slave_stacksize
mp_setlock
mp_setlock, mp_unsetlock, mp_barrier
mp_setup
mp_setup, mp_create, and mp_destroy
mp_suggested_numthreads
mp_numthreads, mp_suggested_numthreads , mp_set_numthreads
mp_unblock
mp_block and mp_unblock
mp_unsetlock
mp_setlock, mp_unsetlock, mp_barrier
ussetlock
mp_setlock, mp_unsetlock, mp_barrier
usunsetlock
mp_setlock, mp_unsetlock, mp_barrier

Run-time library routines
See Routines

Scalar types
Derived Types

Scheduling
MP_SCHEDTYPE, CHUNK

Scheduling methods
between processors
Communicating Between Threads Through Thread Local Data
gang
MPC_GANG

Scope
block
Block Scope
changes
Scoping Differences
definition
Scope
file
File Scope
function
Function Scope
function prototype
Function Prototype Scope

Scoping
changes
Scoping Differences

Scoping restrictions
Scoping Restrictions

Selection statements
Selection Statements

setlocale
Library Functions (F.3.14)

Shift operators
Shift Operators

Shift states
Characters (F.3.4)

shmem
See mp_shmem

shmem routines
rules
Communicating Between Threads Through Thread Local Data

short
Integer and Floating Point Types

SIGCLD
mp_setup, mp_create, and mp_destroy

Signal-catching functions
valid codes
Signals

signals
default handling
Diagnostics
semantics
Signals
set of
Signals
SIGCLD
mp_setup, mp_create, and mp_destroy

Simple assignment
Assignment Using = (Simple Assignment)

Single precision
Conversions of Float and Double

size_t
sizeof Unary Operator
Arrays and Pointers (F.3.7)

sizeof
sizeof Unary Operator
Type Names
Arrays and Pointers (F.3.7)
type of result
sizeof Unary Operator

Sizes
floating points
Floating Point (F.3.6)
integers
Integers (F.3.5)

Slave processes
stack size
MP_SLAVE_STACKSIZE

Slave threads
blocking
mp_block and mp_unblock
mp_blocktime

special characters
Special Characters

Spin-wait lock example
Example of Implementing a Pure Spin-Wait Lock

sprocsp
mp_set_slave_stacksize

Stack size
mp_set_slave_stacksize
MP_SLAVE_STACKSIZE

Standard headers
Standard Headers

Standards
ANSI C
ANSI C

Statements
block
Compound Statement or Block
break
break Statement
compound
Compound Statement or Block
scope of declarations
Compound Statement or Block
continue
for Statement
continue Statement
do
do Statement
else
if Statement
expression
Expression Statement
for
for Statement
goto
goto Statement
if
if Statement
iteration
Iteration Statements
jump
Jump Statements
labeled
Labeled Statements
null
Expression Statement
return
return Statement
selection
Selection Statements
switch
Selection Statements
while
while Statement

static
function definitions
External Function Definitions

Static keyword
Storage Class Specifiers

Static storage duration
Storage Duration
Storage Class Specifiers

stdarg
Practices to Avoid
Function Declarators and Prototypes

stderr
Environment (F.3.2)

Storage class sizes
Integer and Floating Point Types
Integer and Floating Point Types

Storage class specifiers
Storage Class Specifiers

Storage duration
Storage Class Specifiers
auto
Storage Class Specifiers
automatic
Storage Duration
static
Storage Duration
Storage Class Specifiers

strerror function
strerror Function

String literals
Practices to Avoid
String Literals
Writable String Literals (F.5.5)
Primary Expressions
wide
String Literals
wide characters
Initialization of Aggregates

struct
Structure and Union Declarations
initialization
Initialization of Aggregates
members
restrictions
Structure and Union Declarations
namespace
changes
Name Space Changes

Structs
alignment
Structures, Unions, Enumerations, and Bitfields (F.3.9)

Structure
declaration
Structure and Union Declarations
indirect references
Indirect Structure and Union References
members
restrictions
Structure and Union Declarations
references
Structure and Union References

Structure designators
Recommended Practices

Structures
Structures, Unions, Enumerations, and Bitfields (F.3.9)
alignment
Structures, Unions, Enumerations, and Bitfields (F.3.9)
initialization
Initialization of Aggregates
padding
Structures, Unions, Enumerations, and Bitfields (F.3.9)

Subroutines
See Routines

Subscripts
in postfix expressions
Subscripts

switch statements
Selection Statements
switch Statement
labels
Labeled Statements
maximum number of case values
Statements (F.3.12)

Switches
Compiling ANSI Programs
-ansi
Compiling ANSI Programs
-xansi
Compiling ANSI Programs

Synchronization intrinsics
Performance Considerations
Synchronization Intrinsics

Synchronize operation
__synchronize
Atomic synchronize Operation

system function
system Function

Tabs
Lexical Conventions

Temporary files
Temporary Files
abort Function

Text stream
last line
Streams and Files
newline
Streams and Files

Text streams
writes on
Streams and Files

Thread
master
mp_my_threadnum
slave
mp_numthreads, mp_suggested_numthreads , mp_set_numthreads

Threads
and processors
Communicating Between Threads Through Thread Local Data

Time
availability
Preprocessing Directives (F.3.13)
clock function
Time Zones and the clock Function
daylight savings
Time Zones and the clock Function
local
Time Zones and the clock Function

Time zone
Time Zones and the clock Function

Token
definition
Lexical Conventions

Token concatenation
Token Concatenation

Tokens
classes of
Lexical Conventions
in -ansi mode
Token Concatenation
in -cckr mode
Token Concatenation

Traditional C
allocating storage
Changes in the Linkage of Identifiers
compiler option
Compiling Traditional C Programs
conversion rules
Integral Promotions
Traditional C Conversion Rules
enumeration constants
Name Space Changes
floating point
Conversions of Float and Double
function prototype error
Function Prototypes
identifiers
Meaning of Identifiers
incompatibilities
Function Declarators and Prototypes
linkage discrepancies
Linkage Discrepancies Between Traditional and ANSI C
name space discrepancies
Name Space Discrepancies Between Traditional and ANSI C
scope
Scoping Differences
scoping differences
Scoping Differences
unsigned preserving integer promotion
Conversions of Characters and Integers

Translation
Translation (F.3.1)

Trigraph sequences
Trigraph Sequences (ANSI C Only)

Truncation
direction of
Floating Point (F.3.6)
Floating Point (F.3.6)
pointer value
Cast Operators
type used
Floating Point (F.3.6)

tType qualifiers
__restrict
Qualifiers and Pointers

Type
Type Promotion and Floating Point Constants

Type names
Type Names

Type qualifiers
Type Qualifiers

Type specifiers
list of
Type Specifiers

typedef
Type Specifiers
Structure and Union Declarations
Storage Class Specifiers
Type Qualifiers
typedef

Types
Object Types
32-bit mode
Integer and Floating Point Types
64-bit mode
Integer and Floating Point Types
arithmetic
Derived Types
changes
Types and Type Compatibility
character
Character Types
compatibility
Types and Type Compatibility
Compatible Types
derived
Derived Types
differences
Integer and Floating Point Types
float
Conversions of Float and Double
floating
Conversion of Floating and Integral Types
floating-point
Integer and Floating Point Types
int
Additive Operators
integer
Integer and Floating Point Types
integral
Derived Types
Conversion of Floating and Integral Types
long double
Floating Constants
multibyte characters
Character Types
promotion in arithmetic expressions
Type Promotion in Arithmetic Expressions
promotion rules
Types and Type Compatibility
promotions
arguments
Argument Type Promotions
floating-point
Type Promotion in Arithmetic Expressions
integral
Type Promotion in Arithmetic Expressions
sizes
Integer and Floating Point Types
unsigned char
Character Types
variably modified
Declarations
void
void Type

TZ environment variable
Time Zones and the clock Function

Unary operators
Unary Operators

unblockproc
mp_blocktime

Underflow handling
Integer and Floating Point Exceptions

Underflow range errors
math functions
Library Functions (F.3.14)

union
Structure and Union Declarations
declaration
Structure and Union Declarations
indirect references
Indirect Structure and Union References
initialization
Initialization of Aggregates
members
restrictions
Structure and Union Declarations
namespace
changes
Name Space Changes
references
Structure and Union References

Unions
Structures, Unions, Enumerations, and Bitfields (F.3.9)
32-bit mode
Structures, Unions, Enumerations, and Bitfields (F.3.9)
64-bit mode
Structures, Unions, Enumerations, and Bitfields (F.3.9)
accessing members
Structures, Unions, Enumerations, and Bitfields (F.3.9)

unlock operation
Atomic lock-test-and-set Operation

unsigned char
Character Types
default
Characters (F.3.4)

unsigned integers
conversions
Conversion of unsigned Integers

usconfig
mp_setlock, mp_unsetlock, mp_barrier

-use_readwrite_const option
Writable String Literals (F.5.5)

User name space
Name Spaces

usinit
mp_setlock, mp_unsetlock, mp_barrier

ussetlock
mp_setlock, mp_unsetlock, mp_barrier

usunsetlock
mp_setlock, mp_unsetlock, mp_barrier

valid filenames
Streams and Files

Variable length array
as specifier for type declarator
Declarations

Variable length arrays
Array Declarators

Variables
float
Types and Type Compatibility

void
void Type
Function Declarators and Prototypes
conversions
Conversion of void Objects
pointers to
Conversion of Pointers
return statements
return Statement

Volatile
Type Qualifiers

volatile object
Recommended Practices

Volatile-qualified types
access to
Qualifiers (F.3.10)

Warnings
Guidelines for Using ANSI C

while statements
while Statement

White space
Lexical Conventions
Translation (F.3.1)

Wide characters
Characters (F.3.4)

Wide string literals
String Literals

Words
alignment
Structures, Unions, Enumerations, and Bitfields (F.3.9)
size
Structures, Unions, Enumerations, and Bitfields (F.3.9)

Work-sharing constructs
Parallel Regions

write()
Changes in Function Names

-xansi compiler option
external names and
Data Area Name Changes

-xansi switch
Compiling ANSI Programs

-Xlocal
Communicating Between Threads Through Thread Local Data

Zero-length files
Streams and Files

| operator
Bitwise Inclusive OR Operator

|| operator
Logical OR Operator

~ operator
Unary ! and ~ Operators

Prev Table of Contents 
Appendix C. Built-in Functions