HP C/iX Reference Manual (31506-90011)

Chapter 2 13

Lexical Elements

Identiﬁers

Finally, identiﬁers cannot have the same spelling as reserved words. For example, int

cannot be used as an identiﬁer because it is a reserved word. INT is a valid identiﬁer

because it has different case letters.

Identiﬁer Scope

The scope of an identiﬁer is the region of the program in which the identiﬁer has meaning.

There are four kinds of scope:

1. File Scope — Identiﬁers declared outside of any block or list of parameters have scope

from their declaration point until the end of the translation unit.

2. Function Prototype Scope — If the identiﬁer is part of the parameter list in a

function declaration, then it is visible only inside the function declarator. This scope

ends with the function prototype.

3. Block Scope — Identiﬁers declared inside a block or in the list of parameter

declarations in a function deﬁnition have scope from their declaration point until the

end of the associated block.

4. Function Scope — Statement labels have scope over the entire function in which they

are deﬁned. Labels cannot be referenced outside of the function in which they are

deﬁned. Labels do not follow the block scope rules. In particular, goto statements can

reference labels that are deﬁned inside iteration statements. Label names must be

unique within a function.

A preprocessor macro is visible from the #define directive that declares it until either the

end of the translation unit or an #undef directive that undeﬁnes the macro.

Identiﬁer Linkage

An identiﬁer is bound to a physical object by the context of its use. The same identiﬁer can

be bound to several different objects at different places in the same program. This

apparent ambiguity is resolved through the use of scope and name spaces. The term name

spaces refers to various categories of identiﬁers in C (see "Name Spaces" later in this

chapter for more information).

Similarly, an identiﬁer declared in different scopes or in the same scope more than once

can be made to refer to the same object or function by a process called linkage. There are

three kinds of linkage:

1. Internal — Within a single translation unit, each instance of an identiﬁer with

internal linkage denotes the same object or function.

2. External — Within all the translation units and libraries that constitute an entire

program, each instance of a particular identiﬁer with external linkage denotes the same

object or function.

3. None — Identiﬁers with no linkage denote unique entities.

If an identiﬁer is declared at ﬁle scope using the storage-class speciﬁer static, it has

internal linkage.

If an identiﬁer is declared using the storage-class speciﬁer extern, it has the same linkage

as any visible declaration of the identiﬁer with ﬁle scope. If there is no visible declaration

with ﬁle scope, the identiﬁer has external linkage.