A.2.2 Declarations

declaration: (§3.5) declaration-specifiers init-declarator-listopt ;

declaration-specifiers: (§3.5) storage-class-specifier declaration-specifiersopt type-specifier declaration-specifiersopt type-qualifier declaration-specifiersopt

init-declarator-list: (§3.5) init-declarator init-declarator-list , init-declarator

init-declarator: (§3.5) declarator declarator = initializer

storage-class-specifier: (§3.5.1) typedef extern static auto register

type-specifier: (§3.5.2) void char short int long float double signed unsigned _Bool _Complex (ALPHA, I64)

struct-or-union-specifier enum-specifier typedef-name

struct-or-union-specifier: (§3.5.2.1) struct-or-union identifieropt { struct-declaration-list } struct-or-union identifier

struct-or-union: (§3.5.2.1) struct union

struct-declaration-list: (§3.5.2.1) struct-declaration struct-declaration-list struct-declaration

struct-declaration: (§3.5.2.1) specifier-qualifier-list struct-declarator-list ;

specifier-qualifier-list: (§3.5.2.1) type-specifier specifier-qualifier-listopt type-qualifier specifier-qualifier-listopt

struct-declarator-list: (§3.5.2.1) struct-declarator struct-declarator-list , struct-declarator

struct-declarator: (§3.5.2.1) declarator declaratoropt : constant-expression

enum-specifier: (§3.5.2.2) enum identifieropt {enumerator-list } enum identifieropt {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) pointeropt direct-declarator

direct-declarator: (§3.5.4) identifier ( declarator ) direct-declarator [ constant-expressionopt ] direct-declarator ( parameter-type-list ) direct-declarator ( identifier-listopt )

pointer: (§3.5.4) * type-qualifier-listopt * type-qualifier-listopt 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-declaratoropt

identifier-list: (§3.5.4) identifier identifier-list , identifier

type-name: (§3.5.5) specifier-qualifier-list abstract-declaratoropt

abstract-declarator: (§3.5.5) pointer pointeropt direct-abstract-declarator

direct-abstract-declarator: (§3.5.5) ( abstract-declarator ) direct-abstract-declaratoropt [ constant-expressionopt ] direct-abstract-declaratoropt ( parameter-type-listopt )

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.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-listopt statement-listopt }

declaration-list: (§3.6.2) declaration declaration-list declaration

statement-list: (§3.6.2) statement statement-list statement

expression-statement: (§3.6.3) expressionopt ;

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 ( expressionopt ; expressionopt ; expressionopt ) statement

jump-statement: (§3.6.6) goto identifier ; continue ; break ; return expressionopt ;

A.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-specifiersopt declarator declaration-listopt compound-statement

A.3 Preprocessing Directives

preprocessing-file: (§3.8) groupopt

group: (§3.8) group-part group group-part

group-part: (§3.8) pp-tokensopt new-line if-section control-line

if-section: (§3.8.1) if-group elif-groupsopt else-groupopt endif-line

if-group: (§3.8.1) #if constant-expression new-line groupopt #ifdef identifier new-line groupopt #ifndef identifier new-line groupopt

elif-groups: (§3.8.1) elif-group elif-groups elif-group

elif-group: (§3.8.1) #elif constant-expression new-line groupopt

else-group: (§3.8.1) #else new-line groupopt

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-tokensopt new-line (§3.8.5) #pragma pp-tokensopt 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-tokensopt

pp-tokens: (§3.8) preprocessing-token pp-tokens preprocessing-token

new-line: (§3.8) the new-line character

HP 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). HP C has successfully passed the Plum-Hall test suite for ANSI conformance. In strict ANSI C mode, the HP 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 HP 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, HP 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 HP C language. Together with the ANSI C Standard, this section completely specifies the HP 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 HP 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, HP C avoids imposing translation limits.

The following lists show the only limits imposed in HP C. Translation limits listed in the Standard, but not in the following list, are not imposed in HP 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)

HP 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.