HP OpenVMS Systems

Block                    

 A block is a compound statement.  It allows more than one statement

 to appear where a single statement ordinarily is used.  It is made

 up of a list of declarations and statements, enclosed in braces:



          { [declaration ...] [statement ...] }



 The declaration list is optional; if it is included, all

 declarations of variables are local to the block and supersede

 previous declarations for the duration of the block.  A block is

 entered normally when control flows into it, or when a goto

 statement transfers control to a label at the beginning of the

 block.  Each time the block is entered normally, storage is

 allocated for auto or register variables.  If, on the other hand, a

 goto statement transfers control to a label inside the block or if

 the block is the body of a switch statement, these storage

 allocations do not occur.  Blocks can be used wherever single

 statements are valid -- for example, as the action clause of an if

 statement:



           if ( i < 1 )

              {                       /* BEGINNING OF BLOCK */

                 char x;

                 for (x = 'a';  x <= 'z';  x++) 

                    printf("char = %c\n", x);

              }                       /* END OF BLOCK      */



Valid_File_Specifications

 In Compaq C source programs, you can include both OpenVMS and UNIX*

 style file specifications.  Combinations of the two specifications

 are not supported by Compaq C.



 Example of a valid UNIX* file specification:



      beatle!/dba0/lennon/songs.lis.3



 Example of an invalid UNIX* file specification:



      BEATLE::DBA0:[LENNON.C]/songs.lis.3







----------

* UNIX is a trademark of The Open Group.



Data_Types               

 The data type of an object must be specified in its declaration.

 The fundamental data types are the scalar types:



 short int           16-bit signed integer

 signed short int    16-bit signed integer

 unsigned short int  16-bit unsigned integer

 int                 32-bit signed integer

 signed int          32-bit signed integer

 unsigned int        32-bit unsigned integer

 long int            32-bit signed integer

 signed long int     32-bit signed integer

 unsigned long int   32-bit unsigned integer

 char                8-bit signed integer

 signed char         8-bit signed integer

 unsigned char       8-bit unsigned integer

 wchar_t             Long character (32-bit unsigned integer)

 float               32-bit (single-precision) floating-point number

 double              64-bit (double-precision) floating-point number

 long float          Interchangeable with double, but usage is

                     obsolete

 _Bool               An unsigned int that has the value 0 or 1

 _Imaginary          A C99-specified data type.  In Compaq C, use of

                     the _Imaginary keyword produces a warning,

                     which is resolved by treating it as an ordinary

                     identifier.



 The signed keyword is the default.  Declaring an object with int,

 for example, is equivalent to declaring it with signed int.

 However, char declarations should be explicitly declared, as the

 compiler offers command-line options to change the default.  If in

 doubt, use signed char over char because signed char is more

 portable.



 Strings are arrays of characters terminated by the null character

 (\0).



 Also, view the contents of the <ints.h> header file for definitions

 of platform-specific integer types.

Additional Information on:

Declarations             

 Declarations specify the functions and variables referenced in a

 program.  Declarations in C have the following syntax:



       declaration:



          declaration-specifiers [init-declarator-list];



       declaration-specifiers:



          storage-class-specifier [declaration-specifiers]

          type-specifier [declaration-specifiers]

          type-qualifier [declaration-specifiers]



       init-declarator-list:



          init-declarator

          init-declarator-list, init-declarator



       init-declarator:



          declarator

          declarator = initializer



 Note the following items about the general syntax of a declaration:



  o  The storage-class-specifier, type-qualifier, and type-specifier

     can be listed in any order.  All are optional, but, except for

     function declarations, at least one such specifier or qualifier

     must be present.  Placing the storage-class-specifier anywhere

     but at the beginning of the declaration is an obsolete style.



  o  Storage-class keywords are auto, static, extern, and register.



  o  Type qualifiers are const, volatile, and __restrict.



  o  The declarator is the name of the object being declared.  A

     declarator can be as simple as a single identifier, or can be a

     complex construction declaring an array, structure, pointer,

     union, or function (such as *x, tree(), and treebar[10]).



  o  Initializers are optional and provide the initial value of an

     object.  An initializer can be a single value or a

     brace-enclosed list of values, depending on the type of object

     being declared.



  o  A declaration determines the beginning of an identifier's

     scope.



  o  An identifier's linkage is determined by the declaration's

     placement and its specified storage class.



 Consider the following example:



      volatile static int var_number = 10;



This declaration shows a qualified type (a type, int, with a type

qualifier, 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 var_number.



For more information, see HELP CC LANGUAGE_TOPICS DATA_TYPES, HELP

CC LANGUAGE_TOPICS STORAGE_CLASSES, and HELP CC LANGUAGE_TOPICS

TYPE_QUALIFIERS.

Additional Information on:

Functions                

 Functions consist of one or more blocks of statements that perform

 one logical operation.  They can be called from other functions

 either in the same program or in different programs.  A function

 may exchange values with the calling function by use of parameters.



 Function declarations have the following syntax:



      function_name()

 or

      function_name(arg1, arg2,...)

 or

      function_name(data-type arg1, data-type arg2,...)



 In the first form of the function declaration, the function takes

 no arguments.  In the second form, the function takes arguments;

 the arguments are declared outside the parameter list.  In the

 third form, the function declaration is a function prototype that

 specifies the type of its arguments in the identifier list; the

 prototype form is recommended.  In all three cases, the parenthesis

 after the function name are required.



 Compaq C for OpenVMS Systems provides a library of common

 functions.  These functions perform standard I/O operations,

 character and string handling, mathematical operations,

 miscellaneous system services, and UNIX* system emulation.  For

 more information, see HELP CC RUN-TIME_FUNCTIONS.







----------

* UNIX is a trademark of The Open Group.



Builtin_Functions                 

 Built-in functions allow you to directly access hardware and

 machine instructions to perform operations that are cumbersome,

 slow, or impossible in pure C.



 These functions are very efficient because they are built into the

 Compaq C compiler.  This means that a call to one of these

 functions does not result in a reference to a function in the C

 run-time library or in your programs.  Instead, the compiler

 generates the machine instructions necessary to carry out the

 function directly at the call site.  Because most of these built-in

 functions closely correspond to single VAX or Alpha machine

 instructions, the result is small, fast code.



 Some of these functions (such as those that operate on strings or

 bits) are of general interest.  Others (such as the functions

 dealing with process context) are of interest if you are writing

 device drivers or other privileged software.  Some of the functions

 are privileged and unavailable to user mode programs.



 Be sure to include the <builtins.h> header file in your source

 program to access these built-in functions.



 Compaq C supports the #pragma builtins preprocessor directive for

 compatibility with VAX C, but it is not required.



 Some of the built-in functions have optional arguments or allow a

 particular argument to have one of many different types.  To

 describe different valid combinations of arguments, the description

 of each built-in function may list several different prototypes for

 the function.  As long as a call to a built-in function matches one

 of the prototypes listed, the call is valid.  Furthermore, any

 valid call to a built-in function acts as if the corresponding

 prototype was in scope, so the compiler performs the argument

 checking and argument conversions specified by that prototype.



 The majority of the built-in functions are named after the machine

 instruction that they generate.  For more information on these

 built-in functions, see the documentation on the corresponding

 machine instruction.  In particular, see that reference for the

 structure of queue entries manipulated by the queue built-in

 functions.



 The Compaq C for OpenVMS VAX built-in functions use enumerated

 typedefs to define possible return values.  We recommend that you

 use the enumerated types to store and compare return values.

Additional Information on:

Variable_Length_Argument_Lists               

 The set of functions and macros defined and declared in the

 <varargs.h> and the <stdarg.h> header files provide a method of

 accessing variable-length argument lists.  (Note that the

 <stdarg.h> functions are defined by the ANSI C standard and are,

 therefore, portable as compared with those defined in <varargs.h>.)



 The Compaq C RTL functions such as printf and execl, for example,

 use variable-length argument lists.  User-defined functions with

 variable-length argument lists that do not use <varargs.h> or

 <stdarg.h> are not portable due to the different argument-passing

 conventions of various machines.



 To use these functions and macros in <stdarg.h>, you must include

 the <stdarg.h> header file with the following preprocessor

 directive:



      #include <stdarg.h>



 The <stdarg.h> header file declares a type (va_list) and three

 macros (va_start, va_arg, and va_end) for advancing through a list

 of function arguments of varying number and type.  The macros have

 the following syntax:



      void va_start(va_list ap, parmN);



      type va_arg(va_list ap, type);



      void va_end(va_list ap);



 The va_start macro initializes the object ap of type va_list for

 subsequent use by va_arg and va_end.  The va_start macro must be

 invoked before any access to the unnamed arguments.  The parameter

 parmN is the identifier of the rightmost parameter in the variable

 parameter list of the function definition.  If parmN is declared

 with the register storage class, with a function or array type, or

 with a type that is not compatible with the type that results after

 application of the default arguments promotions, the behavior is

 undefined.  The va_start macro returns no value.



 The va_arg macro expands to an expresion that has the type and

 value of the next argument in the call.  The parameter ap is the

 same as the one initialized by va_start.  Each invocation of va_arg

 modifies ap so that the values of successive arguments are returned

 in turn.  The parameter "type" is a type name specified such that

 the type of a pointer to an object that has the specified type can

 be obtained by postfixing an asterisk (*) to "type".  If there is

 no actual next argument, or if type is not compatible with the type

 of the next actual argument (as promoted according to the default

 argument promotions), the behavior is undefined.  The first

 invocation of va_arg after that of va_start returns the value of

 the argument after that specified by parmN.  Successive invocations

 return the values of the remaining arguments in turn.



 The va_end macro facilitates a normal return from the function

 whose variable argument list was referred to by the expansion of

 va_start that initialized the va_list ap object.  The va_end macro

 can modify ap) so that it can no longer be used (without an

 intervening invocation of va_start).  If there is no corresponding

 invocation of va_start or if va_end is not invoked before the

 return, the behavior is undefined.  The va_end macro returns no

 value.



Preprocessor             

 The Compaq C preprocessor uses directives to affect the compilation

 of a source file.  For Compaq C on OpenVMS systems, these

 directives are processed by an early phase of the compiler, not by

 a separate program.



 The preprocessor directives begin with a number sign (#) and do not

 end with a semicolon.  The number sign must appear in the first

 column of the source line.

Additional Information on:

Predefined_Macros  



 In addition to the ANSI-compliant, implementation-independent

 macros described in the Compaq C Language Reference Manual, Compaq

 C for OpenVMS systems provides the following predefined macros:

Additional Information on:

Predeclared_Identifiers  

Additional Information on:

Statements               

 Statements are the executable instructions performed by the

 program.  Statements produce values and control program flow.  A

 group of statements enclosed in braces makes up a block.



 Any valid expression or declaration terminated by a semicolon is

 considered a statement.  The statements that control program flow

 are described in further HELP frames.



 See also HELP CC LANGUAGE_TOPICS DECLARATION and HELP CC

 LANGUAGE_TOPICS PREPROCESSOR.

Additional Information on:

Storage_Classes          

 The storage class of a variable determines when its storage is

 allocated, whether its contents are preserved across different

 blocks or functions, and what link-time scope the variable has.



 Auto variables are allocated at run time.  They are not preserved

 across functions.  Auto is the default storage class for variables

 declared within a function.



 Extern variables are allocated at compile time.  They are preserved

 across functions.  There can be only 65,532 extern variables per

 program.  Extern is the default storage class for variables

 declared outside a function.



 Globaldef, globalref, and globalvalue variables are allocated at

 compile time.  They are preserved across functions.  The number of

 global symbols is unlimited.



 Register variables are allocated at run time.  They cannot be

 referenced from other separately compiled functions.



 Static variables are allocated at compile time.  If externally

 declared, they retain their values across functions.  If internally

 declared (inside of a function), they cannot be referenced from

 other functions; if control passes from the defining function, to

 other functions, and then passed back to the defining function, the

 variable retains its previous value and is not reinitialized.



Type_Qualifiers             

 Data-type qualifiers affect the allocation or access of data

 storage.  The data-type qualifiers are const, volatile, and

 __restrict.

Additional Information on:

Storage_Class_Modifiers



 The storage-class modifiers allow individual attributes of a

 variable to change without changing the other default attributes

 connected with a given storage class.  Storage-class keywords and

 storage-class modifiers can be specified in either order.



 Syntax:



      modifier storage_class_keyword identifier;



 If you specify a storage-class modifier but not a storage class

 keyword, the storage class defaults to extern.

Additional Information on: