 |
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 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
Message <Context> the 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
Message Extension: A '$' was encountered in an identifier.
Description Accepting a "$" character in an identifier is an
extension of HP C. The program might not compile
with other C compilers.
User Action Be aware of this if you wish to port the program.
DONOTAPPLY
Message 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
Message 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
Message The switch statement containing this default label
already has a default label.
Description A switch statement can contain only one default
label.
User Action Remove the duplicate default label.
DUPENUM
Message <Context> the 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
Message 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
Message 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
Message 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
Message #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
Message <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
Message There is a redundant use of the keyword "static" in
this array declaration.
Description In C99 the keyword "static" may appear at most once
in the outermost array-bounds specifier of a function
parameter in a function prototype.
User Action Remove redundant occurrences(s) of "static" from the
array declaration
DUPSTORCLS
Message <Context> the same storage class modifier occurs more
than once.
Description This declaration specifies the same storage class
modifier more than once.
User Action Remove the extra uses of the storage class modifier.
DUPTYPEDEF
Message <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
Message <Context> the same type specifier occurs more than
once.
Description The same type specifier appears more than once in the
same declaration. The redundant specifier will be
ignored.
User Action Remove the duplicate type specifier.
DUPTYPQUAL
Message <Context> there 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
Message Out of place #elif directive ignored.
Description An #elif preprocessing directive was encountered
outside of an #if/#endif body. The directive will be
ignored.
User Action Remove the directive.
ELLIPSEARG
Message Standard C does not permit the use of an ellipsis as
an only argument.
Description Standard C requires at least one formal parameter be
declared before the ellipses. This declaration might
not be portable to other C compilers.
User Action Recode the function declaration to contain at least
one formal parameter.
ELLIPSEPARM
Message <Context> a 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
Message No tokens may follow ... in a formal parameter list.
Description The ellipsis may only appear at the end of a formal
parameter list. Everything after that is being
ignored.
User Action Remove the unexpected token.
ELSEIGNORED
Message Out of place #else directive ignored.
Description An #else preprocessing directive was encountered
outside of an #if/#endif body. The directive will be
ignored.
User Action Remove the directive.
EMBEDCOMMENT
Message A comment is neither preceded nor followed by white
space.
Description A comment is neither preceded nor followed by white
space. In certain modes the compiler will paste the
tokens before and after the comment together to form
a single token. This behavior is not valid in
standard C. Writing programs that rely on this
behavior might prevent the program from being
compiled on other platforms.
User Action Add white space before or after the comment, or use
the ## operator to paste tokens together.
EMPTYCHARCONST
Message Empty character constant.
Description In some modes the HP C compiler will allow a null
character constant. The compiler will give this
constant a value of zero. Accepting an empty
character constant is a language extension. Empty
character constants are not valid in standard C.
Writing programs that rely on this behavior might
prevent the program from being compiled on other
platforms.
User Action Replace the empty character constant with '\0'.
EMPTYFILE
Message Source file does not contain any declarations.
Description This source file contains no declarations. This
might not have been what you intended. For example,
perhaps a necessary macro was not defined.
User Action Every source program should contain at least one
declaration.
EMPTYINIT
Message An initializer list without an expression is not
valid. The compiler will replace the empty
expression with the constant 0.
Description The C standard requires that an initializer list
contain an expression. The compiler has encountered
one without an expression. The compiler will treat
the empty list ({}) as if it contained a single zero
({0}). This is for compatibility with some other C
compilers. Be aware that this syntax may not be
accepted by other C compilers.
User Action Supply an expression to the initializer.
EMPTYOBJ
Message Empty object file due to errors.
Description An earlier condition will cause an empty object
module to be created.
User Action Correct the condition that was reported earlier.
EMPTYSTRUCT
Message Allowing struct/union type with no members is a
language extension.
Description The C standard requires that a struct/union type have
at least one member. The HP C compiler will accept
this for compatibility with older compilers. The
struct/union type will be treated as if it were
declared { : 0; }
User Action Provide at least one member for the struct/union.
ENUM16BIT
Message <Context> the 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
Message <Context> the 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
Message <Context> the 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
Message <Context> the 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
Message <Context> allowing an enumeration type and a signed
int to be compatible may not be portable.
Description The standard states that enumeration types shall be
compatible with an integer type. HP C, along with
most other C compilers, has chosen the signed int
type to be compatible with enumeration types. Other
compilers may chose another type such as unsigned int
(the C standard even allows an implementation to
choose different integer types depending on the
values of the enumeration constants defined for the
type). Therefore this program may not be accepted by
other C compilers.
User Action Insert a cast to make the types the same.
ENUMSNOTCOMPAT
Message <Context> allowing two different enumeration types to
be compatible is a language extension.
Description The HP C compiler allows two objects of different
enumeration types to be compatible. The C standard
specifies that enumeration types are distinct types.
Therefore this program is not standard compliant and
other C compilers may not accept it.
User Action Use the same enumeration type or cast one type to the
other.
ENUMUSED
Message <Context> the 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
Message 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
Message diagnostic message limit exceeded
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
ERRORMESSAGE
Message #error<errormsg>
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
Message Invalid escape sequence encountered.
Description An escape sequence in a character or string literal
specifies a value outside the range of a character or
wide character.
User Action Specify a valid escape sequence.
EXPANDEDDEFINED
Message Macro expansion includes the token "defined", which
will be treated as an operator. This might not be
portable.
Description A macro expanded during the processing of a
preprocessor #if directive included the token
"defined". The HP C compiler will treat this as the
defined preprocessing operator. Other compilers
might treat this differently.
User Action Rewrite the macro not to use the "defined" operator.
EXPNOTRES
Message expression does not contribute to result
Description The compiler has detected a source expression that
does not contribute to the result. This may not be
what you expected.
User Action Verify the expression is what you intend.
EXPRCVTINT
Message 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
Message 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
Message <Context> the 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
Message This platform specific type is a language extension.
Description The use of the types __int8, __int16, __int32,
__int64, or other type specifiers beginning with
leading double underscores might not be portable to
other platforms or to other C compilers.
User Action Be aware of this portability concern.
EXTERNINIT
Message HP C allows the initialization of a variable with
extern storage class. This differs from the VAX C
behavior.
Description VAX C does not allow a variable with extern storage
class to be initialized. HP C will allow this, even
in vaxc mode.
User Action Be aware of this difference if you plan to compile
the source with VAX C.
EXTERNPOP
Message This "restore" has underflowed the extern model's
stack. No corresponding "save" was found.
Description The extern_model stack, managed by the #pragma
extern_model and #pragma environment directives,
contains more restores than saves. This could
signify a coding or logic error in the program.
User Action Make sure each restore has a corresponding save.
EXTPREAFTER
Message 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
Message 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
Message 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
Message <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
Message Redundant "#pragma module" or "#module" directive
ignored.
Description A compilation unit can contain only one #pragma
module or #module directive. All subsequent
directives will be ignored.
User Action Remove the extra directives.
EXTRAPRAGARGS
Message 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
Message Extraneous semicolon.
Description An extra semicolon was found at the end of a
declaration. It will be ignored.
User Action Remove the extra semicolon.
FALLOFFEND
Message 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
Message 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
Message 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
Message File not found: <text>
Description The specified file could not be found by the
compiler.
User Action Specify the correct file name.
FILEREAD
Message 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
Message <Context> the 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
Message 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
Message <Context> allowing 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
Message <Context> allowing 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
Message 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
Message Ill-formed floating constant.
Description An invalid floating constant was encountered.
User Action Correct the floating constant.
FLOATERR
Message <Context> a 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
Message <Context> floating-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
Message <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
Message 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
Message 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
Message <Context> the 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
Message 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
Message 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
Message <Context> the 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
Message <Context> the 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
Message 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
Message 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
Message <Context> function 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
Message 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
Message 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
Message <Context> function 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
Message <Context> a 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
Message <Context> a 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
Message 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
Message "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
Message "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
Message <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
Message 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
Message 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
Message <Context> the 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
Message 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. <code_example>
globaldef int var1; globalref int var2; globalvalue
int var3; <endcode_example> Can be written as:
<code_example> #pragma extern_model save #pragma
extern_model strict_refdef int var1; extern int var2;
#pragma extern_model globalvalue extern int var3;
#pragma extern_model restore <endcode_example> For
more information, consult the #pragma extern_model
documentation.
GOTSZOVFL
Message GOT table overflow for module <text>
Description The object file required for this module is too
complex.
User Action Break the source program into several pieces so the
individual objects will be simpler.
HEXOCTSIGN
Message In VAX C mode, the compiler will give this constant a
signed type for compatibility with VAX C. This
differs from the behavior specified in the C
standard, which would give this constant an unsigned
type.
Description The C standard specifies that an octal or hexadecimal
integer constant has an unsigned type when its value
cannot be represented in a signed integer type, but
can be represented in the corresponding unsigned
integer type. Some older compilers, such as VAX C,
will treat this constant as having a signed type. In
VAX C mode, the compiler matches the behavior of VAX
C. In other modes the compiler matches the behavior
specified in the standard.
User Action Be aware that this difference may cause porting
problems if this program is compiled in a mode other
than VAX C mode, or with a compiler that does not
support this old behavior.
HEXOCTUNSIGN
Message The HP C compiler conforms to the C standard and will
give this constant an unsigned type. Some older
compilers may give this constant a signed type.
Description The C standard specifies that an octal or hexadecimal
integer constant has an unsigned type when its value
cannot be represented in a signed integer type, but
can be represented in the corresponding unsigned
integer type. Some older compilers will treat this
constant as having a signed type.
User Action Be aware of this difference if you plan to port this
source to an older compiler.
HINTNOTFUNC
Message The identifier "<ident>" is not a declared function.
It will be ignored in this #pragma hint func_attrs
list.
Description The identifiers in a #pragma hint func_attrs must be
declared functions.
User Action Either declare the function prior to the pragma or
remove the identifier from the pragma.
HINTTOOBIG
Message <Context> this hint value must not be greater than
one. The hint will be ignored.
Description This #pragma hint directives must take positive
floating point values which is not greater than one.
User Action Correct the hint.
IDEXPECTED
Message Identifier expected but not found.
Description The compiler was expecting an identifier, but one was
not found.
User Action Correct the program syntax.
IDINPARENSEXT
Message <Context> accepting an identifier enclosed in
parentheses as the second argument to va_start is a
language extension.
Description The C standard states that the second argument to
va_start must be an identifier. For compatibility
with other C compilers, HP C will accept an
identifier enclosed in parentheses. Be aware that
this program does not conform to the standard and may
be rejected by other compilers.
User Action Remove the parentheses.
IDPACKPOPPRAG
Message The identifier <name> from the pragma pack pop
directive was not found on the top of the pragma pack
stack.
Description The identifier specified in the #pragma pack (pop,
<identifier>) directive was not found on the top of
the pragma pack stack. A previous #pragma pack pop
or #pragma member_alignment restore may have already
popped this identifier off the stack, the identifier
may not have been previously pushed onto the stack,
or extra elements are pushed on the stack on the top
of element with the identifier, or the identifer may
be spelled incorrectly.
User Action Check the spelling of the identifier. Verify that
the identifier was previously pushed onto the pack
stack and not popped off by another #pragma pack pop
or #pragma member_alignment restore, and all elements
pushed on the top of the identifier are popped.
Correct the directive(s).
IEEEASSUMED
Message Use of /ROUNDING_MODE qualifier implies /FLOAT=IEEE.
Compilation will be performed as if /FLOAT=IEEE were
specified on the command line.
Description This compilation has specified an IEEE floating-point
rounding mode without specifying /FLOAT=IEEE on the
command line. The compiler will set the
floating-point type to IEEE floating.
User Action Specify /FLOAT=IEEE on the command line.
IEEEASSUMED1
Message Use of /IEEE_MODE qualifier implies /FLOAT=IEEE.
Compilation will be performed as if /FLOAT=IEEE were
specified on the command line.
Description This compilation has specified an IEEE floating-point
mode without specifying /FLOAT=IEEE on the command
line. The compiler will set the floating-point type
to IEEE floating.
User Action Specify /FLOAT=IEEE on the command line.
IGNORECALLVAL
Message <Context> the value returned from the function
"<expression>" is not used - if this is intended, it
should be cast to "void".
Description A function that returns a value has been invoked, yet
the value was not used. This might not have been
what you intended.
User Action Cast the function to void to suppress the message.
IGNOREEXTRA
Message Spurious token(s) ignored on preprocessor directive
line.
Description A preprocessing directive was supplied more arguments
than it expects. The extra arguments will be
ignored.
User Action Remove the extra arguments.
IGNORETAG
Message <Context> the tag "<name>" is redeclared, but will be
ignored.
Description The "struct" or "union" before the tag used in this
declaration does not match that in the declaration of
the tag. The "struct" or "union" at the earlier
declaration of the tag will be used in this
declaration.
User Action Either change the current declaration to match the
declaration of the tag, or create a new tag
containing the different type.
IGNORETOKENS
Message # not in column 1 is ignored, skipping to end of
line.
Description In K & R mode, white space is not allowed before a
preprocessing directive. The compiler will ignore
this source line.
User Action Either remove the white space or compile in a mode
other than K & R.
IGNORSYSREG
Message Ignoring system register specified in routine's
linkage.
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.
IMAGINARYNA
Message The _Imaginary keyword is not supported by HP C. It
will be treated as an identifier in this compilation.
Description Support for the _Imaginary keyword is an optional
extension to the C standard. HP C does not support
this extension. All occurrences of _Imaginary will
be treated as an identifier.
User Action Do not use the _Imaginary type.
IMPFNCFALLOFF
Message The last statement in non-void function "<name>" is
not a return statement.
Description This message indicates that a function with an
implicit return type of it does not end with a return
statement. If function execution reaches the end of
the function, the implied return statement that
executes will return an undefined value. This might
not have been what you intended.
User Action Consider declaring the function to be a void
function. If it is supposed to return a value, add a
return statement with the value the function is to
return.
IMPFNCMSSNGRET
Message Non-void function "<name>" with implicit return type
int does not contain a return statement.
Description This message indicates that a function with an
implicit return type of int does not contain a return
statement. This message is not issued for functions
with an explicit return type. See message
MISSINGRETURN.
User Action Consider declaring the function to be a void
function. If it is supposed to return a value, add a
return statement with the value the function is to
return.
IMPLICITFUNC
Message <Context> the identifier "<name>" is implicitly
declared as a function.
Description A expression contained a reference to a function that
has not been declared. The C99 standard requires
that all referenced functions must be declared before
they are referenced.
User Action Declare the function before it is referenced.
INCARGTYP
Message Type of actual argument inconsistent with formal
parameter declaration in <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.
INCARRAYPARM
Message <Context> using array syntax to declare a parameter
that is a pointer to an incomplete array type may not
be portable.
Description Although this array parameter declaration conforms to
the C standard (since it is equivalent to a pointer
to the inner array), other C compilers may not accept
it.
User Action Be aware of this difference if you plan to port this
source to another compiler.
INCARRAYPARM1
Message <Context> allowing an array parameter that has more
than two unspecified element counts is a language
extension.
Description Because this parameter declaration will cause an
array of incomplete types to be created, it does not
conform to the C standard. Although some other C
compilers will accept this declaration, many
compilers will reject it.
User Action Be aware of this difference if you plan to port this
source to another compiler.
INCLUDENOPEA
Message A non-default pointer size or member alignment is
specified, and the header files in <directory> are
not protected. This might yield unpredictable
results. The protect_headers_setup script can help.
See the protect_headers_setup(8) man page for
details.
Description Using a non-default pointer size or member alignment
can cause unpredictable results for system header
files that are not protected and that rely on the
default pointer size or alignment.
User Action Examine the man page referenced in the message for
more information.
INCLUDEOPEN
Message An error occurred while attempting to open the
include file <name>: <problem>.
Description An unexpected error occurred during the opening of an
include file. The message text will contain
additional information about the failure.
User Action Correct the condition that caused the failure.
INCLUDEPROEPI
Message Cannot include files in a prologue or epilogue file.
Description It is not possible for a prologue or epilogue file to
perform an #include directive. This might lead to
nested inclusion.
User Action Remove the #include directive from the
prologue/epilogue file.
INCOMPARRY
Message <Context> the member <name> has incomplete array
type. This is not strictly conformant with the C
standard and might not be portable.
Description The compiler has detected an array without a bounds
specifier to be part of a struct or union type. The
C89 standard does not allow members of this type.
The C99 standard will allow only the final member of
a struct with more than one named member to be of
this type. Other C compilers might not successfully
compile a program that uses this extension.
User Action Specify the bounds if possible.
INCOMPARRY1
Message <Context> the last member of a union, or a struct
with only one named member, <name>, has incomplete
array type. This is not strictly conformant with the
C standard and might not be portable.
Description The compiler has detected an array without a bounds
specifier to be part of a struct or union type. The
C89 standard does not allow members of this type.
The C99 standard will allow only the final member of
a struct with more than one named member to be of
this type. Other C compilers might not successfully
compile a program that uses this
User Action Be aware of this extension if you wish to port the
code.
INCOMPARRY2
Message <Context> the last member of a struct with more than
one named member, <name>, has incomplete array type.
This does not conform to the C89 standard.
Description The C89 standard does not allow struct members to be
an array without a bounds specifier. The C99
standard will allow the final member of a struct with
more than one named member to be an incompete type.
Other C compilers may not support this C99 extension.
User Action Be aware of this if you wish to port the code to a
compiler that does not support C99.
INCOMPCALL
Message <Context> the return type of "<expression>" is
incomplete.
Description A function with an incomplete return type other than
void cannot be invoked.
User Action Complete the function return type before the function
is invoked.
INCOMPDEREF
Message <Context> "<expression>" is a pointer to an
incomplete struct or union and should not be used as
the left operand of a member dereference.
Description In certain modes, HP C will allow the struct or union
specifier of a member dereference operator (->) to
specify a struct or union that does not contain the
element specified by the right operand. While this
is considered poor programming practice, it was
common with older C compilers. In cases where the
left operand is a pointer to an incomplete type, the
practice is considered even worse. While HP C will
accept the construct in certain modes, the code
should be modified. Further, this program does not
conform to the C standard and might not be accepted
by other C compilers.
User Action Be aware of this if you wish to port the program.
INCOMPELINIT
Message <Context> , an array's element type is incomplete,
which precludes its initialization.
Description In order to initialize an array, the array element
type must not be incomplete.
User Action Either remove the initializer or complete the array
element type before this point in the program.
INCOMPELMNT
Message <Context> the element type of an array type is
incomplete.
Description The element type of an array type is incomplete at
the point in the program where the array is declared.
While HP C will allow this if the element type is
completed later, other compilers might require the
type to be complete at this point in the program.
User Action Either complete the type before the array
declaration, or be aware of this if you wish to port
the program.
INCOMPMEM
Message The member "<name>" has an incomplete type.
Description A struct or union member must not have an incomplete
type. An exception is that HP C will accept a member
that is an array with unspecified bounds, although
warnings are often generated for this case.
User Action Complete the type before it is used in as a member of
a struct or union.
INCOMPNOLINK
Message In this declaration, "<name>" has no linkage and is
of an incomplete type.
Description A declaration with no linkage cannot specify an
incomplete type. Incomplete types can only be used
for identifiers with external or internal linkage.
User Action Either complete the type before the declaration or
modify the declaration to specify an external or
internal linkage.
INCOMPPARM
Message In the definition of the function "<function name>",
the parameter "<parameter name>" has an incomplete
type.
Description This function definition contains a parameter with an
incomplete type other than an array whose bounds are
not specified. This is not valid.
User Action Complete the type before the function definition.
INCOMPRETURN
Message In the definition of the function "<name>", the
return type is an incomplete type other than void.
Description A function definition cannot specify a return type
that is an incomplete type except for the void type.
User Action Complete the type before the function definition.
INCOMPSTAT
Message The static declaration of "<name>" is a tentative
definition and specifies an incomplete type.
Description This file scope static declaration declares an
identifier with incomplete type. This is not valid
because a static declaration will allocate storage
for the object, but the object's size is not known at
this point in the compilation.
User Action Complete the type before the static declaration.
INCOMPSTATARR
Message Allowing the declaration of a static array with an
incomplete type is a language extension.
Description The HP C compiler will allow an incomplete array type
to appear in a static file scope declaration for
compatibility with other compilers. This is an
extension to the standard. Other compilers may
reject this declaration.
User Action Either use a complete type in this declaration, or
change the storage class to extern.
INCOMPTENT
Message The type of the tentatively-defined variable "<name>"
is incomplete at the end of the compilation unit.
Description This file-scope declaration with no storage-class
specifier declares an identifier with incomplete
type. The type must be completed before the end of
the compilation unit.
User Action Complete the type.
INCOMPVALUE
Message <Context> "<expression>" has incomplete type, and so
cannot be used as an rvalue.
Description It is not possible to get the value of an expression
with incomplete type.
User Action Complete the type before its value is used.
INCOMPVOID
Message <Context> the element type of an array type is
incomplete. The void type cannot be completed.
Description The compiler has encountered an array with an element
type of void. An array element must be an object
type.
User Action Change the type of the array element.
INCONSASSFUN
Message A function "<name>" appeared in more than one #pragma
assert/hint func_attrs specifying the same
assertion/hints.
Description A function can appear on more than one #pragma assert
or #pragma hint func_attrs as long as each #pragma
specifies a different assertion/hint about the
function. The assertion will be ignored.
User Action Either remove the #pragma, or remove the function
name from the pragma, or correct its spelling.
INITCONFLICT
Message Overlapping static storage initializations detected
at Psect <text> + <number>
Description The compiler back-end as detected a case where the
same storage location has been initialized to more
than one value. This can occur when inter-file
optimization has been enabled.
User Action Remove one of the initializers.
INITOVERLAP1
Message <Context> , this initializer list will provide a
value for a subobject that was initialized by the
earlier initializer "<init>".
Description This initializer list will provide a value for a
subobject that has already been initialized. While
this is valid, it might not have been what was
intended.
User Action Initialize each subobject only once.
INITVLA
Message A variable-length array declaration cannot contain an
initializer. The initializer will be ignored.
Description A variable-length array declaration cannot contain an
initializer.
User Action Initialize the array using assignment statements
after the declaration.
INLINEIG
Message An inline specifier may only be used to declare an
identifier for a function. The inline keyword will
be ignored.
Description The inline, __inline or __forceinline keywords have
been used on a non-function type. Or a non-function
type has been listed in a #pragma inline or #pragma
forceinline directive
User Action Remove the keyword or remove the identifier from the
pragma.
INLINESTOCLSMOD
Message The <__inline or __forceinline> storage class
modifier is a language extension and might not be
portable.
Description The __inline and __forceinline storage class
modifiers are an extension of 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.
INPTRTYPE
Message <Context> this argument to <function name> is of
"<type name>" type and is not appropriate for the
conversion specifier "<incorrect conversion>". The
value may overwrite other data or produce unexpected
results.
Description The compiler has detected an input conversion
specifier that does not match its corresponding
argument. The corresponding argument may not be a
pointer or may point to data that is wider or
narrower than that specified by the conversion
specifier. This might not have been what you
intended.
User Action Modify either the argument or the conversion
specifier so that they match.
INSUFALN
Message Alignment specified for extern model is insufficient
for variable. Extern model alignment updated.
Description The current extern model places all external objects
in a section whose alignment is not sufficient for
the alignment of an object being placed in that
section. The compiler will update the alignment of
the section so that it is adequate for the object.
User Action Either increase the alignment of the section or move
the object to another section.
INTBADLINKAGE
Message #pragma use_linkage was applied to the intrinsic
function "<routine name>". The function will be
treated as an ordinary external function.
Description Trying to optimize a pointer argument passed to an
intrinsic function, the compiler discovered that
#pragma use_linkage had been applied to the function
declaration. The intrinsic function of this name
that is understood by the compiler does not allow you
specify a linkage. Therefore the compiler must
assume that you are supplying your own function
definition, and treat this as a call to an external
function with no special properties.
User Action If you want to call the intrinsic function, remove
the #pragma use_linkage directive. If you are
supplying your own function definition, you may want
to rename the function or add a #pragma function
directive for it.
INTCONCASTSGN
Message <Context> casting of the constant "<constant>" to
<type> type will cause a change in sign.
Description Either a negative constant value has been cast to an
unsigned type, or a positive value has been cast to a
signed type and will be treated as a negative number
after the cast.
User Action Change the constant so that the sign will match the
type of the cast.
INTCONCASTTRU
Message <Context> casting of the constant "<constant>" to
<type> type will cause data loss.
Description A constant is cast to a type that is too small to
hold the constant value. Data will be lost in the
conversion.
User Action Remove the cast, or use a smaller constant.
INTCONST
Message Ill-formed integer constant.
Description An invalid integer constant was encountered.
User Action Correct the integer constant.
INTCONSTSIGN
Message <Context> conversion of the constant "<constant>" to
<type> type will cause a change in sign.
Description Either an unsigned type was assigned a negative
constant value, or a signed type was assigned a
positive contant value which will be evalated as a
negative number after the assignment. Note that this
message is not output for assignments to 1-bit
bitfields. The message bitconstsign is generated in
that case.
User Action If this is what you intended, cast the constant to
the desired type. You might also want to change the
constant to the correct signed or unsigned value in
order to avoid the optional message intconcastsgn,
which reports sign changes caused by casts.
INTCONSTSIGNED
Message This integer constant value will be given the type
long long int. This is compatible with the C99
standard. Older versions of the compiler would have
given this unsigned long int type.
Description With the introduction of the long long int type, the
C99 standard changed the rules for how the type of
certain integer constants are determined. Unsuffixed
decimal constants which are too large for long int,
but could fit in an unsigned long int are given the
type long long int in C99. Prior to C99 these would
be given unsigned long int type.
User Action Be aware of this difference.
INTCONSTTOOBIG
Message This integer constant is too large for the long long
type. It will be given the unsigned long long type.
Description The C99 standard specifies that a decimal constant
must fit in a signed type. This constant is too
large for the long long int type. For compatibility
with older versions of the compiler, the constant
will be given the unsigned long long type.
User Action Append a 'U' suffix to the constant. This will force
it to be unsigned.
INTCONSTTRUNC
Message <Context> conversion of the constant "<constant>" to
<type> type will cause data loss.
Description A constant is converted to a type that is too small
to hold the constant value. Data will be lost in the
conversion.
User Action If this is what you intended, cast the constant to
the desired type. You might also want to mask off
the high-order bits before casting in order to avoid
optional message intconcasttru, which reports data
loss caused by casts.
INTCONSTUNSIGN
Message This integer constant value will be given the type
unsigned long int. This is compatible with the C89
standard and older compilers. The C99 standard
requires this to be a signed long long int.
Description With the introduction of the long long int type, the
C99 standard changed the rules for how the type of
certain integer constants are determined. Unsuffixed
decimal constants which are too large for long int,
but could fit in an unsigned long int are given the
type long long int in C99. Prior to C99 these would
be given unsigned long int type.
User Action Be aware of this difference.
INTERNALPRAGMA
Message This is an internal pragma which should only be used
by the compiler development team. It should not
appear in user programs as it may cause unexpected
behavior.
Description This pragma exists only to allow the compiler
developers to test certain functionality of the
compiler. Its use outside the development team is
unsupported.
User Action Remove the pragma.
INTIMPLIED
Message In the declaration of "<name>", no type was
specified. Type defaulted to int. This is a
violation of the C99 standard.
Description The declaration contains a storage-class specifier,
but no type was specified. The compiler will assume
a type of int. Omitting the type specifier is not
valid in C++ or in C99, and is often considered poor
programming practice.
User Action Add a type specifier to the declaration.
INTOVERFL
Message <Context> integer overflow occurs in evaluating the
expression "<expression>".
Description An integer overflow occurred while evaluating a
constant expression. The value of the expression is
undefined.
User Action Correct the constant expression so that it does not
overflow.
INTRINSICCALL
Message <Context> an apparent invocation of intrinsic
function "<name>", <problem>. It will be treated as
an ordinary external call.
Description A function that could be handled internally by the
compiler has been called in a manner that is
inconsistent with expected usage. In such a case,
the compiler will generate a run-time call to the
function. This could result in performance loss.
User Action If the function is intended to refer to the runtime
library routine, the appropriate header file should
be included in the source to provide the full
function prototype and allow certain types of
argument conversions. Alternatively, call arguments
could be type cast as specified in the error message,
or the function prototype could be added by hand. If
the function is not intended to refer to the runtime
library routine, the intrinsic version can be
disabled by means of the "#pragma function
(function_name)" directive.
INTRINSICDECL
Message <Context> the declaration for intrinsic function
"<name>" referenced at <location>, <problem>. It
will be treated as an ordinary external function.
Description A function that could be handled internally by the
compiler has been declared with a prototype that does
not agree with what the compiler expected to see, or
has been declared at block scope instead of file
scope. The function might in fact be a
similarly-named replacement for the expected
function, or the prototype might be incorrect or
misplaced. In such cases, the function will not be
handled internally, but will instead be called at run
time in the usual manner. This could result in a
performance loss.
User Action If the function is intended to refer to the runtime
library routine, the appropriate header file should
be included in the source (note that it is not
portable to include standard headers at other than
file scope). Alternatively, the prototype could be
modified as specified in the error message. If the
function is intended to be a replacement for the
runtime library routine, disable the intrinsic
version by specifying "#pragma
function(function_name)" in the source file.
INTRINSICDECLER
Message <Context> the declaration for the prototyped
intrinsic function "<name>" is incorrect: <problem>.
Description A function that could be handled internally by the
compiler and requires a prototype, has been declared
with a prototype that does not agree with what the
compiler expected to see. The function might be
intended as a similarly-named replacement for the
compiler-known function, or the prototype might be
incorrect. The source must be modified to specify
the intended behavior.
User Action If the function is intended to refer to the
compiler-known routine, the appropriate header file
should be included in the source. Alternatively, the
prototype could be modified as specified in the error
message. If the function is intended to be a
replacement for the compiler-known routine, disable
the intrinsic version by specifying "#pragma
function(function_name)" in the source file.
INTRINSICINT
Message <Context> the <place> type for intrinsic "<name>" is
being changed from "size_t" to "int".
Description A function that is handled internally by the compiler
expects an argument type or return type of "size_t",
but the prototype for the function uses "int". The
compiler will use "int" in this case.
User Action Declare the function by including the appropriate
header file. Alternatively, provide a private
declaration (or modify an existing private
declaration) with "size_t" in the appropriate
location(s), and with "size_t" defined as it is in
the standard system header files. If the function is
not intended to refer to the runtime library routine,
the intrinsic version can be disabled by means of the
"#pragma function (function_name)" directive.
INTUNDFUN
Message There is no function declaration visible for the
identifier "<name>" at the point of this #pragma
<pragma type>.
Description An identifier specified in a #pragma intrinsic or
#pragma function directive must refer to a function
declaration visible at the point of the pragma. The
identifier will be ignored.
User Action Either remove the identifer from the pragma, correct
its spelling, or reorder the source to ensure that a
declaration of the identifier as a function is
visible at the point of the pragma.
INVALIDARG
Message Invalid argument to <pragma> pragma. Pragma is
ignored.
Description An invalid argument has been specified for a pragma
directive. The compiler will ignore the directive.
User Action Correct the directive.
INVALIDSTR
Message The # operator produced an invalid string.
Description During the expansion of a macro, the # stringize
operator produced a token that is not a valid string.
The operand to the stringize operator must contain
characters that form a valid string.
User Action Correct the operand to the stringize operator.
INVALTOKEN
Message Invalid token discarded.
Description An unexpected token was encountered by the compiler.
The token has been ignored. An example is the
preprocessing operator "#" appearing outside a macro
body (int #a;).
User Action Remove the unexpected token.
INVCPPINARGS
Message Possible directive "#<directive>" within a macro
argument list. The directive is treated as part of
the argument list, and not as a preprocessing
directive.
Description The compiler has encountered a directive as part of
the argument list of a macro invocation. This
directive will be treated as part of the argument
list, and not as a preprocessing directive. The
behavior might be different than other compilers.
User Action Rewrite the macro invocation so that it does not
include the directive.
INVDUPENUM
Message <Context> the value of the enumerator "<name>"
conflicts with a previous declaration.
Description The specified enumerator name has been previously
declared with a different value.
User Action Either use a different enumerator name or remove the
previous declaration of the name.
INVNOMEMPRAG
Message Invalid argument to nomember_alignment pragma.
Pragma is ignored.
Description The compiler was unable to parse a #pragma
nomember_alignment directive. The directive will be
ignored.
User Action Correct the directive.
INVPACKPRAG
Message Invalid pack pragma. Pragma is ignored.
Description The compiler was unable to parse a #pragma pack
directive. The directive will be ignored.
User Action Correct the directive.
INVPPDIRPEA
Message The preprocessor directive <name> is not allowed in a
prologue or epilogue file. The directive is ignored.
Description It is not possible for a prologue or epilogue file to
have this preprocessor directive in it.
User Action Remove the offending preprocessor directive from the
prologue/epilogue file.
INVSTATIC1
Message <Context> the keyword "static" and/or type qualifiers
may appear only in the outermost array-bounds
specifier of a function parameter. Keyword/qualifier
ignored.
Description The keyword "static" or a type specifier appeared in
an array-bound specifier that was either not part of
the declarator for a function parameter or it was not
the outermost array-bound specifier of a function
parameter.
User Action Remove the keywords or confine them to use in the
outermost array-bound specifier of a function
parameter.
INVSTATIC3
Message The keyword "static" may not appear in an array-bound
specifier for a declaration of an array of unknown
size. Keyword ignored.
Description The keyword "static" appeared in the declaration of
an array whose size was not known, either because
array has in incomplete type or because the array has
a star bounds specifier.
User Action Remove the keyword.
INVSTATIC4
Message An expression specifying the bound is required when
the keyword "static" is used in an array-bounds
specifer. Keyword ignored.
Description The keyword "static" appeared in an array-bounds
specifier that did not have an expression describing
the array bound. The keyword tells the compiler that
actual arguments passed to this parameter will always
have at least as many elements as specified in the
formal parameter. It is inconsistent to specify the
keyword without also supplying a value for the bound.
User Action Remove the keyword or supply a value for the bound.
INVSTATIC5
Message <Context> the static bound value differs from the
static bound value in another declaration at
<location>. The smaller static bound value will be
used.
Description In a previous declaration of a function one or more
parameters with array type were declared with a
different static bound value than in the current
declaration. This can occur if one of the sizes of
the corresponding static arrays differ between the
two declarations.
User Action Remove the keyword "static" from the declarations, or
give all function declarations the same static bound
value.
INVSTATIC6
Message <Context> neither the keyword "static" nor a type
qualifier may be used in array-bounds for old-style
function parameters. Keyword/qualifiers ignored.
Description Use of the keyword "static" or a type specifier
within the outermost array bound specifier of a
formal parameter is a new feature in the C99
statndard. It cannot be used in old-style function
definitions.
User Action Remove the keywords or convert the code to use
prototype-style function declarations and
definitions.
IVDEPNOFOR
Message This #pragma directive was not followed by a for
statement. The directive will be ignored.
Description The #pragma ivdep and #pragma unroll directives
modify the for loop which follows them. The compile
has encoutered one of the directives without a
following for loop. The directive will be ignored.
User Action Remove the directive.
KEYCOMB
Message Illegal combination of keywords.
Description An invalid combination of Microsoft keywords was
encountered during a declaration. In most cases this
is because the keywords contradict each other. One
example would be using the __fastcall and __stdcall
modifiers in the same function declaration. This
message is only output when the compiler is in
Microsoft mode.
User Action Remove one of the contradictory modifiers.
KNRFUNC
Message The function "<name>" is defined using the old style
K&R syntax. The C standard has marked this syntax as
obsolescent, and it is not supported in C++.
Consider using the standard C prototype syntax.
Description The function uses an old style function definition.
HP recommends that old style function definitions be
replaced by prototype-format definitions.
User Action Recode the function definition to use the recommended
prototype-format definition.
LABELWOSTMT
Message Accepting a label without a following statement is a
language extension.
Description The C standard states that a label must be followed
by a statement. For compatibility with other C
compilers, HP C will accept a label without a
statement. Be aware that this program does not
conform to the standard and may be rejected by other
compilers.
User Action Add a semicolon after the label to create a null
statement.
LCRXCOND
Message Common Data Dictionary description extraction
condition. <msg>.
Description Something went wrong while trying to get the CDD
record description from the CDD. The error message
that follows gives more information about the nature
of the problem.
User Action If necessary, correct the indicated condition in the
CDD record description or with the user environment.
LDCOMPLEXNYI
Message <Context> the type long double _Complex is not fully
supported on this platform. The type is only
accepted when the compilation specifies the option to
make the long double type 64-bits in size.
Description On some platforms HP C does not support the long
double _Complex type where the real and imaginary
component are 128-bits in size. As HP C requires
that each component of a long double _Complex be the
same size as a long double, this compilation must
specify the option to treat long double as 64-bits.
User Action Either specify the correct compiler option or use the
double _Complex type instead of the long double
_Complex type.
LEXNESTPAR
Message Lexically nested parallel at scope <text> is not
supported
Description Nested parallel directives are not supported.
User Action Remove the nested parallel directive.
LISTOPEN
Message An error occurred while attempting to open the
listing file: <reason>.
Description An unexpected error occurred during the creation of
the listing file. The message text will contain
additional information about the failure.
User Action Correct the condition that caused the failure.
LOCALEXTINI
Message The block-level declaration of "<name>" includes an
initializer and specifies storage class extern.
Description A block-level declaration with extern storage class
cannot contain an initializer.
User Action Remove the initializer from the declaration or move
the declaration to file scope.
LONGDEBUG
Message The identifier name exceeds <number> characters; name
passed to the debugger will be truncated to
"<truncated spelling>".
Description On some platforms, the name length supported by the
compiler is greater than the length supported by the
debugger. In this case the compiler must truncate
the name when it is output to the debugger symbol
table for this compilation.
User Action Reduce the size of the name.
LONGDOUBLENY1
Message <Context> type long double has the same
representation as type double on this platform and is
treated as a synonym for type double in this
compilation mode.
Description HP C does not support the long double type on this
platform. In this compilation mode, the compiler
will treat the long double type as a synonym for the
double type.
User Action Be aware of this.
LONGDOUBLENYI
Message <Context> type long double has the same
representation as type double on this platform.
Description Although HP C will recognize the long double type as
a different type than double in this compilation
mode, on this platform they will both use the same
representation. Using long double will not provide
any additional precision or range.
User Action Be aware of this.
LONGEXTERN
Message The external identifier name exceeds <number>
characters; truncated to "<truncated spelling>".
Description The length of an identifier with external linkage
exceeds the maximum allowed on this platform. The
name used in an output object file will be truncated
to meet the platform restrictions. Note that the
debugger name will be unchanged.
User Action Reduce the size of the name. On OpenVMS platforms
the /NAMES=SHORTENED qualifier can also be used.
When the qualifier is specified, the compiler will
encode long external names instead of truncating
them.
LONGFLOATEXT
Message <Context> long float as a synonym for double is a
language extension.
Description Certain standard modes allow the use of the long
float type as a synonym for double. This is not
allowed by the C standard. This message indicates
this use of long float as a potential portability
problem.
User Action Change long float to double.
LONGLINE
Message A <type> source line longer than <number> characters
was encountered.
Description The length of a source line has exceeded the maximum
length supported by the HP C compiler.
User Action Reduce the size of the line.
LONGLONGSUFX
Message The integer constant is of type "<type>", which is a
new feature of C99 might not be portable.
Description The use of the suffix ULL or LL on an integer
constant does not conform to the C89 standard and
might not be accepted by other C compilers.
User Action Be aware of this if you wish to port the program.
LONGLONGTYPE
Message <Context> type "<type>" is a new feature in C99.
Description On some platforms, HP C will accept the [unsigned]
long long type as a way to declare [unsigned] 64-bit
integers. The long long int type is a new feature of
C99 and other compilers might not accept this
declaration.
User Action Be aware of this portability concern.
LONGMODULEID
Message Identifier "<name>" in a #pragma module or #module
directive exceeds 31 characters.
Description A module or identification name specified in the
#pragma module or #module directive must be less than
32 characters. The compiler will truncate the name
to the first 31 characters specified.
User Action Shorten the module or identification name.
LONGMODULESTR
Message The identification string <string> in a #pragma
module or #module directive exceeds 31 characters.
The compiler will ignore the directive.
Description An identification string specified in the #pragma
module or #module directive must be less than 32
characters. The compiler will ignore the directive.
User Action Shorten the identification string.
LONGPREFIX
Message Prefix string too long. Truncated to "<newprefix>".
Description The specified prefix to the #pragma extern_prefix
directive is too large for this platform. The prefix
will be truncated.
User Action Reduce the size of the specified extern prefix.
LONGPSECT
Message Psect name is too long (maximum is 31 characters).
Description The psect name specified in a globaldef declaration
was longer than 31 characters. This exceeds the
maximum allowed length.
User Action Either reduce the psect name to 31 characters or
remove the psect specifier.
LONGTOKEN
Message An individual token longer than <number> characters
was encountered.
Description The length of an individual token has exceeded the
maximum length supported by the HP C compiler.
User Action Reduce the size of the token; perhaps it can be
converted into two or more smaller tokens.
LVALUECAST
Message <Context> the result of the cast "<cast>" is used as
an lvalue.
Description The result of a cast has been used as an lvalue.
This is a language extension of HP C. The program
does not conform to the C standard, and might not be
accepted by other compilers.
User Action Remove the cast.
MACROREDEF
Message The redefinition of the macro "<name>" conflicts with
a current definition because <reason>. The
redefinition is now in effect.
Description A macro has been redefined with either different
formal parameters and/or a different body than a
previous definition of the macro.
User Action Either make all definitions of the same macro
identical, or undefine the macro using the #undef
preprocessing directive before it is redefined.
MACROREDEFIN
Message Macro redefined.
Description A #define preprocessing directive has redefined a
macro whose previous definition contained an error or
warning. Normally, the compiler will issue a warning
if a macro is redefined to something other than the
previous definition. However, if the previous
definition caused a warning or error to be generated,
this informational message is output instead.
User Action Do not redefine a macro without first undefining it.
MAINNOTINT
Message Strict standard C extension: The declaration of the
"main" function has a return type other than int.
Description Standard C requires that the "main" function be
defined with a return type of int. HP C will accept
other return types, but the program does not conform
to the C standard. The status value returned to the
environment may not be what you expect, and other C
compilers may not accept the definition as written.
User Action Define the "main" function with a return type of int
for maximal portability.
MAINPARM
Message Strict standard C extension: The declaration of the
"main" function has more than two parameters.
Description Standard C requires that the "main" function takes no
more than two parameters. HP C will accept more, but
the program does not conform to the C standard.
User Action Modify the declaration if you want the program to be
standard conformant.
MAINPROGEXT
Message MAIN_PROGRAM is a language extension.
Description The use of MAIN_PROGRAM to designate a function as
the main program is a language extension of HP C.
Other C compilers might not successfully compile a
program that uses the extension.
User Action The main program should be declared by naming the
function main.
MAPREGIGNORED
Message The linkage register "<registers>" has no effect on
Alpha and will not be mapped to any register on IA64.
This condition may cause the SHOWMAPLINKAGE message
output for this directive to be incorrect.
Description The use of an Alpha argument register (R16-R21) in a
linkage characteristic other than "parameters" or
"results" has no effect on Alpha. No mapping to an
IA64 register will be done for this register. This
may cause the mapped linkage shown in the
showmaplinkage message to be incorrect.
User Action Remove the register from the characteristic.
MATHERRNO
Message <Context> function <name> is defined to set errno
when a domain error or range error occurs. As an
intrinsic, it may not be able to do so.
Description Any code that tests the value of errno set by this
function may not work properly due to the
optimizations that are possible when this function is
an intrinsic.
User Action If the value of errno set by this function is
ignored, tell the compiler via its command line
qualifiers to assume nomath_errno. Otherwise,
disable the intrinsic by using a #pragma
function(func-name).
MAYHIDELOSS
Message <Context> "<expression>" has a larger data size than
"<target type>". The use of a cast operator can
suppress the message that this assignment might
result in data loss.
Description In a cast of a pointer to one of the integer types,
or a cast of one of the integer types to a pointer,
or a cast of one pointer type to another, the size of
the source is greater than the size of the type being
cast to. This cast could result in a loss of data if
it is used as the source of an assignment. This
potential loss of data can be verified by removing
the cast and seeing if the compiler emits a loss of
data message on the assignment.
User Action If the cast cannot lose precision, it is safe to
ignore this warning.
MAYLOSEDATA
Message <Context> "<expression>" has a larger data size than
"<target type>". Assignment can result in data loss.
Description In an assignment of a pointer to one of the integer
types, or one of the integer types to a pointer, the
size of the source is greater than the size of the
destination. The assignment can result in a loss of
data. This might not have been what you intended.
User Action If this was the intended operation, cast the source
to the type of the destination before the assignment.
MAYLOSEDATA2
Message <Context> "<expression>" has a larger data size than
"<target type>". Assignment can result in data loss.
Description In an assignment of two pointers, the size of the
source is greater than the size of the destination.
The assignment can result in a loss of data. This
might not have been what you intended.
User Action If this was the intended operation, cast the source
to the type of the destination before the assignment.
MECHMISMATCH
Message Argument passing mechanism does not match formal
parameter mechanism for <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.
MEMBERVLA
Message <Context> the struct or union member "<name>" cannot
be declared with a variably modified type.
Description Only ordinary identifiers with block scope and
without storage class extern, or ordinary identifiers
with function prototype scope can be declared with a
variably modified type.
User Action Correct the declaration.
MISALGNDMEM
Message This member is at offset <offset>, which is not a
multiple of the member's alignment of <align>.
Consider padding before this member, rearranging the
order of member declarations, or using #pragma
member_alignment.
Description A member of a struct or union requires an alignment
for efficient access but will be allocated at an
offset that is not a multiple of that alignment.
User Action Use one of the suggestions made in the message.
MISALGNDSTRCT
Message This member requires <align1> alignment for efficient
access, but is contained in a struct containing
<align2> alignment. Consider using #pragma
nomember_alignment <align1>.
Description A member of a struct or union requires an alignment
for efficient access that is more strict than the
alignment of the enclosing struct or union. Even
though this member is correctly aligned within the
struct or union, if the struct or union is enclosed
within another type, the member in question might be
placed at a position with incorrect alignment for its
type.
User Action Use either the #pragma member_alignment directive or
#pragma nomember_alignment directive with an argument
equal to or greater than the alignment of the member.
MISDEFARG
Message Missing argument for "defined" operator.
Description The defined preprocessing operator was not supplied
with an argument. The operator expects an identifier
optionally enclosed in parenthesis. The value of the
operator is undefined.
User Action Supply a valid argument to the preprocessing
operator.
MISDEFPAR
Message Missing right parenthesis for "defined" operator.
Description The defined preprocessing operator began with a left
parenthesis, but no matching right parenthesis was
found. The value of the operator is undefined.
User Action Add the right parenthesis after the preprocessing
operator argument.
MISMATPARAM
Message <Context> parameter <number> has a different type
than specified in an earlier declaration of this
function.
Description A function has been redeclared with a parameter whose
type is different than the type specified in a
previous declaration of the function. This generally
leads to additional errors.
User Action Correct the function declarations so that the
parameter information is the same in each
declaration.
MISMATPRSRET
Message "<name>" has a non-void return type but its linkage
"<name>" preserves the return register(s). Standard
linkage will be used.
Description The function or typedef's special linkage specifies
that the register(s) used to return the function
value are to be preserved. This is invalid as the
register can either be preserved, or hold the return
value, but not both.
User Action Modify the #pragma linkage directive to either remove
the register from the preserved list or to specify
another register to hold the return value.
MISMATTHREAD
Message <Context> the __declspec(thread) storage class
modifier of "<name>" is different from a previous
declaration of "<name>" at <location>.
Description If an object is declared with thread-local storage,
then all declarations of that object must declare it
with thread-local storage.
User Action Either remove the invalid redeclaration or modify it
to match the previous declaration.
MISPARAMCOUNT
Message <Context> the number of parameters differs from an
earlier declaration of this function.
Description A function has been redeclared with a different
number of parameters than a previous declaration of
the function. This message generally proceeds
additional errors.
User Action Correct the function declarations so that the
parameter information is the same in each
declaration.
MISSINGCASE
Message Was the 'case' keyword omitted Within a switch
statement, "<label>" defines an unreferenced label
that matches an enumeration constant.
Description This user label has been defined, but there are no
references to it. As the label is defined inside a
switch statement, and the label name matches an
enumumeration constant name, there is a chance you
intended this to be a case label.
User Action Remove the label or add the 'case' keyword before it.
MISSINGCOMMA
Message This parameter is not preceded by a comma.
Description The compiler has encountered a parameter specifier
that is missing a preceding comma. The parameter
will be defined anyway, though this may not have been
what you intended.
User Action Correct the formal parameter list so that it consists
of a comma separated list of identifiers (possibly
followed by ", ...").
MISSINGFUNC
Message The function "<name>" has internal linkage, occurs in
a context that requires its definition, and has no
definition.
Description The program has referenced a function declared with
static storage class, but the function is not defined
in the compilation unit. If a program references a
static function, the function must be defined in the
compilation unit.
User Action Either define the function or change the function
declaration to have extern storage class.
MISSINGLABEL
Message The label "<label name>" is the target of a goto
statement within the function "<function name>", but
has no definition within "<function name>".
Description Every label referenced in a goto statement must be
defined in the same function.
User Action Either change the name of the label in the goto
statement, or define the label.
MISSINGRETURN
Message Non-void function "<name>" does not contain a return
statement.
Description This message indicates that a function with an
explicit return type does not contain a return
statement. This message is not issued for functions
with an implicit return type of int. See message
IMPFNCMSSNGRET.
User Action Consider declaring the function to be a void
function. If it is supposed to return a value, add a
return statement with the value the function is to
return.
MISSINGTYPE
Message Missing type specifier or type qualifier.
Description The compiler was expecting a type specifier or type
qualifier, but one was not found.
User Action Correct the program syntax.
MISSPELLDEF
Message The user label "<label>", defined within a switch
statement, is never referenced.
Description This user label has been defined, but there are no
references to it. As the label is defined inside a
switch statement, there is a chance this is a
misspelling of "default".
User Action Remove the label or correct the spelling.
MIXALLOCAVLA
Message <Context> this call to __ALLOCA occurs in a block
that contains <vlaallocafrag1>. The storage
allocated by this __ALLOCA call will
<vlaallocafrag2>vla or aligned automatic declaration
was at <where>.
Description Storage allocated for arrays of variable length and
for automatics whose alignment is greater than
octaword have their storage deallocated when the
block they are declared in exits. Storage allocated
by __ALLOCA is not normally deallocated until
function exit. HP C cannot support both types of
deallocation in the same block. Therefore, when both
appear in the same block, the storage for both will
be deallocated with the block exits.
User Action Be aware of this. If the storage allocated for
__ALLOCA must remain allocated until function exit,
move the __ALLOCA call outside the block declaring
the vla or the aligned auto.
MIXALLOCAVLAV
Message <Context> using __ALLOCA and variable-length arrays
in the same function is not allowed on this platform.
The first variable-length array declaration is at
<where>.
Description Because they place different requirements on stack
allocation on VAX systems, __ALLOCA and
variable-length arrays cannot be used in the same
function.
User Action Recode the function to use either variable-length
arrays or __ALLOCA.
MIXFUNCVOID
Message <Context> compatibility of a pointer to void and a
pointer to a function is not portable under the C
standard.
Description The C standard defines pointer to void as being
assignment compatible only with pointers to object or
incomplete types. An implementation may represent
function pointers in a way that cannot be stored in a
pointer to void (or vice-versa). Thus even an
explicit cast between a function pointer and a
pointer to void is not portable.
User Action If a generic pointer to function is needed, declare a
typedef for some pointer to function type, and always
use explicit casts to assign to and from that type.
MIXINLINE
Message The function <name> is declared both <this> and
<that>.
Description A function is declared with more than one of the
forceinline, inline, or noinline attributes. It will
be given the attribute that will provide the most
optimization.
User Action Make sure each function has only one of the
attributes.
MIXLINKAGE
Message <Context> "<name>" is declared with both internal and
external linkage. The previous declaration is at
<location>.
Description This warning is output in certain cases when the
linkage of a declaration conflicts with the linkage
specified in an earlier declaration.
User Action Change one of the declarations so that the linkages
match.
MIXLINKAGE1
Message <Context> "<name>" is declared with both internal and
external linkage. The previous declaration is at
<location>.
Description This informational is output when a function
previously declared to have extern storage class is
redeclared to have internal storage class and the
mode of the compiler is common (K & R) mode.
User Action Change one of the declarations so that the linkages
match.
MIXOLDNEW
Message The definition of the function <name> includes both a
prototype and a declaration list.
Description A function has been defined using both a declaration
list and a prototype. This is not valid.
User Action Correct the declaration.
MIXSTORCLS
Message <Context> a storage class has already been specified.
This storage class is ignored.
Description The same declaration contains more than one storage
class specifier. The compiler will ignore all
storage class specifiers after the first one.
User Action Change the declaration to use only one storage class
specifier.
MIXVLAALLOCA
Message Declaring <vlaallocafrag1> in the same block as a
call to __ALLOCA will cause the storage allocated by
any __ALLOCA call to <vlaallocafrag2>previous call to
__ALLOCA was at <where>.
Description Storage allocated for arrays of variable length and
for automatics whose alignment is greater than
octaword have their storage deallocated when the
block they are declared in exits. Storage allocated
by __ALLOCA is not normally deallocated until
function exit. HP C can not support both types of
deallocation in the same block. Therefore, when both
appear in the same block, the storage for both will
be deallocated with the block exits.
User Action Be aware of this. If the storage allocated for
__ALLOCA must remain allocated until function exit,
move the __ALLOCA call outside the block declaring
the vla or the aligned auto.
MIXVLAALLOCAV
Message Using both __ALLOCA and variable-length arrays in the
same function is not allowed on this platform. The
first call to __ALLOCA is at <where>.
Description Because they place different requirements on stack
allocation on VAX systems, __ALLOCA and
variable-length arrays cannot be used in the same
function.
User Action Recode the function to use either variable-length
arrays or __ALLOCA.
MODNOIDSTR
Message Invalid identifier or character-string constant
specification.
Description If specified, the second argument to the #pragma
module or #module directive must be either an
identifier or a string constant.
User Action Correct the directive.
MODSTORCLS
Message Storage class modifier noshare has no meaning with
this storage class. Modifier is ignored.
Description The storage class modifier noshare is only valid for
variables with a storage class of static, extern, or
globaldef. It is ignored for other storage classes.
User Action Remove the noshare storage class modifier.
MODULEFIRST
Message "#pragma module" or "#module" directive must precede
any language text.
Description The #pragma module or #module directive must appear
before any declarations. The directive will be
ignored.
User Action Move the directive to the top of the compilation
unit.
MSGPOP
Message This "restore" has underflowed the message stack. No
corresponding "save" was found.
Description The message stack, managed by the #pragma message and
#pragma environment directives, contains more
restores than saves. This could signify a coding or
logic error in the program.
User Action Make sure each restore has a corresponding save.
MSGSFRMEXLCODE
Message Enabling this message may cause additional messages
from excluded code to be output.
Description This message is never output by the compiler.
Instead it is used to control whether other messages
will be output. Normally, the compiler will not
output some messages when it is processing code that
it knows will never be executed. One example of this
would be the second operand of the conditional
operator when the first operand is FALSE. This
suppression of these messages can be overridden by
enabling this message.
User Action Decide if you want the additional messages.
MULTICHAR
Message A character constant includes more than one character
or wide character.
Description A character constant includes more than one
character. While this is valid, it might not have
been what you intended.
User Action Verify that the constant should contain more than one
character.
MULTILINK
Message Multiple linkage pragmas specified for "<routine
name>".
Description The same routine appeared in more than one #pragma
use_linkage directive. Each routine can only be
given one linkage.
User Action Remove the routine from all but one #pragma
use_linkage directive.
MULTILINKREG
Message The register "<register>" is specified more than once
in the linkage pragma. Pragma is ignored.
Description The same register was specified more than once in the
same register list in a #pragma linkage directive.
The compiler will ignore the entire pragma.
User Action Correct the directive.
MULTIMAIN
Message More than one main program has been defined.
Description The compiler has encountered more than one main
program in this compilation unit. Each program can
have only one main program.
User Action Remove one of the main programs.
MULTIPSECTNAME
Message Multiple <psect_type> names specified. The name
"<new_name>" supersedes "<old_name>".
Description More than one #pragma code_psect or #pragma
linkage_psect was encountered. The psect specified
by the later #pragma supersedes the one specified
earlier. This message is only output for C compilers
on OpenVMS Alpha.
User Action Each program should contain at most one #pragma
code_psect and one #pragma linkage_psect.
NAMESHORTENED
Message The external identifier or module name "<name>"
exceeds 31 characters. The name has been shortened
to "<shortened spelling>".
Description A compilation that used the /NAMES=SHORTENED
qualifier or #pragma names shortened directive has
encountered a name that needs to be shortened. The
external name will be different than the internal
name. Also, because the external name exceeds the
length specified by standard C as the minimum
external length an implementation must support, this
program does not strictly conform to standard C and
might not be accepted by other C compilers.
User Action Be aware of these items.
NAMESLOWER1
Message The /NAMES=LOWERCASE qualifier is no longer
supported. The qualifier /NAMES=AS_IS will be used.
Description While the C language has always required identifiers
with internal linkage to be treated case sensitively.
It traditionally permitted implementations to
monocase identifiers with external linkage. Modern
standards require C/C++ implementations to preserve
the case of identifiers with external linkage. As
VMS and other operating systems that traditionally
implemented monocasing chose uppercase as the
convention, /NAMES=LOWERCASE runs contrary both to
the C and C++ standards and to traditional
conventions. Continued support for this option
interferes with support for compatibility between old
code compiled with /NAMES=UPPERCASE and new code
compiled with /NAMES=AS_IS.
User Action Use /NAMES=AS_IS, making source code changes as
needed.
NEEDADDRCONT
Message <Context> "<name>" does not have a constant address,
but occurs in a context that requires an address
constant.
Description A variable with static storage has been initialized
to the address of an object whose address is not
constant. This can happen if a static pointer
variable is initialized to the address of an
automatic variable.
User Action Either make the initialize a constant, or, if
possible, initialize the static storage using a
run-time assignment.
NEEDARITH
Message <Context> "<expression>" has <type> type, which is
not arithmetic.
Description An expression that must be an arithmetic type was not
an arithmetic type. For example, the operands of an
arithmetic operator such as * must be arithmetic
type.
User Action Modify the expression so that it is an arithmetic
type.
NEEDCONSTEXPR
Message <Context> "<name>" is not constant, but occurs in a
context that requires a constant expression.
Description An expression that must evaluate to a compile-time is
not a constant.
User Action Modify the constant expression so that it will
evaluate as a compile-time constant.
NEEDCONSTEXT
Message <Context> "<name>" is not constant, but occurs in a
context that requires a constant expression. This is
an extension of the language.
Description The C89 standard requires that an initializer for an
automatic aggregate or union type object have an
initializer that is a list of constant expressions.
HP C allows non-constants in these initializers.
This is an extension to C89. Although this is
allowed by the C99 standard, other C compilers might
not successfully compile a program that uses this
extension.
User Action Be aware of this if you wish to port the program.
NEEDDFLOAT
Message The CDD description for <name> specifies the
D_Floating data type. The data can only be
represented when compiling with /FLOAT=D_FLOAT.
Description The /FLOAT command-line qualifier specified a
floating type other than D_floating format. The CDD
description specified was D_floating type, which did
not match the floating type specified on the command
line.
User Action Specify the correct command-line qualifier, or change
the description of the item in the CDD.
NEEDFUNCPTR
Message <Context> "<expression>" points to <type> type, but
occurs in a context that requires a pointer to a
function type.
Description An expression that must be a pointer to a function
type is a pointer to an object or incomplete type.
For example, if a function invocation expression is a
pointer, it must be a pointer to a function type.
User Action Modify the expression so that it is a pointer to a
function type.
NEEDGFLOAT
Message The CDD description for <name> specifies the
G_Floating data type. The data can only be
represented when compiling with /FLOAT=G_FLOAT.
Description The /FLOAT command-line qualifier specified a
floating type other than G_floating format. The CDD
description specified was G_floating type, which did
not match the floating type specified on the command
line.
User Action Specify the correct command line qualifier, or change
the description of the item in the CDD.
NEEDIEEE
Message The CDD description for <name> specifies a VAX
floating data type. The data cannot be represented
when compiling with /FLOAT=IEEE_FLOAT.
Description The command-line qualifier /FLOAT=IEEE_FLOAT was
specified, indicating that all floating-point data
should be represented in IEEE-floating format, yet
the CDD description specified a non-IEEE_floating
type.
User Action Specify the correct command-line qualifier, or change
the description of the item in the CDD.
NEEDIEEE1
Message The CDD description for <name> specifies an IEEE
floating data type. The data can only be represented
when compiling with /FLOAT=IEEE_FLOAT.
Description The CDD description for an item specifies an IEEE
floating point type. However this module was not
compiled with the /FLOAT=IEEE_FLOAT qualifier.
User Action Specify the correct command-line qualifier, or change
the description of the item in the CDD.
NEEDINTEXPR
Message <Context> "<expression>" has <type> type, which is
not integral.
Description An expression that must be an integer type was not
integral. For example, an array-index specifier must
be an integral type.
User Action Modify the expression so that it is an integral type.
NEEDLVALUE
Message <Context> "<expression>" is not an lvalue, but occurs
in a context that requires one.
Description An expression that must be an lvalue was not an
lvalue. For example, the operand of the address-of
operator must be an lvalue.
User Action Modify the expression so that it is an lvalue.
NEEDMEMBER
Message <Context> "<name>" is not a member of "<struct or
union expression>".
Description The second operand of a . or -> operator specifies a
member name that is not a member of the struct or
union type specified by the first operand. Note that
in certain modes, HP C will search all other visible
struct/union types for a matching member name. If it
finds one, a diagnostic will be issued, and the
offset of that name will be used.
User Action Specify a valid member name.
NEEDNONBLTIN
Message <Context> "<name>" is a builtin and cannot be used in
this context.
Description A program has used a builtin function in a way that
is invalid for builtin functions. For example, a
program cannot take the address of a builtin.
User Action Remove the improper use of the builtin.
NEEDNONCONST
Message <Context> "<expression>" has const-qualified type,
but occurs in a context that requires a modifiable
lvalue.
Description The code has attempted to modify an object that is
either a const-qualified type or has been declared
with the readonly storage-class modifier. This is
not valid. A typical example is assigning a value to
a const variable.
User Action Either remove the const qualifier from the object's
type, remove the readonly storage-class modifier from
the object declaration, or rework the code so that
the object is not written to.
NEEDNONVOID
Message <Context> "<expression>" has void type, but occurs in
a context that requires a non-void result.
Description An expression that must not be a void type was void.
For example, the control expression for an if
statement must not have void type.
User Action Modify the expression so that it has the required
type.
NEEDPOINTER
Message <Context> "<expression>" has <type> type, but occurs
in a context that requires a pointer.
Description An expression that must be a pointer type was not a
pointer type. For example, the operand of the
dereference operator must be a pointer type.
User Action Modify the expression so that it has a pointer type.
NEEDPTROBJ
Message <Context> "<expression>" does not point to an object
type.
Description An expression that must be a pointer to an object
type is a pointer to a function or incomplete type.
For example, if a pointer is the operand of the
postincrement operator, it must point to an object
type.
User Action Modify the expression so that it is a pointer to an
object type.
NEEDSCALAR
Message <Context> "<expression>" has <type> type, which is
not scalar.
Description An expression that must be a scalar type was not
scalar. For example, only scalars can be cast to
other types.
User Action Modify the expression so that it is a scalar type.
NEEDSCALARTYP
Message <Context> "<source type>" is <type> type, which is
not scalar.
Description In a cast expression, the destination type of the
cast is not a scalar type. This is not valid. Both
the source and target type of a cast must be scalars.
User Action Modify the cast destination type so that it is a
scalar type.
NEEDSIMPLEASM
Message This asm is unsupported or illegal.
Description The argument to the asm intrinsic is invalid.
User Action Supply a valid argument to the asm instrinsic.
NEEDSTRCONST
Message <Context> "<name>" is not a legal asm string, a
string constant is required.
Description The argument to the asm intrinsic must be a string
constant.
User Action Change the argument to be a string constant.
NEEDSTRUCT
Message <Context> "<expression>" has <type> type, but occurs
in a context that requires a union or struct.
Description The left operand of the . or -> operator does not
have struct or union type.
User Action Correct the operand.
NEGATIVEHINT
Message <Context> a negative hint value is not allowed. The
hint will be ignored.
Description All #pragma hint directives must take positive
floating point values.
User Action Correct the hint.
NESTEDCOMMENT
Message Opening comment delimiter found inside a delimited
comment; a previous comment may be missing its
closing delimiter.
Description C comments delimited by /* */ do not nest. When /*
is encountered inside a delimited comment it usually
means that the previous comment is missing its
terminating */ or that the user has ill-advisedly
attempted to "comment out" a section of code that
contains a delimited comment.
User Action It is traditional in C to use #if 0 to conditionalize
out large sections of code. You may also want to
consider //-style comments if the compiler modes you
care about recognize them.
NESTEDENUM
Message The type "<type>" is declared nested within
"<enclosing type>". In C, the nesting is ignored and
<type> and its enumerator constants can be accessed
as if they were not nested. <However, the type and
its enumerators are members in C++>. <Fix>.
Description C allows types to be declared within other types.
For example: struct S { int a; enum E { first,
second, third} b; int c; }; In C++ the enum E would
not be accessible without using the :: operator.
User Action Declare the nested type before declaring the
enclosing type.
NESTEDTYPE
Message The type "<type>" is declared nested within
"<enclosing type>". In C, the nesting is ignored and
<type> can be accessed as if it were not nested.
<However, the type is a member in C++>. <Fix>.
Description C allows types to be declared within other types.
For example: struct S { int x; struct S1 { int a;
int b; } y; }; In C++ the struct S1 would not be
accessible without using the :: operator.
User Action Declare the nested type before declaring the
enclosing type.
NESTINCL
Message Files included by this file are referenced. However
nothing else appears to be referenced from this file.
Description When compiling with the current set of compilation
options, to improve compilation efficiency, you may
wish to include the files which this file includes
directly, rather than including them from this file.
User Action For compilation efficiency, you may exclude this
include file when compiling with the current set of
compilation options.
NEWLOCALE
Message The compiler could not set its locale to the
locale-specific native environment. This problem
might be caused by an incorrect value for a name
defined in your process environment such as "LC_ALL"
or "LANG". The "C" locale will be used.
Description During start-up, the compiler was unable to set its
locale to the locale-specific environment. As part
of its initialization, the compiler will issue the
call setlocale(LC_ALL, ""). If this call fails, the
compiler will set its locale to the "C" locale. In
general, this message is output because the
locale-specific native environment has been set
incorrectly.
User Action The best way to determine why the compiler was unable
to set the locale is to write a small program that
contains the library call setlocale(LC_ALL, "") and
then examine the return value from the call.
NLCHAR
Message An unexpected newline character is present in a
character constant.
Description An end of line was encountered during the scanning of
a character constant.
User Action Terminate the character constant with a closing
single quote character before the end of line.
NLHEADER
Message A newline occurs inside of a header name.
Description An end of line was encountered before the closing
double quote or angle bracket of an #include
directive.
User Action Terminate the directive argument properly.
NLSTRING
Message An unexpected newline character is present in a
string literal.
Description An end of line was encountered during the scanning of
a string literal.
User Action Terminate the string constant with a closing double
quote character before the end of line, or continue
the line with a continuation character.
NOADD
Message <Context> "<expression1>" and "<expression2>" cannot
be added.
Description Because of their types, the two expressions cannot be
used as the operands of the addition operator.
Either both operands must be arithmetic type, or one
operand must be a pointer to an object type and the
other must be an integral type.
User Action Modify the addition to use valid types.
NOBIFDISABLE
Message The function "<routine name>" is a builtin function
reserved to the compiler, and cannot be used with
#pragma function. The function will continue to be
treated as a builtin.
Description A function identifier specified in a #pragma function
directive is the name of a builtin function. These
functions cannot be explicitly disabled, they are
always handled as builtin functions.
User Action Remove the inappropriate use of the pragma, and
change the name of the function in order to have it
treated as an ordinary callable function.
NOBITFIELD
Message <Context> "<expression>" is a bitfield, but occurs in
a context that precludes bitfields.
Description An expression that must not be a bitfield was a
bitfield. For example, the operand of the address-of
operator must not be a bitfield.
User Action Modify the expression so that its type is not a
bitfield type.
NOCASEHERE
Message This case label occurs outside of any switch
statement.
Description A case label can only occur inside of a switch
statement.
User Action Remove the case label.
NOCDDHERE
Message CDD is not available on this platform. The
#dictionary directive has been ignored.
Description The #dictionary directive requires CDD to be present
on the platform. This directive will only be
recognized on OpenVMS systems.
User Action Remove the directive.
NOCOLON
Message Missing ":".
Description The compiler was expecting a colon, but one was not
found.
User Action Correct the program syntax.
NOCOLONINEXPR
Message Missing colon for conditional expression.
Description A conditional expression that occurs as part of a
preprocessing expression was missing the ":" that
separates the second from the third operand. The
value of the resulting expression is undefined.
User Action Correct the conditional expression.
NOCOMMA
Message Missing ",".
Description The compiler was expecting a comma, but one was not
found.
User Action Correct the program syntax.
NOCONDEXPR
Message Missing #if conditional expression.
Description An argument was not supplied to an #if or #elif
preprocessing directive. The missing argument will
cause the compiler to consider these as FALSE
conditionals.
User Action Supply a valid argument to the directive.
NOCONVERT
Message <Context> "<expression>" is of type "<type>", and
cannot be converted to "<target type>".
Description An expression of one type cannot be converted to the
type required by this expression. This most often
occurs when the source type of an assignment or cast
cannot be converted to the destination type. The
rules for which types can be converted are rather
complicated and differ based upon the compiler mode.
Refer to the language documentation for a complete
list of valid combinations.
User Action Modify the conversion to use valid types.
NOCONVERTCLS
Message <Context> "<expression>" is of type "<type>", and
cannot be converted to a different "<type>" type.
Description A struct or union of one type cannot be converted to
a different struct or union type.
User Action Modify the conversion to use valid types.
NODCL
Message <Context> nothing is declared.
Description The C standard requires that a declaration must
declare at least a tag, an enumeration constant, or a
declarator. This declaration contains none of these.
This might not have been what you intended.
User Action Correct or remove the declaration.
NODEFAULTHERE
Message This default label occurs outside of any switch
statement.
Description A case default label can only occur inside of a
switch statement.
User Action Remove the case default label.
NOENDIF
Message Missing #endif directive.
Description The compiler encountered an #if, #ifdef, or #ifndef
preprocessing directive without a matching #endif.
This might not have been what you intended. The
compiler will add the necessary #endif directive at
the end of the compilation unit.
User Action Make sure every #if, #ifdef and #ifndef has a
matching #endif.
NOEQUAL
Message Missing "=".
Description The compiler was expecting to see an "=" after the
secondary_name specification of a #pragma weak or
#pragma external_name directive. This message is
only output on UNIX.
User Action Correct the #pragma directive.
NOEQUALITY
Message <Context> "<expression1>" and "<expression2>" cannot
be compared for equality or inequality.
Description Because of their types, the two expressions cannot be
compared for equality or inequality. The rules for
which types can be compared are rather complicated
and differ based upon the compiler mode. Refer to
the language documentation for a complete list of
valid combinations.
User Action Modify the comparison to use valid types. This can
often be done by casting one of the expressions to
the type of the other.
NOEXCEPTFLTR
Message <Context> this exception handling call is not within
an exception filter of a try block.
Description The exception handling call must appear within an
exception filter of a try statement block.
User Action Either remove the exception handling call, or place
it in a try statement block.
NOFBDAT
Message <text> does not contain feedback data
Description The file indicated by the -feedback switch exists,
but does not contain feedback data. This is probably
an error on the users part, although it might be seen
as part of the bootstrapping process.
User Action Create a valid feedback file
NOFBFIL
Message Feedback file <text> does not exist
Description The file specified after the -feedback option does
not exist. This is normal during the bootstrapping
process.
User Action Either correct the spelling of the feedback option,
or create the required feedback file.
NOFBOPT
Message Compilation will proceed without feedback
optimizations
Description A condition has occurred that has prevented the
compiler from using feedback optimizations. This
message is most often preceded by another message
that will provide additional information.
User Action Correct the condition that prevented the feedback
optimizations.
NOFBRTN
Message Feedback inactive for <text> in this compilation
Description Feedback information has gone stale for a particular
routine (the source for the routine has changed).
Feedback optimizations will not be applied to this
routine.
User Action Create a new feedback file
NOFIFILE
Message Cannot find include file <filename> specified on the
command line.
Description The header file name specified in the UNIX -FI
command line option or the OpenVMS /FIRST_INCLUDE
qualifier was not found using the search rules in
effect for the quoted form of #include directives.
User Action Either change the name of the file following the
option or create the file.
NOFNTPDEFDECL
Message There is no identifier named "<name>" declared as a
function or function typedef in this compilation
unit.
Description A #pragma assert and/or #pragma linkage directive(s)
contains an identifier that is not declared as a
function or function typedef in the compilation unit.
This may not have been what you intented.
User Action Remove the identifier from the #pragma assert and/or
#pragma linkage, or declare it as a function or
function typedef. empty string.
NOFORMALPARM
Message Missing formal parameter specifier.
Description While processing the formal parameter list of a macro
definition, the compiler encountered a missing formal
parameter specifier. The macro will be be defined
and this parameter ignored, but that may not have
been what you intended.
User Action Correct the formal parameter list so that it consists
of a comma separated list of identifiers.
NOFUNC
Message There is no function named <name> defined in this
compilation unit.
Description A function that appears in a #pragma weak and is not
defined in the compilation unit.
User Action Either define the function or remove the function
name from the pragma.
NOFUNC1
Message There is no definition for the inline function named
<name> in this compilation unit.
Description A function that appears in a #pragma inline or
#pragma noinline, or is declared with the __inline or
__forceinline storage class modifier, is not defined
in the compilation unit.
User Action Either define the function or remove the function
name from the pragma, or remove the storage class
modifier or the function specifier from the
declaration.
NOIDFOUND
Message <Context> an identifier was expected but not found.
Description The compiler was expecting an identifier, but one was
not found.
User Action Correct the program syntax.
NOIDINPACKPOP
Message pragma pack pop directive has no identifier <name>
which was found on the top of the pack stack.
Description The #pragma pack (pop) directive has no identifier
specified while the top element of the pack stack has
one. Either this #pragma pack pop should have the
identifier found on the stack, or this is an extra
pragma pack pop, or the identifier should not be
pushed by the corresponding #pragma pack push.
User Action Check whether the pragma pack pop should have the
identifier. Verify that there's no extra #pragma
pack pop or #pragma member_alignment restore which
popped the identifier to the top of the pack stack.
Correct the directive(s).
NOINCLFILE
Message Cannot find file <filename> specified in #include
directive.
Description The specified include file does not exist.
User Action Either change the name of the file in the #include
preprocessing directive, or create the include file.
NOINCLFILEF
Message Cannot find file <filename> specified in #include
directive.
Description The specified include file does not exist.
User Action Either change the name of the file in the #include
preprocessing directive, or create the include file.
NOINCLUDEARG
Message #include directive missing argument.
Description An argument was not supplied to an #include
preprocessing directive. The directive will be
ignored.
User Action Supply a valid argument to the directive.
NOINIT
Message The type of <variable> does not permit
initialization.
Description This type cannot be initialized. Only objects and
arrays of unknown size can be initialized.
User Action Remove the initializer.
NOINLFUNC
Message There is no definition for the inline function named
<name> in this compilation unit.
Description A function is declared with an __inline or inline
keyword and is not defined in the compilation unit.
User Action Either define the function or remove the __inline or
inline keyword from the declaration.
NOINLINEM
Message The main function cannot be inlined.
Description The C99 standard prohibits the inline keyword from
being used on the main function.
User Action Remove the inline keyword.
NOINLINEREF
Message <Context> "<name>" has internal linkage and is
referenced from an an inline auxiliary function.
This is a violation of the C99 Standard.
Description A function declared with the inline keyword and
without a declaration containing the keyword, extern,
or without a declaration which lacks the inline
keyword and the static keyword declares an auxiliary
inline declaration. A definition of an auxiliary
inline shall not contain a definition of a modifiable
object with static storage duration, and shall not
contain a reference to an identifier with internal
linkage.
User Action Remove the inline keyword from all declarations of
the parent function, or if it is appropriate, change
the declaration of the referenced item to a
declaration which has something other than internal
linkage.
NOINLINEST
Message In an inline auxiliary function, the modifiable
object "<name>" is declared with static storage
duration. This is a violation of the C99 standard.
Description A function declared with the inline keyword and
without a declaration containing the keyword, extern,
or without a declaration which lacks the inline
keyword and the static keyword declares an auxiliary
inline declaration. A definition of an auxiliary
inline shall not contain a definition of a modifiable
object with static storage duration, and shall not
contain a reference to an identifier with internal
linkage.
User Action Remove the inline keyword from all declarations of
the parent function, or if it is appropriate, add the
const keyword to the declaration to create an
non-modifiable object.
NOLEAVETARG
Message This leave statement is not within a try statement.
Description The exception handling statement leave must appear
within a try statement block.
User Action Either remove the leave statement, or place it in a
try statement block.
NOLEFTOPERND
Message Token pasting operator missing left operand.
Description The preprocessing token pasting operator "##" appears
in a macro body without the preceeding token
argument.
User Action Either remove the operator or supply it with two
tokens that will be pasted together.
NOLINKAGE
Message <Context> "<name>" has no linkage and has a prior
declaration in this scope at <where>.
Description A declaration within a function body redeclares an
identifier declared earlier in the current scope, and
both declarations did not have the extern storage
class.
User Action Either remove the extra declarations, or have all
declarations for the identifier use the extern
storage class.
NOLONGLONG
Message <Context> 64-bit integral types are not supported on
this platform.
Description 64-bit integer types are not supported on the VAX
platform.
User Action Change the type to an integer type that is supported
on VAX, or compile the application on a platform that
does support 64-bit integers.
NOMACRONAME
Message #define directive is missing macro name identifier.
Description The #define preprocessing directive was not supplied
with an argument. The directive should be followed
with an identifier that specifies the macro name to
be defined. The directive will be ignored.
User Action Supply a valid argument to the preprocessing
directive.
NOMAINUFLO
Message No main function encountered within module.
/IEEE_MODE=UNDERFLOW_TO_ZERO is ignored.
Description Use of the /IEEE_MODE=UNDERFLOW_TO_ZERO is only
meaningful for compilation units that contain a main
program. The compiler will ignore the qualifier.
User Action Remove the qualifier from the command line.
NOMAPPOSSIBLE
Message The register "<register>" cannot be mapped to a
register on the target platform.
Description The pragma linkage directive contains
architecture-specific information. The Alpha
register conventions are different from the IA64
registers conventions. The compiler will normally
try to map the Alpha registers to the corresponding
registers on IA64. In this case this register cannot
be mapped because there is no corresponding IA64
register.
User Action Update the linkage to use a register that can be
mapped, or specify the linkage to use the
linkage_ia64 directive.
NONAMEMEMBERS
Message <Context> a struct or union has no named members.
This is undefined behavior according to the C
standard.
Description The C standard requires that a struct or union
contain at least one named member. Because this
struct/union contains no named members, it does not
conform to the C standard and might not be portable.
User Action Make sure at least one member has a name.
NONATOMIC
Message Unable to generate code for atomic access
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.
NONEWTYPE
Message The type "<type>" is being declared as part of
<context>. C++ does not permit a new type to be
declared in this context. <Fix>.
Description C++ does not allow types to be declared in certain
contexts that are valid in C. One example is the
declaration of a type within a function prototype.
User Action Declare the type before its use.
NONGRNACC
Message Unable to generate code for requested granularity
Description The compiler has generated a call a routine that
performs longword operations on some data that is
requested to be accessed with byte granularity.
Because of this, the requested granularity will not
be met for this data access. This routine may be
generated for a memory copy routine (such as memcpy).
The call can also be generated for certain struct
assignments.
User Action If the data must be accessed with byte granularity
then write your own routine that does the required
action using byte objects. If byte granularity is
not needed at this point, the message can be ignored.
NONINTENUM
Message <Context> the enumeration type, and all associated
enumeration constants will have type <type> because
at least one enumeration constant had a value that
could not be represented in the type signed int.
Description The standard requires that enumeration constants have
a value representable as an int. Other C compilers
will allow enumeration constants to have values
outside this range. In some modes the HP C compiler
will allow this extension. To identify exactly which
constants are outside the range, enable the
nonintenumcon message.
User Action Be aware that other compilers may not support this
extension.
NONINTENUMCON
Message <Context> allowing an enumeration constant outside
the range of signed int is a language extension.
Description The standard requires that enumeration constants have
a value representable as an int. Other C compilers
will allow enumeration constants to have values
outside the range. In some modes the HP C compiler
will allow this extension.
User Action Be aware that other compilers may not support this
extension.
NONINTENUMCON1
Message <Context> this enumeration constant and its
associated enumeration type will not have the type
signed int. This behavior differs from earlier
versions of the compiler.
Description This message will only be output when the "enumrange"
message is disabled. This version of the HP C
compiler will allow enum constants to have a type
other than signed int. This is for compatibility
with other compilers. Programs that rely on the
compiler to truncate enum constants may not work as
expected. For more information, enable the
nonintenum message.
User Action If your program relies on this truncation, cast the
constant to int.
NONLBEFOREEOF
Message File does not end in unescaped newline.
Description The final character of a file was not a newline
character. This could indicate that the file has
been corrupted. The compiler will insert a newline
character at this point in the input stream.
User Action Update the source file so that it ends with a
newline.
NONMULTALIGN
Message The size of this structure is <size> bytes, which is
not a multiple of its alignment of <align>.
Respecify the alignment of the structure or add
<bytes> bytes of additional padding.
Description The size of a struct or union is not a multiple of
its alignment. This could cause unaligned accesses
if an array of these structs or unions is declared.
User Action Modify the struct/union or the alignment so that the
size of the struct or union is a multiple of the
alignment.
NONOCTAL
Message An octal constant contains non-octal digits.
Description An octal constant contains a non-octal digit. The
compiler will convert this non-octal digit to its
corresponding octal value and use that value instead.
For example, 0190 will be converted to 0210 (decimal
136) as the non-octal digit 9 is converted to the
octal 11.
User Action Correct the octal constant to use only octal digits.
NONPORTDEFINED
Message "defined" is treated as an identifier here, not an
operator.
Description For compatibility with older C compilers, in certain
modes the compiler will treat #ifdef defined(foo) as
#ifdef defined, and #ifndef defined(foo) as #ifndef
defined. This might not have been what you intended.
User Action Do not mix #ifdef/#ifndef with the defined operator.
NONPORTLINEDIR
Message Non-standard #line directive.
Description Accepting the line directive without the "line"
preprocessing keyword is an extension of HP C. The
program does not conform to the C standard, and might
not be accepted by other compilers.
User Action Add the "line" preprocessing keyword to the
directive.
NONSTANDCAST
Message <Context> "<expression>" of type "<type>", is being
converted to "<target type>". Such a cast is not
permitted by the standard.
Description The standard only permits casts from a pointer to an
object incomplete type to another pointer to an
object or incomplete type, or from a pointer to
function type to another pointer to function type.
Note that void is considered an incomplete type, so
casts between pointer to void and pointer to function
types are not permitted by the C standard.
User Action Be aware of this difference if you plan to port this
source to another compiler.
NONULINIT
Message <Context> , there is no room for the terminating
'\0'. Standard C allows this, but C++ does not.
Description This declaration initializes an object to a strict
literal. Although the object is large enough to hold
the characters in the literal, it is not large enough
to hold the terminating null character. This might
not have been what you intended. This practice is
also not valid in C++.
User Action Increase the size of the object, or reduce the size
of the initializer.
NOOPERAND
Message Stringization operator missing operand.
Description The preprocessing stringization operator "#" appears
in a macro body without a token argument after the
operator.
User Action Either remove the operator or supply it with a token
that will be stringized.
NOOPERANDS
Message Token pasting operator missing both operands.
Description The preprocessing token pasting operator "##" appears
in a macro body without either the preceeding or
following token arguments.
User Action Either remove the operator or supply it with two
tokens that will be pasted together.
NOPARENARGLST
Message Missing right parenthesis for macro argument list.
Description A macro invocation's argument list did not end in a
right parenthesis.
User Action Correct the program syntax.
NOPARM
Message This declaration does not declare a parameter.
Description The parameter declaration list of an old-style
function definition included a type but no parameter
identifier.
User Action Replace the old-style function definition with the
recommended prototype-format declaration. If this is
not possible, include the correct identifier after
the parameter type.
NOPARMLIST
Message The declaration of <function> has an empty parameter
list. If the function has parameters, they should be
declared here; if it has no parameters, "void" should
be specified in the parameter list.
Description The recommended way to declare a function that takes
no parameters is to use "void" in the parameter list.
User Action Make the recommended change.
NOPRAGARG
Message No argument for #pragma <pragma> was found. Pragma
is ignored.
Description A #pragma directive was not followed by one of the
expected arguments. The directive will be ignored.
User Action Supply all required arguments to the directive.
NOPSECT
Message Missing psect name.
Description The psect specifier in a globaldef declaration must
be a string constant.
User Action Either make the psect a string constant or remove the
psect specifier.
NOREGAVAIL
Message Unable to satisfy program register allocation
requirements.
Description The compiler is unable to allocate all the registers
requested by the program. This most often happens
when asm directives require too many registers.
User Action Rework the asm directives so they use fewer registers
NORELATIONAL
Message <Context> "<expression1>" and "<expression2>" cannot
be compared with a relational operator.
Description Because of their types, the two expressions cannot be
used as the operands of a relational operator. The
rules for which types can be used in a relational are
rather complicated and differ based upon the compiler
mode. Refer to the language documentation for a
complete list of valid combinations.
User Action Modify the relational to use valid types. This can
often be done by casting one of the expressions to
the type of the other.
NORETNONVOID
Message noreturn assertion of #pragma assert directive can't
be specified for non-void function.
Description noreturn assertion was specified in #pragma assert
directive for non-void function; the noreturn
assertion will be ignored.
User Action Either remove noreturn assertion from the directive,
or change return type for the function to void.
NORETURNVAL
Message The function "<name>" returns a value, but no value
is given in this return statement.
Description A function that returns a value contains a return
statement that is missing a return value. Therefore,
the returned value will be undefined. This might not
have been what you intended.
User Action Supply a return value for the return statement.
NORETURNVAL1
Message The function "<name>" has an implicit return type of
int, but no value is given in this return statement.
Description A function that has an implicit return type of int
contains a return statement that is missing a return
value. Therefore, the returned value will be
undefined. This might not have been what you
intended.
User Action Supply a return value for the return statement or
define the function with a void return type.
NORETVAL
Message routine <text> does not return a value
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.
NORGHTPAREN
Message No right parenthesis for parameter list.
Description A macro definition's formal parameter list did not
end in a right parenthesis. A right parenthesis has
been assumed.
User Action End the formal parameter list with a right
parenthesis.
NORIGHTOPERND
Message Token pasting operator missing right operand.
Description The preprocessing token pasting operator "##" appears
in a macro body without a token argument after the
operator.
User Action Either remove the operator or supply it with two
tokens that will be pasted together.
NORIGHTPAREN
Message Missing ")".
Description A right parenthesis was expected at this point in the
program, but none was found.
User Action Correct the program syntax.
NOSEHHAND
Message Missing exception handler.
Description The __builtin_try clause must specify an exception
handler of either __builtin_finally or
__builtin_except. This message is only generated on
UNIX systems.
User Action Correct the __builtin_try clause.
NOSEMI
Message Missing ";".
Description The compiler was expecting a semicolon, but one was
not found.
User Action Correct the program syntax.
NOSEMI1
Message Missing ";". This condition may have been caused by
an open brace without a matching close brace. The
compiler will attempt to identify open braces that
might be missing a close brace.
Description The compiler was expecting a semicolon, but one was
not found. This condition may have been caused
missing close brace. This message is followed by
some number of additional messages that attempt to
identify the bad open brace.
User Action Correct the program syntax.
NOSEMISTRUCT
Message Missing ";" after last structure or union member.
Description Accepting a struct/union type without a semicolon
after the last member specifier is a language
extension of HP C provided for compatiblity with
older C compilers. This syntax is not valid in
standard C, and may not be accepted by other C
compilers.
User Action Add the semicolon at the end of the last member.
NOSFILE
Message Cannot create .s file: overlapping static storage
initializations at Psect <text> + <number>
Description When producing an output assembly file, the compiler
back-end as detected a case where the same storage
location has been initialized to more than one value.
This can occur when inter-file optimization has been
enabled.
User Action Remove one of the initializers.
NOSHAREEXT
Message noshare is a language extension.
Description The noshare 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.
NOSHRINSHR
Message Noshare variable resides in shr extern model -
noshare ignored.
Description The current extern model places all external objects
in a shareable section. Placing an object with a
noshare type qualifier in such a section is invalid.
The compiler will ignore the noshare type qualifier
User Action Place noshare objects in sections with the noshare
attribute.
NOSTRING
Message Missing string literal.
Description The compiler was expecting a string literal, but one
was not found.
User Action Correct the program syntax.
NOSUBTRACT
Message <Context> "<expression2>" cannot be subtracted from
"<expression1>".
Description Because of their types, the two expressions cannot be
used as the operands of the subtraction operator.
Either both operands must be arithmetic type, or both
operands must be pointers to qualified or unqualified
versions of compatible object types, or the left
operand must be a pointer type and the right operand
must be an integral type.
User Action Modify the subtraction to use valid types.
NOTADDRCAST
Message <Context> the address constant "<expression>" can be
cast only to a pointer type, but "<type>" is <type
class> type.
Description An address constant can only be cast to a pointer
type.
User Action Correct the cast.
NOTAREDUCTION
Message bad reduction path from fetch of <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.
NOTCOMPAT
Message <Context> the type of "<name>" is not compatible with
the type of a previous declaration of "<name>" at
<location>.
Description The same identifier has been redeclared with a type
that is incompatible with the type given in a
previous visible declaration. In some modes, the
compiler will use the redeclared type as the type of
the identifier.
User Action Change the declarations to use compatible types.
NOTCOMPATIMP
Message <Context> the type of the function "<name>" is not
compatible with the earlier implicit declaration of
"<name>" at <location>.
Description The declared type of a function does not match the
type given to the function by its earlier implicit
declaration. This may cause unexpected behavior.
User Action Make sure that a valid function declaration is
visible at the point in the source where the function
is first called.
NOTCOMPFUNC
Message <Context> an invalid redeclaration of "<name>" to or
from a function type is being ignored.
Description In certain modes, the compiler will allow an
identifier to be redeclared with a different type.
In this case, the type of the redeclaration is used.
However, in cases where the identifier is redeclared
to or from a function type, the redeclaration is
ignored.
User Action Remove the redeclaration of the identifier.
NOTCONSTQUAL
Message <Context> the referenced type of the pointer value
"<expression>" is const, but the referenced type of
the target of this assignment is not.
Description In an assignment of two pointer types, the type
pointed to by the destination operand must have all
the type qualifiers of the type pointed to by the
source operand. In this case, the type pointed to by
the source has the const type qualifier, but the type
pointed to by the destination does not.
User Action Correct the assignment to use compatible types. This
can be done by inserting a cast operand.
NOTEXPECTING
Message Error parsing <what>. Found "<found>" when expecting
<expecting>.
Description While parsing the program, the compiler has
encountered something unexpected. The message will
detail what the compiler was trying to parse and the
item that was invalid, and will also produce a list
of those items it was expecting to find.
User Action Correct the offending section of the program.
NOTINCRTL
Message Identifier "<id>" is reserved by the
<C89|C99|C2010...> standard and will be mapped to
"<name>" although it is not available in the CRTL
available to the compiler.
Description The specified identifier is reserved for use as an
identifer with external lingage in the specified
version of the C standard. But according to the CRTL
mapping table available to the compiler, that
identifier is not defined in the CRTL you expect to
link against. This may be because the function or
object is not yet implemented in the current
DECC$SHR, or because you have used logical
DECC$CRTLMAP to specify a CRTL mapping table for a
version of the CRTL that does not implement it.
User Action If you intended to use the identifier as defined by
the C standard, and you have not defined the logical
DECC$CRTLMAP, then the identifier is not defined in
the DECC$SHR available to the compiler. If this is
the latest released DECC$SHR, then the identifier is
not yet implemented and you need to consider
workarounds; otherwise you should upgrade to the
latest available CRTL that does implement it. If you
did not intend to use the identifier as defined by
the C standard (i.e. it is an identifier you
expected to be defined by your application), then you
have a name clash with the specified version of the
standard and you should change the spelling of the
identifier; alternatively, you could disable
prefixing for it using /PREFIX=EXCEPT=, or specify an
older version of the standard with either /PREFIX= or
/STANDARD=.
NOTINTRINSIC
Message The function "<routine name>" is not a known
intrinsic function and cannot be used with #pragma
function. The function is unaffected by this pragma.
Description A function identifier specified in a #pragma function
directive is not a valid intrinsic function on this
platform. The function is thus never treated as an
intrinsic, and so #pragma function can never be
applicable to it. Perhaps the name was misspelled,
or perhaps the function was thought to be intrinsic,
possibly because it is intrinsic on some other
platform. In the latter case, the desired result,
that the function not be treated as intrinsic, would
happen with or without the pragma.
User Action Either correct the identifier spelling or remove the
use of the pragma.
NOTLOCALPARM
Message <Context> "<identifier>" is not a local parameter.
Description The second argument to the variable argument list
va_start macro is not a formal parameter of the
current function. The second argument to va_start
should be the rightmost parameter in the function
definition.
User Action Correct the second argument to va_start.
NOTONEORZERO
Message <Context> the value of "<expression>" is neither 0
nor 1.
Description The __builtin_va_start macro has been used
incorrectly.
User Action Correct the use of the macro.
NOTPARM
Message <Context> <name> is not a parameter.
Description The identifier name in the parameter declaration does
not match a name in the identifier list of an
old-style function definition.
User Action Correct either the identifier in the declaration or
in the identifier list so that they match. HP also
recommends that old-style function definitions be
replaced by prototype-format definitions.
NOTPOSINT
Message <Context> the array bound "<expression>" is not a
positive integer.
Description The compiler has encountered an array-bounds
specifier that is either zero or negative.
Array-bounds specifiers must be positive integer
constants.
User Action Correct the array-bounds specifier
NOTRESTQUAL
Message <Context> the referenced type of the pointer value
"<expression>" is restrict, but the referenced type
of the target of this assignment is not.
Description In an assignment of two pointer types, the type
pointed to by the destination operand must have all
the type qualifiers of the type pointed to by the
source operand. In this case, the type pointed to by
the source has the restrict type qualifier, but the
type pointed to by the destination does not.
User Action Correct the assignment to use compatible types. This
can be done by inserting a cast operand. Note that
care should be taken in assigning to a restricted
pointer type.
NOTRIGHTMOST
Message <Context> "<identifier>" is not the rightmost
parameter to "<function>".
Description The second argument to va_start was not the rightmost
parameter in the variable parameter list in the
function definition. This is an invalid argument to
va_start. Other compilers might not accept this
program.
User Action Update the second argument to va_start to use the
rightmost parameter.
NOTSCALARCTRL
Message The controlling expression "<expression>" has <type>
type, which is not scalar.
Description An execution control expression does not have scalar
type. This is not valid. An example of an execution
control expression is the expression following the
while keyword in a while statement.
User Action Change the control expression to have scalar type.
NOTTYPEDEF
Message <Context> "<name>" does not name a type.
Description This message is output when the compiler encounters
an identifier that it believes is a typedef and no
valid typedef by this name is defined in the current
scope. This most often occurs when there was an
error in the declaration of the typedef name.
User Action Correct the declaration of typedef.
NOTUNALQUA
Message <Context> the referenced type of the pointer value
"<expression>" is __unaligned, but the referenced
type of the target of this assignment is not.
Description In an assignment of two pointer types, the type
pointed to by the destination operand must have all
the type qualifiers of the type pointed to by the
source operand. In this case, the type pointed to by
the source has the __unaligned type qualifier, but
the type pointed to by the destination does not.
User Action Correct the assignment to use compatible types. This
can be done by inserting a cast operand.
NOTVOLQUAL
Message <Context> the referenced type of the pointer value
"<expression>" is volatile, but the referenced type
of the target of this assignment is not.
Description In an assignment of two pointer types, the type
pointed to by the destination operand must have all
the type qualifiers of the type pointed to by the
source operand. In this case, the type pointed to by
the source has the volatile type qualifier, but the
type pointed to by the destination does not.
User Action Correct the assignment to use compatible types. This
can be done by inserting a cast operand.
NOTYPES
Message Declaration has no type or storage class.
Description A file-scope declaration contains no type and no
storage-class specifier. In some modes, the HP C
compiler will treat this as a tentative definition of
an int variable. Accepting this declaration is an
extension to standard C provided for compatibility
with other compilers.
User Action Rewrite the declaration to contain a data type and/or
storage class.
NOUNIQFORMALS
Message Non-unique formal parameter definition.
Description The same name has been used for more than one formal
parameter in a macro definition. Any occurrence of
the name in the macro body will correspond to the
last formal parameter given this name.
User Action Each macro formal parameter should have a unique
name.
NOWHILE
Message Missing "while".
Description While processing a do statement, the compiler did not
find a while clause.
User Action Supply a while clause for the do statement.
NOWRTWRITTEN
Message Readonly psect <text> is written
Description The compiler has detected an attempt to write to
read-only storage.
User Action Either remove the write or make the storage
read/write.
OBJECTTOOBIG
Message The size of "<name>" exceeds the maximum size of an
object allowed on this platform which is <size>
bytes.
Description An object has been declared with a size that is too
large for this platform.
User Action Reduce the size of the object.
OKCPPINARGS
Message "#<directive>" directive within a macro argument list
is not portable.
Description HP C will allow certain directives to appear within
the argument list of a macro invocation. This might
not be portable.
User Action If possible, rewrite the macro invocation.
OPENBRACE
Message Missing "{".
Description The compiler was expecting an open brace, but one was
not found.
User Action Correct the program syntax.
OPENCOMMENT
Message A comment is not terminated.
Description The end of a file was reached while within a comment.
The message will indicate the start of the comment.
All source files, even those included via the
#include preprocessing directive, must not end in a
pending comment.
User Action Terminate the comment before the end of the source
file.
OPENPAREN
Message Missing "(".
Description The compiler was expecting an open parenthesis, but
one was not found.
User Action Correct the program syntax.
OPTIMIZEPOP
Message This "restore" has underflowed the pragma optimize
stack. No corresponding "save" was found.
Description The optimize stack, managed by the #pragma optimize
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.
OPTLEVEL
Message Invalid optimization level <number>, defaulted to
<number>.
Description An optimization level that is outside the range of
valid optimization levels has been specified. The
compiler will default to the stated level.
User Action Supply a valid optimization level on the command
line.
OTHERDECLUSED
Message <Context> "<name>" is not declared in a scope active
at this point in the compilation. However, there is
a declaration of this identifer with extern storage
class in another scope at <where>. This declaration
will be used.
Description In some modes, if the compiler cannot find the
declaration of an object in the current scope, it
will search other scopes for extern declarations of
that object. If it finds such a declaration, it will
be used. Note that this is a language extension
provided for compatibility with other compilers.
User Action Declare the object so that it is visible at all
places it is referenced.
OTHERMEMBER
Message <Context> "<name>" is a member of another struct or
union.
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.
User Action Correct the struct or union reference so that the
member specifier is a member of the type of the left
operand.
OUTARGPREC
Message <Context> the type of this argument to <function
name> is not appropriate for the precision argument
of the conversion specifier "<incorrect conversion>".
Behavior can be unpredictable.
Description This argument corresponds to an output precision
specification. C requires that this argument have
integer type, and it does not.
User Action Cast the argument to an int type.
OUTARGWIDTH
Message <Context> the type of this argument to <function
name> is not appropriate for the width argument of
the conversion specifier "<incorrect conversion>".
Behavior can be unpredictable.
Description This argument corresponds to an output width
specifier. C requires that this argument have
integer type, and it does not.
User Action Cast the argument to an int type.
OUTFLOATINT
Message <Context> this argument to <function name> and
conversion specifier "<incorrect conversion>" combine
integer and floating-point types. Behavior can be
unpredictable.
Description The compiler has detected an output conversion
specifier whose data type does not match its
corresponding argument in a way that will cause
unpredictable behavior.
User Action Modify either the argument or the conversion
specifier so that they match.
OUTSTRINGTYPE
Message <Context> this argument to <function name> is of
"<type name>" type and is not appropriate for the
conversion specifier "<incorrect conversion>". The
value will be formatted in an unintended manner.
Description The compiler has detected a string conversion
specifier that does not match its corresponding
argument. This might not have been what you
intended.
User Action Modify either the argument or the conversion
specifier so that they match.
OUTTOOFEW
Message <Context> the number of conversion specifiers to
<function name> exceeds the number of values to be
converted. Conversion specifiers from "<last valid
conversion>" onward will process meaningless and
perhaps invalid data.
Description The number of conversion specifiers is greater than
the number of values to be converted as specified in
the parameter list. This is probably not what you
intended.
User Action Make sure the number of conversion specifiers match
the values to be converted.
OUTTOOMANY
Message <Context> additional arguments to <function name> are
provided for which there are no conversion specifiers
in the format string. Arguments from "<last
expression>" onward will be evaluated, but not
processed by <function name>.
Description The number of conversion specifiers is less than the
number of values to be converted as specified in the
parameter list. This is probably not what you
intended.
User Action Make sure the number of conversion specifiers match
the values to be converted.
OUTTYPELEN
Message <Context> this argument to <function name> is of
"<typeclass>" type and is not appropriate for the
conversion specifier "<incorrect conversion>". The
value might be truncated or formatted in an
unintended manner.
Description The compiler has detected an output conversion
specifier that does not match its corresponding
argument. This might not have been what you
intended.
User Action Modify either the argument or the conversion
specifier so that they match.
OUTVARORDER
Message <Context> variable ordering is used in a conversion
specifier for <function name>. If variable ordering
is used, it must be specified for all conversions.
Description A conversion specification can contain only one type
of conversion specification - % or %n$. Mixing them
will cause unpredictable behavior.
User Action Change the format specification to use only one type
of conversion specification.
PACKSTACKPOP
Message This "pop" has underflowed the pragma <stack name>
stack. No corresponding "push" was found.
Description The member_alignment/pack stack, managed by the
#pragma pack and #pragma member_alignment directives,
contains more pops/restores than pushes/saves, This
could signify a coding or logic error in the program.
User Action Make sure each pop/restore has a corresponding
push/save.
PARAMREDECL
Message <Context> "<name>" overrides a formal parameter
declared at <where>.
Description A declaration within a function body redeclares a
formal parameter.
User Action Change the name of either the formal parameter or the
declared variable.
PARENLITERAL
Message <Context> accepting a string literal in parentheses
as the initializer for a character array is a
language extension.
Description The compiler accepts this kind of initializer for
compatibility with many other C compilers. According
to the C standard, a string literal in parentheses is
a character pointer. Therefore, this program does
not conform to the standard and may be rejected by
other compilers.
User Action Remove the parentheses.
PARMINCOMP
Message <Context> the parameter <name> has an incomplete
type.
Description The parameter of an old-style function definition has
an incomplete type. This is not valid.
User Action Complete the type before the declaration of the
parameter. HP also recommends that old-style
function definitions be replaced by prototype-format
definitions.
PARMINIT
Message <Context> a parameter declaration cannot include an
initializer.
Description The parameter declaration list of an old-style
function definition included an initializer. This is
not valid.
User Action Remove the initializer from the declaration and
initialize the parameter in the function body. HP
also recommends that old-style function definitions
be replaced by prototype-format definitions.
PARMSTORCLS
Message <Context> a parameter has an explicit storage class
other than "register".
Description The only storage class that can be specified for a
formal parameter is "register".
User Action Either remove the storage class or use "register" if
that is desired.
PARMSTORMOD
Message <Context> a parameter cannot have a storage class
modifier.
Description A formal parameter cannot be declared with a storage
class modifier.
User Action Remove the storage class modifier.
PARMTYPLIST
Message Ill-formed parameter type list.
Description While processing a function declaration, an invalid
parameter type list was encountered.
User Action Correct the program syntax.
PARNOIDENT
Message Missing identifier.
Description While processing an old-style function definition,
the compiler was expecting an identifier, but one was
not found.
User Action Correct the program syntax. HP also recommends that
old-style function definitions be replaced by
prototype-format definitions.
PDBOPERR
Message Error opening PDB file <text>: <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.
PDBTYPERR
Message Error adding type record to PDB file: <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.
PDOINDEXNOTPRIV
Message index variable of PDO <text> is not a private
variable
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.
PDONEINSTATIC
Message pdone <text> in statically-scheduled PDO will be
ignored
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.
PDONENOTINPDO
Message pdone <text> is not nested in a PDO
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.
PLUSWSTOCLS
Message The use of the <spelling> option has prevented this
redeclaration of "<variable>" from changing its
linkage. The linkage will be that specified by the
earlier declaration at <location>.
Description In many cases, the compiler will allow a
redeclaration of an item to change its linkage. For
example, in most modes, if an object is declared with
extern linkage and later with static linkage, the
compiler will give it static linkage. This changing
of linkage usually causes a warning to be issued.
However, in cases where interfile optimization has
been selected (-ifo on UNIX, /PLUS_LIST_OPTIMIZE on
OpenVMS), the compiler cannot allow a later
declaration to modify the linkage of a previous
declaration.
User Action Change all declarations to use the same linkage.
POINTERINTCAST
Message <Context> the 64-bit pointer "<expression>" is being
cast to an integer type that is only <size> bits in
size. This behavior is undefined.
Description Casting a 64-bit pointer to a shorter integer type is
undefined behavior. This also could indicate code
that relies on pointers and integers being the same
size. The code will cause an unexpected loss of data
on 64-bit platforms.
User Action If this is the intended behavior, first cast the
pointer to a 64-bit integer, then cast the result to
the desired integer type.
POPMISMATCH
Message The member alignment popped/restored with pragma
<pragma name> was saved using pragma <pragma name>.
The member alignment restored will take effect.
Description HP C supports two forms of the member alignment
directives. One begins with #pragma pack, the other
with #pragma member_alignment. A program has mixed
the pack and the member_alignment form of the
directives in a way that is not recommended. This
might indicate a programming error.
User Action If a member alignment has been saved by one form of
the member-alignment directive, it should be restored
by the same form of the directive.
PRAGIGNORE
Message The pointer size control <name> pragma is not active.
Pragma is ignored.
Description Either one of the pragmas that used to control
pointer size has been specified on a platform that
does not support mixed pointer sizes, or the #pragma
pointer_size directive has been used without the
appropriate command-line option or qualifier. In all
cases, the directive is ignored.
User Action Either remove the directive or add the appropriate
command-line option.
PRAGMA
Message Strict standard C extension: A #pragma directive was
encountered.
Description As the purpose of a #pragma directive is to specify
implementation-defined behavior, it is likely that
other C compilers will not treat this pragma in the
same way HP C will.
User Action Be aware of this if you wish to port the program.
PRAGMAIDENT
Message Please use the preferred "#pragma ident" directive in
place of the "#ident" directive.
Description The #ident directive is a language extension. Other
C compilers might not accept it.
User Action Use the portable #pragma ident directive instead.
PRAGMAINBLK
Message The pragma <name> cannot be used inside a function
block.
Description This #pragma directive is only permitted at file
scope, outside of all function definitions.
User Action Move the directive to file scope, preceding the
function definition that is to be affected. To limit
the pragma to just that particular function, sandwich
the #pragma and the function definition between a
pair of matching pragmas with the save and restore
keywords.
PRAGMAMOD
Message Please use the preferred "#pragma module" directive
in place of the "#module" directive.
Description The #module directive is a language extension. Other
C compilers are unlikely to accept it.
User Action Use the portable #pragma module directive instead.
PRAGMAOPTDUP
Message This #pragma optimize has already modified this
optimization setting. This setting will replace the
old.
Description A #pragma optimize has specified the same
optimization setting more than once. The later
setting will replace the previous one.
User Action Remove the earlier setting.
PRAGMAOPTLVL
Message The level set by a #pragma optimize directive must be
between 0 and 5. Pragma is ignored.
Description A #pragma optimize has tried to set the optimization
level to a value outside the valid range. The
compiler will ignore the directive.
User Action Set the optimization level to a number from 0 to 5.
PRAGMAOPTSPEC
Message Setting speculation control is not available on this
platform. The setting will be ignored.
Description Setting speculation control in only available on
certain platforms. Trying to modify the setting on
other platforms will have no effect.
User Action Remove the speculation setting.
PRAGMAOPTZERO
Message If a #pragma optimize specifies level=0, that must be
the only optimization setting specified by the
pragma. Pragma is ignored.
Description If a #pragma optimize specifies level=0, that must be
the only optimization setting specified by the
pragma. The compiler will ignore the directive.
User Action Remove the other settings specified by the directive.
PREOPTE
Message An error was detected in the processing of a <option
spelling> option: <#define or #undefine problem>
Description An error was encountered during the processing of a
macro definition specified on the command line. The
message should provide additional information about
the error.
User Action Correct the command line argument.
PREOPTW
Message A problem was detected in the processing of a <option
spelling> option: <#define or #undefine problem>
Description A problem was encountered during the processing of a
macro definition specified on the command line. The
message should provide additional information about
the problem.
User Action Correct the command-line argument.
PREPROCOUT
Message An error occurred while attempting to open either the
preprocessor output file or the dependency file:
<problem>.
Description An unexpected error occurred during the creation of a
preprocessor output file or a dependency file. The
message text will contain additional information
about the failure.
User Action Correct the condition that caused the failure.
PRIVATENOTSHARE
Message variable <text> on a local or lastlocal list is not
declared in a shared scope.
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.
PROMOTMATCH
Message <Context> the promoted type of <name> is incompatible
with the type of the corresponding parameter in a
prior declaration.
Description The promoted type of a parameter of an old-style
function declaration does not match the type given
earlier in a prototype declaration of the function.
User Action Correct the data types so they match. HP also
recommends that old-style function definitions be
replaced by prototype-format definitions.
PROMOTMATCHW
Message <Context> the promoted type of <name> is incompatible
with the type of the corresponding parameter in a
prior declaration.
Description The promoted interger or floating type of a parameter
of an old-style function declaration does not match
the integer or floating type given earlier in a
prototype declaration of the function.
User Action Correct the data types so they match. HP also
recommends that old-style function definitions be
replaced by prototype-format definitions.
PROTOF
Message An error occurred while attempting to open the
prototype output file: <problem>.
Description An unexpected error occurred during the creation of a
prototype output file. The message text will contain
additional information about the failure.
User Action Correct the condition that caused the failure.
PROTOSCOPE
Message The type "<type>" has been declared within and is
limited to a function prototype scope. It will not
be compatible with an identical type declared in
another scope. This might not be what you intended.
Description A type is declared within a function prototype. The
type is local to the function prototype and will not
be visible outside the prototype. This might cause
unexpected errors later in the compilation.
User Action Declare the type before the function prototype.
PROTOSCOPE2
Message <Context> the struct type was previously declared
with prototype scope in this function. Now it is
declared with a different prototype scope.
Description This function declaration contains a parameter that
is a pointer to a type that has prototype scope, and
an earlier declaration of the function contains a
parameter that is also a pointer to a type that has a
different prototype scope. In most compiler modes
this will cause the function redeclarations to
differ.
User Action Avoid declaring types with function prototype scope.
PROTOSCOPE3
Message <Context> the struct type was previously declared in
this function with prototype scope. Now it is
declared with file scope.
Description This message is generated when the compiler first
encounters a function prototype that declares a type
with prototype scope, and then later sees a second
declaration or definition of that same function with
the parameter declared using the same type declared
at file scope. For example: void foo(struct S { int
a; int b;} *s); struct S { int a; int b;} s; void
foo(struct S *s);
User Action Declare the type at file scope before the first
prototype declaration.
PROTOSTATIC
Message The extracted header file contains prototypes for
static functions, which should be removed before
including the header in a source file other than the
originator.
Description When extracting function prototype declarations, the
compiler has encountered a static function. The
prototype declaration placed in the output .H file
should be removed if the .H file is included in any
source other than that used to create the .H file.
This is because those static functions may not be
declared in the other files. This message can only
be generated when the compiler has been invoked with
the option to extract function prototype
declarations, and the suboption to generate
prototypes for static functions has also been
specified.
User Action Be aware of this if you wish to use the output .H
file in a file other than the one from which the .H
file was generated.
PROTOTAG
Message The extracted header file contains prototypes with
tag names, which should be moved to after the tag
name declaration.
Description When extracting function prototype declarations, the
compiler has encountered a parameter type specifier
that references a tag. Because the created prototype
will use this tag, it should be moved after the tag
declaration in the final compilation source. This
message can only be generated when the compiler has
been invoked with the option to extract function
prototype declarations.
User Action Be aware of this if you wish to use the output .H
file.
PROTOTYPEDEF
Message The extracted header file contains prototypes with
typedefs, which should be moved to after the typedef
declaration.
Description When extracting function prototype declarations, the
compiler has encountered a parameter type specifier
that is defined by a typedef. Because the created
prototype will use this typedef, it should be moved
after the typedef declaration in the final
compilation source. This message can only be
generated when the compiler has been invoked with the
option to extract function prototype declarations.
User Action Be aware of this if you wish to use the output .H
file.
PROTOVLA
Message The extracted header file contains prototypes for
functions which have formal parameters with variably
modified type. All variable length bound specifiers
have been replaced by a "*" signifying a variable
length array of unspecified size.
Description When extracting function prototype declarations, the
compiler has encountered a function or functions
which have a formal parameter with variably modified
type. The compiler is unable to recreate the source
that specified the number of array elements.
Instead, the output prototype will use the "*" bounds
specifier. Note that the output prototype is valid
for the function.
User Action Be aware that the compiler has made this minor change
to the function declaration.
PSECTFIRST
Message "#pragma <psect_type>" directive must precede any
declarations.
Description The #pragma code_psect or #pragma linkage_psect
directives must appear before any function or
external data definitions.
User Action Place the directive earlier in the source program.
PSECTTOOLONG
Message Psect name is too long (maximum is 31 characters).
Pragma is ignored.
Description A psect name specified in a #pragma code_psect,
#pragma linkage_psect, or #pragma extern_model
directive must be less than 32 characters in length.
The compiler will ignore the directive.
User Action Shorten the psect name.
PTRINTTOLONG
Message <Context> "<expression>", a pointer to a 32-bit
integer, is being cast to a pointer to a 64-bit
integer. This may lead to unintended results.
Description On many platforms long integers are the same size as
integers, and casting a pointer to int to a pointer
to long int is not a problem. On this platform long
integers are 64-bits. This cast could indicate a
potential porting problem.
User Action Verify that this is the intended behavior.
PTRLONGTOINT
Message <Context> "<expression>", a pointer to a 64-bit
integer, is being cast to a pointer to a 32-bit
integer. This may lead to unintended results.
Description On many platforms long integers are the same size as
integers, and casting a pointer to long int to a
pointer to int is not a problem. On this platform
long integers are 64-bits. This cast could indicate
a potential porting problem.
User Action Verify that this is the intended behavior.
PTRMISMATCH
Message <Context> the referenced type of the pointer value
"<expression>" is "<type>", which is not compatible
with "<target type>".
Description In a pointer assignment, the type pointed to by the
source pointer is different than the type pointed to
by the destination pointer.
User Action Correct the assignment to use compatible types. This
can be done by inserting a cast operand.
PTRMISMATCH1
Message <Context> the referenced type of the pointer value
"<expression>" is "<type>", which is not compatible
with "<target type>" because they differ by
signed/unsigned attribute.
Description In a pointer assignment, the type pointed to by the
source pointer is different than the type pointed to
by the destination pointer. In this case the types
differ because the signed/unsigned type attributes
are different.
User Action Correct the assignment to use compatible types. This
can be done by inserting a cast operand.
QUALAFTCOMMA
Message Type qualifier(s) after a comma ignored.
Description In Microsoft mode, the compiler used to accept a type
qualifier after a comma used for separating
declarators. Because Microsoft no longer accepts
this type of declaration, HP C will no longer accept
it. The type qualifier is ignored.
User Action Remove the type qualifier.
QUALFUNCRET
Message The return type of "<name>" is a qualified type.
Type qualifiers have no meaning for function return
values.
Description A type qualifier has been used as part of the type of
a function return value. The type qualifiers have no
meaning for function return values.
User Action Remove the type qualifier.
QUALISPTR
Message <Context> "<expression>" has a pointer type, but
occurs in a context that expects a struct or union.
Description The left operand of the struct/union member operator
(.) is a pointer type instead of a struct or union
type.
User Action Specify the correct struct or union type object as
the left operand. In cases where the left operand is
a pointer to a struct or union, it might be possible
to use the struct/union pointer operator (->) instead
of the member operator.
QUALNA
Message The <qualifier name> qualifier is not available on
this platform and will be ignored.
Description The specified qualifier is not supported on this
platform.
User Action Remove the qualifier from the command line.
QUALNOTUS
Message <Context> the qualifier for "<name>" is not a struct
or union.
Description In certain modes, the compiler will allow the left
operand of a struct/union member reference to be
certain types other than a struct or union type. In
these cases the compiler will issue a warning that
this non-standard syntax is being accepted.
User Action Modify the left operand to be a struct or union type.
QUESTCOMPARE
Message <Context> the unsigned expression "<expr>" is being
compared with a relational operator to a constant
whose value is not greater than zero. This might not
be what you intended.
Description An ordered comparison between an unsigned value and a
constant that is less than or equal to zero often
indicates a programming error. Humans consider an
unsigned value to be larger than any negative value.
But in C a negative value is converted to an unsigned
value before the comparison, so any negative value
compares larger than most unsigned values. An
ordered comparison of an unsigned value to zero
suggests a programming error because the value can
only be greater than or equal to zero. If the code
is correct, the comparison could be more clearly
coded by testing for equality with zero.
User Action Cast (or otherwise rewrite) one of the operands of
the compare to match the signedness of the other
operand, or compare for equality with zero.
QUESTCOMPARE1
Message <Context> the unsigned expression "<expr>" is being
compared with an equality operator to a constant
whose value is negative. This might not be what you
intended.
Description An unsigned value and a signed constant whose value
is negative are being compared for equality.
Logically, these value would never be equal. But in
C the negative constant value is converted to an
unsigned value before the comparison, and may well
compare equal.
User Action Cast (or otherwise rewrite) one of the operands of
the compare to match the signedness of the other
operand.
QUESTCOMPARE2
Message <Context> the unsigned expression "<expr>" is being
tested to see if it is greater than zero. This might
not be what you intended.
Description An ordered comparison between an unsigned value and a
constant that is zero may indicate a programming
error. Often C programmers do not realize that an
expression has an unsigned type. If the code is
correct, the comparison could be more clearly coded
by testing for equality with zero.
User Action Cast (or otherwise rewrite) one of the operands of
the compare to match the signedness of the other
operand, or compare for equality with zero.
READONLYEXT
Message readonly is a language extension.
Description The readonly 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.
REDECLNOPARAM
Message <Context> the declaration of the function "<name>"
containing no parameter information replaces an
earlier declaration of "<name>" at <location>.
Description A function which was previously declared with a
function prototype has been redeclared without
parameter information. This is a violation of the C
standard. The HP C compiler will accept this for
compatibility with older compilers.
User Action Remove one of the declarations.
REDEF
Message This declaration contains a redefinition of "<name>".
The previous declaration is at <location>.
Description This declaration has tried to redefine an identifier
that was defined earlier. This is not valid.
User Action Remove one of the definitions.
REDEFSTRUCT
Message <Context> the struct "<name>" is redefined.
Description The struct tag declared in this declaration is
already declared as a struct tag by another
declaration.
User Action Change the name of the struct tag.
REDEFTAG
Message <Context> the tag "<name>" is redeclared.
Description The tag declared in this declaration is already
declared.
User Action Change the name of the tag.
REDEFUNION
Message <Context> the union "<name>" is redefined.
Description The union tag declared in this declaration is already
declared as a union tag by another declaration.
User Action Change the name of the union tag.
REFBEFORETLS
Message <Context> the reference to the variable "<var>"
lexically precedes its use in a #pragma omp
threadprivate directive. This is not allowed.
Description An OpenMP threadprivate directive must lexically
precede all references to any varible in its variable
list. The compiler had detected a reference to a
variable which appears in a subsequent threadprivate
directive.
User Action Move the threadprivate directive before the
reference.
REGCONFLICT
Message Conflicting required uses of register(s): <text>
Description The special linkage associated with a function has
specified that one of the standard calling convention
registers be used in a nonstandard way without also
replacing its standard use with another register. An
example would be a function that returns an int value
using a special linkage that states R0 is not used,
and does not specify another register to hold the
return value.
User Action Correct the #pragma linkage directive that specifies
the special linkage.
REGNOSHARE
Message <Context> noshare cannot be used with the register
storage class. Modifier noshare is ignored.
Description The storage class modifier noshare is meaningless for
objects declared with register storage class. The
compiler ignores the noshare.
User Action Remove the noshare storage class modifier.
RELOCALIGNMENT
Message An initialization requiring relocation is not
correctly aligned at Psect <text> + <number>
Description On some platforms, initializing an object to an
address requires that the object be aligned on a
natural boundary.
User Action Either remove the static initializer or align the
object being initialized.
RESMISMATCH
Message The pointer size restored with pragma <pragma name>
was saved using pragma <pragma name>. The pointer
size restored will take effect.
Description HP C supports two forms of the pointer-size
directives. One begins with #pragma pointer_size,
the other with #pragma required_pointer_size. A
program has mixed the required_pointer_size and the
pointer_size form of the pointer-size directives in a
way that is not recommended. This might indicate a
programming error.
User Action If a pointer size has been saved by one form of the
pointer-size directive, it should be restored by the
same form of the directive.
RESTRICTEXT
Message The __restrict type qualifier is a language
extension.
Description The use of the __restrict type qualifier might not be
portable to other C compilers.
User Action Be aware of this portability concern.
RESTRICTEXT1
Message Placement of the __restrict qualifier within the
array-bound specifier of a formal parameter
declaration is a language extension.
Description The use of the restrict type qualifier within the
array bound specifier of a formal parameter is a
language extension supported by HP C. 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.
RESTRICTEXT2
Message The restrict type qualifier is a new feature in C99.
Other C compilers might not successfully compile a
program that uses this feature.
Description The use of the restrict type qualifier might not be
portable to other C compilers.
User Action Be aware of this portability concern.
RESTRICTNOP
Message The restrict type qualifier can only be applied to a
pointer type that points to an object or incomplete
type. Qualifier is ignored.
Description The restrict type qualifier has been used with an
invalid type. Only pointers to object or incomplete
types can have the restrict type qualifier. The
compiler will ignore the type qualifier in all other
cases.
User Action Remove the type qualifier or change the type to one
that accepts the qualifier.
RETLOCALADDR
Message This return statement returns the address of a local
variable. The address returned cannot be used by the
caller in any meaningful way.
Description The storage for all local variables is undefined
after a function has returned. Returning the address
of a local variable will cause undefined behavior
when the return value is used in the calling program.
User Action Either change the variable to have static storage
duration, use malloc to allocate the storage (and
free it after its use), or change the interface to
have the caller pass in the address at which data is
to be stored.
RETRYCONV
Message Built-in function <retry-name> is not available on
this platform. It has been converted to
<nonretry-name> by ignoring the retry count and
setting the retry status to 1.
Description The version of this built-in function with retry
capability is not available on the IA64 platform.
User Action Use the non-retry version of this built-in function.
RETRYNOTAVAIL
Message Built-in function <name> with retry count is not
available on this platform. The retry count is
ignored.
Description The retry capability of this built-in function is not
available on the IA64 platform.
User Action Remove retry count from built-in function call.
RETVALTOOBIG
Message The size of return value of "<name>" exceeds the
maximum size of an object allowed on this platform
which is <size> bytes.
Description A function's return value is too large for this
platform.
User Action Reduce the size of the return value.
RIGHTSHIFTOVR
Message <Context> the right shift count "<number>" is greater
than or equal to the size of the unpromoted operand
"<expression>".
Description The compiler has detected a right shift count that is
greater than or equal to the size of the operand to
be shifted (before application of the integral
promotions). This might not be what you intended, as
the result contains none of the original bits of the
operand. For an unsigned operand, the result is
always 0. For a signed operand, the result is either
0 or -1, depending on whether or not the operand had
a negative value. The same result would be achieved
by shifting a signed operand one fewer bits.
User Action Correct the shift count (or replace the expression by
0 if appropriate).
RTEXCEPT
Message <Context> the floating-point constant named "<name>"
will cause an exception at runtime.
Description The IEEE trap mode of this program will cause an
exception at runtime if this floating-point constant
is used in an expression.
User Action If you do not choose to cause a runtime exception,
replace the named constant with a conventional
floating point constant. The HUGE_VAL macros defined
by <math.h> may be used in place of IEEE Infinities
with any floating-point representation.
RTLMAPNOTFOUND
Message C RTL mapping information for RTL <name> not found.
Could not access <image_name>.
Description In most cases, the HP C compiler will automatically
map names of C standard library functions to their
corresponding names in the HP C RTL shareable image.
In many cases, this is done simply by adding a
"DECC$" prefix to the name. In order for this
mapping to work, the compiler accesses an RTL mapping
table. This message is issued if the compiler was
unable to open the mapping table. In these cases, no
name mapping will be performed. The most common
cause of this message is specifying bad name in the
/PREFIX=RTL="name" compiler qualifier.
User Action Specify a valid RTL on the /PREFIX=RTL qualifier. If
no qualifier was used, it might be necessary to
reinstall the compiler and/or RTL. For more
information consult the HP C Run-time Library Manual
for OpenVMS Systems.
RTLMISMATCH
Message HP C RTL prefix table version mismatch: RTL table is
V<major>.<minor>, compiler needs V<major>.<minor>.
Description In most cases, the HP C compiler will automatically
map names of C standard library functions to their
corresponding names in the HP C RTL shareable image.
In many cases, this is done simpl by adding a "DECC$"
prefix to the name. In order for this mapping to
work, the compiler accesses an RTL mapping table.
The compiler also requires that the version of the
RTL mapping table be compatible with the version of
the compiler. In cases where the versions are
incompatible, this message is generated. In these
cases, no name mapping will be performed. The most
common cause of this message is specifying an old RTL
name in the /PREFIX=RTL="name" compiler qualifier.
User Action Specify a new RTL on the /PREFIX=RTL qualifier. If
no qualifier was used, it might be necessary to
reinstall the compiler and/or RTL. For more
information, consult the HP C Run-time Library Manual
for OpenVMS Systems.
SAMEASTYPEDEF
Message <Context> the extern has the same name as a
file-scope typedef. This is a language extension.
Description The program has declared an extern inside a function
whose name matches a file-scope typedef. This is not
allowed by the C standard, but is accepted for
compatibility with other C compilers.
User Action Change the name of the variable or the typedef.
SCACALL
Message This function contains too many parameters for SCA to
handle. Function parameter info will be truncated.
Description The parameter information for this function contains
more data than SCA can process. The compiler will
truncate the parameter information. Be aware that
the parameter information will be incomplete.
User Action Simplify the parameter information.
SCAID2LONG
Message The identifier exceeds the SCA limit of <number>
characters. In the SCA file the name will be
truncated to "<truncated spelling>".
Description The length of an identifier supported by SCA is less
than the length of an identifier supported by the HP
C compiler. Because of this, the compiler will
truncate an identifier name to fit the SCA limits.
User Action Either reduce the identifier name, or be aware of
this when using SCA.
SCALEFACTOR
Message The CDD description for <name> specifies a scale
factor of <number>. The scale factor is being
ignored.
Description HP C does not support scaled arithmetic.
User Action Verify that all computations involving this item are
correctly scaled.
SCAOVFLO
Message Compiler Internal Error: SCA event buffer
overflowed. Please submit a problem report.
Description When building SCA information, the compiler
overflowed its internal buffer. This should not
happen.
User Action Please submit a problem report detailing the failure.
SEQUENCEEXT
Message <Context> allowing a comma operator is a language
extension.
Description In this context the C standard does not allow the
comma (sequence) operator. HP C allows this syntax
for compatibility with some other C compilers. Be
aware that this syntax may not be accepted by other C
compilers.
User Action If the intent is to use an expression that is not
necessarily a constant expression, then enclose it in
parentheses. But if the intent of the declaration is
to use a constant expression, then the comma operator
cannot be used.
SESEMULTIEXITS
Message parallel directive scope <text> has multiple exits
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.
SESEMULTIPREDS
Message parallel directive scope <text> has multiple entry
paths
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.
SESEVFLOW
Message parallel directive scope <text> is crossed by a
VBRANCH
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.
SHARECONST
Message In this declaration, noshare has been ignored due to
the presence of const or readonly.
Description A variable declared with the readonly storage class
modifier, or the const type modifier cannot also have
the noshare storage class modifier. The compiler
will ignore the noshare storage class modifier.
User Action Remove either the noshare storage class modifier or
the const or readonly modifiers.
SHIFTCOUNT
Message <Context> the shift count "<number>" is negative or
is greater than or equal to the promoted size of the
operand "<expression>".
Description The compiler has detected a shift count that is
negative or is greater than or equal to the promoted
size of the operand to be shifted. This behavior is
undefined.
User Action Correct the shift count.
SHORTCIRCUIT
Message <Context> potential side effects from the evaluation
of "<operand>" will not take place. This is because
the first operand of a logical operator is a constant
whose value requires that this expression must not be
evaluated.
Description The C language requires that if the first operand of
a logical || or && operator determines the result of
the expression, the second operand must not be
evaluated. This behavior is different from other
operators. The compiler has noticed that the second
operand will generate code that may produce side
effects that the programmer expects to take place.
This message is to inform the user that the code
generated for the second operand will not be
executed.
User Action Replace the logical expression with its first
operand.
SHOWMAPLINKAGE
Message The linkage has been mapped to: #pragma linkage_ia64
<name> = (<stuff>).
Description The pragma linkage directive contains
architecture-specific information. The Alpha
register conventions are different from the IA64
register conventions. The compiler will try to map
the Alpha registers to the corresponding registers on
IA64. This message details the mapping.
User Action Replace the linkage directive with the linkage_ia64
directive that appears in the message.
SIGNEDKNOWN
Message <Context> HP C recognizes the standard keyword
"signed". This differs from the VAX C behavior.
Description VAX C does not recognize the "signed" keyword. 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.
SIGNEDMEMBER
Message <Context> HP C recognizes the standard C keyword
"signed" in member declarations. The VAX C compiler
does not and would treat the member as unsigned.
Description VAX C does not recognize the "signed" keyword in a
member declaration. VAX C will treat the member as
an unsigned type. HP C will recognize the keyword
and declare the member as a signed type.
User Action Be aware of this difference if you plan to compile
the source with VAX C.
SIMPLEMESSAGE
Message <user text>
Description The compiler has encountered a #pragma message
(<quoted string>)directive. It will output the
message in the quoted string.
User Action Remove the pragma message.
SIZEBIT
Message <Context> "<expression>" is a bitfield, and so has no
size.
Description A bitfield expression cannot be used as the argument
to the sizeof operator or the __builtin_alignof
builtin.
User Action Pass an expression with a valid type to the operator
or builtin.
SIZEINCOMP
Message <Context> "<expression>" is of an incomplete type,
and so has no size.
Description An expression that has incomplete type has no size
and therefore cannot be used as the argument to the
sizeof operator.
User Action Pass an expression with a valid type to the sizeof
operator.
SIZEINCOMPTYP
Message <Context> "<type>" is an incomplete type, and so has
no size.
Description A incomplete type has no size and therefore cannot be
used as the argument to the sizeof operator.
User Action Pass a valid type to the sizeof operator.
SIZFUNVOIDTYP
Message <Context> "<type>" has function or void type and may
not appear in this context. The compiler will treat
the type as if it were char.
Description A function or void type cannot be used as the
argument of the sizeof operator or the
__builtin_alignof builtin. For compatibility with
some other compilers, an output file is still
created. The result produced will be the same as if
a char type was passed. This may or may not be
compatible with other compilers that accept this
syntax.
User Action Pass a valid type to the operator or builtin.
STACKPOP
Message This "restore" has underflowed the pragma <stack
name> stack. No corresponding "save" was found.
Description One of the pointer-size stacks, managed by the
#pragma pointer_size, #pragma require_pointer_size,
#pragma required_vptr_size, 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.
STATICIFLOAT
Message <Context> conversion of a link-time address constant
to a floating type is required. This is not allowed.
Description The initialization of an object with static extent
requires a value that is a link-time constant
expresion. Link-time constant expressions cannot
involve values of floating types (other than floating
constants that are the immediate operands of casts).
User Action Remove the floating point types from the
initialization.
STATICVLA
Message <Context> the static object "<name>" cannot be a
variable length array.
Description Only ordinary identifiers with block scope and
without storage class extern or static, or ordinary
identifiers with function prototype scope can be
declared as variable-length arrays.
User Action Correct the declaration.
STATINITWARN
Message <Context> the linker will be unable to perform this
static initialization if the initializer is defined
in a sharable image.
Description A static initialization will require that a link-time
constant be truncated. If the constant is resolved
in a sharable image, the linker will issue a
diagnostic and be unable to perform the
initialization. This message is output on OpenVMS
systems only.
User Action Rewrite the static initialization so that the
link-time constant will not be truncated.
STDARG
Message <Context> stdarg.h macros might be required if the
address of the parameter <name> is used to index
through a parameter list.
Description Some older C programs will traverse a function's
parameter list by taking the address of one of the
parameters and then adjusting it to get to subsequent
parameters. In most cases, this technique will not
produce the desired results on Alpha. This message
is specific to UNIX, and is only output if -varargs
option is specified.
User Action If the address is used to walk the parameter list,
recode the function to use the standard stdarg.h
macros.
STKALLEXC
Message Allocations to stack exceeded maximum stack size
Description A routine uses more stack space than is available on
this platform. This is most often caused by
declaring too many large automatic variables.
User Action Reduce the size required by the automatic variables.
STOALNERR
Message Psect <text> alignment is insufficient for allocation
of <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.
STONOTFIRST
Message The placement of a storage-class specifier other than
at the beginning of the declaration specifiers in a
declaration is an obsolescent feature.
Description The standard states that this style of declaration is
obsolescent.
User Action Place the storage-class specifier first in the
declaration.
STORCLSDCL
Message <Context> a storage class without a declarator is
meaningless.
Description This message is generated when the compiler
encounters certain declarations that contain a
storage class but no declarator. For example:
extern struct S { int a;};
User Action Either remove the storage class or add a declarator
to the declaration.
STOREBIF
Message Built-in function <store-bif> is not available on
this platform. It may be converted to <swap-bif> if
the source and dest parameters are identical.
Description The STORE version of this built-in function is not
available on the IA64 platform.
User Action Use the SWAP version of this built-in function.
STOREQEXC
Message Allocations to <text> section exceeded growth bounds
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.
STORISSTAT
Message This redeclaration of the static initialized variable
"<name>" will have static storage class that differs
from the VAX C behavior. The previous declaration is
at <location>.
Description In VAX C mode, if a variable is first declared static
and then declared extern, the variable will be given
extern storage class. This matches the VAX C
behavior. If, however, the static variable is
initialized, the storage class will remain static.
User Action Be aware of this difference.
STORMODDCL
Message <Context> a storage class modifier without a
declarator is meaningless.
Description This message is generated when the compiler
encounters certain declarations that contain a
storage class modifier but no declarator. For
example: readonly struct S { int a;};
User Action Either remove the storage class modifier or add a
declarator to the declaration.
STRCTPADDING
Message An additional <number> bytes of padding have been
implicitly inserted prior to this member for proper
alignment of this member.
Description The compiler has added pad bytes before a member so
that it will be accessed efficiently. This might not
have been what you intended.
User Action Consider rearranging the order of member
declarations.
STRINGCONST
Message Ill-formed string constant.
Description An invalid string constant was encountered.
User Action Correct the string constant.
STRUCTBRACE
Message <Context> a required set of braces is missing.
Description The initializer for this struct was not enclosed in
braces. While some compilers allow this, standard C
requires braces around the initializer.
User Action Enclose the initializer in braces.
STRUCTLIMITSUP
Message <Context> HP C provides only limited support for
struct/union types larger than <n> bytes.
Description This struct/union 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 type.
STRUCTOVERFLOW
Message Integer overflow occurred when computing the size of
a struct or union type.
Description An struct or union type is larger than allowed on
this platform. Note that as the compiler computes
the size of the type in bits, the limit on the size
of struct/union types is eight times smaller than the
size of other types.
User Action Reduce the size of the struct/union type.
SUBINVALIDCHR
Message Parameter substitution produced an invalid character
constant.
Description In certain modes, the compiler will replace
identifiers found within a character constant if they
match a macro argument name. This form of "old-style
stringization" is provided for compatibility with
older C compilers. This message is output if this
replacement forms an invalid character constant.
User Action Modify the macro argument so that a valid character
constant is formed.
SUBINVALIDSTR
Message Parameter substitution produced an invalid string
literal.
Description In certain modes, the compiler will replace
identifiers found within a string literal if they
match a macro argument name. This form of "old-style
stringization" is provided for compatibility with
older C compilers. This message is output if this
replacement forms an invalid string literal.
User Action Modify the macro argument so that a valid string is
formed. HP also recommends that the macro body be
rewritten to use the standard C stringize operator
(#).
SUBSCRBOUNDS
Message <Context> an array is being accessed outside the
bounds specified for the array type.
Description The compiler has detected an array access that is
outside the bounds of the array. The array access
might cause unpredictable behavior. Note that in C,
an array is declared using the number of elements,
but the first element has subscript 0. It is a
common coding error to attempt to access the last
element of an array of "n" elements using a subscript
of "n" instead of "n - 1". However, there are two
common practices that intentionally employ
out-of-bounds subscripts to useful/correct effects
that are not reported by this message, but have
separate optional messages. First, taking the
address of an array element that is exactly one
beyond the last element of an array is completely
valid in standard C as long as the address is not
used to access memory. The optional subscrbounds2
message can be enabled to report taking the address
of the array element exactly one beyond the last
element. Second, it is a somewhat common practice to
declare the last member of a struct as an array with
one element, and then allocate such structs at
runtime with different sizes, recording the actual
size in an earlier member of the struct. The
optional subscrbounds1 message can be enabled to
report subscripts greater than zero applied to arrays
declared with only one element.
User Action Specify an array subscript that is within the bounds
of the array type.
SUBSCRBOUNDS1
Message <Context> an array type declared with one element is
being accessed beyond the end of the array.
Description An array declared with one element is being accessed
beyond the end of the array. The array access can
cause unpredictable behavior. Note that in C, an
array is declared using the number of elements, but
the first element has subscript 0. It is a common
coding error to attempt to access the last element of
an array of "n" elements using a subscript of "n"
instead of "n - 1".
User Action Specify an array subscript that is within the bounds
of the array type.
SUBSCRBOUNDS2
Message <Context> accessing the address of an array element
that is exactly one beyond the end of the array might
not be what you intended.
Description Accessing the address of an array element that is
exactly one beyond the end of the array might be a
coding error (e.g. if the address is then used to
access memory), or it might be fully correct (e.g.
to compute a pointer value to be used as the upper
bound on a loop).
User Action Specify an array addressthat is within the bounds of
the array type.
SWAPBIF
Message Built-in function <store-bif> is not available on
this platform. The compiler was able to convert it
to <swap-bif> because the source and dest parameters
are identical.
Description The STORE version of this built-in function is not
available on the IA64 platform.
User Action Use the SWAP version of this built-in function.
SWITCHLONG
Message The signed or unsigned long expression "<expression>"
is used in a switch statement.
Description A switch value has an integer type of signed or
unsigned long int. While this is perfectly portable
under the C standard, the original K&R definition of
C required that the expression have type int. HP C
accepts this usage in all modes, but there may be
older C compilers that require type int in this
context.
User Action Be aware that older, non-standard compilers might not
accept this construct, or force the result to type
int.
SYSREGUSED
Message System register specified as external register.
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.
SYSTEM
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.
TAGDIFFER
Message <Context> the tag "<name>" differs from the tag
"<name>" used in an earlier declaration of this
function.
Description This function declaration contains a parameter that
is a pointer to a struct or union type whose tag
differs from the tag of the struct or union type
referenced by a pointer type in an earlier
declaration of this function. In most modes of the
compiler, this will cause the function declarations
to be incompatible.
User Action Multiple declarations of a function should use
exactly the same parameter types.
TAGORBRACE
Message Missing tag or "{".
Description The enum, struct, and union keywords must be followed
by either an open brace or a tag.
User Action Correct the program syntax.
TENTREDEF
Message This <definition or tentative definition> of "<name>"
is redefining the <definition or tentative
definition> on <location>. This is not allowed in
C++. <compiler__declare_tent_redef1>.
Description C will allow a tentative definition to be redefined
later in the compilation unit. C++ does not have the
concept of a tentative definition. Therefore this
redefinition is invalid in C++.
User Action Either remove the previous tentative definition, or
modify it to match the later redefinition.
TEXTARRAY
Message The CDD description for <name> specifies that it is
text 1; It has been translated into an array of char.
Description When the CDD type "TEXT" is of length one, HP C will
normally convert this to type "char" in order to be
compatible with VAX C. If however, the nullterminate
or text1toarray keywords are specified in a HP C
dictionary directive, the CDD type TEXT will be
converted to type "array of char".
User Action No action is necessary as long as the type "array of
char" is the desired datatype.
TEXTARRAYN
Message The CDD description for <name> specified that it is
text 1; It has been translated into an array of char
because null_terminate was used.
Description The CDD type "TEXT" is of length 1 and has been
converted to the C type "array of char" of size 2
because the null_terminate keyword was specified on
the dictionary directive.
User Action No action is necessary as long as the type "array of
char" of size two is the desired C datatype.
TEXTCHAR
Message The CDD description for <name> specified that it is
text 1; It has been translated into a type char.
Description When the CDD type "TEXT" is of length one, HP C will
normally convert this to type "char" in order to be
compatible with VAX C. However, when the length of
the CDD type "TEXT" is greater than one, the C type
"array of char" is generated. This means that CDD
type "TEXT" will result in different C datatypes
depending upon the length of the TEXT stored in the
dictionary.
User Action No action is necessary as long as the type "char" is
the desired datatype.
TEXTMODULE
Message The text library module form of #include is an
extension.
Description On OpenVMS systems, an #include directive whose file
specifier is not enclosed in either quotation marks
or angle brackets denotes an include from a text
library. This is an extension of HP C. This
directive will not work as expected on non-VMS
systems.
User Action Be aware of this if you wish to port the program.
THREADFUNC
Message <Context> the __declspec(thread) storage class
modifier cannot be used with a function type.
Modifier is ignored.
Description Only objects can be declared with thread-local
storage. The storage class modifier is ignored when
applied to an identifier with function type.
User Action Either remove the storage class modifier or change
the type to one that is valid for __declspec(thread).
THREADNYI
Message <Context> the __declspec(thread) storage class
modifier is not implemented on this platform. It
will be ignored except to verify correct compile-time
usage.
Description Thread-local storage is only supported on UNIX
platforms. The compiler will ignore the storage
class modifier except to verify that it is correctly
used.
User Action Remove the __declspec(thread) storage class modifier
or compile the program on a platform that supports
the modifier.
THREADSTO1
Message <Context> the __declspec(thread) storage class
modifier requires a storage class of extern, static,
or none. Modifier is ignored.
Description Declaring a file-scope object with thread-local
storage requires that the object have a storage class
of extern, static or none. In other cases, the
compiler will ignore the __declspec(thread) storage
class modifier.
User Action Either remove the storage class modifier or change
the storage class to one that is valid for
__declspec(thread).
THREADSTO2
Message <Context> the __declspec(thread) storage class
modifier requires a storage class of extern, or
static. Modifier is ignored.
Description Declaring a local object with thread-local storage
requires that the object have a storage class of
extern, or static. In other cases, the compiler will
ignore the __declspec(thread) storage class modifier.
User Action Either remove the storage class modifier or change
the storage class to one that is valid for
__declspec(thread).
TLSANDSTATIC
Message <Context> the storage class modifier
__declspec(thread) cannot be used with the -static
option. The storage class modifier is ignored.
Description Thread-local storage cannot be declared in
compilations that are performed with the -static
option. The compiler will ignore the
__declspec(thread) storage class modifier.
User Action Either remove the __declspec(thread) storage class
modifier or do not compile with the -static option.
TOOFEWACTUALS
Message Too few actual parameters in the invocation of the
macro "<name>".
Description A macro invocation supplied fewer actual arguments
than the macro expects. The macro arguments not
specified in the call will be given a null value.
User Action Supply all arguments in the macro invocation.
TOOFEWARGS
Message <Context> "<function expression>" expects <correct
number> arguments, but <actual number> are supplied.
Description A function has been invoked with fewer arguments than
it expects. In some modes this is a warning message,
and the compiler will compile the program. In this
case, the function being called might not produce the
expected results.
User Action Make sure the number of arguments passed to a
function match those specified in the function
declaration.
TOOFEWARGSO
Message <Context> "<function expression>", which was declared
with an old-style function definition, expects
<correct number> arguments, but <actual number> are
supplied.
Description A function that was declared with an old-style
function definition has been invoked with fewer
arguments than it expects. While this is valid C, it
might not have been what you intended.
User Action Make sure the number of arguments passed to a
function match those specified in the function
declaration. If the function is to be called with a
variable number of arguments, it should use the
facilities of <varargs.h> for old-style definitions.
HP generally recommends that old-style function
definitions be replaced by prototype-format
definitions, in which case variable argument lists
are specified using the ... notation and the
definition uses the facilities of <stdarg.h>.
TOOLONG
Message <Context> , "<expression>" is too long by <count>
character(s).
Description A string initializer for a char array contains more
characters than the array can hold. This is not
valid.
User Action Reduce the number of characters to be less than or
equal to the number of elements in the char array.
TOOMANY
Message <Context> , there are <actual number> elements, which
is <extra number> too many. The extra initializers
will be ignored.
Description An initializer list contains more initializers than
there are objects to be initialized. This is not
valid.
User Action Reduce the number of initializers to be less than or
equal to the number of objects being initialized.
TOOMANYACTLS
Message Too many actual parameters in the invocation of the
macro "<name>".
Description A macro invocation supplied more actual arguments
than the macro expects. The additional arguments
will be ignored.
User Action Remove the extra arguments from the macro invocation.
TOOMANYARGS
Message <Context> "<function expression>" expects <correct
number> arguments, but <actual number> are supplied.
Description A function has been invoked with more arguments than
it expects. In some modes this is a warning message,
and the compiler will compile the program.
User Action Make sure the number of arguments passed to a
function match those specified in the function
declaration.
TOOMANYARGSO
Message <Context> "<function expression>", which was declared
with an old-style function definition, expects
<correct number> arguments, but <actual number> are
supplied.
Description A function that was declared with an old-style
function definition has been invoked with more
arguments than it expects. While this is valid C, it
might not have been what you intended.
User Action Make sure the number of arguments passed to a
function match those specified in the function
declaration. If the function is to be called with a
variable number of arguments, it should use the
facilities of <varargs.h> for old-style definitions.
HP generally recommends that old-style function
definitions be replaced by prototype-format
definitions, in which case variable argument lists
are specified using the ... notation and the
definition uses the facilities of <stdarg.h>.
TOOMANYERR
Message More than <number> errors were encountered in the
course of compilation.
Description After emitting a certain number of errors, the
compiler will stop the compilation and issue this
message. The number of errors output before the
compilation stops can be changed using the
/ERROR_LIMIT qualifier on OpenVMS systems, or the
-error_limit option on UNIX systems.
User Action Either reduce the number of errors generated by the
program or give a larger value for the error limit.
TOOMANYGATES
Message only 64 gates maybe be used within a parallel region
Description For each parallel region there is a limit of 64
different gates that can be specified in a #pragma
enter gate/#pragma exit gate pair.
User Action Reduce the number of gates
TOOMANYTOKENS
Message Too many tokens in macro expansion.
Description An argument to the #line preprocessing directive
contained a macro whose expansion generated more
tokens than the #line directive expects.
User Action Either modify the macro definition or change the
arguments to the #line directive.
TOOMANYTXTLIB
Message Too many text libraries. Library <library name> and
subsequent will not be searched.
Description The compiler has tried to open more text libraries
than it can support in its internal data structures.
The specified library, and all subsequent libraries
will not be opened.
User Action Reduce the number of text libraries the compilation
requires.
TOOMNYREL
Message Object file section <text> has <number> relocations;
maximum allowed is <number>
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.
TRAILCOMMA
Message Trailing comma found in enumerator list.
Description Accepting an enumerator list that contains a trailing
comma is an extension of HP C provided for
compatibility with other C compilers. An enumerator
list with a trailing comma is not valid in C89, nor
in C++. The C99 standard does permit this syntax.
User Action Remove the trailing comma.
TRUNCFLTASN
Message <Context> "<expression>" has more precision than
"<target type>". Assignment might result in loss of
precision and/or range.
Description The destination of a floating-point assignment has
less range and/or precision than the expression being
assigned to the destination. Because of this, the
assignment might cause a loss of range and/or
precision.
User Action Verify that no unexpected data can be lost by the
assignment. If not, cast the expression to the type
of the destination.
TRUNCFLTINT
Message <Context> "<expression>" is a floating-point type
being assigned to an integer type. The assignment
might result in data loss.
Description A floating-point expression is being assigned to an
integer type. This assignment might cause a loss of
range and/or precision.
User Action Verify that no unexpected data can be lost by the
assignment. If not, cast the expression to the type
of the destination.
TRUNCINTASN
Message <Context> "<expression>" has a larger data size than
"<target type>". Assignment might result in data
loss.
Description The destination of an integer or pointer assignment
is smaller than the expression being assigned to the
destination. Because of this, the assignment might
cause data to be lost.
User Action Verify that no unexpected data can be lost by the
assignment.
TRUNCINTCAST
Message <Context> "<expression>" has a larger data size than
"<target type>". Cast might result in data loss.
Description An integer or pointer expression is being cast to a
size that is smaller than the expression. Because of
this, the cast might cause data to be lost.
User Action Verify that no unexpected data can be lost by the
cast.
TRUNCLONGCAST
Message <Context> "<expression>", a 64-bit integer, is being
cast to a 32-bit integer. The cast might result in
data loss.
Description On many platforms long integers are the same size as
integers. On this platform long integers are
64-bits. This cast could indicate a potential
porting problem.
User Action Verify that no unexpected data can be lost by the
cast.
TRUNCLONGINT
Message <Context> "<expression>", a 64-bit integer, is being
assigned to a 32-bit integer. Assignment might
result in data loss.
Description On many platforms long integers are the same size as
integers. On this platform long integers are
64-bits. This assignment could indicate a potential
porting problem.
User Action Verify that no unexpected data can be lost by the
assignment.
TUNEOVERRIDE
Message tune setting <text> overridden by arch setting
<text>, tune forced to <text>
Description The program has specified a tune architecture that is
older than the arch setting. The arch setting is the
oldest architecture that the code should ever run on.
Asking the compiler to tune for an even older
architecture is not reasonable. The compiler will
use the arch setting for the tune option as well
User Action Specify a tune architecture that is at least as new
as the arch architecture.
TYPEALIGN
Message <Context> _align cannot be used with the typedef
storage class. Modifier _align is ignored.
Description The storage class modifier _align is meaningless for
typedefs. The compiler ignores the _align.
User Action Remove the _align storage class modifier.
TYPECONFLICT
Message <Context> "<typespec1>" cannot be combined with
"<typespec2>".
Description Two type keywords used in the same type specifier
cannot be combined. In some modes, the compiler will
use the most recent keyword as the type specifier.
User Action Correct the type specifier.
TYPEDEFFUNC
Message In this function definition, "<name>" acquires its
type from a typedef.
Description A function definition acquires its type from a
typedef. This is not allowed.
User Action Correct the function definition.
TYPEDEFINIT
Message The declaration of the typedef "<name>" contains an
initializer. The initializer is ignored.
Description A typedef declaration must not contain an
initializer.
User Action Remove the initializer from the declaration.
TYPEDEFNA
Message Accepting an old-style parameter name that matches a
typedef is a language extension.
Description The HP C compiler will allow old-style parameters to
have the same name as a typedef. Many other
compilers will not allow this.
User Action Recode the function definition to use the standard C
prototype syntax.
TYPEDEFNOTDEF
Message In this declaration, "<name>" appears to be used as
if it named a type, but there is no declared type of
that name visible.
Description The compiler has encountered what appears to be a
typedef declaration that provides a new name for an
existing type, but the identifier used to specify the
existing type is not the name of a type that is
visible.
User Action Declare the identifier for the first type, or correct
its spelling.
TYPEEXPR
Message <Context> "<name>" is declared as <a label, tag, or
typedef>, and so cannot occur as an expression.
Description An identifier declared as a typedef has been used in
an expression when an object or function was
required.
User Action Correct the expression.
TYPEOFEXT
Message The use of __typeof__ is a language extension.
Description Support for __typeof__ is a language extension
provided for compatibilty with some other C
compilers. Although some other C compilers will
accept this syntax, many compilers will reject it.
User Action Be aware of this difference if you plan to port this
source to another compiler.
TYPQUALNOT
Message A type qualifier is not allowed in this context.
Description In Microsoft mode, the compiler used to accept a type
qualifier after a comma used to separate declarators.
This was refered to as a local type qualifier. This
message is output when a local type qualifier is
applied to a declarator that can not be qualified.
User Action Remove the local type qualifier because this is no
longer accepted.
TYPQUALNOT2
Message Use of the keyword "static" or a type qualifier
within the outermost array-bounds specifier of a
formal parameter declaration is a new feature in the
C99 standard.
Description The C99 construct may not be available in other
compilers you use to build your application, in which
case they will likely report it as a syntax error.
User Action You may want to conditionalize your code with the
preprocessor so that you can take advantage of the
feature on platforms that support it, without getting
syntax errors from older compilers or language modes
that do not support it.
TYPQUALNOT3
Message Use of the keyword "static" or a type qualifier in an
array-bounds specifier is invalid in this compilation
mode. Keyword/qualifier ignored.
Description Use of the keyword "static" or a type qualifier
within the outermost array bound specifier of a
formal parameter is a new feature in the C99 standard
and is not supported in this language mode.
User Action Either compile in a mode that supports C99 features,
or remove the construct from your code.
TYPQUALNOT4
Message Use of this type qualifier in an array-bounds
specifier is invalid. Qualifier ignored.
Description Use of this type qualifier is not a permitted in the
array bound specifier of a formal parameter.
User Action Remove the keyword.
UABORT
Message Compilation terminated by user.
Description This message is often output when the compilation was
aborted by the user by hitting Control C.
User Action Do not abort the compilation.
UCNICONVOPN
Message The call iconv_open(<CODESET>, "UCS-4") failed
because: <STRERROR>. UCNs will not be mapped to the
native character set.
Description To translate Universal Character Name escape
sequences to the codeset of the current locale, the
compiler needs to call the iconv_open library routine
with the specified parameters. This call failed, for
the reason shown. Thus no UCN escape sequences in
this program can be translated.
User Action Make sure your system has the specified codeset
converter installed, or set your locale to use a
codeset for which a converter from UCS-4 is
available. Alternatively, change your code to avoid
the use of UCNs, e.g. using hexadecimal escape
sequences.
UCNNOMAP
Message A UCN escape sequence was recognized, but there was
no translation for it into the current codeset. The
escape sequence will be used verbatim.
Description A Universal Character Name (UCN) escape sequence was
recognized, but there was no translation for it into
the current codeset using the iconv library routine.
The complete escape sequence itself, including the
backslash, will be used in the object module.
User Action Make sure your locale is set at compile-time to use a
codeset for which a converter from UCS-4 is
available, and which supports all of the characters
that are expressed as UCNs in your program.
Alternatively, change your code to avoid the use of
UCNs, e.g. using hexadecimal escape sequences.
UCNUNSUPP
Message An apparent UCN escape sequence was encountered, but
UCNs are not supported in this language mode. The
backslash will be ignored.
Description Universal Character Name (UCN) escape sequences were
added to C in the C99 standard. The language mode of
the current compilation does not process UCNs, so
they will be treated as unrecognized escape
sequences, which ignore the backslash.
User Action Compile in a mode that processes UCNs (C99, or the
default "relaxed" mode), or remove the backslash.
Relying on apparent escape sequences to be
unrecognized is not good practice.
UCNUSED
Message A UCN escape sequence was encountered.
Description Universal Character Name (UCN) escape sequences were
added to C in the C99 standard, and are processed in
this language mode. C compilers and dialects that do
not specifically process UCNs will treat them as
unrecognized escape sequences, and may silently
ignore the backslash.
User Action Be aware of this if you wish to port the program.
UNALIGNEDFUNC
Message Ignoring __unaligned type qualifier in declaration of
<name>.
Description The __unaligned type qualifier has no meaning for
function types. It is being ignored.
User Action Remove the type qualifier.
UNALIGNEXT
Message The __unaligned type qualifier is a language
extension.
Description The use of the __unaligned type qualifier might not
be portable to other C compilers.
User Action Be aware of this portability concern.
UNAVAILPRAGMA
Message The pragma "<pragma name>" is not available on this
platform.
Description The compiler has encountered a pragma that is not
currently supported on this platform. The compiler
will ignore the pragma.
User Action Compile the program on a platform that does support
the pragma. Otherwise, understand that this pragma
will have no effect.
UNAVOLACC
Message volatile access appears unaligned, but must be
aligned at run-time to ensure atomicity and byte
granularity
Description The compiler has detected an unaligned access to a
volatile variable. In order to meet atomicity and
granularity requirements of volatile, the access will
be done using an aligned instruction. This may cause
an alignment fault at runtime if the access is
unaligned.
User Action Make sure volatile objects are aligned on a natural
boundary.
UNCALLED
Message routine <text> can never be called
Description The compiler has detected a static function that is
never referenced.
User Action Remove the unused function.
UNDECLARED
Message <Context> "<name>" is not declared.
Description An identifier used in an expression has not been
declared. The only time an identifier can be used
and not previously declared is when the identifier
specifies the function name in a function call.
User Action Either declare the identifier or remove its use.
UNDECLFUN
Message There is no function declaration for the identifier
"<name>" at the point of this #pragma <pragma type>
<attributes>.
Description An identifier specified in a #pragma assert/hint
func_attrs directive must refer to a function
declaration at the point of the pragma.
User Action Either remove the identifer from the pragma, correct
its spelling, or reorder the source to ensure that a
declaration of the identifier as a function is
visible at the point of the pragma. Identifier must
be a function declaration; no other kind of
declaration (i.e. typedef, var, etc.) is allowed for
func_attrs.
UNDECLVAR
Message There is no global declaration visible for the
variable "<name>" at the point of this #pragma assert
global_status_variable.
Description An identifier specified in a #pragma assert directive
must refer to a global variable declaration visible
at the point of the pragma. The identifier will be
ignored.
User Action Either remove the identifer from the pragma, correct
its spelling, or reorder the source to ensure that a
declaration of the identifier as a global_variable is
visible at the point of the pragma.
UNDEFENUM
Message <Context> the enum "<name>" is not defined.
Description The enum tag used to declare an enum variable is not
defined at this point in the compilation.
User Action Define the enum tag before using it.
UNDEFESCAP
Message An undefined escape sequence was encountered; the
backslash is being ignored.
Description The character or characters following a backslash do
not form a valid escape sequence. The compiler will
ignore the backslash.
User Action Correct the escape sequence.
UNDEFINEDTYPE
Message The compiler was expecting a "<token>", but one was
not found. This condition could have occured because
"<id>" is used in what might be a type cast, but
there is no declared type of that name visible.
Description The compiler has discoverd a syntax error. This
error may have been caused because a cast operator
used an unknown type.
User Action Correct the syntax error.
UNDEFVARFETCH
Message <Context> the expression "<expr>" modifies "<var>",
and fetches its value in a computation that is not
used to produce the modified value without an
intervening sequence point. This behavior is
undefined.
Description The compiler has detected a case where the same
variable has been modified and fetched in a
computation that does not later modify that same
variable. Because the order of the variable fetch
and store is not defined, this expression might
produce different results on different platforms.
User Action Rewrite the expression so that if a variable is
stored to, it is fetched only to determine the value
to be stored.
UNDEFVARMOD
Message <Context> the expression "<expr>" modifies the
variable "<var>" more than once without an
intervening sequence point. This behavior is
undefined.
Description The compiler has detected a case where the same
variable has been modified more than once in an
expression without a sequence point between the
modifications. Because what modification will occur
last is not defined, this expression might produce
different results on different platforms.
User Action Rewrite the expression so that each variable is
modified only once.
UNDERFLOW
Message <Context> underflow occurs in evaluating the
expression "<expression>".
Description A floating-point underflow occurred while evaluating
a constant expression. The value of the expression
is undefined.
User Action Correct the floating-point constant expression.
UNINIT1
Message The scalar variable "<var>"<declared in> is fetched
but not initialized<inlineinfo>. And there may be
other such fetches of this variable that have not
been reported in this compilation.
Description A variable's value has been used without being set.
This might not have been what you intended. The
algorithms that detect this situation only report it
once for a given variable, and not necessarily at the
first use of the uninitialized value.
User Action Provide the variable with a value before the variable
is used. If you only provide a value for the use
reported here, you may find that when you recompile
your program another uninitialized use is detected.
It is best to initialize variables as close as
possible to the point of declaration.
UNINIT2
Message Part or all of the non-scalar variable
"<var>"<declared in> is fetched but not
initialized<inlineinfo>. And there may be other such
fetches of this variable that have not been reported
in this compilation.
Description A non-scalar variable has had its value used and some
or all of the variable has not been given a value.
This might not have been what you intended. The
algorithms that detect this situation only report it
once for a given variable, and not necessarily at the
first use of the uninitialized value.
User Action Provide the variable with a value before the variable
is used. If you only provide a value for the use
reported here, you may find that when you recompile
your program another uninitialized use is detected.
It is best to initialize variables as close as
possible to the point of declaration.
UNINIT3
Message Variable "<var>"<declared in> is fetched but not
initialized<inlineinfo>. And there may be other such
fetches of this field that have not been reported in
this compilation.
Description The specified member of a struct variable has been
used without being set. This might not have been
what you intended. The algorithms that detect this
situation only report it once for a given field, and
not necessarily at the first use of the uninitialized
value.
User Action Provide the struct member with a value before the
variable is used. If you only provide a value for
the use reported here, you may find that when you
recompile your program another uninitialized use is
detected. It is best to initialize variables as
close as possible to the point of declaration.
UNINIT4
Message Byte offsets <start> to <end> of "<var>"<declared in>
are fetched but not initialized<inlineinfo>. And
there may be other such fetches of this field that
have not been reported in this compilation.
Description The specified byte offsets of a variable have been
used without being set. This might not have been
what you intended. The algorithms that detect this
situation only report it once for a given field, and
not necessarily at the first use of the uninitialized
value.
User Action Provide the full variable with values before the
variable is used. If you only provide a value for
the use reported here, you may find that when you
recompile your program another uninitialized use is
detected. It is best to initialize variables as
close as possible to the point of declaration.
UNINIT5
Message <fragment uninit5a><inlineinfo>. Also the variable
itself is not initialized. And there may be other
fetches of this variable that have not been reported
in this compilation.
Description The specified storage location has been used without
being set. This might not have been what you
intended. In addition, as this fetch is outside the
storage allocated to the variable, the behavior is
undefined.
User Action First verify that the fetch is correct(code that uses
the address of a declared object to access memory
outside the address range allocated to that object is
not likely to be reliable). Then initialize the
storage being fetched and, if necessary, the variable
noted in the message. If you only provide a value
for the use reported here, you may find that when you
recompile your program another uninitialized use is
detected, since the algorithms that detect this
situation only report it once for a given variable,
and not necessarily at the first use of the
uninitialized value. It is best to initialize
variables as close as possible to the point of
declaration.
UNIONBRACE
Message <Context> a required set of braces is missing.
Description The initializer for this union was not enclosed in
braces. While some compilers allow this, standard C
requires braces around the initializer.
User Action Enclose the initializer in braces.
UNKEXTMOD
Message Unknown extern model. Pragma is ignored.
Description The compiler was unable to parse a #pragma
extern_model directive. The extern_model must be an
identifier that specifies one of the valid extern
models. The directive will be ignored.
User Action Correct the directive.
UNKINTRIN
Message The function "<routine name>" is not a known
intrinsic function and cannot be used with #pragma
intrinsic. Pragma not applied to this function.
Description A function identifier specified in a #pragma
intrinsic directive is not a valid intrinsic function
on this platform. The pragma will not be applied to
this identifier, leaving it to be treated as an
ordinary function.
User Action Either correct the function name to specify an
intrinsic supported for this platform, or remove it
from the pragma.
UNKMSGCMD
Message Bad or missing command in pragma message. Pragma is
ignored.
Description The #pragma message directive must be followed by an
identifier that specifies message-related action for
the compiler to perform. Either something other than
an identifier was found, or the identifier did not
specify one of the valid actions. The compiler will
ignore the pragma.
User Action Specify a valid action for #pragma message.
UNKMSGID
Message Unknown message id or group "<id>" is ignored.
Description A message identifier in a #pragma message directive
did not specify a valid message id or message group.
The identifier will be ignored.
User Action Update the identifier so that it specifies a valid
message id or message group.
UNKNOWNLINK
Message The specified linkage is undefined. Pragma is
ignored.
Description The linkage specified in a #pragma use_linkage
directive has not been defined by an earlier #pragma
linkage directive. The compiler will ignore the
entire pragma.
User Action Either define the linkage first or change the linkage
name.
UNKNOWNMACRO
Message "<name>" is not currently defined as a macro. It has
been replaced by the constant zero.
Description An identifier found in an #if or #elif is not
defined. This might not have been what you intended.
The compiler will replace the identifier with the
constant zero.
User Action Verify the use of the identifier.
UNKNOWNPRAGMA
Message The pragma "<pragma text>" is unrecognized.
Description A pragma that has no meaning to HP C was encountered.
The pragma will be ignored.
User Action Make sure that you did not misspell the pragma.
Also, make certain you are running the correct
version of HP C. If the spelling and compiler
version are correct, understand that this pragma will
have no effect.
UNKNOWNPRGMA
Message Unrecognized #pragma directive.
Description This #pragma preprocessing directive is not
recognized by HP C. The directive will be ignored.
User Action Make sure that this is the intended behavior.
UNKPSECTATTR
Message Unknown psect attribute for extern model. Attribute
is ignored.
Description A psect attribute specified in a #pragma extern_model
is invalid. In general, the psect attributes
accepted by HP C match those accepted by the
assembler. The psect attribute will be ignored.
User Action Correct the psect attribute.
UNMATCHENDIF
Message Out of place #endif directive ignored.
Description An #endif preprocessing directive was encountered
without a previous #if directive. The directive will
be ignored.
User Action Remove the directive.
UNNAMEDMEM
Message An unnamed member does not have a bitfield, struct,
or union type. Member is ignored.
Description An unnamed member of a struct or union type has no
meaning unless it is a bitfield or a struct/union
type. The compiler will ignore this member.
User Action If the member is desired, give it a name. Otherwise
remove the unnamed member.
UNNAMEPARM
Message In the definition of the function <name>, a parameter
has no name.
Description This function declaration contained a parameter type
but no parameter name.
User Action Provide a name for the formal parameter.
UNNECCDD
Message It is not necessary to include this dictionary
directive, if other unused dictionary directives and
unused include directives are removed.
Description There is some reference to this file from an unused
include file or from an unused dictionary directive
when using the current set of compilation options.
If you remove the unused include files and unused
dictionary directives, this dictionary directive
could also be eliminated when compiling with the
current set of compilation options.
User Action When compiling with the current set of compilation
options, to increase compilation efficiency you may
exclude this dictionary directive if you also remove
other unused files.
UNNECINCL
Message It is not necessary to include this file, if other
unused include directives are removed.
Description There is some reference to this file from another
include file or dictionary directive that is not used
when using the current set of compilation options.
If you remove the unused include files and unused
dictionary directives, this include file could also
be eliminated when compiling with the current set of
compilation options.
User Action When compiling with the current set of compilation
options, to increase compilation efficiency you may
exclude this include file if you also remove other
unused files.
UNREACHCODE
Message Code at or just after this location can never be
executed<inline info>.
Description The compiler has detected code that can never be
executed. Often unreachable code represents a real
coding error such as a label that is incorrectly
spelled, or a statement that was inserted on the
wrong line. But sometimes it occurs in good code as
a result of logical expressions that depend only on
the values of constants (typically through macro
expansion).
User Action Usually any code correction is obvious. And often it
is straightforward to rewrite compile-time logical
expressions in terms of preprocessing constructs to
avoid this diagnostic. But in some programs it may
be necessary to suppress this informational message
explicitly in order to obtain a diagnostic-free
compilation of production code, since rewriting the
expression not to be evaluated at compile time would
impact performance.
UNREFADECL
Message This local identifier is declared but not referenced
in this module.
Description A declaration was found for an identifier which is
not referenced in this module
User Action Examine your code to determine if this declaration is
needed in this module.
UNREFDECL
Message This identifier is declared but not defined or
referenced in this module.
Description A declaration was found for an identifier which is
not defined or referenced in this module
User Action Examine your code to determine if this declaration is
needed in this module.
UNREFLABEL
Message The user label "<label>" is never referenced.
Description This user label has been defined, but there are no
references to it.
User Action Remove the label.
UNREFSDECL
Message A static variable is declared but never referenced in
this module.
Description This identifier is defined but never referenced when
using the current set of compilation options.
User Action Examine your code to determine if this definition is
needed in this module.
UNREFSFUNC
Message A static function definition or prototype is found,
but never referenced.
Description A static function declaration was found in this
module, but is unused when compiling with the current
settings.
User Action Examine your code to determine if this function is
needed in this module.
UNREFTYP
Message This type is never referenced in this module.
Description A type is declared but never referenced when using
the current set of compilation options.
User Action Examine your code to determine if this declaration is
needed in this module.
UNRLINKATTR
Message Unrecognized attribute for linkage pragma. Pragma is
ignored.
Description The compiler encountered an attribute in a #pragma
linkage directive that it did not recognize. The
message should point to the offending attribute. The
compiler will ignore the entire pragma.
User Action Correct the directive.
UNSIGNEDPRES
Message <Context> the conversion of the unsigned char/short
value "<expression>" to unsigned int shows one
example of this program's use of unsigned-preserving
integral promotion. This differs from the
value-preserving semantics of standard C compilers.
Description This expression shows one of possibly many places
where this compilation uses unsigned-preserving
semantics for small integer promotions rather than
value-preserving semantics required of standard C
compilers. In cases where an unsigned char or
unsigned short int is promoted to an integer, there
are two different ways the convert could happen.
Standard C requires that the type be converted to a
signed int (value-preserving semantics) while some
older compilers will convert to an unsigned int
(unsigned-preserving semantics). The difference in
the choice of int or unsigned int can have an impact
on results of expressions that use the converted
value. The compiler cannot determine whether or not
a particular instance of this usage will cause an
observable behavior difference in the program. For
more information, consult Section 3.2.1.1 of the
Rationale for ANSI C.
User Action Be aware that standard compilers might interpret this
expression differently.
UNSTRUCTMEM
Message The declaration of a member that is an unnamed struct
or union type is an extension and might not be
portable.
Description HP C allows a member of a struct or union to be an
unnamed struct or union type. This is an extension
of HP C that other compilers might not support. In
addition this behavior does not conform to the C
standard.
User Action If portability is desired, provide a name for the
struct/union member.
UNSUPCONV
Message Hexadecimal floating point constants are not yet
implemented.
Description Hexadecimal floating point constants are a new C99
feature that is not yet supported on this platform.
User Action Please use traditional syntax for floating point
numbers.
UNSUPCONVSPEC
Message <Context> this argument to <function name> has a
conversion specification "<incorrect conversion>"
that is not supported or not fully supported on this
platform.
Description The compiler has detected a conversion specification
that will not work as specified on this platform.
User Action Review the documentation for this function and modify
the conversion specification as necessary to
accomplish your objective.
UNSUPCONVV
Message Hexadecimal floating point constants are not
supported on this platform.
Description Hexadecimal floating point constants are a new
feature in C99 that is not being implemented on the
VAX platform.
User Action Please use traditional syntax for floating point
numbers.
UNSUPIEEE
Message The _FASTMATH version of this function has been
specified, but _FASTMATH routines do not support the
IEEE behaviors requested and will simply trap and
terminate when given arguments or computing values
outside the normal range.
Description The compiler has recognized a math intrinsic function
that has a _FASTMATH version and the compilation has
defined the macro _FASTMATH, but command line options
have also specified IEEE trapping behaviors other
than the default of flushing underflow to zero and
aborting on all others.
User Action If the body of your code relies on IEEE denormals,
infinities, or nans, but is careful to condition the
arguments to math library functions to avoid passing
or computing these values, you may ignore or suppress
this warning. Otherwise, you should either remove
the options specifying non-default IEEE behavior or
else undefine the _FASTMATH macro.
UNSUPPTYPE
Message The CDD description for <name> specifies a data type
not supported in C.
Description There is no HP C datatype to exactly represent this
type. HP C has created a declaration of the same
total size as the unsupported data type.
User Action If the type provided by the HP C compiler is not
satisfactory, change the CDD description to one that
the compiler can represent more exactly.
UNUSEDCDD
Message This CDD record appears to be unused.
Description The contents of this CDD record are not used by the
rest of the compilation.
User Action For compilation efficiency, you can exclude this
dictionary directive when compiling with the current
set of compilation options.
UNUSEDINCL
Message This nested include file appears to be unused.
Description The contents of this include file are not used by the
rest of the compilation.
User Action For compilation efficiency, you can exclude this
include file when compiling with the current set of
compilation options.
UNUSEDTOP
Message This include directive does not contribute to the
compilation, perhaps because the file has already
been included.
Description The contents of this top-level include file are not
used by the rest of the compilation. This message
can occur when the include file has already been
included, perhaps by a nested include file.
User Action For compilation efficiency, you can exclude this
include file when compiling with the current set of
compilation options.
USELESSALIGN
Message <Context> _align cannot be used with the <class>
storage class. Modifier _align is ignored.
Description The storage class modifier _align is meaningless for
objects declared with register, globalref, or
globalvalue storage class. The compiler ignores the
_align.
User Action Remove the _align storage class modifier.
USELESSSTOMOD
Message <Context> <noshare or readonly> cannot be used with
the typedef storage class. Modifier is ignored.
Description The storage class modifiers noshare and readonly are
meaningless for typedefs. The compiler ignores the
storage class modifier.
User Action Remove the storage class modifier.
USELESSTYPED
Message This typedef declaration is useless because it does
not declare a typedef name.
Description This typedef declaration does not declare a typedef
name. This case can occur when a declaration tries
to declare both a tag and a typedef, but the name of
the typedef is not included.
User Action Either remove the typedef keyword or add a typedef
name.
USELESSTYPEQUAL
Message <Context> this type qualifier will have no effect.
Description A type qualifier is applied only to the declarators
in a declaration. Declarations that lack declarators
are permitted if they declare a tag or an enumeration
constant, but in such cases type qualifiers are not
useful.
User Action Remove the type qualifier, or change this to a
typedef declaration that declares a name for the type
and use that typedef name to refer to the qualified
type.
VAARGSBODY
Message __VA_ARGS__ may not appear except in a function-like
macro that uses the ellipsis notation in the
parameters.
Description The identifier __VA_ARGS__ may only appear in the
replacement list of a function-like macro definion
that uses ellipsis notation in the parameters.
User Action Either remove __VA_ARGS__ or change its spelling.
VAARGSFORMAL
Message __VA_ARGS__ may not be used as a formal parameter.
Description The identifier __VA_ARGS__ may only appear in the
replacement list of a function-like macro definion
that uses ellipsis notation in the parameters.
User Action Rename the formal parameter.
VALUENOTSUP
Message <Context> the floating-point constant named "<name>"
is not supported in "<fpmode>" representation.
Description The representation of an IEEE Infinity or NaN has no
special meaning when used with non-IEEE
floating-point operations.
User Action Replace the named constant with a conventional
floating point constant. The HUGE_VAL macros defined
by <math.h> may be used in place of IEEE Infinities
with any floating-point representation.
VALUEPRES
Message <Context> the conversion of the unsigned char/short
value "<expression>" to signed int shows one example
of this program's use of value-preserving integral
promotion. This differs from the unsigned-preserving
semantics of some older C compilers.
Description This expression shows one of possibly many places
where this compilation uses value-preserving
semantics for small integer promotions rather than
unsigned-preserving semantics used by some older
compilers. In cases where an unsigned char or
unsigned short int is promoted to an integer, there
are two different ways the convert could happen.
Standard C requires that the type be converted to a
signed int (value-preserving semantics) while some
older compilers will convert to an unsigned int
(unsigned-preserving semantics). The difference in
the choice of int or unsigned int can have an impact
on results of expressions that use the converted
value. The compiler cannot determine whether or not
a particular instance of this usage will cause an
observable behavior difference in the program. For
more information, consult Section 3.2.1.1 of the
Rationale for ANSI C.
User Action Be aware that older, non-standard compilers might
interpret this expression differently.
VARIANTDCL
Message A declaration of a variant struct or variant union
must have a single declarator that is an identifier.
Description A variant_struct or variant_union member was either
not followed by a declarator or followed by more than
one declarator. This is not valid.
User Action Declare the variant_struct or variant_union member
with a single identifier.
VARIANTDUP
Message The anonymous struct or union member "<member name>"
duplicates the name of a member in the enclosing
struct or union.
Description As members of an anonymous structure or union are
promoted to membership of the enclosing struct/union
type, the names of each element of the anonymous
struct/union must not match an element name in the
enclosing struct/union. This message can also be
output when the variant_struct or variant_union
syntax is used instead of the anonymous struct/union.
User Action Choose a new name for either the offending anonymous
struct/union member or the matching member of the
enclosing type.
VARIANTEXT
Message variant struct or union is a language extension.
Description Declaring a member to be a variant_struct or
variant_union is a language extension of HP C. Other
C compilers might not successfully compile a program
that uses the extension.
User Action Consider using an anonymous struct or union (one
without a tag or declarator) instead: anonymous
structs/unions are supported by HP C and some other
vendors' C compilers.
VARIANTTAG
Message A variant struct or union cannot have a tag.
Description A variant_struct or variant_union declaration
specified a tag name. This is not allowed.
User Action Either remove the tag or change the declaration to be
a regular struct or union instead of a variant struct
or union.
VARNOMEM
Message A variant struct or variant union can occur only as a
member of a struct or union.
Description A declaration contained a variant_struct or
variant_union in some place other than a member of a
struct or union. This is not valid.
User Action Correct the offending declaration.
VERTICALSPDIR
Message Vertical whitespace within pp directive.
Description Unexpected vertical white space as been encountered
within a preprocessing directive.
User Action Remove the vertical white space from the directive.
VLAEXTENSION
Message <Context> variable length arrays are 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.
VOIDRETURN
Message The function "<name>" has return type void, and so
must not contain a return statement with an
expression.
Description The current function was declared with a void return
type. The expression specified in the return value
will be evaluated but will not be returned to the
caller.
User Action Either change the return type in the function
declaration or remove the return value from the
return statement.
VOIDRETURN1
Message The function "<name>" has return type void. The
return statement must not specify a return value even
if the return expression has void type.
Description The current function was declared with a void return
type. Although some C compilers allow such a
function to return a void expression, this is a
violation of the C standard and may not be portable.
User Action Modify the program so that the return statement does
not specify a return value.
VOLATILEFUNC
Message Ignoring volatile type qualifier in declaration of
<name>.
Description The volatile type qualifier cannot be used with a
function type. The compiler will ignore the type
qualifier.
User Action Remove the type qualifier.
WCHARCAT
Message A character string literal was concatenated with a
wide string literal.
Description The C99 standard defines the behavior of adjacent
string concatenation between character string
literals and wide string literals, basically
promoting the character string to a wide string
before forming the wide string result. The older C90
standard gave this construct undefined behavior - it
only defined concatenation between adjacent strings
of the same kind (all character or all wide).
Although this version of HP C always gives the C99
behavior with diagnostics optional, some compilers
(including previous versions of HP C) may give more
severe diagnostics and/or different behaviors.
User Action Be aware of this if you wish to port the program.
WRTINNOWRT
Message Writable variable resides in nowrt extern model.
Description The current extern model places all external objects
in a read-only section. An object without a const
type qualifier in such a section means that while the
compiler will not diagnose writes to the object, any
attempt to modify the object at runtime will cause
the program to fail. This might not have been what
you intended.
User Action Place non-const objects in sections that can be
modified.
XFERINTOVLA
Message This statement performs an invalid transfer into a
block that declares a variably modified type or
object. The identifier "<name>" is variably
modified, and declared at <where>.
Description It is invalid to transfer control into a block after
that block declares a variably modified type.
User Action Either remove the transfer, or move the declaration
of the variably modified type.
XTRALARGE
Message Line number is greater than the 32767 specified by
the C standard and might not be portable.
Description A #line preprocessing directive specified a line
value that is greater than 32767. While the value is
supported by HP C, the C89 standard specifies that
the value must not be greater than 32767. Therefore,
this program does not conform to the C89 standard,
and the directive might not be accepted by other C
compilers.
User Action Be aware of this if you wish to port the program.
ZERODIV
Message <Context> division by zero occurs in evaluating the
expression "<expression>".
Description A divide by zero occurred while evaluating a constant
expression. The value of the expression is
undefined.
User Action Correct the constant expression so that it does not
contain a division by zero.
ZERODIVIDE
Message Division by zero in expression.
Description A divide by zero occurs in a preprocessor constant
expression. The result of the divide will be zero.
User Action Correct the preprocessor constant expression.
ZEROELEMENTS
Message <Context> zero cannot be used as an element count
specifier. The specifier will be ignored, (leaving
the member/parameter with an incomplete array type)
in this context.
Description The C standard states that if an element count
specifier is a constant expression then it shall have
a value greater than zero. For compatibility with
some other C compilers, HP C will accept a zero
element count specifier. When appearing in a
struct/union member or a parameter, the specifier
will be ignored.
User Action Remove the zero.
ZEROELEMENTS1
Message <Context> zero cannot be used as an element count
specifier. It will be replaced with the constant one
in this context.
Description The C standard states that if an element count
specifier is a constant expression then it shall have
a value greater than zero. For compatibility with
some other C compilers, HP C will accept a zero
element count specifier. When appearing outside a
struct/union member or a parameter, the compiler will
replace the zero with the value one. This may or may
not be compatible with the behavior of other C
compilers.
User Action Use a valid element count specifier.
|
