 |
dec_c_help.HLP
ABSTRACTDCL
Message Invalid abstract declarator.
Description An identifier was encountered in an abstract
declarator. An abstract declarator is used to
specify a type only and must not contain an
identifier that specifies a declarator.
User Action Correct the abstract declarator.
ADDRARRAY
Message <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
Message <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
Message <Context> taking the address of a void type is a
language extension.
Description The HP C compiler will allow taking the address of a
void type for compatibility with other compilers.
This is an extension to the standard. Other
compilers may reject this.
User Action Be aware of this if you plan to port this source to
another compiler.
ADDRSUBCONST
Message <Context> accepting 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
Message <Context> the 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
Message <Context> the 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
Message 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
Message _align is a language extension.
Description The _align storage class modifier is a language
extension of HP C. Other C compilers might not
successfully compile a program that uses the
extension.
User Action Be aware of this extension if you wish to port the
code.
ALIGNPOP
Message This "restore" has underflowed the member alignment's
stack. No corresponding "save" was found.
Description The member_alignment stack, managed by the #pragma
member_alignment and #pragma environment directives,
contains more restores than saves. This could
signify a coding or logic error in the program.
User Action Make sure each restore has a corresponding save.
ALREADYTLS
Message 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
Message <Context> a 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
Message <Context> taking 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
Message <Context> the function call specifies an argument
list whose length exceeds maximum specified by the
calling standard. Any use of va_count by the called
function will be wrong.
Description The OpenVMS calling standard uses a byte-sized field
to specify the size of the argument list. The
argument list to this function call requires more
storage than can be represented in this size. As a
result, any use of va_count in the called function
will return inaccurate information.
User Action Either reduce the size of the argument list, or do
not use va_count in the called function.
ARGLISTOOLONG
Message <Context> the function call specifies an argument
list whose length exceeds the VAX architecture limit.
This call allocates stack space that is never
deallocated by the called program.
Description The OpenVMS VAX Calling Standard requires that the
called program deallocate the storage allocated for
its arguments. This is done by looking at the
byte-size value that holds the argument list size.
However, the argument list to this function call
requires more storage than can be represented in a
byte. As a result, the called function will not
deallocate the proper amount of storage. This could
result in unpredictable behavior.
User Action Reduce the size of the argument list.
ARGSIZE
Message <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
Message <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
Message <Context> HP 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
Message Integer overflow occurred when computing the size of
an array type.
Description An array type is larger than allowed on this
platform.
User Action Reduce the size of the array type. It may be
possible to use a pointer type instead of a large
array. The storage can still be accessed using array
syntax.
ARRNOTLVALUE
Message <Context> accepting a non-lvalue array in a subscript
operator is an extension to the C89 standard.
Description The C89 standard states that one of the operands to
the subscript operator must be a pointer. However,
the array used in this operator could not be
converted to a pointer because it is not an lvalue.
Therefore this code does not conform to the C89
standard and may not be accepted by other compilers.
Note that the C99 standard allows this because all
arrays are converted to pointers, not just lvalue
arrays.
User Action Be aware of this difference if you plan to port this
source to another compiler.
ASMCOMEXP
Message 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
Message 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
Message Floating point load-immediate instructions require a
.s file
Description Using a floating point load immediate instruction in
this asm directive will require the compiler to
produce an .s file and invoke the assembler to
process this source.
User Action Do not use floating point load immediate instructions
in asm directives.
ASMFREGEXP
Message 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
Message 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
Message 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
Message 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
Message 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
Message 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
Message 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
Message 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
Message Unusual ldgp requires a .s file
Description This indicates that a ldgp pseudo-instruction was
encountered in an unusual place or with unusual
arguments. The assembler will be invoked on the .s
file.
User Action Correct the asm directive.
ASMLPAREXP
Message 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
Message 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
Message <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
Message <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
Message 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
Message 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
Message <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
Message 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
Message 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
Message 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
Message 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
Message 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
Message 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
Message 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
Message <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
Message <Context> relaxed struct or union type compatibility
is a language extension.
Description In certain modes, the compiler will allow assignments
or comparisons between structs or unions of different
types if their sizes are the same. This is an
extension to standard C. Other C compilers might not
successfully compile a program that uses this
extension.
User Action Recode the operation to use one of the memxxx
run-time library functions.
ASSUMEONEELEM
Message 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.
AUTOALIGN
Message The alignment boundary of an automatic cannot be
greater than longword.
Description For automatic variables, the storage class modifier
_align cannot specify an alignment greater than
longword on VAX systems. The alignment will be set
to longword.
User Action Decrease the alignment. If a larger alignment is
required, declare the variable with static storage
class.
AUTOEXTERNAL
Message <Context> a storage class of "auto" or "register" is
illegal at file scope.
Description The storage classes auto and register can only be
used in a declaration that appears inside a function.
They cannot be used in a declaration at file scope.
User Action Remove the storage class specifier or move the
declaration inside a function body.
BADALIAS
Message 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
Message Invalid alignment boundary.
Description The _align storage class modifier was given an
invalid value. See documentation for valid values on
each platform.
User Action Supply a correct value or remove the _align storage
class modifier.
BADANSIALIAS
Message 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
Message <Context> pointer 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
Message <Context> the array bounds are incorrectly specified.
Description A multi-dimensional array declaration contains a
missing dimension specifier in a dimension other than
the first.
User Action Correct the declaration.
BADBREAK
Message This break statement is not within a for, while, do,
or switch statement.
Description A break statement can only appear inside a for,
while, do, or switch statement.
User Action Remove the break statement, or replace it with a goto
statement.
BADC99PRAGOP
Message Invalid syntax for the C99 _Pragma operator, its
operands cannot be recognized.
Description After macro expansion and whitespace has been
removed, the C99 _Pragma keyword must be followed by
exactly three tokens: left-parenthesis,
string-literal (or wide-string), right-parenthesis.
Any other sequence cannot be processed, and will
likely produce other spurious compile-time
diagnostics.
User Action Correct the syntax, or compile in a language mode
that does not recognize the C99_Pragma operator (e.g.
if your code has used this reserved identifier for
some other purpose).
BADCHARSINHDR
Message Illegal characters after header name.
Description While processing an #include directive whose argument
did not start with either a '<' or '"' character, the
compiler encountered a character it did not expect.
This most often occurs when the directive argument is
a macro and there is an error during the expansion of
that macro.
User Action Correct the argument to the #include directive.
BADCMMNTPSTNG
Message Token concatenation with comments might not be
portable -- use ## operator.
Description A macro body contains a comment between two tokens
with no white space either before or after the
comment. Older C compilers allowed this as a form of
token pasting. This type of token pasting might not
give the desired results with newer compilers.
User Action Use the standard C form of token pasting by replacing
the comment with the ## token pasting operator.
BADCOMLITTYPE
Message <Context> the 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
Message <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
Message <Context> a 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
Message Syntax error in constant expression.
Description A preprocessing constant expression contained a
syntax error. The preprocessor was expecting to find
a constant value or a left parenthesis. The
preprocessor will assume a value of zero was
encountered.
User Action Correct the preprocessing constant expression.
BADCONTINUE
Message This continue statement is not within a for, while,
or do statement.
Description A continue statement can only appear inside a for,
while, or do statement.
User Action Remove the continue statement, or replace it with a
goto statement.
BADCONVSPEC
Message <Context> this 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
Message 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
Message Invalid argument to __declspec. Valid arguments are
"thread" or "__thread".
Description The only valid arguments to the __declspec storage
class modifier are "thread" or "__thread".
User Action Either use one of the valid arguments, or remove the
storage class modifier.
BADDEFARG
Message Bad argument for "defined" operator.
Description The defined preprocessing operator was given an
invalid argument. The operator expects an identifier
optionally enclosed in parenthesis. The value of the
operator is undefined.
User Action Supply a valid argument to the preprocessing
operator.
BADENUM
Message Invalid enumerator.
Description While processing an enumerator list, the compiler was
expecting to encounter an identifier, but it found
something else instead.
User Action Correct the program syntax.
BADENUMREDECL
Message <Context> the 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
Message Invalid expression.
Description An invalid expression was encountered.
User Action Correct the program syntax.
BADFATCOMMENT
Message The compiler cannot recover.
Description In certain cases, the compiler cannot proceed after
an unterminated comment. In these cases this message
will be issued. Note that this message is always
output after the opencomment error has been output.
User Action Terminate the comment before the end-of-file.
BADFBDAT
Message <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
Message 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
Message 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
Message <Context> this 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
Message This token may not appear in a formal parameter list.
Description While processing the formal parameter list of a macro
definition, the compiler encountered an invalid
formal parameter specifier. The macro will be be
defined and this token will ignored, but that may not
have been what you intended.
User Action Correct the formal parameter list so that it consists
of a comma separated list of identifiers.
BADFORSTOCLS
Message The declaration in a for loop can only have storage
class auto or register.
Description The declaration in a for loop contains a storage
class specifier other than auto or register. This is
not allowed.
User Action Correct the storage class.
BADFUNCSTOCLS
Message 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
Message 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
Message Invalid include file or header name specification.
Description An #include directive was not followed by a valid
argument. The directive will be ignored. The
#include directive should be followed by either a
file specification enclosed in angle brackets, a file
specification enclosed in quotes, or an identifier
that specifies a text module (OpenVMS only), or a
macro to be expanded.
User Action Supply a valid argument to the #include directive.
BADHEXCONST
Message Hex constant value too large.
Description A hex constant used in a preprocessor directive is
too large. The value of the constant will be
undefined.
User Action Decrease the value of the constant.
BADIDENTUCN
Message Invalid UCN encountered in an identifier.
Description An identifier contained a Universal Character Name
(UCN) that did not conform to the requirements of C99
Annex D for use of UCNs in identifiers.
User Action Specify a valid UCN sequence.
BADIFDEF
Message An #ifdef or #ifndef is not followed by an
identifier.
Description An #ifdef or #ifndef preprocessing directive was not
followed by an identifier. The compiler will
consider the preprocessor argument to be an
identifier that is not defined. Therefore, in these
cases an #ifdef will always be FALSE, and an #ifndef
will always be TRUE.
User Action Supply a valid identifier to the directive.
BADIFNDEFARG
Message #ifndef argument is not an identifier.
Description An #ifndef preprocessing directive was not followed
by an identifier. The compiler will consider this to
be a TRUE condition.
User Action Supply a valid identifier to the directive.
BADINCLDIR
Message The #pragma include_directory must not appear after
an #include directive or in a /FIRST_INCLUDE file
after the first /FIRST_INCLUDE file has been
processed. The directive will be ignored.
Description There are several restrictions on the placement of
the #pragma include_directory directive. It must not
appear after any #include directive has been
encountered. Also, if /FIRST_INCLUDE is specified on
the command line, all #pragma include_directory
directives must be placed in the first file in the
/FIRST_INCLUDE list (if there is more than one in the
list) or in the the main source before any #include
directives (if there is only one file in the
/FIRST_INCLUDE list).
User Action Place the directive in a valid location.
BADINCLDIRSIZE
Message 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
Message An #include directive has illegal syntax.
Description An #include directive was not followed by a valid
argument. This message occurs when the argument
starts with a '<' or '"' character, but does not end
with a matching delimiter. In this case the compiler
will add the matching delimiter to the end of the
argument and process the directive normally.
User Action Correct the argument to the #include directive.
BADLINEDIR
Message Missing argument for #line directive.
Description An argument was not supplied to a #line preprocessing
directive. This directive must be followed by a
digit sequence that specifies the line number or a
macro that expands to a digit sequence. The
directive will be ignored.
User Action Supply a valid argument to the directive.
BADLINEDIRTV
Message Illegal token in #line directive.
Description A #line directive was followed by an invalid
argument. The #line directive should be followed by
either a digit sequence or a digit sequence followed
by a string literal. The #line directive will be
ignored.
User Action Supply a valid argument to the #line directive.
BADLINKREG
Message 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
Message Ignoring the line number for the #line directive --
too small.
Description A #line preprocessing directive specified a line
value that is either zero or less than zero. This is
not valid. The directive will be ignored.
User Action Either remove the directive or supply a positive
value to the line specifier.
BADLOCALE
Message The compiler could not set its locale to either the
locale-specific native environment or the "C" locale.
Description During start-up, the compiler was unable to set its
locale. As part of its initialization, the compiler
will issue the call setlocale(LC_ALL, ""). If this
call fails, the compiler will try to issue the call
setlocale(LC_ALL, "C"). If this call also fails, the
compiler will issue this message and abort.
User Action The best way to determine why the compiler is failing
is to write a small program that contains the same
library calls the compiler is making and then examine
the return values.
BADMACROINLN
Message Illegal token from macro call in #line directive.
Description A #line directive was followed by a macro whose
expansion did not form a valid argument to the
directive. The #line directive should be followed by
either a digit sequence or a digit sequence followed
by a string literal. The #line directive will be
ignored.
User Action Supply a valid argument to the #line directive.
BADMACRONAME
Message "<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
Message An invalid multibyte character was encountered in a
comment.
Description An invalid multibyte character was found in a
comment. While this will not affect the program
execution, it might not have been what you intended.
User Action Correct the multibyte character.
BADMCRORECURS
Message 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
Message Invalid member declaration.
Description A struct or union contains an invalid member
declaration. In most cases this error occurs when a
semi-colon was omitted from the previous member
declaration.
User Action Correct the declaration.
BADMEMOFF
Message <Context> multiple 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
Message <Context> multiple 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
Message Invalid identifier found immediately following
"#pragma module" or "#module" directive.
Description The #pragma module or #module directive must be
followed by an identifier that specifies the module
name used by the linker.
User Action Correct the directive.
BADMULTIBYTE
Message 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
Message <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
Message Octal constant value too large.
Description An octal constant used in a preprocessor directive is
too large. The value of the constant will be
undefined.
User Action Decrease the value of the constant.
BADOPCCAP
Message <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
Message 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
Message 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
Message 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
Message File ends in an unfinished pp directive.
Description An unexpected end-of-file was encountered during a
preprocessing directive.
User Action Correct the directive.
BADPRAGMAARG
Message 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
Message 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
Message A bad linkage pragma was specified. Pragma is
ignored.
Description The compiler encountered a bad #pragma linkage
directive. The error message should point to the
place in the pragma that the compiler considers bad.
The compiler will ignore the entire pragma.
User Action Correct the directive.
BADPRAGNAMES
Message Invalid argument to the pragma names directive.
Pragma is ignored.
Description An invalid argument has been specified for the
#pragma names preprocessing directive.
User Action Correct the argument to the pragma.
BADPREFIX
Message Argument to extern_prefix is not a recognized keyword
or a quoted string. Pragma is ignored.
Description An invalid argument has been specified for the
#pragma extern_prefix preprocessing directive. The
directive expects either the identifiers "save",
"__save", "restore", "__restore", or a string
constant that specifies the external prefix to use.
The compiler will ignore the pragma.
User Action Correct the argument to the pragma.
BADPROTYP
Message 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
Message <Context> performing pointer arithmetic on a pointer
to void or a pointer to function is not allowed. The
compiler will treat the type as if it were pointer to
char.
Description Pointer arithmetic is not allowed on pointers to
function or void types For compatibility with some
other compilers, an output file is still created.
The result produced will be the same as if the
pointer were a pointer to char. This may or may not
be compatible with other compilers that accept this
syntax.
User Action Cast the pointer type to a pointer to object type
before performing the arithmetic.
BADREGISTER
Message <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
Message <Context> a 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
Message 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
Message <Context> the address cannot be converted to the
destination type.
Description A static initialization tried to convert a link-time
address to another type. However, the linker on this
platform will not support such a conversion.
User Action Rewrite the static initialization, or perform the
initialization using runtime code.
BADSTDLINKAGE
Message If standard_linkage is used, it must be the only
characteristic specified.
Description The standard_linkage characteristic cannot be used
with any other linkage characteristic.
User Action Correct the pragma.
BADSTMT
Message Invalid statement.
Description An invalid statement was encountered. The most
common cause of this error is when a declaration
appears after the first statement in a compound
statement.
User Action Correct the program syntax.
BADSTMT1
Message Invalid statement. This condition may have been
caused by an open brace without a matching close
brace. The compiler will attempt to identify open
braces that might be missing a close brace.
Description An invalid statement was encountered. This condition
may have been caused missing close brace. This
message is followed by some number of additional
messages that attempt to identify
User Action Correct the program syntax.
BADSUBSCRIPT
Message <Context> an array subscript expression is either
less than zero or greater than the largest value that
can be represented by the size_t type.
Description The compiler has detected an array subscript
expression that is outside the bounds of any valid
array. The array access might cause unpredictable
behavior.
User Action Specify a valid array subscript.
BADTARGMACRO
Message 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
Message Lexically invalid token.
Description An invalid token was encountered in a preprocessing
directive.
User Action Correct the preprocessing directive.
BADUNKNOWNVLA
Message <Context> a "*" bounds specifier is invalid. Using a
"*" to specify a variable-length array of unknown
size is only valid in declarations with function
prototype scope.
Description Using a "*" as a bounds specifier to designate a
variable-length array with unknown size is only valid
in declarations with function prototype scope.
User Action Supply a valid bound specifier.
BADUNROLLVAL
Message 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
Message A bad use_linkage pragma was specified. Pragma is
ignored.
Description The compiler encountered a bad #pragma use_linkage
directive. The error message should point to the
place in the pragma that the compiler considers bad.
The compiler will ignore the entire pragma.
User Action Correct the directive.
BADUSERMACRO
Message 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
Message <Context> old-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
Message 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
Message <Context> use 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
Message 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
Message <Context> the 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
Message 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
Message <Context> the bitfield type is not an integral type.
Description A bitfield has been declared with a non-integral
type. Standard C requires that all bitfields be
declared with either int, unsigned int, or signed int
type.
User Action Change the type of the bitfield.
BITCONSTSIGN
Message <Context> the 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
Message 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
Message <Context> the bitfield type is not an int, signed
int, unsigned int or _Bool.
Description A bitfield has been declared with a type other than
int, signed int, unsigned int or _Bool. This is not
allowed by the C standard.
User Action Change the declaration to use one of the allowed
types or compile with a standard mode that allows
this behavior.
BITWIDTH
Message <Context> the 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
Message <Context> the 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
Message <Context> the 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
Message Block level declarations of inline functions are not
allowed.
Description In C99 standard, block level declaration of inline
functions are prohibited.
User Action Move the inline function declaration to file scope.
BLTINARGCNT
Message <Context> an 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
Message <Context> for 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
Message The _Bool data type is a new feature in the C99
standard. Other C compilers may not support this
feature.
Description This is a new language feature in C99. While having
a standard specification for portability, the feature
may not yet be available in all of the compilers you
use.
User Action Determine whether or not the use of this feature will
cause portability problems for this code.
BOOLNA
Message The _Bool keyword is not supported in this language
mode. It will be treated as an identifier in this
compilation.
Description Support for the _Bool keyword is only available in
certain language modes. Support is not present when
the compiler is in VAX C, K & R (common), or strict
ANSI89 standard modes. In these language modes _Bool
will be treated as an identifier.
User Action Compile using one of the other compilation modes.
BOUNDADJ
Message 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
Message <Context> the 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
Message Compiler bugcheck. Submit a problem report with a
problem description.
Description An unexpected condition occurred in the compiler.
This is most likely caused by a compiler bug.
User Action Reduce the program that is causing the failure as
much as possible. This often leads to a small test
case. Please submit a problem report containing
enough information for Engineering to reproduce the
problem. The problem report should include the small
test case.
CALLNEEDSFUNC
Message <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
Message Cannot #define a macro that is currently expanding.
Description The program is trying to #define the same macro it is
currently expanding. The #define will be ignored.
User Action Remove the #define, or move it after the expansion of
the macro.
CANNOTUNDEF
Message Cannot #undef a macro that is currently expanding.
Description The program is trying to #undef the same macro it is
currently expanding. The #undef will be ignored.
User Action Remove the #undef, or move it after the expansion of
the macro.
CANTDISABLE
Message 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
Message 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
Message One or more field descriptions in this CDD record
specify an attribute that is being ignored.
Description The CDD description specifies an attribute that is
not supported in HP C. The attribute is ignored.
User Action No action is required.
CDDBADID
Message 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
Message #dictionary is a language extension.
Description The #dictionary directive is an extension of HP C on
OpenVMS. The program might not compile with other
compilers or on other platforms.
User Action Be aware of this if you wish to port the program.
CDDPATH
Message A valid CDD pathname was not found. The CDD
directive has been ignored.
Description The #dictionary preprocessing directive was not
followed by an argument. The directive must be
followed by a character string that gives the path
name of a CDD record, or a macro that expands to the
path name of the record.
User Action Supply a valid argument to #dictionary. HP also
recommends that the #dictionary preprocessing
directive be replaced by the #pragma dictionary
operator.
CDDTOODEEP
Message 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
Message Ill-formed character constant.
Description An invalid character constant was encountered.
User Action Correct the character constant.
CHAROVERFL
Message A character constant value requires more than
sizeof(int) bytes of storage.
Description A character constant is too long to fit in an int.
The compiler will ignore the extra characters.
User Action Remove the extra characters from the character
constant.
CHKEXPAND
Message <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
Message <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
Message <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
Message <Context> the 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
Message Missing "]".
Description The compiler was expecting a closing bracket, but one
was not found.
User Action Correct the program syntax.
CLOSEBRACE
Message Missing "}".
Description The compiler was expecting a closing brace, but one
was not found.
User Action Correct the program syntax.
CLOSECOMMENT
Message This unmatched comment delimiter is ignored.
Description An unmatched comment delimiter (*/) is an illegal
combination of unary indirection and binary division
operators that would have caused your compilation to
fail.
User Action Remove the comment delimiter.
CLOSEPAREN
Message Missing ")".
Description The compiler was expecting a closing parenthesis, but
one was not found.
User Action Correct the program syntax.
CMPPTRFUNVOID
Message <Context> accepting the [in]equality comparison of a
pointer to void and a pointer to function type is a
language extension.
Description Under the C standard, it is a constraint violation to
perform an [in]equality comparison between a pointer
to void and a pointer to function type. Therefore
this code may not be accepted by other compilers.
User Action Cast one of the pointers to the type of the other.
COLMAJOR
Message 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
Message 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
Message 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
Message The complex data type is a new feature in the C99
standard. Other C compilers may not support this
extension.
Description This is a new language feature in the C99 revision of
the standard. While having a standard specification
for portability, the feature may not yet be available
in all of the compilers you use.
User Action Determine whether or not the use of this feature will
cause portability problems for this code.
COMPLEXNA
Message The complex data types are not supported in this
language mode. This will be treated as an identifier
in this compilation.
Description Support for the complex data types is only available
in certain language modes. Support is not present
when the compiler is in VAX C, K & R (common), or
strict ANSI89 standard modes. In these language
modes _Complex and _Complex_I will be treated as
identifiers.
User Action Compile using one of the other compilation modes.
COMPLEXNA1
Message The complex data types are not supported on this
platform. This will be treated as an identifier in
this compilation.
Description The complex data type is not supported on the VAX
platform.
User Action Remove use of the complex types or compile the
application on a platform that does support the
complex data types.
CONFLICTHINTS
Message <Context> this 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
Message 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
Message Conflicting psect attribute overrides previous
attribute.
Description A psect attribute specified in a #pragma extern_model
directive contradicts an attribute specified earlier
in the directive. This attribute will override the
one specified earlier.
User Action Remove one of the contradictory psect attributes.
CONSTCOMPLIT
Message <Context> accepting a compound literal as a constant
is a language extension. The compound literal will
be treated as a cast expression.
Description A compound literal appears in a context where a
constant expression is required. The C standard does
not list compound literals as a form of operand that
is allowed in a constant expression, so using a
compound literal in this context is not maximally
portable. The compiler will treat the compound
literal as if it were a cast expression, which is a
form of operand that the standard lists as being
allowed in constant expressions.
User Action For maximum portability, replace the compound literal
with a cast expression.
CONSTFOLDNS
Message <Context> the 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
Message 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
Message Const variable resides in wrt extern model.
Description The current extern model places all external objects
in a modifiable section. Placing an object with a
const type qualifier in such a section means that
there is no run-time protection against writing to
the object. This might not have been what you
intended.
User Action Place const objects in sections that cannot be
modified.
CONSTNOINIT
Message <Context> the 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
Message <Context> the 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
Message A file ends with a continuation character.
Description All source files, even those included via the
#include preprocessing directive, must not end with a
backslash continuation character.
User Action Either remove the continuation character or add an
additional line to the source program that does not
end in a continuation character.
CONTROLASSIGN
Message <Context> the 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
Message <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
Message Common Data Dictionary description extraction
condition.
Description Something went wrong while trying to get the CDD
record description from the CDD. The error message
that follows gives more information about the nature
of the problem.
User Action If necessary, correct the indicated condition in the
CDD record description or with the user environment.
CVIDXOVFL
Message module uses more than 65536 CodeView type indices
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
CVTDIFTYPES
Message <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
Message <Context> an unsigned 32-bit integer constant that
has its high-order bit set has been converted to a
signed 64-bit type. The conversion will not
sign-extend.
Description This message indicates a conversion that may produce
unexpected results on this platform because the
destination type is a 64-bit type instead of a 32-bit
type.
User Action If this is the intended behavior, first cast the
constant to an unsigned 64-bit type.
CXXCOMMENT
Message C++ style comments (//) may not be portable.
Description C++ style comments have been detected on this line.
Although they have been accepted by HP C in this
language mode, they will not be accepted by all
compilers or by HP C in strict C89 standard mode.
User Action Replace C++ style line comments (//) with equivalent
C comments (/* ... */) if portability is a concern.
CXXKEYWORD
Message "<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
Message 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
Message 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
Message 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
Message <where> "<name>" <modifier>has 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
Message <where> "<name>" <modifier>requires 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
Message <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
Message <where> "<name>" <modifier>has 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
Message "<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
Message <where> "<name>" <modifier>has 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
Message Decimal constant value too large.
Description A decimal constant used in a preprocessor directive
is too large. The value of the constant will be
undefined.
User Action Decrease the value of the constant.
DECLAFTERSTMT
Message Placing a declaration after a statement is a new
feature in the C99 standard. Other C compilers may
not support this feature.
Description This is a new language feature in the C99 revision of
the standard. While having a standard specification
for portability, the feature may not yet be available
in all of the compilers you use.
User Action Determine whether or not the use of this feature will
cause portability problems for this code.
DECLARATOR
Message Invalid declarator.
Description A declaration did not contain an identifier that
specifies the item to be declared.
User Action Specify a declarator in the declaration.
DECLINFOR
Message Placing a declaration in a for loop is a new feature
in the C99 standard. Other C compilers may not
support this extension.
Description This is a new language feature in the C99 revision of
the standard. While having a standard specification
for portability, the feature may not yet be available
in all of the compilers you use.
User Action Determine whether or not the use of this feature will
cause portability problems for this code.
DECLSPECEXT
Message __declspec is a language extension.
Description The __declspec storage class modifier is a language
extension of HP C. Other C compilers might not
successfully compile a program that uses the
extension.
User Action Be aware of this extension if you wish to port the
code.
DEFINOTHER
Message 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
Message 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
Message 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
Message 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
Message 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
Message 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
Message <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
Message <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
Message <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
Message <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
Message The use of a designation in an initializer list is
not supported in this compilation mode.
Description Initializer lists that contain designations are a new
feature in the C99 revision of the C standard. HP C
will only support this extension in relaxed mode and
strict c99 mode.
User Action Use a compilation mode that supports the use of
designations.
DESIGNATORUSE
Message The use of a designation in an initializer list is a
new feature in the C99 standard.
Description Initializer lists that contain designations are a new
feature in the C99 revision of the C standard. Other
compilers may not support this feature.
User Action Be aware of this portablility issue.
DESIGNOMEMB
Message <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
Message <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
Message 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
Message <Context> the 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
Message "<Directive text>" is not recognized as a
preprocessing di |
