 |
HP C
HP C
User's Guide for OpenVMS Systems
Appendix D
HP C Compiler Messages
This appendix lists the HP C compiler diagnostic messages.
For each message, this appendix gives the mnemonic and the message
text, an explanation of the message, and suggested actions to be taken
to avoid the message. For more information about the format of compiler
diagnostic messages, see Section 1.3.5.
To display a particular compiler message online, enter the following
command:
$ HELP CC MESSAGE mnemonic[Return] (ALPHA, I64)
$ HELP CC/DECC MESSAGE mnemonic[Return] (VAX ONLY)
|
To display a list of all compiler message mnemonics, enter the
following command:
$ HELP CC MESSAGE[Return] (ALPHA, I64)
$ HELP CC/DECC MESSAGE[Return] (VAX ONLY)
|
Some messages substitute information from the program into the message
text. In this appendix, the portion of the text to be substituted is
shown in italics.
Often, the same message is issued in different contexts within a
program. In this appendix, the message context is indicated by the
italicized word context within the message. The actual message
issued by the compiler will contain one of the following phrases
substituted for context:
- In this declaration,
- In the initializer for
- In the declaration of "name",
- In the definition of the function "name",
- In the declaration of an unnamed object,
- In this statement,
You can control the messages issued with the /[NO]WARNINGS command-line
qualifier ( Section 1.3.4) and the
#pragma message
preprocessor directive ( Section 5.4.14).
DECDEC, In this declaration,
DECINITVR, In the initializer for
DECNAMDEC, In the declaration of "name",
DECNAMFUNDEF, In the definition of the function "name",
DECUNDEC, In the declaration of an unnamed object,
PASSTA, In this statement,
ABSTRACTDCL, Invalid abstract declarator.
Description: An identifier was encountered in an
abstract declarator. An abstract declarator is used to specify a type
only and must not contain an identifier that specifies a declarator.
User Action: Correct the abstract declarator.
ADDRARRAY, context& before array "expression" is
ignored.
Description: In certain modes, HP C will ignore an
address-of operator used on an entire array. This is for compatibility
with other compilers that have this behavior.
User Action: Remove the address-of operator.
ADDRCONSTEXT, context"name" does not have a constant
address, but occurs in a context that requires an address constant.
This is an extension of the language.
Description: The C89 standard requires that an
initializer for a pointer-type member of an automatic aggregate or
union-type object have an initializer that is an address constant.
Other C compilers might not successfully compile a program that uses
this extension.
User Action: Be aware of this if you wish to port the
program.
ADDRESSOFVOID, contexttaking the address of a void type is a
language extension.
Description: The HP C compiler will allow taking the
address of a void type for compatibility with other compilers. This is
an extension to the standard. Other compilers may reject this.
User Action: Be aware of this if you plan to port this
source to another compiler.
ADDRSUBCONST, contextaccepting the expression "expr"
as a constant is a language extension.
Description: In many cases HP C accepts the
subtraction of two addresses within the same array or struct/union as a
constant. The C standard does not consider such an expression to be a
constant. Therefore, this program does not conform to the standard and
may be rejected by other compilers.
User Action: Change the expression to be a constant.
ALIGNCONFLICT, contextthe address "expr" has
alignment of align which is less than the alignment
requirements of the destination pointer. Dereferencing the destination
pointer may cause an alignment fault.
Description: The compiler has detected a situation
where a pointer to an aligned data type is being assigned an address
that may not be properly aligned. A later dereference of this pointer
could cause an alignment fault.
User Action: There are a number of possible actions.
The best is to correct the condition that is causing the source to have
the wrong alignment, as access to an unaligned data structure involves
additional run-time overhead. Other options would be to modify the
declaration of the destination pointer such that its referenced type
has the __unaligned type qualifier, or use the compiler option that
tells the compiler to assume all pointer references are unaligned. It
is also possible to cast the source to the destination type to silence
this message. However, that solution will not correct any unaligned
access.
ALIGNCONFLICT1, contextthe address "expr" has
alignment of align which is less than the alignment
requirements of the pointer type it is cast to. Dereferencing the
resulting pointer may cause an alignment fault.
Description: The compiler has detected a situation
where an address is being cast to a pointer type with a greater
alignment requirement than the type of the address expression implies.
A later dereference of this pointer type value could cause an alignment
fault.
User Action: There are a number of possible actions.
The best is to correct the condition that is causing the source to have
the wrong alignment, as access to an unaligned data structure involves
additional run-time overhead. Other options would be to change the type
of the pointer used in the cast such that its referenced type has the
__unaligned type qualifier, or use the compiler option that tells the
compiler to assume all pointer references are unaligned. It is also
possible to cast the address expression to (void *) before casting it
to the specified type to silence this message. However, that solution
will not correct any unaligned access.
ALIGNCONST, Integer constant alignment number is not
necessarily supported on all platforms.
Description: Although the specified alignment value is
valid on this system, it might not be valid on other systems. For
example, 16 is a valid alignment value on Alpha systems but would not
be valid on VAX systems.
User Action: Be aware of this potential portability
issue.
ALIGNEXT, _align is a language extension.
Description: The _align storage class modifier is a
language extension of HP C. Other C compilers might not successfully
compile a program that uses the extension.
User Action: Be aware of this extension if you wish to
port the code.
ALIGNPOP, This "restore" has underflowed the member alignment's stack.
No corresponding "save" was found.
Description: The member_alignment stack, managed by
the #pragma member_alignment and #pragma environment directives,
contains more restores than saves. This could signify a coding or logic
error in the program.
User Action: Make sure each restore has a
corresponding save.
ALREADYTLS, The identifier "name" has already appeared in an
omp threadprivate directive.
Description: The same identifier appears more than
once in a single omp threadprivate directive, or appears in more than
one omp threadprivate clause.
User Action: Remove the duplicate identifiers
ANSIALIASCAST, contexta pointer to type1 is being
cast to a pointer to type2. Using ANSI aliasing rules, the
compiler may subsequently assume that the two pointer types are
pointing to different storage locations.
Description: The C standard allows a compiler to
assume that these two pointer types will point to different storage
locations. The compiler will make this assumption whenever ansi
aliasing is enabled on the command line, either directly or via another
switch. The cast in itself does not violate aliasing rules, e.g. you
might cast the pointer value back to an allowed type before you use it
to access memory. But the compiler cannot generally determine whether
or not you do that. If your code accesses the memory designated by this
pointer value using both of these pointer types, you may get unexpected
results when ansi aliasing is enabled.
User Action: Casting through pointer to void will
silence this message. But if the end result is that the same memory
still gets accessed through different types that are not permitted
under the aliasing rules, you may still get unexpected results. If
compiling without ansi aliasing corrects the behavior of your program,
your code almost certainly violates the aliasing rules in a way that
the compiler cannot detect.
ARGADDR, contexttaking the address of the constant expression
"expression" in an argument list is a language extension.
Description: The HP C compiler will allow the address
of a constant to be passed as an argument to a function call. This is
an extension to standard C. Other C compilers might not successfully
compile a program that uses this extension.
User Action: Assign the constant to a variable, and
pass the address of the variable.
ARGLISGTR255, contextthe function call specifies an argument
list whose length exceeds maximum specified by the calling standard.
Any use of va_count by the called function will be wrong.
Description: The OpenVMS calling standard uses a
byte-sized field to specify the size of the argument list. The argument
list to this function call requires more storage than can be
represented in this size. As a result, any use of va_count in the
called function will return inaccurate information.
User Action: Either reduce the size of the argument
list, or do not use va_count in the called function.
ARGSIZE, context the argument being passed to this function is
too small.
Description: A function parameter of array type has
been declared with the keyword "static" in its outermost bound to
indicate that the function may generate code that assumes that when it
is called the actual argument will have at least as many elements as
specified in the parameter declaration. The argument provided in this
call has fewer array elements than specified in the parameter
declaration with static bound.
User Action: Check the size of the argument passed to
the function and/or modify or remove the static bound on the function
parameter.
ARRAYBRACE, context a required set of braces is missing.
Description: The initializer for this array was not
enclosed in braces. While some compilers allow this, standard C
requires braces around the initializer.
User Action: Enclose the initializer in braces.
ARRAYLIMITSUP, contextHP C provides only limited support for
array types larger than n bytes.
Description: This array type is larger than can be
represented by size_t. While HP C will allow a type declared to be this
size, uses of the type are not fully supported and may cause
unpredictable behavior.
User Action: Reduce the size of the array type. It may
be possible to use a pointer type instead of a large array. The storage
can still be accessed using array syntax.
ARRAYOVERFLOW, Integer overflow occurred when computing the size of an
array type.
Description: An array type is larger than allowed on
this platform.
User Action: Reduce the size of the array type. It may
be possible to use a pointer type instead of a large array. The storage
can still be accessed using array syntax.
ARRNOTLVALUE, contextaccepting a non-lvalue array in a
subscript operator is an extension to the C89 standard.
Description: The C89 standard states that one of the
operands to the subscript operator must be a pointer. However, the
array used in this operator could not be converted to a pointer because
it is not an lvalue. Therefore this code does not conform to the C89
standard and may not be accepted by other compilers. Note that the C99
standard allows this because all arrays are converted to pointers, not
just lvalue arrays.
User Action: Be aware of this difference if you plan
to port this source to another compiler.
ASMCOMEXP, Comma expected while processing text instruction
Description: The asm directive parser was expecting a
comma, but one was not found.
User Action: Correct the asm directive.
ASMENDEXP, Semicolon or asm end expected while processing text
instruction
Description: The asm directive parser was expecting a
semicolon to end an instruction, but one was not found.
User Action: Correct the asm directive.
ASMFIMMDOTS, Floating point load-immediate instructions require a .s
file
Description: Using a floating point load immediate
instruction in this asm directive will require the compiler to produce
an .s file and invoke the assembler to process this source.
User Action: Do not use floating point load immediate
instructions in asm directives.
ASMFREGEXP, Float register expected while processing text
instruction
Description: The asm directive parser was expecting a
valid floating register, but one was not found.
User Action: Correct the asm directive.
ASMHINTDOTS, Hint on text instruction requires a .s file
Description: Using a hint in a transfer instruction in
this asm directive will require the compiler to produce an .s file and
invoke the assembler to process this source.
User Action: Do not use hints in asm directives.
ASMICONEXP, Integer constant expected while processing text
instruction
Description: The asm directive parser was expecting a
valid integer constant, but one was not found.
User Action: Correct the asm directive.
ASMIDEXP, Identifier expected while processing text instruction
Description: The asm directive parser was expecting an
identifier, but one was not found.
User Action: Correct the asm directive.
ASMINSTEXP, Instruction mnemonic expected (found text)
Description: The asm directive parser was expecting an
instruction mnemonic, but one was not found.
User Action: Correct the asm directive.
ASMLABEXP, Label expected while processing text instruction
Description: The asm directive parser was expecting a
label, but one was not found.
User Action: Correct the asm directive.
ASMLABMULDEF, Multiple definitions of label in asm (text)
Description: The asm directive parser has detected the
same label defined more than once.
User Action: Change one of the label names.
ASMLABUNDEF, Reference to undefined label in asm (text)
Description: The asm directive parser has detected a
reference to an undefined label.
User Action: Correct the asm directive.
ASMLDGPDOTS, Unusual ldgp requires a .s file
Description: This indicates that a ldgp
pseudo-instruction was encountered in an unusual place or with unusual
arguments. The assembler will be invoked on the .s file.
User Action: Correct the asm directive.
ASMLPAREXP, Left paren expected while processing text
instruction
Description: The asm directive parser was expecting a
left paren, but one was not found.
User Action: Correct the asm directive.
ASMNOTAVAIL, In-line assembly code directive name is not
available on this platform.
Description: In-line assembly code is not available on
the IA64 platform.
User Action: See documentation for alternatives.
ASMNOTINST, text instruction is not supported in asms on
text
Description: The asm directive parser does not
recognizes a pseudo-opcode on this platform.
User Action: Correct the asm directive.
ASMNOTREG, text is not a register name on text
Description: The asm directive parser has noticed that
a special register used in the directive is not valid on this platform.
User Action: Correct the asm directive.
ASMNOTSUP, Support for text (text) in asms is not
implemented on text
Description: The asm directive parser does not support
the feature in question on this platform.
User Action: Rewrite the asm so that the feature is
not used.
ASMPALTRUNC, PALcode function has been truncated to number
Description: The asm directive call_pal instruction is
followed by an integer beyond the range of call_pal values expected by
the compiler.
User Action: Use a valid call_pal argument.
ASMRAWREG, text uses text before it is defined
Description: The asm directive parser has noticed that
an instruction uses a register as a source before it is given a value.
User Action: Correct the asm directive.
ASMREGEXP, Fixed register expected while processing text
instruction
Description: The asm directive parser was expecting a
valid integer register, but one was not found.
User Action: Correct the asm directive.
ASMREGOVRLAPSC, Destination register overlaps input for text
(software completion) instruction
Description: An asm directive contains an instruction
that may require a software completion routine in case of a runtime
exception. Such an instruction requires that the result register be
different than any input register.
User Action: Modify the asm so that the destination
register is different than the sources.
ASMRPAREXP, Right paren expected while processing text
instruction
Description: The asm directive parser was expecting a
right paren, but one was not found.
User Action: Correct the asm directive.
ASMSYMDOTS, Use of symbolic addresses with text instruction
requires a .s file
Description: Using a symbolic operand in this asm
directive will require the compiler to produce an .s file and invoke
the assembler to process this source.
User Action: Do not use symbolic operands in asm
directives.
ASMUNKNOWNARCH, Unknown architecture (text) specified in
text assembler directive
Description: The asm directive parser has detected an
unexpected argument to a .tune or .arch directive.
User Action: Correct the asm directive.
ASMUNKSETOPT, Unsupported or illegal .set option (text)
Description: The asm directive parser has detected an
unexpected argument to a .set directive.
User Action: Correct the asm directive.
ASSERTFAIL, The assertion "assertion" was not true,
reason.
Description: The expression in a #pragma assert
non_zero(expression) directive was found to be zero.
User Action: Correct the condition that caused the
expression to be zero.
ASSERTION, text
Description: This message is emitted by the code
generator. It should never be output when compiling a C program.
User Action: Please submit a problem report if you
encounter this message when compiling a C program.
ASSIGNEXT, contextrelaxed struct or union type compatibility
is a language extension.
Description: In certain modes, the compiler will allow
assignments or comparisons between structs or unions of different types
if their sizes are the same. This is an extension to standard C. Other
C compilers might not successfully compile a program that uses this
extension.
User Action: Recode the operation to use one of the
memxxx run-time library functions.
ASSUMEONEELEM, The type of the tentatively-defined array
"name" is incomplete at the end of the compilation unit. The
compiler will assume one array element.
Description: The C standard requires that the type of
all tentative definitions must be completed before the end of the
compilation unit. For compatibility with some other C compilers, HP C
will give the array one element.
User Action: Complete the type.
AUTOEXTERNAL, contexta storage class of "auto" or "register"
is illegal at file scope.
Description: The storage classes auto and register can
only be used in a declaration that appears inside a function. They
cannot be used in a declaration at file scope.
User Action: Remove the storage class specifier or
move the declaration inside a function body.
BADALIAS, Reference through restricted pointer text uses a
pointer value based on different restricted pointer, text
Description: The C language requires that restricted
pointers always point to different storage. The compiler has detected a
case where an access using a restricted pointer is referencing memory
pointed to a different restricted pointer. This may cause unexpected
behavior.
User Action: Make sure restricted pointers point at
unique storage.
BADALIGN, Invalid alignment boundary.
Description: The _align storage class modifier was
given an invalid value. See documentation for valid values on each
platform.
User Action: Supply a correct value or remove the
_align storage class modifier.
BADANSIALIAS, This statement accesses an object frag1. The
statement at loc accesses the same storage location
frag2.
Description: The standard allows a compiler to assume
that since these two statements use different types, these two
statements reference different storage locations. The HP C compiler
does so whenever ansi aliasing is enabled. Since your code relies on
these two statements accessing the same storage location you should
disable ansi aliasing. If you do not do so, optimization may cause your
program to behave unexpectedly.
User Action: Specify noansi_alias on the command line.
BADBOUNDCHK, contextpointer arithmetic was performed more than
once in computing an array element. The bounds checking code output by
the compiler will only verify the "expr" expression.
Description: When an array is accessed using pointer
arithmetic and run-time array bounds checking is enabled, the HP C
compiler is only able to output the checking code for the first pointer
arithmetic operation performed on the array. This can result in an
incorrect check if the resulting pointer value is again operated on by
pointer arithmetic. Consider the expression a = b + c - d; where a is a
pointer, b an array, and c and d integers. When bounds checking is
enabled the compiler will output a check to verify that c within the
bounds of the array. This will lead to an incorrect runtime trap in
cases where c is outside the bounds of the array and c - d is not.
User Action: Recode the pointer expression so that the
integer part is in parenthesis. This way the expression will contain
only one pointer arithmetic operation. In the earlier example the
expression would be changed to a = b + (c - d);
BADBOUNDS, contextthe array bounds are incorrectly specified.
Description: A multi-dimensional array declaration
contains a missing dimension specifier in a dimension other than the
first.
User Action: Correct the declaration.
BADBREAK, This break statement is not within a for, while, do, or
switch statement.
Description: A break statement can only appear inside
a for, while, do, or switch statement.
User Action: Remove the break statement, or replace it
with a goto statement.
BADC99PRAGOP, Invalid syntax for the C99 _Pragma operator, its operands
cannot be recognized.
Description: After macro expansion and whitespace has
been removed, the C99 _Pragma keyword must be followed by exactly three
tokens: left-parenthesis, string-literal (or wide-string),
right-parenthesis. Any other sequence cannot be processed, and will
likely produce other spurious compile-time diagnostics.
User Action: Correct the syntax, or compile in a
language mode that does not recognize the C99_Pragma operator (e.g. if
your code has used this reserved identifier for some other purpose).
BADCHARSINHDR, Illegal characters after header name.
Description: While processing an #include directive
whose argument did not start with either a '<' or '"' character, the
compiler encountered a character it did not expect. This most often
occurs when the directive argument is a macro and there is an error
during the expansion of that macro.
User Action: Correct the argument to the #include
directive.
BADCMMNTPSTNG, Token concatenation with comments might not be
portable---use ## operator.
Description: A macro body contains a comment between
two tokens with no white space either before or after the comment.
Older C compilers allowed this as a form of token pasting. This type of
token pasting might not give the desired results with newer compilers.
User Action: Use the standard C form of token pasting
by replacing the comment with the ## token pasting operator.
BADCOMLITTYPE, contextthe type "type" cannot be used
to specify the type of a compound literal.
Description: The type of a compound literal must be an
object type or an array of unknown size.
User Action: Use a valid type.
BADCOMPLEXTYPE, context"spelling" is an invalid
complex type specifier.
Description: The valid complex type specifiers are
float _Complex, double _Complex, and long double _Complex.
User Action: Use on of the valid complex type
specifiers.
BADCONDIT, contexta common type could not be determined for
the 2nd and 3rd operands ("true expression" and "false
expression") of a conditional operator.
Description: The types of the second and third
operands of the conditional operator must conform to a set of rules
that define what the type of the result of the conditional operator
itself will be. If the types of these operands do not conform to those
rules, the compiler cannot determine the type of the result, which is
an error. Refer to the language documentation for a complete list of
valid combinations of types for the second and third operands of the
conditional operator.
User Action: Modify the conditional expression so that
the types of the second and third operands conform to the language
rules.
BADCONSTEXPR, Syntax error in constant expression.
Description: A preprocessing constant expression
contained a syntax error. The preprocessor was expecting to find a
constant value or a left parenthesis. The preprocessor will assume a
value of zero was encountered.
User Action: Correct the preprocessing constant
expression.
BADCONTINUE, This continue statement is not within a for, while, or do
statement.
Description: A continue statement can only appear
inside a for, while, or do statement.
User Action: Remove the continue statement, or replace
it with a goto statement.
BADCONVSPEC, contextthis argument to function name
contains a bad conversion specification "incorrect conversion"
that will cause unpredictable behavior.
Description: The compiler has detected an illformed
conversion specification (flags, width, precision, length modifier) or
an unknown conversion specifier (not diouxefgcspn...) that will cause
unpredictable behavior. This might not have been what you intended.
User Action: Review the documentation for this
function and modify the conversion specification as appropriate.
BADDCL, The name "name" cannot be undefined.
Description: The code has tried to #undef a macro that
is predefined by the C standard. This is not allowed. The #undef will
be ignored.
User Action: Remove the #undef directive.
BADDECLSPEC, Invalid argument to __declspec. Valid arguments are
"thread" or "__thread".
Description: The only valid arguments to the
__declspec storage class modifier are "thread" or "__thread".
User Action: Either use one of the valid arguments, or
remove the storage class modifier.
BADDEFARG, Bad argument for "defined" operator.
Description: The defined preprocessing operator was
given an invalid argument. The operator expects an identifier
optionally enclosed in parenthesis. The value of the operator is
undefined.
User Action: Supply a valid argument to the
preprocessing operator.
BADENUM, Invalid enumerator.
Description: While processing an enumerator list, the
compiler was expecting to encounter an identifier, but it found
something else instead.
User Action: Correct the program syntax.
BADENUMREDECL, contextthe enum "tag" cannot be given
a type other than signed int because the tag was declared earlier at
where.
Description: This enum tag would normally be given a
type other than signed int because the enumeration constants used in
the declaration exceed the range of signed int. The compiler cannot use
the extended type because the enum tag was declared earlier, and given
signed int type at that point.
User Action: Remove the earlier tag declaration.
BADEXPR, Invalid expression.
Description: An invalid expression was encountered.
User Action: Correct the program syntax.
BADFATCOMMENT, The compiler cannot recover.
Description: In certain cases, the compiler cannot
proceed after an unterminated comment. In these cases this message will
be issued. Note that this message is always output after the
opencomment error has been output.
User Action: Terminate the comment before the
end-of-file.
BADFBDAT, text contains invalid feedback data
Description: A feedback file contains data, but it was
corrupt and could not be used.
User Action: Create a new feedback file.
BADFBFILE, Invalid feedback file: text
Description: The compiler was unable to read
information from the specified feedback file.
User Action: Make sure the feedback file contains
valid feedback information.
BADFBTYP, Unexpected file type for feedback file text
Description: The file specified in the -feedback
option does not have the file type expected by the compiler.
User Action: Use a valid feedback file.
BADFLOATTYPE, contextthis floating point type "type"
is not supported on this platform.
Description: The IEEE floating types __s_float and
__t_float are not supported on the VAX platform.
User Action: Change the type to a floating type that
is supported on VAX, or compile the application on a platform that does
support IEEE floating.
BADFORMALPARM, This token may not appear in a formal parameter list.
Description: While processing the formal parameter
list of a macro definition, the compiler encountered an invalid formal
parameter specifier. The macro will be be defined and this token will
ignored, but that may not have been what you intended.
User Action: Correct the formal parameter list so that
it consists of a comma separated list of identifiers.
BADFORSTOCLS, The declaration in a for loop can only have storage class
auto or register.
Description: The declaration in a for loop contains a
storage class specifier other than auto or register. This is not
allowed.
User Action: Correct the storage class.
BADFUNCSTOCLS, The storage class of function name cannot be
storage_class. This storage class has been changed to 'extern'.
Description: The globalref storage class cannot be
used with a function declaration. The compiler will use the storage
class extern.
User Action: Remove the globalref storage class from
the function declaration.
BADGLOBALTYPE, This declaration has type "type", which is
invalid for a globalvalue. The extern_model strict_refdef will be used
instead.
Description: An object with globalvalue storage class
can only have a type of integer, enum, or pointer type. In other cases,
the compiler will change the storage class from globalvalue to
strict_refdef.
User Action: Change the data type to be one that is
valid for a globalvalue.
BADHEADERNM, Invalid include file or header name specification.
Description: An #include directive was not followed by
a valid argument. The directive will be ignored. The #include directive
should be followed by either a file specification enclosed in angle
brackets, a file specification enclosed in quotes, or an identifier
that specifies a text module (OpenVMS only), or a macro to be expanded.
User Action: Supply a valid argument to the #include
directive.
BADHEXCONST, Hex constant value too large.
Description: A hex constant used in a preprocessor
directive is too large. The value of the constant will be undefined.
User Action: Decrease the value of the constant.
BADIDENTUCN, Invalid UCN encountered in an identifier.
Description: An identifier contained a Universal
Character Name (UCN) that did not conform to the requirements of C99
Annex D for use of UCNs in identifiers.
User Action: Specify a valid UCN sequence.
BADIFDEF, An #ifdef or #ifndef is not followed by an identifier.
Description: An #ifdef or #ifndef preprocessing
directive was not followed by an identifier. The compiler will consider
the preprocessor argument to be an identifier that is not defined.
Therefore, in these cases an #ifdef will always be FALSE, and an
#ifndef will always be TRUE.
User Action: Supply a valid identifier to the
directive.
BADIFNDEFARG, #ifndef argument is not an identifier.
Description: An #ifndef preprocessing directive was
not followed by an identifier. The compiler will consider this to be a
TRUE condition.
User Action: Supply a valid identifier to the
directive.
BADINCLDIR, The #pragma include_directory must not appear after an
#include directive or in a /FIRST_INCLUDE file after the first
/FIRST_INCLUDE file has been processed. The directive will be ignored.
Description: There are several restrictions on the
placement of the #pragma include_directory directive. It must not
appear after any #include directive has been encountered. Also, if
/FIRST_INCLUDE is specified on the command line, all #pragma
include_directory directives must be placed in the first file in the
/FIRST_INCLUDE list (if there is more than one in the list) or in the
the main source before any #include directives (if there is only one
file in the /FIRST_INCLUDE list).
User Action: Place the directive in a valid location.
BADINCLDIRSIZE, The include_directory string length must be at least
one and must be less than max. The directive will be ignored.
Description: The #pragma include_directory directive
does not support an empty string argument. Also the directory must not
exceed the longest directory specification supported on this platform.
User Action: Specify a valid length string.
BADINCLUDE, An #include directive has illegal syntax.
Description: An #include directive was not followed by
a valid argument. This message occurs when the argument starts with a
'<' or '"' character, but does not end with a matching delimiter. In
this case the compiler will add the matching delimiter to the end of
the argument and process the directive normally.
User Action: Correct the argument to the #include
directive.
BADLINEDIR, Missing argument for #line directive.
Description: An argument was not supplied to a #line
preprocessing directive. This directive must be followed by a digit
sequence that specifies the line number or a macro that expands to a
digit sequence. The directive will be ignored.
User Action: Supply a valid argument to the directive.
BADLINEDIRTV, Illegal token in #line directive.
Description: A #line directive was followed by an
invalid argument. The #line directive should be followed by either a
digit sequence or a digit sequence followed by a string literal. The
#line directive will be ignored.
User Action: Supply a valid argument to the #line
directive.
BADLINKREG, Invalid register "register" for linkage pragma.
Pragma is ignored.
Description: The compiler encountered bad register
specifier in a #pragma linkage directive. The message should point at
the offending specifier. The compiler will ignore the entire pragma.
User Action: Correct the directive.
BADLINNUM, Ignoring the line number for the #line directive---too small.
Description: A #line preprocessing directive specified
a line value that is either zero or less than zero. This is not valid.
The directive will be ignored.
User Action: Either remove the directive or supply a
positive value to the line specifier.
BADLOCALE, The compiler could not set its locale to either the
locale-specific native environment or the "C" locale.
Description: During start-up, the compiler was unable
to set its locale. As part of its initialization, the compiler will
issue the call setlocale(LC_ALL, ""). If this call fails, the compiler
will try to issue the call setlocale(LC_ALL, "C"). If this call also
fails, the compiler will issue this message and abort.
User Action: The best way to determine why the
compiler is failing is to write a small program that contains the same
library calls the compiler is making and then examine the return values.
BADMACROINLN, Illegal token from macro call in #line directive.
Description: A #line directive was followed by a macro
whose expansion did not form a valid argument to the directive. The
#line directive should be followed by either a digit sequence or a
digit sequence followed by a string literal. The #line directive will
be ignored.
User Action: Supply a valid argument to the #line
directive.
BADMACRONAME, "directive" directive is not followed by an
identifier and is being ignored.
Description: A #define or #undef preprocessing
directive was not followed by an identifier. The first argument to
these directives must be an identifier that specifies the macro to
define or undefine. The compiler will ignore the directive.
User Action: Correct the argument to the preprocessing
directive.
BADMBCOMMENT, An invalid multibyte character was encountered in a
comment.
Description: An invalid multibyte character was found
in a comment. While this will not affect the program execution, it
might not have been what you intended.
User Action: Correct the multibyte character.
BADMCRORECURS, Recursive expansion of macro "name" exceeded
num levels and was terminated.
Description: In certain cases, the compiler will allow
a macro to be recursively expanded. In these cases, the compiler limits
the level of the recursion to prevent the compiler from looping to the
point where it consumes all available memory. When this level has been
reached, this message is output.
User Action: Rewrite either the macro definition or
the macro invocation so that the recursion ends before the compiler
limit is reached. Note that the use of recursive macros is not a
feature of the C standard, and most other C compilers will not support
this.
BADMEMBER, Invalid member declaration.
Description: A struct or union contains an invalid
member declaration. In most cases this error occurs when a semi-colon
was omitted from the previous member declaration.
User Action: Correct the declaration.
BADMEMOFF, contextmultiple definitions of member
"name" found with different offsets.
Description: In certain modes, the compiler will allow
a struct or union reference whose right operand is not a member of the
struct or union type of the left operand. This is allowed for
compatibility with other compilers. However, in these cases the right
operand must specify a member name that is declared with the same type
and at the same offset in every struct or union type that declares it.
This message is issued when the compiler finds member name it is
looking for declared with a different offset in more than one struct or
union type.
User Action: HP recommends that the left operand or a
struct or union reference specify a member that is a member of the type
of the struct or union specified by the right operand. If this
modification cannot be made then the member specified by the left
operand must be declared at the same offset and with the same data type
in all struct or union declarations that declare that member.
BADMEMTYP, contextmultiple definitions of member
"name" found with different types.
Description: In certain modes, the compiler will allow
a struct or union reference whose right operand is not a member of the
struct or union type of the left operand. This is allowed for
compatibility with other compilers. However, in these cases the right
operand must specify a member name that is declared with the same type
and at the same offset in every struct or union type that declares it.
This message is issued when the compiler finds a member name it is
looking for declared at the same offset but with different types in
more than one struct or union type.
User Action: HP recommends that the left operand or a
struct or union reference specify a member that is a member of the type
of the struct or union specified by the right operand. If this
modification cannot be made then the member specified by the left
operand must be declared at the same offset and with the same data type
in all struct or union declarations that declare that member.
BADMODULEID, Invalid identifier found immediately following "#pragma
module" or "#module" directive.
Description: The #pragma module or #module directive
must be followed by an identifier that specifies the module name used
by the linker.
User Action: Correct the directive.
BADMULTIBYTE, An invalid multibyte character was encountered in
type of construction.
Description: An invalid multibyte character was
encountered. The message will provide additional information about the
location and attempted use of the character.
User Action: Correct the multibyte character.
BADNUM, text Qualifier value 'text' is not an integer
Description: This message is emitted by the code
generator. It should never be output when compiling a C program.
User Action: Please submit a problem report if you
encounter this message when compiling a C program.
BADOCTCONST, Octal constant value too large.
Description: An octal constant used in a preprocessor
directive is too large. The value of the constant will be undefined.
User Action: Decrease the value of the constant.
BADOPCCAP, text instruction used is not in the selected
instruction set
Description: The compiler has output an instruction
that is not in the instruction set selected on the command line. One
way this can happen is to compile a program which contains a floating
point operation and specifying that no floating point instructions
should be generated.
User Action: Either modify the source so the
instruction will not be necessary, or use a different instruction set.
BADOPENBRACE, This open brace may be missing a close brace and causing
the syntax error at location.
Description: This message is always output to the
terminal after another syntax error. It is intended to provide the
programmer with additional information that may identify the cause of
the syntax error. This message may, or may not, provide useful
information. In general, the more consistent the coding style in the
source function, the more likely this message will be accurate.
User Action: Correct the program syntax.
BADPARSEDECL, In this declaration, "id" must specify a type.
Description: In processing a declaration, the type of
the declarator has not been declared as a typedef.
User Action: Either declare the type as a typedef, or
correct the spelling of the type specifier in this declaration.
BADPARSEPARAM, In this parameter list, "param" must either be
a type or must be followed by a ",".
Description: In processing a function declaration, the
compiler has found a case where the parameter list begins with two
identifiers not separated by a comma and where the first identifier is
not a type specifier. If this is an old-style declaration the two
identifiers must be separated by a comma. If this is a prototype
declaration, the first identifier must specify a type.
User Action: Correct the function parameter specifiers.
BADPPDIR, File ends in an unfinished pp directive.
Description: An unexpected end-of-file was encountered
during a preprocessing directive.
User Action: Correct the directive.
BADPRAGMAARG, Unexpected or missing argument to #pragma pragma
name. Pragma is ignored.
Description: An argument to a #pragma preprocessing
directive is either missing or is not correct. The compiler will ignore
the directive.
User Action: Correct the directive.
BADPRAGMAARG1, Unexpected token encountered in pragma. Found
"found" when expecting expecting. The pragma will be
ignored.
Description: While parsing a #pragma directive, the
compiler has encountered something unexpected. The message will contain
information about what the compiler was expecting as well as what it
found.
User Action: Correct the offending directive.
BADPRAGMALINK, A bad linkage pragma was specified. Pragma is ignored.
Description: The compiler encountered a bad #pragma
linkage directive. The error message should point to the place in the
pragma that the compiler considers bad. The compiler will ignore the
entire pragma.
User Action: Correct the directive.
BADPRAGNAMES, Invalid argument to the pragma names directive. Pragma is
ignored.
Description: An invalid argument has been specified
for the #pragma names preprocessing directive.
User Action: Correct the argument to the pragma.
BADPREFIX, Argument to extern_prefix is not a recognized keyword or a
quoted string. Pragma is ignored.
Description: An invalid argument has been specified
for the #pragma extern_prefix preprocessing directive. The directive
expects either the identifiers "save", "__save", "restore",
"__restore", or a string constant that specifies the external prefix to
use. The compiler will ignore the pragma.
User Action: Correct the argument to the pragma.
BADPROTYP, Unexpected file type for profile file text
Description: The file specified in the -feedback
option does not have the file type expected by the compiler.
User Action: Use a valid feedback file.
BADPTRARITH, contextperforming pointer arithmetic on a pointer
to void or a pointer to function is not allowed. The compiler will
treat the type as if it were pointer to char.
Description: Pointer arithmetic is not allowed on
pointers to function or void types For compatibility with some other
compilers, an output file is still created. The result produced will be
the same as if the pointer were a pointer to char. This may or may not
be compatible with other compilers that accept this syntax.
User Action: Cast the pointer type to a pointer to
object type before performing the arithmetic.
BADREGISTER, context"name" has register storage
class, but occurs in a context that precludes register storage. The
storage class has been changed to auto.
Description: An object that was declared with register
storage class has been referenced in a way that is not valid for a
register. The most common example is taking the address of an object
declared with register storage class. As certain array accesses also
require taking the address of an array, this message can also be output
for accessing the element of an array declared with register storage
class. The compiler will change the storage class from register to auto.
User Action: Either remove the register storage class
from the declaration, or change the reference to be one that is valid
for objects with register storage class.
BADRETURNTYPE, contexta function cannot return type
type.
Description: A function return type cannot be an array
or function type.
User Action: Correct the function declaration so that
the return type is valid.
BADSEVERITY, The severity of message id name cannot be made
less severe. The severity for this message was not changed.
Description: The severities of the compiler's error
and fatal messages cannot be changed to a severity that is less severe.
The compiler's fatal messages cannot be changed to any other severity.
The compiler's error messages can only be changed to fatals.
User Action: Remove the pragma or compiler option that
tried to change the severity.
BADSTATICCVT, contextthe address cannot be converted to the
destination type.
Description: A static initialization tried to convert
a link-time address to another type. However, the linker on this
platform will not support such a conversion.
User Action: Rewrite the static initialization, or
perform the initialization using runtime code.
BADSTDLINKAGE, If standard_linkage is used, it must be the only
characteristic specified.
Description: The standard_linkage characteristic
cannot be used with any other linkage characteristic.
User Action: Correct the pragma.
BADSTMT, Invalid statement.
Description: An invalid statement was encountered. The
most common cause of this error is when a declaration appears after the
first statement in a compound statement.
User Action: Correct the program syntax.
BADSTMT1, Invalid statement. This condition may have been caused by an
open brace without a matching close brace. The compiler will attempt to
identify open braces that might be missing a close brace.
Description: An invalid statement was encountered.
This condition may have been caused missing close brace. This message
is followed by some number of additional messages that attempt to
identify
User Action: Correct the program syntax.
BADSUBSCRIPT, contextan array subscript expression is either
less than zero or greater than the largest value that can be
represented by the size_t type.
Description: The compiler has detected an array
subscript expression that is outside the bounds of any valid array. The
array access might cause unpredictable behavior.
User Action: Specify a valid array subscript.
BADTARGMACRO, The target macro "name" does not match the
compiler's target. This will likely cause incorrect code paths to be
taken.
Description: On OpenVMS I64, some users have tried
defining the macro __ALPHA explicitly using /DEFINE or a #define in a
/FIRST_INCLUDE file as a quick way to deal with source code
conditionals that assume that if __ALPHA is not defined then the target
must be a VAX. Defining __ALPHA will cause many of the CRTL and other
OpenVMS headers to take the wrong path for I64.
User Action: Remove any definitions of Alpha target
macros, and if necessary correct the preprocessor conditionals that
seemed to require an Alpha target macro to get the desired effect. E.g.
change "#ifdef __ALPHA" to "#ifndef __VAX" or "#if defined(__ALPHA) ||
defined(__ia64)".
BADTKEN, Lexically invalid token.
Description: An invalid token was encountered in a
preprocessing directive.
User Action: Correct the preprocessing directive.
BADUNKNOWNVLA, contexta "*" bounds specifier is invalid. Using
a "*" to specify a variable-length array of unknown size is only valid
in declarations with function prototype scope.
Description: Using a "*" as a bounds specifier to
designate a variable-length array with unknown size is only valid in
declarations with function prototype scope.
User Action: Supply a valid bound specifier.
BADUNROLLVAL, The #pragma unroll directive takes a value from zero to
255. The value "val" is outside that range. The directive will
be ignored.
Description: The value supplied to a #pragma unroll is
outside the range allowed for the directive. The #pragma directive will
be ignored.
User Action: Use a valid value for the unroll count.
BADUSELINK, A bad use_linkage pragma was specified. Pragma is ignored.
Description: The compiler encountered a bad #pragma
use_linkage directive. The error message should point to the place in
the pragma that the compiler considers bad. The compiler will ignore
the entire pragma.
User Action: Correct the directive.
BADUSERMACRO, The name "name" cannot be a user-defined macro.
Description: The code has tried to #define either a
macro that is predefined by the C standard or the DEFINED preprocessing
keyword. This is not allowed. The #define will be ignored.
User Action: Remove the #define directive.
BADVASTART, contextold-style parameter "name", with
type that requires default argument promotion, cannot be used with
va_start.
Description: It is invalid for the parameter specified
in va_start to be one that requires default argument promotion.
User Action: The recommended fix is to recode the
function definition to use a prototype-format definition. It is also
possible to change the parameter declaration to use one of the default
types, for example double.
BIFENABLED, The function "routine name" is a builtin function
reserved to the compiler, and does not require a #pragma intrinsic. The
function will continue to be treated as a builtin.
Description: A function identifier specified in a
#pragma function intrinsic is the name of a builtin function. These
functions cannot be explicitly enabled, they are always handled as
builtin functions.
User Action: Remove the inappropriate use of the
pragma.
BIFNEEDSSTD, contextuse of "function" is not allowed
in a function with a non-standard linkage. This function was given the
linkage "name" by a #pragma use_linkage directive.
Description: Certain built-ins that return information
about a function call require that the function be called with standard
linkage. Because this function appears in a #pragma use_linkage
directive naming a linkage that specifies attributes other than
standard_linkage, these builtins cannot be called from this function.
User Action: Use a standard linkage on this function,
remove the calls to the builtins, or move them to a different function
that is called with standard linkage.
BIFNOTAVAIL, Built-in function name is not available on this
platform.
Description: This Alpha built-in function is not
available on the IA64 platform.
User Action: See documentation for alternatives.
BIFPROTO, contextthe built-in function, "name",
requires a prototype declaration from filename.
Description: Invoking a built-in function requires
that the function be declared before it is invoked. This should be done
by including the header file noted in the message.
User Action: Include the header file before the
function is invoked.
BITARRAY, The CDD description for name specifies that it is an
array of bitfields; It has been converted to a scalar bitfield.
Description: HP C does not allow arrays of bitfields.
The resulting C declaration will be a bitfield of the same total size
as that specified in the CDD description.
User Action: If a bitfield type is acceptable, then no
user action is necessary. If, however, the bitfield type is not
acceptable, then the CDD description should be altered.
BITBADREP, contextthe bitfield type is not an integral type.
Description: A bitfield has been declared with a
non-integral type. Standard C requires that all bitfields be declared
with either int, unsigned int, or signed int type.
User Action: Change the type of the bitfield.
BITCONSTSIGN, contextthe integer constant "constant"
does not have the same sign as the 1-bit bitfield it is being converted
to.
Description: Either an unsigned 1-bit bitfield was
assigned -1, or a signed 1-bit bitfield was assigned 1. This may not be
what you intended.
User Action: Change the constant to be the appropriate
sign.
BITFIELDSIZE, The CDD description for bitfield name specifies
a size greater than 32; The excess is declared separately.
Description: HP C does not allow individual bitfields
larger than 32. As a result, a series of bitfields have been declared
whose total size matches that of the CDD definition.
User Action: If the generated definitions are
acceptable, then no user action is necessary. If, however, the
generated definitions are not acceptable, then the CDD description
should be altered.
BITNOTINT, contextthe bitfield type is not an int, signed int,
unsigned int or _Bool.
Description: A bitfield has been declared with a type
other than int, signed int, unsigned int or _Bool. This is not allowed
by the C standard.
User Action: Change the declaration to use one of the
allowed types or compile with a standard mode that allows this behavior.
BITWIDTH, contextthe bitfield width expression
"expression" is outside the range lower to
upper.
Description: A bitfield width specifier was either
less than zero, or is greater than the number of bits in an int. In
some modes, the compiler will assume a width specifier equal to the
number of bits in an int.
User Action: Use a valid bitfield width specifier.
BITWIDTHTYP, contextthe bitfield width expression
"expression" does not have an integral type.
Description: A bitfield width specifier does not have
an integral type. A bitfield width specifier must be an integral
constant expression.
User Action: Correct the width specifier.
BLOCKEXTVLA, contextthe block scope identifier "name"
cannot be declared with a variably modified type because it has extern
storage class.
Description: Only ordinary identifiers with block
scope and without storage class extern, or ordinary identifiers with
function prototype scope can be declared with a variably modified type.
User Action: Correct the declaration.
BLOCKINL, Block level declarations of inline functions are not allowed.
Description: In C99 standard, block level declaration
of inline functions are prohibited.
User Action: Move the inline function declaration to
file scope.
BLTINARGCNT, contextan incorrect number of arguments were
passed to the builtin function, "function expression".
Description: This message is output on OpenVMS systems
when the number of arguments passed to the builtin function is not one.
User Action: Correct the call to the builtin function.
BLTINIMPLRET, contextfor the function "name", the
implicit return type of "type" is not consistent with the
expected type of "type". It will be treated as an ordinary
implicitly defined external function.
Description: A function that could be handled
internally by the compiler has not been declared, so an implicit
declaration has been created for the function. The return value for the
function is being used, and the implicit return type does not agree
with what the compiler expected to see. In such cases, the function
will not be handled internally, but will instead be called at run time
in the usual manner. This could result in a performance loss, or
possibly incorrect results if the implicit return type is incorrect.
User Action: If the function is intended to refer to
the runtime library routine, the appropriate header file should be
included in the source. Alternatively, a correct prototype could be
provided privately in the source file. If the function is intended to
be a replacement for the runtime library routine, disable the intrinsic
version by specifying "#pragma function(function_name)" in the source
file.
BOOLEXT, The _Bool data type is a new feature in the C99 standard.
Other C compilers may not support this feature.
Description: This is a new language feature in C99.
While having a standard specification for portability, the feature may
not yet be available in all of the compilers you use.
User Action: Determine whether or not the use of this
feature will cause portability problems for this code.
BOOLNA, The _Bool keyword is not supported in this language mode. It
will be treated as an identifier in this compilation.
Description: Support for the _Bool keyword is only
available in certain language modes. Support is not present when the
compiler is in VAX C, K & R (common), or strict ANSI89 standard
modes. In these language modes _Bool will be treated as an identifier.
User Action: Compile using one of the other
compilation modes.
BOUNDADJ, The CDD description for name specifies
non-zero-origin dimension bound(s); The bound(s) are adjusted to
zero-origin.
Description: The CDD description specifies lower
bounds(s) for an array that is non-zero. The resulting C definition
will have the upper bound(s) adjusted for lower bound(s) of zero.
User Action: Verify that all subscript expressions are
referencing the correct array element(s).
BOUNDNOTINT, contextthe array bound "expression" does
not have an integral type.
Description: The compiler has encountered an
array-bounds specifier that is not an integral type. Array-bounds
specifiers must be positive integer constants.
User Action: Correct the array-bounds specifier
BUGCHECK, Compiler bugcheck. Submit a problem report with a problem
description.
Description: An unexpected condition occurred in the
compiler. This is most likely caused by a compiler bug.
User Action: Reduce the program that is causing the
failure as much as possible. This often leads to a small test case.
Please submit a problem report containing enough information for
Engineering to reproduce the problem. The problem report should include
the small test case.
CALLNEEDSFUNC, context"expression" is not a function.
Description: In what appears to be a function call,
the expression denoting the the function to call is neither the
identifier for a function nor an expression of type pointer to function.
User Action: Correct the expression denoting the
function. If the expression is a simple identifier, perhaps a
function-like macro definition is missing.
CANNOTREDEF, Cannot #define a macro that is currently expanding.
Description: The program is trying to #define the same
macro it is currently expanding. The #define will be ignored.
User Action: Remove the #define, or move it after the
expansion of the macro.
CANNOTUNDEF, Cannot #undef a macro that is currently expanding.
Description: The program is trying to #undef the same
macro it is currently expanding. The #undef will be ignored.
User Action: Remove the #undef, or move it after the
expansion of the macro.
CANTDISABLE, The message id name cannot be disabled.
Description: The compiler's error and fatal messages
cannot be disabled.
User Action: Remove this message id from the list of
messages being disabled on the command line or in the #pragma message
line.
CANTMKRPSTORY, Attempt to create repository "string" for
shortend names failed; OpenVMS status: reason.
Description: A compilation that used the
/NAMES=SHORTENED qualifier could not open the repository used to store
the shortened names. This could be because an invalid name was
specified in the /REPOSITORY qualifier. The message will give
additional information about the failure.
User Action: Correct whatever caused the failure.
CDDATTR, One or more field descriptions in this CDD record specify an
attribute that is being ignored.
Description: The CDD description specifies an
attribute that is not supported in HP C. The attribute is ignored.
User Action: No action is required.
CDDBADID, An invalid identifier, name, is being ignored in the
dictionary directive.
Description: An unexpected identifier follows the
dictionary pathname in a dictionary preprocessing directive. The
identifier is ignored.
User Action: Remove the invalid identifier(s) in the
dictionary directive.
CDDEXT, #dictionary is a language extension.
Description: The #dictionary directive is an extension
of HP C on OpenVMS. The program might not compile with other compilers
or on other platforms.
User Action: Be aware of this if you wish to port the
program.
CDDPATH, A valid CDD pathname was not found. The CDD directive has been
ignored.
Description: The #dictionary preprocessing directive
was not followed by an argument. The directive must be followed by a
character string that gives the path name of a CDD record, or a macro
that expands to the path name of the record.
User Action: Supply a valid argument to #dictionary.
HP also recommends that the #dictionary preprocessing directive be
replaced by the #pragma dictionary operator.
CDDTOODEEP, The attributes for the Common Data Dictionary record
description name exceed the implementation's limit for record
complexity.
Description: The CDD description specifies more
attributes than the interface between the CDD and the compiler can
handle.
User Action: Simplify the record description.
CHARCONST, Ill-formed character constant.
Description: An invalid character constant was
encountered.
User Action: Correct the character constant.
CHAROVERFL, A character constant value requires more than sizeof(int)
bytes of storage.
Description: A character constant is too long to fit
in an int. The compiler will ignore the extra characters.
User Action: Remove the extra characters from the
character constant.
CHKEXPAND, number integrity check error(s) after IL expansion
of routine text
Description: This message is emitted by the code
generator. It should never be output when compiling a C program.
User Action: Please submit a problem report if you
encounter this message when compiling a C program.
CHKINIT, number integrity check error(s) in initial IL &
ST for module text
Description: This message is emitted by the code
generator. It should never be output when compiling a C program.
User Action: Please submit a problem report if you
encounter this message when compiling a C program.
CHKOPT, number integrity check error(s) after text
optimization phase for routine text
Description: This message is emitted by the code
generator. It should never be output when compiling a C program.
User Action: Please submit a problem report if you
encounter this message when compiling a C program.
CLASSNOINIT, contextthe struct or union object "name"
is uninitialized and has a const member.
Description: An object of struct or union type has a
const member and has not been initialized. This might not have been
what you intended. HP recommends that you initialize all objects with
the const attribute. The missing initializer will make this an invalid
declaration in C++.
User Action: Initialize the struct or union object.
CLOSBRACKET, Missing "]".
Description: The compiler was expecting a closing
bracket, but one was not found.
User Action: Correct the program syntax.
CLOSEBRACE, Missing "}".
Description: The compiler was expecting a closing
brace, but one was not found.
User Action: Correct the program syntax.
CLOSECOMMENT, This unmatched comment delimiter is ignored.
Description: An unmatched comment delimiter (*/) is an
illegal combination of unary indirection and binary division operators
that would have caused your compilation to fail.
User Action: Remove the comment delimiter.
CLOSEPAREN, Missing ")".
Description: The compiler was expecting a closing
parenthesis, but one was not found.
User Action: Correct the program syntax.
CMPPTRFUNVOID, contextaccepting the [in]equality comparison of
a pointer to void and a pointer to function type is a language
extension.
Description: Under the C standard, it is a constraint
violation to perform an [in]equality comparison between a pointer to
void and a pointer to function type. Therefore this code may not be
accepted by other compilers.
User Action: Cast one of the pointers to the type of
the other.
COLMAJOR, The CDD description for name specifies that it is a
column-major array; It has been converted to a one-dimensional array.
Description: The HP C compiler supports only row-major
arrays. Therefore the column-major array description in the CDD has
been converted to a one-dimensional array of the same total size and
with the same total number of elements.
User Action: Verify that all subscript references to
the array reference the correct array element.
COMMANDMACRO, Extraneous text "text" at the end of the command
line macro "macro" is ignored.
Description: A command line macro define contains an
invalid macro name. The compiler will define the macro name listed in
the message.
User Action: Correct the command line invocation.
COMPILERBUG, Bug found in compiler: bug.
Description: This message indicates that the compiler
detected a bug within itself.
User Action: Please report the compiler bug and
include an example program that reproduces the problem.
COMPLEXEXT, The complex data type is a new feature in the C99 standard.
Other C compilers may not support this extension.
Description: This is a new language feature in the C99
revision of the standard. While having a standard specification for
portability, the feature may not yet be available in all of the
compilers you use.
User Action: Determine whether or not the use of this
feature will cause portability problems for this code.
COMPLEXNA, The complex data types are not supported in this language
mode. This will be treated as an identifier in this compilation.
Description: Support for the complex data types is
only available in certain language modes. Support is not present when
the compiler is in VAX C, K & R (common), or strict ANSI89 standard
modes. In these language modes _Complex and _Complex_I will be treated
as identifiers.
User Action: Compile using one of the other
compilation modes.
COMPLEXNA1, The complex data types are not supported on this platform.
This will be treated as an identifier in this compilation.
Description: The complex data type is not supported on
the VAX platform.
User Action: Remove use of the complex types or
compile the application on a platform that does support the complex
data types.
CONFLICTHINTS, contextthis hint value contridicts a related
hint at where. The hints will be ignored.
Description: This program has supplied hints for
either both branches of an if/else or both the second and third operand
of a conditional operator. In these cases the two hint values must add
to one.
User Action: Correct the hints.
CONLINKREG, Conflicting register usage between "first set" and
"second set". Pragma is ignored.
Description: The same register was specified in two
different register lists of a #pragma linkage directive. The compiler
will ignore the entire pragma.
User Action: Correct the directive.
CONPSECTATTR, Conflicting psect attribute overrides previous attribute.
Description: A psect attribute specified in a #pragma
extern_model directive contradicts an attribute specified earlier in
the directive. This attribute will override the one specified earlier.
User Action: Remove one of the contradictory psect
attributes.
CONSTCOMPLIT, contextaccepting a compound literal as a
constant is a language extension. The compound literal will be treated
as a cast expression.
Description: A compound literal appears in a context
where a constant expression is required. The C standard does not list
compound literals as a form of operand that is allowed in a constant
expression, so using a compound literal in this context is not
maximally portable. The compiler will treat the compound literal as if
it were a cast expression, which is a form of operand that the standard
lists as being allowed in constant expressions.
User Action: For maximum portability, replace the
compound literal with a cast expression.
CONSTFOLDNS, contextthe libraries on this platform do not yet
support compile-time evaluation of the constant expression
"expression".
Description: Compile-time evaluation of constant
expressions requires underlying support in the libraries available to
the compiler at compile-time, and this expression contains an operator
that is not yet implemented in those libraries.
User Action: If possible, replace part of the constant
expression with a variable of the same value.
CONSTFUNC, Ignoring const type qualifier in declaration of
name.
Description: The const type qualifier cannot be used
with a function type. The compiler will ignore the type qualifier.
User Action: Remove the type qualifier.
CONSTINWRT, Const variable resides in wrt extern model.
Description: The current extern model places all
external objects in a modifiable section. Placing an object with a
const type qualifier in such a section means that there is no run-time
protection against writing to the object. This might not have been what
you intended.
User Action: Place const objects in sections that
cannot be modified.
CONSTNOINIT, contextthe const object "name" is
uninitialized.
Description: A defined or tentatively-defined const
object has not been initialized. This would not be valid in C++. It is
also considered good programming practice to initialize all const
objects with their value.
User Action: Either remove the const type modifier, or
supply an initializer for the object.
CONSTSTOCLS, contextthe const object "name" has no
explicit storage class. In C, its storage class defaults to "extern";
in C++, it defaults to "static". Add an explicit "extern" or "static"
keyword.
Description: One of the more signifcant and confusing
differences between C and C++ is their treatment of file scope const
objects declared without a storage class. C will give the object extern
storage class, making the object visible in other compilation units.
C++ will give the object static storage class. This can cause an
undefined symbol error when other compilation units try to reference
the symbol.
User Action: Add an explicit "extern" or "static"
keyword to the declaration.
CONTFILE, A file ends with a continuation character.
Description: All source files, even those included via
the #include preprocessing directive, must not end with a backslash
continuation character.
User Action: Either remove the continuation character
or add an additional line to the source program that does not end in a
continuation character.
CONTROLASSIGN, contextthe assignment expression
"expression" is used as the controlling expression of an if,
while or for statement.
Description: A common user mistake is to accidentally
use assignment operator "=" instead of the equality operator "==" in an
expression that controls a transfer. For example saying if (a = b)
instead of if (a == b). While using the assignment operator is valid,
it is often not what was intended. When this message is enabled, the
compiler will detect these cases at compile-time. This can often avoid
long debugging sessions needed to find the bug in the user's program.
User Action: Make sure that the assignment operator is
what is expected.
CONVARASLIT, context the use of the const variable
"name" in place of a literal constant is a language extension.
Description: HP C will allow a non-volatile const
variable that has been initialized to be used in contexts where a
constant is required. For example, as the bounds specifier to a file
scope array. This is an extension to standard C. Other C compilers
might not successfully compile a program that uses this extension.
User Action: Use the constant value instead of the
variable.
CRXCOND, Common Data Dictionary description extraction condition.
Description: Something went wrong while trying to get
the CDD record description from the CDD. The error message that follows
gives more information about the nature of the problem.
User Action: If necessary, correct the indicated
condition in the CDD record description or with the user environment.
CVIDXOVFL, module uses more than 65536 CodeView type indices
Description: This message is emitted by the code
generator. It should never be output when compiling a C program.
User Action: Please submit a problem report if you
encounter this message when compiling a C program.
CVTDIFTYPES, context"expression" of type
"type", is being converted to "target type".
Description: In certain modes, the compiler will allow
assignments or comparisons between pointer and integer types. This is
an extension to standard C. Other C compilers might not successfully
compile a program that uses this extension.
User Action: Use a cast operator to convert one
operand to the other.
CVTU32TO64, contextan unsigned 32-bit integer constant that
has its high-order bit set has been converted to a signed 64-bit type.
The conversion will not sign-extend.
Description: This message indicates a conversion that
may produce unexpected results on this platform because the destination
type is a 64-bit type instead of a 32-bit type.
User Action: If this is the intended behavior, first
cast the constant to an unsigned 64-bit type.
CXXCOMMENT, C++ style comments (//) may not be portable.
Description: C++ style comments have been detected on
this line. Although they have been accepted by HP C in this language
mode, they will not be accepted by all compilers or by HP C in strict
C89 standard mode.
User Action: Replace C++ style line comments (//) with
equivalent C comments (/* ... */) if portability is a concern.
CXXKEYWORD, "C++ keyword" is a keyword in C++. Using it as an
identifier in your C program will prevent porting your program to C++.
Description: This identifier is a keyword in C++. The
program is, therefore, not a valid C++ program.
User Action: Choose a different name for the
identifier.
CXXPRAGMANA, The HP C++ pragma "pragma name" is not supported
by HP C. The pragma will be ignored.
Description: The compiler has encountered a pragma
that is supported by HP C++ but is not supported by HP C. The compiler
will ignore the pragma.
User Action: Remove the pragma or compile the program
with HP C++.
DCLMISMATLNK, The declaration of "name" has number
parameter(s) but its linkage "name" has number.
Standard linkage will be used.
Description: The number of parameters specified in a
declaration does not match the number of parameters specified by the
special linkage associated with this function or typedef. The special
linkage was specified via the #pragma use_linkage directive. Because of
this mismatch, the compiler will ignore the special linkage and use the
standard linkage instead.
User Action: Make sure the number of parameters
specified by the special linkage match the number of parameters in the
function.
DCLMISMATLNK0, The declaration of "name" has an unknown number
of parameters and cannot be used with the linkage "name".
Standard linkage will be used.
Description: If a special linkage specifies parameter
information, the declaration must not specify an unknown or variable
number of parameters. The special linkage was specified via the #pragma
use_linkage directive. Because of this mismatch, the compiler will
ignore the special linkage and use the standard linkage instead.
User Action: Make sure the number of parameters
specified by the special linkage match the number of parameters in the
function type.
DCLMISMATLNK1, where "name" modifierhas a
floating type but its linkage "name" specifies an integer
register. Standard linkage will be used.
Description: A parameter or return value of a function
type is a floating type, but the corresponding parameter or return
value in the special linkage specifies an integer register. The special
linkage was specified via the #pragma use_linkage directive. Because of
this mismatch, the compiler will ignore the special linkage and use the
standard linkage instead.
User Action: Make sure the register specified by the
special linkage matches the type of of the corresponding parameter and
return value of the function type.
DCLMISMATLNK2, where "name" modifierrequires
an integer register but its linkage "name" specifies a
floating register. Standard linkage will be used.
Description: A parameter or return value of a function
type is an integer type, but the corresponding parameter or return
value in the special linkage specifies a floating register. The special
linkage was specified via the #pragma use_linkage directive. Because of
this mismatch, the compiler will ignore the special linkage and use the
standard linkage instead.
User Action: Make sure the register specified by the
special linkage matches the type of of the corresponding parameter and
return value of the function type.
DCLMISMATLNK3, where "name" has a size that is
incompatible with the number of registers specified by its linkage
"name". Standard linkage will be used.
Description: The size of a parameter or return value
of a function type is incompatible with the size specified by the
special linkage. The special linkage was specified via the #pragma
use_linkage directive. Because of this mismatch, the compiler will
ignore the special linkage and use the standard linkage instead.
User Action: Make sure the number of registers
specified by the special linkage match the type of the corresponding
parameter and return value.
DCLMISMATLNK4, where "name" modifierhas a
type that is not allowed because the it has the linkage
"name". Standard linkage will be used.
Description: Using a special linkage places certain
restrictions on the type of a function's parameters and return value.
In general, the type must be a scalar type that can be represented by a
register or registers on this platform. In cases where some other type
is used, the compiler will ignore the special linkage and use the
standard linkage instead.
User Action: Either remove the name from the #pragma
use_linkage directive that specified the special linkage, or modify the
type to be acceptable to the special linkage.
DCLMISMATLNK5, "name" has a void return type but its linkage
"name" specifies a return location. Standard linkage will be
used.
Description: If a special linkage specifies return
value information, the declaration must not specify a void return type.
The special linkage was specified via the #pragma use_linkage
directive. Because of this mismatch, the compiler will ignore the
special linkage and use the standard linkage instead.
User Action: Make sure the return value specified by
the special linkage matches the return type.
DCLMISMATLNK6, where "name" modifierhas
float _Complex or double _Complex type. The corresponding floating
point registers in linkage "name" must be consecutive.
Standard linkage will be used.
Description: Using a special linkage places certain
restrictions on the type of a function's parameters and return value.
Whenever float _Complex or double _Complex types are used, they linkage
must specify two consecutive floating point registers. The compiler
will ignore the special linkage and use the standard linkage instead.
User Action: Either remove the name from the #pragma
use_linkage directive that specified the special linkage, or modify the
linkage to use consecutive floating point registers.
DECCONSTLARGE, Decimal constant value too large.
Description: A decimal constant used in a preprocessor
directive is too large. The value of the constant will be undefined.
User Action: Decrease the value of the constant.
DECLAFTERSTMT, Placing a declaration after a statement is a new feature
in the C99 standard. Other C compilers may not support this feature.
Description: This is a new language feature in the C99
revision of the standard. While having a standard specification for
portability, the feature may not yet be available in all of the
compilers you use.
User Action: Determine whether or not the use of this
feature will cause portability problems for this code.
DECLARATOR, Invalid declarator.
Description: A declaration did not contain an
identifier that specifies the item to be declared.
User Action: Specify a declarator in the declaration.
DECLINFOR, Placing a declaration in a for loop is a new feature in the
C99 standard. Other C compilers may not support this extension.
Description: This is a new language feature in the C99
revision of the standard. While having a standard specification for
portability, the feature may not yet be available in all of the
compilers you use.
User Action: Determine whether or not the use of this
feature will cause portability problems for this code.
DECLSPECEXT, __declspec is a language extension.
Description: The __declspec storage class modifier is
a language extension of HP C. Other C compilers might not successfully
compile a program that uses the extension.
User Action: Be aware of this extension if you wish to
port the code.
DEFINOTHER, Another file in this compilation contains an external
definition of a function named "name", or declares it as a
variable with external linkage, at where.
Description: In a compilation where interfile
optimization has been selected (-ifo on UNIX, /PLUS_LIST_OPTIMIZE on
OpenVMS), the compiler has detected more than one definition of a
function using the same external name, or has found that a function and
a variable have the same external name. An external function can have
only a single definition. And a given identifier with external linkage
can refer either to a function or to a variable, but not both.
User Action: Remove or rename one of the names.
DEFINOTHER1, The external variable "name" was defined as an
external function in another module of this compilation at
where.
Description: In a compilation where interfile
optimization has been selected (-ifo on UNIX, /PLUS_LIST_OPTIMIZE on
OpenVMS), the compiler has detected a name with external linkage
defined as a variable in one compilation unit and a function in another.
User Action: Remove or rename one of the definitions.
DEFINOTHER2, This declaration of "name" specifies a different
type than the declaration in another module of this compilation at
where.
Description: In a compilation where interfile
optimization has been selected (-ifo on UNIX, /PLUS_LIST_OPTIMIZE on
OpenVMS), the compiler has detected a name with external linkage
declared with different types in two different modules. Although the
runtime behavior may be as intended and match the behavior when the
modules are separately compiled without interfile optimization, the
behavior is not well defined unless the types are compatible.
User Action: Modify one or more of the declarations to
make the types compatible.
DEFINOTHER3, This declaration of "name" specifies a different
thread-local attribute than a declaration in another module of this
compilation at where.
Description: In a compilation where interfile
optimization has been selected (-ifo on UNIX, /PLUS_LIST_OPTIMIZE on
OpenVMS), the compiler has detected a name with external linkage
declared thread-local in one module and not thread-local in another.
This can lead to unexpected results at runtime.
User Action: Modify one the declarations to make the
thread-local attributes match.
DEFPARMTYPE, There is no declaration for the old-style function
parameter "name". Type defaulted to int. This is a violation
of the C99 standard.
Description: The parameter of an old-style function
definition was not declared. It will default to int type. Omitting the
type specifier is not valid in C99, and is often considered poor
programming practice.
User Action: Declare the parameter. HP also recommends
that old-style function definitions be replaced by prototype-format
definitions.
DEFRETURNTYPE, The type of the function name defaults to "int".
Description: A function definition did not include a
type specifier for the function's return value. It will default to int.
This might not be what you intend. This is also a violation of the C99
Standard.
User Action: It is a good programming practice to give
all function definitions explicit return types.
DESIGBADARR, context, a struct/union designator cannot be used
with an object of array type.
Description: An initialization designator must match
the type of the object being initialized. In this initialization, the
current object is an array so a struct/union designator is not allowed.
User Action: Correct the initialization.
DESIGBADCOMP, context, an array designator cannot be used with
an object of struct or union type.
Description: An initialization designator must match
the type of the object being initialized. In this initialization, the
current object is a struct or union, so an array designator is not
allowed.
User Action: Correct the initialization.
DESIGBADIND, context, the constant expression
"expression" in an array element designator is not a positive
integer.
Description: An array-element designator must be an
constant expression that yields a positive integer value.
User Action: Correct the element designator.
DESIGBADIND1, context, the array element designator
"[expression]" specifies an element beyond the end of the
array.
Description: An array element designator must specify
a valid array element.
User Action: Correct the element designator.
DESIGNATIONNA, The use of a designation in an initializer list is not
supported in this compilation mode.
Description: Initializer lists that contain
designations are a new feature in the C99 revision of the C standard.
HP C will only support this extension in relaxed mode and strict c99
mode.
User Action: Use a compilation mode that supports the
use of designations.
DESIGNATORUSE, The use of a designation in an initializer list is a new
feature in the C99 standard.
Description: Initializer lists that contain
designations are a new feature in the C99 revision of the C standard.
Other compilers may not support this feature.
User Action: Be aware of this portablility issue.
DESIGNOMEMB, context, the component designator "name"
is not a member of the current structure or union object being
initialized.
Description: An initialization designator specifies a
struct or union member that is not a member of the current struct or
union object.
User Action: Correct the initialization.
DESIGSCALAR, context, a designator cannot be used with an
object of scalar type.
Description: An initialization designator can only be
used on objects of array, structure, or union type. In this
initialization, the current object being initialized is a scalar type
so a designator is not allowed.
User Action: Correct the initialization.
DIFFEXMODEL, This redeclaration of "name" specifies a
different extern model than a previous declaration of the variable at
location.
Description: Two declarations of the same variable use
different extern models. The extern model is specified by a #pragma
extern_model directive that appears before the declaration in the
source. This redeclaration may cause unexpected behavior.
User Action: All declarations of a variable should use
the same extern model.
DIFFTYPEQUALS, contextthe type of "name" has
different type qualifiers than the previous declaration at
location. The resulting type will be the composite of the two
types.
Description: The C standard permits redeclaration and
formation of a composite type only when the two types being considered
are compatible, and types with different type qualifiers are not
compatible. HP C allows this redeclaration for consistency with some
other C compilers, and will form a composite type with all of the type
qualifiers from both declarations. Be aware that these declarations may
not be accepted by other C compilers.
User Action: Modify the declarations so that they use
identically qualified types.
DIRECTVNOCPP, "Directive text" is not recognized as a
preprocessing directive in nopreprocessing mode, and is being ignored.
Description: An invalid preprocessing directive was
encountered in a compilation performed with the -nocpp option. When
using the -nocpp option, only a limited number of preprocessing
directives, such as #pragma and #line, can appear in the program. The
compiler will ignore the rest of the line.
User Action: Either remove the directive or compile
without the -nocpp option.
DISREDECL, contextthe type of the external "name" is
not compatible with the type of a declaration of "name" in
another name scope at location.
Description: The same external identifier has been
declared in different scopes with incompatible types. This might not
have been what you intended.
User Action: Change all declarations of the same
external identifier to use the same type.
DOLLARID, Extension: A '$' was encountered in an identifier.
Description: Accepting a "$" character in an
identifier is an extension of HP C. The program might not compile with
other C compilers.
User Action: Be aware of this if you wish to port the
program.
DONOTAPPLY, linkage, assert or hint information for built-in function
name is ignored.
Description: A built-in function is always handled
specially. There is no actual function call to which linkage, assert or
hint information could be applied.
User Action: Remove the name of the built-in function
from this pragma.
DUPCASE, The switch statement containing this case label already has a
case label for "number".
Description: A switch statement contains more than one
case label for the same case value.
User Action: Remove the duplicate case label.
DUPDEFAULT, The switch statement containing this default label already
has a default label.
Description: A switch statement can contain only one
default label.
User Action: Remove the duplicate default label.
DUPENUM, contextthe enumerator "name" is not unique.
Description: An enumerator constant is declared more
than once with the same value. While this is accepted by HP C, it is
not allowed by the C standard.
User Action: Either use a different enumerator name or
remove the previous declaration of the name.
DUPEXTERN, The declaration of "name1" will map to the same
external name as the declaration of "name2" at where.
Description: The compiler has detected a case where
two different names in a program will map to the same external name in
the output object file. This can cause unpredictable results at
runtime. This will most often happen when the /NAMES=UPPERCASE or
/NAMES=LOWERCASE qualifier causes two names with different case
spellings to map to the same external name.
User Action: Either use the /NAMES=AS_IS qualifier, or
modify one of the names.
DUPLABEL, The label "name" is already defined in this
procedure at location.
Description: A label has already been defined. Each
function can define each label only once.
User Action: Remove the duplicate label definition.
DUPLINK, Duplicate linkage pragmas for linkage name "linkage
name".
Description: The same linkage specifier has been
defined in more than one #pragma linkage directive.
User Action: Declare each linkage only once.
DUPLPRAGASS, #pragma assert directive specified for the function name
name while different #pragma assert was specified for its type.
Description: Duplicate assertion can't be specified
for a function. Check whether #pragma assert was mistakenly specified
for the same function more than once, or function's type is declared in
a typedef which in turn has its own #pragma assert directive.
User Action: Either remove duplicate #pragma assert
directive, or change assertions, or fix spelling of the function name
or typedef.
DUPPARM, context"name" is a duplicate parameter name.
Description: The parameter identifier list of an
old-style function definition uses the same identifier more than once.
User Action: Each identifier in the parameter list
must be unique. HP also recommends that old-style function definitions
be replaced by prototype-format definitions.
DUPSTATIC, There is a redundant use of the keyword "static" in this
array declaration.
Description: In C99 the keyword "static" may appear at
most once in the outermost array-bounds specifier of a function
parameter in a function prototype.
User Action: Remove redundant occurrences(s) of
"static" from the array declaration
DUPSTORCLS, contextthe same storage class modifier occurs more
than once.
Description: This declaration specifies the same
storage class modifier more than once.
User Action: Remove the extra uses of the storage
class modifier.
DUPTYPEDEF, context"name" has a duplicate typedef at
where. This might not be portable.
Description: The same typedef has been declared to the
same type more than once. Standard C does not allow this and other
compilers might not accept it.
User Action: Remove the redundant declaration.
DUPTYPESPEC, contextthe same type specifier occurs more than
once.
Description: The same type specifier appears more than
once in the same declaration. The redundant specifier will be ignored.
User Action: Remove the duplicate type specifier.
DUPTYPQUAL, contextthere is a redundant use of type qualifier
"const or volatile".
Description: The same type qualifier appears more than
once in a type specifier. This violates the C89 standard. Other
compilers may not accept this program. Note that C99 will allow
redundant qualifiers.
User Action: Remove the redundant type qualifier.
ELIFIGNORED, Out of place #elif directive ignored.
Description: An #elif preprocessing directive was
encountered outside of an #if/#endif body. The directive will be
ignored.
User Action: Remove the directive.
ELLIPSEARG, Standard C does not permit the use of an ellipsis as an
only argument.
Description: Standard C requires at least one formal
parameter be declared before the ellipses. This declaration might not
be portable to other C compilers.
User Action: Recode the function declaration to
contain at least one formal parameter.
ELLIPSEPARM, contexta parameter with type "type"
matches an ellipsis in previous declaration at location.
Description: A function that has been previously
declared as taking variable arguments is now redeclared as using a
different number of formal parameters before the start of the variable
argument list. This redeclaration might not be portable to other C
compilers.
User Action: Recode the function declarations to match
each other.
ELLIPSISEND, No tokens may follow ... in a formal parameter list.
Description: The ellipsis may only appear at the end
of a formal parameter list. Everything after that is being ignored.
User Action: Remove the unexpected token.
ELSEIGNORED, Out of place #else directive ignored.
Description: An #else preprocessing directive was
encountered outside of an #if/#endif body. The directive will be
ignored.
User Action: Remove the directive.
EMBEDCOMMENT, A comment is neither preceded nor followed by white space.
Description: A comment is neither preceded nor
followed by white space. In certain modes the compiler will paste the
tokens before and after the comment together to form a single token.
This behavior is not valid in standard C. Writing programs that rely on
this behavior might prevent the program from being compiled on other
platforms.
User Action: Add white space before or after the
comment, or use the ## operator to paste tokens together.
EMPTYCHARCONST, Empty character constant.
Description: In some modes the HP C compiler will
allow a null character constant. The compiler will give this constant a
value of zero. Accepting an empty character constant is a language
extension. Empty character constants are not valid in standard C.
Writing programs that rely on this behavior might prevent the program
from being compiled on other platforms.
User Action: Replace the empty character constant with
'\0'.
EMPTYFILE, Source file does not contain any declarations.
Description: This source file contains no
declarations. This might not have been what you intended. For example,
perhaps a necessary macro was not defined.
User Action: Every source program should contain at
least one declaration.
EMPTYINIT, An initializer list without an expression is not valid. The
compiler will replace the empty expression with the constant 0.
Description: The C standard requires that an
initializer list contain an expression. The compiler has encountered
one without an expression. The compiler will treat the empty list ({})
as if it contained a single zero ({0}). This is for compatibility with
some other C compilers. Be aware that this syntax may not be accepted
by other C compilers.
User Action: Supply an expression to the initializer.
EMPTYOBJ, Empty object file due to errors.
Description: An earlier condition will cause an empty
object module to be created.
User Action: Correct the condition that was reported
earlier.
EMPTYSTRUCT, Allowing struct/union type with no members is a language
extension.
Description: The C standard requires that a
struct/union type have at least one member. The HP C compiler will
accept this for compatibility with older compilers. The struct/union
type will be treated as if it were declared { : 0; }
User Action: Provide at least one member for the
struct/union.
ENUM16BIT, contextthe enumeration constant name is
out of the range -32768 to 32767. This might not be portable.
Description: An enum constant is larger than can be
represented in 16 bits. This would not be portable to a system with an
int size of 16 bits.
User Action: Be aware of this if you wish to port to a
system with an int size of 16 bits.
ENUMCALC, contextthe enum variable "expression" is
used in an arithmetic operation.
Description: An enumerated type variable was used in
an arithmetic operation. While this is valid in C, it might not have
been what you intended.
User Action: Verify the use of the enum variable.
ENUMINIT, contextthe enumerator "name" is initialized
to the nonintegral value "expression".
Description: An enum declaration contains an
enumeration constant initializer that does not have an integer type.
The initializer for an enumeration constant must be an integral
constant expression.
User Action: Correct the initializer.
ENUMRANGE, contextthe enumeration constant "name" is
out of range INT_MIN to INT_MAX and will be truncated.
Description: An enumeration constant must be
representable as an int type. The specified value is outside the range
of an int. In modes where this is a warning, the compiler will use the
low-order bits to form the int value.
User Action: Use a valid constant value.
ENUMSANDINT, contextallowing an enumeration type and a signed
int to be compatible may not be portable.
Description: The standard states that enumeration
types shall be compatible with an integer type. HP C, along with most
other C compilers, has chosen the signed int type to be compatible with
enumeration types. Other compilers may chose another type such as
unsigned int (the C standard even allows an implementation to choose
different integer types depending on the values of the enumeration
constants defined for the type). Therefore this program may not be
accepted by other C compilers.
User Action: Insert a cast to make the types the same.
ENUMSNOTCOMPAT, contextallowing two different enumeration
types to be compatible is a language extension.
Description: The HP C compiler allows two objects of
different enumeration types to be compatible. The C standard specifies
that enumeration types are distinct types. Therefore this program is
not standard compliant and other C compilers may not accept it.
User Action: Use the same enumeration type or cast one
type to the other.
ENUMUSED, contextthe enumerator name "name" has been
used previously.
Description: The specified enumerator name has been
previously declared as something other than an enumerator.
User Action: Either use a different enumerator name or
remove the previous declaration of the name.
ENVIRSTKDIRTY, At the end of the compilation the pragma name
stack was not empty. This may indicate a coding error.
Description: The program being compiled has saved the
named pragma state more often than it has restored it. Good coding
practice calls for the pragma state to be restored some point after it
has been saved. This condition may indicate the accidental failure to
restore the state.
User Action: Make sure each pragma save has a
corresponding pragma restore.
ERRORLIM, diagnostic message limit exceeded
Description: This message is emitted by the code
generator. It should never be output when compiling a C program.
User Action: Please submit a problem report if you
encounter this message when compiling a C program.
ERRORMESSAGE, #errorerrormsg
Description: An #error directive was encountered. This
message will include the text that follows the directive in the source
program.
User Action: Remove the #error directive, or supply
the proper macro definitions so that the compiler will skip the
directive.
ESCOVERFL, Invalid escape sequence encountered.
Description: An escape sequence in a character or
string literal specifies a value outside the range of a character or
wide character.
User Action: Specify a valid escape sequence.
EXPANDEDDEFINED, Macro expansion includes the token "defined", which
will be treated as an operator. This might not be portable.
Description: A macro expanded during the processing of
a preprocessor #if directive included the token "defined". The HP C
compiler will treat this as the defined preprocessing operator. Other
compilers might treat this differently.
User Action: Rewrite the macro not to use the
"defined" operator.
EXPNOTRES, expression does not contribute to result
Description: The compiler has detected a source
expression that does not contribute to the result. This may not be what
you expected.
User Action: Verify the expression is what you intend.
EXPRCVTINT, The expression "expression" has been converted to
integer.
Description: In certain modes, HP C will allow switch
expressions or case constants to be non-integer types. The expression
or constant will be converted to int. In one of these cases, this
warning will be issued.
User Action: Cast the switch expression to an integer
type or use an integer case constant.
EXPRNOTINT, The expression "expression" has type
type, which is not integral.
Description: An expression that is required to have an
integer type had a type that is not integral. This is not valid. An
example of a situation where an integer is required is that in most
modes HP C requires that the switch control expression have integer
type.
User Action: Modify or cast the expression so that it
has integer type.
EXPRNOTUSED, contextthe expression "expr" is never
used.
Description: The compiler has detected an expression
that is not used, and might not have a side-effect. This might not have
been what you intended.
User Action: If the expression has a desired
side-effect, the message can be ignored. Otherwise, you might want to
consider removing the expression.
EXTENDTYPE, This platform specific type is a language extension.
Description: The use of the types __int8, __int16,
__int32, __int64, or other type specifiers beginning with leading
double underscores might not be portable to other platforms or to other
C compilers.
User Action: Be aware of this portability concern.
EXTERNINIT, HP C allows the initialization of a variable with extern
storage class. This differs from the VAX C behavior.
Description: VAX C does not allow a variable with
extern storage class to be initialized. HP C will allow this, even in
vaxc mode.
User Action: Be aware of this difference if you plan
to compile the source with VAX C.
EXTERNPOP, This "restore" has underflowed the extern model's stack. No
corresponding "save" was found.
Description: The extern_model stack, managed by the
#pragma extern_model and #pragma environment directives, contains more
restores than saves. This could signify a coding or logic error in the
program.
User Action: Make sure each restore has a
corresponding save.
EXTPREAFTER, This directive will not set the extern_prefix of
"name" because there is a previous declaration of the
identifer with external linkage at where.
Description: When an identifier is specified in a
#pragma extern_prefix, the declaration of that identifier must appear
after the #pragma.
User Action: Reorder the declaration and the #pragma
so that the #pragma comes first.
EXTPREAGAIN, This directive overrides the extern_prefix for
"name" specified by an earlier #pragma extern_prefix at
where.
Description: Two #pragma extern_prefix directives have
specified different non-empty extern_prefixes for the same identifier.
In such cases the later directive will set the extern_prefix for the
identifier.
User Action: If it is necessary to respecify the
extern_prefix for an identifier, first remove the prefix (by setting it
to an empty string) and then specify the new prefix in a subsequent
#pragma.
EXTPRENODECL, There is no identifier named "name" with
external linkage declared in this compilation unit.
Description: A #pragma extern_prefix directive
specifies an extern prefix for an identifier that is not declared with
external linkage in the compilation unit. This may not have been what
you intented.
User Action: Remove the identifier from the #pragma
extern_prefix, or declare it with external linkage, or set the prefix
for this identifier to an empty string.
EXTRABRACES, context, the value is enclosed within too many
pairs of braces.
Description: An initializer contains too many open
braces for the object being initialized.
User Action: Reduce the number of braces.
EXTRAMODULE, Redundant "#pragma module" or "#module" directive ignored.
Description: A compilation unit can contain only one
#pragma module or #module directive. All subsequent directives will be
ignored.
User Action: Remove the extra directives.
EXTRAPRAGARGS, Extra pragma arguments to #pragma pragma were
found. Pragma is ignored.
Description: Unexpected arguments were found at the
end of a #pragma directive. The directive will be ignored.
User Action: Remove the extra arguments.
EXTRASEMI, Extraneous semicolon.
Description: An extra semicolon was found at the end
of a declaration. It will be ignored.
User Action: Remove the extra semicolon.
FALLOFFEND, The last statement in non-void function "name" is
not a return statement.
Description: A function that returns a value does not
end with a return statement. If function execution reaches the end of
the function, the implied return statement that executes will return an
undefined value. This might not have been what you intended.
User Action: End the function with a return statement
that specifies a return value.
FBFILENOTFOUND, Feedback file not found: text
Description: The specified feedback file could not be
found by the compiler.
User Action: Specify the correct file name.
FILECLOSE, An error occurred while attempting to close a source file:
problem.
Description: An unexpected error occurred while
closing a source file. The message text will contain additional
information about the failure.
User Action: Correct the condition that caused the
failure.
FILENOTFOUND, File not found: text
Description: The specified file could not be found by
the compiler.
User Action: Specify the correct file name.
FILEREAD, An error occurred while attempting to read a source file:
problem.
Description: An unexpected error occurred while
reading a source file. The message text will contain additional
information about the failure.
User Action: Correct the condition that caused the
failure.
FILESCOPEVLA, contextthe file-scope identifier "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.
FINBRANCH, A goto to the label "label" branches into a finally
handler.
Description: A goto statement tried to transfer into a
finally handler. This is illegal.
User Action: Modify the goto or move the label outside
the handler.
FLEXARRAYELEM, contextallowing an array element to be a struct
with a flexible array member is a language extension.
Description: The C99 standard allows the final element
of a struct with more than one named member to have incomplete array
type. Such a member is called a flexible array member. The standard
does not allow such a struct (and any union containing, possibly
recursively, a member that is such a struct) to be an array element.
Other C compilers may not support this extension.
User Action: Be aware of this extension if you wish to
port the code.
FLEXARRAYMEM, contextallowing the struct member,
"name" to be a struct with a flexible array member is a
language extension.
Description: The C99 standard allows the final element
of a struct with more than one named member to have incomplete array
type. Such a member is called a flexible array member. The standard
does not allow such a struct (and any union containing, possibly
recursively, a member that is such a struct) to be a member of another
structure. Other C compilers may not support this extension.
User Action: Be aware of this extension if you wish to
port the code.
FLOATCONSQUAL, The float_const_qual is not valid in strict
ANSI mode and will be ignored.
Description: The -float_const option cannot be used in
strict ANSI mode. The option will be ignored.
User Action: Either remove the -float_const option or
use a different mode.
FLOATCONST, Ill-formed floating constant.
Description: An invalid floating constant was
encountered.
User Action: Correct the floating constant.
FLOATERR, contexta floating point error occurs in evaluating
the expression "expression".
Description: A floating-point error occurred while
evaluating a constant expression. This is often caused by an invalid
floating-point number. The value of the expression is undefined.
User Action: Correct the floating-point constant
expression.
FLOATOVERFL, contextfloating-point overflow occurs in
evaluating the expression "expression".
Description: A floating-point overflow occurred while
evaluating a constant expression. The value of the expression is
undefined.
User Action: Correct the floating-point constant
expression.
FLOATTOINT, context"expr" is being converted from
type type to int type.
Description: The C language requires that this
expression be of integer type. In most cases the compiler will emit an
error for this case. In VAX C mode, the compiler emits this warning and
converts the expression to int type. This matches the behavior of VAX C.
User Action: If the VAX C behavior is what you
intended, cast the expression to int to silence the diagnostic.
Otherwise, recode the expression to reflect your intent.
FMTNOTSTR, argument number of this function is not of type
char * but corresponds to the format string specified by the #pragma
assert directive at location. The format func_attr will be
ignored.
Description: The format attribute causes the format
string to be checked if it is a string constant. The format parameter
can't be a format string because it is not declared as a char * type.
The format attribute will be ignored.
User Action: Either remove the format assertion from
the directive, correct the position of the format argument in the
assertion, or declare the format argument as a "char *" in the proper
position in the function prototype.
FNAMETOOLONG, The file name "name" in this directive is too
long.
Description: A preprocessing directive has specified a
file name that is too long for this platform.
User Action: Supply a valid file name
FORMATATTR, contextthe arguments to function name do
not match the assertions of its format attribute. The format argument
or the argument preceeding the first argument to check is missing.
Description: The format attribute of this function
asserts that the format argument exists and will be checked if it is a
string constant. The first argument to check, if non-zero, identifies
the argument corresponding to the ellipsis in the function declaration
and asserts that the argument preceeding it exists.
User Action: Modify either the function call or the
format attribute so that they match.
FOUNDCR, A carriage-return character was encountered; it is being
treated as white space.
Description: The compiler encountered a
carriage-return character some place other than inside a character or
string constant. The compiler will treat the carriage-return as white
space.
User Action: The source might have been created by
some non-standard means. If possible, replace all carriage-return
characters outside of character or string constants with white space.
FREGNEEDSIEEE, Use of the floating register "regnum" in a
#pragma linkage directive requires the /FLOAT=IEEE_FLOAT qualifier.
Description: On IA64, VAX floating-point data is
passed in general registers. HP C requires that any program that uses a
floating point register in a linkage directive must be compiled with
IEEE floating-point.
User Action: Compile with IEEE floating-point. Another
option would be to remove the floating point registers from the linkage.
FUNCELEMENT, contextthe element type of an array type is a
function type.
Description: The compiler has encountered an array
with an element type of function. An array element must be an object
type.
User Action: Change the type of the array element.
FUNCIDLIS, contextthe identifier "id" is not the name
of a type. All parameter information in this declaration will be
ignored.
Description: The declaration is most likely a
malformed prototype-style function declaration. In a prototype-style
declaration, each parameter must have a type. The identifier named in
the message might be intended to be the (optional) name of a formal
parameter and the type specification was mistakenly omitted, or it
might be intended to be the name of a type but no typedef declaration
for it is visible. Alternatively, the declaration might be intended to
correspond to an old-style function definition, and mistakenly contains
a formal parameter name in the declaration. Old-style function
definitions list the names of formal parameters (without types) inside
the parentheses, but old-style function declarations contain nothing
inside the parentheses.
User Action: Correct the declaration.
FUNCINIT, The declaration of the function "name" includes an
initializer.
Description: A function declaration cannot contain an
initializer.
User Action: Remove the initializer from the
declaration.
FUNCMEM, The member name has a function type.
Description: A struct or union member is declared with
function type. This is not valid.
User Action: Correct the member declaration.
FUNCMIXPTR, contextfunction types differ because this
declaration specifies "type1" and a previous declaration
specifies "type2".
Description: A function redeclaration differs from an
earlier declaration of the same function because the pointer size of
one of the arguments or the return result is different.
User Action: Use the same pointer size for all
declarations of the function.
FUNCNOTDEF, The function "name" has non-extern storage class,
occurs in a context that requires its definition, and has no
definition. The storage class has been changed to extern.
Description: In certain modes, the compiler will allow
a static function to be declared within the scope of another function.
If this function is referenced, then it must also be defined in the
compilation unit. If the function is not defined, this message will be
output, and the earlier static declaration will be changed to extern.
User Action: Define the static function with
compilation unit.
FUNCNOTFUNC, In this function definition, "name" has
type type instead of a function type.
Description: A function definition does not have a
function type. This can occur if the definition did not contain an
open/close parenthesis pair.
User Action: Change the definition to specify a
function type.
FUNCREDECL, contextfunction types differ because one has no
argument information and the other has an ellipsis.
Description: Two function types, used in an operation
or a redeclaration of a function, are different because one uses
ellipses and the other does not. Older compilers will accept this, but
it is not valid standard C.
User Action: If used in an operation, a cast should be
inserted. If used in a redeclaration, the redeclaration should be
removed or modified.
FUNCSTORCLS, contexta function has an explicit storage class
other than "static" or "extern".
Description: This declaration specifies a storage
class that is not valid for a function. If an explicit storage class is
used in a function declaration, it must be either static or extern.
User Action: Either remove the storage class
specifier, or use one of the valid storage classes.
FUNCSTORMOD, contexta function cannot have this storage class
modifier. Modifier ignored.
Description: A function cannot be declared with this
storage class modifier. The only valid storage class modifier for a
function declaration is __inline. The modifier is ignored by the
compiler.
User Action: Remove the storage class modifier from
the function declaration.
FUNCSTRCLS, The block-level declaration of the function "name"
specifies an explicit storage class other than extern.
Description: A block-level declaration of a function
has specified an explicit storage class other than extern. HP C will
change the storage class to extern.
User Action: Either remove the storage-class
specifier, or change it to extern.
FUTUREKEYWD2, "inline" is a keyword in the C99 revision of the C
standard. Using it as an identifier will prevent your program from
conforming to that standard.
Description: The token inline has been selected as a
keyword in the C99 release of the C standard. Because the program uses
it as an identifier, the program will not conform to that standard.
User Action: Change the name of the identifier.
FUTUREKEYWORD, "restrict" is a keyword in the C99 revision of the C
standard. Using it as an identifier will prevent your program from
conforming to that standard.
Description: The token restrict has been selected as a
keyword in the C99 release of the C standard. Because the program uses
it as an identifier, the program will not conform to that standard.
User Action: Change the name of the identifier.
GBLOUTSIDEINT, context the globalvalue constant value
is outside the range of type int. This may cause unexpected results.
Description: The C compiler does not support
globalvalue constants larger than int. The compiler preserves only the
low-order 32 bits of the value, which will be sign-extended by the
linker if the symbol is used in a certain contexts requiring a 64-bit
value. This may cause unexpected results.
User Action: Use constants within the range of type
int to initialize globalvalues, or use more portable constructs such as
macro definitions or global const-qualified variables to share constant
values among compilation units.
GBLREFINIT, The declaration of "name" specifies the globalref
storage class and includes an initializer.
Description: A declaration with storage class
globalref cannot include an initializer.
User Action: Either remove the initializer or use a
storage class that will allow an initializer.
GCCINLINE, The inline and __inline keywords will be interpreted with
GCC style semantics. To get C99 semantics, please specify -accept
nogccinline.
Description: The C99 standard has a slightly different
interpretation of the keyword inline than in GCC. The GCC __inline
keyword also differs from the HP C __inline keyword.
User Action: Use the command line specifier -accept
nogccinline.
GEMARGSIZE, contextthe size of "expression" exceeds
the implementation's limit of 2147483647 bytes on the size of a
function argument.
Description: The size of a function argument exceeds
the HP C implementation limit.
User Action: Either reduce the size of the argument or
consider passing it by reference.
GLOBALEXT, A storage class of globaldef, globalref, or globalvalue is a
language extension.
Description: These storage classes are language
extensions of HP C. Other C compilers might not successfully compile a
program that uses the extension.
User Action: These storage classes can be recoded
using the more portable #pragma extern model.
|
