United States

Compaq C

Compaq C
Language Reference Manual

Contents

Index

specifier-qualifier-list: (§3.5.2.1)

type-specifier specifier-qualifier-list_opt type-qualifier specifier-qualifier-list_opt

struct-declarator-list: (§3.5.2.1)

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

struct-declarator: (§3.5.2.1)

declarator declarator_opt : constant-expression

enum-specifier: (§3.5.2.2)

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

enumerator-list: (§3.5.2.2)

enumerator enumerator-list , enumerator

enumerator: (§3.5.2.2)

enumeration-constant enumeration-constant = constant-expression

type-qualifier: (§3.5.3)

const volatile

declarator: (§3.5.4)

pointer_opt direct-declarator

direct-declarator: (§3.5.4)

identifier ( declarator ) direct-declarator [ constant-expression_opt ] direct-declarator ( parameter-type-list ) direct-declarator ( identifier-list_opt )

pointer: (§3.5.4)

* type-qualifier-list_opt * type-qualifier-list_opt pointer

type-qualifier-list: (§3.5.4)

type-qualifier type-qualifier-list type-qualifier

parameter-type-list: (§3.5.4)

parameter-list parameter-list , ...

parameter-list: (§3.5.4)

parameter-declaration parameter-list , parameter-declaration

parameter-declaration: (§3.5.4)

declaration-specifiers declarator declaration-specifiers abstract-declarator_opt

identifier-list: (§3.5.4)

identifier identifier-list , identifier

type-name: (§3.5.5)

specifier-qualifier-list abstract-declarator_opt

abstract-declarator: (§3.5.5)

pointer pointer_opt direct-abstract-declarator

direct-abstract-declarator: (§3.5.5)

( abstract-declarator ) direct-abstract-declarator_opt [ constant-expression_opt ] direct-abstract-declarator_opt ( parameter-type-list_opt )

typedef-name: (§3.5.6)

identifier

initializer: (§3.5.7)

assignment-expression { initializer-list } { initializer-list , }

initializer-list: (§3.5.7)

initializer initializer-list , initializer

A.1.2.3 Statements

statement: (§3.6)

labeled-statement compound-statement expression-statement selection-statement iteration-statement jump-statement

labeled-statement: (§3.6.1)

identifier : statement case constant-expression : statement default : statement

compound-statement: (§3.6.2)

{ declaration-list_opt statement-list_opt }

declaration-list: (§3.6.2)

declaration declaration-list declaration

statement-list: (§3.6.2)

statement statement-list statement

expression-statement: (§3.6.3)

expression_opt ;

selection-statement: (§3.6.4)

if ( expression ) statement if ( expression ) statement else statement switch ( expression) statement

iteration-statement: (§3.6.5)

while ( expression ) statement do statement while ( expression ) ; for ( expression_opt ; expression_opt ; expression_opt ) statement

jump-statement: (§3.6.6)

goto identifier ; continue ; break ; return expression_opt ;

A.1.2.4 External Definitions

translation-unit: (§3.7)

external-declaration translation-unit external-declaration

external-declaration: (§3.7)

function-definition declaration

function-definition: (§3.7.1)

declaration-specifiers_opt declarator declaration-list_opt compound-statement

A.1.3 Preprocessing Directives

preprocessing-file: (§3.8)

group_opt

group: (§3.8)

group-part group group-part

group-part: (§3.8)

pp-tokens_opt new-line if-section control-line

if-section: (§3.8.1)

if-group elif-groups_opt else-group_opt endif-line

if-group: (§3.8.1)

#if constant-expression new-line group_opt #ifdef identifier new-line group_opt #ifndef identifier new-line group_opt

elif-groups: (§3.8.1)

elif-group elif-groups elif-group

elif-group: (§3.8.1)

#elif constant-expression new-line group_opt

else-group: (§3.8.1)

#else new-line group_opt

endif-line: (§3.8.1)

#endif new-line

control-line:

#include pp-tokens new-line (§3.8.2) #define identifier replacement-list new-line (§3.8.3) #define identifier (identifier-list)_opt replacement-list new-line (§3.8.3) #undef identifier new-line (§3.8.3) #line pp-tokens new-line (§3.8.4) #error pp-tokens_opt new-line (§3.8.5) #pragma pp-tokens_opt new-line (§3.8.6) # new-line (§3.8.7)

lparen: (§3.8.3)

the left parenthesis character without preceding white space

replacement-list: (§3.8.3)

pp-tokens_opt

pp-tokens: (§3.8)

preprocessing-token pp-tokens preprocessing-token

new-line: (§3.8)

the new-line character

Appendix B
ANSI Conformance Summary

Compaq C conforms to the ANSI standard for the Programming Language C, as specified by the X3J11 Technical Committee and documented in the American National Standard for Information Systems--Programming Language C (document number: X3.159-1989). Compaq C has successfully passed the Plum-Hall test suite for ANSI conformance. In strict ANSI C mode, the Compaq C compiler is a conforming implementation as described by the ANSI C Standard in Section 1.7, Compliance: " A conforming hosted implementation shall accept any strictly conforming program. A conforming implementation can have extensions (including additional library functions), provided they do not alter the behavior of any strictly conforming program. "

The ANSI C Standard defines a strictly conforming program as:

" A strictly conforming program shall use only those features of the language and library specified in this Standard. It shall not produce output dependent on any unspecified, undefined, or implementation-defined behavior, and shall not exceed any minimum implementation limit. "

" An implementation shall be accompanied by a document that defines all implementation-defined characteristics and all extensions. "

As with most language definitions, the ANSI C Standard does not encompass the entire definition of the C language available within an implementation. The C implementations currently supported by Compaq include a number of features that are not defined in the ANSI C Standard.

The rest of this section describes the compiler's functionality in a format mirroring the outline of the ANSI C Standard. The relevant ANSI C Standard section number is shown in parentheses following each heading. If a heading from the ANSI C Standard is missing from this description, Compaq C conforms to the Standard exactly, without extension or implementation-defined behavior.

The following sections document only the extensions and implementation-defined portions of the Compaq C language. Together with the ANSI C Standard, this section completely specifies the Compaq C implementation of the C language. The ANSI C Standard is referred to as "the Standard" throughout this appendix.

B.1 Diagnostics (§2.1.1.3)

A diagnostic message is produced for the first violation of a syntax rule or constraint specified in the Standard. Subsequent violations are reported if they are not hidden by previous violations.

B.2 Hosted Environment (§2.1.2.2)

The semantics of the arguments to main() , including envp , are determined by the programming environment. See your platform-specific Compaq C documentation for information on arguments to main() .

B.3 Multibyte Characters (§2.2.1.2)

The shift states used for the encoding of multibyte characters are dependent on translation tables available on the local system. A particular character set is supported by the language if the local system's translation tables support it.

B.4 Escape Sequences (§2.2.2)

Elements within a character constant or string literal of the source character set are mapped directly into the elements of the execution character set. Escape sequences other than those defined by the Standard are diagnosed with a warning and the backslash is ignored, so that the character constant's or string literal's value is the same as if the backslash were not present.

B.5 Translation Limits (§2.2.4.1)

Translation limits vary across platforms because of differences in the underlying machine architecture and operating systems. Otherwise, Compaq C avoids imposing translation limits.

The following lists show the only limits imposed in Compaq C. Translation limits listed in the Standard, but not in the following list, are not imposed in Compaq C:

32,767 characters in an internal identifier or a macro name
32,767 characters in a logical or physical source line
32,767 bytes in the representation of a string literal (this limit does not apply to string literals formed as a result of concatenation)

On Tru64 UNIX systems:

1023 significant initial characters in an external identifier. A warning is issued if such an identifier is truncated.

On OpenVMS systems:

31 significant initial characters in an external identifier. A warning is issued if such an identifier is truncated.
253 actual arguments or formal parameters to a function.
1012 bytes in a function argument list.

B.6 Numerical Limits (§2.2.4.2)

Compaq C's numerical limits are defined in the limits.h and float.h header files. These header files contain the implementation-defined values so that the following descriptions hold:

There are 8 bits in a character of the execution character set.
The representation and set of values for the type char are the same as that of type signed char . This equivalence can be changed from signed char to unsigned char with a command-line option.
On OpenVMS systems, the representation and set of values for the types int and signed int are the same as that for type long (32 bits).
On OpenVMS systems, the representation and set of values for the type unsigned int are the same as that for type unsigned long (32 bits).
On Tru64 UNIX systems, the long int and unsigned long int types are 64 bits, while int and unsigned int are 32 bits.
The representation and set of values for the type long double are the same as that for type double (64 bits).

Any limits not found in the previous list are defined as shown in the Standard.

B.7 Keywords (§3.1.1)

The __inline , __unaligned , and __restrict keywords are supported on OpenVMS Alpha systems and Tru64 UNIX systems.

All VAX C keywords are supported in VAX C mode. They are:

_align
globaldef
globalref
globalvalue
noshare
readonly
variant_struct
variant_union

The following keywords are accepted on Tru64 UNIX systems, but result in a warning:

_align
noshare
readonly

On Tru64 UNIX systems, globaldef and initialized globalvalue declarations are treated as external definitions. globalref and uninitialized globalvalue declarations are treated as if they were declared extern .

Note

The MAIN_PROGRAM option is also available with the VAX C compatibility option on OpenVMS systems.

B.8 Identifiers (§3.1.2)

An identifier can include the character dollar sign ($). (A warning is given for this in strict ANSI mode.)

On Tru64 UNIX systems, case distinctions are always significant in an identifier with external linkage.

On OpenVMS systems, all identifier names with external linkage are converted to uppercase by default, but this can be controlled with a command-line option.