Jump to 
content
HP.com Home Products and Services Support and Drivers Solutions How to Buy
»  Contact HP

 

HP C

HP C
User's Guide for OpenVMS Systems


Previous Contents Index


a = b + c - d; 


When bounds checking is enabled, the compiler outputs a check to verify that c is within the bounds of the array. This leads to an incorrect run-time trap in cases where c is outside the bounds of the array and c - d is not.

In these cases, the compiler outputs a diagnostic noting that the check code it produced is bad. You can then recode the pointer expression so that the integer part is in parentheses. In this way, the expression will contain only one pointer-arithmetic operation, and the compiler will output the correct check. In the previous example, the expression would be changed to:


a = b + (c - d); 

/CHECK=POINTER_SIZE

/CHECK=POINTER_SIZE directs the compiler to generate code that checks 64-bit pointer values (used in certain contexts where 32-bit pointers are also present) to make sure they will fit in a 32-bit pointer. If such a value cannot be represented by a 32-bit pointer, the run-time code signals a range error (SS$_RANGEERR).

To control the types of pointer-size checks you want made, use one or more of the POINTER_SIZE option keywords shown in Table 1-5.

Table 1-5 /CHECK =POINTER_SIZE Qualifier Options
Option Usage
[NO]ASSIGNMENT Check whenever a 64-bit pointer is assigned to a 32-bit pointer (including use as an actual argument).
[NO]CAST Check whenever a 64-bit pointer is cast to a 32-bit pointer.
[NO]INTEGER_CAST Check whenever a long pointer is cast to a 32-bit integer.
[NO]PARAMETER Check all formal parameters at function startup to make sure that all formal parameters declared to be 32-bit pointers are 32-bit values.
ALL Do all checks.
NONE Do no checks.

Specifying /CHECK=POINTER_SIZE defaults to /CHECK=POINTER_SIZE=(ASSIGNMENT,PARAMETER).

For information about compiler features that affect pointer size, see the following:

The following contrived program contains a number of pointer assignments. The comment on each line indicates what /CHECK=POINTER_SIZE keyword to specify to enable checking for that line.


    #pragma required_pointer_size long 
    int *a; 
    char *b; 
    typedef char * l_char_ptr; 
 
    #pragma required_pointer_size short 
    char *c; 
    int *d; 
 
    foo(int * e)              /* Check e if PARAMETER is specified. */ 
    { 
        d = a;                /* Check a if ASSIGNMENT is specified. */ 
        c = (char *) a;       /* Check a if CAST is specified. */ 
        c = (char *) d;       /* No checking ever. */ 
        foo( a );             /* Check a if ASSIGNMENT is specified. */ 
        bar( a );             /* No checking ever - no prototype */ 
        b = (l_char_ptr) a;   /* No checking ever. */ 
        c = (l_char_ptr) a;   /* Check a if ASSIGNMENT is specified */ 
        b = (char *) a;       /* Check if CAST is specified. */ 
    } 

/CHECK=[NO]ARG_INFO (I64 ONLY)

/CHECK=ARG_INFO generates code to verify the input parameters to functions defined in the compiled source. This code checks for datatype consistency between the caller and its called function.

When the runtime does parameter-type checking, only the following types are considered:

VAX single-precision floating-point
VAX double-precision floating-point - D_floating
VAX double-precision floating-point - G_floating
IEEE single-precision floating-point
IEEE double-precision floating-point
none-of-the-above "bucket"

It is only a mismatch of these types that is considered. So while the run-time code will catch a case of a VAX D_floating number passed to a function that expects a VAX single-precision number, it will not detect the case of an int passed to a function that expects a long double type (because both int and long double are viewed as the same type - that is, they both fall into the none-of-the-above bucket).

When a mismatch is found, a %SYSTEM-I-ARGTYP1 message is output at runtime for each argument slot whose type does not match the expected type.

This checking applies only to arguments passed in the first eight argument slots, and does not check that the number of arguments passed matches the number expected.

/CHECK=[NO]FP_MODE (I64 ONLY)

/CHECK=FP_MODE generates code in the prologue of every function defined in the compilation to compare the current values of certain fields in the processor's floating-point status register (FPSR) with the values expected in those fields based on the command-line qualifiers with which the function was compiled.

The values checked are the rounding mode and the trap-enable bits:

Note that the checking code generated for /CHECK=FP_MODE includes a standard call to OTS$CHECK_FP_MODE within the prologue of each function, and OTS$CHECK_FP_MODE itself assumes the standard calling conventions (described in the OpenVMS Calling Standard). Because of this, it is not possible to use this checking option when compiling function definitions that have a nonstandard linkage (see #pragma linkage and #pragma use_linkage ) specifying conventional scratch registers with the PRESERVED or NOTUSED attribute. Doing so will cause the compiler to issue the "REGCONFLICT" E-level diagnostic at the opening brace of such function definitions. To compile such functions successfully, the FP_MODE keyword must be removed from the list of /CHECK= keywords.

Defaults

Omitting this qualifier defaults to /NOCHECK, which equates to /CHECK=(NOUNINITIALIZED_VARIABLE,NOBOUNDS,NOPOINTER_SIZE,NOFP_MODE,NOARG INFO).

Specifying /CHECK defaults to /CHECK=(UNINITIALIZED_VARIABLES,BOUNDS, POINTER_SIZE=(ASSIGNMENT,PARAMETER),FP_MODE,ARG_INFO).

/[NO]COMMENTS=option

Governs whether or not comments appear in preprocess output files and, if they are to appear, whether they appear themselves or are replaced by a single space.

Table 1-6 shows the /COMMENTS qualifier options.

Table 1-6 /COMMENTS Qualifier Options
Option Usage
AS_IS Specifies that the comment appears in the output file.
SPACE Specifies that a single space replaces the comment in the output file.

/NOCOMMENTS specifies that nothing replaces the comment in the output file. This can result in inadvertent token pasting.

The HP C preprocessor might replace a comment at the end of a line or on a line by itself with nothing, even if /COMMENTS=SPACE is specified. Doing so does not change the meaning of the program.

The default is /COMMENTS=SPACE for the ANSI89, RELAXED, and MIA modes of the compiler. The default is /NOCOMMENTS for all other compiler modes.

Specifying /COMMENTS on the command line defaults to /COMMENTS=AS_IS.

/[NO]CROSS_REFERENCE

Specifies whether the compiler generates cross-references for variable names.

If you specify /CROSS_REFERENCE, the compiler lists, for each variable referenced in the procedure, the line numbers of the lines on which the variable is referenced.

This qualifier has no effect unless you also specify /LIST and either /SHOW=SYMBOLS or /SHOW=BRIEF. The default is /NOCROSS_REFERENCE.

/[NO]DEBUG[=(option[,...])]

Includes information in the object module for use by the OpenVMS Debugger.

If the /DEBUG qualifier is not specified, the default is:

Specifying /DEBUG with no keywords is equivalent to specifying /DEBUG=ALL.

Table 1-7 describes the debugger options.

Table 1-7 Debugger Compilation Options
Option Usage
ALL Includes symbol table records and traceback records for both VAX and Alpha systems. On VAX systems, this also selects the behavior of the INLINE keyword.

On Alpha and I64 systems, /DEBUG=ALL is equivalent to /DEBUG=(TRACEBACK,SYMBOLS).

On VAX systems, /DEBUG=ALL is equivalent to /DEBUG=(TRACEBACK,SYMBOLS,INLINE).

INLINE (VAX ONLY) Generates debug information to cause a STEP command to STEP/INTO an inlined function call.
NOINLINE (VAX ONLY) Generates debug information to cause a STEP command to STEP/OVER an inlined function call.
NONE Does not include any debugging information. This is equivalent to /NODEBUG.
NOTRACEBACK Suppresses generation of traceback records.
NOSYMBOLS Suppresses generation of symbol table records.
SYMBOLS Generates symbol table records.
TRACEBACK Generates traceback records.

/DECC

Invokes the HP C compiler.

On OpenVMS VAX systems, the CC command is used to invoke either the VAX C or HP C compiler. If your system has a VAX C compiler already installed on it, the HP C installation procedure provides the option of specifying which compiler will be invoked by default when just the CC command is used. To invoke the compiler that is not the default, use the CC command with the appropriate qualifier: CC/DECC for the HP C compiler, or CC/VAXC for the VAX C compiler. If your system does not have a VAX C compiler installed on it, the CC command will invoke the HP C compiler.

On OpenVMS Alpha and I64 systems, specifying /DECC is equivalent to not specifying it; this qualifier is supported to provide compatibility with HP C on OpenVMS VAX systems.

/[NO]DEFINE=(identifier[=definition][,...])
/[NO]UNDEFINE=(identifier[,...])

Performs the same functions as the #define and #undef preprocessor directives. The /DEFINE qualifier defines a macro to be substituted for every occurrence of a given identifier in the compilation unit or units. The /UNDEFINE qualifier cancels a previous definition (but not subsequent ones). When both /DEFINE and /UNDEFINE are present in a compilation unit or on the CC command line, /DEFINE is evaluated before /UNDEFINE.

Since /DEFINE and /UNDEFINE are not part of the source file, they are not associated with a listing line number or source line number. Therefore, when an error occurs in a command-line definition, the message displayed at the terminal does not indicate a line number. In the listing file, these diagnostic messages are placed before the source listing in the order that they were encountered. When the expansion of a definition causes an error at a specific source line in the program, the diagnostics---both at the terminal and in the listing file---are associated with that source line.

A command line containing the /DEFINE and the /UNDEFINE qualifiers can be long. Continuation characters cannot appear within quotes or they will be included in the macro stream. The length of a CC command line cannot exceed the maximum length allowed by DCL.

The /NODEFINE and /NOUNDEFINE qualifiers are provided for compatibility with other DCL qualifiers. You can use these qualifiers to cancel /DEFINE or /UNDEFINE qualifiers that you have specified in a symbol that you use to compile HP C programs.

The defaults are /NODEFINE and /NOUNDEFINE.

Usage and Examples

Since the CC command line must be compatible with DCL, the syntax of the /DEFINE and /UNDEFINE qualifiers differs from the syntax of the #define and #undef preprocessor directives in the following way:

You can pass an equal sign to the compiler in any of the following ways:


$ CC/DEFINE=(EQU==,"equ =","equal==")

In the first definition, the first equal sign is removed by DCL as the delimiter; the second equal sign is passed to the compiler. In the second example, the space is recognized as a delimiter because the definition is inside quotes; therefore, only one equal sign is required. In the third definition, the first equal sign is recognized as the delimiter and is removed; the second equal sign is passed to the compiler.

You can pass quotation marks in any of the following ways:


$ CC/DEFINE=(QUOTES="""","funct(b)=printf(")")

In both examples, DCL removes the first and last quotation marks before passing the definition to the compiler.

Here is a simple use of the /UNDEFINE qualifier to cancel a previous definition of TRUE:


$ CC/UNDEFINE=TRUE

The /UNDEFINE qualifier is useful for undefining the predefined HP C preprocessor constants. For example, if you use a preprocessor system identification macro (such as __vaxc , __VAXC , __DECC , or __vms ) to conditionally compile segments of HP C specific code, you can undefine that constant to see how the portable sections of your program execute. Consider the following program:


main() 
{ 
#if __DECC 
printf("I'm being compiled with HP C on an OpenVMS system."); 
#else 
printf("I'm being compiled on some other compiler."); 
#endif 
} 

This program produces the following output:


$ CC  EXAMPLE.C[Return]
$ LINK  EXAMPLE.OBJ[Return]
$ RUN  EXAMPLE.EXE[Return]
I'm being compiled with HP C on an OpenVMS system.
$ CC/UNDEFINE="__DECC" EXAMPLE [Return]
$ LINK  EXAMPLE.OBJ[Return]
$ RUN  EXAMPLE.EXE[Return]
I'm being compiled on some other compiler.

/[NO]DIAGNOSTICS[=file-spec]

Creates a file containing compiler messages and diagnostic information. The default file extension for a diagnostics file is .DIA. The diagnostics file is used with the HP Language-Sensitive Editor (LSE). To display a diagnostics file, enter the command REVIEW/FILE=file-spec while in LSE. For more information, see Appendix C. The default is /NODIAGNOSTICS.

/ENDIAN=option

This qualifier takes the options BIG or LITTLE.

It controls whether big or little endian ordering of bytes is carried out in character constants. For example, consider the following declaration:


int foo = 'ABCD'; 

Specifying /ENDIAN=LITTLE places 'A' in the first byte, 'B' in the second byte, and so on.

Specifying /ENDIAN=BIG places 'D' in the first byte, 'C' in the second byte, and so on.

The default is /ENDIAN=LITTLE.

/[NO]ERROR_LIMIT[=n]

This qualifier limits the number of Error-level diagnostic messages that are acceptable during program compilation. Compilation terminates when the limit n is exceeded. /NOERROR_LIMIT specifies that there is no limit on error messages.

The default is /ERROR_LIMIT=30, which specifies that compilation terminates after 31 error messages.

/EXTERN_MODEL=option

In conjunction with the /[NO]SHARE_GLOBALS qualifier, controls the initial compiler model for external objects. Conceptually, the compiler behaves as if the first line of the program being compiled was a #pragma extern_model with the model and psect name, if any, specified by the /EXTERN_MODEL qualifier and with the shr or noshr keyword specified by the /[NO]SHARE_GLOBALS qualifier.

For example, assume the command line contains the following qualifiers:


/EXTERN_MODEL=STRICT_REFDEF="MYDATA"/NOSHARE 

The compiler will behave as if the program begins with the following line:


#pragma extern_model strict_refdef "MYDATA" noshr 

Table 1-8 describes the /EXTERN_MODEL qualifier options.

Table 1-8 /EXTERN_MODEL Qualifier Options
Option Usage
COMMON_BLOCK Sets the compiler's extern_model to the common_block model. This is the model traditionally used for extern data by VAX C.
RELAXED_REFDEF Sets the compiler's extern_model to the relaxed_refdef model. Some declarations are references and some are definitions. Multiple uninitialized definitions for the same object are allowed and are resolved into one by the linker. However, a reference requires that at least one definition exist.

This is the model used by the portable C compiler ( pcc ) on UNIX systems.

STRICT_REFDEF [=" name"] Sets the compiler's extern_model to the strict_refdef model. Some declarations are references and some are definitions. There must be exactly one definition in the program for any symbol referenced. The optional name, in quotation marks, is the name of the psect for any definitions.

This is the model specified by standard C. Use it in a program that is to be a strict standard-conforming program.

This model is the preferred alternative to the nonstandard storage-class keywords globaldef and globalref .

GLOBALVALUE Sets the compiler's extern_model to the globalvalue model. This model is similar to the strict_refdef model except that these global objects have no storage; instead, they are link-time constant values. There are two cases:
  • If the declaration is a standard C reference, the same object file records are produced as VAX C would produce for an uninitialized globalvalue .
  • If the declaration is a standard C definition, the same object records are produced as VAX C would produce for an initialized globalvalue .

This model is the preferred alternative to the nonstandard storage-class keyword globalvalue .

The default is /EXTERN_MODEL=RELAXED_REFDEF. This is different from VAX C, which uses the common block model for external objects.

/[NO]FIRST_INCLUDE=(file[,...])

Includes the specified files before any source files. This qualifier corresponds to the Tru64 UNIX -FI switch.

This qualifier is useful if you have command lines to pass to the C compiler that are exceeding the DCL command-line length limit. Using the /FIRST_INCLUDE qualifier can help solve this problem by replacing lengthy /DEFINE and /WARNINGS qualifiers with #define and #pragma message preprocessor directives placed in a /FIRST_INCLUDE file.

When /FIRST_INCLUDE=file is specified, file is included in the source as if the line before the first line of the source was:


#include "file" 

If more than one file is specified, the files are included in their order of appearance on the command line.

The default is /NOFIRST_INCLUDE.

/FLOAT=option

Controls the format of floating-point variables.

Table 1-9 describes the /FLOAT qualifier options.

Table 1-9 /FLOAT Qualifier Options
Option Usage
D_FLOAT double variables are represented in D_floating format. The __D_FLOAT macro is predefined.
G_FLOAT double variables are represented in G_floating format. The __G_FLOAT macro is predefined.
IEEE_FLOAT float and double variables are represented in IEEE floating-point format (S_float and T_float, respectively). The __IEEE_FLOAT macro is predefined. Use the /IEEE_MODE qualifier for controlling the handling of IEEE exceptional values. If /IEEE_MODE is not specified, the default behavior is /IEEE_MODE=FAST for Alpha systems and /IEEE_MODE=DENORM_RESULTS for I64 systems.


Previous Next Contents Index

Privacy statement Using this site means you accept its terms
© 2007 Hewlett-Packard Development Company, L.P.