A character set defines the valid characters that can be used in source programs or interpreted when a program is running. The source character set is the set of characters available for the source text. The execution character set is the set of characters available when executing a program. The source character set does not necessarily match the execution character set; for example, when the execution character set is not available on the devices used to produce the source code.

Different character sets exist; for example, one character set is based on the American Standard Code for Information Interchange (ASCII) definition of characters, while another set includes the Japanese kanji characters. The character set in use makes no difference to the compiler; each character simply has a unique value. C treats each character as a different integer value. The ASCII character set has fewer than 255 characters, and these characters can be represented in 8 bits or less. However, in some extended character sets, so many characters exist that some characters' representation requires more than 8 bits. A special type was created to accommodate these larger characters, called the wchar_t(or wide character) type. Section 1.9.3.1, “Wide Characters” discusses wide characters further.

In character constants and string literals, characters from the execution character set can also be represented by character or numeric escape sequences. Section 1.9.3.3, “Character Escape Sequences” and Section 1.9.3.4, “Numeric Escape Sequences” describe these escape sequences.

The ASCII execution character set also includes the following control characters:

The null character is a byte or wide character with all bits set to 0. It is used to mark the end of a character string. Section 1.8, “String Literals” discusses character strings in more detail.

The new-line character splits the source character stream into separate lines for greater legibility and for proper operation of the preprocessor.

#define ERROR_TEXT "Your entry was outside the range of \
0 to 100." 

#define ERROR_TEXT "Your entry was outside the range of 0 to 100."

printf ("Your entry was outside the range of "
        "0 to 100.\n");

The maximum logical line length is 32,767 characters.

printf ("Any questions???/n");

printf ("Any questions?\n");

An identifier without external linkage has at most 32,767 significant characters. An identifier with external linkage has 31 significant characters. Section 2.8, “Linkage” describes linkage in more detail. Case is not significant in external identifiers, unless the #pragma names or /NAMES command-line qualifier is used.

Identifiers that differ within their significant characters are different identifiers. If two or more identifiers differ in nonsignificant characters only, they are treated as the same identifier.

Universal character names provide a way to name other characters. They can be used in identifiers, character constants, and string literals to designate characters that are not in the basic character set.

A universal character name begins with a \u or \U and is followed by either four or eight hexadecimal digits.

The universal character name \Unnnnnnnn designates the character whose eight-digit short identifier (as specified by ISO/IEC 10646) is nnnnnnnn) Similarly, the universal character name \unnnn designates the character whose four-digit short identifier is nnnn (and whose eight-digit short identifier is 0000nnnn).

A universal character name cannot specify a character whose short identifier is less than 00A0, other than 0024 ($), 0040 (@), or 0060 ('), nor one in the range D800 through DFFF inclusive.)

See Appendix F, Universal Character Names for Identifiers for a list of valid universal character names.

Except within a character constant, string literal, or a comment, the /* character combination introduces a comment and the */ character combination ends a comment. The contents of such a comment are examined only to identify multibyte characters and to find the characters */ to terminate it.

Alternatively, the // character combination introduces a comment that includes all multibyte characters up to, but not including, the next new-line character. The contents of such a comment are examined only to identify multibyte characters and to find the terminating new-line character.

Comments cannot be nested; once a comment is started, the compiler treats the first occurrence of */ as the end of the comment.

#if 0
/*  This code is excluded from execution because ...  */
code_to_be_excluded ();
#endif

See Chapter 8, Preprocessor Directives and Predefined Macros for more information on the preprocessing directives #if and #endif.

Comments cannot span source files. Within a source file, comments can be of any length and are interpreted as white space by both the compiler and the preprocessor.

"a//b"                   // four-character string literal
#include "//e"           // undefined behavior
// */                    // comment, not syntax error
f = g/**//h;             // equivalent to f = g / h;
//\
i();                     // part of a two-line comment
/\
/ j();                   // part of a two-line comment
#define glue(x,y) x##y
glue(/,/) k();           // syntax error, not comment
/*//*/ l();              // equivalent to l();
m = n//**/o
+ p;                     // equivalent to m = n + p;

C defines several keywords, each with special meaning to the compiler. Keywords identify statement constructs and specify basic types and storage classes. Keywords cannot be used as identifiers and cannot be declared.

In addition to the keywords listed in Table 1.3, “Keywords”, the compiler reserves all identifiers that begin with two underscores (__) or with an underscore followed by an uppercase letter. User variable names must never begin with one of these sequences.

_align
globaldef
globalref
globalvalue
noshare
readonly
variant_struct
variant_union

inline
restrict

#define int short

Here, the keyword int has been redefined as short, which causes all data objects declared with the int data type to be stored as short objects.

x = -b;          /*   Unary minus operator   */
y = a - c;       /*   Binary minus operator  */

Operators with three operands are called ternary operators.

All operators are ranked by precedence, a ranking system determining which operators are evaluated before others in a statement. See Chapter 6, Expressions and Operators for information on what each operator does and for the rules of operator precedence.

!  %  ^  &  *  -  +  =  ~  |  .  <  >  /  ?  :  ,  [  ]  (  )  #

++    --    ->    <<     >>     <=    >=    ==    !=    *=    /=
%=    +=    -=    <<=    >>=    &=    ^=    |=    ##    &&     ||

The # and ## operators can only be used in preprocessor macro definitions. See Chapter 8, Preprocessor Directives and Predefined Macros for more information on predefined macros and preprocessor directives.

The sizeof operator determines the size of a data type. See Chapter 6, Expressions and Operators for more information on the sizeof operator.

x =-3;

x - 3

The error-checking compiler option provides a warning message when the old form of compound assignment operators is encountered.

<limits.h>

char a[7];

char x[4] = {'H', 'i', '!', '0'  }; 

int f (x,y)

int *x;

char x[4] = { 'H', 'i', '!', '0'};

labela: if (x == 0) x += 1;

char x[4] = { "Hi!" };

x += 1;

int f ( int y, ...) 

#include
<limits.h>

char x = 'x';

char x[] = "Hi!";

Some characters can be used either as a punctuator or as an operator, or as part of an operator. The context of the occurrence specifies the meaning. Punctuators usually delineate a specific type of C construct, as shown in Table 1.4, “Punctuators”.

Strings are sequences of zero or more characters. A character string literal is a sequence of zero or more multibyte characters enclosed in double quotation marks, as in "xyz". String literals can include any valid character, including white-space characters and character escape sequences. A wide string literal is the same, except prefixed by the letter L. Once a string is stored as a string literal, modification of the string leads to undefined results.

char x[] = "ABC";

String literals are typically stored as arrays of type char (or wchar_t if prefaced with an L), and have static storage duration.

char s[] = "Hello!";

The character array s is initialized with the characters specified in the double quotation marks, and terminated with a null character (\0). The null character marks the end of each string, and is automatically concatenated to the end of the string literal by the compiler. Adjacent string literals are automatically concatenated (with a single null character added at the end) to reduce the need for the line continuation character (the backslash at the end of a line).

Normal string literals and wide string literals can be concatenated, in which case the normal strings get promoted to wide strings, and a wide-string result is produced.

""            /*  Here's a string with only the null character */

"You can have many characters in a string."

"\"You can mix characters and escape sequences.\"\n"

"Long lines of text can be continued on the next line \
by using the backslash character at the end of a line."

"Or, long lines of text can be continued by using "
"ANSI's concatenation of adjacent string literals."

"\'\n"        /*  Only escape sequences are in this string    */

To determine the length of a given string literal (not including the null character), use the strlen function. See Chapter 9, The ANSI C Standard Library for more information on other library routines available for string manipulation.

The following sections describe these constants.

The value of any constant must be within the range of representable values for the specified type. Regardless of its type, a constant is a literal or symbolic value that does not change. A constant is also an rvalue, as defined in Section 2.14, “lvalues and rvalues”.

char alpha = 'A';

wchar_t wc = L'A';
wchar_t wmc = L'ABCD';
wchar_t *wstring = L"Hello!";
wchar_t *x = L"Wide";
wchar_t z[] = L"wide string";

printf ("\t\aReady\?\n");

     Ready?

#define NUL '\0'   /*  Defines logical null character   */

char x[] = {'\110','\145','\154','\154','\157','\41','\0'};
                    /*  Initializes x with "Hello!"  */

char a[] = "\xff" "f";
char a[] = {'\xff', 'f', '\0'};

Header files are text files included in a source file during compilation. To include a header file in a compilation, the #include preprocessor directive must be used in the source file. See Chapter 8, Preprocessor Directives and Predefined Macros for more information on this directive. The entire header file, regardless of content, is substituted for the #include preprocessor directive.

A header file can contain other #include preprocessor directives to include another file. You can nest #include directives to any depth.

Header files can include any legal C source code. They are most often used to include external variable declarations, macro definitions, type definitions, and function declarations. Groups of logically related functions are commonly declared together in a header file, such as the C library input and output functions listed in the stdio.h header file. Header files traditionally have a .h suffix (stdio.h, for example).

The names of header files must not include the ' , \ , " , or /* characters, because the use of these punctuation characters in a header file is undefined.

#include <math.h>   /* or */
#include "local.h"

Chapter 8, Preprocessor Directives and Predefined Macros explains the difference between the two formats. The algorithm the compiler uses for finding the named files is discussed in Section B.37, “Source File Inclusion (§3.8.2)”. Chapter 9, The ANSI C Standard Library describes the library routines in each of the ANSI standard header files.

The ANSI C standard suggests several environmental limits on the use of the C language. These limits are an effort to define minimal standards for a conforming implementation of a C compiler. For example, the number of significant characters in an identifier is implementation-defined, with a minimum set required by the ANSI C standard.

The standard also includes several numerical limits that restrict the characteristics of integral and floating-point types. For the most part, these limits will not affect your use of the C language or compiler. However, for unusually large or unusually constructed programs, certain limits can be reached. The ANSI standard contains a list of minimum limits, and your platform-specific VSI C documentation contains the actual limits used in VSI C.

A block in C is a section of code surrounded by braces { }. Understanding the definition of a block is very important to understanding many other C concepts, such as scope, visibility, and external or internal declarations.

main ()
{              /*  This brace marks the beginning of the outer block  */
   int x;
   if (x!=0)
   {           /*  This brace marks the beginning of the inner block */
      x = x++;
      return x;
   };          /*  This brace marks the end of the inner block        */
}              /*  This brace marks the end of the outer block        */

A block is also a form of a compound statement; a set of related C statements enclosed in braces. Declarations of objects used in the program can appear anywhere within a block and affect the object's scope and visibility. Section 2.3, “Scope” discusses scope; Section 2.4, “Visibility” discusses visibility.

A compilation unit is C source code that is compiled and treated as one logical unit. The compilation unit is usually one or more entire files, but can also be a selected portion of a file if, for example, the #ifdef preprocessor directive is used to select specific code sections. Declarations and definitions within a compilation unit determine the scope of functions and data objects.

Files included by using the #include preprocessor directive become part of the compilation unit. Source lines skipped because of the conditional inclusion preprocessor directives are not included in the compilation unit.

Compilation units are important in determining the scope of identifiers, and in determining the linkage of identifiers to other internal and external identifiers. Section 2.3, “Scope” discusses scope. Section 2.8, “Linkage” discusses linkage.

Programs composed of more than one compilation unit can be separately compiled, and later linked to produce the executable program. A legal C compilation unit consists of at least one external declaration, as defined in Section 4.3, “External Declarations”.

A translation unit with no declarations is accepted with a compiler warning in all modes except for the strict ANSI standard mode.

An enumeration constant's scope begins at the defining enumerator in an enumerator list. The scope of a statement label includes the entire function body. The scope of any other type of identifier begins at the identifier itself in the identifier's declaration. See the following sections for information on when an identifier's scope ends.

int off = 5;     /*  Declares (and defines) the integer
                        identifier off.                           */
main ()
{
   int on;       /*  Declares the integer identifier on.          */
   on = off + 1; /*  Uses off, declared outside the function
                     block of main.  This point of the
                     program is still within the
                     active scope of off.                         */
   if (on<=100)
   {
     int off = 0;/*  This declaration of off creates a new object
                     that hides the former object of the same name.
                     The scope of the new off lasts through the
                     end of the if block.                         */
     off = off + on;
     return off;
   }
}

int blue = 5;                /*  blue: file scope            */
main ()
{
    int x = 0 , y = 0;       /*  x and y: block scope        */
    int red = 10;            /*  red: block scope            */
    x = red + blue;
}

int func1(int x, int y, int z)
{
  label:  x += (y + z);   /*  label has function scope        */
  if (x > 1) goto label;
}
int func2(int a, int b, int c)
{
  if (a > 1) goto label; /*  illegal jump to undefined label */
}

int students ( int david, int susan, int mary, int john );

An identifier is visible only within a certain region of the program. An identifier has visibility over its entire scope, unless a subsequent declaration of the same identifier in an enclosed block overrides, or hides, the previous declaration. Visibility affects the ability to access a data object or other identifier, because an identifier can be used only where it is visible.

Once an identifier is used for a specific purpose, it cannot be used for another purpose within the same scope, unless the second use of the identifier is in a different name space. Section 2.15, “Name Spaces” describes the name space restrictions. For example, declarations of two different data objects using the same name as an identifier is illegal within the same scope.

When the scope of one of two identical identifiers is contained within the other (nested), the identifier with inner scope remains visible, while the identifier with wider scope becomes hidden for the duration of the inner identifier's scope.

#include <math.h>
int number;        /*  number is declared as an integer variable  */

main ()
{
 float x;
 float number;     /*  This declaration of number occurs in an inner
                       block, and "hides" the outer declaration.
                       The inner declaration creates a new object */
 x = sqrt (number);/*  x receives a floating-point value          */
}

The actual order in which expressions are evaluated is not specified for most of the operators in C. Because this sequence of evaluation is determined within the compiler depending on context, some unexpected results may occur when using certain operators. These unexpected results are caused by side effects.

Any operation that affects an operand's storage has a side effect. Side effects can be deliberately induced by the programmer to produce a desired result; in fact, the assignment operator depends on the side effect of altered storage to do its job. C guarantees that all side effects of a given expression will be completed by the next sequence point in the program. Sequence points are checkpoints in the program at which the compiler ensures that operations in an expression are concluded.

These operations do guarantee the order, or sequence, of evaluation (expr1), expr2, and expr3 are expressions). For each of these operators, the evaluation of expression expr1 is guaranteed to occur before the evaluation of expression expr2 (or expr3, in the case of the conditional expression).

int x[4] = { 0, 0, 0, 0 };
int i = 1;
x[i] = i++;

If the increment of i occurs before the subscript is evaluated, the value of x[2] is 1. If the subscript is evaluated first, the value of x[1] is 1.

int y = 0;
int z = 0;
int x = 0;

int f1(int s)
   {
     printf ("Now in f1\n");
     y += 7;        /*  Storage of y affected   */
     return y;
    }

int f2(int t)
   {
     printf ("Now in f2\n");
     z += 3;        /*  Storage of z affected   */
     return z;
    }


main ()
{
x = f1(y) + f2(z);     /*  Undefined calling order   */
}

The printf functions can be executed in any order even though the value of x will always be 10.

extern int x[];

struct s
  { struct t *pt };  /* Incomplete structure declaration  */
.
.
.
struct t
   { int a;
     float *ps };    /*  Completion of structure t        */

The void type is a special case of an incomplete type. It is an incomplete type that cannot be completed, and is used to signify that a function returns no value. Section 3.5, “void Type” has more information on the void type.

Composite Type

int f(int (*) (), double (*) [3]);
int f(int (*) (char *), double (*)[]);

int f(int (*) (char *), double (*)[3]);

The previous composite type rules apply recursively to types derived from composite types.

When more than one declaration of the same object or function is made, linkage is made. The linked declarations can be in the same scope or in different scopes. Externally linked objects are available to any function in any compilation unit used to create the executable file. Internally linked objects are available only to the compilation unit in which the declarations appear.

Identifiers other than data objects and functions have no linkage. An identifier declared as a function parameter also has no linkage.

extern int x;          /*  External linkage                        */
static int y;          /*  Internal linkage                        */
register int z;        /*  Illegal storage-class declaration       */

main ()                /*  Functions default to external linkage   */
{
    int w;             /*  No linkage                              */
    extern int x;      /*  External linkage                        */
    extern int y;      /*  Internal linkage                        */
    static int a;      /*  No linkage                              */
}

void func1 (int arg1)  /*  arg1 has no linkage                     */
{ }

In VSI C, a message is issued if the same object is declared with both internal and external linkage.

A declaration of an identifier with file scope, no initializer, and either no storage-class specifier or the static storage-class specifier is a tentative definition. The tentative definition only applies if no other definition of the object appears in the compilation unit, in which case all tentative definitions for an object are treated as if there were only one file scope definition of the object, with an initializer of zero.

If a definition for a tentatively defined object is used later in the compilation unit, the tentative definition is treated as a redundant declaration of the object. If the declaration of an identifier for an object is a tentative definition and has internal linkage, the declared type cannot be an incomplete type. Section 2.8, “Linkage” discusses linkage.

int i1 = 1;    /* Standard definition with external linkage      */
int i4;        /* Tentative definition with external linkage     */
static int i5; /* Tentative definition with internal linkage     */
int i1;        /* Valid tentative definition, refers to previous */
               /* i1 declaration                                 */

An object's storage class determines its availability to the linker and its storage duration. An object with external or internal linkage, or with the storage-class specifier static, has static storage duration, which means that storage for the object is reserved and initialized to 0 only once, before main begins execution. An object with no linkage and without the storage-class specifier static has automatic storage duration; for such an object, storage is automatically allocated on entry to the block in which it is declared, and automatically deallocated on exiting from the block. An automatic object is not initialized.

When applied to functions, the storage-class specifier extern makes the function visible from other compilation units, and the storage-class specifier static makes the function visible only to other functions in the same compilation unit. For example:static int tree(void);

The following sections describe these storage classes.

auto int a;        /*  Illegal – auto must be within a block  */

main ()
{
    auto int b;               /*  Valid auto declaration   */
    for (b = 0; b < 10; b++)
      {
        auto int a = b + a;   /*   Valid inner block declaration    */
      }
}

The first three modifiers listed are recognized as valid keywords in all compiler modes on all platforms. They are in the namespace reserved to the C implementation, so it is not necessary to allow them to be treated as user-declared identifiers. They have the same effects on all platforms.

extern  noshare  int  x;

   /*  Or, equivalently…  */

int  noshare  extern  x;

However, placing the storage-class specifier anywhere other than first is obsolescent.

The following sections describe each of the VSI C storage-class modifiers.

 __inline [type]  function_definition

/* prototype */

 __inline int x (float y);


/* definition */
 __inline int x (float y)

{
   return (1.0);
}

$ type t.h
int my_max (int x, int y)
{
    if (x >= y)
        return (x);
    else
        return (y);
}
$
$ type a.c
#include "t.h"

main()
{
    int a =1;
    int b=2;

    func1();
    my_max(func1(a,b),20);
}
$
$ type b.c
#include "t.h"

void func1(int p1, int p2)
{
    my_max(p1,p2);
}
$
$ link a,b
%LINK-W-MULDEF, symbol MY_MAX multiply defined
        in module B file DISK$:[TEST.TMP]B.OBJ;4

static int my_max (int x, int y)
{
    if (x >= y)
        return (x);
    else
        return (y);
}

inline int my_max (int x, int y)
{
    if (x >= y)
        return (x);
    else
        return (y);
}

 __forceinline [type]  function_definition

int   __align( QUADWORD )  data;
int   __align( quadword )  data;
int   __align( 3 )  data;

Tags can be used with structures, unions, or enumerated types as a means of referring to the structure, union, or enumerated type elsewhere in the program. Once a tag is included in the declaration of a structure, union, or enumerated type, it can specify the declared structure, union, or enumerated type anywhere the declaration is visible.

struct tnode {                 /*  Initial declaration –              */
                               /*  tnode is the structure tag         */
 int count;
 struct tnode *left, *right;   /*  tnode's members referring to tnode */
 union datanode *p;            /*  forward reference to union type is
                                   declared below                     */
};


union datanode {               /*  Initial declaration –              */
                               /*  datanode is the union tag          */
 int ival;
 float fval;
 char *cval;
} q = {5};


enum color { red, blue, green };/*  Initial declaration –             */
.                               /*  color is the enumeration tag      */
.
.
struct tnode x;                /*   tnode tag is used to declare x    */
enum color z = blue;           /*   color tag declares z to be of
                                    type color;  z is also
                                    initialized to blue               */

As shown in the previous example, once a tag is declared it can be used to reference other structure, union, or enumerated type declarations in the same scope without fully redefining the object.

struct s;            /*  Tag s used in incomplete type declaration */
struct t {
  struct s *p;
};
struct s { int i; };/*  struct s definition completed              */

Section 2.6, “Incomplete Type” describes the concept of an incomplete type.

struct tag;

union tag;

These declarations specify a structure or union type and declare a tag visible only within the scope of the declaration. The declaration specifies a new type distinct from any other type with the same tag in an enclosing scope (if any).

struct s1 { struct s2 *s2p; /*...*/ };  /* D1  */
struct s2 { struct s1 *s1p; /*...*/ };  /* D2  */

struct s2;

This declares a new tag s2 in the inner scope; the declaration D2 then completes the specification of the type.

if (x > 0)
   {
     y += 1;
   }
x = *y;        /*  The value pointed to by y is assigned to x   */

The identifiers x and y are objects with allocated storage. The pointer to y holds an lvalue.

[]
*
->

The dot operator ( . ) can, and usually does, produce an lvalue but it does not have to do so. For example, f().m is not an lvalue.

A modifiable lvalue is an lvalue that does not have array type, an incomplete type, a const-qualified type, or, if it is a structure or union, has no member with const-qualified type.

Name spaces are identifier classifications based on the context of the identifier's use in the program. Name spaces allow the same identifier to simultaneously stand for an object, statement label, structure tag, union member, and enumeration constant. Simultaneous use of an identifier in the same scope for two different entities without ambiguity is possible only if the identifiers are in different name spaces. The context of the identifier's use resolves the ambiguity over which of the identically named entities is desired.

For example, the identifier flower can be used in one block to stand for both a variable and an enumeration tag, because variables and tags are in different name spaces. Subsequently, an inner block can redefine the variable flower without disturbing the enumeration tag flower. Therefore, when using the same identifier for various purposes, analyze the name space and scope rules governing the identifier. Section 2.3, “Scope” presents the scope rules.

A structure, union, and enumeration member name can be common to each of these objects at the same time. The use of the structure, union, or enumeration name in the reference to the member resolves any ambiguity about which identifier is meant. However, the structure, union, or enumeration tag must be unique, since the tags of these three object types share the same name space.

The fourth step is called preprocessing, and is handled by a separate unit of the compiler. Each preprocessor directive appears on a line beginning with a pound sign (#); white space may precede the pound sign. These lines are syntactically independent from the rest of the C source file, and can appear anywhere in the source file. Preprocessor directive lines terminate at the end of the logical line.

It is possible to preprocess a source file without actually compiling the program (see your platform-specific VSI C documentation for the available compiler options.) Chapter 8, Preprocessor Directives and Predefined Macros discusses the preprocessing directives.

In several contexts a type name can or must be specified without an identifier. For example, in a function prototype declaration, the parameters of the function can be declared only with a type name. Also, when casting an object from one type to another, a type name is required without an associated identifier. (Section 6.4.6, “The Cast Operator” has information on casting, and Section 5.5, “Function Prototypes” has information on function prototypes.) This is accomplished using a type name, which is a declaration for a function or object which omits the identifier.

Table 2.2, “Type Name Examples” also provides good examples of abstract declarators. An abstract declarator is a declarator without an identifier. The characters following the int type name form an abstract declarator in each case. The *,[], and ( ) characters all indicate a declarator without naming a specific identifier.

Derived types can require more memory space.

See your platform-specific VSI C documentation for the sizes of implementation-defined data types.

The following sections describe these derived types.

A derived type is formed by using one or more basic types in combination. Using derived types, an infinite variety of new types can be formed. The array and structure types are collectively called the aggregate types. Note that the aggregate types do not include union types, but a union may contain an aggregate member

void function1 ();

int uppercase(int lc)
{
  int uc = lc + 0X20;
  return uc;
}

int *p;          /*  p is a pointer to an int type                 */
double *q();     /*  q is a function returning a pointer to an
                     object of type double                         */
int (*r)[5];     /*  r is a pointer to an array of five elements   */
                 /*  (r holds the address to the first element of
                     the array)                                    */
const char s[6]; /*  s is a const-qualified array of 6 elements    */

char x[] = "Hi!"   /*  Declaring an array x   */;

int x[];

a[0][0], a[0][1], a[0][2], a[1][0], a[1][1], a[1][2]

struct employee { char name[30]; int age; int empnumber; };
struct employee ed, mary;

/*  This is invalid. */
struct employee {
  char name[30];
  struct employee div1;       /*  This is invalid. */

  int *f();                   /*  This is also invalid. */

};

struct employee {
  char name[30];
  struct employee *div1;/*  Member can contain pointer to employee
                            structure.                             */
  int (*f)();           /*  Pointer to a function returning int    */
};

struct {
  int a;
  struct {
    int a;  /* This 'a' refers to a different object
               than the previous 'a'               */

  } nested;

};

union {
  int a;

  union foo {

    int a;  /* This 'a' refers to a different object
               than the previous 'a'                */

  } nested;

};

union name {
  double dvalue;
  struct x { int value1; int value2; };
  float fvalue;
} alberta;
alberta.dvalue = 3.141596;
/* Assigns the value of pi to the union object */

/*
    Assume that `node' is a typedef_name for objects for which
    information has been entered into a hash table;

    `hash_entry' is a structure describing an entry in the hash table.
    The member `hash_value' is a pointer to the relevant `node'.
 */
typedef struct hash_entry
{
   struct hash_entry *next_hash_entry;
   node   *hash_value;
   /* ... other information may be present ... */
} hash_entry;

extern hash_entry *hash_table [512];

/*
    'hash_pointer' is a union whose members are a pointer to a
    'node' and a structure containing three bit fields that
    overlay the pointer value.  Only the second bit field is
    being used, to extract a value from the middle
    of the pointer to be used as an index into the hash table.
    Note that nine bits gives a range of values from 0 to 511;
    hence, the size of 'hash_table' above.
 */
typedef union
{
   node *node_pointer;
   struct
   {
    unsigned : 4;
    unsigned  index : 9;
    unsigned :19;
   } bits;
} hash_pointer;

The void type is an incomplete type that cannot be completed.

void message(void)
{
  printf ("Stop making sense!");
}

void memcopy (void *dest, void *source, int length);

A pointer to the void type has the same representation and alignment requirements as a pointer to a character type. The void * type is a derived type based on void.

int tree(void);

void main()
{
  int i;

  for (; ; (void)tree()){...}  /* void cast is valid                  */

  for (; (void)tree(); ;){...} /* void cast is NOT valid, because the */
                               /* value of the second expression in a */
                               /* for statement is used               */

  for ((void)tree(); ;) {...}  /* void cast is valid                  */

}

A void expression has no value, and cannot be used in any context where a value is required.

An enumerated type is used to specify the possible values of an object from a predefined list. Elements of the list are called enumeration constants. The main use of enumerated types is to explicitly show the symbolic names, and therefore the intended purpose, of objects whose values can be represented with integer values.

enum colors { black, red, blue, green, white } background_color;

background_color = white;

enum colors { black = 5, red = 10, blue, green = 7, white = green+2 };

Here, black equals the integer value 5, red = 10, blue = 11, green = 7, and white = 9. Note that blue equals the value of the previous constant (red) plus one, and green is allowed to be out of sequential order.

Because the ANSI C standard is not strict about assignment to enumerated types, any assigned value not in the predefined list is accepted without complaint.

Type qualifiers were introduced by the ANSI C standard to, in part, give you greater control over the compiler's optimizations. The const and volatile type qualifiers can be applied to any type. The __restrict type qualifier can be applied only to pointer types.

Note that because the __restrict type qualifier is not part of the 1989 ANSI C standard, this keyword has double leading underscores. Version C99 of the C standard adopted the keyword restrict with the same semantics described in this section.

The use of const gives you a method of controlling write access to an object, and eliminates potential side effects across function calls involving that object. This is because a side effect is an alteration of an object's storage and const prohibits such alteration.

Use volatile to qualify an object that can be changed by other processes or hardware. The use of volatile disables optimizations with respect to referencing the object. If an object is volatile qualified, it may be changed between the time it is initialized and any subsequent assignments. Therefore, it cannot be optimized.

int f( const int a, int b)   /*  a is const qualified; b is not  */

When using a type qualifier with an array identifier, the elements of the array are qualified, not the array type itself.

const struct s { int mem; } cs = { 1 };
struct s ncs;                        /* ncs is modifiable         */
typedef int A[2][3];
const A a = {{4, 5, 6}, {7, 8, 9}};  /*  array of array of const  */
                                     /*  int's                    */
int *pi;
const int *pci;

ncs = cs;            /*  Valid                                    */
cs = ncs;            /*  Invalid, cs is const-qualified           */
pi = &ncs.mem;       /*  Valid                                    */
pi = &cs.mem;        /*  Violates type constraints for = operator */
pci = &cs.mem;       /*  Valid                                    */
pi = a[0];           /*  Invalid; a[0] has type "const int *"     */

const int x = 44;   /*  const qualification of int type.
                        The value of x cannot be modified. */
const int *z;       /*  Pointer to a constant integer.
                        The value in the location pointed
                        to by z cannot be modified.        */
int * const ptr;    /*  A constant pointer, a pointer
                        that will always point to the
                        same location                      */
const int *const p; /*  A constant pointer to a constant
                        integer: neither the pointer or
                        the integer can be modified.       */
const const int y;  /*  Illegal - redundant use of const   */

typedef enum {int_kind, float_kind, double_kind} kind;
void foo(void *ptr, kind k) {
    switch (k) {
    case int_kind:
        printf("%d", *(__unaligned int *)ptr);
        break;
    case float_kind:
        printf("%f", *(__unaligned float *)ptr);
        break;
    case double_kind:
        printf("%f", *(__unaligned double *)ptr);
        break;
    }
}

/* Sample implementation of memmove */

   void *memmove(void *s1, const void *s2, size_t n) {
           char * t1 = s1;
           const char * t2 = s2;
           char * t3 = malloc(n);
           size_t i;
           for(i=0; i<n; i++) t3[i] = t2[i];
           for(i=0; i<n; i++) t1[i] = t3[i];
           free(t3);
           return s1;
   }


/* Sample implementation of memcpy */

   void *memcpy(void *s1, const void *s2, size_t n);
           char * t1 = s1;
           const char * t2 = s2;
           while(n -> 0) *t1++ = *t2++;
           return s1;
   }

/* memcpy between rows of a matrix */

void f1(void) {
        extern char a[2][N];
        memcpy(a[1], a[0], N);
}

/* memcpy between halves of an array */

void f2(void) {
        extern char b[2*N];
        memcpy(b+N, b, N);
}

void *memcpy(void * __restrict s1, const void * __restrict s2, size_t n);

/* File Scope Restricted Pointer */

float * __restrict a, * __restrict b;
float c[100];

int init(int n) {
    float * t = malloc(2*n*sizeof(float));
    a = t;       /* a refers to 1st half. */
    b = t + n;   /* b refers to 2nd half. */
   }

/* Restricted pointer function parameters */

float x[100];
float *c;

void f3(int n, float * __restrict a, float * const b) {
    int i;
    for ( i=0; i<n; i++ )
        a[i] = b[i] + c[i];
}
void g3(void) {
    float d[100], e[100];
    c = x; f3(100,   d,    e); /* Behavior defined.   */
           f3( 50,   d, d+50); /* Behavior defined.   */
           f3( 99, d+1,    d); /* Behavior undefined. */
    c = d; f3( 99, d+1,    e); /* Behavior undefined. */
           f3( 99,   e,  d+1); /* Behavior defined.   */
}

/*  Macro version of f3 */

float x[100];
float *c;

#define f3(N, A, B)                                    \
{   int n = (N);                                       \
    float * __restrict a = (A);                          \
    float * const    b = (B);                          \
    int i;                                             \
    for ( i=0; i<n; i++ )                              \
        a[i] = b[i] + c[i];                            \
}

/* Restricted pointers as members of a structure */

struct t {     /* Restricted pointers assert that    */
    int n;     /* members point to disjoint storage. */
    float * __restrict p;
    float * __restrict q;
};

void f4(struct t r, struct t s) {
    /* r.p, r.q, s.p, s.q should all point to    */
    /* disjoint storage during each execution of f4. */
    /* ... */
}

/* Pointer expressions based on p */

#include <stdlib.h>
#include <string.h>

struct t { int * q; int i; } a[2] = { /* ... */ };

void f5(struct t * __restrict p, int c)
{
     struct t * q;
     int n;
     if(c) {
         struct t * r;
         r = malloc(2*sizeof(*p));
         memcpy(r, p, 2*sizeof(*p));
         p = r;
     }
     q = p;
     n = (int)p;

     /* - - - - - - - - - - - - - - - - - - - - - - -

       Pointer expressions     Pointer expressions
       based on p:             not based on p:
       -------------------     -------------------
       p                       p->q
       p+1                     p[1].q
       &p[1]                   &p
       &p[1].i
       q                       q->p
       ++q
       (char *)p               (char *)(p->i)
       (struct t *)n           ((struct t *)n)->q
     - - - - - - - - - - - - - - - - - - - - - - - - */
}

main() {
    f5(a, 0);
    f5(a, 1);
}

/* Assignments between restricted pointers */
int * ____restrict p1, * ____restrict p2;
void f6(int * ____restrict q1, * ____restrict q2)
{
        q1 = p1; /* Valid behavior */
        p1 = p2; /* Behavior undefined */
        p1 = q1; /* Behavior undefined */
        q1 = q2; /* Behavior undefined */
    {
        int * ____restrict r1, * ____restrict r2;
        ...
        r1 = p1; /* Valid behavior */
        r1 = q1; /* Valid behavior */
        r1 = r2; /* Behavior undefined */
        q1 = r1; /* Behavior undefined */
        p1 = r1; /* Behavior undefined */
        ...
    }
}

/* Assignments to unrestricted pointers */
void f7(int n, float * ____restrict r, float * ____restrict s) {
    float * p = r, * q = s;
    while(n->0)
        *p++ = *q++;
}

/* Qualified function return type and casts */

float * __restrict f8(void)  /* No assertion about aliasing. */
{
    extern int i, *p, *q, *r;

    r = (int * __restrict)q; /* No assertion about aliasing. */

    for(i=0; i<100; i++)
        *(int * __restrict)p++ =   r[i];  /* No assertion    */
                                          /* about aliasing. */
    return p;
}

/*__restrict cannot qualify non-pointer object types: */

int __restrict x;    /* Constraint violation */
int __restrict *p;   /* Constraint violation */

/* __restrict cannot qualify pointers to functions: */

float (* __restrict f9)(void); /* Constraint violation */

The keyword typedef is used to define a type synonym. In such a definition, the identifiers name types instead of objects. One such use is to define an abbreviated name for a lengthy or confusing type definition.

typedef float *floatp, (*float_func_p)();

The type floatp is now “pointer to a float value” type, and the type float_func_p is “pointer to a function returning float”.

A type definition can be used anywhere the full type name is normally used (you can, of course, use the normal type name). Type definitions share the same name space as variables, and defined types are fully compatible with their equivalent types. Types defined as qualified types inherit their type qualifications.

typedef char byte;
typedef byte ten_bytes[10];

typedef int *int_p;
typedef unsigned int *uint_p;
unsigned int_p x;           /*  Invalid   */
uint_p y;                   /*  Valid     */

typedef unsigned *uint_p; /* uint_p has type "pointer to unsigned */
                          /* int"                                 */
uint_p xp;
typedef uint_p func(void); /* func has type "function returning */
                           /* pointer to unsigned int           */
func f;
func b;
  func f(void)   /* Invalid – this declaration specifies a     */
                 /* function returning a function type, which  */
  {              /* is not allowed                             */
    return xp;
  }

uint_p b(void)   /* Legal – this function returns a value of   */
  {              /* type uint_p.                               */
   return xp;
  }

typedef int func(int x);
func f;
func f        /* Valid definition of f with type func                  */
{
  return 3;
}             /* Invalid, because the function's type is not inherited */

typedef int func(int x);
func f;
int f(int x)   /* Valid definition of f with type func            */
{
  return 3;
}              /* Legal, because the function's type is specified */

You can include prototype information, including parameter names, in the typedef name. You can also redefine typedef names in inner scopes, following the scope rules explained in Section 2.3, “Scope”.

The general syntax of a declaration is as follows:

declaration-specifiers init-declarator-listopt;

declaration-specifiers:

storage-class-specifier declaration-specifiersopt
type-specifier declaration-specifiersopt
type-qualifier declaration-specifiersopt

init-declarator-list:

init-declarator
init_declarator-list , init-declarator 

init-declarator:

declarator
declarator = initializer 

volatile static int data = 10;

This declaration shows a qualified type (a data type with a type qualifier—in this case, int qualified by volatile), a storage class (static), a declarator (data), and an initializer (10). This declaration is also a definition, because storage is reserved for the data object data.

The previous example is simple to interpret, but complex declarations are more difficult. See your platform-specific VSI C documentation for more information about interpreting C declarations.

Storage Allocation

Initialization of objects of each type is discussed in the following sections, but a few universal constraints apply to all initializations in C:

Initializers provide an initial value for objects, and follow this syntax:

assignment-expr
{ initializer-list }
{ initializer-list, }

designation-opt initializer
initializer-list, designation-opt initializer

designator-list =

designator
designator-list designator

[ constant-expr ]
. identifier

Initialization of objects of each type is discussed in the following sections, but a few universal constraints apply to all initializations in C:

C has historically allowed initializers to be optionally surrounded by extra braces (to improve formatting clarity, for instance). These initializers are parsed differently depending on the type of parser used. VSI C uses the parsing technique specified by the ANSI standard, known as the top-down parse. Programs depending on a bottom-up parse of partially braced initializers can yield unexpected results. The compiler generates a warning message when it encounters unnecessary braces in common C compatibility mode or when the error-checking compiler option is specified on the command line.

An object declaration outside of a function is called an external declaration. Contrast this with an internal declaration, which is a declaration made inside a function or block; the declaration is internal to that function or block, and is visible only to that function or block. The compiler recognizes an internally declared identifier from the point of the declaration to the end of the block.

If an object's declaration has file scope and an initializer, the declaration is also an external definition for the object. A C program consists of a sequence of external definitions of objects and functions.

float fvalue = 15.0;                /* external definition  */
main ()
{
  int ivalue = 15;                  /* internal definition  */
}

void function1()
{
int a,b;
x (a,b);
}

The first declaration of an identifier in a compilation unit must specify, explicitly or by the omission of the static keyword, whether the identifier is internal or external. For each object, there can be only one definition. Multiple declarations of the same object may be made, as long as there are no conflicting or duplicate definitions for the same object.

An external object may be defined with either an explicit initialization or a tentative definition. A declaration of an object with file scope, without an initializer, and with a storage-class specifier other than static is a tentative definition. The compiler will treat a tentative definition as the object's only definition unless a complete definition for the object is found. As with all declarations, storage is not actually allocated until the object is defined.

If a compilation unit contains more than one tentative definition for an object, and no external definition for the object, the compiler treats the definition as if there were a file scope declaration of the object with an initializer of zero, with composite type as of the end of the compilation unit. See Section 2.7, “Compatible and Composite Types” for a definition of composite type.

If the declaration of an object is a tentative definition and has internal linkage, the declared type must not be an incomplete type. See Section 2.9, “Tentative Definitions” for examples of tentative definitions.

Simple objects are objects with one of the basic data types. Therefore, a simple object can have an integral or floating-point type. Like all objects, simple objects are named storage locations whose values can change throughout the execution of the program. All simple objects used in a program must be declared.

int x = 10;
float y = ((12 - 2) + 25);

int x;        /*  Declares an integer variable x    */
int y = 10;   /*  Declares an integer variable y    */
              /*  and sets y's initial value to 10  */

unsigned long int a;
signed long;           /*  Synonymous with "signed long int"   */
unsigned int;

char ch = 'a'; /* Declares an object ch with an initial value 'a' */

float x = 7.5;
double y = 3.141596;

An enumerated type is a user-defined integer type. An enumerated type defines enumeration constants, which are integral constant expressions with values that can be represented as integers. An enumerated type declaration follows this syntax:

enum identifieropt { enumerator-list}
enum identifieropt { enumerator-list , }
enum identifier 

enumerator
enumerator-list, enumerator

enumeration-constant
enumeration-constant = constant_expression

In VSI C, objects of type enum are compatible with objects of type signed int.

enum shades
   {
      off, verydim, dim, prettybright, bright
   }  light;

This declaration defines the variable light to be of an enumerated type shades. light can assume any of the enumerated values.

The tag shades is the enumeration tag of the new type. off through bright are the enumeration constants with values 0 through 4. These enumeration constants are constant values and can be used wherever integer constants are valid.

enum  shades  light1;

enum e;

An enum tag can have the same spelling as other identifiers in the same program in other name spaces. However, enum constant names share the same name space as variables and functions, so they must have unique names to avoid ambiguity.

enum spectrum
   {
      red, yellow = 4, green, blue, indigo, violet
   }  color2 = yellow;

This declaration gives red, yellow, green, blue, ..., the values 0, 4, 5, 6, ... Assigning duplicate values to enumeration constants is permitted.

The value of color2 is an integer (4), not a string such as "red" or "yellow".

Pointers are variables that contain the memory addresses of objects or functions. Pointer variables are declared as a pointer type by using the asterisk punctuator and the data type of the object pointed to, as shown in the following syntax:

pointer:

* type-qualifier-listopt
* type-qualifier-listopt pointer

type-qualifier-list:

type-qualifier
type-qualifier-list type-qualifier

By default, VSI C pointers are 32 bits long. VSI supports both 32-bit (short) and 64-bit (long) pointers. VSI C provides qualifiers/switches and #pragma preprocessor directives to control pointer size.

The type-qualifier is either const, volatile, __unaligned (Alpha), __restrict, or any combination thereof.

char *px;

In this example, identifier px is declared as a pointer to an object of type char. No type-qualifier is used in this example. The expression *px yields the char that px points to.

const int *ptr_to_constant;     /*  pointer variable pointing
                                    to a const object         */
int *const constant_ptr;        /*  constant pointer to a
                                    non-const object          */
const int *const constant_ptr;  /*  Const pointer to a
                                    const object              */

The contents of an object pointed to by ptr_to_constant cannot be modified through that pointer, but ptr_to_constant itself can be changed to point to another const-qualified object. Similarly, the contents of the integer pointed to by constant_ptr can be modified, but constant_ptr itself will always point to the same location.

typedef int *int_ptr;
const int_ptr constant_ptr;

The __unaligned data-type qualifier can be used in pointer definitions to indicate to the compiler that the data pointed to is not properly aligned on a correct address. To be properly aligned, the address of an object must be a multiple of the size of the type. For example, 2-byte objects must be aligned on even addresses.

When data is accessed through a pointer declared __unaligned, the compiler generates the additional code necessary to copy or store the data without causing alignment errors. It is best to avoid use of misaligned data altogether, but in some cases the usage may be justified by the need to access packed structures, or by other considerations. VSI OpenVMS I64 and VSI OpenVMS x86-64 are not as sensitive to unaligned data accesses with regards to run-time performance.

The __restrict data-type qualifier is used to designate a pointer as pointing to a distinct object, thus allowing compiler optimizations to be made (see Section 3.7.4, “__restrict Type Qualifier”).

Unless an extern or static pointer variable is explicitly initialized, it is initialized to a null pointer. A null pointer is a pointer value of 0. The contents of an uninitialized auto pointer are undefined.

float *float_pointer;
void  *void_pointer;
.
.
.
float_pointer = void_pointer;
                                        /*    or,      */
void_pointer  = float_pointer;

void *memcpy (void *s1, const void *s2, size_t n);
{
   void  *generic_pointer;
.
.
.
/* The function return value can be a pointer to many types. */

generic_pointer = func_returning_pointer( arg1, arg2, arg3 );
.
.
.
/*  size_t is a defined type                                 */
}

int i = 10;
int *p = &i;  /*  p is a pointer to int, initialized */
              /*  as holding the address of i        */

char *p =  "abc";

Arrays are declared with the bracket punctuators [ ], as shown in the following syntax:

storage-class-specifieropt type-specifier declarator[* or constant-expression-listopt]

int table_one[10];

int x[5];
x[0] = 25; /* The first array element is assigned the value 25 */

The expression between the brackets in the declaration must be either the (*) punctuator or an integral constant expression with a value greater than zero.

If * is specified between the brackets, then the array type is a variable-length array type of unspecified size, which can be used only in declarations with function prototype scope.

If the size expression is an integer constant expression and the element type has a known constant size, the array type is not a variable-length array type. Otherwise, it is a variable-length array type. The size of each instance of a variable-length array type does not change during its lifetime. For more information on variable-length arrays, see Section 4.7.3, “Variable-Length Arrays”.

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

int x[];
int *x;
int x[10];

Note that the specified size of the array does not matter in the case of a function parameter, since the pointer always points to only the first element of the array.

int table_one[10][2];

Arrays are stored in row-major order, which means the element table_one[0][0] (in the previous example) immediately precedes table_one[0][1], which in turn immediately precedes table_one[1][0].

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

int x[5] = { 0, 1, 2, 3, 4, 5 };    /*  error     */ 

char string[26] = { "This is a string literal." };
                  /* The braces above are optional here */

char string[12] = {'T', 'h', 'i', 's', ' ', 'w', 'a', 'y' };

char c[4] = "abcd";

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

x[0][0] = 1;
x[0][1] = 2;
x[1][0] = 3;
x[1][1] = 4;
x[2][0] = 5;
x[2][1] = 6;
x[3][0] = 0;
x[3][1] = 0;

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

int x[5] = { 0, 1, 2, 3, 4 };
/* Array x declared with five elements       */
int *p = x;              /* Pointer declared and initialized to point */
                         /* to the first element of the array x       */
int a, b;
a = *(x + 3);            /* Pointer x incremented by twelve bytes     */
                         /* to reference element 3 of x               */
b = x[3];                /* b now holds the same value as a           */

int func(int *x, int *y) /* The arrays are converted to pointers         */
{
   *y = *(x + 4);        /* Various elements of the arrays are accessed  */
}

  #include <stdio.h>
  #include <stdlib.h>

  void sub(int, int, int[*][*]);

  int main(int argc, char **argv)
  {
      if (argc != 3) {
          printf("Specify two array bound arguments.\n");
          exit(EXIT_FAILURE);
      }
      {
          int dim1 = atoi(argv[1]);
          int dim2 = atoi(argv[2]);
          int a[dim1][dim2];
          int i, j, k = 0;
          for (i = 0; i &lt; dim1; i++) {
              for (j = 0; j &lt; dim2; j++) {
                  a[i][j] = k++;
              }
          }
          printf("dim1 = %d, dim2 = %d.",
                 sizeof(a)/sizeof(a[0]),
                 sizeof(a[0])/sizeof(int));

          sub(dim1, dim2, a);
          sub(dim2, dim1, a);
      }
      exit(EXIT_SUCCESS);
  }

  void sub(int sub1, int sub2, int suba[sub1][sub2])
  {
      int i, j, k = 0;
      printf("\nIn sub, sub1 = %d, sub2 = %d.",
                        sub1,      sub2);
      for (i = 0; i &lt; sub1; i++) {
          printf("\n");
          for (j = 0; j &lt; sub2; j++) {
              printf("%4d", suba[i][j]);
          }
      }
  }

A structure consists of a list of members whose storage is allocated in an ordered sequence. A union consists of a sequence of members whose storage overlaps. Structure and union declarations have the same form, as follows:

struct-or-union-specifier:

struct-or-union identifieropt {struct-declaration-list}
struct-or-union identifier

struct-or-union:

struct
union 

struct-declaration-list:

struct-declaration
struct-declaration-list struct-declaration

struct-declaration:

specifier-qualifier-list struct-declarator-list ;

specifier-qualifier-list:

type-specifier specifier-qualifier-listopt
type-qualifier specifier-qualifier-list opt

struct-declarator-list:

struct-declarator
struct-declarator-list , struct-declarator

struct-declarator:

declarator
declaratoropt : constant-expression

Neither a structure nor union member can have a function type or an incomplete type. Structures and unions cannot contain instances of themselves as members, but they can have pointers to instances of themselves as members. The declaration of a structure with no members is accepted; its size is zero.

Each structure or union definition creates a unique structure or union type within the compilation unit. The struct or union keywords can be followed by a tag, which gives a name to the structure or union type in much the same way that an enum tag gives a name to an enumerated type. The tag can then be used with the struct or union keywords to declare variables of that type without repeating a long definition.

The tag is followed by braces { } that enclose a list of member declarations. Each declaration in the list gives the data type and name of one or more members. The names of structure or union members can be the same as other variables, function names, or members in other structures or unions; the compiler distinguishes them by context. In addition, the scope of the member name is the same as the scope of the structure or union in which it appears. The structure or union type is completed when the closing brace completes the list.

An identifier used for a structure or union tag must be unique among the visible tags in its scope, but the tag identifier can be the same as an identifier used for a variable or function name. Tags can also have the same spellings as member names; the compiler distinguishes them by name space and context. The scope of a tag is the same as the scope of the declaration in which it appears.

struct person
   {
      char first[20];
      char middle[3];
      char last[30];
      struct         /*  Nested structure here  */
      {
          int day;
          int month;
          int year;
      } birth_date;
   }  employees, managers;

declarator: constant-expression
:constant-expression

struct {
    unsigned int a : 1;  /*  Named bit field (a)    */
    unsigned int   : 0;  /*  Unnamed bit field = 0  */
    unsigned int   : 1;  /*  Unnamed bit field      */
}  class;

struct
   {
      int i;
      float c;
   }  a = { 1, 3.0e10 },  b = { 2, 1.5e5 };

#include <stdio.h>

main()
{
   int m, n;
   static struct
      {
         char ch;
         int i;
         float c;
      }  ar[2][3] =
         {
            {
               { 'a', 1, 3e10 },
               { 'b', 2, 4e10 },
               { 'c', 3, 5e10 },
            }
         };

   printf("row/col\t ch\t i\t      c\n");
   printf("-------------------------------------\n");
   for (n = 0; n < 2; n++)
      for (m = 0; m < 3; m++)
         {
            printf("[%d][%d]:", n, m);
            printf("\t %c \t %d \t %e \n",
                   ar[n][m].ch, ar[n][m].i, ar[n][m].c);
         }
}

row/col  ch      i            c
-------------------------------------
[0][0]:  a       1       3.000000e+10
[0][1]:  b       2       4.000000e+10
[0][2]:  c       3       5.000000e+10
[1][0]:          0       0.000000e+00
[1][1]:          0       0.000000e+00
[1][2]:          0       0.000000e+00

static union
  {
     char ch;
     int i;
     float c;
  } letter = {'A'};

main ()
{
union1 {
    int i;
    char ch;
    float c;
  } number1 = { 2 };

auto union2
  {
    int i;
    char ch;
    float c;
  } number2 = number1;
}

In conformance with the C99 standard, VSI C supports the use of designations in the initialization of arrays and structures. (Note that designations are not supported in the common C, VAX C, and Strict ANSI89 modes of the compiler.)

        designation:
                designator-list =

        designator-list:
                designator
                designator-list designator

        designator:
                [ constant-expression ]
                . identifier

[ integral-constant-expression ]

 .identifier

The following syntax declares the identifier tag as a structure, union, or enumeration tag. If this tag declaration is visible, a subsequent reference to the tag substitutes for the declared structure, union, or enumerated type. Subsequent references of the tag in the same scope (visible declarations) must omit the bracketed list. The syntax of a tag is:

struct tag { declarator-list }
union tag { declarator-list }
enum tag { enumerator-list }

If the tag is declared without the complete structure or union declaration, it refers to an incomplete type. Incomplete enumerated types are illegal. An incomplete type is valid only to specify an object where the type is not required; for example, during type definitions and pointer declarations. To complete the type, another declaration of the tag in the same scope (but not within an enclosed block), defines the content.

struct test {
    float height;
    struct test *x, *y, *z;
};

struct test s, *sp;

typedef struct test tnode;
struct test {
     float height;
     tnode *x, *y, *z;
};
tnode s, *sp;

typedef int integral_type;
integral_type x;

In the previous example, integral_type is defined as a synonym for int, and so the following declaration of x declares x to be of type int. Type definitions are useful in cases where a long type name (such as some forms of structures or unions) benefits from abbreviation, and in cases where the interpretation of the type can be made easier through a type definition.

typedef signed int t;
typedef int plain;
struct tag {
   unsigned t:4;
   const t:5;
   plain r:5;
};

It is evident that such constructions are obscure. The previous example declares a typedef name t with type signed int, a typedef name plain with type int, and a structure with three bit-field members, one named t, another unnamed member, and a third member named r. The first two bit-field declarations differ in that unsigned is a type specifier, which forces t to be the name of a structure member by the rule previously given. The second bit-field declaration includes const, a type qualifier, which only qualifies the still-visible typedef name t.

typedef int miles, klicksp(void);
typedef struct { double re, im; } complex;
.
.
.
miles distance;
extern klicksp *metricp;
complex x;
complex z, *zp;

All of the code shown in the previous example is valid. The type of distance is int, the type of metricp is a pointer to a function with no parameters returning int, and the type of x and z is the specified structure. zp is a pointer to the structure.

typedef const int x;
const x y;            /*  Illegal – duplicate qualifier used  */

main()
{
.
.
.
y = power(x,n);                     /* function call */
}

See Section 6.3.2, “Function Calls” for more information on function calls.

A function has the derived type “function returning type”. The type can be any data type except array types or function types, although pointers to arrays and functions can be returned. If the function returns no value, its type is “function returning void”, sometimes called a void function. A void function in C is equivalent to a procedure in Pascal or a subroutine in FORTRAN. A non-void function in C is equivalent to a function in these other languages.

A function definition includes the code for the function. Function definitions can appear in any order, and in one source file or several, although a function cannot be split between files. Function definitions cannot be nested.

A function definition has the following syntax:

function-definition:

declaration-specifiersopt  declarator  declaration-listopt
compound-statement

The declaration-specifiers (storage-class-specifier, type-qualifier, and type-specifier) can be listed in any order. All are optional.

By default, the storage-class-specifier is extern. The static specifier is also allowed. See Section 2.10, “Storage Classes” for more information on storage-class specifiers.

ANSI allows the type-qualifier to be const or volatile, but either qualifier applied to a function return type is meaningless, because functions can only return rvalues and the type qualifiers apply only to lvalues.

The type-specifier is the data type of the value returned by the function. If no return type is specified, the function is declared to return a value of type int. A function can return a value of any type except “array of type” or “function returning type”. Pointers to arrays and functions can be returned. The value returned, if any, is specified by an expression in a return statement. Executing a return statement terminates function execution and returns control to the calling function. For functions that return a value, any expression with a type compatible with the function's return type can follow return using the following format:

return expression;

If necessary, the expression is converted to the return type of the function. Note that the value returned by a function is not an lvalue. A function call, therefore, cannot constitute the left side of an assignment operator.

char letter(char param1)
{
   .
   .
   . 
   return param1;
}

The calling function can ignore the returned value. If no expression is specified after return, or if a function terminates by encountering the right brace, then the return value of the function is undefined. No value is returned in the case of a void function.

void message()
{
   printf("This function has no return value.");
   return;
}

int f1(char p2)

int (*(*fpapfi(int x))[5])(float)

In this example, fpapfi is a “function (taking an int argument) returning a pointer to an array of five pointers to functions (taking a float argument) returning int”. See Chapter 4, Declarations for information on specific declarator syntax.

The declarator (function) need not have been previously declared. If the function was previously declared, the parameter types and return type in the function definition must be identical to the previous function declaration.

The declarator can include a list of the function's parameters. In VSI C, up to 253 parameters can be specified in a comma-separated list enclosed in parentheses. Each parameter has the auto storage class by default, although register is also allowed. There is no semicolon after the right parenthesis of the parameter list.

A function defined using the prototype style establishes a prototype for that function. The prototype must agree with any preceding or following declarations of the same function.

A function defined using the old style does not establish a prototype, but if a prototype exists because of a previous declaration for that function, the parameter declarations in the definition must exactly match those in the prototype after the default argument promotions are applied to the parameters in the definition.

Avoid mixing old style and prototype style declarations and definition for a given function. It is allowed but not recommended.

See Section 5.6, “Parameters and Arguments” for more information on function parameters and arguments. See Section 5.5, “Function Prototypes” for more information on function prototypes.

The compound-statement is the group of declarations and statements surrounded by braces in a function or loop body. This compound statement is also called the function body. It begins with a left brace ({) and ends with a right brace (}), with any valid C declarations and statements in between. One or more return statements can be included, but they are not required.

char lower(int c);                    /* Function declaration */

caller()                              /* Calling function     */
{
int c;
char c_out;      
      .
      .
      .
c_out = lower(c);                     /* Function call        */

}

char lower(int c_up)                  /* Function definition  */
{
.
.
.
}

If the function definition for lower was located before the function caller in the source code, lower would not have to be declared again before calling it. In that case, the function definition would serve as its own declaration and would be in scope for any function calls from within all subsequently defined functions in the same source file.

Note that both the function definition and function declaration for lower are in the prototype style. Although C supports the old style of function declaration in which the parameter types are not specified in the function declarator, it is good programming practice to use prototype declarations for all user-defined functions in your program, and to place the prototypes before the first use of the function. Also note that it is valid for the parameter identifier in the function declaration to be different from the parameter identifier in the function definition.

   char function_name(void);

main()
{
   void function_name( );
      .
      .
      .
}
void function_name( )
{ }

A function prototype is a function declaration that specifies the data types of its arguments in the parameter list. The compiler uses the information in a function prototype to ensure that the corresponding function definition and all corresponding function declarations and calls within the scope of the prototype contain the correct number of arguments or parameters, and that each argument or parameter is of the correct data type.

Prototypes are syntactically distinguished from the old style of function declaration. The two styles can be mixed for any single function, but this is not recommended. The following is a comparison of the old and the prototype styles of declaration:

declaration-specifiersopt  declarator;

storage_classopt return_typeopt 
function_name ( type1 parameter1, ..., 
typen parametern );

char  function_name( int lower, int *upper, char (*func)(), double y )
{ }

char  function_name( int lower, int *upper, char (*func)(), double y );

char  function_name( int lower, int *upper, char (*func)(), double y );
char  function_name( int a, int *b, char (*c)(), double d );
char  function_name( int, int *, char (*)(), double );

char  function_name( int lower, ... );

void foo(int a[1000]){ ... } 
void bar(int b[static 1000]) { ...} 

C functions exchange information by means of parameters and arguments. The term parameter refers to any declaration within the parentheses following the function name in a function declaration or definition; the term argument refers to any expression within the parentheses of a function call.

int x()  { return 25; }            /* Function definition and   */
int z[10];                          /* array defined before use  */

fn(int f1(), int (*f2)(), int a1[]))   /* Function definition       */
{
    f1();                           /* Call to function f1       */
      .
      .
      .
}

void caller(void)
{
   int y();                         /* Function declaration      */
      .
      .
      .
   fn(x, y, z);                     /* Function call: functions  */
                                     /* x and y, and array z      */
                                     /* passed as addresses       */
      .
      .
      .
}
int y(void) { return 30; }           /* Function definition       */

fn(int f1(), int f2(), int a1[])      /* f1, f2 declared as     */
{...}                                 /* functions; a1 declared */
                                      /* as array of int.       */


fn(int (*f1)(), int (*f2)(), int *a1) /* f1, f2 declared as     */
{...}                                 /* pointers to functions; */
                                      /* a1 declared as pointer */
                                      /* to int.                */

int  main(void) {...}
int  main(int argc, char *argv[ ]) {...})

Simple expressions are called primary expressions; they denote values. Primary expressions include previously declared identifiers, constants, string literals, and parenthesized expressions.

Primary expressions have the following syntax:

primary-expression:

identifier
constant
string-literal
expression

The following sections describe the primary expressions.