1 CC Online Help for VSI C Version 7.4 The CC command invokes the VSI C compiler to compile C source programs. The syntax is: CC file-spec,... +library-file-spec/LIBRARY... 2 Command_Parameters file-spec,... One or more VSI C source files separated by plus signs or commas. If plus signs are used, the input files are concatenated into a single object file. If commas are used, each file is compiled separately to create separate object files. If no input file extension is specified, VSI C assumes the .C default file extension. library-file-spec A text library containing #include modules referenced in one or more of the source files. A library file specification must be concatenated with a file specification with a plus sign and qualified using the /LIBRARY qualifier. If the input file extension is not specified, VSI C assumes the .TLB default file extension. 2 Qualifiers Indicate special actions to be performed by the compiler or special input file properties. Compiler qualifiers can apply to either the CC command or to the specification of the file being compiled. When a qualifier follows the CC command, it applies to all the files listed. When a qualifier follows the file specification, it applies only to the file immediately preceding it. The following list shows all the qualifiers available with the CC command: o /ACCEPT(option[,...]) o /[NO]ANALYSIS_DATA[=file-spec] o /[NO]ANNOTATIONS[=(option,...)] o /[NO]ANSI_ALIAS o /ARCHITECTURE=option o /ASSUME=(option[,...]) o /[NO]CHECK[=(option[,...])] o /COMMENTS={AS_IS | SPACE} o /[NO]CROSS_REFERENCE o /[NO]DEBUG[=(option[,...])] o /DECC o /[NO]DEFINE=(identifier[=definition][,...]) o /[NO]DIAGNOSTICS[=file-spec] o /ENDIAN=option o /ERROR_LIMIT[=number] o /EXTERN_MODEL=option o /[NO]FIRST_INCLUDE=(file[,...]) o /FLOAT=option o /GRANULARITY o /IEEE_MODE=option o /[NO]INCLUDE_DIRECTORY=(pathname[,...]) o /L_DOUBLE_SIZE=option o /LIBRARY o /[NO]LINE_DIRECTIVES o /[NO]LIST[=file-spec] o /[NO]MACHINE_CODE o /[NO]MEMBER_ALIGNMENT o /[NO]MMS_DEPENDENCIES[=(option[,option])] o /NAMES=(option1,option2) o /NESTED_INCLUDE_DIRECTORY[=option] o /[NO]OBJECT[=file-spec] o /[NO]OPTIMIZE[=option] o /PDSC_MASK=option o /[NO]PLUS_LIST_OPTIMIZE o /[NO]POINTER_SIZE=option o /PRECISION={SINGLE | DOUBLE} o /[NO]PREFIX_LIBRARY_ENTRIES o /[NO]PREPROCESS_ONLY[=filename] o /[NO]PROTOTYPE[=(option[,...])] o /PSECT_MODEL=[NO]MULTILANGUAGE o /REENTRANCY=option o /REPOSITORY=option o /ROUNDING_MODE=option o /[NO]SHARE_GLOBALS o /SHOW[=(option[,...])] o /[NO]STANDARD=(option) o /[NO]TIE o /[NO]UNDEFINE=(identifier[,...]) o /[NO]UNSIGNED_CHAR o /[NO]VERSION o /[NO]WARNINGS[=(option[,...])] 2 /ACCEPT /ACCEPT=(option[,option]) Allows the compiler to accept C language syntax that it might not normally accept. VSI C accepts slightly different syntax depending upon the compilation mode specified with the /STANDARD qualifier. The /ACCEPT qualifier can fine tune the language syntax accepted by each /STANDARD mode. Specify one of the following qualifier options: [NO]C99_KEYWORDS Controls whether or not the C99 Standard keywords inline and restrict (which are are in the C89 namespace for user identifiers) are accepted without double leading underscores. The spelling with two leading underscores (__inline, __restrict) is in the namespace reserved to the compiler implementation and is always recognized as a keyword regardless of this option. In /STANDARD=RELAXED mode, the default is C99_KEYWORDS. In all other compiler modes, the default is NOC99_KEYWORDS. [NO]GCCINLINE The gcc compiler implements an inline function qualifier for functions with external linkage that gives similar capabilites as the C9x extern inline feature for functions, but the usage details are somewhat different: the combination of extern and inline keywords makes an inline definition, instead of the exlusive use of the inline keyword without the extern keyword. This option controls which variation of the feature is implemented. In all compiler modes, the default is NOGCCINLINE. [NO]TRIGRAPHS Turns trigraph support on or off. In COMMON and VAXC compiler modes, trigraphs are disabled by default. In all other modes, they are enabled by default. [NO]VAXC_KEYWORDS Controls whether or not the compiler recognizes the VAX C keywords (such as "readonly") regardless of the /STANDARD mode used. [NO]RESTRICT_KEYWORD Controls whether or not the compiler recognizes the C9x standard restrict keyword regardless of the /STANDARD mode used. This only affects recognition of the spelling of the keyword as proposed for inclusion in the C9x standard. The spelling with two leading underscores, __restrict, is in the namespace reserved to the compiler implementation, and it is always recognized as a keyword regardless of this option. Note that [NO]RESTRICT_KEYWORD is a subset of [NO]C99_KEYWORDS. They have the same compiler-mode defaults. The default values are based upon the settings of the /STANDARD qualifier: For /STANDARD=RELAXED the default is: /ACCEPT=(VAXC_KEYWORDS,C99_KEYWORDS,NOGCCINLINE,TRIGRAPHS) For /STANDARD=VAXC, the default is: /ACCEPT=(VAXC_KEYWORDS,NOC99_KEYWORDS,NOGCCINLINE,NOTRIGRAPHS) For /STANDARD=COMMON, the default is: /ACCEPT=(NOVAXC_KEYWORDS,NOC99_KEYWORDS,NOGCCINLINE,NOTRIGRAPHS) For /STANDARD=C99 or /STANDARD=LATEST, the default is: /ACCEPT=(NOVAXC_KEYWORDS,C99_KEYWORDS,NOGCCINLINE,TRIGRAPHS) In all other modes, the default is: /ACCEPT=(NOVAXC_KEYWORDS,NOC99_KEYWORDS,NOGCCINLINE,TRIGRAPHS) 2 /ANALYSIS_DATA /ANALYSIS_DATA[=file-spec] /NOANALYSIS_DATA (D) Controls whether the compiler generates a file of source code analysis information. The default file name is the file name of the primary source file; the default file type is .ANA. 2 /ANNOTATIONS /ANNOTATIONS[=(option,...)] /NOANNOTATIONS (D) Controls whether or not the source listing file is annotated with indications of specific optimizations performed or, in some cases, not performed. These annotations can be helpful in understanding the optimization process. Select one or more of the following /ANNOTATIONS qualifier options: ALL Selects all annotations. This output can be quite verbose because it includes detailed output for all annotations. For more concise output for each kind of annotation, use /ANNOTATIONS=(ALL,NODETAIL), or just /ANNOTATIONS with no qualifier options. [NO]CODE Annotates the machine-code listing with descriptions of special instructions used for prefetching, alignment, and so on. The /MACHINE_CODE qualifier must also be specified for /ANNOTATION=CODE to have any visible effect. [NO]DETAIL Provides additional level of annotation detail, where available. [NO]FEEDBACK Indicates use of profile-directed feedback optimizations. Feedback optimizations are not implemented on OpenVMS systems, so this keyword has no visible effect. [NO]INLINING Indicates where code for a called procedure was expanded inline. [NO]LOOP_TRANSFORMS Indicates optimizations such as loop reordering and code hoisting. [NO]LOOP_UNROLLING Indicates where advanced loop nest optimizations have been applied to improve cache performance (unroll and jam, loop fusion, loop interchange, and so on). [NO]PREFETCHING Indicates where special instructions were used to reduce memory latency. [NO]SHRINKWRAPPING Indicates removal of code establishing routine context when it is not needed. [NO]SOFTWARE_PIPELINING Indicates where loops have been scheduled to hide functional unit latency. [NO]TAIL_CALLS Indicates an optimization where a call from routine A to B can be replaced by a jump. [NO]TAIL_RECURSION Indicates an optimization that eliminates unnecessary routine context for a recursive call. NONE Same as /NOANNOTATIONS. The default is /NOANNOTATIONS. Specifying /ANNOTATIONS with no keywords is the same as specifying /ANNOTATIONS=(ALL,NODETAIL). 2 /ANSI_ALIAS /ANSI_ALIAS /NOANSI_ALIAS (D) Directs the compiler to assume the ANSI C aliasing rules, thus giving it the freedom to generate better optimized code. The aliasing rules are explained in Section 3.3, paragraphs 20 and 25 of the ANSI C Standard. The default is /NOANSI_ALIAS for the /STANDARD=VAXC and /STANDARD=COMMON compiler modes. The default is /ANSI_ALIAS for all other modes. 2 /ARCHITECTURE /ARCHITECTURE=options /ARCHITECTURE=GENERIC (D) Determines the Intel processor instruction set to be used by the compiler. The /ARCHITECTURE qualifier uses the same keyword options (keywords) as the /OPTIMIZE=TUNE qualifier. Where the /OPTIMIZE=TUNE qualifier is primarily used by certain higher-level optimizations for instruction scheduling purposes, the /ARCHITECTURE qualifier determines the type of code instructions generated for the program unit being compiled. OpenVMS Version 7.1 and subsequent releases provide an operating system kernel that includes an instruction emulator. This emulator allows new instructions, not implemented on the host processor chip, to execute and produce correct results. Applications using emulated instructions will run correctly, but may incur significant software emulation overhead at runtime. The following /ARCHITECTURE option is supported: ITANIUM2 Generates code for the Intel Itanium 2 processor. 2 /ASSUME /ASSUME=(option[,...]) Controls compiler assumptions. You may select the following options: [NO]ACCURACY_SENSITIVE Specifies whether certain code transformations that affect floating-point operations are allowed. These changes may or may not affect the accuracy of the program's results. If you specify NOACCURACY_SENSITIVE, the compiler is free to reorder floating-point operations, based on algebraic identities (inverses, associativity, and distribution). This allows the compiler to move divide operations outside of loops, improving performance. The default, ACCURACY_SENSITIVE, directs the compiler to use only certain scalar rules for calculations. This setting can prevent some optimization. [NO]ALIGNED_OBJECTS Controls an optimization for dereferencing pointers. On OpenVMS Alpha systems, dereferencing a pointer to a longword- or quadword-aligned object is more efficient than dereferencing a pointer to a byte- or word-aligned object. Therefore, the compiler can generate more optimized code if it makes the assumption that a pointer object of an aligned pointer type does point to an aligned object. Since the compiler determines the alignment of the dereferenced object from the type of the pointer, and the program is allowed to compute a pointer that references an unaligned object (even though the pointer type indicates that it references an aligned object), the compiler must assume that the dereferenced object's alignment matches or exceeds the alignment indicated by the pointer type. The default, /ASSUME=ALIGNED_OBJECTS, allows the compiler to make such an assumption. With this assumption made, the compiler can generate more efficient code for pointer dereferences of aligned pointer types. To prevent the compiler from assuming the pointer type's alignment for objects that it points to, use the /ASSUME=NOALIGNED_OBJECTS qualifier. [NO]CLEAN_PARAMETERS Controls compiler assumptions about short-integer formal parameters. The Alpha Calling Standard requires integers less than 64 bits long that are passed by value to have their upper bits either zeroed or sign-extended to make full 64-bit values. These are referred to as clean parameters. Some old code does not follow this convention. This can cause problems if the called program assumes that the caller followed the Calling Standard by passing only clean parameters. Specifying /ASSUME=NOCLEAN_PARAMETERS allows a program to be called by old code that might pass unclean integer parameters. It directs the compiler to generate run-time code to clean the short integers so they comply with the Calling Standard. The default is /ASSUME=CLEAN_PARAMETERS. [NO]EXACT_CDD_OFFSETS Controls the alignment of Control Data Dictionary records. If /ASSUME=EXACT_CDD_OFFSETS is specified, the records input from the CDD are given the exact alignment (relative to the start of the record) specified by the CDD definition. This alignment is independent of the current compiler member-alignment setting. If /ASSUME=NOEXACT_CDD_OFFSETS is specified, the compiler may modify the offsets specified in a CDD record according to the current member-alignment setting. The default is /ASSUME=NOEXACT_CDD_OFFSETS. [NO]HEADER_TYPE_DEFAULT Specifies whether the default file-type mechanism (.h) for header files is enabled (HEADER_TYPE_DEFAULT) or disabled (NOHEADER_TYPE_DEFAULT). The default is /ASSUME=HEADER_TYPE_DEFAULT. [NO]MATH_ERRNO Controls whether or not intrinsic code is generated for math functions that set the errno variable. The default is /ASSUME=MATH_ERRNO, which does not allow intrinsic code for such math functions to be generated, even if /OPTIMIZE=INTRINSICS is in effect. Their prototypes and call formats, however, are still checked. [NO]POINTERS_TO_GLOBALS Controls whether or not the compiler can safely assume that global variables have not had their addresses taken in code that is not visible to the current compilation. The default, /ASSUME=POINTERS_TO_GLOBALS, assumes that global variables have had their addresses taken in separately compiled modules and that, in general, any pointer dereference could be accessing the same memory as any global variable. This is often a significant barrier to optimization. The /ANSI_ALIAS qualifier allows some resolution based on data type, but /ASSUME=NOPOINTER_TO_GLOBALS provides significant additional resolution and improved optimization in many cases. [NO]WEAK_VOLATILE Affects the generation of code for assignments to objects that are less than or equal to 16 bits in size (for example: char, short) that have been declared as volatile. Specifying /ASSUME=WEAK_VOLATILE directs the compiler to generate code for volatile assignments to single bytes or words without using the load-locked store-conditional sequences that, in general, are required to assure volatile data integrity when direct byte or word memory-access instructions are not being used. This option is intended for use in special I/O hardware access situations, and should not generally be used. The default is /ASSUME=NOWEAK_VOLATILE, which uses interlocked instructions for sub-longword volatile accesses when byte or word instructions are not enabled. [NO]WHOLE_PROGRAM Asserts to the compiler that except for "well-behaved library routines," the whole program consists only of the single object module being produced by this compilation. The optimizations enabled by /ASSUME=WHOLE_PROGRAM include all those enabled by /ASSUME=NOPOINTER_TO_GLOBALS, and possibly additional optimizations as well. The default is /ASSUME=NOWHOLE_PROGRAM. [NO]WRITABLE_STRING_LITERALS Stores string constants in a writable psect. Otherwise, such constants will be placed in non-writable psect. For /STANDARD=VAXC or /STANDARD=COMMON, the default is /ASSUME=WRITABLE_STRING_LITERALS. For all other compiler modes, the default is /ASSUME=NOWRITABLE_STRING_LITERALS. 2 /CHECK /CHECK[=ALL|NONE|([NO]UNINITIALIZED_VARIABLES, [NO]BOUNDS, [NO]POINTER_SIZE[=(option,...)], [NO]FP_MODE, [NO]ARG_INFO)] /NOCHECK (D) This qualifier is for use only as a debugging aid. It should not be used to build production code without carefully assessing its performance impact on the application in question for each platform on which the application runs. For example, the I64-only FP_MODE check can add significant overhead to every function in the compilation, even if the application uses little or no floating point. /CHECK=NONE is equivalent to /NOCHECK. /CHECK=ALL is equivalent to /CHECK=(UNINITIALIZED_VARIABLES,BOUNDS,POINTER_SIZE=ALL,FP_MODE,ARG_INFO). /CHECK=UNINITIALIZED_VARIABLES initializes all automatic variables to the value 0x7ff580057ff58005. This value is a double signaling NaN and, if used as a floating-point value in certain double operations, causes a floating-point trap if traps are enabled. Traps are not enabled if the program is compiled /FLOAT=IEEE and the /IEEE value is something other than FAST. On I64 systems: o Traps are not caused when values are converted to an integer type. o The float type does not trap. /CHECK=BOUNDS enables run-time checking of array bounds. Array-bounds processing is performed in the following way: o Checks are done only when accessing an array. o Checks are not done when accessing a pointer, even if that access is done using the subscript operator. This means that checks are not done on arrays declared as formal parameters because they are considered pointers in the C language. If a formal parameter is a multi-dimension array, all bounds except the first are checked. o If an array is accessed using the subscript operator (as either the left or right operand), and the subscript operator is not the operand of an address-of operator, the check is for the index to be between 0 and the number of array elements minus one, inclusive. o If an array is accessed using the subscript operator (as either the left or right operand), and the subscript operator is the operand of the address-of operator, the check is for the index to be between 0 and the number of elements in the array, inclusive. The reason for treating the address-of case differently is that it is common programming practice to have a loop such as: int a[10]; int *b; for (b = a ; b < &a[10] ; b++) { .... } In this case, access to &a[10] is allowed even though it is outside the range of the array. o If the array is being accessed using pointer addition, the check is for the value being added to be between 0 and the number of elements in the array, inclusive. o If the array is being accessed using pointer subtraction (that is, the subraction of an integer value from a pointer, not the subtraction of one pointer from another), the check is for the value being subtracted to be between the negation of the number of elements in the array and 0, inclusive. o In the previous three cases, an optional compile-time message (ident SUBSCRBOUNDS2) can be enabled to detect the case where an array has been accessed using either a constant subscript or constant pointer arithmetic, and the element accessed is exactly one past the end of the array. o Bounds checking is not done for arrays declared with one element. (Because ANSI C does not allow arrays without dimensions inside structs, it is common practice to declare such arrays with a bounds specifier of 1.) In this case, an optional compile-time message (ident SUBSCRBOUNDS1) can be enabled to detect the case where an array declared with a single element is accessed using either a constant subscript or constant pointer arithmetic, and the element accessed is not part of the array. o VSI C emits run-time checks for arrays indexed by constants, even though the compiler can and does detect this situation at compile-time. An exeption is that no run-time check is made if the compiler can determine that the access is valid. o If a multi-dimension array is accessed, the compiler performs checks on each of the subscript expressions, making sure each is within the corresponding bound. So for the following code, the compiler checks that both x and y are between 0 and 9. It does not check that 10 * x + y is between 0 and 99: int a[10][10]; int x,y,z; x = a[x][y]; /CHECK=POINTER_SIZE directs the compiler to check 32-bit pointer values 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). Use one or more of the following POINTER_SIZE option keywords to determine the pointer-size checks you want made: [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. /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: o If the rounding mode is not consistent with the value of the /ROUNDING_MODE qualifier specified at compile time, an informational message SYSTEM-I-FPMODERC is issued at runtime, citing the current mode and the compile-time specified mode (Note that /ROUNDING_MODE=DYNAMIC is treated the same as /ROUNDING_MODE=NEAREST for this purpose). o If the trap-enable flags are not consistent with the setting of the /IEEE qualifier (for /FLOAT=IEEE_FLOAT compilations) or with the setting used to implement VAX floating types (for /FLOAT=G_FLOAT or /FLOAT=D_FLOAT compilations), an informational message SYSTEM-I-FPMODECTL is issued at run time, citing the current trap-enable flags as well as the trap-enable flags expected by the compilation. To identify the point of failure, you need to rerun the program under DEBUG and issue "SET BREAK/EXCEPTION". 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. /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, it categorizes the actual type information into one of six possibilities: 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 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 will not check that the number of arguments passed matches the number expected. If the /CHECK qualifier is omitted, the default is /NOCHECK, which equates to /CHECK=(NOUNINITIALIZED_VARIABLE, NOBOUNDS, NOPOINTER_SIZE, NOFP_MODE, NOARGINFO). If you specify /CHECK, the default is /CHECK=(UNINITIALIZED_VARIABLES, BOUNDS, POINTER_SIZE=(ASSIGNMENT,PARAMETER), FP_MODE, ARG_INFO). 2 /COMMENTS /COMMENTS={AS_IS | SPACE} /COMMENTS=SPACE (D) (ANSI89, RELAXED, and MIA compiler modes) /NOCOMMENTS (D) (all other compiler modes) 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. Specify one of the following qualifier options: 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 VSI 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 compiler modes. The default is /NOCOMMENTS for all other compiler modes. Specifying just /COMMENTS defaults to /COMMENTS=AS_IS. 2 /CROSS_REFERENCE /NOCROSS_REFERENCE (D) Specifies whether the compiler generates cross-references. 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. You must use the /CROSS_REFERENCE qualifier with either the /SHOW=SYMBOLS or the /SHOW=BRIEF qualifiers. To obtain any type of listing, you must specify /LIST. 2 /DEBUG /DEBUG[=(option[,...])] /DEBUG=(TRACEBACK,NOSYMBOLS) (D) /NODEBUG Includes information in the object module for use by the OpenVMS Debugger. You can select the following options: ALL Includes all possible debugging information. On Alpha systems, /DEBUG=ALL is equivalent to /DEBUG=(TRACEBACK,SYMBOLS). On VAX systems, /DEBUG=ALL is equivalent to /DEBUG=(TRACEBACK,SYMBOLS,INLINE). NONE Excludes any debugging information. NOSYMBOLS Suppresses generation of symbol table records. SYMBOLS Generates symbol table records. NOTRACEBACK Suppresses generation of traceback records. TRACEBACK Generates traceback records. Specifying /DEBUG with no options is equivalent to specifying /DEBUG=ALL. If the /DEBUG qualifier is not specified, the default is /DEBUG=(TRACEBACK,NOSYMBOLS). 2 /DECC The /DECC qualifier is provided for compatibility with HP C on OpenVMS VAX systems. On OpenVMS Alpha systems, CC and CC/DECC are always equivalent. 2 /DEFINE /DEFINE=(identifier[=definition][,...]) /NODEFINE (D) Performs the same function as the #define preprocessor directive. That is, /DEFINE defines a token string or macro to be substituted for every occurrence of a given identifier in the program. DCL converts all input to uppercase unless it is enclosed in quotation marks. The simplest form of a /DEFINE definition is: /DEFINE=true This results in a definition like the one that would result from the following definition: #define TRUE 1 Macro definitions must be enclosed in quotation marks as shown in the following definition: /DEFINE="funct(a)=a+sin(a)" This definition produces the same results as the following definition: #define funct(a) a+sin(a) When more than one /DEFINE is present on the CC command line or in a single compilation unit, only the last /DEFINE is used. When both /DEFINE and /UNDEFINE are present in a command line, /DEFINE is evaluated before /UNDEFINE. The default is /NODEFINE. 2 /DIAGNOSTICS /DIAGNOSTICS[=file-spec] /NODIAGNOSTICS (D) Creates a file containing compiler diagnostic messages. The default file extension for a diagnostics file is .DIA. The diagnostics file is used with the DEC Language-Sensitive Editor (LSE). To display a diagnostics file, enter the command REVIEW/FILE=file-spec while in LSE. 2 /ENDIAN /ENDIAN={BIG | LITTLE} /ENDIAN=LITTLE (D) Controls whether big or little endian ordering of bytes is carried out in character constants. 2 /ERROR_LIMIT /ERROR_LIMIT[=number] /NOERROR_LIMIT Limits the number of Error-level diagnostic messages that are acceptable during program compilation. Compilation terminates when the limit (number) 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. 2 /EXTERN_MODEL /EXTERN_MODEL=option /EXTERN_MODEL=RELAXED_REFDEF (D) In conjunction with the /SHARE_GLOBALS qualifier, controls the initial extern model of the compiler. Conceptually, the compiler behaves as if the first line of the program being compiled was a #pragma extern_model directive with the model and psect name, if any, specified by the /EXTERN_MODEL qualifier and with the shr or noshr keyword specified by the /SHARE_GLOBALS qualifier. For example, assume the command line contains the following qualifier: /EXTERN_MODEL=STRICT_REFDEF="MYDATA"/NOSHARE The compiler will act as if the program began with the following line: #pragma extern_model strict_refdef "MYDATA" noshr See also #pragma extern_model. The /EXTERN_MODEL qualifier takes the following options, which have the same meaning as for the #pragma extern_model directive: COMMON_BLOCK RELAXED_REFDEF STRICT_REFDEF STRICT_REFDEF="NAME" GLOBALVALUE The default model on VSI C is relaxed/refdef with the noshare attribute. This is different from the model used by VAX C, which is common block, share. 2 /FIRST_INCLUDE FIRST_INCLUDE=(file[,...]) NOFIRST_INCLUDE (D) 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 directives placed in a /FIRST_INCLUDE file. The default is NOFIRST_INCLUDE. 2 /FLOAT /FLOAT=option Controls the format of floating-point variables. Options: D_FLOAT Double variables are represented in D_FLOAT format. The __D_FLOAT macro is predefined. G_FLOAT Double variables are represented in G_FLOAT 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 or _IEEE_FP macro (if/IEEE_MODE=DENORM_RESULTS) is predefined. See also the /IEEE_MODE qualifier for selecting an IEEE floating-point mode. If /IEEE_MODE is not specified, the default behavior is /IEEE_MODE=FAST for Alpha systems and DENORM_RESULTS for I64 systems. On OpenVMS I64 systems, /FLOAT=IEEE_FLOAT is the default floating-point representation. The _IEEE_FP macro is predefined by default, IEEE format data is assumed, and IEEE floating-point instructions are used. There is no hardware support for floating-point representations other than IEEE, although you can specify the /FLOAT=D_FLOAT or /FLOAT=G_FLOAT compiler option. These VAX floating-point formats are supported in the I64 compiler by generating run-time code that converts VAX floating-point formats to IEEE format to perform arithmetic operations, and then converts the IEEE result back to the appropriate VAX floating-point format. This imposes additional run-time overhead and some loss of accuracy compared to performing the operations in hardware on Alpha and VAX systems. The software support for the VAX formats is provided to meet an important functional compatibility requirement for certain applications that need to deal with on-disk binary floating-point data. On I64 systems, the default for /IEEE_MODE is DENORM_RESULTS. This is a change from the default of /IEEE_MODE=FAST on Alpha systems. This means that by default, floating-point operations may silently generate values that print as Infinity or Nan (the industry-standard behavior), instead of issuing a fatal run-time error as they would when using VAX floating-point format or /IEEE_MODE=FAST. Also, the smallest-magnitude nonzero value in this mode is much smaller because results are allowed to enter the denormal range instead of being flushed to zero as soon as the value is too small to represent with normalization. The conversion of VAX floating-point formats to IEEE single and IEEE double floating-point types on the Intel Itanium architecture is a transparent process that will not impact most applications. All you need to do is recompile your application. Because IEEE floating-point format is the default, unless your build explicitly specifies VAX floating-point format options, a simple rebuild for I64 systems will use the native IEEE formats directly. For the large class of programs that do not directly depend on the VAX formats for correct operation, this is the most desirable way to build for I64 systems. When you compile an OpenVMS application that specifies an option to use VAX floating-point on the Itanium architecture, the compiler automatically generates code for converting floating-point formats. Whenever the application performs a sequence of arithmetic operations, this code does the following: o Converts VAX floating-point formats to either IEEE single or IEEE double floating-point formats. o Performs arithmetic operations in IEEE floating-point arithmetic. o Converts the resulting data from IEEE formats back to VAX formats. Where no arithmetic operations are performed (VAX float fetches followed by stores), no conversion will occur. The code handles such situations as moves. VAX floating-point formats have the same number of bits and precision as their equivalent IEEE floating-point formats. For most applications the conversion process will be transparent and thus a non-issue. In a few cases, arithmetic calculations might have different results because of the following differences between VAX and IEEE formats: o Values of numbers represented o Rounding rules o Exception behavior These differences might cause problems for applications that do any of the following: o Depend on exception behavior o Measure the limits of floating-point behaviors o Implement algorithms at maximal processor-specific accuracy o Perform low-level emulations of other floating-point processors o Use direct equality comparisons between floating-point values, instead of appropriately ranged comparisons (a practice that is extremely vulnerable to changes in compiler version or compiler options, as well as architecture) You can test an application's behavior with IEEE floating-point values by compiling it on an OpenVMS Alpha system using /FLOAT=IEEE_FLOAT/IEEE_MODE=DENORM. If that produces acceptable results, simply build the application on the I64 system using the same qualifier. If you determine that simply recompiling with an /IEEE_MODE qualifier is not sufficient because your application depends on the binary representation of floating-point values, then first try building for your I64 system by specifying the VAX floating-point option that was in effect for your VAX or Alpha build. This causes the representation seen by your code and on disk to remain unchanged, with some additional runtime cost for the conversions generated by the compiler. If this is not an efficient approach for your application, you can convert VAX floating-point binary data in disk files to IEEE floating-point formats before moving the application to an I64 system. 2 /GRANULARITY /GRANULARITY=option /GRANULARITY=QUADWORD (D) Determines how much memory to effectively cache for memory reference by the combination of the compiler and the underlying system. For example, quadword granularity may require that the system cache quadword values in registers. If access to data in the same granularity unit occurs simultaneously, corruption (by storing back stale values) can occur. Granularity has two aspects: references inside a particular data segment and references between data segments. The options are: o BYTE o LONGWORD o QUADWORD The default is /GRANULARITY=QUADWORD. 2 /IEEE_MODE /IEEE_MODE=option /IEEE_MODE=DENORM_RESULTS (D) Selects the IEEE floating-point mode to be used. Options: FAST During program execution, only finite values (no infinities, NaNs, or denorms) are created. Exceptional conditions, such as floating point overflow and divide by zero, are fatal. UNDERFLOW_TO_ZERO Generate infinities and NaNs. Flush denormalized results and underflow to zero without exceptions. DENORM_RESULTS Same as UNDERFLOW_TO_ZERO, except that denorms are generated. This is the default for I64 systems. INEXACT Same as DENORM_RESULTS, except that inexact values are trapped. This is the slowest mode. On Alpha sytems, the /IEEE_MODE qualifier generally has its greatest effect on the generated code of a compilation. When calls are made between functions compiled with different /IEEE_MODE qualifiers, each function produces the /IEEE_MODE behavior with which it was compiled. On I64 systems, the /IEEE_MODE qualifier primarily affects only the setting of a hardware register at program startup. In general, the /IEEE_MODE behavior for a given function is controlled by the /IEEE_MODE option specified on the compilation that produced the main program: the startup code for the main program sets the hardware register according the command-line qualifiers used to compile the main program. When applied to a compilation that does not contain a main program, the /IEEE_MODE qualifier does have some effect: it might affect the evaluation of floating-point constant expressions, and it is used to set the EXCEPTION_MODE used by the math library for calls from that compilation. But the qualifier has no effect on the exceptional behavior of floating-point calculations generated as inline code for that compilation. Therefore, if floating-point exceptional behavior is important to an application, all of its compilations, including the one containing the main program, should be compiled with the same /IEEE_MODE setting. Even on Alpha systems, the particular setting of /IEEE_MODE=UNDERFLOW_TO_ZERO has this characteristic: its primary effect requires the setting of a runtime status register, and so it needs to be specified on the compilation containing the main program in order to be effective in other compilations. 2 /INCLUDE_DIRECTORY /INCLUDE_DIRECTORY=(place[,...]) /NOINCLUDE_DIRECTORY (D) Provides similar functionality to the -I option of the cc command on DIGITAL UNIX systems. This qualifier allows you to specify additional places to search for include files. A place can be one of the following: o OpenVMS file-spec to be used as a default file-spec to RMS file services (example: DISK$:[directory]) o UNIX style pathname in quotation marks (example: "/sys") o Empty string ("") If one of the places is specified as an empty string, the compiler is not to search any of its conventionally-named places (DECC$USER_INCLUDE, DECC$SYSTEM_INCLUDE, DECC$LIBRARY_INCLUDE, SYS$COMMON:[DECC$LIB.INCLUDE.*], DECC$TEXT_LIBRARY, DECC$RTLDEF.TLB, SYS$STARLET_C.TLB). It searches only places specified explicitly on the command line by the /INCLUDE_DIRECTORY and /LIBRARY qualifiers (or by the location of the primary source file, depending on the /NESTED_INCLUDE_DIRECTORY qualifier). The basic search order depends on the form of the header-file name (after macro expansion). Additional aspects of the search order are controlled by other command-line qualifiers and the presence or absence of logical name definitions. All forms of header-file inclusion are affected: o In quotes (example: "stdio.h") o In angle brackets (example: ) o An identifier to be treated as a text-module name (example: stdio) Except where otherwise specified, searching a "place" means that the string designating the place is used as the default file-spec in a call to an RMS system service (for example, $SEARCH/$PARSE), with a file-spec consisting of the name in the #include directive without enclosing delimiters. The search terminates successfully as soon as a file can be opened for reading. For the quoted form, the search order is: 1. One of the following: o If /NESTED_INCLUDE_DIRECTORY=INCLUDE_FILE (the default) is in effect, search the directory containing the file in which the #include directive itself occurred. The meaning of "directory containing" is: the RMS "resultant string" obtained when the file in which the #include occurred was opened, except that the filename and subsequent components are replaced by the default file type for headers (".H", or just "." if /ASSUME=NOHEADER_TYPE_DEFAULT is in effect). The "resultant string" will not have translated any concealed device logical. o If /NESTED_INCLUDE_DIRECTORY=PRIMARY_FILE is in effect, search the default file type for headers using the context of the primary source file. This means that just the file type (".H" or ".") is used for the default file-spec but, in addition, the chain of "related file-specs" used to maintain the sticky defaults for processing the next top-level source file is applied when searching for the include file. o If /NESTED_INCLUDE_DIRECTORY=NONE is in effect, this entire step (Step 1) is bypassed. 2. Search the places specified in the /INCLUDE_DIRECTORY qualifier, if any. A place that can be parsed successfuly as an OpenVMS file-spec and that does not contain an explicit file type or version specification is edited to append the default header file type specification (".H" or "."). A place containing a "/" character is considered to be a UNIX-style name. If the name in the #include directive also contains a "/" character that is not the first character and is not preceded by a "!" character (that is, it is not an absolute UNIX-style pathname), then the name in the #include directive is appended to the named place, separated by a "/" character, before applying the decc$to_vms pathname translation function. 3. If "DECC$USER_INCLUDE" is defined as a logical name, search "DECC$USER_INCLUDE:.H", or just "DECC$USER_INCLUDE:." if /ASSUME=NOHEADER_TYPE_DEFAULT is in effect. 4. If the file is not found, follow the steps for the angle-bracketed form of inclusion. For the angle-bracketed form, the search order is: 1. Search the place "/". This is a UNIX-style name that can combine only with UNIX names specified explicitly in the #include directive. It causes a specification like to be considered first as /sys/types.h, which is translated to SYS:TYPES.H. 2. Search the places specified in the /INCLUDE_DIRECTORY qualifier, exactly as in Step 2 for the quoted form of inclusion. 3. If "DECC$SYSTEM_INCLUDE" is defined as a logical name, search "DECC$SYSTEM_INCLUDE:.H", or just "DECC$SYSTEM_INCLUDE:." if /ASSUME=NOHEADER_TYPE_DEFAULT is in effect. 4. If "DECC$LIBRARY_INCLUDE" is defined as a logical name and "DECC$SYSTEM_INCLUDE" is NOT defined as a logical name, search "DECC$LIBRARY_INCLUDE:.H", or just "DECC$LIBRARY_INCLUDE:." if /ASSUME=NOHEADER_TYPE_DEFAULT is in effect. 5. If neither "DECC$LIBRARY_INCLUDE" nor "DECC$SYSTEM_INCLUDE" are defined as logical names, then search the default list of places for plain text-file copies of compiler header files as follows: SYS$COMMON:[DECC$LIB.INCLUDE.DECC$RTLDEF]*.H SYS$COMMON:[DECC$LIB.INCLUDE.SYS$STARLET_C]*.H If the file is not found, perform the text library search described in the next step. 6. Extract the simple filename and file type from the #include specification and use the filename as the module name to search a list of text libraries associated with that file type. For any file type, the initial text libraries searched consist of those named on the command line with /LIBRARY qualifiers. If the /INCLUDE_DIRECTORY qualifier contained an empty string, no further text libraries are searched. Otherwise, DECC$TEXT_LIBRARY is searched for all file types. If "DECC$LIBRARY_INCLUDE" is defined as a logical name, then no further text libraries are searched. Otherwise, the subsequent libraries searched for each file type are: For ".H" or ".": SYS$LIBRARY:DECC$RTLDEF.TLB SYS$LIBRARY:SYS$STARLET_C.TLB For any file type other then ".H" or ".": SYS$LIBRARY:SYS$STARLET_C.TLB 7. If the previous step fails, search: SYS$LIBRARY:.H Under /ASSUME=NOHEADER_TYPE_DEFAULT, the default file type is modified as usual. For the text-module (non-portable) form of #include: The name can only be an identifier. It, therefore, has no associated "file type". The identifier is used as a module name to search the following: 1. The text libraries named on the command line with /LIBRARY qualifiers, in left-to-right order. 2. The following list of text libraries in the order shown (unless the /INCLUDE_DIRECTORY qualifier contains an empty string, in which case no further text libraries are searched): DECC$TEXT_LIBRARY SYS$LIBRARY:DECC$RTLDEF.TLB SYS$LIBRARY:SYS$STARLET_C.TLB 2 /L_DOUBLE_SIZE /L_DOUBLE_SIZE=option /L_DOUBLE_SIZE=128 (D) Determines how the compiler interprets the long double type. The qualifier options are 64 and 128. /L_DOUBLE_SIZE=64 treats all long double references as G_FLOAT, D_FLOAT, or T_FLOAT, depending on the value of the /FLOAT qualifier. /L_DOUBLE_SIZE=128 treats all long double references as X_FLOAT. 2 /LIBRARY Indicates that the associated input file is a library containing source text modules specified in #include directives. The compiler searches the specified library for all #include module names that are not enclosed in angle brackets or quotation marks. The name of the library must be concatenated with the file specification using a plus sign. For example: CC DATAB/LIBRARY+APPLIC 2 /LINE_DIRECTIVES /LINE_DIRECTIVES (D) /NOLINE_DIRECTIVES Controls whether or not #line directives appear in preprocess output files. 2 /LIST /LIST[=file-spec] (Batch default) /NOLIST (Interactive default) Controls whether a listing file is produced. The default output file extension is .LIS. 2 /MACHINE_CODE /MACHINE_CODE /NOMACHINE_CODE (D) Controls whether the listing produced by the compiler includes the machine language code generated during the compilation. If you use this qualifier you also need to use the /LIST qualifier. 2 /MAIN=POSIX_EXIT /MAIN /NOMAIN (D) Directs the compiler to call __posix_exit instead of exit when returning from main. 2 /MEMBER_ALIGNMENT /MEMBER_ALIGNMENT (D) /NOMEMBER_ALIGNMENT Directs the compiler to naturally align data structure members. This means that data structure members are aligned on the next boundary appropriate to the type of the member, rather than on the next byte. For instance, a long variable member is aligned on the next longword boundary; a short variable member is aligned on the next word boundary. Any use of the #pragma member_alignment or #pragma nomember_alignment directives within the source code overrides the setting established by this qualifier. Specifying /NOMEMBER_ALIGNMENT causes data structure members to be byte-aligned (with the exception of bit-field members). For 64-bit systems, the default is /MEMBER_ALIGNMENT. For OpenVMS VAX systems, the default is /NOMEMBER_ALIGNMENT. 2 /MMS_DEPENDENCIES /MMS_DEPENDENCIES[=(option[,option)]] /NOMMS_DEPENDENCIES (D) Directs the compiler to produce a dependency file. Dependency files list all source files and included files for each object module. Note that the /OBJECT qualifier has no impact on the dependency file. The dependency file format is: object_file_name : object_file_name : object_file_name : You can specify none, one, or all of the following qualifier options: FILE[=filespec] Specifies where to save the dependency file. The default file extension for a dependency file is .mms. Other than using a different default extension, this qualifier uses the same procedure that /OBJECT and /LIST use for determining the name of the output file. SYSTEM_INCLUDE_FILES Specifies whether or not to include dependency information about system include files (that is, those included with #include ). The default is to include dependency information about system include files. Note that the /OBJECT qualifier has no impact on the dependency file. TARGET=string Specifies the target that appears in the output .mms file. The default is TARGET="" in which case the target is the source file name with an .OBJ extension, as in previous versions of the compiler. If you specify any string other than .OBJ, that string is used as the target. For the special case of .OBJ, the compiler uses the name of the object file, stripped of any version number and path, for the MMS target. 2 /NAMES /NAMES=(option1,option2) /NAMES=(UPPERCASE,TRUNCATED) (D) Option1 converts all definitions and references of external symbols and psects to the specified case: o /NAMES=UPPERCASE (default) converts to uppercase. o /NAMES=AS_IS leaves the case unchanged. Option2 controls whether or not long external names greater than 31 characters get truncated or shortened: o /NAMES=TRUNCATED (default) truncates long external names o /NAMES=SHORTENED shortens long external names. A shortened name consists of the first 23 characters of the name followed by a 7-character Cyclic Redundancy Check (CRC) computed by looking at the full name, and then a "$". The CRC is generated by calling lib$crc as follows: long initial_crc = -1; crc_result = lib$crc(good_crc_table, &initial_crc, ); where good_crc_table is: /* ** Default CRC table: ** ** This table was taken from Ada's generalized name generation ** algorithm. It represents a commonly used CRC polynomial ** known as AUTODIN-II. For more information see the VAX ** Macro OpenVMS documentation under the CRC VAX instruction. */ static const unsigned int good_crc_table[16] = {0x00000000, 0x1DB71064, 0x3B6E20C8, 0x26D930AC, 0x76DC4190, 0x6B6B51F4, 0x4DB26158, 0x5005713C, 0xEDB88320, 0xF00F9344, 0xD6D6A3E8, 0xCB61B38C, 0x9B64C2B0, 0x86D3D2D4, 0xA00AE278, 0xBDBDF21C}; By default, the compiler issues a warning and truncates the name to 31 characters. The /NAMES qualifier does not affect the names of the $ABS$, $BSS$, $CODE$, $DATA$, $LINK$, $LITERAL$, and $READONLY$ psects. 2 /NESTED_INCLUDE_DIRECTORY /NESTED_INCLUDE_DIRECTORY[=option] /NESTED_INCLUDE_DIRECTORY=INCLUDE_FILE (D) Controls the first step in the search algorithm the compiler uses when looking for files included using the quoted form of the #include preprocessing directive: #include "file-spec" /NESTED_INCLUDE_DIRECTORY has the following options: PRIMARY_FILE Directs the compiler to search the default file type for headers using the context of the primary source file (the .C file). This means that just the file type (".H" or ".") is used for the default file-spec but, in addition, the chain of "related file-specs" used to maintain the sticky defaults for processing the next top-level source file is applied when searching for the include file. INCLUDE_FILE Directs the compiler to search the directory containing the file in which the #include directive itself occurred. The meaning of "directory containing" is: the RMS "resultant string" obtained when the file in which the #include occurred was opened, except that the filename and subsequent components are replaced by the default file type for headers (".H", or just "." if /ASSUME=NOHEADER_TYPE_DEFAULT is in effect). The "resultant string" will not have translated any concealed device logical. NONE Directs the compiler to skip the first step of processing #include "file.h" directives. The compiler starts its search for the include file in the /INCLUDE_DIRECTORY directories. See also /INCLUDE_DIRECTORY. 2 /OBJECT /OBJECT[=file-spec] (D) /NOOBJECT Controls whether the compiler produces an output object module. The default output file extension is .OBJ. Note that the /OBJECT qualifier has no impact on the output file of the /MMS_DEPENDENCIES qualifier. 2 /OPTIMIZE /OPTIMIZE[=option] (D) /NOOPTIMIZE Controls the level of code optimization that the compiler performs. /OPTIMIZE has the following options: LEVEL=n Selects the level of optimization. Specify an integer from 0 (no optimization) to 5 (full optimization, including pipelining). [NO]INLINE[=keyword] Provides inline expansion of functions that yield optimized code when they are expanded. You can specify one of the following keywords: NONE No inlining is done, even if requested by the language syntax. /OPTIMIZE=INLINE=NONE is equivalent to /OPTIMIZE=NOINLINE. MANUAL Inlines only those function calls for which the program explicitly requests inlining. AUTOMATIC Inlines all of the function calls in the MANUAL category, plus additional calls that the compiler determines are appropriate on this platform. On Alpha systems, this is the same as SIZE; on I64 systems, this is the same as SPEED. AUTOMATIC is the default. SIZE Inlines all of the function calls in the MANUAL category plus any additional calls that the compiler determines would improve run-time performance without significantly increasing the size of the program. SPEED Performs more aggressive inlining for run-time performance, even when it might significantly increase the size of the program. ALL Inlines every call that can be inlined while still generating correct code. Recursive routines, however, will not cause an infinite loop at compile time. Note that /OPT=INLINE=ALL is not recommended for general use, because it performs very aggressive inlining and can cause the compiler to exhaust virtual memory or take an unacceptably long time to compile [NO]INTRINSICS Controls whether or not certain functions are handled as intrinsic functions without explicitly enabling each of them as an intrinsic through the #pragma intrinsic preprocessor directive. Functions that can be handled as intrinsics are: Main Group - ANSI: abs atanl atan2l ceill cosl floorf memcpy sinf atan atan2 ceil cos fabs floorl memmove sinl atanf atan2f ceilf cosf floor labs memset strcpy sin strlen Main Group - Non-ANSI: alloca atand2 bzero sind atand bcopy cosd Printf functions: fprintf printf sprintf Printf non-ANSI: snprintf ANSI math functions that set errno, thereby requiring /ASSUME=NOMATH_ERRNO: acos asinf coshl log log10f powl sqrt tanf acosf asinl exp logf log10l sinh sqrtf tanl acosl cosh expf logl pow sinhf sqrtl tanh asin coshf expl log10 powf sinhl tan tanhf tanhl Non-ANSI math functions that set errno, thereby requiring /ASSUME=NOMATH_ERRNO: log2 tand The /OPTIMZE=INTRINSICS qualifier works together with /OPTIMIZE=LEVEL=n and some other qualifiers to determine how intrinsics are handled: o If the optimization level specified is less than 4, the intrinsic-function prototypes and call formats are checked, but normal run-time calls are still made. o If the optimization level is 4 or higher, intrinsic code is generated. o If /STANDARD=ANSI89 is specified, non-ANSI-Standard functions are not automatically intrinsic and do not even have their prototypes checked. They are only checked if the non-ANSI-Standard functions are made intrinsic through #pragma intrinsic. o Intrinsic code is not generated for math functions that set the errno variable unless /ASSUME=NOMATH_ERRNO is specified. Such math functions, however, do have their prototypes and call formats checked. The default is /OPTIMIZE=INTRINSICS, which turns on this handling. To turn it off, specify /NOOPTIMIZE or /OPTIMIZE=NOINTRINSICS. [NO]PIPELINE Controls Activation of the software pipelining optimization. The software pipelining optimization applies instruction scheduling to certain innermost loops, allowing instructions within a loop to "wrap around" and execute in a different iteration of the loop. This can reduce the impact of long-latency operations, resulting in faster loop execution. Software pipelining can be more effective when you combine /OPTIMIZE=PIPELINE with the appropriate /OPTIMIZE=TUNE keyword for the target Alpha processor generation. Software pipelining also enables the prefetching of data to reduce the impact of cache misses. Software pipelining is a subset of the optimizations activated by optimization level 5. To determine whether using /OPTIMIZE=PIPELINE benefits your particular program, you should time program execution for the same program (or subprogram) compiled with and without software pipelining. For programs that contain loops that exhaust available registers, longer execution times can result with optimization level 5, requiring use of /OPTIMIZE=UNROLL=n to limit loop unrolling. UNROLL=n Controls loop unrolling done by the optimizer. UNROLL=n means to unroll loop bodies n times. The default is UNROLL=0, which means the optimizer will use its own default unroll amount. TUNE=keyword Selects processor-specific instruction tuning for implementations of the Alpha or Itanium architecture. Regardless of the setting of the /OPTIMIZE=TUNE flag, the generated code will run correctly on all implementations of the Alpha architecture. Tuning for a specific implementation can provide improvements in run-time performance. Code tuned for a specific target might run slower on another target. For Itanium systems, you can specify the following keyword: ITANIUM2 Generates code for the Intel Itanium 2 processor. The default is /OPTIMIZE, which is equivalent to /OPTIMIZE=(INLINE=AUTOMATIC,LEVEL=4,UNROLL=0,TUNE=GENERIC). 2 /PDSC_MASK /PDSC_MASK=option Forces the compiler to set the PDSC$V_EXCEPTION_MODE field of the procedure descriptor for each function in the compilation unit to the specified value, regardless of the setting of any other qualifiers. Ordinarily the PDSC$V_EXCEPTION_MODE field gets set automatically by the compiler, depending on which /IEEE mode is specified on the command line. The /PDSC_MASK qualifier overrides the /IEEE_MODE qualifer setting of this field. NOTE: The /PDSC_MASK qualifier is a low-level systems-programming feature that is seldom necessary. Its usage can produce object modules that do not conform to the OpenVMS common language environment and, within C, it can produce non-standard and seemingly incorrect floating-point behaviors at runtime. The qualifier option keywords are exactly the allowed values defined in the OpenVMS Calling Standard for this field, stripped of the PDSC$V_EXCEPTION_MODE prefix (for example, /PDSC_MASK=SIGNAL sets the field to PDSC$V_EXCEPTION_MODE_SIGNAL). The qualifier options are: SIGNAL Maps to PDSC$K_EXCEPTION_MODE_SIGNAL. Raise exceptions for all except underflow (which equals 0). SIGNAL_ALL Maps to PDSC$K_EXCEPTION_MODE_SIGNAL_ALL. Raise exceptions for all. SILENT Maps to PDSC$K_EXCEPTION_MODE_SILENT. Raise no exceptions. Create only finite values: no infinities, no denorms, no NaNs. The function result or errno needs to be examined.) FULL_IEEE Maps to PDSC$K_EXCEPTION_MODE_FULL_IEEE. Raise no exceptions except as controlled by separate IEEE exception-enabling bits. Create exceptional values according to the IEEE standard. CALLER Maps to PDSC$K_EXCEPTION_MODE_CALLER. Emulate the same mode as the caller. In the absence the /PDSC_MASK qualifier, the compiler sets the PDSC$V_EXCEPTION_MODE field automatically, depending on the /IEEE_MODE qualifier setting: o If /IEEE_MODE is specified with UNDERFLOW_TO_ZERO, DENORM_RESULTS, or INEXACT, then /PDSC_MASK is set to FULL_IEEE. o In all other cases, /PDSC_MASK is set to SILENT. This setting differs from the calling-standard-specified default of SIGNAL used by Fortran, and is largly responsible for the ANSI C conforming behavior of the math library when called from C or C++ programs. 2 /PLUS_LIST_OPTIMIZE /PLUS_LIST_OPTIMIZE /NOPLUS_LIST_OPTIMIZE (D) Provides improved optimization and code generation across file boundaries that would not be available if the files were compiled seperately. When you specify /PLUS_LIST_OPTIMIZE on the command line in conjunction with a series of file specifications separated by plus signs, the compiler does not concatenate each of the specified source files together. Instead, each file is treated separately for purposes of parsing, except that the compiler will issue diagnostics about conflicting external declarations and function definitions that occur in different files. For purposes of code generation, the compiler treats the files as one application. The default is /NOPLUS_LIST_OPTIMIZE. 2 /POINTER_SIZE /POINTER_SIZE=option /NOPOINTER_SIZE (D) Controls whether or not pointer-size features are enabled, and whether pointers are 32 bits or 64 bits long. The default is /NOPOINTER_SIZE, which disables pointer-size features, such as the ability to use #pragma pointer_size, and directs the compiler to assume that all pointers are 32-bit pointers. This default represents no change over previous versions of the compiler. You must specify one of the following options: SHORT The compiler assumes 32-bit pointers. 32 Same as SHORT. LONG[=ARGV] The compiler assumes 64-bit pointers. If the ARGV option to LONG or 64 is present, the main argument argv will be an array of long pointers instead of an array of short pointers. 64[=ARGV] Same as LONG. Specifying /POINTER_SIZE=32 directs the compiler to assume that all pointers are 32-bit pointers. But unlike the default of /NOPOINTER_SIZE, /POINTER_SIZE=32 enables use of the #pragma pointer_size long and #pragma pointer_size short preprocessor directives to control pointer size throughout your program. Specifying /POINTER_SIZE=64 directs the compiler to assume that all pointers are 64-bit pointers, and also enables use of the #pragma pointer_size directives. 2 /PRECISION /PRECISION={SINGLE | DOUBLE} Controls whether floating-point operations on float variables are performed in single or double precision. The default is /PRECISION=DOUBLE for /STANDARD=VAXC and /STANDARD=COMMON modes. The default is /PRECISION=SINGLE for /STANDARD=ANSI89 and /STANDARD=RELAXED modes. 2 /PREFIX_LIBRARY_ENTRIES Controls the VSI C RTL name prefixing. The VSI C Run-Time Library (RTL) shareable image (DECC$SHR.EXE) resides in IMAGELIB.OLB with a DECC$ prefix for its entry points. Every external name in IMAGELIB.OLB has a DECC$ prefix, and, therefore, has an OpenVMS conformant name space (a requirement for inclusion in IMAGELIB). The /[NO]PREFIX_LIBRARY_ENTRIES qualifier lets you control the VSI C RTL name prefixing. The qualifier options are: EXCEPT=(name,...) The names specified are not prefixed. ALL_ENTRIES All C RTL names, as well as C99 names not supported by the underlying C RTL, are prefixed. ANSI_C89_ENTRIES Only ANSI library names are prefixed. C99_ENTRIES Only ISO C Standard 99 (C99) library names are prefixed. These are a superset of the external names prefixed under /PREFIX=ANSI_C89_ENTRIES and a subset of those prefixed under /PREFIX=ALL_ENTRIES. Note: The compiler prefixes C99 entries based on their inclusion in the standard, not on the availability of their implementations in the run-time library. So calling functions introduced in C99 that are not yet implemented in the VSI C RTL will produce unresolved references to symbols prefixed by DECC$ when the program is linked. In addition, the compiler issues a CC-W-NOTINCRTL message when it prefixes a name that is not in the current C RTL. RTL="name" Generates references to the C RTL indicated by the "name" keyword. If no keyword is specified, then references to the VSI C RTL are generated by default. To use an alternate RTL, see its documentation for the name to use. If you want no names prefixed, specify /NOPREFIX_LIBRARY_ENTRIES. For /STANDARD=ANSI89, the default is /PREFIX=ANSI_C89_ENTRIES. For /STANDARD=C99, the default is /PREFIX=C99_ENTRIES. For all other compiler modes, the default is /PREFIX=ALL. 2 /PREPROCESS_ONLY /PREPROCESS_ONLY[=filename] /NOPREPROCESS_ONLY (D) Causes the compiler to perform only the actions of the preprocessor phase and write the resulting processed text out to a file. Furthermore, no object file or analysis file can be produced. 2 /PROTOTYPE /PROTOTYPE[=(option[,...])] /NOPROTOTYPE (D) Creates an output file containing function prototypes for all global functions defined in the module being compiled. The qualifier options are: [NO]IDENTIFIERS Indicates that identifier names are to be included in the prototype declarations that appear in the output file. The default is NOIDENTIFIERS. [NO]STATIC_FUNCTIONS Indicates that prototypes for static function definitions are to be included in the output file. The default is NOSTATIC_FUNCTIONS. FILE=filename Specifies the output file name. When not specified, the output file name has the same defaults as the listing file, except that the file extension is .CH instead of .LIS. The default is /NOPROTOTYPES. 2 /PSECT_MODEL /PSECT_MODEL=MULTILANGUAGE /PSECT_MODEL=NOMULTILANGUAGE (D) Controls whether the compiler allocates the size of overlaid psects to ensure compatibility when the psect is shared by code created by other HP compilers. The problem this switch solves can occur when a psect generated by a Fortran COMMON block is overlaid with a psect consisting of a C struct. Because Fortran COMMON blocks are not padded, if the C struct is padded, the inconsistent psect sizes can cause linker error messages. Compiling with /PSECT_MODEL=MULTILANGUAGE ensures that VSI C uses a consistent psect size allocation scheme. The corresponding Fortran switch is /ALIGN=COMMON=[NO]MULTILANGUAGE. The default is /PSECT=NOMULTILANGUAGE, which is the old default behavior of the compiler, and is sufficient for most applications. 2 /REENTRANCY /REENTRANCY=option /REENTRANCY=TOLERANT (D) Controls the type of reentrancy that reentrant VSI C RTL routines will exhibit. (See also the decc$set_reentrancy RTL routine.) This qualifier is for use only with a module containing the main routine. The reentrancy level is set at run time according to the /REENTRANCY qualifier specified while compiling the module containing the main routine. You can specify one of the following options: AST Uses the __TESTBITSSI builtin to perform simple locking around critical sections of RTL code, and may additionally disable asynchronous system traps (ASTs) in locked region of codes. This type of locking should be used when AST code contains calls to VSI C RTL I/O routines. MULTITHREAD Designed to be used in conjunction with the DECthreads product. It performs DECthreads locking and never disables ASTs. NONE Gives optimal performance in the RTL, but does absolutely no locking around critical sections of RTL code. It should only be used in a single threaded environment when there is no chance that the thread of execution will be interrupted by an AST that would call the VSI C RTL. TOLERANT Uses the __TESTBITSSI builtin to perform simple locking around critical sections of RTL code, but ASTs are not disabled. This type of locking should be used when ASTs are used and must be delivered immediately. This is also the default reentrancy type. 2 /REPOSITORY Specifies a repository for the compiler to store shortened external name information. When /NAMES=SHORTENED is specified, the compiler stores to the repository any external names that were shortened. The demangler utility can then be used to map the shortened names back to the names used in the original C program. By default, the qualifier is not active unless /NAMES=SHORTENED has been specified, in which case the default is /REPOSITORY=[.CXX_REPOSITORY]. Note that the default name of the repository is the same as that used by the HP C++ compiler for decoding mangled names. This is intentional. A C++ mangled name cannot match a shortened name, so a single repository can be used by both the VSI C and HP C++ compilers. 2 /ROUNDING_MODE /ROUNDING_MODE=option /ROUNDING_MODE=NEAREST (D) For /FLOAT=IEEE_MODE, the /ROUNDING_MODE qualifier lets you select one of the following IEEE rounding modes: o NEAREST (default) o DYNAMIC o MINUS_INFINITY o CHOPPED For /FLOAT=G_FLOAT or /FLOAT=D_FLOAT, rounding defaults to /ROUNDING_MODE=NEAREST, with no other choice of rounding mode. 2 /SHARE_GLOBALS /NOSHARE_GLOBALS (D) Performs two functions: o Controls whether the compiler treats declarations of objects with the globaldef keyword as shared or not shared. o Controls whether the initial extern_model is shared or not shared (for those extern_models where it is allowed). The initial extern_model of the compiler is a fictitious pragma constructed from the settings of the /EXTERN_MODEL and /SHARE_GLOBALS. The default value is /NOSHARE_GLOBALS. This default value is different from VAX C (which treated externs as SHR by default), and has the following impact: 1. When linking old object files or object libraries with newly produced object files, you might get "conflicting attributes for psect" messages, which can be safely ignored as long as you are not building shareable libraries. 2. The /NOSHARE_GLOBALS default makes building shareable libraries easier. 2 /SHOW /SHOW=(option[,...]) /SHOW=SOURCE (D) Used with the /LIST qualifier to set or cancel specific listing options. You can select the following options: ALL Print all listing information. [NO]BRIEF Print a brief symbol table, listing only those identifiers that are referenced in the program. [NO]CROSS_REFERENCE Specifies whether the compiler generates cross-references. If you specify /SHOW=CROSS_REFERENCE, the compiler lists, for each variable referenced in the procedure, the line numbers of the lines on which the variable is referenced. You may use /SHOW=CROSS_REFERENCE with /SHOW=SYMBOLS. Otherwise, specifying /SHOW=CROSS_REFERENCE also gives you /SHOW=BRIEF. To obtain any type of listing, you must specify /LIST. /SHOW=CROSS_REFERENCE is the same as specifying /[NO]CROSS_REFERENCE. (D = NOCROSS_REFERENCE) [NO]DICTIONARY Print/do not print Common Data Dictionary definitions. (D = NODICTIONARY) [NO]EXPANSION Print/do not print macro expansions. (D = NOEXPANSION) [NO]HEADER Print/do not print header lines at the top of each page. (D = HEADER) [NO]INCLUDE Print/do not print contents of #include files. (D = NOINCLUDE) [NO]MESSAGES Print/do not print a list of all messages that are in effect at compilation (based on the settings of /STANDARD, /WARNINGS, and #pragma message). (D = NOMESSAGES) NONE Print no listing information. [NO]SOURCE Print/do not print source file statements. (D = SOURCE) [NO]STATISTICS Print/do not print compiler performance statistics. (D = NOSTATISTICS) [NO]SYMBOLS Print/do not print symbol table information in the listing file. (D = NOSYMBOLS) 2 /STANDARD /STANDARD=(option) /STANDARD=RELAXED (equivalent to /NOSTANDARD) (D) /NOSTANDARD (D) Defines the compilation mode. You can select the following options: ANSI89 Places the compiler in strict ANSI C Standard 89 (C89) mode. This mode compiles the C language as defined by the American National Standard for C, along with any extensions not prohibited by that standard. C99 On OpenVMS Alpha and I64 systems, places the compiler in strict ISO/IEC C Standard 99 (C99) mode. This mode accepts just the C99 language without extensions, and diagnoses violations of the C99 standard. /STANDARD=C99 defines the __STDC_VERSION__ macro to the C99-specified value of 199901L, because C99 is a superset of Amendment 1 to the C89 standard, and the default mode of RELAXED is a superset of C99. On OpenVMS VAX systems, produces a warning and places the compiler in /STANDARD=RELAXED ANSI89 mode. LATEST On OpenVMS Alpha and I64 systems, places the compiler in the latest ISO C standard dialect. /STANDARD=LATEST is currently equivalent to /STANDARD=C99, but is subject to change when newer versions of the ISO C standard are released. RELAXED Places the compiler in relaxed ANSI C Standard mode. The compiler accepts ANSI/ISO C Standard C89 and C99 features, as well as nearly all language extensions (such as additional VSI C keywords and predefined macros that do not begin with an underscore). It excludes only K&R (COMMON mode), VAX C, and Microsoft features that conflict with standard C. This is the default mode of the compiler, and is equivalent to /NOSTANDARD. MS Places the compiler in Microsoft compatibility mode, which interprets source programs according to certain language rules followed by the C compiler provided with the Microsoft Visual C++ compiler product. ISOC94 Places the compiler in ISO C 94 mode, which enables digraph processing. It also defines the predefined macro __STDC_VERSION__=199409 when specified alone or in combination with the ANSI89, MIA, RELAXED, MS, COMMON, or PORTABLE keywords. This option can be specified alone or with any other /STANDARD option except VAXC. If it is specified alone, the default major mode is RELAXED. COMMON Places the compiler in K & R language mode; that is, compatibility with older UNIX compilers such as pcc and gcc. This mode is close to a subset of /STANDARD=VAXC mode. VAXC Places the compiler in VAX C mode. There are differences in the C language as implemented in previous versions of VAX C and the C language as defined by ANSI (the differences are primarily concerned with how the preprocessor works). This mode provides compatibility for programs that depend on old VAX C behavior. PORTABLE Places the compiler in RELAXED mode, and enables the issuance of diagnostics that warn of any nonportable usages encountered. Note that /STANDARD=PORTABLE is supported for VAX C compatibility only. It is equivalent to the recommended combination of qualifiers /STANDARD=RELAXED /WARNINGS=ENABLE=PORTABLE. MIA Places the compiler in strict ANSI C mode with the following behavior differences to conform to the Multivendor Integration Architecture (MIA) standard: o On OpenVMS VAX systems, G_FLOAT becomes the default floating-point format for double variables. (On OpenVMS Alpha systems, G_FLOAT is already the default.) o In structures, zero-length bit fields cause the next bit field to start on an integer boundary, rather than on a character boundary. If the /STANDARD qualifier is not specified, the default is /NOSTANDARD, which is equivalent to /STANDARD=RELAXED. If you specify the /STANDARD qualifier, you must supply an option. With one exception, the /STANDARD qualifier options are mutually exclusive. Do not combine them. The exception is that you can specify /STANDARD=ISOC94 with any other option except VAXC. VSI C modules compiled in different modes can be linked and executed together. 2 /TIE /NOTIE (D) Enables the compiled code to be used in combination with translated images, either because the code might call into a translated image or might be called from a translated image. 2 /UNDEFINE /UNDEFINE=(identifier[,...]) /NOUNDEFINE (D) Performs the same function as the #undef preprocessor directive: it cancels a macro definition. The /UNDEFINE qualifier is useful for undefining the predefined VSI C preprocessor constants. For example, if you use a preprocessor constant (such as vaxc, VAXC, VAX11C, or vms) to conditionally compile segments of code specific to VSI C for OpenVMS Systems, you can undefine constants to see how the portable sections of your program execute. For example: /UNDEFINE="vaxc" When both /DEFINE and /UNDEFINE are present on the CC command line, /DEFINE is evaluated before /UNDEFINE. The default is /NOUNDEFINE. 2 /UNSIGNED_CHAR /NOUNSIGNED_CHAR (D) Changes the default for all char types from signed to unsigned. This qualifier causes all plain char declarations to have the same representation and set of values as signed char declarations. The default is /NOUNSIGNED_CHAR. 2 /VERSION /VERSION /NOVERSION (D) Directs the compiler to print out the compiler version and platform. The compiler version is the same as in the listing file. This qualifier helps you to report what compiler you are using. When this qualifier is specified, the compiler just prints its version and exits. No other qualifiers are processed, no source file is read, and no object module is produced. The syntax for using this qualifier is: CC/VERSION The default is /NOVERSION. 2 /WARNINGS /WARNINGS[=(option[,...])] /WARNINGS (D) /NOWARNINGS Controls the issuance of compiler diagnostic messages, or groups of messages. The default qualifier, /WARNINGS, enables all warning and informational messages for the compiler mode you are using. The /NOWARNINGS qualifier suppresses the informational and warning messages. Also see the #pragma message preprocessor directive. The options are: DISABLE=msg-list Suppresses the issuance of the indicated messages. Only messages of severity Warning (W) or Information (I) can be disabled. If the message has severity of Error (E) or Fatal (F), it is issued regardless of any attempt to disable it. ENABLE=msg-list Enables the issuance of the indicated messages. NOINFORMATIONALS Suppresses informational messages. EMIT_ONCE=msg-list Emits the specified messages only once per compilation. Errors and Fatals are always emitted. You cannot set them to EMIT_ONCE. EMIT_ALWAYS=msg-list Emits the specified messages at every occurrence of the condition. ERRORS=msg-list Sets the severity of each message in the message-list to Error. Note that supplied Error messages and Fatal messages cannot be made less severe. (Exception: A message can be upgraded from Error to Fatal, then later downgraded to Error again, but it can never be downgraded from Error.) Warnings and Informationals can be made any severity. FATALS=msg-list Sets the severity of each message on the message-list to Fatal. INFORMATIONALS=msg-list Sets the severity of each message in the message-list to Informational. Note that Fatal and Error messages cannot be made less severe. WARNINGS=msg-list Sets the severity of each message in the message-list to Warning. Note that Fatal and Error messages cannot be made less severe. VERBOSE Displays the full message information for every compiler message encountered. This information includes the message description and user action, as well as the identifier, severity, and message text. When /WARNINGS=VERBOSE is used with /LIST/SHOW=MESSAGES, a list of all messages in effect at compilation are added to the listing file, showing the full information for each message. The msg-list can be any one of the following: o A single message identifier (within parentheses, or not). The message identifier is the name following the severity at the start of a line when a message is issued. For example, in the following message, the message identifier is GLOBALEXT: %CC-W-GLOBALEXT, a storage class of globaldef, globalref, or globalvalue is a language extension. o A single message-group name (within parentheses, or not). Message-group names are: ALL All the messages in the compiler ALIGNMENT Messages about unusual or inefficient data alignment. C_TO_CXX Messages reporting the use of C features that would be invalid or have a different meaning if compiled by a C++ compiler. CDD Messages about CDD (Common Data Dictionary) support. CHECK Messages reporting code or practices that, although correct and perhaps portable, are sometimes considered ill-advised because they can be confusing or fragile to maintain. For example, assignment as the test expression in an "if" statement. NOTE: The check group gets defined by enabling LEVEL5 messages. DEFUNCT Messages reporting the use of obsolete features: ones that were commonly accepted by early C compilers but were subsequently removed from the language. NEWC99 Messages reporting the use of the new C99 Standard features. NOANSI This is a deprecated message group. It is an obsolete synonym for NOC89. Also see message groups NEWC99, NOC89, NOC99. NOC89 Messages reporting the use of non-C89 Standard features. NOC99 Messages reporting the use of non-C99 Standard features. OBSOLESCENT Messages reporting the use of features that are valid in ANSI Standard C, but which were identified in the standard as being obsolescent and likely to be removed from the language in a future version of the standard. OVERFLOW Messages that report assignments and/or casts that can cause overflow or other loss of data significance. PERFORMANCE Messages reporting code that might result in poor run-time performance. PORTABLE Messages reporting the use of language extensions or other constructs that might not be portable to other compilers or platforms. PREPROCESSOR Messages reporting questionable or non-portable use of preprocessing constructs. QUESTCODE Messages reporting questionable coding practices. Similar to the CHECK group, but messages in this group are more likely to indicate a programming error rather than just a non-robust style. Enabling the QUESTCODE group provides lint-like checking. RETURNCHECKS Messages related to function return values. UNINIT Messages related to using uninitialized variables. UNUSED Messages reporting expressions, declarations, header files, CDD records, static functions, and code paths that are not used. o A single message-level name (within parentheses, or not). Note: There is a core of very important compiler messages that are enabled by default, regardless of what you specify with /WARNINGS or #pragma message. Referred to as message level 0, it includes all messages issued in header files, and comprises what is known as the nostandard group. All other message levels add additional messages to this core of enabled messages. You cannot modify level 0 (You cannot disable it, enable it, change its severity, or change its EMIT_ONCE characteristic). However, you can modify individual messages in level 0, provided such modification is allowed by the action. For example, you can disable a warning or informational in level 0, or you can change an error in level 0 to a fatal, and so on. (See above restrictions on modifying individual messages.) Message-level names are: LEVEL1 Important messages. These are less important than the level 0 core messages, because messages in this group are not displayed if #pragma nostandard is active. LEVEL2 Moderately important messages. LEVEL3 Less important messages. LEVEL3 is the default message level. LEVEL4 Useful check/portable messages. LEVEL5 Not so useful check/portable messages. LEVEL6 Additional "noisy" messages. Enabling a level also enables all the messages in the levels below it. So enabling LEVEL3 messages also enables messages in LEVEL2 and LEVEL1. Disabling a level also disables all the messages in the levels above it. So disabling LEVEL4 messages also disables messages in LEVEL5 and LEVEL6. o A comma-separated list of message identifiers, group names, and messages levels, freely mixed, enclosed in parentheses. The default is /WARNINGS. This enables all diagnostic messages for the selected compiler mode. Notes: o If a message is on both the enabled and disabled list, it is disabled. o If a message is on both the EMIT_ONCE and the EMIT_ALWAYS list, it is considered to be on the EMIT_ONCE list. o If a message is on more than one of the FATALS, ERRORS, WARNINGS, or INFORMATIONALS lists, the message is given the least severe level. o The NOINFORMATIONALS option is not the negation of INFORMATIONALS=msg-list. It is valid to say: /WARN=(INFORMATIONALS=message_list,NOINFORMATIONALS) This has the effect of making the messages on the message_list informationals, and causing the compiler to suppress any informational messages. 2 Message_Groups VSI C compiler message groups The following tables list all compiler messages by message group. For a description of each compiler message, see the Messages section of this online help. 3 64BIT CVTU32TO64 FUNCMIXPTR LONGLONGSUFX LONGLONGTYPE POINTERINTCAST PRAGIGNORE PTRINTTOLONG PTRLONGTOINT TRUNCLONGCAST TRUNCLONGINT 3 64BITPOINTERS POINTERINTCAST 3 ALIGNMENT ALIGNCONFLICT ALIGNCONFLICT1 ALIGNCONST ALIGNEXT MISALGNDMEM MISALGNDSTRCT NONMULTALIGN UNALIGNEXT 3 C_TO_CXX CLASSNOINIT CONSTNOINIT CONSTSTOCLS CXXKEYWORD INTIMPLIED KNRFUNC NESTEDENUM NESTEDTYPE NONEWTYPE NONULINIT NOPARMLIST STORCLSDCL STORMODDCL TENTREDEF 3 CDD CDDEXT TEXTARRAY TEXTARRAYN TEXTCHAR 3 DEFUNCT DEFPARMTYPE DUPENUM EMBEDCOMMENT LONGFLOATEXT MAINPROGEXT READONLYEXT 3 NEWC99 ADDRCONSTEXT ARRNOTLVALUE BOOLEXT COMPLEXEXT CXXCOMMENT DECLAFTERSTMT DECLINFOR DEFRETURNTYPE DESIGNATORUSE DOLLARID DUPTYPQUAL FUTUREKEYWD2 FUTUREKEYWORD IMPLICITFUNC INCOMPARRY2 INTCONSTSIGNED LONGLONGSUFX LONGLONGTYPE NEEDCONSTEXT RESTRICTEXT2 TRAILCOMMA TYPQUALNOT2 UCNUNSUPP UCNUSED VLAEXTENSION WCHARCAT XTRALARGE 3 NOC89 ADDRCONSTEXT ADDRSUBCONST ALIGNEXT ARGADDR ARRNOTLVALUE ASSIGNEXT BADCMMNTPSTNG BADREGISTER BITNOTINT BOOLEXT CDDEXT CMPPTRFUNVOID COMPLEXEXT CONSTCOMPLIT CONSTFUNC CONVARASLIT CXXCOMMENT DECLAFTERSTMT DECLINFOR DECLSPECEXT DESIGNATORUSE DOLLARID DUPENUM DUPTYPEDEF DUPTYPQUAL ELLIPSEARG ELLIPSEPARM EMPTYCHARCONST ENUMSNOTCOMPAT EXPANDEDDEFINED EXTENDTYPE FLEXARRAYELEM FLEXARRAYMEM FUNCREDECL FUTUREKEYWD2 FUTUREKEYWORD GLOBALEXT HEXOCTSIGN IDINPARENSEXT INCARRAYPARM1 INCOMPARRY INCOMPARRY1 INCOMPARRY2 INCOMPDEREF INLINESTOCLSMOD INTCONSTTOOBIG LABELWOSTMT LONGFLOATEXT LONGLONGSUFX LONGLONGTYPE LVALUECAST MACROREDEF MAINNOTINT MAINPROGEXT MISMATPARAM MISPARAMCOUNT MIXFUNCVOID NEEDCONSTEXT NODCL NONAMEMEMBERS NONINTENUM NONOCTAL NONPORTLINEDIR NONSTANDCAST NOSEMISTRUCT NOSHAREEXT NOTADDRCAST OKCPPINARGS PARENLITERAL PRAGMAIDENT PRAGMAMOD PTRMISMATCH1 READONLYEXT RESTRICTEXT RESTRICTEXT1 RESTRICTEXT2 SAMEASTYPEDEF TEXTMODULE TRAILCOMMA TYPEDEFNA TYPEOFEXT TYPQUALNOT2 UCNUNSUPP UCNUSED UNALIGNEXT UNDEFENUM UNSIGNEDPRES UNSTRUCTMEM VARIANTEXT VLAEXTENSION VOLATILEFUNC WCHARCAT XTRALARGE 3 NOC99 ADDRSUBCONST ALIGNEXT ARGADDR ASSIGNEXT BADCMMNTPSTNG BADREGISTER BITNOTINT CDDEXT CMPPTRFUNVOID CONSTCOMPLIT CONSTFUNC CONVARASLIT DECLSPECEXT DUPENUM DUPTYPEDEF ELLIPSEARG ELLIPSEPARM EMPTYCHARCONST ENUMSNOTCOMPAT EXPANDEDDEFINED EXTENDTYPE FLEXARRAYELEM FLEXARRAYMEM FUNCREDECL GLOBALEXT HEXOCTSIGN IDINPARENSEXT INCARRAYPARM1 INCOMPARRY INCOMPARRY1 INCOMPDEREF INLINESTOCLSMOD INTCONSTTOOBIG INTCONSTUNSIGN LABELWOSTMT LONGFLOATEXT LVALUECAST MACROREDEF MAINNOTINT MAINPROGEXT MISMATPARAM MISPARAMCOUNT MIXFUNCVOID NODCL NONAMEMEMBERS NONINTENUM NONOCTAL NONPORTLINEDIR NONSTANDCAST NOSEMISTRUCT NOSHAREEXT NOTADDRCAST OKCPPINARGS PARENLITERAL PRAGMAIDENT PRAGMAMOD PTRMISMATCH1 READONLYEXT RESTRICTEXT RESTRICTEXT1 SAMEASTYPEDEF TEXTMODULE TYPEDEFNA TYPEOFEXT UNALIGNEXT UNDEFENUM UNSIGNEDPRES UNSTRUCTMEM VARIANTEXT VOLATILEFUNC 3 OBSOLESCENT DEFRETURNTYPE INTIMPLIED KNRFUNC STONOTFIRST 3 OVERFLOW BITCONSTSIGN INPTRTYPE INTCONCASTSGN INTCONCASTTRU INTCONSTSIGN INTCONSTTRUNC MAYHIDELOSS NONOCTAL OUTSTRINGTYPE OUTTYPELEN RIGHTSHIFTOVR TRUNCFLTASN TRUNCFLTINT TRUNCINTASN TRUNCINTCAST 3 PERFORMANCE ALIGNCONFLICT ALIGNCONFLICT1 BLTINIMPLRET MISALGNDMEM MISALGNDSTRCT NONMULTALIGN 3 PORTABLE ADDRARRAY ADDRCONSTEXT ADDRSUBCONST ALIGNCONST ALIGNEXT ARGADDR ARRNOTLVALUE ASSIGNEXT BADCMMNTPSTNG BADREGISTER BITNOTINT BOOLEXT CDDEXT CMPPTRFUNVOID COMPLEXEXT CONSTCOMPLIT CONSTFUNC CONVARASLIT CXXCOMMENT DECLAFTERSTMT DECLINFOR DECLSPECEXT DESIGNATORUSE DOLLARID DUPENUM DUPSTORCLS DUPTYPEDEF DUPTYPQUAL ELLIPSEARG ELLIPSEPARM EMBEDCOMMENT EMPTYCHARCONST ENUMSANDINT ENUMSNOTCOMPAT EXPANDEDDEFINED EXTENDTYPE FLEXARRAYELEM FLEXARRAYMEM FUNCREDECL FUTUREKEYWD2 FUTUREKEYWORD GLOBALEXT HEXOCTSIGN HEXOCTUNSIGN IDINPARENSEXT INCARRAYPARM INCARRAYPARM1 INCOMPARRY INCOMPARRY1 INCOMPARRY2 INCOMPDEREF INCOMPELMNT INLINESTOCLSMOD INTCONSTSIGNED INTCONSTTOOBIG INTCONSTUNSIGN LABELWOSTMT LONGFLOATEXT LONGLONGSUFX LONGLONGTYPE LVALUECAST MACROREDEF MAINNOTINT MAINPROGEXT MISMATPARAM MISPARAMCOUNT MIXFUNCVOID MULTICHAR NAMESHORTENED NEEDCONSTEXT NONAMEMEMBERS NONINTENUM NONOCTAL NONPORTLINEDIR NONSTANDCAST NOSEMISTRUCT NOSHAREEXT NOTADDRCAST OKCPPINARGS PARENLITERAL PRAGMA PRAGMAIDENT PRAGMAMOD QUALNA READONLYEXT RESTRICTEXT RESTRICTEXT1 RESTRICTEXT2 SAMEASTYPEDEF SWITCHLONG TEXTMODULE TRAILCOMMA TYPEDEFNA TYPEOFEXT TYPQUALNOT2 UCNUNSUPP UCNUSED UNALIGNEXT UNDEFENUM UNSTRUCTMEM VALUEPRES VARIANTEXT VLAEXTENSION VOLATILEFUNC WCHARCAT 3 PREPROCESSOR BADCMMNTPSTNG CDDEXT EMBEDCOMMENT EXPANDEDDEFINED MACROREDEF NESTINCL NONPORTLINEDIR OKCPPINARGS PRAGMAIDENT PRAGMAMOD TEXTMODULE UNKNOWNMACRO UNNECCDD UNNECINCL UNUSEDCDD UNUSEDINCL UNUSEDTOP VAARGSBODY XTRALARGE 3 QUESTCODE BADCMMNTPSTNG BADREGISTER BITCONSTSIGN CONSTFUNC CONSTNOINIT CONTROLASSIGN DUPENUM ELLIPSEARG ELLIPSEPARM EMPTYCHARCONST ENUMCALC ENVIRSTKDIRTY EXPRNOTUSED FALLOFFEND FUNCMIXPTR FUNCREDECL IMPFNCFALLOFF IMPFNCMSSNGRET INCOMPDEREF INTCONCASTSGN INTCONCASTTRU INTCONSTSIGN INTCONSTTRUNC INTIMPLIED LVALUECAST MACROREDEF MISSPELLDEF MULTICHAR NESTEDCOMMENT NODCL NONOCTAL NONULINIT NORETURNVAL1 OKCPPINARGS PTRMISMATCH1 QUALFUNCRET QUESTCOMPARE QUESTCOMPARE1 QUESTCOMPARE2 RIGHTSHIFTOVR SAMEASTYPEDEF SHORTCIRCUIT SUBSCRBOUNDS1 SUBSCRBOUNDS2 TYPEDEFNA UNDEFENUM UNDEFESCAP UNINIT2 UNINIT3 UNINIT4 UNINIT5 UNKNOWNMACRO UNREACHCODE USELESSTYPEQUAL VOLATILEFUNC 3 RETURNCHECKS DEFRETURNTYPE FALLOFFEND IGNORECALLVAL IMPFNCFALLOFF IMPFNCMSSNGRET NORETURNVAL1 QUALFUNCRET 3 UNINIT UNINIT2 UNINIT3 UNINIT4 UNINIT5 3 UNUSED CONSTFUNC EXPNOTRES EXPRNOTUSED MISSPELLDEF NESTEDCOMMENT NESTINCL PRAGIGNORE QUALFUNCRET QUALNA SHORTCIRCUIT UNCALLED UNNECCDD UNNECINCL UNREACHCODE UNREFADECL UNREFDECL UNREFLABEL UNREFSDECL UNREFSFUNC UNREFTYP UNUSEDCDD UNUSEDINCL UNUSEDTOP VOLATILEFUNC 2 Messages Compiler messages - HP C V7.1 Some compiler messages substitute information from the program into the message text. In this online help, the portion of the text to be substituted is shown in angle brackets (<>). Often, the same message is issued in different contexts within a program. In this online help, the message context is indicated by the word within the message. The actual message issued by the compiler will contain one of the following phrases substituted for : In this declaration, In the initializer for In the declaration of "", In the definition of the function "", In the declaration of an unnamed object, In this statement, You can control the messages issued with the /[NO]WARNINGS command line qualifier or the #pragma message preprocessor directive. Note that some messages are not produced directly by the compiler; they are produced by other software that the compiler uses. Messages not produced directly by the compiler are not included in this list and can not be controlled by /[NO]WARNINGS or #pragma message. 3 ABSTRACTDCL Message Invalid abstract declarator. Description An identifier was encountered in an abstract declarator. An abstract declarator is used to specify a type only and must not contain an identifier that specifies a declarator. User Action Correct the abstract declarator. 3 ADDRARRAY Message & before array "" is ignored. Description In certain modes, HP C will ignore an address-of operator used on an entire array. This is for compatibility with other compilers that have this behavior. User Action Remove the address-of operator. 3 ADDRCONSTEXT Message "" does not have a constant address, but occurs in a context that requires an address constant. This is an extension of the language. Description The C89 standard requires that an initializer for a pointer-type member of an automatic aggregate or union-type object have an initializer that is an address constant. Other C compilers might not successfully compile a program that uses this extension. User Action Be aware of this if you wish to port the program. 3 ADDRESSOFVOID Message taking the address of a void type is a language extension. Description The HP C compiler will allow taking the address of a void type for compatibility with other compilers. This is an extension to the standard. Other compilers may reject this. User Action Be aware of this if you plan to port this source to another compiler. 3 ADDRSUBCONST Message accepting the expression "" as a constant is a language extension. Description In many cases HP C accepts the subtraction of two addresses within the same array or struct/union as a constant. The C standard does not consider such an expression to be a constant. Therefore, this program does not conform to the standard and may be rejected by other compilers. User Action Change the expression to be a constant. 3 ALIGNCONFLICT Message the address "" has alignment of which is less than the alignment requirements of the destination pointer. Dereferencing the destination pointer may cause an alignment fault. Description The compiler has detected a situation where a pointer to an aligned data type is being assigned an address that may not be properly aligned. A later dereference of this pointer could cause an alignment fault. User Action There are a number of possible actions. The best is to correct the condition that is causing the source to have the wrong alignment, as access to an unaligned data structure involves additional run-time overhead. Other options would be to modify the declaration of the destination pointer such that its referenced type has the __unaligned type qualifier, or use the compiler option that tells the compiler to assume all pointer references are unaligned. It is also possible to cast the source to the destination type to silence this message. However, that solution will not correct any unaligned access. 3 ALIGNCONFLICT1 Message the address "" has alignment of which is less than the alignment requirements of the pointer type it is cast to. Dereferencing the resulting pointer may cause an alignment fault. Description The compiler has detected a situation where an address is being cast to a pointer type with a greater alignment requirement than the type of the address expression implies. A later dereference of this pointer type value could cause an alignment fault. User Action There are a number of possible actions. The best is to correct the condition that is causing the source to have the wrong alignment, as access to an unaligned data structure involves additional run-time overhead. Other options would be to change the type of the pointer used in the cast such that its referenced type has the __unaligned type qualifier, or use the compiler option that tells the compiler to assume all pointer references are unaligned. It is also possible to cast the address expression to (void *) before casting it to the specified type to silence this message. However, that solution will not correct any unaligned access. 3 ALIGNCONST Message Integer constant alignment is not necessarily supported on all platforms. Description Although the specified alignment value is valid on this system, it might not be valid on other systems. For example, 16 is a valid alignment value on Alpha systems but would not be valid on VAX systems. User Action Be aware of this potential portability issue. 3 ALIGNEXT Message _align is a language extension. Description The _align storage class modifier is a language extension of HP C. Other C compilers might not successfully compile a program that uses the extension. User Action Be aware of this extension if you wish to port the code. 3 ALIGNPOP Message This "restore" has underflowed the member alignment's stack. No corresponding "save" was found. Description The member_alignment stack, managed by the #pragma member_alignment and #pragma environment directives, contains more restores than saves. This could signify a coding or logic error in the program. User Action Make sure each restore has a corresponding save. 3 ALREADYTLS Message The identifier "" has already appeared in an omp threadprivate directive. Description The same identifier appears more than once in a single omp threadprivate directive, or appears in more than one omp threadprivate clause. User Action Remove the duplicate identifiers 3 ANSIALIASCAST Message a pointer to is being cast to a pointer to . Using ANSI aliasing rules, the compiler may subsequently assume that the two pointer types are pointing to different storage locations. Description The C standard allows a compiler to assume that these two pointer types will point to different storage locations. The compiler will make this assumption whenever ansi aliasing is enabled on the command line, either directly or via another switch. The cast in itself does not violate aliasing rules, e.g. you might cast the pointer value back to an allowed type before you use it to access memory. But the compiler cannot generally determine whether or not you do that. If your code accesses the memory designated by this pointer value using both of these pointer types, you may get unexpected results when ansi aliasing is enabled. User Action Casting through pointer to void will silence this message. But if the end result is that the same memory still gets accessed through different types that are not permitted under the aliasing rules, you may still get unexpected results. If compiling without ansi aliasing corrects the behavior of your program, your code almost certainly violates the aliasing rules in a way that the compiler cannot detect. 3 ARGADDR Message taking the address of the constant expression "" in an argument list is a language extension. Description The HP C compiler will allow the address of a constant to be passed as an argument to a function call. This is an extension to standard C. Other C compilers might not successfully compile a program that uses this extension. User Action Assign the constant to a variable, and pass the address of the variable. 3 ARGLISGTR255 Message the function call specifies an argument list whose length exceeds maximum specified by the calling standard. Any use of va_count by the called function will be wrong. Description The OpenVMS calling standard uses a byte-sized field to specify the size of the argument list. The argument list to this function call requires more storage than can be represented in this size. As a result, any use of va_count in the called function will return inaccurate information. User Action Either reduce the size of the argument list, or do not use va_count in the called function. 3 ARGLISTOOLONG Message the function call specifies an argument list whose length exceeds the VAX architecture limit. This call allocates stack space that is never deallocated by the called program. Description The OpenVMS VAX Calling Standard requires that the called program deallocate the storage allocated for its arguments. This is done by looking at the byte-size value that holds the argument list size. However, the argument list to this function call requires more storage than can be represented in a byte. As a result, the called function will not deallocate the proper amount of storage. This could result in unpredictable behavior. User Action Reduce the size of the argument list. 3 ARGSIZE Message the argument being passed to this function is too small. Description A function parameter of array type has been declared with the keyword "static" in its outermost bound to indicate that the function may generate code that assumes that when it is called the actual argument will have at least as many elements as specified in the parameter declaration. The argument provided in this call has fewer array elements than specified in the parameter declaration with static bound. User Action Check the size of the argument passed to the function and/or modify or remove the static bound on the function parameter. 3 ARRAYBRACE Message a required set of braces is missing. Description The initializer for this array was not enclosed in braces. While some compilers allow this, standard C requires braces around the initializer. User Action Enclose the initializer in braces. 3 ARRAYLIMITSUP Message HP C provides only limited support for array types larger than bytes. Description This array type is larger than can be represented by size_t. While HP C will allow a type declared to be this size, uses of the type are not fully supported and may cause unpredictable behavior. User Action Reduce the size of the array type. It may be possible to use a pointer type instead of a large array. The storage can still be accessed using array syntax. 3 ARRAYOVERFLOW Message Integer overflow occurred when computing the size of an array type. Description An array type is larger than allowed on this platform. User Action Reduce the size of the array type. It may be possible to use a pointer type instead of a large array. The storage can still be accessed using array syntax. 3 ARRNOTLVALUE Message accepting a non-lvalue array in a subscript operator is an extension to the C89 standard. Description The C89 standard states that one of the operands to the subscript operator must be a pointer. However, the array used in this operator could not be converted to a pointer because it is not an lvalue. Therefore this code does not conform to the C89 standard and may not be accepted by other compilers. Note that the C99 standard allows this because all arrays are converted to pointers, not just lvalue arrays. User Action Be aware of this difference if you plan to port this source to another compiler. 3 ASMCOMEXP Message Comma expected while processing instruction Description The asm directive parser was expecting a comma, but one was not found. User Action Correct the asm directive. 3 ASMENDEXP Message Semicolon or asm end expected while processing instruction Description The asm directive parser was expecting a semicolon to end an instruction, but one was not found. User Action Correct the asm directive. 3 ASMFIMMDOTS Message Floating point load-immediate instructions require a .s file Description Using a floating point load immediate instruction in this asm directive will require the compiler to produce an .s file and invoke the assembler to process this source. User Action Do not use floating point load immediate instructions in asm directives. 3 ASMFREGEXP Message Float register expected while processing instruction Description The asm directive parser was expecting a valid floating register, but one was not found. User Action Correct the asm directive. 3 ASMHINTDOTS Message Hint on instruction requires a .s file Description Using a hint in a transfer instruction in this asm directive will require the compiler to produce an .s file and invoke the assembler to process this source. User Action Do not use hints in asm directives. 3 ASMICONEXP Message Integer constant expected while processing instruction Description The asm directive parser was expecting a valid integer constant, but one was not found. User Action Correct the asm directive. 3 ASMIDEXP Message Identifier expected while processing instruction Description The asm directive parser was expecting an identifier, but one was not found. User Action Correct the asm directive. 3 ASMINSTEXP Message Instruction mnemonic expected (found ) Description The asm directive parser was expecting an instruction mnemonic, but one was not found. User Action Correct the asm directive. 3 ASMLABEXP Message Label expected while processing instruction Description The asm directive parser was expecting a label, but one was not found. User Action Correct the asm directive. 3 ASMLABMULDEF Message Multiple definitions of label in asm () Description The asm directive parser has detected the same label defined more than once. User Action Change one of the label names. 3 ASMLABUNDEF Message Reference to undefined label in asm () Description The asm directive parser has detected a reference to an undefined label. User Action Correct the asm directive. 3 ASMLDGPDOTS Message Unusual ldgp requires a .s file Description This indicates that a ldgp pseudo-instruction was encountered in an unusual place or with unusual arguments. The assembler will be invoked on the .s file. User Action Correct the asm directive. 3 ASMLPAREXP Message Left paren expected while processing instruction Description The asm directive parser was expecting a left paren, but one was not found. User Action Correct the asm directive. 3 ASMNOTAVAIL Message In-line assembly code directive is not available on this platform. Description In-line assembly code is not available on the IA64 platform. User Action See documentation for alternatives. 3 ASMNOTINST Message instruction is not supported in asms on Description The asm directive parser does not recognizes a pseudo-opcode on this platform. User Action Correct the asm directive. 3 ASMNOTREG Message is not a register name on Description The asm directive parser has noticed that a special register used in the directive is not valid on this platform. User Action Correct the asm directive. 3 ASMNOTSUP Message Support for () in asms is not implemented on Description The asm directive parser does not support the feature in question on this platform. User Action Rewrite the asm so that the feature is not used. 3 ASMPALTRUNC Message PALcode function has been truncated to Description The asm directive call_pal instruction is followed by an integer beyond the range of call_pal values expected by the compiler. User Action Use a valid call_pal argument. 3 ASMRAWREG Message uses before it is defined Description The asm directive parser has noticed that an instruction uses a register as a source before it is given a value. User Action Correct the asm directive. 3 ASMREGEXP Message Fixed register expected while processing instruction Description The asm directive parser was expecting a valid integer register, but one was not found. User Action Correct the asm directive. 3 ASMREGOVRLAPSC Message Destination register overlaps input for (software completion) instruction Description An asm directive contains an instruction that may require a software completion routine in case of a runtime exception. Such an instruction requires that the result register be different than any input register. User Action Modify the asm so that the destination register is different than the sources. 3 ASMRPAREXP Message Right paren expected while processing instruction Description The asm directive parser was expecting a right paren, but one was not found. User Action Correct the asm directive. 3 ASMSYMDOTS Message Use of symbolic addresses with instruction requires a .s file Description Using a symbolic operand in this asm directive will require the compiler to produce an .s file and invoke the assembler to process this source. User Action Do not use symbolic operands in asm directives. 3 ASMUNKNOWNARCH Message Unknown architecture () specified in assembler directive Description The asm directive parser has detected an unexpected argument to a .tune or .arch directive. User Action Correct the asm directive. 3 ASMUNKSETOPT Message Unsupported or illegal .set option () Description The asm directive parser has detected an unexpected argument to a .set directive. User Action Correct the asm directive. 3 ASSERTFAIL Message The assertion "" was not true, . Description The expression in a #pragma assert non_zero(expression) directive was found to be zero. User Action Correct the condition that caused the expression to be zero. 3 ASSERTION Message Description This message is emitted by the code generator. It should never be output when compiling a C program. User Action Please submit a problem report if you encounter this message when compiling a C program. 3 ASSIGNEXT Message relaxed struct or union type compatibility is a language extension. Description In certain modes, the compiler will allow assignments or comparisons between structs or unions of different types if their sizes are the same. This is an extension to standard C. Other C compilers might not successfully compile a program that uses this extension. User Action Recode the operation to use one of the memxxx run-time library functions. 3 ASSUMEONEELEM Message The type of the tentatively-defined array "" is incomplete at the end of the compilation unit. The compiler will assume one array element. Description The C standard requires that the type of all tentative definitions must be completed before the end of the compilation unit. For compatibility with some other C compilers, HP C will give the array one element. User Action Complete the type. 3 AUTOALIGN Message The alignment boundary of an automatic cannot be greater than longword. Description For automatic variables, the storage class modifier _align cannot specify an alignment greater than longword on VAX systems. The alignment will be set to longword. User Action Decrease the alignment. If a larger alignment is required, declare the variable with static storage class. 3 AUTOEXTERNAL Message a storage class of "auto" or "register" is illegal at file scope. Description The storage classes auto and register can only be used in a declaration that appears inside a function. They cannot be used in a declaration at file scope. User Action Remove the storage class specifier or move the declaration inside a function body. 3 BADALIAS Message Reference through restricted pointer uses a pointer value based on different restricted pointer, Description The C language requires that restricted pointers always point to different storage. The compiler has detected a case where an access using a restricted pointer is referencing memory pointed to a different restricted pointer. This may cause unexpected behavior. User Action Make sure restricted pointers point at unique storage. 3 BADALIGN Message Invalid alignment boundary. Description The _align storage class modifier was given an invalid value. See documentation for valid values on each platform. User Action Supply a correct value or remove the _align storage class modifier. 3 BADANSIALIAS Message This statement accesses an object . The statement at accesses the same storage location . Description The standard allows a compiler to assume that since these two statements use different types, these two statements reference different storage locations. The HP C compiler does so whenever ansi aliasing is enabled. Since your code relies on these two statements accessing the same storage location you should disable ansi aliasing. If you do not do so, optimization may cause your program to behave unexpectedly. User Action Specify noansi_alias on the command line. 3 BADBOUNDCHK Message pointer arithmetic was performed more than once in computing an array element. The bounds checking code output by the compiler will only verify the "" expression. Description When an array is accessed using pointer arithmetic and run-time array bounds checking is enabled, the HP C compiler is only able to output the checking code for the first pointer arithmetic operation performed on the array. This can result in an incorrect check if the resulting pointer value is again operated on by pointer arithmetic. Consider the expression a = b + c - d; where a is a pointer, b an array, and c and d integers. When bounds checking is enabled the compiler will output a check to verify that c within the bounds of the array. This will lead to an incorrect runtime trap in cases where c is outside the bounds of the array and c - d is not. User Action Recode the pointer expression so that the integer part is in parenthesis. This way the expression will contain only one pointer arithmetic operation. In the earlier example the expression would be changed to a = b + (c - d); 3 BADBOUNDS Message the array bounds are incorrectly specified. Description A multi-dimensional array declaration contains a missing dimension specifier in a dimension other than the first. User Action Correct the declaration. 3 BADBREAK Message This break statement is not within a for, while, do, or switch statement. Description A break statement can only appear inside a for, while, do, or switch statement. User Action Remove the break statement, or replace it with a goto statement. 3 BADC99PRAGOP Message Invalid syntax for the C99 _Pragma operator, its operands cannot be recognized. Description After macro expansion and whitespace has been removed, the C99 _Pragma keyword must be followed by exactly three tokens: left-parenthesis, string-literal (or wide-string), right-parenthesis. Any other sequence cannot be processed, and will likely produce other spurious compile-time diagnostics. User Action Correct the syntax, or compile in a language mode that does not recognize the C99_Pragma operator (e.g. if your code has used this reserved identifier for some other purpose). 3 BADCHARSINHDR Message Illegal characters after header name. Description While processing an #include directive whose argument did not start with either a '<' or '"' character, the compiler encountered a character it did not expect. This most often occurs when the directive argument is a macro and there is an error during the expansion of that macro. User Action Correct the argument to the #include directive. 3 BADCMMNTPSTNG Message Token concatenation with comments might not be portable -- use ## operator. Description A macro body contains a comment between two tokens with no white space either before or after the comment. Older C compilers allowed this as a form of token pasting. This type of token pasting might not give the desired results with newer compilers. User Action Use the standard C form of token pasting by replacing the comment with the ## token pasting operator. 3 BADCOMLITTYPE Message the type "" cannot be used to specify the type of a compound literal. Description The type of a compound literal must be an object type or an array of unknown size. User Action Use a valid type. 3 BADCOMPLEXTYPE Message "" is an invalid complex type specifier. Description The valid complex type specifiers are float _Complex, double _Complex, and long double _Complex. User Action Use on of the valid complex type specifiers. 3 BADCONDIT Message a common type could not be determined for the 2nd and 3rd operands ("" and "") of a conditional operator. Description The types of the second and third operands of the conditional operator must conform to a set of rules that define what the type of the result of the conditional operator itself will be. If the types of these operands do not conform to those rules, the compiler cannot determine the type of the result, which is an error. Refer to the language documentation for a complete list of valid combinations of types for the second and third operands of the conditional operator. User Action Modify the conditional expression so that the types of the second and third operands conform to the language rules. 3 BADCONSTEXPR Message Syntax error in constant expression. Description A preprocessing constant expression contained a syntax error. The preprocessor was expecting to find a constant value or a left parenthesis. The preprocessor will assume a value of zero was encountered. User Action Correct the preprocessing constant expression. 3 BADCONTINUE Message This continue statement is not within a for, while, or do statement. Description A continue statement can only appear inside a for, while, or do statement. User Action Remove the continue statement, or replace it with a goto statement. 3 BADCONVSPEC Message this argument to contains a bad conversion specification "" that will cause unpredictable behavior. Description The compiler has detected an illformed conversion specification (flags, width, precision, length modifier) or an unknown conversion specifier (not diouxefgcspn...) that will cause unpredictable behavior. This might not have been what you intended. User Action Review the documentation for this function and modify the conversion specification as appropriate. 3 BADDCL Message The name "" cannot be undefined. Description The code has tried to #undef a macro that is predefined by the C standard. This is not allowed. The #undef will be ignored. User Action Remove the #undef directive. 3 BADDECLSPEC Message Invalid argument to __declspec. Valid arguments are "thread" or "__thread". Description The only valid arguments to the __declspec storage class modifier are "thread" or "__thread". User Action Either use one of the valid arguments, or remove the storage class modifier. 3 BADDEFARG Message Bad argument for "defined" operator. Description The defined preprocessing operator was given an invalid argument. The operator expects an identifier optionally enclosed in parenthesis. The value of the operator is undefined. User Action Supply a valid argument to the preprocessing operator. 3 BADENUM Message Invalid enumerator. Description While processing an enumerator list, the compiler was expecting to encounter an identifier, but it found something else instead. User Action Correct the program syntax. 3 BADENUMREDECL Message the enum "" cannot be given a type other than signed int because the tag was declared earlier at . Description This enum tag would normally be given a type other than signed int because the enumeration constants used in the declaration exceed the range of signed int. The compiler cannot use the extended type because the enum tag was declared earlier, and given signed int type at that point. User Action Remove the earlier tag declaration. 3 BADEXPR Message Invalid expression. Description An invalid expression was encountered. User Action Correct the program syntax. 3 BADFATCOMMENT Message The compiler cannot recover. Description In certain cases, the compiler cannot proceed after an unterminated comment. In these cases this message will be issued. Note that this message is always output after the opencomment error has been output. User Action Terminate the comment before the end-of-file. 3 BADFBDAT Message contains invalid feedback data Description A feedback file contains data, but it was corrupt and could not be used. User Action Create a new feedback file. 3 BADFBFILE Message Invalid feedback file: Description The compiler was unable to read information from the specified feedback file. User Action Make sure the feedback file contains valid feedback information. 3 BADFBTYP Message Unexpected file type for feedback file Description The file specified in the -feedback option does not have the file type expected by the compiler. User Action Use a valid feedback file. 3 BADFLOATTYPE Message this floating point type "" is not supported on this platform. Description The IEEE floating types __s_float and __t_float are not supported on the VAX platform. User Action Change the type to a floating type that is supported on VAX, or compile the application on a platform that does support IEEE floating. 3 BADFORMALPARM Message This token may not appear in a formal parameter list. Description While processing the formal parameter list of a macro definition, the compiler encountered an invalid formal parameter specifier. The macro will be be defined and this token will ignored, but that may not have been what you intended. User Action Correct the formal parameter list so that it consists of a comma separated list of identifiers. 3 BADFORSTOCLS Message The declaration in a for loop can only have storage class auto or register. Description The declaration in a for loop contains a storage class specifier other than auto or register. This is not allowed. User Action Correct the storage class. 3 BADFUNCSTOCLS Message The storage class of function cannot be . This storage class has been changed to 'extern'. Description The globalref storage class cannot be used with a function declaration. The compiler will use the storage class extern. User Action Remove the globalref storage class from the function declaration. 3 BADGLOBALTYPE Message This declaration has type "", which is invalid for a globalvalue. The extern_model strict_refdef will be used instead. Description An object with globalvalue storage class can only have a type of integer, enum, or pointer type. In other cases, the compiler will change the storage class from globalvalue to strict_refdef. User Action Change the data type to be one that is valid for a globalvalue. 3 BADHEADERNM Message Invalid include file or header name specification. Description An #include directive was not followed by a valid argument. The directive will be ignored. The #include directive should be followed by either a file specification enclosed in angle brackets, a file specification enclosed in quotes, or an identifier that specifies a text module (OpenVMS only), or a macro to be expanded. User Action Supply a valid argument to the #include directive. 3 BADHEXCONST Message Hex constant value too large. Description A hex constant used in a preprocessor directive is too large. The value of the constant will be undefined. User Action Decrease the value of the constant. 3 BADIDENTUCN Message Invalid UCN encountered in an identifier. Description An identifier contained a Universal Character Name (UCN) that did not conform to the requirements of C99 Annex D for use of UCNs in identifiers. User Action Specify a valid UCN sequence. 3 BADIFDEF Message An #ifdef or #ifndef is not followed by an identifier. Description An #ifdef or #ifndef preprocessing directive was not followed by an identifier. The compiler will consider the preprocessor argument to be an identifier that is not defined. Therefore, in these cases an #ifdef will always be FALSE, and an #ifndef will always be TRUE. User Action Supply a valid identifier to the directive. 3 BADIFNDEFARG Message #ifndef argument is not an identifier. Description An #ifndef preprocessing directive was not followed by an identifier. The compiler will consider this to be a TRUE condition. User Action Supply a valid identifier to the directive. 3 BADINCLDIR Message The #pragma include_directory must not appear after an #include directive or in a /FIRST_INCLUDE file after the first /FIRST_INCLUDE file has been processed. The directive will be ignored. Description There are several restrictions on the placement of the #pragma include_directory directive. It must not appear after any #include directive has been encountered. Also, if /FIRST_INCLUDE is specified on the command line, all #pragma include_directory directives must be placed in the first file in the /FIRST_INCLUDE list (if there is more than one in the list) or in the the main source before any #include directives (if there is only one file in the /FIRST_INCLUDE list). User Action Place the directive in a valid location. 3 BADINCLDIRSIZE Message The include_directory string length must be at least one and must be less than . The directive will be ignored. Description The #pragma include_directory directive does not support an empty string argument. Also the directory must not exceed the longest directory specification supported on this platform. User Action Specify a valid length string. 3 BADINCLUDE Message An #include directive has illegal syntax. Description An #include directive was not followed by a valid argument. This message occurs when the argument starts with a '<' or '"' character, but does not end with a matching delimiter. In this case the compiler will add the matching delimiter to the end of the argument and process the directive normally. User Action Correct the argument to the #include directive. 3 BADLINEDIR Message Missing argument for #line directive. Description An argument was not supplied to a #line preprocessing directive. This directive must be followed by a digit sequence that specifies the line number or a macro that expands to a digit sequence. The directive will be ignored. User Action Supply a valid argument to the directive. 3 BADLINEDIRTV Message Illegal token in #line directive. Description A #line directive was followed by an invalid argument. The #line directive should be followed by either a digit sequence or a digit sequence followed by a string literal. The #line directive will be ignored. User Action Supply a valid argument to the #line directive. 3 BADLINKREG Message Invalid register "" for linkage pragma. Pragma is ignored. Description The compiler encountered bad register specifier in a #pragma linkage directive. The message should point at the offending specifier. The compiler will ignore the entire pragma. User Action Correct the directive. 3 BADLINNUM Message Ignoring the line number for the #line directive -- too small. Description A #line preprocessing directive specified a line value that is either zero or less than zero. This is not valid. The directive will be ignored. User Action Either remove the directive or supply a positive value to the line specifier. 3 BADLOCALE Message The compiler could not set its locale to either the locale-specific native environment or the "C" locale. Description During start-up, the compiler was unable to set its locale. As part of its initialization, the compiler will issue the call setlocale(LC_ALL, ""). If this call fails, the compiler will try to issue the call setlocale(LC_ALL, "C"). If this call also fails, the compiler will issue this message and abort. User Action The best way to determine why the compiler is failing is to write a small program that contains the same library calls the compiler is making and then examine the return values. 3 BADMACROINLN Message Illegal token from macro call in #line directive. Description A #line directive was followed by a macro whose expansion did not form a valid argument to the directive. The #line directive should be followed by either a digit sequence or a digit sequence followed by a string literal. The #line directive will be ignored. User Action Supply a valid argument to the #line directive. 3 BADMACRONAME Message "" directive is not followed by an identifier and is being ignored. Description A #define or #undef preprocessing directive was not followed by an identifier. The first argument to these directives must be an identifier that specifies the macro to define or undefine. The compiler will ignore the directive. User Action Correct the argument to the preprocessing directive. 3 BADMBCOMMENT Message An invalid multibyte character was encountered in a comment. Description An invalid multibyte character was found in a comment. While this will not affect the program execution, it might not have been what you intended. User Action Correct the multibyte character. 3 BADMCRORECURS Message Recursive expansion of macro "" exceeded levels and was terminated. Description In certain cases, the compiler will allow a macro to be recursively expanded. In these cases, the compiler limits the level of the recursion to prevent the compiler from looping to the point where it consumes all available memory. When this level has been reached, this message is output. User Action Rewrite either the macro definition or the macro invocation so that the recursion ends before the compiler limit is reached. Note that the use of recursive macros is not a feature of the C standard, and most other C compilers will not support this. 3 BADMEMBER Message Invalid member declaration. Description A struct or union contains an invalid member declaration. In most cases this error occurs when a semi-colon was omitted from the previous member declaration. User Action Correct the declaration. 3 BADMEMOFF Message multiple definitions of member "" found with different offsets. Description In certain modes, the compiler will allow a struct or union reference whose right operand is not a member of the struct or union type of the left operand. This is allowed for compatibility with other compilers. However, in these cases the right operand must specify a member name that is declared with the same type and at the same offset in every struct or union type that declares it. This message is issued when the compiler finds member name it is looking for declared with a different offset in more than one struct or union type. User Action HP recommends that the left operand or a struct or union reference specify a member that is a member of the type of the struct or union specified by the right operand. If this modification cannot be made then the member specified by the left operand must be declared at the same offset and with the same data type in all struct or union declarations that declare that member. 3 BADMEMTYP Message multiple definitions of member "" found with different types. Description In certain modes, the compiler will allow a struct or union reference whose right operand is not a member of the struct or union type of the left operand. This is allowed for compatibility with other compilers. However, in these cases the right operand must specify a member name that is declared with the same type and at the same offset in every struct or union type that declares it. This message is issued when the compiler finds a member name it is looking for declared at the same offset but with different types in more than one struct or union type. User Action HP recommends that the left operand or a struct or union reference specify a member that is a member of the type of the struct or union specified by the right operand. If this modification cannot be made then the member specified by the left operand must be declared at the same offset and with the same data type in all struct or union declarations that declare that member. 3 BADMODULEID Message Invalid identifier found immediately following "#pragma module" or "#module" directive. Description The #pragma module or #module directive must be followed by an identifier that specifies the module name used by the linker. User Action Correct the directive. 3 BADMULTIBYTE Message An invalid multibyte character was encountered . Description An invalid multibyte character was encountered. The message will provide additional information about the location and attempted use of the character. User Action Correct the multibyte character. 3 BADNUM Message Qualifier value '' is not an integer Description This message is emitted by the code generator. It should never be output when compiling a C program. User Action Please submit a problem report if you encounter this message when compiling a C program. 3 BADOCTCONST Message Octal constant value too large. Description An octal constant used in a preprocessor directive is too large. The value of the constant will be undefined. User Action Decrease the value of the constant. 3 BADOPCCAP Message instruction used is not in the selected instruction set Description The compiler has output an instruction that is not in the instruction set selected on the command line. One way this can happen is to compile a program which contains a floating point operation and specifying that no floating point instructions should be generated. User Action Either modify the source so the instruction will not be necessary, or use a different instruction set. 3 BADOPENBRACE Message This open brace may be missing a close brace and causing the syntax error at . Description This message is always output to the terminal after another syntax error. It is intended to provide the programmer with additional information that may identify the cause of the syntax error. This message may, or may not, provide useful information. In general, the more consistent the coding style in the source function, the more likely this message will be accurate. User Action Correct the program syntax. 3 BADPARSEDECL Message In this declaration, "" must specify a type. Description In processing a declaration, the type of the declarator has not been declared as a typedef. User Action Either declare the type as a typedef, or correct the spelling of the type specifier in this declaration. 3 BADPARSEPARAM Message In this parameter list, "" must either be a type or must be followed by a ",". Description In processing a function declaration, the compiler has found a case where the parameter list begins with two identifiers not separated by a comma and where the first identifier is not a type specifier. If this is an old-style declaration the two identifiers must be separated by a comma. If this is a prototype declaration, the first identifier must specify a type. User Action Correct the function parameter specifiers. 3 BADPPDIR Message File ends in an unfinished pp directive. Description An unexpected end-of-file was encountered during a preprocessing directive. User Action Correct the directive. 3 BADPRAGMAARG Message Unexpected or missing argument to #pragma . Pragma is ignored. Description An argument to a #pragma preprocessing directive is either missing or is not correct. The compiler will ignore the directive. User Action Correct the directive. 3 BADPRAGMAARG1 Message Unexpected token encountered in pragma. Found "" when expecting . The pragma will be ignored. Description While parsing a #pragma directive, the compiler has encountered something unexpected. The message will contain information about what the compiler was expecting as well as what it found. User Action Correct the offending directive. 3 BADPRAGMALINK Message A bad linkage pragma was specified. Pragma is ignored. Description The compiler encountered a bad #pragma linkage directive. The error message should point to the place in the pragma that the compiler considers bad. The compiler will ignore the entire pragma. User Action Correct the directive. 3 BADPRAGNAMES Message Invalid argument to the pragma names directive. Pragma is ignored. Description An invalid argument has been specified for the #pragma names preprocessing directive. User Action Correct the argument to the pragma. 3 BADPREFIX Message Argument to extern_prefix is not a recognized keyword or a quoted string. Pragma is ignored. Description An invalid argument has been specified for the #pragma extern_prefix preprocessing directive. The directive expects either the identifiers "save", "__save", "restore", "__restore", or a string constant that specifies the external prefix to use. The compiler will ignore the pragma. User Action Correct the argument to the pragma. 3 BADPROTYP Message Unexpected file type for profile file Description The file specified in the -feedback option does not have the file type expected by the compiler. User Action Use a valid feedback file. 3 BADPTRARITH Message performing pointer arithmetic on a pointer to void or a pointer to function is not allowed. The compiler will treat the type as if it were pointer to char. Description Pointer arithmetic is not allowed on pointers to function or void types For compatibility with some other compilers, an output file is still created. The result produced will be the same as if the pointer were a pointer to char. This may or may not be compatible with other compilers that accept this syntax. User Action Cast the pointer type to a pointer to object type before performing the arithmetic. 3 BADREGISTER Message "" has register storage class, but occurs in a context that precludes register storage. The storage class has been changed to auto. Description An object that was declared with register storage class has been referenced in a way that is not valid for a register. The most common example is taking the address of an object declared with register storage class. As certain array accesses also require taking the address of an array, this message can also be output for accessing the element of an array declared with register storage class. The compiler will change the storage class from register to auto. User Action Either remove the register storage class from the declaration, or change the reference to be one that is valid for objects with register storage class. 3 BADRETURNTYPE Message a function cannot return type. Description A function return type cannot be an array or function type. User Action Correct the function declaration so that the return type is valid. 3 BADSEVERITY Message The severity of message id cannot be made less severe. The severity for this message was not changed. Description The severities of the compiler's error and fatal messages cannot be changed to a severity that is less severe. The compiler's fatal messages cannot be changed to any other severity. The compiler's error messages can only be changed to fatals. User Action Remove the pragma or compiler option that tried to change the severity. 3 BADSTATICCVT Message the address cannot be converted to the destination type. Description A static initialization tried to convert a link-time address to another type. However, the linker on this platform will not support such a conversion. User Action Rewrite the static initialization, or perform the initialization using runtime code. 3 BADSTDLINKAGE Message If standard_linkage is used, it must be the only characteristic specified. Description The standard_linkage characteristic cannot be used with any other linkage characteristic. User Action Correct the pragma. 3 BADSTMT Message Invalid statement. Description An invalid statement was encountered. The most common cause of this error is when a declaration appears after the first statement in a compound statement. User Action Correct the program syntax. 3 BADSTMT1 Message Invalid statement. This condition may have been caused by an open brace without a matching close brace. The compiler will attempt to identify open braces that might be missing a close brace. Description An invalid statement was encountered. This condition may have been caused missing close brace. This message is followed by some number of additional messages that attempt to identify User Action Correct the program syntax. 3 BADSUBSCRIPT Message an array subscript expression is either less than zero or greater than the largest value that can be represented by the size_t type. Description The compiler has detected an array subscript expression that is outside the bounds of any valid array. The array access might cause unpredictable behavior. User Action Specify a valid array subscript. 3 BADTARGMACRO Message The target macro "" does not match the compiler's target. This will likely cause incorrect code paths to be taken. Description On OpenVMS I64, some users have tried defining the macro __ALPHA explicitly using /DEFINE or a #define in a /FIRST_INCLUDE file as a quick way to deal with source code conditionals that assume that if __ALPHA is not defined then the target must be a VAX. Defining __ALPHA will cause many of the CRTL and other OpenVMS headers to take the wrong path for I64. User Action Remove any definitions of Alpha target macros, and if necessary correct the preprocessor conditionals that seemed to require an Alpha target macro to get the desired effect. E.g. change "#ifdef __ALPHA" to "#ifndef __VAX" or "#if defined(__ALPHA) || defined(__ia64)". 3 BADTKEN Message Lexically invalid token. Description An invalid token was encountered in a preprocessing directive. User Action Correct the preprocessing directive. 3 BADUNKNOWNVLA Message a "*" bounds specifier is invalid. Using a "*" to specify a variable-length array of unknown size is only valid in declarations with function prototype scope. Description Using a "*" as a bounds specifier to designate a variable-length array with unknown size is only valid in declarations with function prototype scope. User Action Supply a valid bound specifier. 3 BADUNROLLVAL Message The #pragma unroll directive takes a value from zero to 255. The value "" is outside that range. The directive will be ignored. Description The value supplied to a #pragma unroll is outside the range allowed for the directive. The #pragma directive will be ignored. User Action Use a valid value for the unroll count. 3 BADUSELINK Message A bad use_linkage pragma was specified. Pragma is ignored. Description The compiler encountered a bad #pragma use_linkage directive. The error message should point to the place in the pragma that the compiler considers bad. The compiler will ignore the entire pragma. User Action Correct the directive. 3 BADUSERMACRO Message The name "" cannot be a user-defined macro. Description The code has tried to #define either a macro that is predefined by the C standard or the DEFINED preprocessing keyword. This is not allowed. The #define will be ignored. User Action Remove the #define directive. 3 BADVASTART Message old-style parameter "", with type that requires default argument promotion, cannot be used with va_start. Description It is invalid for the parameter specified in va_start to be one that requires default argument promotion. User Action The recommended fix is to recode the function definition to use a prototype-format definition. It is also possible to change the parameter declaration to use one of the default types, for example double. 3 BIFENABLED Message The function "" is a builtin function reserved to the compiler, and does not require a #pragma intrinsic. The function will continue to be treated as a builtin. Description A function identifier specified in a #pragma function intrinsic is the name of a builtin function. These functions cannot be explicitly enabled, they are always handled as builtin functions. User Action Remove the inappropriate use of the pragma. 3 BIFNEEDSSTD Message use of "" is not allowed in a function with a non-standard linkage. This function was given the linkage "" by a #pragma use_linkage directive. Description Certain built-ins that return information about a function call require that the function be called with standard linkage. Because this function appears in a #pragma use_linkage directive naming a linkage that specifies attributes other than standard_linkage, these builtins cannot be called from this function. User Action Use a standard linkage on this function, remove the calls to the builtins, or move them to a different function that is called with standard linkage. 3 BIFNOTAVAIL Message Built-in function is not available on this platform. Description This Alpha built-in function is not available on the IA64 platform. User Action See documentation for alternatives. 3 BIFPROTO Message the built-in function, "", requires a prototype declaration from . Description Invoking a built-in function requires that the function be declared before it is invoked. This should be done by including the header file noted in the message. User Action Include the header file before the function is invoked. 3 BITARRAY Message The CDD description for specifies that it is an array of bitfields; It has been converted to a scalar bitfield. Description HP C does not allow arrays of bitfields. The resulting C declaration will be a bitfield of the same total size as that specified in the CDD description. User Action If a bitfield type is acceptable, then no user action is necessary. If, however, the bitfield type is not acceptable, then the CDD description should be altered. 3 BITBADREP Message the bitfield type is not an integral type. Description A bitfield has been declared with a non-integral type. Standard C requires that all bitfields be declared with either int, unsigned int, or signed int type. User Action Change the type of the bitfield. 3 BITCONSTSIGN Message the integer constant "" does not have the same sign as the 1-bit bitfield it is being converted to. Description Either an unsigned 1-bit bitfield was assigned -1, or a signed 1-bit bitfield was assigned 1. This may not be what you intended. User Action Change the constant to be the appropriate sign. 3 BITFIELDSIZE Message The CDD description for bitfield specifies a size greater than 32; The excess is declared separately. Description HP C does not allow individual bitfields larger than 32. As a result, a series of bitfields have been declared whose total size matches that of the CDD definition. User Action If the generated definitions are acceptable, then no user action is necessary. If, however, the generated definitions are not acceptable, then the CDD description should be altered. 3 BITNOTINT Message the bitfield type is not an int, signed int, unsigned int or _Bool. Description A bitfield has been declared with a type other than int, signed int, unsigned int or _Bool. This is not allowed by the C standard. User Action Change the declaration to use one of the allowed types or compile with a standard mode that allows this behavior. 3 BITWIDTH Message the bitfield width expression "" is outside the range to . Description A bitfield width specifier was either less than zero, or is greater than the number of bits in an int. In some modes, the compiler will assume a width specifier equal to the number of bits in an int. User Action Use a valid bitfield width specifier. 3 BITWIDTHTYP Message the bitfield width expression "" does not have an integral type. Description A bitfield width specifier does not have an integral type. A bitfield width specifier must be an integral constant expression. User Action Correct the width specifier. 3 BLOCKEXTVLA Message the block scope identifier "" cannot be declared with a variably modified type because it has extern storage class. Description Only ordinary identifiers with block scope and without storage class extern, or ordinary identifiers with function prototype scope can be declared with a variably modified type. User Action Correct the declaration. 3 BLOCKINL Message Block level declarations of inline functions are not allowed. Description In C99 standard, block level declaration of inline functions are prohibited. User Action Move the inline function declaration to file scope. 3 BLTINARGCNT Message an incorrect number of arguments were passed to the builtin function, "". Description This message is output on OpenVMS systems when the number of arguments passed to the builtin function is not one. User Action Correct the call to the builtin function. 3 BLTINIMPLRET Message for the function "", the implicit return type of "" is not consistent with the expected type of "". It will be treated as an ordinary implicitly defined external function. Description A function that could be handled internally by the compiler has not been declared, so an implicit declaration has been created for the function. The return value for the function is being used, and the implicit return type does not agree with what the compiler expected to see. In such cases, the function will not be handled internally, but will instead be called at run time in the usual manner. This could result in a performance loss, or possibly incorrect results if the implicit return type is incorrect. User Action If the function is intended to refer to the runtime library routine, the appropriate header file should be included in the source. Alternatively, a correct prototype could be provided privately in the source file. If the function is intended to be a replacement for the runtime library routine, disable the intrinsic version by specifying "#pragma function(function_name)" in the source file. 3 BOOLEXT Message The _Bool data type is a new feature in the C99 standard. Other C compilers may not support this feature. Description This is a new language feature in C99. While having a standard specification for portability, the feature may not yet be available in all of the compilers you use. User Action Determine whether or not the use of this feature will cause portability problems for this code. 3 BOOLNA Message The _Bool keyword is not supported in this language mode. It will be treated as an identifier in this compilation. Description Support for the _Bool keyword is only available in certain language modes. Support is not present when the compiler is in VAX C, K & R (common), or strict ANSI89 standard modes. In these language modes _Bool will be treated as an identifier. User Action Compile using one of the other compilation modes. 3 BOUNDADJ Message The CDD description for specifies non-zero-origin dimension bound(s); The bound(s) are adjusted to zero-origin. Description The CDD description specifies lower bounds(s) for an array that is non-zero. The resulting C definition will have the upper bound(s) adjusted for lower bound(s) of zero. User Action Verify that all subscript expressions are referencing the correct array element(s). 3 BOUNDNOTINT Message the array bound "" does not have an integral type. Description The compiler has encountered an array-bounds specifier that is not an integral type. Array-bounds specifiers must be positive integer constants. User Action Correct the array-bounds specifier 3 BUGCHECK Message Compiler bugcheck. Submit a problem report with a problem description. Description An unexpected condition occurred in the compiler. This is most likely caused by a compiler bug. User Action Reduce the program that is causing the failure as much as possible. This often leads to a small test case. Please submit a problem report containing enough information for Engineering to reproduce the problem. The problem report should include the small test case. 3 CALLNEEDSFUNC Message "" is not a function. Description In what appears to be a function call, the expression denoting the the function to call is neither the identifier for a function nor an expression of type pointer to function. User Action Correct the expression denoting the function. If the expression is a simple identifier, perhaps a function-like macro definition is missing. 3 CANNOTREDEF Message Cannot #define a macro that is currently expanding. Description The program is trying to #define the same macro it is currently expanding. The #define will be ignored. User Action Remove the #define, or move it after the expansion of the macro. 3 CANNOTUNDEF Message Cannot #undef a macro that is currently expanding. Description The program is trying to #undef the same macro it is currently expanding. The #undef will be ignored. User Action Remove the #undef, or move it after the expansion of the macro. 3 CANTDISABLE Message The message id cannot be disabled. Description The compiler's error and fatal messages cannot be disabled. User Action Remove this message id from the list of messages being disabled on the command line or in the #pragma message line. 3 CANTMKRPSTORY Message Attempt to create repository "" for shortend names failed; OpenVMS status: . Description A compilation that used the /NAMES=SHORTENED qualifier could not open the repository used to store the shortened names. This could be because an invalid name was specified in the /REPOSITORY qualifier. The message will give additional information about the failure. User Action Correct whatever caused the failure. 3 CDDATTR Message One or more field descriptions in this CDD record specify an attribute that is being ignored. Description The CDD description specifies an attribute that is not supported in HP C. The attribute is ignored. User Action No action is required. 3 CDDBADID Message An invalid identifier, , is being ignored in the dictionary directive. Description An unexpected identifier follows the dictionary pathname in a dictionary preprocessing directive. The identifier is ignored. User Action Remove the invalid identifier(s) in the dictionary directive. 3 CDDEXT Message #dictionary is a language extension. Description The #dictionary directive is an extension of HP C on OpenVMS. The program might not compile with other compilers or on other platforms. User Action Be aware of this if you wish to port the program. 3 CDDPATH Message A valid CDD pathname was not found. The CDD directive has been ignored. Description The #dictionary preprocessing directive was not followed by an argument. The directive must be followed by a character string that gives the path name of a CDD record, or a macro that expands to the path name of the record. User Action Supply a valid argument to #dictionary. HP also recommends that the #dictionary preprocessing directive be replaced by the #pragma dictionary operator. 3 CDDTOODEEP Message The attributes for the Common Data Dictionary record description exceed the implementation's limit for record complexity. Description The CDD description specifies more attributes than the interface between the CDD and the compiler can handle. User Action Simplify the record description. 3 CHARCONST Message Ill-formed character constant. Description An invalid character constant was encountered. User Action Correct the character constant. 3 CHAROVERFL Message A character constant value requires more than sizeof(int) bytes of storage. Description A character constant is too long to fit in an int. The compiler will ignore the extra characters. User Action Remove the extra characters from the character constant. 3 CHKEXPAND Message integrity check error(s) after IL expansion of routine Description This message is emitted by the code generator. It should never be output when compiling a C program. User Action Please submit a problem report if you encounter this message when compiling a C program. 3 CHKINIT Message integrity check error(s) in initial IL & ST for module Description This message is emitted by the code generator. It should never be output when compiling a C program. User Action Please submit a problem report if you encounter this message when compiling a C program. 3 CHKOPT Message integrity check error(s) after optimization phase for routine Description This message is emitted by the code generator. It should never be output when compiling a C program. User Action Please submit a problem report if you encounter this message when compiling a C program. 3 CLASSNOINIT Message the struct or union object "" is uninitialized and has a const member. Description An object of struct or union type has a const member and has not been initialized. This might not have been what you intended. HP recommends that you initialize all objects with the const attribute. The missing initializer will make this an invalid declaration in C++. User Action Initialize the struct or union object. 3 CLOSBRACKET Message Missing "]". Description The compiler was expecting a closing bracket, but one was not found. User Action Correct the program syntax. 3 CLOSEBRACE Message Missing "}". Description The compiler was expecting a closing brace, but one was not found. User Action Correct the program syntax. 3 CLOSECOMMENT Message This unmatched comment delimiter is ignored. Description An unmatched comment delimiter (*/) is an illegal combination of unary indirection and binary division operators that would have caused your compilation to fail. User Action Remove the comment delimiter. 3 CLOSEPAREN Message Missing ")". Description The compiler was expecting a closing parenthesis, but one was not found. User Action Correct the program syntax. 3 CMPPTRFUNVOID Message accepting the [in]equality comparison of a pointer to void and a pointer to function type is a language extension. Description Under the C standard, it is a constraint violation to perform an [in]equality comparison between a pointer to void and a pointer to function type. Therefore this code may not be accepted by other compilers. User Action Cast one of the pointers to the type of the other. 3 COLMAJOR Message The CDD description for specifies that it is a column-major array; It has been converted to a one-dimensional array. Description The HP C compiler supports only row-major arrays. Therefore the column-major array description in the CDD has been converted to a one-dimensional array of the same total size and with the same total number of elements. User Action Verify that all subscript references to the array reference the correct array element. 3 COMMANDMACRO Message Extraneous text "" at the end of the command line macro "" is ignored. Description A command line macro define contains an invalid macro name. The compiler will define the macro name listed in the message. User Action Correct the command line invocation. 3 COMPILERBUG Message Bug found in compiler: . Description This message indicates that the compiler detected a bug within itself. User Action Please report the compiler bug and include an example program that reproduces the problem. 3 COMPLEXEXT Message The complex data type is a new feature in the C99 standard. Other C compilers may not support this extension. Description This is a new language feature in the C99 revision of the standard. While having a standard specification for portability, the feature may not yet be available in all of the compilers you use. User Action Determine whether or not the use of this feature will cause portability problems for this code. 3 COMPLEXNA Message The complex data types are not supported in this language mode. This will be treated as an identifier in this compilation. Description Support for the complex data types is only available in certain language modes. Support is not present when the compiler is in VAX C, K & R (common), or strict ANSI89 standard modes. In these language modes _Complex and _Complex_I will be treated as identifiers. User Action Compile using one of the other compilation modes. 3 COMPLEXNA1 Message The complex data types are not supported on this platform. This will be treated as an identifier in this compilation. Description The complex data type is not supported on the VAX platform. User Action Remove use of the complex types or compile the application on a platform that does support the complex data types. 3 CONFLICTHINTS Message this hint value contridicts a related hint at . The hints will be ignored. Description This program has supplied hints for either both branches of an if/else or both the second and third operand of a conditional operator. In these cases the two hint values must add to one. User Action Correct the hints. 3 CONLINKREG Message Conflicting register usage between "" and "". Pragma is ignored. Description The same register was specified in two different register lists of a #pragma linkage directive. The compiler will ignore the entire pragma. User Action Correct the directive. 3 CONPSECTATTR Message Conflicting psect attribute overrides previous attribute. Description A psect attribute specified in a #pragma extern_model directive contradicts an attribute specified earlier in the directive. This attribute will override the one specified earlier. User Action Remove one of the contradictory psect attributes. 3 CONSTCOMPLIT Message accepting a compound literal as a constant is a language extension. The compound literal will be treated as a cast expression. Description A compound literal appears in a context where a constant expression is required. The C standard does not list compound literals as a form of operand that is allowed in a constant expression, so using a compound literal in this context is not maximally portable. The compiler will treat the compound literal as if it were a cast expression, which is a form of operand that the standard lists as being allowed in constant expressions. User Action For maximum portability, replace the compound literal with a cast expression. 3 CONSTFOLDNS Message the libraries on this platform do not yet support compile-time evaluation of the constant expression "". Description Compile-time evaluation of constant expressions requires underlying support in the libraries available to the compiler at compile-time, and this expression contains an operator that is not yet implemented in those libraries. User Action If possible, replace part of the constant expression with a variable of the same value. 3 CONSTFUNC Message Ignoring const type qualifier in declaration of . Description The const type qualifier cannot be used with a function type. The compiler will ignore the type qualifier. User Action Remove the type qualifier. 3 CONSTINWRT Message Const variable resides in wrt extern model. Description The current extern model places all external objects in a modifiable section. Placing an object with a const type qualifier in such a section means that there is no run-time protection against writing to the object. This might not have been what you intended. User Action Place const objects in sections that cannot be modified. 3 CONSTNOINIT Message the const object "" is uninitialized. Description A defined or tentatively-defined const object has not been initialized. This would not be valid in C++. It is also considered good programming practice to initialize all const objects with their value. User Action Either remove the const type modifier, or supply an initializer for the object. 3 CONSTSTOCLS Message the const object "" has no explicit storage class. In C, its storage class defaults to "extern"; in C++, it defaults to "static". Add an explicit "extern" or "static" keyword. Description One of the more signifcant and confusing differences between C and C++ is their treatment of file scope const objects declared without a storage class. C will give the object extern storage class, making the object visible in other compilation units. C++ will give the object static storage class. This can cause an undefined symbol error when other compilation units try to reference the symbol. User Action Add an explicit "extern" or "static" keyword to the declaration. 3 CONTFILE Message A file ends with a continuation character. Description All source files, even those included via the #include preprocessing directive, must not end with a backslash continuation character. User Action Either remove the continuation character or add an additional line to the source program that does not end in a continuation character. 3 CONTROLASSIGN Message the assignment expression "" is used as the controlling expression of an if, while or for statement. Description A common user mistake is to accidentally use assignment operator "=" instead of the equality operator "==" in an expression that controls a transfer. For example saying if (a = b) instead of if (a == b). While using the assignment operator is valid, it is often not what was intended. When this message is enabled, the compiler will detect these cases at compile-time. This can often avoid long debugging sessions needed to find the bug in the user's program. User Action Make sure that the assignment operator is what is expected. 3 CONVARASLIT Message the use of the const variable "" in place of a literal constant is a language extension. Description HP C will allow a non-volatile const variable that has been initialized to be used in contexts where a constant is required. For example, as the bounds specifier to a file scope array. This is an extension to standard C. Other C compilers might not successfully compile a program that uses this extension. User Action Use the constant value instead of the variable. 3 CRXCOND Message Common Data Dictionary description extraction condition. Description Something went wrong while trying to get the CDD record description from the CDD. The error message that follows gives more information about the nature of the problem. User Action If necessary, correct the indicated condition in the CDD record description or with the user environment. 3 CVIDXOVFL Message module uses more than 65536 CodeView type indices Description This message is emitted by the code generator. It should never be output when compiling a C program. User Action Please submit a problem report if you encounter this message when compiling a C program. 3 CVTDIFTYPES Message "" of type "", is being converted to "". Description In certain modes, the compiler will allow assignments or comparisons between pointer and integer types. This is an extension to standard C. Other C compilers might not successfully compile a program that uses this extension. User Action Use a cast operator to convert one operand to the other. 3 CVTU32TO64 Message an unsigned 32-bit integer constant that has its high-order bit set has been converted to a signed 64-bit type. The conversion will not sign-extend. Description This message indicates a conversion that may produce unexpected results on this platform because the destination type is a 64-bit type instead of a 32-bit type. User Action If this is the intended behavior, first cast the constant to an unsigned 64-bit type. 3 CXXCOMMENT Message C++ style comments (//) may not be portable. Description C++ style comments have been detected on this line. Although they have been accepted by HP C in this language mode, they will not be accepted by all compilers or by HP C in strict C89 standard mode. User Action Replace C++ style line comments (//) with equivalent C comments (/* ... */) if portability is a concern. 3 CXXKEYWORD Message "" is a keyword in C++. Using it as an identifier in your C program will prevent porting your program to C++. Description This identifier is a keyword in C++. The program is, therefore, not a valid C++ program. User Action Choose a different name for the identifier. 3 CXXPRAGMANA Message The HP C++ pragma "" is not supported by HP C. The pragma will be ignored. Description The compiler has encountered a pragma that is supported by HP C++ but is not supported by HP C. The compiler will ignore the pragma. User Action Remove the pragma or compile the program with HP C++. 3 DCLMISMATLNK Message The declaration of "" has parameter(s) but its linkage "" has . Standard linkage will be used. Description The number of parameters specified in a declaration does not match the number of parameters specified by the special linkage associated with this function or typedef. The special linkage was specified via the #pragma use_linkage directive. Because of this mismatch, the compiler will ignore the special linkage and use the standard linkage instead. User Action Make sure the number of parameters specified by the special linkage match the number of parameters in the function. 3 DCLMISMATLNK0 Message The declaration of "" has an unknown number of parameters and cannot be used with the linkage "". Standard linkage will be used. Description If a special linkage specifies parameter information, the declaration must not specify an unknown or variable number of parameters. The special linkage was specified via the #pragma use_linkage directive. Because of this mismatch, the compiler will ignore the special linkage and use the standard linkage instead. User Action Make sure the number of parameters specified by the special linkage match the number of parameters in the function type. 3 DCLMISMATLNK1 Message "" has a floating type but its linkage "" specifies an integer register. Standard linkage will be used. Description A parameter or return value of a function type is a floating type, but the corresponding parameter or return value in the special linkage specifies an integer register. The special linkage was specified via the #pragma use_linkage directive. Because of this mismatch, the compiler will ignore the special linkage and use the standard linkage instead. User Action Make sure the register specified by the special linkage matches the type of of the corresponding parameter and return value of the function type. 3 DCLMISMATLNK2 Message "" requires an integer register but its linkage "" specifies a floating register. Standard linkage will be used. Description A parameter or return value of a function type is an integer type, but the corresponding parameter or return value in the special linkage specifies a floating register. The special linkage was specified via the #pragma use_linkage directive. Because of this mismatch, the compiler will ignore the special linkage and use the standard linkage instead. User Action Make sure the register specified by the special linkage matches the type of of the corresponding parameter and return value of the function type. 3 DCLMISMATLNK3 Message "" has a size that is incompatible with the number of registers specified by its linkage "". Standard linkage will be used. Description The size of a parameter or return value of a function type is incompatible with the size specified by the special linkage. The special linkage was specified via the #pragma use_linkage directive. Because of this mismatch, the compiler will ignore the special linkage and use the standard linkage instead. User Action Make sure the number of registers specified by the special linkage match the type of the corresponding parameter and return value. 3 DCLMISMATLNK4 Message "" has a type that is not allowed because the it has the linkage "". Standard linkage will be used. Description Using a special linkage places certain restrictions on the type of a function's parameters and return value. In general, the type must be a scalar type that can be represented by a register or registers on this platform. In cases where some other type is used, the compiler will ignore the special linkage and use the standard linkage instead. User Action Either remove the name from the #pragma use_linkage directive that specified the special linkage, or modify the type to be acceptable to the special linkage. 3 DCLMISMATLNK5 Message "" has a void return type but its linkage "" specifies a return location. Standard linkage will be used. Description If a special linkage specifies return value information, the declaration must not specify a void return type. The special linkage was specified via the #pragma use_linkage directive. Because of this mismatch, the compiler will ignore the special linkage and use the standard linkage instead. User Action Make sure the return value specified by the special linkage matches the return type. 3 DCLMISMATLNK6 Message "" has float _Complex or double _Complex type. The corresponding floating point registers in linkage "" must be consecutive. Standard linkage will be used. Description Using a special linkage places certain restrictions on the type of a function's parameters and return value. Whenever float _Complex or double _Complex types are used, they linkage must specify two consecutive floating point registers. The compiler will ignore the special linkage and use the standard linkage instead. User Action Either remove the name from the #pragma use_linkage directive that specified the special linkage, or modify the linkage to use consecutive floating point registers. 3 DECCONSTLARGE Message Decimal constant value too large. Description A decimal constant used in a preprocessor directive is too large. The value of the constant will be undefined. User Action Decrease the value of the constant. 3 DECLAFTERSTMT Message Placing a declaration after a statement is a new feature in the C99 standard. Other C compilers may not support this feature. Description This is a new language feature in the C99 revision of the standard. While having a standard specification for portability, the feature may not yet be available in all of the compilers you use. User Action Determine whether or not the use of this feature will cause portability problems for this code. 3 DECLARATOR Message Invalid declarator. Description A declaration did not contain an identifier that specifies the item to be declared. User Action Specify a declarator in the declaration. 3 DECLINFOR Message Placing a declaration in a for loop is a new feature in the C99 standard. Other C compilers may not support this extension. Description This is a new language feature in the C99 revision of the standard. While having a standard specification for portability, the feature may not yet be available in all of the compilers you use. User Action Determine whether or not the use of this feature will cause portability problems for this code. 3 DECLSPECEXT Message __declspec is a language extension. Description The __declspec storage class modifier is a language extension of HP C. Other C compilers might not successfully compile a program that uses the extension. User Action Be aware of this extension if you wish to port the code. 3 DEFINOTHER Message Another file in this compilation contains an external definition of a function named "", or declares it as a variable with external linkage, at . Description In a compilation where interfile optimization has been selected (-ifo on UNIX, /PLUS_LIST_OPTIMIZE on OpenVMS), the compiler has detected more than one definition of a function using the same external name, or has found that a function and a variable have the same external name. An external function can have only a single definition. And a given identifier with external linkage can refer either to a function or to a variable, but not both. User Action Remove or rename one of the names. 3 DEFINOTHER1 Message The external variable "" was defined as an external function in another module of this compilation at . Description In a compilation where interfile optimization has been selected (-ifo on UNIX, /PLUS_LIST_OPTIMIZE on OpenVMS), the compiler has detected a name with external linkage defined as a variable in one compilation unit and a function in another. User Action Remove or rename one of the definitions. 3 DEFINOTHER2 Message This declaration of "" specifies a different type than the declaration in another module of this compilation at . Description In a compilation where interfile optimization has been selected (-ifo on UNIX, /PLUS_LIST_OPTIMIZE on OpenVMS), the compiler has detected a name with external linkage declared with different types in two different modules. Although the runtime behavior may be as intended and match the behavior when the modules are separately compiled without interfile optimization, the behavior is not well defined unless the types are compatible. User Action Modify one or more of the declarations to make the types compatible. 3 DEFINOTHER3 Message This declaration of "" specifies a different thread-local attribute than a declaration in another module of this compilation at . Description In a compilation where interfile optimization has been selected (-ifo on UNIX, /PLUS_LIST_OPTIMIZE on OpenVMS), the compiler has detected a name with external linkage declared thread-local in one module and not thread-local in another. This can lead to unexpected results at runtime. User Action Modify one the declarations to make the thread-local attributes match. 3 DEFPARMTYPE Message There is no declaration for the old-style function parameter "". Type defaulted to int. This is a violation of the C99 standard. Description The parameter of an old-style function definition was not declared. It will default to int type. Omitting the type specifier is not valid in C99, and is often considered poor programming practice. User Action Declare the parameter. HP also recommends that old-style function definitions be replaced by prototype-format definitions. 3 DEFRETURNTYPE Message The type of the function defaults to "int". Description A function definition did not include a type specifier for the function's return value. It will default to int. This might not be what you intend. This is also a violation of the C99 Standard. User Action It is a good programming practice to give all function definitions explicit return types. 3 DESIGBADARR Message , a struct/union designator cannot be used with an object of array type. Description An initialization designator must match the type of the object being initialized. In this initialization, the current object is an array so a struct/union designator is not allowed. User Action Correct the initialization. 3 DESIGBADCOMP Message , an array designator cannot be used with an object of struct or union type. Description An initialization designator must match the type of the object being initialized. In this initialization, the current object is a struct or union, so an array designator is not allowed. User Action Correct the initialization. 3 DESIGBADIND Message , the constant expression "" in an array element designator is not a positive integer. Description An array-element designator must be an constant expression that yields a positive integer value. User Action Correct the element designator. 3 DESIGBADIND1 Message , the array element designator "[]" specifies an element beyond the end of the array. Description An array element designator must specify a valid array element. User Action Correct the element designator. 3 DESIGNATIONNA Message The use of a designation in an initializer list is not supported in this compilation mode. Description Initializer lists that contain designations are a new feature in the C99 revision of the C standard. HP C will only support this extension in relaxed mode and strict c99 mode. User Action Use a compilation mode that supports the use of designations. 3 DESIGNATORUSE Message The use of a designation in an initializer list is a new feature in the C99 standard. Description Initializer lists that contain designations are a new feature in the C99 revision of the C standard. Other compilers may not support this feature. User Action Be aware of this portablility issue. 3 DESIGNOMEMB Message , the component designator "" is not a member of the current structure or union object being initialized. Description An initialization designator specifies a struct or union member that is not a member of the current struct or union object. User Action Correct the initialization. 3 DESIGSCALAR Message , a designator cannot be used with an object of scalar type. Description An initialization designator can only be used on objects of array, structure, or union type. In this initialization, the current object being initialized is a scalar type so a designator is not allowed. User Action Correct the initialization. 3 DIFFEXMODEL Message This redeclaration of "" specifies a different extern model than a previous declaration of the variable at . Description Two declarations of the same variable use different extern models. The extern model is specified by a #pragma extern_model directive that appears before the declaration in the source. This redeclaration may cause unexpected behavior. User Action All declarations of a variable should use the same extern model. 3 DIFFTYPEQUALS Message the type of "" has different type qualifiers than the previous declaration at . The resulting type will be the composite of the two types. Description The C standard permits redeclaration and formation of a composite type only when the two types being considered are compatible, and types with different type qualifiers are not compatible. HP C allows this redeclaration for consistency with some other C compilers, and will form a composite type with all of the type qualifiers from both declarations. Be aware that these declarations may not be accepted by other C compilers. User Action Modify the declarations so that they use identically qualified types. 3 DIRECTVNOCPP Message "" is not recognized as a preprocessing directive in nopreprocessing mode, and is being ignored. Description An invalid preprocessing directive was encountered in a compilation performed with the -nocpp option. When using the -nocpp option, only a limited number of preprocessing directives, such as #pragma and #line, can appear in the program. The compiler will ignore the rest of the line. User Action Either remove the directive or compile without the -nocpp option. 3 DISREDECL Message the type of the external "" is not compatible with the type of a declaration of "" in another name scope at . Description The same external identifier has been declared in different scopes with incompatible types. This might not have been what you intended. User Action Change all declarations of the same external identifier to use the same type. 3 DOLLARID Message Extension: A '$' was encountered in an identifier. Description Accepting a "$" character in an identifier is an extension of HP C. The program might not compile with other C compilers. User Action Be aware of this if you wish to port the program. 3 DONOTAPPLY Message linkage, assert or hint information for built-in function is ignored. Description A built-in function is always handled specially. There is no actual function call to which linkage, assert or hint information could be applied. User Action Remove the name of the built-in function from this pragma. 3 DUPCASE Message The switch statement containing this case label already has a case label for "". Description A switch statement contains more than one case label for the same case value. User Action Remove the duplicate case label. 3 DUPDEFAULT Message The switch statement containing this default label already has a default label. Description A switch statement can contain only one default label. User Action Remove the duplicate default label. 3 DUPENUM Message the enumerator "" is not unique. Description An enumerator constant is declared more than once with the same value. While this is accepted by HP C, it is not allowed by the C standard. User Action Either use a different enumerator name or remove the previous declaration of the name. 3 DUPEXTERN Message The declaration of "" will map to the same external name as the declaration of "" at . Description The compiler has detected a case where two different names in a program will map to the same external name in the output object file. This can cause unpredictable results at runtime. This will most often happen when the /NAMES=UPPERCASE or /NAMES=LOWERCASE qualifier causes two names with different case spellings to map to the same external name. User Action Either use the /NAMES=AS_IS qualifier, or modify one of the names. 3 DUPLABEL Message The label "" is already defined in this procedure at . Description A label has already been defined. Each function can define each label only once. User Action Remove the duplicate label definition. 3 DUPLINK Message Duplicate linkage pragmas for linkage name "". Description The same linkage specifier has been defined in more than one #pragma linkage directive. User Action Declare each linkage only once. 3 DUPLPRAGASS Message #pragma assert directive specified for the function name while different #pragma assert was specified for its type. Description Duplicate assertion can't be specified for a function. Check whether #pragma assert was mistakenly specified for the same function more than once, or function's type is declared in a typedef which in turn has its own #pragma assert directive. User Action Either remove duplicate #pragma assert directive, or change assertions, or fix spelling of the function name or typedef. 3 DUPPARM Message "" is a duplicate parameter name. Description The parameter identifier list of an old-style function definition uses the same identifier more than once. User Action Each identifier in the parameter list must be unique. HP also recommends that old-style function definitions be replaced by prototype-format definitions. 3 DUPSTATIC Message There is a redundant use of the keyword "static" in this array declaration. Description In C99 the keyword "static" may appear at most once in the outermost array-bounds specifier of a function parameter in a function prototype. User Action Remove redundant occurrences(s) of "static" from the array declaration 3 DUPSTORCLS Message the same storage class modifier occurs more than once. Description This declaration specifies the same storage class modifier more than once. User Action Remove the extra uses of the storage class modifier. 3 DUPTYPEDEF Message "" has a duplicate typedef at . This might not be portable. Description The same typedef has been declared to the same type more than once. Standard C does not allow this and other compilers might not accept it. User Action Remove the redundant declaration. 3 DUPTYPESPEC Message the same type specifier occurs more than once. Description The same type specifier appears more than once in the same declaration. The redundant specifier will be ignored. User Action Remove the duplicate type specifier. 3 DUPTYPQUAL Message there is a redundant use of type qualifier "". Description The same type qualifier appears more than once in a type specifier. This violates the C89 standard. Other compilers may not accept this program. Note that C99 will allow redundant qualifiers. User Action Remove the redundant type qualifier. 3 ELIFIGNORED Message Out of place #elif directive ignored. Description An #elif preprocessing directive was encountered outside of an #if/#endif body. The directive will be ignored. User Action Remove the directive. 3 ELLIPSEARG Message Standard C does not permit the use of an ellipsis as an only argument. Description Standard C requires at least one formal parameter be declared before the ellipses. This declaration might not be portable to other C compilers. User Action Recode the function declaration to contain at least one formal parameter. 3 ELLIPSEPARM Message a parameter with type "" matches an ellipsis in previous declaration at . Description A function that has been previously declared as taking variable arguments is now redeclared as using a different number of formal parameters before the start of the variable argument list. This redeclaration might not be portable to other C compilers. User Action Recode the function declarations to match each other. 3 ELLIPSISEND Message No tokens may follow ... in a formal parameter list. Description The ellipsis may only appear at the end of a formal parameter list. Everything after that is being ignored. User Action Remove the unexpected token. 3 ELSEIGNORED Message Out of place #else directive ignored. Description An #else preprocessing directive was encountered outside of an #if/#endif body. The directive will be ignored. User Action Remove the directive. 3 EMBEDCOMMENT Message A comment is neither preceded nor followed by white space. Description A comment is neither preceded nor followed by white space. In certain modes the compiler will paste the tokens before and after the comment together to form a single token. This behavior is not valid in standard C. Writing programs that rely on this behavior might prevent the program from being compiled on other platforms. User Action Add white space before or after the comment, or use the ## operator to paste tokens together. 3 EMPTYCHARCONST Message Empty character constant. Description In some modes the HP C compiler will allow a null character constant. The compiler will give this constant a value of zero. Accepting an empty character constant is a language extension. Empty character constants are not valid in standard C. Writing programs that rely on this behavior might prevent the program from being compiled on other platforms. User Action Replace the empty character constant with '\0'. 3 EMPTYFILE Message Source file does not contain any declarations. Description This source file contains no declarations. This might not have been what you intended. For example, perhaps a necessary macro was not defined. User Action Every source program should contain at least one declaration. 3 EMPTYINIT Message An initializer list without an expression is not valid. The compiler will replace the empty expression with the constant 0. Description The C standard requires that an initializer list contain an expression. The compiler has encountered one without an expression. The compiler will treat the empty list ({}) as if it contained a single zero ({0}). This is for compatibility with some other C compilers. Be aware that this syntax may not be accepted by other C compilers. User Action Supply an expression to the initializer. 3 EMPTYOBJ Message Empty object file due to errors. Description An earlier condition will cause an empty object module to be created. User Action Correct the condition that was reported earlier. 3 EMPTYSTRUCT Message Allowing struct/union type with no members is a language extension. Description The C standard requires that a struct/union type have at least one member. The HP C compiler will accept this for compatibility with older compilers. The struct/union type will be treated as if it were declared { : 0; } User Action Provide at least one member for the struct/union. 3 ENUM16BIT Message the enumeration constant is out of the range -32768 to 32767. This might not be portable. Description An enum constant is larger than can be represented in 16 bits. This would not be portable to a system with an int size of 16 bits. User Action Be aware of this if you wish to port to a system with an int size of 16 bits. 3 ENUMCALC Message the enum variable "" is used in an arithmetic operation. Description An enumerated type variable was used in an arithmetic operation. While this is valid in C, it might not have been what you intended. User Action Verify the use of the enum variable. 3 ENUMINIT Message the enumerator "" is initialized to the nonintegral value "". Description An enum declaration contains an enumeration constant initializer that does not have an integer type. The initializer for an enumeration constant must be an integral constant expression. User Action Correct the initializer. 3 ENUMRANGE Message the enumeration constant "" is out of range INT_MIN to INT_MAX and will be truncated. Description An enumeration constant must be representable as an int type. The specified value is outside the range of an int. In modes where this is a warning, the compiler will use the low-order bits to form the int value. User Action Use a valid constant value. 3 ENUMSANDINT Message allowing an enumeration type and a signed int to be compatible may not be portable. Description The standard states that enumeration types shall be compatible with an integer type. HP C, along with most other C compilers, has chosen the signed int type to be compatible with enumeration types. Other compilers may chose another type such as unsigned int (the C standard even allows an implementation to choose different integer types depending on the values of the enumeration constants defined for the type). Therefore this program may not be accepted by other C compilers. User Action Insert a cast to make the types the same. 3 ENUMSNOTCOMPAT Message allowing two different enumeration types to be compatible is a language extension. Description The HP C compiler allows two objects of different enumeration types to be compatible. The C standard specifies that enumeration types are distinct types. Therefore this program is not standard compliant and other C compilers may not accept it. User Action Use the same enumeration type or cast one type to the other. 3 ENUMUSED Message the enumerator name "" has been used previously. Description The specified enumerator name has been previously declared as something other than an enumerator. User Action Either use a different enumerator name or remove the previous declaration of the name. 3 ENVIRSTKDIRTY Message At the end of the compilation the pragma stack was not empty. This may indicate a coding error. Description The program being compiled has saved the named pragma state more often than it has restored it. Good coding practice calls for the pragma state to be restored some point after it has been saved. This condition may indicate the accidental failure to restore the state. User Action Make sure each pragma save has a corresponding pragma restore. 3 ERRORLIM Message diagnostic message limit exceeded Description This message is emitted by the code generator. It should never be output when compiling a C program. User Action Please submit a problem report if you encounter this message when compiling a C program. 3 ERRORMESSAGE Message #error Description An #error directive was encountered. This message will include the text that follows the directive in the source program. User Action Remove the #error directive, or supply the proper macro definitions so that the compiler will skip the directive. 3 ESCOVERFL Message Invalid escape sequence encountered. Description An escape sequence in a character or string literal specifies a value outside the range of a character or wide character. User Action Specify a valid escape sequence. 3 EXPANDEDDEFINED Message Macro expansion includes the token "defined", which will be treated as an operator. This might not be portable. Description A macro expanded during the processing of a preprocessor #if directive included the token "defined". The HP C compiler will treat this as the defined preprocessing operator. Other compilers might treat this differently. User Action Rewrite the macro not to use the "defined" operator. 3 EXPNOTRES Message expression does not contribute to result Description The compiler has detected a source expression that does not contribute to the result. This may not be what you expected. User Action Verify the expression is what you intend. 3 EXPRCVTINT Message The expression "" has been converted to integer. Description In certain modes, HP C will allow switch expressions or case constants to be non-integer types. The expression or constant will be converted to int. In one of these cases, this warning will be issued. User Action Cast the switch expression to an integer type or use an integer case constant. 3 EXPRNOTINT Message The expression "" has type, which is not integral. Description An expression that is required to have an integer type had a type that is not integral. This is not valid. An example of a situation where an integer is required is that in most modes HP C requires that the switch control expression have integer type. User Action Modify or cast the expression so that it has integer type. 3 EXPRNOTUSED Message the expression "" is never used. Description The compiler has detected an expression that is not used, and might not have a side-effect. This might not have been what you intended. User Action If the expression has a desired side-effect, the message can be ignored. Otherwise, you might want to consider removing the expression. 3 EXTENDTYPE Message This platform specific type is a language extension. Description The use of the types __int8, __int16, __int32, __int64, or other type specifiers beginning with leading double underscores might not be portable to other platforms or to other C compilers. User Action Be aware of this portability concern. 3 EXTERNINIT Message HP C allows the initialization of a variable with extern storage class. This differs from the VAX C behavior. Description VAX C does not allow a variable with extern storage class to be initialized. HP C will allow this, even in vaxc mode. User Action Be aware of this difference if you plan to compile the source with VAX C. 3 EXTERNPOP Message This "restore" has underflowed the extern model's stack. No corresponding "save" was found. Description The extern_model stack, managed by the #pragma extern_model and #pragma environment directives, contains more restores than saves. This could signify a coding or logic error in the program. User Action Make sure each restore has a corresponding save. 3 EXTPREAFTER Message This directive will not set the extern_prefix of "" because there is a previous declaration of the identifer with external linkage at . Description When an identifier is specified in a #pragma extern_prefix, the declaration of that identifier must appear after the #pragma. User Action Reorder the declaration and the #pragma so that the #pragma comes first. 3 EXTPREAGAIN Message This directive overrides the extern_prefix for "" specified by an earlier #pragma extern_prefix at . Description Two #pragma extern_prefix directives have specified different non-empty extern_prefixes for the same identifier. In such cases the later directive will set the extern_prefix for the identifier. User Action If it is necessary to respecify the extern_prefix for an identifier, first remove the prefix (by setting it to an empty string) and then specify the new prefix in a subsequent #pragma. 3 EXTPRENODECL Message There is no identifier named "" with external linkage declared in this compilation unit. Description A #pragma extern_prefix directive specifies an extern prefix for an identifier that is not declared with external linkage in the compilation unit. This may not have been what you intented. User Action Remove the identifier from the #pragma extern_prefix, or declare it with external linkage, or set the prefix for this identifier to an empty string. 3 EXTRABRACES Message , the value is enclosed within too many pairs of braces. Description An initializer contains too many open braces for the object being initialized. User Action Reduce the number of braces. 3 EXTRAMODULE Message Redundant "#pragma module" or "#module" directive ignored. Description A compilation unit can contain only one #pragma module or #module directive. All subsequent directives will be ignored. User Action Remove the extra directives. 3 EXTRAPRAGARGS Message Extra pragma arguments to #pragma were found. Pragma is ignored. Description Unexpected arguments were found at the end of a #pragma directive. The directive will be ignored. User Action Remove the extra arguments. 3 EXTRASEMI Message Extraneous semicolon. Description An extra semicolon was found at the end of a declaration. It will be ignored. User Action Remove the extra semicolon. 3 FALLOFFEND Message The last statement in non-void function "" is not a return statement. Description A function that returns a value does not end with a return statement. If function execution reaches the end of the function, the implied return statement that executes will return an undefined value. This might not have been what you intended. User Action End the function with a return statement that specifies a return value. 3 FBFILENOTFOUND Message Feedback file not found: Description The specified feedback file could not be found by the compiler. User Action Specify the correct file name. 3 FILECLOSE Message An error occurred while attempting to close a source file: . Description An unexpected error occurred while closing a source file. The message text will contain additional information about the failure. User Action Correct the condition that caused the failure. 3 FILENOTFOUND Message File not found: Description The specified file could not be found by the compiler. User Action Specify the correct file name. 3 FILEREAD Message An error occurred while attempting to read a source file: . Description An unexpected error occurred while reading a source file. The message text will contain additional information about the failure. User Action Correct the condition that caused the failure. 3 FILESCOPEVLA Message the file-scope identifier "" cannot be declared with a variably modified type. Description Only ordinary identifiers with block scope and without storage class extern, or ordinary identifiers with function prototype scope can be declared with a variably modified type. User Action Correct the declaration. 3 FINBRANCH Message A goto to the label "