The storage class specifier indicates linkage and storage duration. These attributes are discussed in “Disambiguating Names” in Chapter 4. Storage class specifiers have the following form:

The typedef specifier does not reserve storage and is called a storage-class specifier only for syntactic convenience. See “typedef”, for more information.

The following rules apply to the use of storage class specifiers:

Type specifiers are listed below. The syntax is as follows:

The following is a list of all valid combinations of type specifiers. These combinations are organized into sets. The type specifiers in each set are equivalent in all implementations. The arrangement of the type specifiers appearing in any set can be altered without effect.

In traditional C, the type long float is allowed and is equivalent to double; its use is not recommended. It elicits a warning if you are not in -cckr mode. Use of the type long double is not recommended in traditional C.

long long is not a valid ANSI C type, so a warning appears for every occurrence of it in the source program text in -ansi and -ansiposix modes.

Specifiers for structures, unions, and enumerations are discussed in “Structure and Union Declarations”, and “Enumeration Declarations”. Declarations with typedef names are discussed in “typedef”.

A structure is an object consisting of a sequence of named members. Each member can have any type. A union is an object that can, at a given time, contain any one of several members. Structure and union specifiers have the same form. The syntax is as follows:

The struct-decl-list is a sequence of declarations for the members of the structure or union. The syntax, in three possible forms, is as follows:

In the usual case, a struct-declarator is just a declarator for a member of a structure or union. A structure member can also consist of a specified number of bits. Such a member is also called a bitfield. Its length, a non-negative constant expression, is separated from the field name by a colon. “Bitfields”, are discussed at the end of this section.

The syntax for struct-declarator is as follows:

A struct or union cannot contain any of the following:

Within a structure, the objects declared have addresses that increase as the declarations are read left to right. Each non-field member of a structure begins on an addressing boundary appropriate to its type; therefore, there may be unnamed holes in a structure.

A union can be thought of as a structure whose members all begin at offset 0 and whose size is sufficient to contain any of its members. At most, one of the members can be stored in a union at any time.

A structure or union specifier of the second form declares the identifier to be the structure tag (or union tag) of the structure specified by the list. This type of specifier is one of the following:

struct identifier {struct-decl-list}
union identifier {struct-decl-list} 

A subsequent declaration can use the third form of specifier, one of the following:

struct identifier   
union identifier   

Structure tags allow definition of self-referential structures. Structure tags also permit the long part of the declaration to be given once and used several times.

The third form of a structure or union specifier can be used before a declaration that gives the complete specification of the structure or union in situations in which the size of the structure or union is unnecessary. The size is unnecessary in two situations: when a pointer to a structure or union is being declared and when a typedef name is declared to be a synonym for a structure or union. This, for example, allows the declaration of a pair of structures that contain pointers to each other.

The names of members of each struct or union have their own name space, and do not conflict with each other or with ordinary variables. A particular member name cannot be used twice in the same structure, but it can be used in several different structures in the same scope.

Names that are used for tags reside in a single name space. They do not conflict with other names or with names used for tags in an enclosing scope. This tag name space, however, consists of tag names used for all struct, union, or enum declarations. Therefore, the tag name of an enum may conflict with the tag name of a struct in the same scope. (See “Disambiguating Names” in Chapter 4.)

A simple but important example of a structure declaration is the following binary tree structure:

struct tnode {
char tword[20];
int count;
struct tnode *left;
struct tnode *right; 
}; 
struct tnode s, *sp; 

This structure contains an array of 20 characters, an integer, and two pointers to instances of itself. Once this structure has been declared, the next line declares a structure of type struct tnode ( s) and a pointer to a structure of type struct tnode (sp).

With these declarations,

A structure member can consist of a specified number of bits, called a bitfield. In strict ANSI C mode, bitfields should be of type int , signed int, or unsigned int. SGI C allows bitfields of any integral type, but warns for non-int types in -ansi and -ansiposix modes.

The default type of field members is int, but whether it is signed or unsigned int is defined by the implementation. Therefore, you should specify the signedness of bitfields when they are declared. In this implementation, the default type of a bitfield is signed.

The constant expression that denotes the width of the bitfield must have a value no greater than the width, in bits, of the type of the bitfield. An implementation can allocate any addressable storage unit (referred to in this discussion as simply a “unit”) large enough to hold a bitfield. If an adjacent bitfield will not fit into the remainder of the unit, the implementation defines whether bitfields are allowed to span units or whether another unit is allocated for the second bitfield. The ordering of the bits within a unit is also implementation-defined.

A bitfield with no declarator, just a colon and a width, indicates an unnamed field useful for padding. As a special case, a field with a width of zero (which cannot have a declarator) specifies alignment of the next field at the next unit boundary.

These implementation-defined characteristics make the use of bitfields inherently nonportable, particularly if they are used in situations where the underlying object may be accessed by another data type (in a union, for example).

In the SGI implementation of C, the first bitfield encountered in a struct is not necessarily allocated on a unit boundary and is packed into the current unit, if possible. A bitfield cannot span a unit boundary. Bits for bitfields are allocated from left (most significant) to right.

There are no arrays of bitfields. Because the address-of operator, &, cannot be applied to bitfields, there are also no pointers to bitfields.

Enumeration variables and constants have integral type. The syntax is as follows:

The identifiers in an enum-list are declared as int constants and can appear wherever such constants are allowed. If no enumerators with = appear, then the values of the corresponding constants begin at 0 and increase by 1 as the declaration is read from left to right. An enumerator with = gives the associated identifier the value indicated; subsequent identifiers continue the progression from the assigned value. Note that the use of = may result in multiple enumeration constants having the same integral value, even though they are declared in the same enumeration declaration.

Enumerators are in the ordinary identifiers name space (see “Name Spaces” in Chapter 4). Thus, an identifier used as an enumerator may conflict with identifiers used for objects, functions, and user-defined types in the same scope.

The role of the identifier in the enum-specifier is entirely analogous to that of the structure tag in a struct-specifier; it names a particular enumeration. For example,

enum color { chartreuse, burgundy, claret = 20, winedark }; 
...
enum color *cp, col; 
...
col = claret; 
cp = &col; 
...
if (*cp == burgundy) ...  

This example makes color the enumeration-tag of a type describing various colors, and then declares cp as a pointer to an object of that type, col. The possible values are drawn from the set {0,1,20,21}. The tags of enumeration declarations are members of the single tag name space, and thus must be distinct from tags of struct and union declarations.

Type qualifiers have the following syntax:

The same type qualifier cannot appear more than once in the same specifier list either directly or indirectly (through typedefs).

The value of an object declared with the const type qualifier is constant. It cannot be modified, although it can be initialized following the same rules as the initialization of any other object. (See the discussion in “Initialization”.) Implementations are free to allocate const objects, that are not also declared volatile, in read-only storage.

An object declared with the volatile type qualifier may be accessed in unknown ways or have unknown side effects. For example, a volatile object may be a special hardware register. Expressions referring to objects qualified as volatile must be evaluated strictly according to the semantics. When volatile objects are involved, an implementation is not free to perform optimizations that would otherwise be valid. At each sequence point, the value of all volatile objects must agree with that specified by the semantics.

The __restrict qualifier applies only to pointers and is discussed in “Qualifiers and Pointers”.

If an array is specified with type qualifiers, the qualifiers are applied to the elements of the array. If a struct or union is qualified, the qualification applies to each member.

Two qualified types are compatible if they are identically qualified versions of compatible types. The order of qualifiers in a list has no effect on their semantics.

The syntax of pointers allows the specification of qualifiers that affect either the pointer itself or the underlying object. Qualified pointers are covered in “Pointer Declarators”.

Declarators have the syntax shown below:

The grouping is the same as in expressions.

Pointer Declarators

Pointer declarators have the form:

pointer:

* type-qualifier-list opt * type-qualifier-listopt pointer

The following is an example of a declaration:

T D1

In this declaration, the identifier has type .. T, where the .. is empty if D1 is just a plain identifier (so that the type of x in int x is just int). Then, if D1 has the form *type-qualifier-list_opt D, the type of the contained identifier is ”.. (possibly-qualified) pointer to T.”

Qualifiers and Pointers

It is important to be aware of the distinction between a qualified pointer to a type and a pointer to a qualified type. In the declarations below, ptr_to_const is a pointer to const long:

const long *ptr_to_const; long * const const_ptr; volatile int * const const_ptr_to_volatile;

The long pointed to by ptr_to_const in the first declaration, cannot be modified by the pointer. The pointer itself, however, can be altered. In the second declaration, const_ptr can be used to modify the long that it points to, but the pointer itself cannot be modified. In the last declaration, const_ptr_to_volatile is a constant pointer to a volatile int and can be used to modify it. The pointer itself, however, cannot be modified.

The __restrict qualifier tells the compiler to assume that dereferencing the qualified pointer is the only way the program can access the memory pointed to by that pointer. Therefore, loads and stores through such a pointer are assumed not to alias with any other loads and stores in the program, except other loads and stores through the same pointer variable.

The following example illustrates the use of the __restrict qualifier:

float x[ARRAY_SIZE]; float *c = x; void f4_opt(int n, float * __restrict a, float * __restrict b) { int i; /* No data dependence across iterations because of __restrict */ for (i = 0; i < n; i++) a[i] = b[i] + c[i]; }

Pointer-related Command Options

The SGI C compiler supports the following two alias-related command-line switches that can be useful for improving performance:

-OPT:alias=restrict
	Implements the following semantics: memory operations dereferencing different named pointers in the program are assumed not to alias with each other, nor with any named scalar in the program. For example, if p and q are pointers, this option means that *p does not alias with *q, with p, or with any named scalar variable.
-OPT:alias=disjoint
	Implements the following semantics: memory operations dereferencing different named pointers in the program are assumed not to alias with each other, and in addition, different dereferencing depths of the same named pointer are assumed not to alias with each other. For example, if p and q are of type pointer to pointer, *p does not alias with *q, with **p, or with **q.

---

Note: With either switch enabled, programs violating the corresponding aliasing assumptions may be compiled incorrectly.

---

float fa[17], *afp[17]; 

static int x3d[3][5][7]; 

direct-declarator (parameter-type-listopt)
direct-declarator (identifier-listopt)
parameter-type-list:
parameter-list
parameter-list ,   ... 
parameter-list:
parameter-declaration
parameter-list , parameter-declaration
parameter-declaration:
declaration-specifiers declarator
declaration-specifiers abstract-declaratoropt
identifier-list:
identifier
identifier-list , identifier 

double foo(int *first, float second, ... ); 
int *fip(int a, long l, int (*ff)(float)); 

int i, *ip, f(), *fip(), (*pfi)(); 

In several contexts (for example, to specify type conversions explicitly by means of a cast, in a function prototype, and as an argument of sizeof), it is best to supply the name of a data type. This naming is accomplished using a “type name,” whose syntax is a declaration for an object of that type without the identifier.

The syntax for type names is as follows:

The type name created can be used as a synonym for the type of the omitted identifier. The syntax indicates that a set of empty parentheses in a type name is interpreted as function with no parameter information rather than as redundant parentheses surrounding the (omitted) identifier.

Examples of type names are shown in Table 7-1.

It is not always necessary to specify both the storage class and the type of identifiers in a declaration. The storage class is supplied by the context in external definitions, and in declarations of formal parameters and structure members. Missing storage class specifiers appearing in declarations outside of functions are assumed to be extern (see “External Name Changes” in Chapter 2, for details. Missing type specifiers in this context are assumed to be int. In a declaration inside a function, if a type but no storage class is indicated, the identifier is assumed to be auto. An exception to the latter rule is made for functions because auto functions do not exist. If the type of an identifier is “function returning < type>”, it is implicitly declared to be extern .

In an expression, an identifier followed by a left parenthesis (indicating a function call) that is not already declared is implicitly declared to be of type function returning int.

Declarations with the storage class specifier typedef do not define storage. A typedef has the following syntax:

An identifier appearing in a typedef declaration becomes a synonym for the type rather than becoming an object with the given type. For example, if the int type specifier in the following example were preceded with typedef, the identifier declared as an object would instead be declared as a synonym for the array type:

int intarray[10]]; 

This can appear as shown below:

typedef int intarray[10]; 

intarray could then be used as if it were a basic type, as in the following:

intarray ia;

In the following example, the last three declarations are legal. The type of distance is int, that of metricp is pointer to int, and that of z is the specified structure. The zp is a pointer to such a structure:

typedef int MILES, *KLICKSP; 
typedef struct { 
double re, im; 
} 
complex; 

MILES distance; 
extern KLICKSP metricp; 
complex z, *zp; 

The typedef does not introduce brand-new types, only synonyms for types that could be specified in another way. For instance, in the preceding example, distance is considered to have the same type as any other int object.

typedef declarations that specify a variably modified type have block scope. The array size specified by the variable length array type is evaluated at the time the type definition is declared and not at the time it is used as a type specifier in an actual declarator.

A declaration of an object or of an array of unknown size can specify an initial value for the identifier being declared. The initializer is preceded by = and consists of an expression or a list of values enclosed in nested braces:

There cannot be more initializers than there are objects to be initialized. All the expressions in an initializer for an object of static storage duration must be constant expressions (see “Primary Expressions” in Chapter 6). Objects with automatic storage duration can be initialized by arbitrary expressions involving constants and previously declared variables and functions, except for aggregate initialization, which can include only constant expressions.

Identifiers declared with block scope and either external or internal linkage (that is, objects declared in a function with the storage class specifier extern) cannot be initialized.

Variables of static storage duration that are not explicitly initialized are implicitly initialized to zero. The value of automatic and register variables that are not explicitly initialized is undefined.

When an initializer applies to a scalar (a pointer or an object of arithmetic type; see “Derived Types” in Chapter 4), it consists of a single expression, perhaps in braces. The initial value of the object is taken from the expression. With the exception of type qualifiers associated with the scalar, which are ignored during the initialization, the same conversions as for assignment are performed.

int x[] = { 1, 3, 5 }; 

float y[4][3] = 
{
      { 1, 3, 5 },
      { 2, 4, 6 },
      { 3, 5, 7 }, 
}; 

float y[4][3] = 
{
      1, 3, 5, 2, 4, 6, 3, 5, 7 
}; 

float y[4][3] = {
      { 1 }, { 2 }, { 3 }, { 4 } 
}; 

union dc_u {
      double d;
      char *cptr; 
}; 
 
union dc_u dc0 = { 4.0 };

char msg[] = "Syntax error on line %s\n";