United States-English

» Contact HP

HP OpenVMS Systems

C Programming Language

Compaq C

Compaq C
User's Guide for OpenVMS Systems

Contents

Index

C.4 CDD/Repository

CDD/Repository is an optional OpenVMS software product available under a separate license. The CDD/Repository product allows you to maintain shareable data definitions (language-independent structure declarations) that are defined by a data or repository administrator.

Note

CDD/Repository supports both the Common Data Dictionary (Version 3) and CDD/Plus (Version 4) interfaces. Older dictionary versions need to be converted to repository (CDD/Repository) format using a supplied conversion utility. For detailed information about CDD/Repository, see the CDD/Repository documentation.

C.4.1 Using CDD/Repository

CDD/Repository data definitions are organized hierarchically in the same way files are organized in directories and subdirectories. For example, a repository for defining personnel data might have separate directories for each employee type.

Descriptions of data definitions are entered into the dictionary in a special-purpose language called CDO (Common Dictionary Operator, which replaces the older interface called CDDL, Common Data Dictionary Language). CDD/Repository converts the data descriptions to an internal form---making them independent of the language used to access them---and inserts them into the repository.

To extract data definitions from CDD/Repository, include the #pragma dictionary preprocessor directive in your Compaq C source program. If the data attributes of the data definitions are consistent with Compaq C requirements, the data definitions are included in the Compaq C program during compilation. See Section 5.4.3 for information about using #pragma dictionary .

CDD/Repository data definitions, in the form of Compaq C source code, appear in source program listings if you specify the /SHOW=DICTIONARY qualifier on the CC command line.

The advantage in using CDD/Repository instead of Compaq C source for structure declarations is that CDD/Repository record declarations are language-independent and can be used with several supported OpenVMS languages.

C.4.2 Accessing CDD/Repository from Compaq C Programs

A repository or data administrator uses CDO to create repositories, define directory structures, and insert record and field definitions into the repository. Many repositories can be linked together to form one logical repository. If the paths are set up correctly, users can access definitions as if they were in a single repository regardless of physical location.

CDO also creates the record paths. Once established, records can be extracted from the repository by means of the #pragma dictionary preprocessor directive in Compaq C programs. At compile time, the record definition and its attributes are extracted from the designated repository. Then the compiler converts the extracted record definition into a Compaq C structure declaration and includes it in the object module.

The #pragma dictionary preprocessor directive incorporates CDD/Repository data definitions into the Compaq C source file during compilation. The #pragma dictionary directive can be embedded in a Compaq C structure declaration. See Section 5.4.3 for sample usage of #pragma dictionary .

C.4.3 Support for CDD/Repository Data Types

CDD/Repository supports all OpenVMS data types. Compaq C can translate all the OpenVMS data types when they are declared in CDD/Repository records. Data types that do not occur naturally in the Compaq C language are handled in the following way:

Compaq C never attempts to approximate a data type that is not supported by the C language.
Instead of approximating a data type, Compaq C uses its own structure data type to represent all types (except for excessively long bit strings) not supported by the C language; specifically, Compaq C creates structures of arrays of type char that are large enough to represent the data structure.
Bit strings (aligned or unaligned) can be up to 32 bits long, as defined by the Compaq C language. Bit strings longer than 32 bits are broken into increments of 32-bit strings or smaller so that the structure is correct with respect to size. However, the long bit string cannot be accessed as one unit.
All row-major arrays are represented as zero-origin arrays of the appropriate size. An informational message is issued if the record description specifies nonzero-origin dimension bounds. The compiler adjusts the upper bound appropriately to maintain the correct number of elements relative to a lower bound of zero. Column-major arrays are converted to one-dimensional arrays containing the same total number of elements.

The compiler applies various consistency checks to the record attributes extracted from CDD/Repository, particularly the field data-type attributes. An error message is issued when a record description does not pass the consistency checks. An informational message is issued when Compaq C is confronted with facility-independent attributes that are not supported. An error message is issued when an attribute that is required by Compaq C is not present, even if the attribute is optional in CDD/Repository record protocol.

The compiler synthesizes names for unnamed and filler fields. If CDD/Repository does not specify a name and a name is required by the syntax of the Compaq C language, the compiler synthesizes the name cc_cdd$_unnamed_nnnnn. When CDD/Repository specifies a filler or a name that Compaq C does not support, the compiler synthesizes the name cc_cdd$_filler_#nnnnn, which includes the pound sign character (#). The string nnnnn represents a unique integer. The # is not a valid character in an identifier, so you cannot reference these fields.

Unsupported data types are mapped into Compaq C as structures of character arrays of the appropriate size. The declaration of these data types uses the following format:

struct { char Cname [s]; } CDDname;

The CDDname is the name of the member in the CDD/Repository record. Cname is an identifier of the form cc_cdd_$_unsupported_#nnnnn, where nnnnn is a unique integer, and s is the size of the data item, in bytes.

Compaq C generates variant_struct or variant_union declarations for unnamed CDD/Repository structures and unions, so you do not have to specify these references.

Table C-2 summarizes the mapping between CDD/Repository data types and Compaq C data types.

**Table C-2 Mapping Between CDD/Repository and *Compaq C* Data Types**
CDD/Repository Data Type	C Data Type
Unspecified Unsigned byte Unsigned word Unsigned longword Unsigned quadword Unsigned octaword	Unsupported `unsigned char` `unsigned short` `unsigned int` Unsupported Unsupported
Signed byte Signed word Signed longword Signed quadword Signed octaword	`char` `short` `int` Unsupported Unsupported
F_floating D_floating G_floating H_floating	`float` ¹ `double` ¹ `double` ¹ Unsupported
F_floating complex D_floating complex G_floating complex H_floating complex	Unsupported Unsupported Unsupported Unsupported
Text Varying text ²	`char` [ n] Unsupported
Numeric string: Unsigned Left separate Left overpunch Right separate Right overpunch Zoned sign	Unsupported Unsupported Unsupported Unsupported Unsupported Unsupported
Packed decimal string	Unsupported
Bit Bit unaligned	Bit field ³ Bit field ³
Date and time	Unsupported
Date Virtual field Varying string ²	Unsupported Ignored Unsupported

¹If the specification of the /FLOAT or /[NO]G_FLOAT qualifier conflicts with the data type of the CDD/Repository record member, an informational message is issued and the member is represented as struct { char [8]} instead of double. CDD/Repository record member is D_floating, and G_floating format (the default) was specified on the CC command line; or if the data type of the record member is G_floating, and either D_floating or IEEE_floating (ALPHA ONLY) was specified on the command line; or if the data type of the record member is F_floating, and IEEE_floating (ALPHA ONLY) was specified on the command line.
²For these data types, the length of the structure is two bytes longer than the string to allow for the length field.
³A message is issued if the bit-string length is greater than 32.

Appendix D
Compaq C Compiler Messages

This appendix lists the Compaq C compiler diagnostic messages.

For each message, this appendix gives the mnemonic and the message text, an explanation of the message, and suggested actions to be taken to avoid the message. For more information about the format of compiler diagnostic messages, see Section 1.3.5.

To display a particular compiler message online, enter the following command:

$ HELP CC/DECC MESSAGE mnemonic[Return]  (VAX ONLY)
$ HELP CC MESSAGE mnemonic[Return]  (ALPHA ONLY)

To display a list of all compiler message mnemonics, enter the following command:

$ HELP CC/DECC MESSAGE[Return]  (VAX ONLY)
$ HELP CC MESSAGE[Return]  (ALPHA ONLY)

Some messages substitute information from the program into the message text. In this appendix, the portion of the text to be substituted is shown in italics.

Often, the same message is issued in different contexts within a program. In this appendix, the message context is indicated by the italicized word context within the message. The actual message issued by the compiler will contain one of the following phrases substituted for context:

In this declaration,
In the initializer for
In the declaration of "name",
In the definition of the function "name",
In the declaration of an unnamed object,
In this statement,

You can control the messages issued with the /[NO]WARNINGS command-line qualifier ( Section 1.3.4) and the #pragma message preprocessor directive ( Section 5.4.13).

DECDEC, In this declaration,

DECINITVR, In the initializer for

DECNAMDEC, In the declaration of "name",

DECNAMFUNDEF, In the definition of the function "name",

DECUNDEC, In the declaration of an unnamed object,

PASSTA, In this statement,

ABSTRACTDCL, 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.

ADDRARRAY, context& before array "expression" is ignored.

Description: In certain modes, Compaq 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.

ADDRCONSTEXT, context"name" 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.

ADDRESSOFVOID, contexttaking the address of a void type is a language extension.

Description: The Compaq 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.

ADDRSUBCONST, contextaccepting the expression "expr" as a constant is a language extension.

Description: In many cases Compaq 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.

ALIGNCONFLICT, contextthe address "expr" has alignment of align 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.

ALIGNCONFLICT1, contextthe address "expr" has alignment of align 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.

ALIGNCONST, Integer constant alignment number 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.

ALIGNEXT, _align is a language extension.

Description: The _align storage class modifier is a language extension of Compaq 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.

ALIGNPOP, 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.

ALREADYTLS, The identifier "name" 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

ANSIALIASCAST, contexta pointer to type1 is being cast to a pointer to type2. 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.

ARGADDR, contexttaking the address of the constant expression "expression" in an argument list is a language extension.

Description: The Compaq 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.

ARGLISGTR255, contextthe 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.

ARGLISTOOLONG, contextthe 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.

ARGSIZE, context 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.

ARRAYBRACE, context 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.

ARRAYLIMITSUP, contextCompaq C provides only limited support for array types larger than n bytes.

Description: This array type is larger than can be represented by size_t. While Compaq 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.

ARRAYOVERFLOW, 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.

ARRNOTLVALUE, contextaccepting 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.

ASMCOMEXP, Comma expected while processing text instruction

Description: The asm directive parser was expecting a comma, but one was not found.
User Action: Correct the asm directive.

ASMENDEXP, Semicolon or asm end expected while processing text 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.

ASMFIMMDOTS, 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.

ASMFREGEXP, Float register expected while processing text instruction

Description: The asm directive parser was expecting a valid floating register, but one was not found.
User Action: Correct the asm directive.

ASMHINTDOTS, Hint on text 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.

ASMICONEXP, Integer constant expected while processing text instruction

Description: The asm directive parser was expecting a valid integer constant, but one was not found.
User Action: Correct the asm directive.

ASMIDEXP, Identifier expected while processing text instruction

Description: The asm directive parser was expecting an identifier, but one was not found.
User Action: Correct the asm directive.

ASMINSTEXP, Instruction mnemonic expected (found text)

Description: The asm directive parser was expecting an instruction mnemonic, but one was not found.
User Action: Correct the asm directive.

ASMLABEXP, Label expected while processing text instruction

Description: The asm directive parser was expecting a label, but one was not found.
User Action: Correct the asm directive.

ASMLABMULDEF, Multiple definitions of label in asm (text)

Description: The asm directive parser has detected the same label defined more than once.
User Action: Change one of the label names.

ASMLABUNDEF, Reference to undefined label in asm (text)

Description: The asm directive parser has detected a reference to an undefined label.
User Action: Correct the asm directive.

ASMLDGPDOTS, 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.

ASMLPAREXP, Left paren expected while processing text instruction

Description: The asm directive parser was expecting a left paren, but one was not found.
User Action: Correct the asm directive.

ASMNOTINST, text instruction is not supported in asms on text

Description: The asm directive parser does not recognizes a pseudo-opcode on this platform.
User Action: Correct the asm directive.

ASMNOTREG, text is not a register name on text

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.

ASMNOTSUP, Support for text (text) in asms is not implemented on text

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.

ASMPALTRUNC, PALcode function has been truncated to number

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.

ASMRAWREG, text uses text 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.

ASMREGEXP, Fixed register expected while processing text instruction

Description: The asm directive parser was expecting a valid integer register, but one was not found.
User Action: Correct the asm directive.

ASMREGOVRLAPSC, Destination register overlaps input for text (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.

ASMRPAREXP, Right paren expected while processing text instruction

Description: The asm directive parser was expecting a right paren, but one was not found.
User Action: Correct the asm directive.

ASMSYMDOTS, Use of symbolic addresses with text 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.

ASMUNKNOWNARCH, Unknown architecture (text) specified in text assembler directive

Description: The asm directive parser has detected an unexpected argument to a .tune or .arch directive.
User Action: Correct the asm directive.

ASMUNKSETOPT, Unsupported or illegal .set option (text)

Description: The asm directive parser has detected an unexpected argument to a .set directive.
User Action: Correct the asm directive.

ASSERTFAIL, The assertion "assertion" was not true, reason.

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.

ASSERTION, text

Description: This message is emitted by the code generator used by all Compaq compilers for the Alpha architecture. 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.

ASSIGNEXT, contextrelaxed 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.

ASSUMEONEELEM, The type of the tentatively-defined array "name" 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, Compaq C will give the array one element.
User Action: Complete the type.

AUTOALIGN, 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.

AUTOEXTERNAL, contexta 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.

BADALIAS, Reference through restricted pointer text uses a pointer value based on different restricted pointer, text

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.

BADALIGN, 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.

BADANSIALIAS, This statement uses the type "type" to reference the same storage location as the statement at loc, which uses the type "type". This does not conform to the ANSI aliasing rules.

Description: The standard allows a compiler to assume that since these two statements use different types, these two statements reference different storage locations. The Compaq C compiler does so whenever ansi aliasing is enabled. Since your code relies on these two statements referencing the same storage location you should disable ansi aliasing. If you do not do so, optimization may result in your program exhibiting unexpected behavior.
User Action: Specify noansi_alias on the command line.

BADBOUNDCHK, contextpointer arithmetic was performed more than once in computing an array element. The bounds checking code output by the compiler will only verify the "expr" expression.

Description: When an array is accessed using pointer arithmetic and run-time array bounds checking is enabled, the Compaq 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);

BADBOUNDS, contextthe 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.

BADBREAK, 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.

BADC99PRAGOP, 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).

BADCHARSINHDR, 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.

BADCMMNTPSTNG, 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.

BADCOMLITTYPE, contextthe type "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.

BADCOMPLEXTYPE, context"spelling" 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.

BADCONDIT, contexta common type could not be determined for the 2nd and 3rd operands ("true expression" and "false expression") 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.

BADCONSTEXPR, 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.

BADCONTINUE, 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.

BADCONVSPEC, contextthis argument to function name contains a bad conversion specification "incorrect conversion" 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.

BADDCL, The name "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.

BADDECLSPEC, 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.

BADDEFARG, 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.

BADENUM, 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.

BADEXPR, Invalid expression.

Description: An invalid expression was encountered.
User Action: Correct the program syntax.

BADFATCOMMENT, 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.

BADFBDAT, text 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.

BADFBFILE, Invalid feedback file: text

Description: The compiler was unable to read information from the specified feedback file.
User Action: Make sure the feedback file contains valid feedback information.

BADFBTYP, Unexpected file type for feedback file text

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.

BADFLOATTYPE, contextthis floating point type "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.

BADFORMALPARM, 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.

BADFORSTOCLS, 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.

BADFUNCSTOCLS, The storage class of function name cannot be storage_class. 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.

BADGLOBALTYPE, This declaration has type "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.

BADHEADERNM, 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.

BADHEXCONST, 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.

BADIDENTUCN, 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.

BADIFDEF, 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.

BADIFNDEFARG, #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.

BADINCLUDE, 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.

BADLINEDIR, 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.

BADLINEDIRTV, 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.

BADLINKREG, Invalid register "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.

BADLINNUM, 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.

BADLOCALE, 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.

BADMACROINLN, 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.

BADMACRONAME, "directive" 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.

BADMBCOMMENT, 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.

BADMCRORECURS, Recursive expansion of macro "name" exceeded num 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.

BADMEMBER, 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.

BADMEMOFF, contextmultiple definitions of member "name" 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: Compaq 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.

BADMEMTYP, contextmultiple definitions of member "name" 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: Compaq 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.

BADMODULEID, 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.

BADMULTIBYTE, An invalid multibyte character was encountered in type of construction.

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.

BADNUM, text Qualifier value 'text' is not an integer

BADOCTCONST, 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.

BADOPCCAP, text 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.

BADOPENBRACE, This open brace may be missing a close brace and causing the syntax error at location.

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.

BADPARSEDECL, In this declaration, "id" 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.

BADPARSEPARAM, In this parameter list, "param" 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.

BADPPDIR, File ends in an unfinished pp directive.

Description: An unexpected end-of-file was encountered during a preprocessing directive.
User Action: Correct the directive.

BADPRAGMAARG, Unexpected or missing argument to #pragma pragma name. 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.

BADPRAGMAARG1, Unexpected token encountered in pragma. Found "found" when expecting 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.

BADPRAGMALINK, 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.

BADPRAGNAMES, 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.

BADPREFIX, 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.

BADPROTYP, Unexpected file type for profile file text

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.

BADPTRARITH, contextperforming 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.

BADREGISTER, context"name" 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.

BADRETURNTYPE, contexta function cannot return type 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.

BADSEVERITY, The severity of message id name 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.

BADSTATICCVT, contextthe 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.

BADSTMT, 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.

BADSTMT1, 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.

BADSUBSCRIPT, contextan 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.

BADTKEN, Lexically invalid token.

Description: An invalid token was encountered in a preprocessing directive.
User Action: Correct the preprocessing directive.

BADUNKNOWNVLA, contexta "*" 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.

BADUNROLLVAL, The #pragma unroll directive takes a value from zero to 255. The value "val" 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.

BADUSELINK, 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.

BADUSERMACRO, The name "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.

BADVASTART, contextold-style parameter "name", 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.

BIFENABLED, The function "routine name" 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.

BIFPROTO, contextthe built-in function, "name", requires a prototype declaration from filename.

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.

BITARRAY, The CDD description for name specifies that it is an array of bitfields; It has been converted to a scalar bitfield.

Description: Compaq 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.

BITBADREP, contextthe 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.

BITCONSTSIGN, contextthe integer constant "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.

BITFIELDSIZE, The CDD description for bitfield name specifies a size greater than 32; The excess is declared separately.

Description: Compaq 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.

BITNOTINT, contextthe 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.

BITWIDTH, contextthe bitfield width expression "expression" is outside the range lower to upper.

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.

BITWIDTHTYP, contextthe bitfield width expression "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.

BLOCKEXTVLA, contextthe block scope identifier "name" 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.

BLOCKINL, 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.

BLTINARGCNT, contextan incorrect number of arguments were passed to the builtin function, "function expression".

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.

BLTINIMPLRET, contextfor the function "name", the implicit return type of "type" is not consistent with the expected type of "type". 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.

BOOLEXT, 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.

BOOLNA, 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.

BOUNDADJ, The CDD description for name 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).

BOUNDNOTINT, contextthe array bound "expression" 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

BUGCHECK, Compiler bugcheck. Submit an SPR 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.

C99NAONVAX, Full C99 is not supported on this platform. Language mode set to "relaxed_ansi89", which includes the C99 features supported on this platform.

Description: The Compaq C compiler on OpenVMS VAX does not support the C99 standard and will therefore not accept the /STANDARD=C99 qualifier. The compiler will use /STANDARD=RELAXED_ANSI. This mode includes all C99 features that are supported on OpenVMS VAX.
User Action: Do not use /STANDARD=C99 on this platform.

CANNOTREDEF, 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.

CANNOTUNDEF, 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.

CANTDISABLE, The message id name 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.

CANTMKRPSTORY, Attempt to create repository "string" for shortend names failed; OpenVMS status: reason.

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.

CDDATTR, 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 Compaq C. The attribute is ignored.
User Action: No action is required.

CDDBADID, An invalid identifier, name, 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.

CDDEXT, #dictionary is a language extension.

Description: The #dictionary directive is an extension of Compaq C/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.

CDDPATH, 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. Compaq also recommends that the #dictionary preprocessing directive be replaced by the #pragma dictionary operator.

CDDTOODEEP, The attributes for the Common Data Dictionary record description name 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.

CHARCONST, Ill-formed character constant.

Description: An invalid character constant was encountered.
User Action: Correct the character constant.

CHAROVERFL, 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.

CHKEXPAND, number integrity check error(s) after IL expansion of routine text

CHKINIT, number integrity check error(s) in initial IL & ST for module text

CHKOPT, number integrity check error(s) after text optimization phase for routine text

CLASSNOINIT, contextthe struct or union object "name" 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. Compaq 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.

CLOSBRACKET, Missing "]".

Description: The compiler was expecting a closing bracket, but one was not found.
User Action: Correct the program syntax.

CLOSEBRACE, Missing "}".

Description: The compiler was expecting a closing brace, but one was not found.
User Action: Correct the program syntax.

CLOSECOMMENT, 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.

CLOSEPAREN, Missing ")".

Description: The compiler was expecting a closing parenthesis, but one was not found.
User Action: Correct the program syntax.

CMPPTRFUNVOID, contextaccepting 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.

COLMAJOR, The CDD description for name specifies that it is a column-major array; It has been converted to a one-dimensional array.

Description: The Compaq 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.

COMMANDMACRO, Extraneous text "text" at the end of the command line macro "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.

COMPILERBUG, Bug found in compiler: bug.

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.

COMPLEXEXT, 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.

COMPLEXNA, 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.

COMPLEXNA1, 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.

CONFLICTHINTS, contextthis hint value contridicts a related hint at where. 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.

CONLINKREG, Conflicting register usage between "first set" and "second set". 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.

CONPSECTATTR, 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.

CONSTCOMPLIT, contextaccepting 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.

CONSTFOLDNS, contextthe libraries on this platform do not yet support compile-time evaluation of the constant expression "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.

CONSTFUNC, Ignoring const type qualifier in declaration of name.

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.

CONSTINWRT, 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.

CONSTNOINIT, contextthe const object "name" 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.

CONSTSTOCLS, contextthe const object "name" 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.

CONTFILE, 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.

CONTROLASSIGN, contextthe assignment expression "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.

CONVARASLIT, context the use of the const variable "name" in place of a literal constant is a language extension.

Description: Compaq 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.

CRXCOND, 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.

CVIDXOVFL, module uses more than 65536 CodeView type indices

CVTDIFTYPES, context"expression" of type "type", is being converted to "target type".

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.

CVTU32TO64, contextan 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.

CXXCOMMENT, C++ style comments (//) may not be portable.

Description: C++ style comments have been detected on this line. Although they have been accepted by Compaq C in this language mode, they will not be accepted by all compilers or by Compaq C in strict C89 standard mode.
User Action: Replace C++ style line comments (//) with equivalent C comments (/* ... */) if portability is a concern.

CXXKEYWORD, "C++ keyword" 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.

CXXPRAGMANA, The Compaq C++ pragma "pragma name" is not supported by Compaq C. The pragma will be ignored.

Description: The compiler has encountered a pragma that is supported by Compaq C++ but is not supported by Compaq C. The compiler will ignore the pragma.
User Action: Remove the pragma or compile the program with Compaq C++.

DCLMISMATLNK, The declaration of "name" has number parameter(s) but its linkage "name" has number. 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.

DCLMISMATLNK0, The declaration of "name" has an unknown number of parameters and cannot be used with the linkage "name". 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.

DCLMISMATLNK1, where "name" modifierhas a floating type but its linkage "name" 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.

DCLMISMATLNK2, where "name" modifierrequires an integer register but its linkage "name" 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.

DCLMISMATLNK3, where "name" has a size that is incompatible with the number of registers specified by its linkage "name". 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.

DCLMISMATLNK4, where "name" modifierhas a type that is not allowed because the it has the linkage "name". 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.

DCLMISMATLNK5, "name" has a void return type but its linkage "name" 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.

DECCONSTLARGE, 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.

DECLAFTERSTMT, Placing a declaration after a statement is a new feature in the C99 standard. Other C compilers may not support this feature.

DECLARATOR, 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.

DECLINFOR, Placing a declaration in a for loop is a new feature in the C99 standard. Other C compilers may not support this extension.

DECLSPECEXT, __declspec is a language extension.

Description: The __declspec storage class modifier is a language extension of Compaq 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.

DEFINOTHER, Another file in this compilation contains an external definition of a function named "name", or declares it as a variable with external linkage, at where.

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.

DEFINOTHER1, The external variable "name" was defined as an external function in another module of this compilation at where.

DEFINOTHER2, This declaration of "name" specifies a different type than the declaration in another module of this compilation at where.

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.

DEFINOTHER3, This declaration of "name" specifies a different thread-local attribute than a declaration in another module of this compilation at where.

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.

DEFPARMTYPE, There is no declaration for the old-style function parameter "name". 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. Compaq also recommends that old-style function definitions be replaced by prototype-format definitions.

DEFRETURNTYPE, The type of the function name 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.
User Action: It is a good programming practice to give all function definitions explicit return types.

DESIGBADARR, context, 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.

DESIGBADCOMP, context, 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.

DESIGBADIND, context, the constant expression "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.

DESIGBADIND1, context, the array element designator "[expression]" 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.

DESIGNATIONNA, 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. Compaq 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.

DESIGNATORUSE, 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.

DESIGNOMEMB, context, the component designator "name" 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.

DESIGSCALAR, context, 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.

DIFFEXMODEL, This redeclaration of "name" specifies a different extern model than a previous declaration of the variable at location.

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.

DIFFTYPEQUALS, contextthe type of "name" has different type qualifiers than the previous declaration at location. 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. Compaq 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.

DIRECTVNOCPP, "Directive text" 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.

DISREDECL, contextthe type of the external "name" is not compatible with the type of a declaration of "name" in another name scope at location.

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.

DOLLARID, Extension: A '$' was encountered in an identifier.

Description: Accepting a "$" character in an identifier is an extension of Compaq C/C++. The program might not compile with other C/C++ compilers.
User Action: Be aware of this if you wish to port the program.

DONOTAPPLY, linkage, assert or hint information for built-in function name 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.

DUPCASE, The switch statement containing this case label already has a case label for "number".

Description: A switch statement contains more than one case label for the same case value.
User Action: Remove the duplicate case label.

DUPDEFAULT, 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.

DUPENUM, contextthe enumerator "name" is not unique.

Description: An enumerator constant is declared more than once with the same value. While this is accepted by Compaq 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.

DUPEXTERN, The declaration of "name1" will map to the same external name as the declaration of "name2" at where.

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.

DUPLABEL, The label "name" is already defined in this procedure at location.

Description: A label has already been defined. Each function can define each label only once.
User Action: Remove the duplicate label definition.

DUPLINK, Duplicate linkage pragmas for linkage name "linkage name".

Description: The same linkage specifier has been defined in more than one #pragma linkage directive.
User Action: Declare each linkage only once.

DUPLPRAGASS, #pragma assert directive specified for the function name name while different #pragma assert was specified for its type.

Description: Duplicate assertion can't be specified for a function.