VMS Help
CC, Messages
*Conan The Librarian (sorry for the slow response - running on an old VAX)
|
|
Compiler messages
Some compiler messages substitute information from the program into
the message text. In this online help, the portion of the text to
be substituted is shown in angle brackets (<>).
Often, the same message is issued in different contexts within a
program. In this online help, the message context is indicated by
the word <context> within the message. The actual message issued by
the compiler will contain one of the following phrases substituted
for <context>:
In this declaration,
In the initializer for
In the declaration of "<name>",
In the definition of the function "<name>",
In the declaration of an unnamed object,
In this statement,
You can control the messages issued with the /[NO]WARNINGS command
line qualifier or the #pragma message preprocessor directive. Note
that some messages are not produced directly by the compiler; they
are produced by other software that the compiler uses. Messages not
produced directly by the compiler are not included in this list and
can not be controlled by /[NO]WARNINGS or #pragma message.
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.
Message <Context> & before array "<expression>" is ignored.
Description In certain modes, Compaq C will ignore an address-of
operator used on an entire array. This is for
compatibility with other compilers that have this
behavior.
User Action Remove the address-of operator.
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.
Message <Context> accepting the expression "<expr>" as a
constant is a language extension.
Description In many cases Compaq C accepts the subtraction of two
addresses within the same array or struct/union as a
constant. The C standard does not consider such an
expression to be a constant. Therefore, this program
does not conform to the standard and may be rejected
by other compilers.
User Action Change the expression to be a constant.
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.
Message _align is a language extension.
Description The _align storage class modifier is a language
extension of Compaq C. Other C compilers might not
successfully compile a program that uses the
extension.
User Action Be aware of this extension if you wish to port the
code.
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.
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
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.
Message <Context> taking the address of the constant
expression "<expression>" in an argument list is a
language extension.
Description The Compaq C compiler will allow the address of a
constant to be passed as an argument to a function
call. This is an extension to standard C. Other C
compilers might not successfully compile a program
that uses this extension.
User Action Assign the constant to a variable, and pass the
address of the variable.
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.
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.
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.
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.
Message <Context> Compaq C provides only limited support for
array types larger than <n> bytes.
Description This array type is larger than can be represented by
size_t. While Compaq C will allow a type declared to
be this size, uses of the type are not fully
supported and may cause unpredictable behavior.
User Action Reduce the size of the array type. It may be
possible to use a pointer type instead of a large
array. The storage can still be accessed using array
syntax.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Message <text>
Description This message is emitted by the code generator used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
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.
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, Compaq C will give the array
one element.
User Action Complete the type.
Message The alignment boundary of an automatic cannot be
greater than <longword or octaword>.
Description For automatic variables, the storage class modifier
_align cannot specify an alignment greater than
octaword on Alpha or longword on VAX. The alignment
will be set to the octaword on Alpha or longword on
VAX.
User Action Decrease the alignment. If a larger alignment is
required, declare the variable with static storage
class.
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.
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.
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.
Message This statement uses the type "<type>" to reference
the same storage location as the statement at <loc>,
which uses the type "<type>". This does not conform
to the ANSI aliasing rules.
Description The standard allows a compiler to assume that since
these two statements use different types, these two
statements reference different storage locations.
The Compaq C compiler does so whenever ansi aliasing
is enabled. Since your code relies on these two
statements referencing the same storage location you
should disable ansi aliasing. If you do not do so,
optimization may result in your program exhibiting
unexpected behavior.
User Action Specify noansi_alias on the command line.
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
Compaq C compiler is only able to output the checking
code for the first pointer arithmetic operation
performed on the array. This can result in an
incorrect check if the resulting pointer value is
again operated on by pointer arithmetic. Consider
the expression a = b + c - d; where a is a pointer, b
an array, and c and d integers. When bounds checking
is enabled the compiler will output a check to verify
that c within the bounds of the array. This will
lead to an incorrect runtime trap in cases where c is
outside the bounds of the array and c - d is not.
User Action Recode the pointer expression so that the integer
part is in parenthesis. This way the expression will
contain only one pointer arithmetic operation. In
the earlier example the expression would be changed
to a = b + (c - d);
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Message Invalid expression.
Description An invalid expression was encountered.
User Action Correct the program syntax.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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 Compaq recommends that the left operand or a struct
or union reference specify a member that is a member
of the type of the struct or union specified by the
right operand. If this modification cannot be made
then the member specified by the left operand must be
declared at the same offset and with the same data
type in all struct or union declarations that declare
that member.
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 Compaq recommends that the left operand or a struct
or union reference specify a member that is a member
of the type of the struct or union specified by the
right operand. If this modification cannot be made
then the member specified by the left operand must be
declared at the same offset and with the same data
type in all struct or union declarations that declare
that member.
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.
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.
Message <text> Qualifier value '<text>' is not an integer
Description This message is emitted by the code generator used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Message Lexically invalid token.
Description An invalid token was encountered in a preprocessing
directive.
User Action Correct the preprocessing directive.
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.
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.
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.
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.
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.
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.
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.
Message The CDD description for <name> specifies that it is
an array of bitfields; It has been converted to a
scalar bitfield.
Description Compaq C does not allow arrays of bitfields. The
resulting C declaration will be a bitfield of the
same total size as that specified in the CDD
description.
User Action If a bitfield type is acceptable, then no user
action is necessary. If, however, the bitfield type
is not acceptable, then the CDD description should be
altered.
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.
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.
Message The CDD description for bitfield <name> specifies a
size greater than 32; The excess is declared
separately.
Description Compaq C does not allow individual bitfields larger
than 32. As a result, a series of bitfields have
been declared whose total size matches that of the
CDD definition.
User Action If the generated definitions are acceptable, then no
user action is necessary. If, however, the generated
definitions are not acceptable, then the CDD
description should be altered.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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).
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
Message Compiler bugcheck. Submit an SPR with a problem
description.
Description An unexpected condition occurred in the compiler.
This is most likely caused by a compiler bug.
User Action Reduce the program that is causing the failure as
much as possible. This often leads to a small test
case. Please submit a problem report containing
enough information for Engineering to reproduce the
problem. The problem report should include the small
test case.
Message Full C99 is not supported on this platform. Language
mode set to "relaxed_ansi89", which includes the C99
features supported on this platform.
Description The Compaq C compiler on OpenVMS VAX does not support
the C99 standard and will therefore not accept the
/STANDARD=C99 qualifier. The compiler will use
/STANDARD=RELAXED_ANSI. This mode includes all C99
features that are supported on OpenVMS VAX.
User Action Do not use /STANDARD=C99 on this platform.
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.
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.
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.
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.
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 Compaq C. The attribute is ignored.
User Action No action is required.
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.
Message #dictionary is a language extension.
Description The #dictionary directive is an extension of Compaq
C/C++ on OpenVMS. The program might not compile with
other compilers or on other platforms.
User Action Be aware of this if you wish to port the program.
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. Compaq also
recommends that the #dictionary preprocessing
directive be replaced by the #pragma dictionary
operator.
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.
Message Ill-formed character constant.
Description An invalid character constant was encountered.
User Action Correct the character constant.
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.
Message <number> integrity check error(s) after IL expansion
of routine <text>
Description This message is emitted by the code generator used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
Message <number> integrity check error(s) in initial IL & ST
for module <text>
Description This message is emitted by the code generator used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
Message <number> integrity check error(s) after <text>
optimization phase for routine <text>
Description This message is emitted by the code generator used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
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. Compaq recommends that you
initialize all objects with the const attribute. The
missing initializer will make this an invalid
declaration in C++.
User Action Initialize the struct or union object.
Message Missing "]".
Description The compiler was expecting a closing bracket, but one
was not found.
User Action Correct the program syntax.
Message Missing "}".
Description The compiler was expecting a closing brace, but one
was not found.
User Action Correct the program syntax.
Message Missing ")".
Description The compiler was expecting a closing parenthesis, but
one was not found.
User Action Correct the program syntax.
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.
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 Compaq C compiler supports only row-major arrays.
Therefore the column-major array description in the
CDD has been converted to a one-dimensional array of
the same total size and with the same total number of
elements.
User Action Verify that all subscript references to the array
reference the correct array element.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Message <Context> the use of the const variable "<name>" in
place of a literal constant is a language extension.
Description Compaq C will allow a non-volatile const variable
that has been initialized to be used in contexts
where a constant is required. For example, as the
bounds specifier to a file scope array. This is an
extension to standard C. Other C compilers might not
successfully compile a program that uses this
extension.
User Action Use the constant value instead of the variable.
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.
Message module uses more than 65536 CodeView type indices
Description This message is emitted by the code generator used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
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.
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.
Message C++ style comments (//) may not be portable.
Description C++ style comments have been detected on this line.
Although they have been accepted by Compaq C in this
language mode, they will not be accepted by all
compilers or by Compaq C in strict C89 standard mode.
User Action Replace C++ style line comments (//) with equivalent
C comments (/* ... */) if portability is a concern.
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.
Message The Compaq C++ pragma "<pragma name>" is not
supported by Compaq C. The pragma will be ignored.
Description The compiler has encountered a pragma that is
supported by Compaq C++ but is not supported by
Compaq C. The compiler will ignore the pragma.
User Action Remove the pragma or compile the program with Compaq
C++.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Message __declspec is a language extension.
Description The __declspec storage class modifier is a language
extension of Compaq C. Other C compilers might not
successfully compile a program that uses the
extension.
User Action Be aware of this extension if you wish to port the
code.
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.
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.
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.
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.
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. Compaq also recommends that
old-style function definitions be replaced by
prototype-format definitions.
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.
User Action It is a good programming practice to give all
function definitions explicit return types.
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.
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.
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.
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.
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.
Compaq C will only support this extension in relaxed
mode and strict c99 mode.
User Action Use a compilation mode that supports the use of
designations.
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.
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.
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.
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.
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. Compaq C allows
this redeclaration for consistency with some other C
compilers, and will form a composite type with all of
the type qualifiers from both declarations. Be aware
that these declarations may not be accepted by other
C compilers.
User Action Modify the declarations so that they use identically
qualified types.
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.
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.
Message Extension: A '$' was encountered in an identifier.
Description Accepting a "$" character in an identifier is an
extension of Compaq C/C++. The program might not
compile with other C/C++ compilers.
User Action Be aware of this if you wish to port the program.
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.
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.
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
Compaq C, it is not allowed by the C standard.
User Action Either use a different enumerator name or remove the
previous declaration of the name.
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.
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.
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.
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.
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.
Compaq also recommends that old-style function
definitions be replaced by prototype-format
definitions.
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
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Message Empty character constant.
Description In some modes the Compaq C/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'.
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.
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.
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.
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 Compaq 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.
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.
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.
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.
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.
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. Compaq 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.
Message <Context> allowing two different enumeration types to
be compatible is a language extension.
Description The Compaq 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.
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.
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.
Message diagnostic message limit exceeded
Description This message is emitted by the code generator used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
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.
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.
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 Compaq C/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.
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.
Message The expression "<expression>" has been converted to
integer.
Description In certain modes, Compaq 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.
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 Compaq C requires that
the switch control expression have integer type.
User Action Modify or cast the expression so that it has integer
type.
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.
Message This platform specific type is a language extension.
Description The use of the types __int8, __int16, __int32,
__int64, __f_float, __g_float, __s_float, __t_float
might not be portable to other platforms or to other
C compilers.
User Action Be aware of this portability concern.
Message Compaq 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. Compaq 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.
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.
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.
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.
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.
Message <Context> 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.
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.
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.
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.
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.
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.
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.
Message File not found: <text>
Description The specified file could not be found by the
compiler.
User Action Specify the correct file name.
Message An error occurred while attempting to open the source
file: <problem>.
Description An unexpected error occurred while opening a source
file. The message text will contain additional
information about the failure.
User Action Correct the condition that caused the failure.
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.
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.
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.
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.
Message Ill-formed floating constant.
Description An invalid floating constant was encountered.
User Action Correct the floating constant.
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.
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.
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.
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.
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
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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. Compaq
C will change the storage class to extern.
User Action Either remove the storage-class specifier, or change
it to extern.
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.
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.
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.
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 COMPAQ
C __inline keyword.
User Action Use the command line specifier -accept nogccinline.
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 Compaq C
implementation limit.
User Action Either reduce the size of the argument or consider
passing it by reference.
Message A storage class of globaldef, globalref, or
globalvalue is a language extension.
Description These storage classes are language extensions of
Compaq 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.
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.
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.
Message The Compaq C compiler conforms to the C standard and
will give this constant an unsigned type. Some older
compilers may give this constant a signed type.
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.
Message Identifier expected but not found.
Description The compiler was expecting an identifier, but one was
not found.
User Action Correct the program syntax.
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, Compaq C will accept an
identifier enclosed in parentheses. Be aware that
this program does not conform to the standard and may
be rejected by other compilers.
User Action Remove the parentheses.
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).
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.
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.
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.
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.
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.
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.
Message Ignoring system register specified in routine's
linkage.
Description This message is emitted by the code generator used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
Message The _Imaginary keyword is not supported by Compaq C.
It will be treated as an identifier in this
compilation.
Description Support for the _Imaginary keyword is an optional
extension to the C standard. Compaq C does not
support this extension. All occurrences of
_Imaginary will be treated as an identifier.
User Action Do not use the _Imaginary type.
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.
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.
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.
User Action Declare the function before it is referenced.
Message Type of actual argument inconsistent with formal
parameter declaration in <text>
Description This message is emitted by the code generator used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
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.
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.
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.
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.
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.
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, and
not the final member of that type. Other C compilers
might not successfully compile a program that uses
this extension.
User Action Specify the bounds if possible.
Message <Context> the last member of a struct or union,
<name>, has incomplete array type. This is not
strictly conformant with the C89 standard and might
not be portable.
Description Compaq C will allow an array without a bounds
specifier to be part of a struct or union type.
While this extension is allowed by the C99 standard,
other C compilers might not successfully compile a
program that uses this extension.
User Action Specify the bounds if possible.
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.
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, Compaq C will allow the struct or
union specifier of a member dereference operator (->)
to specify a struct or union that does not contain
the element specified by the right operand. While
this is considered poor programming practice, it was
common with older C compilers. In cases where the
left operand is a pointer to an incomplete type, the
practice is considered even worse. While Compaq C
will accept the construct in certain modes, the code
should be modified. Further, this program does not
conform to the C standard and might not be accepted
by other C compilers.
User Action Be aware of this if you wish to port the program.
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.
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 Compaq C will allow this if the element type is
completed later, other compilers might require the
type to be complete at this point in the program.
User Action Either complete the type before the array
declaration, or be aware of this if you wish to port
the program.
Message The member "<name>" has an incomplete type.
Description A struct or union member must not have an incomplete
type. An exception is that Compaq C will accept a
member that is an array with unspecified bounds,
although warnings are often generated for this case.
User Action Complete the type before it is used in as a member of
a struct or union.
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.
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.
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.
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.
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.
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.
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.
Message A function "<name>" appeared in more than one #pragma
assert func_attrs specifying the same assertion.
Description A function can appear on more than one #pragma assert
func_attrs as long as each #pragma specifies a
different assertion about the function. The
assertion will be ignored.
User Action Either remove the #pragma assert directive, or remove
the function name from the pragma, or correct its
spelling.
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.
Message <Context> , this initializer list will provide a
value for a subobject that was initialized by the
earlier initializer "<init>". The earlier
initializer will be ignored.
Description This initializer list will provide a value for a
subobject that has already been initialized. While
this is valid, it might not have been what was
intended.
User Action Initialize each subobject only once.
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.
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.
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 Compaq C. Other C
compilers might not successfully compile a program
that uses the extension.
User Action Be aware of this extension if you wish to port the
code.
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.
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.
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.
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.
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.
Message Ill-formed integer constant.
Description An invalid integer constant was encountered.
User Action Correct the integer constant.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Compaq recommends that old style function definitions
be replaced by prototype-format definitions.
User Action Recode the function definition to use the recommended
prototype-format definition.
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, Compaq C will accept a label without a
statement. Be aware that this program does not
conform to the standard and may be rejected by other
compilers.
User Action Add a semicolon after the label to create a null
statement.
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.
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 Compaq C does not support the long
double _Complex type where the real and imaginary
component are 128-bits in size. As Compaq C requires
that each component of a long double _Complex be the
same size as a long double, this compilation must
specify the option to treat long double as 64-bits.
User Action Either specify the correct compiler option or use the
double _Complex type instead of the long double
_Complex type.
Message Lexically nested parallel at scope <text> is not
supported
Description Nested parallel directives are not supported.
User Action Remove the nested parallel directive.
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.
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.
Message A logical source line longer than <number> characters
was encountered.
Description The length of a source line has exceeded the maximum
length supported by the Compaq C compiler.
User Action Reduce the size of the line.
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.
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 Compaq C does not support the long double type on
this platform. In this compilation mode, the
compiler will treat the long double type as a synonym
for the double type.
User Action Be aware of this.
Message <Context> type long double has the same
representation as type double on this platform.
Description Although Compaq C will recognize the long double type
as a different type than double in this compilation
mode, on this platform they will both use the same
representation. Using long double will not provide
any additional precision or range.
User Action Be aware of this.
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.
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.
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.
Message <Context> type "<type>" is a new feature in C99.
Description On some platforms, Compaq C will accept the
[unsigned] long long type as a way to declare
[unsigned] 64-bit integers. The long long int type
is a new feature of C99 and other compilers might not
accept this declaration.
User Action Be aware of this portability concern.
Message Identifier name "<name>" in a #pragma module or
#module directive exceeds 31 characters.
Description A module name specified in the #pragma module or
#module directive must be less than 32 characters.
The compiler will truncate the name to the first 31
characters specified.
User Action Shorten the module name.
Message Character-string constant <string> in a #pragma
module or #module directive exceeds 31 characters.
Description An ident specified in the #pragma module or #module
directive must be less than 32 characters. The
compiler will ignore the directive.
User Action Shorten the ident specifier.
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.
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.
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 Compaq C. The
program does not conform to the C standard, and might
not be accepted by other compilers.
User Action Remove the cast.
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.
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.
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. Compaq C will
accept other return types, but the program does not
conform to the C standard. The status value returned
to the environment may not be what you expect, and
other C compilers may not accept the definition as
written.
User Action Define the "main" function with a return type of int
for maximal portability.
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. Compaq C will accept more,
but the program does not conform to the C standard.
User Action Modify the declaration if you want the program to be
standard conformant.
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 Compaq C.
Other C compilers might not successfully compile a
program that uses the extension.
User Action The main program should be declared by naming the
function main.
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.
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.
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.
Message Argument passing mechanism does not match formal
parameter mechanism for <text>
Description This message is emitted by the code generator used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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 ", ...").
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.
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.
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.
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.
Message <Context> this call to __ALLOCA occurs in a block
that contains a variable-length array declaration.
The storage allocated by this __ALLOCA call
will<fragment>vla declaration was at <where>.
Description Storage allocated for arrays of variable length have
their storage deallocated when the block they are
declared in exits. Storage allocated by __ALLOCA is
not normally deallocated until function exit. Compaq
C cannot support both types of deallocation in the
same block. Therefore, when both a vla array and an
__ALLOCA call 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 array.
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.
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.
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.
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.
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.
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.
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.
Message Declaring a variable length array in the same block
as a call to __ALLOCA will cause the storage
allocated by any __ALLOCA call to<fragment> previous
call to __ALLOCA was at <where>.
Description Storage allocated for arrays of variable length have
their storage deallocated when the block they are
declared in exits. Storage allocated by __ALLOCA is
not normally deallocated until function exit. Compaq
C can not support both types of deallocation in the
same block. Therefore, when both a vla array and an
__ALLOCA call 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 array.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Message The external identifier "<name>" exceeds 31
characters. The name has been shortened to
"<shortened spelling>".
Description A compilation that used the /NAMES=SHORTENED
qualifier has encountered a name that needs to be
shortened. The external name will be different than
the internal name. Also, because the external name
exceeds the length specified by standard C as the
minimum external length an implementation must
support, this program does not strictly conform to
standard C and might not be accepted by other C
compilers.
User Action Be aware of these items.
Message The /NAMES=LOWERCASE qualifier will be removed in a
future version of the compiler. Use /NAMES=AS_IS if
your application must generate global names in
lowercase.
Description While the C language has always required identifiers
with internal linkage to be treated case
sensitively,it traditionally permitted
implementations to monocase identifiers with external
linkage. Modern standards require C/C++
implementations to preserve the case of identifiers
with external linkage. As VMS and other operating
systems that traditionally implemented monocasing
chose uppercase as the convention, /NAMES=LOWERCASE
runs contrary both to the C and C++ standards and to
traditional conventions. Continued support for this
option interferes with support for compatibility
between old code compiled with /NAMES=UPPERCASE and
new code compiled with /NAMES=AS_IS.
User Action Use /NAMES=AS_IS, making source code changes as
needed.
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.
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.
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.
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.
Compaq C allows non-constants in these initializers.
This is an extension to C89. Although this is
allowed by the C99 standard, other C compilers might
not successfully compile a program that uses this
extension.
User Action Be aware of this if you wish to port the program.
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.
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.
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.
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.
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.
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.
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.
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, Compaq C will search all other
visible struct/union types for a matching member
name. If it finds one, a diagnostic will be issued,
and the offset of that name will be used.
User Action Specify a valid member name.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Message Missing ":".
Description The compiler was expecting a colon, but one was not
found.
User Action Correct the program syntax.
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.
Message Missing ",".
Description The compiler was expecting a comma, but one was not
found.
User Action Correct the program syntax.
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.
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.
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.
Message <Context> there is no declarator.
Description A declaration contains a storage class and/or type
specifier but no declarator. This might not have
been what you intended.
User Action Correct the declaration.
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.
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.
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.
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.
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.
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
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.
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.
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
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.
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.
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.
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.
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.
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).
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Message Unable to generate code for atomic access
Description This message is emitted by the code generator used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
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.
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.
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.
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.
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.
Message Non-standard #line directive.
Description Accepting the line directive without the "line"
preprocessing keyword is an extension of Compaq C.
The program does not conform to the C standard, and
might not be accepted by other compilers.
User Action Add the "line" preprocessing keyword to the
directive.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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
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.
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.
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.
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.
Message routine <text> does not return a value
Description This message is emitted by the code generator used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
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.
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.
Message Missing ")".
Description A right parenthesis was expected at this point in the
program, but none was found.
User Action Correct the program syntax.
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.
Message Missing ";".
Description The compiler was expecting a semicolon, but one was
not found.
User Action Correct the program syntax.
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.
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 Compaq C provided for compatiblity with
older C compilers. This syntax is not valid in
standard C, and may not be accepted by other C
compilers.
User Action Add the semicolon at the end of the last member.
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.
Message noshare is a language extension.
Description The noshare storage class modifier is a language
extension of Compaq C. Other C compilers might not
successfully compile a program that uses the
extension.
User Action Be aware of this extension if you wish to port the
code.
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.
Message Missing string literal.
Description The compiler was expecting a string literal, but one
was not found.
User Action Correct the program syntax.
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.
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.
Message bad reduction path from fetch of <text>
Description This message is emitted by the code generator used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
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.
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.
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.
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.
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.
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.
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.
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.
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. Compaq
also recommends that old-style function definitions
be replaced by prototype-format definitions.
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
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.
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.
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.
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.
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.
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.
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 Compaq 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.
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.
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.
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.
Message "#<directive>" directive within a macro argument list
is not portable.
Description Compaq C/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.
Message Missing "{".
Description The compiler was expecting an open brace, but one was
not found.
User Action Correct the program syntax.
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.
Message Missing "(".
Description The compiler was expecting an open parenthesis, but
one was not found.
User Action Correct the program syntax.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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. Compaq also recommends that old-style
function definitions be replaced by prototype-format
definitions.
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.
Compaq also recommends that old-style function
definitions be replaced by prototype-format
definitions.
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.
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.
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.
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. Compaq also recommends
that old-style function definitions be replaced by
prototype-format definitions.
Message Error opening PDB file <text>: <text>
Description This message is emitted by the code generator used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
Message Error adding type record to PDB file: <text>
Description This message is emitted by the code generator used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
Message index variable of PDO <text> is not a private
variable
Description This message is emitted by the code generator used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
Message pdone <text> in statically-scheduled PDO will be
ignored
Description This message is emitted by the code generator used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
Message pdone <text> is not nested in a PDO
Description This message is emitted by the code generator used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
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.
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.
Message The member alignment popped/restored with pragma
<pragma name> was saved using pragma <pragma name>.
The member alignment restored will take effect.
Description Compaq 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.
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.
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 Compaq C/C++ will.
User Action Be aware of this if you wish to port the program.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Message An error occurred while attempting to open the
preprocessor output 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.
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 used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
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. Compaq also
recommends that old-style function definitions be
replaced by prototype-format definitions.
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. Compaq also
recommends that old-style function definitions be
replaced by prototype-format definitions.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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, Compaq C will no longer
accept it. The type qualifier is ignored.
User Action Remove the type qualifier.
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.
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.
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.
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.
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.
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.
Message readonly is a language extension.
Description The readonly storage class modifier is a language
extension of Compaq C. Other C compilers might not
successfully compile a program that uses the
extension.
User Action Be aware of this extension if you wish to port the
code.
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 Compaq C compiler will accept this for
compatibility with older compilers.
User Action Remove one of the declarations.
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.
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.
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.
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.
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.
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.
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.
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.
Message The pointer size restored with pragma <pragma name>
was saved using pragma <pragma name>. The pointer
size restored will take effect.
Description Compaq 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.
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.
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 Compaq 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.
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.
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.
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.
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.
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).
Message C RTL mapping information for RTL <name> not found.
Could not access <image_name>.
Description In most cases, the Compaq C compiler will
automatically map names of C standard library
functions to their corresponding names in the Compaq
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 Compaq C Run-time Library
Manual for OpenVMS Systems.
Message Compaq C RTL prefix table version mismatch: RTL
table is V<major>.<minor>, compiler needs
V<major>.<minor>.
Description In most cases, the Compaq C compiler will
automatically map names of C standard library
functions to their corresponding names in the Compaq
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 Compaq C Run-time Library
Manual for OpenVMS Systems.
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.
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.
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
Compaq 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.
Message The CDD description for <name> specifies a scale
factor of <number>. The scale factor is being
ignored.
Description Compaq C does not support scaled arithmetic.
User Action Verify that all computations involving this item are
correctly scaled.
Message Compiler Internal Error: SCA event buffer
overflowed. Please submit an SPR.
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.
Message <Context> allowing a comma operator is a language
extension.
Description In this context the C standard does not allow the
comma (sequence) operator. Compaq 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.
Message parallel directive scope <text> has multiple exits
Description This message is emitted by the code generator used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
Message parallel directive scope <text> has multiple entry
paths
Description This message is emitted by the code generator used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
Message parallel directive scope <text> is crossed by a
VBRANCH
Description This message is emitted by the code generator used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
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.
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.
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.
Message <Context> Compaq C recognizes the standard keyword
"signed". This differs from the VAX C behavior.
Description VAX C does not recognize the "signed" keyword.
Compaq 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.
Message <Context> Compaq 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. Compaq 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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Message Psect <text> alignment is insufficient for allocation
of <text>
Description This message is emitted by the code generator used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
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.
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.
Message Allocations to <text> section exceeded growth bounds
Description This message is emitted by the code generator used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
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.
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.
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.
Message Ill-formed string constant.
Description An invalid string constant was encountered.
User Action Correct the string constant.
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.
Message <Context> Compaq 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 Compaq C will allow a
type declared to be this size, uses of the type are
not fully supported and may cause unpredictable
behavior.
User Action Reduce the size of the type.
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.
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.
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. Compaq also recommends that the macro body
be rewritten to use the standard C stringize operator
(#).
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.
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.
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.
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 Compaq C will allow this,
some compilers will truncate the value to an int.
User Action Be aware of this if porting the code to another
platform.
Message System register specified as external register.
Description This message is emitted by the code generator used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
Message <text>
Description This message is emitted by the code generator used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
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.
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.
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.
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, Compaq 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 Compaq 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.
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.
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, Compaq 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.
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 Compaq C/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.
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).
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.
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).
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).
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.
Message Too few actual parameters in macro call.
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.
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.
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.
Compaq 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>.
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.
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.
Message Too many actual parameters in macro call.
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.
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.
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.
Compaq 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>.
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.
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
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.
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.
Message Object file section <text> has <number> relocations;
maximum allowed is <number>
Description This message is emitted by the code generator used by
all Compaq compilers for the Alpha architecture. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
Message Trailing comma found in enumerator list.
Description Accepting an enumerator list that contains a trailing
comma is an extension of Compaq 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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Message Accepting an old-style parameter name that matches a
typedef is a language extension.
Description The Compaq 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.
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.
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.
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.
Message <Context> a typedef has been declared to
have<signed>int type. It had been declared to
have<signed>int type <where>. This change will
affect any subsequent bitfield declarations that are
declared with this type.
Description As this program has been compiled with unsigned
bitfields, there is a difference between int and
signed int types. Any bitfield declared with this
typedef type after this redeclaration will use the
new type, while bitfields declared with this type
before the redeclaration will differ in whether or
not the high-order bit is treated as a sign bit.
This may not be what you expected.
User Action If the intent is to have different types, use a
different typedef name. If the intent is to have the
same types, correct or remove the second typedef, or
compile with the default signed-bitfield option.
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.
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.
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.
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.
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.
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.
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.
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.
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. Because the access is unaligned,
there is no guarantee of atomicity and byte
granularity. Therefore the access may not work as
you expect.
User Action Make sure volatile objects are aligned on a natural
boundary.
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.
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.
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
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Message The pragma "<pragma text>" is unrecognized.
Description A pragma that has no meaning to Compaq C/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 Compaq C/C++. If the spelling and
compiler version are correct, understand that this
pragma will have no effect.
Message Unrecognized #pragma directive.
Description This #pragma preprocessing directive is not
recognized by Compaq C. The directive will be
ignored.
User Action Make sure that this is the intended behavior.
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 Compaq C/C++ match those accepted by the
assembler. The psect attribute will be ignored.
User Action Correct the psect attribute.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Message The declaration of a member that is an unnamed struct
or union type is an extension and might not be
portable.
Description Compaq C allows a member of a struct or union to be
an unnamed struct or union type. This is an
extension of Compaq 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.
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.
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.
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.
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.
Message The CDD description for <name> specifies a data type
not supported in C.
Description There is no Compaq C datatype to exactly represent
this type. Compaq C has created a declaration of the
same total size as the unsupported data type.
User Action If the type provided by the Compaq C compiler is not
satisfactory, change the CDD description to one that
the compiler can represent more exactly.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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 Compaq 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 Compaq C and some
other vendors' C compilers.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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 Compaq 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.
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.
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.
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, Compaq 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.
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, Compaq 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.
[legal]
[privacy]
[GNU]
[policy]
[netiquette]
[sponsors]
[FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.