United States-English

» Contact HP

HP OpenVMS Systems

C Programming Language

Compaq C

Compaq C
User's Guide for OpenVMS Systems

Contents

Index

globaldef int var1; globalref int var2; globalvalue int var3;

Can be written as:

#pragma extern_model save #pragma extern_model strict_refdef
int var1; extern int var2; #pragma extern_model globalvalue extern int var3; #pragma
extern_model restore

#pragma extern_model documentation.

GOTSZOVFL, GOT table overflow for module text

Description: The object file required for this module is too complex.
User Action: Break the source program into several pieces so the individual objects will be simpler.

HEXOCTSIGN, In VAX C mode, the compiler will give this constant a signed type for compatibility with VAX C. This differs from the behavior specified in the C standard, which would give this constant an unsigned type.

Description: The C standard specifies that an octal or hexadecimal integer constant has an unsigned type when its value cannot be represented in a signed integer type, but can be represented in the corresponding unsigned integer type. Some older compilers, such as VAX C, will treat this constant as having a signed type. In VAX C mode, the compiler matches the behavior of VAX C. In other modes the compiler matches the behavior specified in the standard.
User Action: Be aware that this difference may cause porting problems if this program is compiled in a mode other than VAX C mode, or with a compiler that does not support this old behavior.

HEXOCTUNSIGN, The Compaq C compiler conforms to the C standard and will give this constant an unsigned type. Some older compilers may give this constant a signed type.

HINTNOTFUNC, The identifier "ident" is not a declared function. It will be ignored in this #pragma hint func_attrs list.

Description: The identifiers in a #pragma hint func_attrs must be declared functions.
User Action: Either declare the function prior to the pragma or remove the identifier from the pragma.

HINTTOOBIG, contextthis hint value must not be greater than one. The hint will be ignored.

Description: This #pragma hint directives must take positive floating point values which is not greater than one.
User Action: Correct the hint.

IDEXPECTED, Identifier expected but not found.

Description: The compiler was expecting an identifier, but one was not found.
User Action: Correct the program syntax.

IDINPARENSEXT, contextaccepting an identifier enclosed in parentheses as the second argument to va_start is a language extension.

Description: The C standard states that the second argument to va_start must be an identifier. For compatibility with other C compilers, Compaq C will accept an identifier enclosed in parentheses. Be aware that this program does not conform to the standard and may be rejected by other compilers.
User Action: Remove the parentheses.

IDPACKPOPPRAG, The identifier name from the pragma pack pop directive was not found on the top of the pragma pack stack.

Description: The identifier specified in the #pragma pack (pop, <identifier>) directive was not found on the top of the pragma pack stack. A previous #pragma pack pop or #pragma member_alignment restore may have already popped this identifier off the stack, the identifier may not have been previously pushed onto the stack, or extra elements are pushed on the stack on the top of element with the identifier, or the identifer may be spelled incorrectly.
User Action: Check the spelling of the identifier. Verify that the identifier was previously pushed onto the pack stack and not popped off by another #pragma pack pop or #pragma member_alignment restore, and all elements pushed on the top of the identifier are popped. Correct the directive(s).

IEEEASSUMED, Use of /ROUNDING_MODE qualifier implies /FLOAT=IEEE. Compilation will be performed as if /FLOAT=IEEE were specified on the command line.

Description: This compilation has specified an IEEE floating-point rounding mode without specifying /FLOAT=IEEE on the command line. The compiler will set the floating-point type to IEEE floating.
User Action: Specify /FLOAT=IEEE on the command line.

IEEEASSUMED1, Use of /IEEE_MODE qualifier implies /FLOAT=IEEE. Compilation will be performed as if /FLOAT=IEEE were specified on the command line.

Description: This compilation has specified an IEEE floating-point mode without specifying /FLOAT=IEEE on the command line. The compiler will set the floating-point type to IEEE floating.
User Action: Specify /FLOAT=IEEE on the command line.

IGNORECALLVAL, contextthe value returned from the function "expression" is not used - if this is intended, it should be cast to "void".

Description: A function that returns a value has been invoked, yet the value was not used. This might not have been what you intended.
User Action: Cast the function to void to suppress the message.

IGNOREEXTRA, Spurious token(s) ignored on preprocessor directive line.

Description: A preprocessing directive was supplied more arguments than it expects. The extra arguments will be ignored.
User Action: Remove the extra arguments.

IGNORETAG, contextthe tag "name" is redeclared, but will be ignored.

Description: The "struct" or "union" before the tag used in this declaration does not match that in the declaration of the tag. The "struct" or "union" at the earlier declaration of the tag will be used in this declaration.
User Action: Either change the current declaration to match the declaration of the tag, or create a new tag containing the different type.

IGNORETOKENS, # not in column 1 is ignored, skipping to end of line.

Description: In K & R mode, white space is not allowed before a preprocessing directive. The compiler will ignore this source line.
User Action: Either remove the white space or compile in a mode other than K & R.

IGNORSYSREG, Ignoring system register specified in routine's linkage.

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.

IMAGINARYNA, The _Imaginary keyword is not supported by Compaq C. It will be treated as an identifier in this compilation.

Description: Support for the _Imaginary keyword is an optional extension to the C standard. Compaq C does not support this extension. All occurrences of _Imaginary will be treated as an identifier.
User Action: Do not use the _Imaginary type.

IMPFNCFALLOFF, The last statement in non-void function "name" is not a return statement.

Description: This message indicates that a function with an implicit return type of it does not end with a return statement. If function execution reaches the end of the function, the implied return statement that executes will return an undefined value. This might not have been what you intended.
User Action: Consider declaring the function to be a void function. If it is supposed to return a value, add a return statement with the value the function is to return.

IMPFNCMSSNGRET, Non-void function "name" with implicit return type int does not contain a return statement.

Description: This message indicates that a function with an implicit return type of int does not contain a return statement. This message is not issued for functions with an explicit return type. See message MISSINGRETURN.
User Action: Consider declaring the function to be a void function. If it is supposed to return a value, add a return statement with the value the function is to return.

IMPLICITFUNC, contextthe identifier "name" is implicitly declared as a function.

Description: A expression contained a reference to a function that has not been declared. The C99 standard requires that all referenced functions must be declared before they are referenced.
User Action: Declare the function before it is referenced.

INCARGTYP, Type of actual argument inconsistent with formal parameter declaration in text

INCARRAYPARM, contextusing array syntax to declare a parameter that is a pointer to an incomplete array type may not be portable.

Description: Although this array parameter declaration conforms to the C standard (since it is equivalent to a pointer to the inner array), other C compilers may not accept it.
User Action: Be aware of this difference if you plan to port this source to another compiler.

INCARRAYPARM1, contextallowing an array parameter that has more than two unspecified element counts is a language extension.

Description: Because this parameter declaration will cause an array of incomplete types to be created, it does not conform to the C standard. Although some other C compilers will accept this declaration, many compilers will reject it.
User Action: Be aware of this difference if you plan to port this source to another compiler.

INCLUDENOPEA, A non-default pointer size or member alignment is specified, and the header files in directory are not protected. This might yield unpredictable results. The protect_headers_setup script can help. See the protect_headers_setup(8) man page for details.

Description: Using a non-default pointer size or member alignment can cause unpredictable results for system header files that are not protected and that rely on the default pointer size or alignment.
User Action: Examine the man page referenced in the message for more information.

INCLUDEOPEN, An error occurred while attempting to open the include file name: problem.

Description: An unexpected error occurred during the opening of an include file. The message text will contain additional information about the failure.
User Action: Correct the condition that caused the failure.

INCLUDEPROEPI, Cannot include files in a prologue or epilogue file.

Description: It is not possible for a prologue or epilogue file to perform an #include directive. This might lead to nested inclusion.
User Action: Remove the #include directive from the prologue/epilogue file.

INCOMPARRY, contextthe member name has incomplete array type. This is not strictly conformant with the C standard and might not be portable.

Description: The compiler has detected an array without a bounds specifier to be part of a struct or union type, and not the final member of that type. Other C compilers might not successfully compile a program that uses this extension.
User Action: Specify the bounds if possible.

INCOMPARRY1, contextthe last member of a struct or union, name, has incomplete array type. This is not strictly conformant with the C89 standard and might not be portable.

Description: Compaq C will allow an array without a bounds specifier to be part of a struct or union type. While this extension is allowed by the C99 standard, other C compilers might not successfully compile a program that uses this extension.
User Action: Specify the bounds if possible.

INCOMPCALL, contextthe return type of "expression" is incomplete.

Description: A function with an incomplete return type other than void cannot be invoked.
User Action: Complete the function return type before the function is invoked.

INCOMPDEREF, context"expression" is a pointer to an incomplete struct or union and should not be used as the left operand of a member dereference.

Description: In certain modes, Compaq C will allow the struct or union specifier of a member dereference operator (->) to specify a struct or union that does not contain the element specified by the right operand. While this is considered poor programming practice, it was common with older C compilers. In cases where the left operand is a pointer to an incomplete type, the practice is considered even worse. While Compaq C will accept the construct in certain modes, the code should be modified. Further, this program does not conform to the C standard and might not be accepted by other C compilers.
User Action: Be aware of this if you wish to port the program.

INCOMPELINIT, context, an array's element type is incomplete, which precludes its initialization.

Description: In order to initialize an array, the array element type must not be incomplete.
User Action: Either remove the initializer or complete the array element type before this point in the program.

INCOMPELMNT, contextthe element type of an array type is incomplete.

Description: The element type of an array type is incomplete at the point in the program where the array is declared. While Compaq C will allow this if the element type is completed later, other compilers might require the type to be complete at this point in the program.
User Action: Either complete the type before the array declaration, or be aware of this if you wish to port the program.

INCOMPMEM, The member "name" has an incomplete type.

Description: A struct or union member must not have an incomplete type. An exception is that Compaq C will accept a member that is an array with unspecified bounds, although warnings are often generated for this case.
User Action: Complete the type before it is used in as a member of a struct or union.

INCOMPNOLINK, In this declaration, "name" has no linkage and is of an incomplete type.

Description: A declaration with no linkage cannot specify an incomplete type. Incomplete types can only be used for identifiers with external or internal linkage.
User Action: Either complete the type before the declaration or modify the declaration to specify an external or internal linkage.

INCOMPPARM, In the definition of the function "function name", the parameter "parameter name" has an incomplete type.

Description: This function definition contains a parameter with an incomplete type other than an array whose bounds are not specified. This is not valid.
User Action: Complete the type before the function definition.

INCOMPRETURN, In the definition of the function "name", the return type is an incomplete type other than void.

Description: A function definition cannot specify a return type that is an incomplete type except for the void type.
User Action: Complete the type before the function definition.

INCOMPSTAT, The static declaration of "name" is a tentative definition and specifies an incomplete type.

Description: This file scope static declaration declares an identifier with incomplete type. This is not valid because a static declaration will allocate storage for the object, but the object's size is not known at this point in the compilation.
User Action: Complete the type before the static declaration.

INCOMPSTATARR, Allowing the declaration of a static array with an incomplete type is a language extension.

Description: The Compaq C compiler will allow an incomplete array type to appear in a static file scope declaration for compatibility with other compilers. This is an extension to the standard. Other compilers may reject this declaration.
User Action: Either use a complete type in this declaration, or change the storage class to extern.

INCOMPTENT, The type of the tentatively-defined variable "name" is incomplete at the end of the compilation unit.

Description: This file-scope declaration with no storage-class specifier declares an identifier with incomplete type. The type must be completed before the end of the compilation unit.
User Action: Complete the type.

INCOMPVALUE, context"expression" has incomplete type, and so cannot be used as an rvalue.

Description: It is not possible to get the value of an expression with incomplete type.
User Action: Complete the type before its value is used.

INCOMPVOID, contextthe element type of an array type is incomplete. The void type cannot be completed.

Description: The compiler has encountered an array with an element type of void. An array element must be an object type.
User Action: Change the type of the array element.

INCONSASSFUN, A function "name" appeared in more than one #pragma assert/hint func_attrs specifying the same assertion/hints.

Description: A function can appear on more than one #pragma assert or #pragma hint func_attrs as long as each #pragma specifies a different assertion/hint about the function. The assertion will be ignored.
User Action: Either remove the #pragma, or remove the function name from the pragma, or correct its spelling.

INITCONFLICT, Overlapping static storage initializations detected at Psect text + number

Description: The compiler back-end as detected a case where the same storage location has been initialized to more than one value. This can occur when inter-file optimization has been enabled.
User Action: Remove one of the initializers.

INITOVERLAP1, context, this initializer list will provide a value for a subobject that was initialized by the earlier initializer "init". The earlier initializer will be ignored.

Description: This initializer list will provide a value for a subobject that has already been initialized. While this is valid, it might not have been what was intended.
User Action: Initialize each subobject only once.

INITVLA, A variable-length array declaration cannot contain an initializer. The initializer will be ignored.

Description: A variable-length array declaration cannot contain an initializer.
User Action: Initialize the array using assignment statements after the declaration.

INLINEIG, An inline specifier may only be used to declare an identifier for a function. The inline keyword will be ignored.

Description: The inline, __inline or __forceinline keywords have been used on a non-function type. Or a non-function type has been listed in a #pragma inline or #pragma forceinline directive
User Action: Remove the keyword or remove the identifier from the pragma.

INLINESTOCLSMOD, The __inline or __forceinline storage class modifier is a language extension and might not be portable.

Description: The __inline and __forceinline storage class modifiers are an 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.

INPTRTYPE, contextthis argument to function name is of "type name" type and is not appropriate for the conversion specifier "incorrect conversion". The value may overwrite other data or produce unexpected results.

Description: The compiler has detected an input conversion specifier that does not match its corresponding argument. The corresponding argument may not be a pointer or may point to data that is wider or narrower than that specified by the conversion specifier. This might not have been what you intended.
User Action: Modify either the argument or the conversion specifier so that they match.

INSUFALN, Alignment specified for extern model is insufficient for variable. Extern model alignment updated.

Description: The current extern model places all external objects in a section whose alignment is not sufficient for the alignment of an object being placed in that section. The compiler will update the alignment of the section so that it is adequate for the object.
User Action: Either increase the alignment of the section or move the object to another section.

INTBADLINKAGE, #pragma use_linkage was applied to the intrinsic function "routine name". The function will be treated as an ordinary external function.

Description: Trying to optimize a pointer argument passed to an intrinsic function, the compiler discovered that #pragma use_linkage had been applied to the function declaration. The intrinsic function of this name that is understood by the compiler does not allow you specify a linkage. Therefore the compiler must assume that you are supplying your own function definition, and treat this as a call to an external function with no special properties.
User Action: If you want to call the intrinsic function, remove the #pragma use_linkage directive. If you are supplying your own function definition, you may want to rename the function or add a #pragma function directive for it.

INTCONCASTSGN, contextcasting of the constant "constant" to type type will cause a change in sign.

Description: Either a negative constant value has been cast to an unsigned type, or a positive value has been cast to a signed type and will be treated as a negative number after the cast.
User Action: Change the constant so that the sign will match the type of the cast.

INTCONCASTTRU, contextcasting of the constant "constant" to type type will cause data loss.

Description: A constant is cast to a type that is too small to hold the constant value. Data will be lost in the conversion.
User Action: Remove the cast, or use a smaller constant.

INTCONST, Ill-formed integer constant.

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

INTCONSTSIGN, contextconversion of the constant "constant" to type type will cause a change in sign.

Description: Either an unsigned type was assigned a negative constant value, or a signed type was assigned a positive contant value which will be evalated as a negative number after the assignment. Note that this message is not output for assignments to 1-bit bitfields. The message bitconstsign is generated in that case.
User Action: If this is what you intended, cast the constant to the desired type. You might also want to change the constant to the correct signed or unsigned value in order to avoid the optional message intconcastsgn, which reports sign changes caused by casts.

INTCONSTSIGNED, This integer constant value will be given the type long long int. This is compatible with the C99 standard. Older versions of the compiler would have given this unsigned long int type.

Description: With the introduction of the long long int type, the C99 standard changed the rules for how the type of certain integer constants are determined. Unsuffixed decimal constants which are too large for long int, but could fit in an unsigned long int are given the type long long int in C99. Prior to C99 these would be given unsigned long int type.
User Action: Be aware of this difference.

INTCONSTTOOBIG, This integer constant is too large for the long long type. It will be given the unsigned long long type.

Description: The C99 standard specifies that a decimal constant must fit in a signed type. This constant is too large for the long long int type. For compatibility with older versions of the compiler, the constant will be given the unsigned long long type.
User Action: Append a 'U' suffix to the constant. This will force it to be unsigned.

INTCONSTTRUNC, contextconversion of the constant "constant" to type type will cause data loss.

Description: A constant is converted to a type that is too small to hold the constant value. Data will be lost in the conversion.
User Action: If this is what you intended, cast the constant to the desired type. You might also want to mask off the high-order bits before casting in order to avoid optional message intconcasttru, which reports data loss caused by casts.

INTCONSTUNSIGN, This integer constant value will be given the type unsigned long int. This is compatible with the C89 standard and older compilers. The C99 standard requires this to be a signed long long int.

INTERNALPRAGMA, This is an internal pragma which should only be used by the compiler development team. It should not appear in user programs as it may cause unexpected behavior.

Description: This pragma exists only to allow the compiler developers to test certain functionality of the compiler. Its use outside the development team is unsupported.
User Action: Remove the pragma.

INTIMPLIED, In the declaration of "name", no type was specified. Type defaulted to int. This is a violation of the C99 standard.

Description: The declaration contains a storage-class specifier, but no type was specified. The compiler will assume a type of int. Omitting the type specifier is not valid in C++ or in C99, and is often considered poor programming practice.
User Action: Add a type specifier to the declaration.

INTOVERFL, contextinteger overflow occurs in evaluating the expression "expression".

Description: An integer overflow occurred while evaluating a constant expression. The value of the expression is undefined.
User Action: Correct the constant expression so that it does not overflow.

INTRINSICCALL, contextan apparent invocation of intrinsic function "name", problem. It will be treated as an ordinary external call.

Description: A function that could be handled internally by the compiler has been called in a manner that is inconsistent with expected usage. In such a case, the compiler will generate a run-time call to the function. This could result in performance loss.
User Action: If the function is intended to refer to the runtime library routine, the appropriate header file should be included in the source to provide the full function prototype and allow certain types of argument conversions. Alternatively, call arguments could be type cast as specified in the error message, or the function prototype could be added by hand. If the function is not intended to refer to the runtime library routine, the intrinsic version can be disabled by means of the "#pragma function (function_name)" directive.

INTRINSICDECL, contextthe declaration for intrinsic function "name" referenced at location, problem. It will be treated as an ordinary external function.

Description: A function that could be handled internally by the compiler has been declared with a prototype that does not agree with what the compiler expected to see, or has been declared at block scope instead of file scope. The function might in fact be a similarly-named replacement for the expected function, or the prototype might be incorrect or misplaced. 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.
User Action: If the function is intended to refer to the runtime library routine, the appropriate header file should be included in the source (note that it is not portable to include standard headers at other than file scope). Alternatively, the prototype could be modified as specified in the error message. 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.

INTRINSICDECLER, contextthe declaration for the prototyped intrinsic function "name" is incorrect: problem.

Description: A function that could be handled internally by the compiler and requires a prototype, has been declared with a prototype that does not agree with what the compiler expected to see. The function might be intended as a similarly-named replacement for the compiler-known function, or the prototype might be incorrect. The source must be modified to specify the intended behavior.
User Action: If the function is intended to refer to the compiler-known routine, the appropriate header file should be included in the source. Alternatively, the prototype could be modified as specified in the error message. If the function is intended to be a replacement for the compiler-known routine, disable the intrinsic version by specifying "#pragma function(function_name)" in the source file.

INTRINSICINT, contextthe place type for intrinsic "name" is being changed from "size_t" to "int".

Description: A function that is handled internally by the compiler expects an argument type or return type of "size_t", but the prototype for the function uses "int". The compiler will use "int" in this case.
User Action: Declare the function by including the appropriate header file. Alternatively, provide a private declaration (or modify an existing private declaration) with "size_t" in the appropriate location(s), and with "size_t" defined as it is in the standard system header files. If the function is not intended to refer to the runtime library routine, the intrinsic version can be disabled by means of the "#pragma function (function_name)" directive.

INTUNDFUN, There is no function declaration visible for the identifier "name" at the point of this #pragma pragma type.

Description: An identifier specified in a #pragma intrinsic or #pragma function directive must refer to a function declaration visible at the point of the pragma. The identifier will be ignored.
User Action: Either remove the identifer from the pragma, correct its spelling, or reorder the source to ensure that a declaration of the identifier as a function is visible at the point of the pragma.

INVALIDARG, Invalid argument to pragma pragma. Pragma is ignored.

Description: An invalid argument has been specified for a pragma directive. The compiler will ignore the directive.
User Action: Correct the directive.

INVALIDSTR, The # operator produced an invalid string.

Description: During the expansion of a macro, the # stringize operator produced a token that is not a valid string. The operand to the stringize operator must contain characters that form a valid string.
User Action: Correct the operand to the stringize operator.

INVALTOKEN, Invalid token discarded.

Description: An unexpected token was encountered by the compiler. The token has been ignored. An example is the preprocessing operator "#" appearing outside a macro body (int #a;).
User Action: Remove the unexpected token.

INVCPPINARGS, Possible directive "#directive" within a macro argument list. The directive is treated as part of the argument list, and not as a preprocessing directive.

Description: The compiler has encountered a directive as part of the argument list of a macro invocation. This directive will be treated as part of the argument list, and not as a preprocessing directive. The behavior might be different than other compilers.
User Action: Rewrite the macro invocation so that it does not include the directive.

INVDUPENUM, contextthe value of the enumerator "name" conflicts with a previous declaration.

Description: The specified enumerator name has been previously declared with a different value.
User Action: Either use a different enumerator name or remove the previous declaration of the name.

INVNOMEMPRAG, Invalid argument to nomember_alignment pragma. Pragma is ignored.

Description: The compiler was unable to parse a #pragma nomember_alignment directive. The directive will be ignored.
User Action: Correct the directive.

INVPACKPRAG, Invalid pack pragma. Pragma is ignored.

Description: The compiler was unable to parse a #pragma pack directive. The directive will be ignored.
User Action: Correct the directive.

INVPPDIRPEA, The preprocessor directive name is not allowed in a prologue or epilogue file. The directive is ignored.

Description: It is not possible for a prologue or epilogue file to have this preprocessor directive in it.
User Action: Remove the offending preprocessor directive from the prologue/epilogue file.

INVSTATIC1, context the keyword "static" and/or type qualifiers may appear only in the outermost array-bounds specifier of a function parameter. Keyword/qualifier ignored.

Description: The keyword "static" or a type specifier appeared in an array-bound specifier that was either not part of the declarator for a function parameter or it was not the outermost array-bound specifier of a function parameter.
User Action: Remove the keywords or confine them to use in the outermost array-bound specifier of a function parameter.

INVSTATIC3, The keyword "static" may not appear in an array-bound specifier for a declaration of an array of unknown size. Keyword ignored.

Description: The keyword "static" appeared in the declaration of an array whose size was not known, either because array has in incomplete type or because the array has a star bounds specifier.
User Action: Remove the keyword.

INVSTATIC4, An expression specifying the bound is required when the keyword "static" is used in an array-bounds specifer. Keyword ignored.

Description: The keyword "static" appeared in an array-bounds specifier that did not have an expression describing the array bound. The keyword tells the compiler that actual arguments passed to this parameter will always have at least as many elements as specified in the formal parameter. It is inconsistent to specify the keyword without also supplying a value for the bound.
User Action: Remove the keyword or supply a value for the bound.

INVSTATIC5, context the static bound value differs from the static bound value in another declaration at location. The smaller static bound value will be used.

Description: In a previous declaration of a function one or more parameters with array type were declared with a different static bound value than in the current declaration. This can occur if one of the sizes of the corresponding static arrays differ between the two declarations.
User Action: Remove the keyword "static" from the declarations, or give all function declarations the same static bound value.

INVSTATIC6, context neither the keyword "static" nor a type qualifier may be used in array-bounds for old-style function parameters. Keyword/qualifiers ignored.

Description: Use of the keyword "static" or a type specifier within the outermost array bound specifier of a formal parameter is a new feature in the C99 statndard. It cannot be used in old-style function definitions.
User Action: Remove the keywords or convert the code to use prototype-style function declarations and definitions.

IVDEPNOFOR, This #pragma directive was not followed by a for statement. The directive will be ignored.

Description: The #pragma ivdep and #pragma unroll directives modify the for loop which follows them. The compile has encoutered one of the directives without a following for loop. The directive will be ignored.
User Action: Remove the directive.

KEYCOMB, Illegal combination of keywords.

Description: An invalid combination of Microsoft keywords was encountered during a declaration. In most cases this is because the keywords contradict each other. One example would be using the __fastcall and __stdcall modifiers in the same function declaration. This message is only output when the compiler is in Microsoft mode.
User Action: Remove one of the contradictory modifiers.

KNRFUNC, The function "name" is defined using the old style K&R syntax. The C standard has marked this syntax as obsolescent, and it is not supported in C++. Consider using the standard C prototype syntax.

Description: The function uses an old style function definition. Compaq recommends that old style function definitions be replaced by prototype-format definitions.
User Action: Recode the function definition to use the recommended prototype-format definition.

LABELWOSTMT, Accepting a label without a following statement is a language extension.

Description: The C standard states that a label must be followed by a statement. For compatibility with other C compilers, Compaq C will accept a label without a statement. Be aware that this program does not conform to the standard and may be rejected by other compilers.
User Action: Add a semicolon after the label to create a null statement.

LCRXCOND, Common Data Dictionary description extraction condition. msg.

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.

LDCOMPLEXNYI, contextthe type long double _Complex is not fully supported on this platform. The type is only accepted when the compilation specifies the option to make the long double type 64-bits in size.

Description: On some platforms Compaq C does not support the long double _Complex type where the real and imaginary component are 128-bits in size. As Compaq C requires that each component of a long double _Complex be the same size as a long double, this compilation must specify the option to treat long double as 64-bits.
User Action: Either specify the correct compiler option or use the double _Complex type instead of the long double _Complex type.

LEXNESTPAR, Lexically nested parallel at scope text is not supported

Description: Nested parallel directives are not supported.
User Action: Remove the nested parallel directive.

LISTOPEN, An error occurred while attempting to open the listing file: reason.

Description: An unexpected error occurred during the creation of the listing file. The message text will contain additional information about the failure.
User Action: Correct the condition that caused the failure.

LOCALEXTINI, The block-level declaration of "name" includes an initializer and specifies storage class extern.

Description: A block-level declaration with extern storage class cannot contain an initializer.
User Action: Remove the initializer from the declaration or move the declaration to file scope.

LOGICALLINE, A logical source line longer than number characters was encountered.

Description: The length of a source line has exceeded the maximum length supported by the Compaq C compiler.
User Action: Reduce the size of the line.

LONGDEBUG, The identifier name exceeds number characters; name passed to the debugger will be truncated to "truncated spelling".

Description: On some platforms, the name length supported by the compiler is greater than the length supported by the debugger. In this case the compiler must truncate the name when it is output to the debugger symbol table for this compilation.
User Action: Reduce the size of the name.

LONGDOUBLENY1, contexttype long double has the same representation as type double on this platform and is treated as a synonym for type double in this compilation mode.

Description: Compaq C does not support the long double type on this platform. In this compilation mode, the compiler will treat the long double type as a synonym for the double type.
User Action: Be aware of this.

LONGDOUBLENYI, contexttype long double has the same representation as type double on this platform.

Description: Although Compaq C will recognize the long double type as a different type than double in this compilation mode, on this platform they will both use the same representation. Using long double will not provide any additional precision or range.
User Action: Be aware of this.

LONGEXTERN, The external identifier name exceeds number characters; truncated to "truncated spelling".

Description: The length of an identifier with external linkage exceeds the maximum allowed on this platform. The name used in an output object file will be truncated to meet the platform restrictions. Note that the debugger name will be unchanged.
User Action: Reduce the size of the name. On OpenVMS platforms the /NAMES=SHORTENED qualifier can also be used. When the qualifier is specified, the compiler will encode long external names instead of truncating them.

LONGFLOATEXT, contextlong float as a synonym for double is a language extension.

Description: Certain standard modes allow the use of the long float type as a synonym for double. This is not allowed by the C standard. This message indicates this use of long float as a potential portability problem.
User Action: Change long float to double.

LONGLONGSUFX, The integer constant is of type "type", which is a new feature of C99 might not be portable.

Description: The use of the suffix ULL or LL on an integer constant does not conform to the C89 standard and might not be accepted by other C compilers.
User Action: Be aware of this if you wish to port the program.

LONGLONGTYPE, contexttype "type" is a new feature in C99.

Description: On some platforms, Compaq C will accept the [unsigned] long long type as a way to declare [unsigned] 64-bit integers. The long long int type is a new feature of C99 and other compilers might not accept this declaration.
User Action: Be aware of this portability concern.

LONGMODULEID, Identifier name "name" in a #pragma module or #module directive exceeds 31 characters.

Description: A module name specified in the #pragma module or #module directive must be less than 32 characters. The compiler will truncate the name to the first 31 characters specified.
User Action: Shorten the module name.

LONGMODULESTR, Character-string constant string in a #pragma module or #module directive exceeds 31 characters.

Description: An ident specified in the #pragma module or #module directive must be less than 32 characters. The compiler will ignore the directive.
User Action: Shorten the ident specifier.

LONGPREFIX, Prefix string too long. Truncated to "newprefix".

Description: The specified prefix to the #pragma extern_prefix directive is too large for this platform. The prefix will be truncated.
User Action: Reduce the size of the specified extern prefix.

LONGPSECT, Psect name is too long (maximum is 31 characters).

Description: The psect name specified in a globaldef declaration was longer than 31 characters. This exceeds the maximum allowed length.
User Action: Either reduce the psect name to 31 characters or remove the psect specifier.

LVALUECAST, contextthe result of the cast "cast" is used as an lvalue.

Description: The result of a cast has been used as an lvalue. This is a language extension of Compaq C. The program does not conform to the C standard, and might not be accepted by other compilers.
User Action: Remove the cast.

MACROREDEF, The redefinition of the macro "name" conflicts with a current definition because reason. The redefinition is now in effect.

Description: A macro has been redefined with either different formal parameters and/or a different body than a previous definition of the macro.
User Action: Either make all definitions of the same macro identical, or undefine the macro using the #undef preprocessing directive before it is redefined.

MACROREDEFIN, Macro redefined.

Description: A #define preprocessing directive has redefined a macro whose previous definition contained an error or warning. Normally, the compiler will issue a warning if a macro is redefined to something other than the previous definition. However, if the previous definition caused a warning or error to be generated, this informational message is output instead.
User Action: Do not redefine a macro without first undefining it.

MAINNOTINT, Strict standard C extension: The declaration of the "main" function has a return type other than int.

Description: Standard C requires that the "main" function be defined with a return type of int. Compaq C will accept other return types, but the program does not conform to the C standard. The status value returned to the environment may not be what you expect, and other C compilers may not accept the definition as written.
User Action: Define the "main" function with a return type of int for maximal portability.

MAINPARM, Strict standard C extension: The declaration of the "main" function has more than two parameters.

Description: Standard C requires that the "main" function takes no more than two parameters. Compaq C will accept more, but the program does not conform to the C standard.
User Action: Modify the declaration if you want the program to be standard conformant.

MAINPROGEXT, MAIN_PROGRAM is a language extension.

Description: The use of MAIN_PROGRAM to designate a function as the main program is a language extension of Compaq C. Other C compilers might not successfully compile a program that uses the extension.
User Action: The main program should be declared by naming the function main.

MATHERRNO, contextfunction name is defined to set errno when a domain error or range error occurs. As an intrinsic, it may not be able to do so.

Description: Any code that tests the value of errno set by this function may not work properly due to the optimizations that are possible when this function is an intrinsic.
User Action: If the value of errno set by this function is ignored, tell the compiler via its command line qualifiers to assume nomath_errno. Otherwise, disable the intrinsic by using a #pragma function(func-name).

MAYHIDELOSS, context"expression" has a larger data size than "target type". The use of a cast operator can suppress the message that this assignment might result in data loss.

Description: In a cast of a pointer to one of the integer types, or a cast of one of the integer types to a pointer, or a cast of one pointer type to another, the size of the source is greater than the size of the type being cast to. This cast could result in a loss of data if it is used as the source of an assignment. This potential loss of data can be verified by removing the cast and seeing if the compiler emits a loss of data message on the assignment.
User Action: If the cast cannot lose precision, it is safe to ignore this warning.

MAYLOSEDATA, context"expression" has a larger data size than "target type". Assignment can result in data loss.

Description: In an assignment of a pointer to one of the integer types, or one of the integer types to a pointer, the size of the source is greater than the size of the destination. The assignment can result in a loss of data. This might not have been what you intended.
User Action: If this was the intended operation, cast the source to the type of the destination before the assignment.

MAYLOSEDATA2, context"expression" has a larger data size than "target type". Assignment can result in data loss.

Description: In an assignment of two pointers, the size of the source is greater than the size of the destination. The assignment can result in a loss of data. This might not have been what you intended.
User Action: If this was the intended operation, cast the source to the type of the destination before the assignment.

MECHMISMATCH, Argument passing mechanism does not match formal parameter mechanism for text

MEMBERVLA, contextthe struct or union member "name" cannot be declared with a variably modified type.

Description: Only ordinary identifiers with block scope and without storage class extern, or ordinary identifiers with function prototype scope can be declared with a variably modified type.
User Action: Correct the declaration.

MISALGNDMEM, This member is at offset offset, which is not a multiple of the member's alignment of align. Consider padding before this member, rearranging the order of member declarations, or using #pragma member_alignment.

Description: A member of a struct or union requires an alignment for efficient access but will be allocated at an offset that is not a multiple of that alignment.
User Action: Use one of the suggestions made in the message.

MISALGNDSTRCT, This member requires align1 alignment for efficient access, but is contained in a struct containing align2 alignment. Consider using #pragma nomember_alignment align1.

Description: A member of a struct or union requires an alignment for efficient access that is more strict than the alignment of the enclosing struct or union. Even though this member is correctly aligned within the struct or union, if the struct or union is enclosed within another type, the member in question might be placed at a position with incorrect alignment for its type.
User Action: Use either the #pragma member_alignment directive or #pragma nomember_alignment directive with an argument equal to or greater than the alignment of the member.

MISDEFARG, Missing argument for "defined" operator.

Description: The defined preprocessing operator was not supplied with an 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.

MISDEFPAR, Missing right parenthesis for "defined" operator.

Description: The defined preprocessing operator began with a left parenthesis, but no matching right parenthesis was found. The value of the operator is undefined.
User Action: Add the right parenthesis after the preprocessing operator argument.

MISMATPARAM, contextparameter number has a different type than specified in an earlier declaration of this function.

Description: A function has been redeclared with a parameter whose type is different than the type specified in a previous declaration of the function. This generally leads to additional errors.
User Action: Correct the function declarations so that the parameter information is the same in each declaration.

MISMATPRSRET, "name" has a non-void return type but its linkage "name" preserves the return register(s). Standard linkage will be used.

Description: The function or typedef's special linkage specifies that the register(s) used to return the function value are to be preserved. This is invalid as the register can either be preserved, or hold the return value, but not both.
User Action: Modify the #pragma linkage directive to either remove the register from the preserved list or to specify another register to hold the return value.

MISMATTHREAD, contextthe __declspec(thread) storage class modifier of "name" is different from a previous declaration of "name" at location.

Description: If an object is declared with thread-local storage, then all declarations of that object must declare it with thread-local storage.
User Action: Either remove the invalid redeclaration or modify it to match the previous declaration.

MISPARAMCOUNT, contextthe number of parameters differs from an earlier declaration of this function.

Description: A function has been redeclared with a different number of parameters than a previous declaration of the function. This message generally proceeds additional errors.
User Action: Correct the function declarations so that the parameter information is the same in each declaration.

MISSINGCOMMA, This parameter is not preceded by a comma.

Description: The compiler has encountered a parameter specifier that is missing a preceding comma. The parameter will be defined anyway, though this 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 (possibly followed by ", ...").

MISSINGFUNC, The function "name" has internal linkage, occurs in a context that requires its definition, and has no definition.

Description: The program has referenced a function declared with static storage class, but the function is not defined in the compilation unit. If a program references a static function, the function must be defined in the compilation unit.
User Action: Either define the function or change the function declaration to have extern storage class.

MISSINGLABEL, The label "label name" is the target of a goto statement within the function "function name", but has no definition within "function name".

Description: Every label referenced in a goto statement must be defined in the same function.
User Action: Either change the name of the label in the goto statement, or define the label.

MISSINGRETURN, Non-void function "name" does not contain a return statement.

Description: This message indicates that a function with an explicit return type does not contain a return statement. This message is not issued for functions with an implicit return type of int. See message IMPFNCMSSNGRET.
User Action: Consider declaring the function to be a void function. If it is supposed to return a value, add a return statement with the value the function is to return.

MISSINGTYPE, Missing type specifier or type qualifier.

Description: The compiler was expecting a type specifier or type qualifier, but one was not found.
User Action: Correct the program syntax.

MIXALLOCAVLA, contextthis call to __ALLOCA occurs in a block that contains vlaallocafrag1. The storage allocated by this __ALLOCA call will vlaallocafrag2vla or aligned automatic declaration was at where.

Description: Storage allocated for arrays of variable length and for automatics whose alignment is greater than octaword have their storage deallocated when the block they are declared in exits. Storage allocated by __ALLOCA is not normally deallocated until function exit. Compaq C cannot support both types of deallocation in the same block. Therefore, when both appear in the same block, the storage for both will be deallocated with the block exits.
User Action: Be aware of this. If the storage allocated for __ALLOCA must remain allocated until function exit, move the __ALLOCA call outside the block declaring the vla or the aligned auto.

MIXALLOCAVLAV, contextusing __ALLOCA and variable-length arrays in the same function is not allowed on this platform. The first variable-length array declaration is at where.

Description: Because they place different requirements on stack allocation on VAX systems, __ALLOCA and variable-length arrays cannot be used in the same function.
User Action: Recode the function to use either variable-length arrays or __ALLOCA.

MIXFUNCVOID, contextcompatibility of a pointer to void and a pointer to a function is not portable under the C standard.

Description: The C standard defines pointer to void as being assignment compatible only with pointers to object or incomplete types. An implementation may represent function pointers in a way that cannot be stored in a pointer to void (or vice-versa). Thus even an explicit cast between a function pointer and a pointer to void is not portable.
User Action: If a generic pointer to function is needed, declare a typedef for some pointer to function type, and always use explicit casts to assign to and from that type.

MIXINLINE, The function name is declared both this and that.

Description: A function is declared with more than one of the forceinline, inline, or noinline attributes. It will be given the attribute that will provide the most optimization.
User Action: Make sure each function has only one of the attributes.

MIXLINKAGE, context"name" is declared with both internal and external linkage. The previous declaration is at location.

Description: This warning is output in certain cases when the linkage of a declaration conflicts with the linkage specified in an earlier declaration.
User Action: Change one of the declarations so that the linkages match.

MIXLINKAGE1, context"name" is declared with both internal and external linkage. The previous declaration is at location.

Description: This informational is output when a function previously declared to have extern storage class is redeclared to have internal storage class and the mode of the compiler is common (K & R) mode.
User Action: Change one of the declarations so that the linkages match.

MIXOLDNEW, The definition of the function name includes both a prototype and a declaration list.

Description: A function has been defined using both a declaration list and a prototype. This is not valid.
User Action: Correct the declaration.

MIXSTORCLS, contexta storage class has already been specified. This storage class is ignored.

Description: The same declaration contains more than one storage class specifier. The compiler will ignore all storage class specifiers after the first one.
User Action: Change the declaration to use only one storage class specifier.

MIXVLAALLOCA, Declaring vlaallocafrag1 in the same block as a call to __ALLOCA will cause the storage allocated by any __ALLOCA call to vlaallocafrag2previous call to __ALLOCA was at where.

Description: Storage allocated for arrays of variable length and for automatics whose alignment is greater than octaword have their storage deallocated when the block they are declared in exits. Storage allocated by __ALLOCA is not normally deallocated until function exit. Compaq C can not support both types of deallocation in the same block. Therefore, when both appear in the same block, the storage for both will be deallocated with the block exits.
User Action: Be aware of this. If the storage allocated for __ALLOCA must remain allocated until function exit, move the __ALLOCA call outside the block declaring the vla or the aligned auto.

MIXVLAALLOCAV, Using both __ALLOCA and variable-length arrays in the same function is not allowed on this platform. The first call to __ALLOCA is at where.

MODNOIDSTR, Invalid identifier or character-string constant specification.

Description: If specified, the second argument to the #pragma module or #module directive must be either an identifier or a string constant.
User Action: Correct the directive.

MODSTORCLS, Storage class modifier noshare has no meaning with this storage class. Modifier is ignored.

Description: The storage class modifier noshare is only valid for variables with a storage class of static, extern, or globaldef. It is ignored for other storage classes.
User Action: Remove the noshare storage class modifier.

MODULEFIRST, "#pragma module" or "#module" directive must precede any language text.

Description: The #pragma module or #module directive must appear before any declarations. The directive will be ignored.
User Action: Move the directive to the top of the compilation unit.

MSGPOP, This "restore" has underflowed the message stack. No corresponding "save" was found.

Description: The message stack, managed by the #pragma message 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.

MSGSFRMEXLCODE, Enabling this message may cause additional messages from excluded code to be output.

Description: This message is never output by the compiler. Instead it is used to control whether other messages will be output. Normally, the compiler will not output some messages when it is processing code that it knows will never be executed. One example of this would be the second operand of the conditional operator when the first operand is FALSE. This suppression of these messages can be overridden by enabling this message.
User Action: Decide if you want the additional messages.

MULTICHAR, A character constant includes more than one character or wide character.

Description: A character constant includes more than one character. While this is valid, it might not have been what you intended.
User Action: Verify that the constant should contain more than one character.

MULTILINK, Multiple linkage pragmas specified for "routine name".

Description: The same routine appeared in more than one #pragma use_linkage directive. Each routine can only be given one linkage.
User Action: Remove the routine from all but one #pragma use_linkage directive.

MULTILINKREG, The register "register" is specified more than once in the linkage pragma. Pragma is ignored.

Description: The same register was specified more than once in the same register list in a #pragma linkage directive. The compiler will ignore the entire pragma.
User Action: Correct the directive.

MULTIMAIN, More than one main program has been defined.

Description: The compiler has encountered more than one main program in this compilation unit. Each program can have only one main program.
User Action: Remove one of the main programs.

MULTIPSECTNAME, Multiple psect_type names specified. The name "new_name" supersedes "old_name".

Description: More than one #pragma code_psect or #pragma linkage_psect was encountered. The psect specified by the later #pragma supersedes the one specified earlier. This message is only output for C compilers on OpenVMS Alpha.
User Action: Each program should contain at most one #pragma code_psect and one #pragma linkage_psect.

NAMESHORTENED, The external identifier "name" exceeds 31 characters. The name has been shortened to "shortened spelling".

Description: A compilation that used the /NAMES=SHORTENED qualifier has encountered a name that needs to be shortened. The external name will be different than the internal name. Also, because the external name exceeds the length specified by standard C as the minimum external length an implementation must support, this program does not strictly conform to standard C and might not be accepted by other C compilers.
User Action: Be aware of these items.

NAMESLOWER, The /NAMES=LOWERCASE qualifier will be removed in a future version of the compiler. Use /NAMES=AS_IS if your application must generate global names in lowercase.

Description: While the C language has always required identifiers with internal linkage to be treated case sensitively,it traditionally permitted implementations to monocase identifiers with external linkage. Modern standards require C/C++ implementations to preserve the case of identifiers with external linkage. As VMS and other operating systems that traditionally implemented monocasing chose uppercase as the convention, /NAMES=LOWERCASE runs contrary both to the C and C++ standards and to traditional conventions. Continued support for this option interferes with support for compatibility between old code compiled with /NAMES=UPPERCASE and new code compiled with /NAMES=AS_IS.
User Action: Use /NAMES=AS_IS, making source code changes as needed.

NEEDADDRCONT, context"name" does not have a constant address, but occurs in a context that requires an address constant.

Description: A variable with static storage has been initialized to the address of an object whose address is not constant. This can happen if a static pointer variable is initialized to the address of an automatic variable.
User Action: Either make the initialize a constant, or, if possible, initialize the static storage using a run-time assignment.

NEEDARITH, context"expression" has type type, which is not arithmetic.

Description: An expression that must be an arithmetic type was not an arithmetic type. For example, the operands of an arithmetic operator such as * must be arithmetic type.
User Action: Modify the expression so that it is an arithmetic type.

NEEDCONSTEXPR, context"name" is not constant, but occurs in a context that requires a constant expression.

Description: An expression that must evaluate to a compile-time is not a constant.
User Action: Modify the constant expression so that it will evaluate as a compile-time constant.

NEEDCONSTEXT, context"name" is not constant, but occurs in a context that requires a constant expression. This is an extension of the language.

Description: The C89 standard requires that an initializer for an automatic aggregate or union type object have an initializer that is a list of constant expressions. Compaq C allows non-constants in these initializers. This is an extension to C89. Although this is allowed by the C99 standard, 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.

NEEDDFLOAT, The CDD description for name specifies the D_Floating data type. The data can only be represented when compiling with /FLOAT=D_FLOAT.

Description: The /FLOAT command-line qualifier specified a floating type other than D_floating format. The CDD description specified was D_floating type, which did not match the floating type specified on the command line.
User Action: Specify the correct command-line qualifier, or change the description of the item in the CDD.

NEEDFUNCPTR, context"expression" points to type type, but occurs in a context that requires a pointer to a function type.

Description: An expression that must be a pointer to a function type is a pointer to an object or incomplete type. For example, if a function invocation expression is a pointer, it must be a pointer to a function type.
User Action: Modify the expression so that it is a pointer to a function type.

NEEDGFLOAT, The CDD description for name specifies the G_Floating data type. The data can only be represented when compiling with /FLOAT=G_FLOAT.

Description: The /FLOAT command-line qualifier specified a floating type other than G_floating format. The CDD description specified was G_floating type, which did not match the floating type specified on the command line.
User Action: Specify the correct command line qualifier, or change the description of the item in the CDD.

NEEDIEEE, The CDD description for name specifies a VAX floating data type. The data cannot be represented when compiling with /FLOAT=IEEE_FLOAT.

Description: The command-line qualifier /FLOAT=IEEE_FLOAT was specified, indicating that all floating-point data should be represented in IEEE-floating format, yet the CDD description specified a non-IEEE_floating type.
User Action: Specify the correct command-line qualifier, or change the description of the item in the CDD.

NEEDIEEE1, The CDD description for name specifies an IEEE floating data type. The data can only be represented when compiling with /FLOAT=IEEE_FLOAT.

Description: The CDD description for an item specifies an IEEE floating point type. However this module was not compiled with the /FLOAT=IEEE_FLOAT qualifier.
User Action: Specify the correct command-line qualifier, or change the description of the item in the CDD.

NEEDINTEXPR, context"expression" has type type, which is not integral.

Description: An expression that must be an integer type was not integral. For example, an array-index specifier must be an integral type.
User Action: Modify the expression so that it is an integral type.

NEEDLVALUE, context"expression" is not an lvalue, but occurs in a context that requires one.

Description: An expression that must be an lvalue was not an lvalue. For example, the operand of the address-of operator must be an lvalue.
User Action: Modify the expression so that it is an lvalue.

NEEDMEMBER, context"name" is not a member of "struct or union expression".

Description: The second operand of a . or -> operator specifies a member name that is not a member of the struct or union type specified by the first operand. Note that in certain modes, Compaq C will search all other visible struct/union types for a matching member name. If it finds one, a diagnostic will be issued, and the offset of that name will be used.
User Action: Specify a valid member name.

NEEDNONBLTIN, context"name" is a builtin and cannot be used in this context.

Description: A program has used a builtin function in a way that is invalid for builtin functions. For example, a program cannot take the address of a builtin.
User Action: Remove the improper use of the builtin.

NEEDNONCONST, context"expression" has const-qualified type, but occurs in a context that requires a modifiable lvalue.

Description: The code has attempted to modify an object that is either a const-qualified type or has been declared with the readonly storage-class modifier. This is not valid. A typical example is assigning a value to a const variable.
User Action: Either remove the const qualifier from the object's type, remove the readonly storage-class modifier from the object declaration, or rework the code so that the object is not written to.

NEEDNONVOID, context"expression" has void type, but occurs in a context that requires a non-void result.

Description: An expression that must not be a void type was void. For example, the control expression for an if statement must not have void type.
User Action: Modify the expression so that it has the required type.

NEEDPOINTER, context"expression" has type type, but occurs in a context that requires a pointer.

Description: An expression that must be a pointer type was not a pointer type. For example, the operand of the dereference operator must be a pointer type.
User Action: Modify the expression so that it has a pointer type.

NEEDPTROBJ, context"expression" does not point to an object type.

Description: An expression that must be a pointer to an object type is a pointer to a function or incomplete type. For example, if a pointer is the operand of the postincrement operator, it must point to an object type.
User Action: Modify the expression so that it is a pointer to an object type.

NEEDSCALAR, context"expression" has type type, which is not scalar.

Description: An expression that must be a scalar type was not scalar. For example, only scalars can be cast to other types.
User Action: Modify the expression so that it is a scalar type.

NEEDSCALARTYP, context"source type" is type type, which is not scalar.

Description: In a cast expression, the destination type of the cast is not a scalar type. This is not valid. Both the source and target type of a cast must be scalars.
User Action: Modify the cast destination type so that it is a scalar type.

NEEDSIMPLEASM, This asm is unsupported or illegal.

Description: The argument to the asm intrinsic is invalid.
User Action: Supply a valid argument to the asm instrinsic.

NEEDSTRCONST, context"name" is not a legal asm string, a string constant is required.

Description: The argument to the asm intrinsic must be a string constant.
User Action: Change the argument to be a string constant.

NEEDSTRUCT, context"expression" has type type, but occurs in a context that requires a union or struct.

Description: The left operand of the . or -> operator does not have struct or union type.
User Action: Correct the operand.

NEGATIVEHINT, contexta negative hint value is not allowed. The hint will be ignored.

Description: All #pragma hint directives must take positive floating point values.
User Action: Correct the hint.

NESTEDCOMMENT, Opening comment delimiter found inside a delimited comment; a previous comment may be missing its closing delimiter.

Description: C comments delimited by /* */ do not nest. When /* is encountered inside a delimited comment it usually means that the previous comment is missing its terminating */ or that the user has ill-advisedly attempted to "comment out" a section of code that contains a delimited comment.
User Action: It is traditional in C to use #if 0 to conditionalize out large sections of code. You may also want to consider //-style comments if the compiler modes you care about recognize them.

NESTEDENUM, The type "type" is declared nested within "enclosing type". In C, the nesting is ignored and type and its enumerator constants can be accessed as if they were not nested. However, the type and its enumerators are members in C++. Fix.

Description: C allows types to be declared within other types. For example: struct S { int a; enum E { first, second, third} b; int c; }; In C++ the enum E would not be accessible without using the :: operator.
User Action: Declare the nested type before declaring the enclosing type.

NESTEDTYPE, The type "type" is declared nested within "enclosing type". In C, the nesting is ignored and type can be accessed as if it were not nested. However, the type is a member in C++. Fix.

Description: C allows types to be declared within other types. For example: struct S { int x; struct S1 { int a; int b; } y; }; In C++ the struct S1 would not be accessible without using the :: operator.
User Action: Declare the nested type before declaring the enclosing type.

NESTINCL, Files included by this file are referenced. However nothing else appears to be referenced from this file.

Description: When compiling with the current set of compilation options, to improve compilation efficiency, you may wish to include the files which this file includes directly, rather than including them from this file.
User Action: For compilation efficiency, you may exclude this include file when compiling with the current set of compilation options.

NEWLOCALE, The compiler could not set its locale to the locale-specific native environment. This problem might be caused by an incorrect value for a name defined in your process environment such as "LC_ALL" or "LANG". The "C" locale will be used.

Description: During start-up, the compiler was unable to set its locale to the locale-specific environment. As part of its initialization, the compiler will issue the call setlocale(LC_ALL, ""). If this call fails, the compiler will set its locale to the "C" locale. In general, this message is output because the locale-specific native environment has been set incorrectly.
User Action: The best way to determine why the compiler was unable to set the locale is to write a small program that contains the library call setlocale(LC_ALL, "") and then examine the return value from the call.

NLCHAR, An unexpected newline character is present in a character constant.

Description: An end of line was encountered during the scanning of a character constant.
User Action: Terminate the character constant with a closing single quote character before the end of line.

NLHEADER, A newline occurs inside of a header name.

Description: An end of line was encountered before the closing double quote or angle bracket of an #include directive.
User Action: Terminate the directive argument properly.

NLSTRING, An unexpected newline character is present in a string literal.

Description: An end of line was encountered during the scanning of a string literal.
User Action: Terminate the string constant with a closing double quote character before the end of line, or continue the line with a continuation character.

NOADD, context"expression1" and "expression2" cannot be added.

Description: Because of their types, the two expressions cannot be used as the operands of the addition operator. Either both operands must be arithmetic type, or one operand must be a pointer to an object type and the other must be an integral type.
User Action: Modify the addition to use valid types.

NOBIFDISABLE, The function "routine name" is a builtin function reserved to the compiler, and cannot be used with #pragma function. The function will continue to be treated as a builtin.

Description: A function identifier specified in a #pragma function directive is the name of a builtin function. These functions cannot be explicitly disabled, they are always handled as builtin functions.
User Action: Remove the inappropriate use of the pragma, and change the name of the function in order to have it treated as an ordinary callable function.

NOBITFIELD, context"expression" is a bitfield, but occurs in a context that precludes bitfields.

Description: An expression that must not be a bitfield was a bitfield. For example, the operand of the address-of operator must not be a bitfield.
User Action: Modify the expression so that its type is not a bitfield type.

NOCASEHERE, This case label occurs outside of any switch statement.

Description: A case label can only occur inside of a switch statement.
User Action: Remove the case label.

NOCDDHERE, CDD is not available on this platform. The #dictionary directive has been ignored.

Description: The #dictionary directive requires CDD to be present on the platform. This directive will only be recognized on OpenVMS systems.
User Action: Remove the directive.

NOCOLON, Missing ":".

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

NOCOLONINEXPR, Missing colon for conditional expression.

Description: A conditional expression that occurs as part of a preprocessing expression was missing the ":" that separates the second from the third operand. The value of the resulting expression is undefined.
User Action: Correct the conditional expression.

NOCOMMA, Missing ",".

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

NOCONDEXPR, Missing #if conditional expression.

Description: An argument was not supplied to an #if or #elif preprocessing directive. The missing argument will cause the compiler to consider these as FALSE conditionals.
User Action: Supply a valid argument to the directive.

NOCONVERT, context"expression" is of type "type", and cannot be converted to "target type".

Description: An expression of one type cannot be converted to the type required by this expression. This most often occurs when the source type of an assignment or cast cannot be converted to the destination type. The rules for which types can be converted are rather complicated and differ based upon the compiler mode. Refer to the language documentation for a complete list of valid combinations.
User Action: Modify the conversion to use valid types.

NOCONVERTCLS, context"expression" is of type "type", and cannot be converted to a different "type" type.

Description: A struct or union of one type cannot be converted to a different struct or union type.
User Action: Modify the conversion to use valid types.

NODCL, contextnothing is declared.

Description: The C standard requires that a declaration must declare at least a tag, an enumeration constant, or a declarator. This declaration contains none of these. This might not have been what you intended.
User Action: Correct or remove the declaration.

NODEFAULTHERE, This default label occurs outside of any switch statement.

Description: A case default label can only occur inside of a switch statement.
User Action: Remove the case default label.

NOENDIF, Missing #endif directive.

Description: The compiler encountered an #if, #ifdef, or #ifndef preprocessing directive without a matching #endif. This might not have been what you intended. The compiler will add the necessary #endif directive at the end of the compilation unit.
User Action: Make sure every #if, #ifdef and #ifndef has a matching #endif.

NOEQUAL, Missing "=".

Description: The compiler was expecting to see an "=" after the secondary_name specification of a #pragma weak or #pragma external_name directive. This message is only output on UNIX.
User Action: Correct the #pragma directive.

NOEQUALITY, context"expression1" and "expression2" cannot be compared for equality or inequality.

Description: Because of their types, the two expressions cannot be compared for equality or inequality. The rules for which types can be compared are rather complicated and differ based upon the compiler mode. Refer to the language documentation for a complete list of valid combinations.
User Action: Modify the comparison to use valid types. This can often be done by casting one of the expressions to the type of the other.

NOEXCEPTFLTR, context this exception handling call is not within an exception filter of a try block.

Description: The exception handling call must appear within an exception filter of a try statement block.
User Action: Either remove the exception handling call, or place it in a try statement block.

NOFBDAT, text does not contain feedback data

Description: The file indicated by the -feedback switch exists, but does not contain feedback data. This is probably an error on the users part, although it might be seen as part of the bootstrapping process.
User Action: Create a valid feedback file

NOFBFIL, Feedback file text does not exist

Description: The file specified after the -feedback option does not exist. This is normal during the bootstrapping process.
User Action: Either correct the spelling of the feedback option, or create the required feedback file.

NOFBOPT, Compilation will proceed without feedback optimizations

Description: A condition has occurred that has prevented the compiler from using feedback optimizations. This message is most often preceded by another message that will provide additional information.
User Action: Correct the condition that prevented the feedback optimizations.

NOFBRTN, Feedback inactive for text in this compilation

Description: Feedback information has gone stale for a particular routine (the source for the routine has changed). Feedback optimizations will not be applied to this routine.
User Action: Create a new feedback file

NOFIFILE, Cannot find include file filename specified on the command line.

Description: The header file name specified in the UNIX -FI command line option or the OpenVMS /FIRST_INCLUDE qualifier was not found using the search rules in effect for the quoted form of #include directives.
User Action: Either change the name of the file following the option or create the file.

NOFNTPDEFDECL, There is no identifier named "name" declared as a function or function typedef in this compilation unit.

Description: A #pragma assert and/or #pragma linkage directive(s) contains an identifier that is not declared as a function or function typedef in the compilation unit. This may not have been what you intented.
User Action: Remove the identifier from the #pragma assert and/or #pragma linkage, or declare it as a function or function typedef. empty string.

NOFORMALPARM, Missing formal parameter specifier.

Description: While processing the formal parameter list of a macro definition, the compiler encountered a missing formal parameter specifier. The macro will be be defined and this parameter 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.

NOFUNC, There is no function named name defined in this compilation unit.

Description: A function that appears in a #pragma weak and is not defined in the compilation unit.
User Action: Either define the function or remove the function name from the pragma.

NOFUNC1, There is no definition for the inline function named name in this compilation unit.

Description: A function that appears in a #pragma inline or #pragma noinline, or is declared with the __inline or __forceinline storage class modifier, is not defined in the compilation unit.
User Action: Either define the function or remove the function name from the pragma, or remove the storage class modifier or the function specifier from the declaration.

NOIDFOUND, contextan identifier was expected but not found.

Description: The compiler was expecting an identifier, but one was not found.
User Action: Correct the program syntax.

NOIDINPACKPOP, pragma pack pop directive has no identifier name which was found on the top of the pack stack.

Description: The #pragma pack (pop) directive has no identifier specified while the top element of the pack stack has one. Either this #pragma pack pop should have the identifier found on the stack, or this is an extra pragma pack pop, or the identifier should not be pushed by the corresponding #pragma pack push.
User Action: Check whether the pragma pack pop should have the identifier. Verify that there's no extra #pragma pack pop or #pragma member_alignment restore which popped the identifier to the top of the pack stack. Correct the directive(s).

NOINCLFILE, Cannot find file filename specified in #include directive.

Description: The specified include file does not exist.
User Action: Either change the name of the file in the #include preprocessing directive, or create the include file.

NOINCLFILEF, Cannot find file filename specified in #include directive.

Description: The specified include file does not exist.
User Action: Either change the name of the file in the #include preprocessing directive, or create the include file.

NOINCLUDEARG, #include directive missing argument.

Description: An argument was not supplied to an #include preprocessing directive. The directive will be ignored.
User Action: Supply a valid argument to the directive.

NOINIT, The type of variable does not permit initialization.

Description: This type cannot be initialized. Only objects and arrays of unknown size can be initialized.
User Action: Remove the initializer.

NOINLFUNC, There is no definition for the inline function named name in this compilation unit.

Description: A function is declared with an __inline or inline keyword and is not defined in the compilation unit.
User Action: Either define the function or remove the __inline or inline keyword from the declaration.

NOINLINEM, The main function cannot be inlined.

Description: The C99 standard prohibits the inline keyword from being used on the main function.
User Action: Remove the inline keyword.

NOINLINEREF, context "name" has internal linkage and is referenced from an an inline auxiliary function. This is a violation of the C99 Standard.

Description: A function declared with the inline keyword and without a declaration containing the keyword, extern, or without a declaration which lacks the inline keyword and the static keyword declares an auxiliary inline declaration. A definition of an auxiliary inline shall not contain a definition of a modifiable object with static storage duration, and shall not contain a reference to an identifier with internal linkage.
User Action: Remove the inline keyword from all declarations of the parent function, or if it is appropriate, change the declaration of the referenced item to a declaration which has something other than internal linkage.

NOINLINEST, In an inline auxiliary function, the modifiable object "name" is declared with static storage duration. This is a violation of the C99 standard.

Description: A function declared with the inline keyword and without a declaration containing the keyword, extern, or without a declaration which lacks the inline keyword and the static keyword declares an auxiliary inline declaration. A definition of an auxiliary inline shall not contain a definition of a modifiable object with static storage duration, and shall not contain a reference to an identifier with internal linkage.
User Action: Remove the inline keyword from all declarations of the parent function, or if it is appropriate, add the const keyword to the declaration to create an non-modifiable object.

NOLEAVETARG, This leave statement is not within a try statement.

Description: The exception handling statement leave must appear within a try statement block.
User Action: Either remove the leave statement, or place it in a try statement block.

NOLEFTOPERND, Token pasting operator missing left operand.

Description: The preprocessing token pasting operator "##" appears in a macro body without the preceeding token argument.
User Action: Either remove the operator or supply it with two tokens that will be pasted together.

NOLINKAGE, context"name" has no linkage and has a prior declaration in this scope at where.

Description: A declaration within a function body redeclares an identifier declared earlier in the current scope, and both declarations did not have the extern storage class.
User Action: Either remove the extra declarations, or have all declarations for the identifier use the extern storage class.

NOLONGLONG, context64-bit integral types are not supported on this platform.

Description: 64-bit integer types are not supported on the VAX platform.
User Action: Change the type to an integer type that is supported on VAX, or compile the application on a platform that does support 64-bit integers.

NOMACRONAME, #define directive is missing macro name identifier.

Description: The #define preprocessing directive was not supplied with an argument. The directive should be followed with an identifier that specifies the macro name to be defined. The directive will be ignored.
User Action: Supply a valid argument to the preprocessing directive.

NOMAINUFLO, No main function encountered within module. /IEEE_MODE=UNDERFLOW_TO_ZERO is ignored.

Description: Use of the /IEEE_MODE=UNDERFLOW_TO_ZERO is only meaningful for compilation units that contain a main program. The compiler will ignore the qualifier.
User Action: Remove the qualifier from the command line.

NONAMEMEMBERS, contexta struct or union has no named members. This is undefined behavior according to the C standard.

Description: The C standard requires that a struct or union contain at least one named member. Because this struct/union contains no named members, it does not conform to the C standard and might not be portable.
User Action: Make sure at least one member has a name.

NONATOMIC, Unable to generate code for atomic access

NONEWTYPE, The type "type" is being declared as part of context. C++ does not permit a new type to be declared in this context. Fix.

Description: C++ does not allow types to be declared in certain contexts that are valid in C. One example is the declaration of a type within a function prototype.
User Action: Declare the type before its use.

NONGRNACC, Unable to generate code for requested granularity

Description: The compiler has generated a call a routine that performs longword operations on some data that is requested to be accessed with byte granularity. Because of this, the requested granularity will not be met for this data access. This routine may be generated for a memory copy routine (such as memcpy). The call can also be generated for certain struct assignments.
User Action: If the data must be accessed with byte granularity then write your own routine that does the required action using byte objects. If byte granularity is not needed at this point, the message can be ignored.

NONLBEFOREEOF, File does not end in unescaped newline.

Description: The final character of a file was not a newline character. This could indicate that the file has been corrupted. The compiler will insert a newline character at this point in the input stream.
User Action: Update the source file so that it ends with a newline.

NONMULTALIGN, The size of this structure is size bytes, which is not a multiple of its alignment of align. Respecify the alignment of the structure or add bytes bytes of additional padding.

Description: The size of a struct or union is not a multiple of its alignment. This could cause unaligned accesses if an array of these structs or unions is declared.
User Action: Modify the struct/union or the alignment so that the size of the struct or union is a multiple of the alignment.

NONOCTAL, An octal constant contains non-octal digits.

Description: An octal constant contains a non-octal digit. The compiler will convert this non-octal digit to its corresponding octal value and use that value instead. For example, 0190 will be converted to 0210 (decimal 136) as the non-octal digit 9 is converted to the octal 11.
User Action: Correct the octal constant to use only octal digits.

NONPORTDEFINED, "defined" is treated as an identifier here, not an operator.

Description: For compatibility with older C compilers, in certain modes the compiler will treat #ifdef defined(foo) as #ifdef defined, and #ifndef defined(foo) as #ifndef defined. This might not have been what you intended.
User Action: Do not mix #ifdef/#ifndef with the defined operator.

NONPORTLINEDIR, Non-standard #line directive.

Description: Accepting the line directive without the "line" preprocessing keyword is an extension of Compaq C. The program does not conform to the C standard, and might not be accepted by other compilers.
User Action: Add the "line" preprocessing keyword to the directive.

NONSTANDCAST, context"expression" of type "type", is being converted to "target type". Such a cast is not permitted by the standard.

Description: The standard only permits casts from a pointer to an object incomplete type to another pointer to an object or incomplete type, or from a pointer to function type to another pointer to function type. Note that void is considered an incomplete type, so casts between pointer to void and pointer to function types are not permitted by the C standard.
User Action: Be aware of this difference if you plan to port this source to another compiler.

NONULINIT, context, there is no room for the terminating '\0'. Standard C allows this, but C++ does not.

Description: This declaration initializes an object to a strict literal. Although the object is large enough to hold the characters in the literal, it is not large enough to hold the terminating null character. This might not have been what you intended. This practice is also not valid in C++.
User Action: Increase the size of the object, or reduce the size of the initializer.

NOOPERAND, Stringization operator missing operand.

Description: The preprocessing stringization operator "#" appears in a macro body without a token argument after the operator.
User Action: Either remove the operator or supply it with a token that will be stringized.

NOOPERANDS, Token pasting operator missing both operands.

Description: The preprocessing token pasting operator "##" appears in a macro body without either the preceeding or following token arguments.
User Action: Either remove the operator or supply it with two tokens that will be pasted together.

NOPARENARGLST, Missing right parenthesis for macro argument list.

Description: A macro invocation's argument list did not end in a right parenthesis.
User Action: Correct the program syntax.

NOPARM, This declaration does not declare a parameter.

Description: The parameter declaration list of an old-style function definition included a type but no parameter identifier.
User Action: Replace the old-style function definition with the recommended prototype-format declaration. If this is not possible, include the correct identifier after the parameter type.

NOPARMLIST, The declaration of function has an empty parameter list. If the function has parameters, they should be declared here; if it has no parameters, "void" should be specified in the parameter list.

Description: The recommended way to declare a function that takes no parameters is to use "void" in the parameter list.
User Action: Make the recommended change.

NOPRAGARG, No argument for #pragma pragma was found. Pragma is ignored.

Description: A #pragma directive was not followed by one of the expected arguments. The directive will be ignored.
User Action: Supply all required arguments to the directive.

NOPSECT, Missing psect name.

Description: The psect specifier in a globaldef declaration must be a string constant.
User Action: Either make the psect a string constant or remove the psect specifier.

NOREGAVAIL, Unable to satisfy program register allocation requirements.

Description: The compiler is unable to allocate all the registers requested by the program. This most often happens when asm directives require too many registers.
User Action: Rework the asm directives so they use fewer registers

NORELATIONAL, context"expression1" and "expression2" cannot be compared with a relational operator.

Description: Because of their types, the two expressions cannot be used as the operands of a relational operator. The rules for which types can be used in a relational are rather complicated and differ based upon the compiler mode. Refer to the language documentation for a complete list of valid combinations.
User Action: Modify the relational to use valid types. This can often be done by casting one of the expressions to the type of the other.

NORETNONVOID, noreturn assertion of #pragma assert directive can't be specified for non-void function.

Description: noreturn assertion was specified in #pragma assert directive for non-void function; the noreturn assertion will be ignored.
User Action: Either remove noreturn assertion from the directive, or change return type for the function to void.

NORETURNVAL, The function "name" returns a value, but no value is given in this return statement.

Description: A function that returns a value contains a return statement that is missing a return value. Therefore, the returned value will be undefined. This might not have been what you intended.
User Action: Supply a return value for the return statement.

NORETURNVAL1, The function "name" has an implicit return type of int, but no value is given in this return statement.

Description: A function that has an implicit return type of int contains a return statement that is missing a return value. Therefore, the returned value will be undefined. This might not have been what you intended.
User Action: Supply a return value for the return statement or define the function with a void return type.

NORETVAL, routine text does not return a value

NORGHTPAREN, No right parenthesis for parameter list.

Description: A macro definition's formal parameter list did not end in a right parenthesis. A right parenthesis has been assumed.
User Action: End the formal parameter list with a right parenthesis.

NORIGHTOPERND, Token pasting operator missing right operand.

Description: The preprocessing token pasting operator "##" appears in a macro body without a token argument after the operator.
User Action: Either remove the operator or supply it with two tokens that will be pasted together.

NORIGHTPAREN, Missing ")".

Description: A right parenthesis was expected at this point in the program, but none was found.
User Action: Correct the program syntax.

NOSEHHAND, Missing exception handler.

Description: The __builtin_try clause must specify an exception handler of either __builtin_finally or __builtin_except. This message is only generated on UNIX systems.
User Action: Correct the __builtin_try clause.

NOSEMI, Missing ";".

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

NOSEMI1, Missing ";". 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: The compiler was expecting a semicolon, but one was not found. This condition may have been caused missing close brace. This message is followed by some number of additional messages that attempt to identify the bad open brace.
User Action: Correct the program syntax.

NOSEMISTRUCT, Missing ";" after last structure or union member.

Description: Accepting a struct/union type without a semicolon after the last member specifier is a language extension of Compaq C provided for compatiblity with older C compilers. This syntax is not valid in standard C, and may not be accepted by other C compilers.
User Action: Add the semicolon at the end of the last member.

NOSFILE, Cannot create .s file: overlapping static storage initializations at Psect text + number

Description: When producing an output assembly file, the compiler back-end as detected a case where the same storage location has been initialized to more than one value. This can occur when inter-file optimization has been enabled.
User Action: Remove one of the initializers.

NOSHAREEXT, noshare is a language extension.

Description: The noshare 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 t

HP OpenVMS Systems

Compaq CUser's Guide for OpenVMS Systems

Compaq C
User's Guide for OpenVMS Systems