|
|
|
|
|
 |
HP C
|
| Previous | Contents | Index |
The result of accessing a union member different than the member holding a value depends on the data types of the members and their alignment within the union.
The type of the sizeof operator is size_t . HP C defines this type, which is the type of integer required to hold the maximum size of an array, in the <stddef.h> header as unsigned int .
The Standard specifies that a pointer can be converted to an integral type, but the size of the integer required and the result are implementation-defined. A pointer occupies the same amount of storage as objects of type int or long (or their unsigned equivalents). Therefore, a pointer can be converted to any of these integer types and back again without changing its value. No scaling takes place, and the representation of the value does not change.
Converting between a pointer and a shorter integer type, such as char , is similar to the conversion between an object of unsigned long type and a shorted integer type. The high-order bits of the pointer are discarded. Converting between a shorter integer and a pointer is similar to the conversion between the shorter integer type and unsigned long . The high-order bits of the pointer are filled with copies of the sign bit if the shorter integer type was signed. Messages are issued for cast operations of these types under the error-checking compiler option.
The Standard does not provide portable semantics for the division and remainder operators. HP C follows these semantics:
The compiler issues a warning in the following cases of undefined behavior detected at compile time:
Pointers to members of the same array can be subtracted. The result is the number of elements between the two array members. The type of the result is ptrdiff_t . HP C defines this type as int .
The result of E1 >> E2 is E1 right-shifted E2 bit positions. If E1 has a signed type, the value of the result is the shifted value of E1 with the vacated high-order bits filled with a copy of E1 's sign bit (arithmetic shift).
The register storage-class specifier suggests that access to the object be as fast as possible. Specifying register is intended to give a variable an increased probability of being stored in a register. However, compiler register allocation techniques make using the register keyword obsolete. That is, HP C accepts and ignores all register requests.
The combination long float is supported as a synonym for double for compatibility with common C and VAX C. This combination results in a warning if compiled with the default mode or the strict ANSI mode.
The high-order bit position of an int bit field is not treated as a sign bit, except in the VAX C compatibility mode. In other words, the type int designates the same type as unsigned int for all bit-field types. In VAX C mode, the type int designates the same type as signed int for all bit-field types.
Variant structures and unions are VAX C extensions that allow nested structures and unions to be declared as members of the enclosing aggregate. This eliminates the need to specify an intermediate qualifier when referring to those members. These capabilities are only available in VAX C mode.
Your platform-specific HP C documentation contains details about these extensions.
The alignment and size of a structure is affected by the alignment requirements and sizes of the structure components for each platform. A structure can begin on any byte boundary and occupy any integral number of bytes. However, individual architectures or operating systems can specify particular default alignment and padding requirements, which can be overridden by pragmas and command-line options.
On OpenVMS Alpha and Tru64 UNIX systems, nonbit-field structure members are, by default, aligned on natural boundaries.
The default alignment of a structure is the maximum alignment required by any member within the structure. The structure is padded to ensure that the size of a structure, in bytes, is a multiple of its alignment requirement to achieve the appropriate alignment when the structure or union is a member of an array.
The components of a structure are laid out in memory in the order they are declared. The first component has the same address as the entire structure. Padding is introduced between components to satisfy the alignment requirements of individual components.
A bit field can have any integral type. However, the compiler issues a warning with the error-checking option if the type is anything other than int , unsigned int , or signed int . The presence of bit fields causes the alignment of the whole structure or union to be at least the same as that of the bit field's base type.
Bit fields (including zero-length bit fields) not immediately declared following other bit fields have the alignment requirement imposed by their base type. Bit fields are allocated within the alignment unit (of the same size as the bit field's base type) from low-order to high-order.
With #pragma member_alignment in effect, if a bit field immediately follows another bit field, the bits are packed into adjacent space in the same unit, if sufficient space remains. Otherwise, padding is inserted at the end of the first bit field and the second bit field is put into the next unit.
With #pragma nomember_alignment in effect, bit fields are allowed to span storage unit boundaries. Alpha systems default to member_alignment while VAX systems default to nomember_alignment .
Bit fields of base type char cannot be larger than 8 bits. Bit fields of base type short cannot be larger than 16 bits.
OpenVMS VAX systems do not require that structures or structure members be aligned on any particular boundaries; nonbit-field structure members are byte-aligned by default.
The components of a structure are laid out in memory in the order they are declared. The first component has the same address as the entire structure. Each additional component follows its predecessor in the immediately following byte.
Natural alignment of structure members, can be obtained by using the following pragma:
pragma member_alignment |
The HP C User's Guide for OpenVMS Systems has examples and diagrams of OpenVMS VAX structure alignment.
Bit fields can have any integral type. However, the compiler issues a warning if /STANDARD=ANSI89 is specified, and the type is other than int , unsigned int , or signed int . Bit fields are allocated within the unit from low order to high order. If a bit field immediately follows another bit field, the bits are packed into adjacent space, even if this overflows into another byte. However, if an unnamed bit field is specified to have length 0, filler is added so the bit field immediately following starts on the next byte boundary.
The HP C User's Guide for OpenVMS Systems has examples and diagrams of OpenVMS VAX bit-field alignment.
The Standard specifies that each enumerated type be compatible with an implementation-defined integer type. In HP C, each enumerated type is compatible with the signed int type.
The volatile storage class is specified for those variables that can be modified in ways unknown to the compiler. Thus, if an object is declared volatile, every reference to the object in the source code results in a reference to memory in the object code.
There is no internal limit on the number of pointer, function or array declarators that can modify an arithmetic, structure, union, or incomplete type.
C allows initializers to be optionally surrounded by braces ( { } ) when they are not logically necessary. This has resulted in aggregate initializers with partially ignored braces that are parsed differently depending on the type of parser implemented (bottom-up or top-down). The Standard has specified the top-down parse originally specified in Kernighan and Ritchie's The C Programming Language. Programs depending on a bottom-up parse (common C parse) of partially braced initializers can yield unexpected results. Even though this construct is allowed, a warning message is given to inform the user of ignored braces when in common C mode or if using the check option.
There is no limit on the number of case labels in a switch statement.
In common C mode, all extern objects have file scope.
Previous preprocessors have allowed extraneous text after a preprocessor directive. For example:
#endif system1
|
However, the Standard has stated that the only text allowed after a preprocessing directive is a comment. Therefore, the HP C compiler issues a warning message if this syntax rule is violated.
The numeric value for character constants within #if and #elif directives matches the value obtained when an identical character constant occurs in expressions that are not part of these directives.
Source files can be included using either a quoted path name ( #include "stdio.h" ) or bracketed path names ( #include <stdio.h> ). OpenVMS systems also support a method of including modules from a text library. See your platform-specific HP C documentation for the search-path algorithm for including source files.
In addition to the predefined macro names defined in the Standard, the HP C compiler defines other preprocessor macros for various identification purposes. When the compiler is invoked, the appropriate identification macros are defined depending on the operating system, architecture, language, compiler mode, and other environment variables. You can reference these macros in #ifdef preprocessor directives to isolate code that applies to a particular environment.
Each HP C platform can have additional predefined macros. See your platform-specific HP C documentation for more information.
Table B-1 shows the predefined macro names for Tru64 UNIX.
Table B-2 shows the predefined macro names for OpenVMS VAX and Alpha systems. All forms are defined unless strict ANSI mode is in effect, in which case only the new spellings are defined.
You can explicitly define the macros in Table B-3 to control which C library routines are declared in header files and to obtain standards conformance checking. To define these macros use one of the following:
The ## operator within a macro replacement list causes the two tokens on either side of the operator to be concatenated into a single token.
In common C and VAX C compatibility mode, comments can also concatenate two tokens because in these modes a comment is replaced by a null string after macro invocations.
This behavior is not supported in strict ANSI or default mode, where comments are replaced with a single space.
The #error directive causes an error message to be issued and the compilation to cease.
The Standard's approved method of adding extensions to the language is through the addition of pragmas. All unrecognized pragmas are diagnosed with an informational message. Supported pragmas vary across platforms. See your platform-specific HP C documentation for more information.
When only preprocessing a file, all pragmas recognized by HP C are written unaltered to the output.
Function inline expansion eliminates procedure-call overhead and allows general optimization methods to apply across the expanded code. Function inlining has advantages over macros in that arguments are evaluated only once, parentheses need not be overused to avoid problems with precedence, and the actual expansion can be controlled from the command line.
The following pragmas are provided to control function inline expansion:
#pragma inline (function_name [,function_name....]) #pragma noinline (function_name [,function_name....]) |
If a function is named in an inline directive, calls to it are expanded as inline code, if the function has the following properties:
Inline functions have the following properties:
| Previous | Next | Contents | Index |
|
|||||||||||
