Online Help for VSI C Version 7.4
The CC command invokes the VSI C compiler to compile C source
programs. The syntax is:
CC file-spec,... +library-file-spec/LIBRARY...
1 – Command Parameters
file-spec,...
One or more VSI C source files separated by plus signs or
commas. If plus signs are used, the input files are
concatenated into a single object file. If commas are used,
each file is compiled separately to create separate object
files. If no input file extension is specified, VSI C assumes
the .C default file extension.
library-file-spec
A text library containing #include modules referenced in one or
more of the source files. A library file specification must be
concatenated with a file specification with a plus sign and
qualified using the /LIBRARY qualifier. If the input file
extension is not specified, VSI C assumes the .TLB default file
extension.
2 – Qualifiers
Indicate special actions to be performed by the compiler or special
input file properties. Compiler qualifiers can apply to either the
CC command or to the specification of the file being compiled.
When a qualifier follows the CC command, it applies to all the
files listed. When a qualifier follows the file specification, it
applies only to the file immediately preceding it.
The following list shows all the qualifiers available with the CC
command:
o /ACCEPT(option[,...])
o /[NO]ANALYSIS_DATA[=file-spec]
o /[NO]ANNOTATIONS[=(option,...)]
o /[NO]ANSI_ALIAS
o /ARCHITECTURE=option
o /ASSUME=(option[,...])
o /[NO]CHECK[=(option[,...])]
o /COMMENTS={AS_IS | SPACE}
o /[NO]CROSS_REFERENCE
o /[NO]DEBUG[=(option[,...])]
o /DECC
o /[NO]DEFINE=(identifier[=definition][,...])
o /[NO]DIAGNOSTICS[=file-spec]
o /ENDIAN=option
o /ERROR_LIMIT[=number]
o /EXTERN_MODEL=option
o /[NO]FIRST_INCLUDE=(file[,...])
o /FLOAT=option
o /GRANULARITY
o /IEEE_MODE=option
o /[NO]INCLUDE_DIRECTORY=(pathname[,...])
o /L_DOUBLE_SIZE=option
o /LIBRARY
o /[NO]LINE_DIRECTIVES
o /[NO]LIST[=file-spec]
o /[NO]MACHINE_CODE
o /[NO]MEMBER_ALIGNMENT
o /[NO]MMS_DEPENDENCIES[=(option[,option])]
o /NAMES=(option1,option2)
o /NESTED_INCLUDE_DIRECTORY[=option]
o /[NO]OBJECT[=file-spec]
o /[NO]OPTIMIZE[=option]
o /PDSC_MASK=option
o /[NO]PLUS_LIST_OPTIMIZE
o /[NO]POINTER_SIZE=option
o /PRECISION={SINGLE | DOUBLE}
o /[NO]PREFIX_LIBRARY_ENTRIES
o /[NO]PREPROCESS_ONLY[=filename]
o /[NO]PROTOTYPE[=(option[,...])]
o /PSECT_MODEL=[NO]MULTILANGUAGE
o /REENTRANCY=option
o /REPOSITORY=option
o /ROUNDING_MODE=option
o /[NO]SHARE_GLOBALS
o /SHOW[=(option[,...])]
o /[NO]STANDARD=(option)
o /[NO]TIE
o /[NO]UNDEFINE=(identifier[,...])
o /[NO]UNSIGNED_CHAR
o /[NO]VERSION
o /[NO]WARNINGS[=(option[,...])]
3 /ACCEPT
/ACCEPT=(option[,option])
Allows the compiler to accept C language syntax that it might not
normally accept.
VSI C accepts slightly different syntax depending upon the
compilation mode specified with the /STANDARD qualifier. The
/ACCEPT qualifier can fine tune the language syntax accepted by
each /STANDARD mode.
Specify one of the following qualifier options:
[NO]C99_KEYWORDS Controls whether or not the C99 Standard
keywords inline and restrict (which are are
in the C89 namespace for user identifiers)
are accepted without double leading
underscores. The spelling with two leading
underscores (__inline, __restrict) is in the
namespace reserved to the compiler
implementation and is always recognized as a
keyword regardless of this option.
In /STANDARD=RELAXED mode, the default is
C99_KEYWORDS. In all other compiler modes,
the default is NOC99_KEYWORDS.
[NO]GCCINLINE The gcc compiler implements an inline
function qualifier for functions with
external linkage that gives similar
capabilites as the C9x extern inline feature
for functions, but the usage details are
somewhat different: the combination of
extern and inline keywords makes an inline
definition, instead of the exlusive use of
the inline keyword without the extern
keyword. This option controls which
variation of the feature is implemented.
In all compiler modes, the default is
NOGCCINLINE.
[NO]TRIGRAPHS Turns trigraph support on or off. In
COMMON and VAXC compiler modes, trigraphs
are disabled by default. In all other
modes, they are enabled by default.
[NO]VAXC_KEYWORDS Controls whether or not the compiler
recognizes the VAX C keywords (such as
"readonly") regardless of the /STANDARD mode
used.
[NO]RESTRICT_KEYWORD Controls whether or not the compiler
recognizes the C9x standard restrict keyword
regardless of the /STANDARD mode used.
This only affects recognition of the
spelling of the keyword as proposed for
inclusion in the C9x standard. The spelling
with two leading underscores, __restrict, is
in the namespace reserved to the compiler
implementation, and it is always recognized
as a keyword regardless of this option.
Note that [NO]RESTRICT_KEYWORD is a subset
of [NO]C99_KEYWORDS. They have the same
compiler-mode defaults.
The default values are based upon the settings of the /STANDARD
qualifier:
For /STANDARD=RELAXED the default is:
/ACCEPT=(VAXC_KEYWORDS,C99_KEYWORDS,NOGCCINLINE,TRIGRAPHS)
For /STANDARD=VAXC, the default is:
/ACCEPT=(VAXC_KEYWORDS,NOC99_KEYWORDS,NOGCCINLINE,NOTRIGRAPHS)
For /STANDARD=COMMON, the default is:
/ACCEPT=(NOVAXC_KEYWORDS,NOC99_KEYWORDS,NOGCCINLINE,NOTRIGRAPHS)
For /STANDARD=C99 or /STANDARD=LATEST, the default is:
/ACCEPT=(NOVAXC_KEYWORDS,C99_KEYWORDS,NOGCCINLINE,TRIGRAPHS)
In all other modes, the default is:
/ACCEPT=(NOVAXC_KEYWORDS,NOC99_KEYWORDS,NOGCCINLINE,TRIGRAPHS)
4 /ANALYSIS_DATA
/ANALYSIS_DATA[=file-spec]
/NOANALYSIS_DATA (D)
Controls whether the compiler generates a file of source code
analysis information. The default file name is the file name of
the primary source file; the default file type is .ANA.
5 /ANNOTATIONS
/ANNOTATIONS[=(option,...)]
/NOANNOTATIONS (D)
Controls whether or not the source listing file is annotated with
indications of specific optimizations performed or, in some cases,
not performed. These annotations can be helpful in understanding
the optimization process.
Select one or more of the following /ANNOTATIONS qualifier options:
ALL
Selects all annotations. This output can be quite verbose
because it includes detailed output for all annotations. For
more concise output for each kind of annotation, use
/ANNOTATIONS=(ALL,NODETAIL), or just /ANNOTATIONS with no
qualifier options.
[NO]CODE
Annotates the machine-code listing with descriptions of
special instructions used for prefetching, alignment, and so
on. The /MACHINE_CODE qualifier must also be specified for
/ANNOTATION=CODE to have any visible effect.
[NO]DETAIL
Provides additional level of annotation detail, where
available.
[NO]FEEDBACK
Indicates use of profile-directed feedback optimizations.
Feedback optimizations are not implemented on OpenVMS
systems, so this keyword has no visible effect.
[NO]INLINING
Indicates where code for a called procedure was expanded
inline.
[NO]LOOP_TRANSFORMS
Indicates optimizations such as loop reordering and code
hoisting.
[NO]LOOP_UNROLLING
Indicates where advanced loop nest optimizations have been
applied to improve cache performance (unroll and jam, loop
fusion, loop interchange, and so on).
[NO]PREFETCHING
Indicates where special instructions were used to reduce
memory latency.
[NO]SHRINKWRAPPING
Indicates removal of code establishing routine context when
it is not needed.
[NO]SOFTWARE_PIPELINING
Indicates where loops have been scheduled to hide functional
unit latency.
[NO]TAIL_CALLS
Indicates an optimization where a call from routine A to B
can be replaced by a jump.
[NO]TAIL_RECURSION
Indicates an optimization that eliminates unnecessary routine
context for a recursive call.
NONE
Same as /NOANNOTATIONS.
The default is /NOANNOTATIONS.
Specifying /ANNOTATIONS with no keywords is the same as specifying
/ANNOTATIONS=(ALL,NODETAIL).
6 /ANSI_ALIAS
/ANSI_ALIAS
/NOANSI_ALIAS (D)
Directs the compiler to assume the ANSI C aliasing rules, thus
giving it the freedom to generate better optimized code.
The aliasing rules are explained in Section 3.3, paragraphs 20 and
25 of the ANSI C Standard.
The default is /NOANSI_ALIAS for the /STANDARD=VAXC and
/STANDARD=COMMON compiler modes. The default is /ANSI_ALIAS for
all other modes.
7 /ARCHITECTURE
/ARCHITECTURE=options
/ARCHITECTURE=GENERIC (D)
Determines the Intel processor instruction set to be used by the
compiler. The /ARCHITECTURE qualifier uses the same keyword options
(keywords) as the /OPTIMIZE=TUNE qualifier.
Where the /OPTIMIZE=TUNE qualifier is primarily used by certain
higher-level optimizations for instruction scheduling purposes,
the /ARCHITECTURE qualifier determines the type of code instructions
generated for the program unit being compiled.
OpenVMS Version 7.1 and subsequent releases provide an operating
system kernel that includes an instruction emulator. This emulator
allows new instructions, not implemented on the host processor chip,
to execute and produce correct results. Applications using emulated
instructions will run correctly, but may incur significant software
emulation overhead at runtime.
The following /ARCHITECTURE option is supported:
ITANIUM2 Generates code for the Intel Itanium 2 processor.
8 /ASSUME
/ASSUME=(option[,...])
Controls compiler assumptions. You may select the following
options:
[NO]ACCURACY_SENSITIVE
Specifies whether certain code transformations that affect
floating-point operations are allowed. These changes may or
may not affect the accuracy of the program's results.
If you specify NOACCURACY_SENSITIVE, the compiler is free to
reorder floating-point operations, based on algebraic
identities (inverses, associativity, and distribution). This
allows the compiler to move divide operations outside of
loops, improving performance.
The default, ACCURACY_SENSITIVE, directs the compiler to use
only certain scalar rules for calculations. This setting can
prevent some optimization.
[NO]ALIGNED_OBJECTS
Controls an optimization for dereferencing pointers.
On OpenVMS Alpha systems, dereferencing a pointer to a
longword- or quadword-aligned object is more efficient than
dereferencing a pointer to a byte- or word-aligned object.
Therefore, the compiler can generate more optimized code if
it makes the assumption that a pointer object of an aligned
pointer type does point to an aligned object.
Since the compiler determines the alignment of the
dereferenced object from the type of the pointer, and the
program is allowed to compute a pointer that references an
unaligned object (even though the pointer type indicates that
it references an aligned object), the compiler must assume
that the dereferenced object's alignment matches or exceeds
the alignment indicated by the pointer type.
The default, /ASSUME=ALIGNED_OBJECTS, allows the compiler to
make such an assumption. With this assumption made, the
compiler can generate more efficient code for pointer
dereferences of aligned pointer types.
To prevent the compiler from assuming the pointer type's
alignment for objects that it points to, use the
/ASSUME=NOALIGNED_OBJECTS qualifier.
[NO]CLEAN_PARAMETERS
Controls compiler assumptions about short-integer formal
parameters.
The Alpha Calling Standard requires integers less than 64
bits long that are passed by value to have their upper bits
either zeroed or sign-extended to make full 64-bit values.
These are referred to as clean parameters. Some old code
does not follow this convention. This can cause problems if
the called program assumes that the caller followed the
Calling Standard by passing only clean parameters.
Specifying /ASSUME=NOCLEAN_PARAMETERS allows a program to be
called by old code that might pass unclean integer
parameters. It directs the compiler to generate run-time
code to clean the short integers so they comply with the
Calling Standard.
The default is /ASSUME=CLEAN_PARAMETERS.
[NO]EXACT_CDD_OFFSETS
Controls the alignment of Control Data Dictionary records.
If /ASSUME=EXACT_CDD_OFFSETS is specified, the records input
from the CDD are given the exact alignment (relative to the
start of the record) specified by the CDD definition. This
alignment is independent of the current compiler
member-alignment setting.
If /ASSUME=NOEXACT_CDD_OFFSETS is specified, the compiler may
modify the offsets specified in a CDD record according to the
current member-alignment setting.
The default is /ASSUME=NOEXACT_CDD_OFFSETS.
[NO]HEADER_TYPE_DEFAULT
Specifies whether the default file-type mechanism (.h) for
header files is enabled (HEADER_TYPE_DEFAULT) or disabled
(NOHEADER_TYPE_DEFAULT).
The default is /ASSUME=HEADER_TYPE_DEFAULT.
[NO]MATH_ERRNO
Controls whether or not intrinsic code is generated for math
functions that set the errno variable.
The default is /ASSUME=MATH_ERRNO, which does not allow
intrinsic code for such math functions to be generated, even
if /OPTIMIZE=INTRINSICS is in effect. Their prototypes and
call formats, however, are still checked.
[NO]POINTERS_TO_GLOBALS
Controls whether or not the compiler can safely assume that
global variables have not had their addresses taken in code
that is not visible to the current compilation.
The default, /ASSUME=POINTERS_TO_GLOBALS, assumes that global
variables have had their addresses taken in separately
compiled modules and that, in general, any pointer
dereference could be accessing the same memory as any global
variable. This is often a significant barrier to
optimization.
The /ANSI_ALIAS qualifier allows some resolution based on
data type, but /ASSUME=NOPOINTER_TO_GLOBALS provides
significant additional resolution and improved optimization
in many cases.
[NO]WEAK_VOLATILE
Affects the generation of code for assignments to objects
that are less than or equal to 16 bits in size (for example:
char, short) that have been declared as volatile.
Specifying /ASSUME=WEAK_VOLATILE directs the compiler to
generate code for volatile assignments to single bytes or
words without using the load-locked store-conditional
sequences that, in general, are required to assure volatile
data integrity when direct byte or word memory-access
instructions are not being used.
This option is intended for use in special I/O hardware
access situations, and should not generally be used.
The default is /ASSUME=NOWEAK_VOLATILE, which uses
interlocked instructions for sub-longword volatile accesses
when byte or word instructions are not enabled.
[NO]WHOLE_PROGRAM
Asserts to the compiler that except for "well-behaved library
routines," the whole program consists only of the single
object module being produced by this compilation. The
optimizations enabled by /ASSUME=WHOLE_PROGRAM include all
those enabled by /ASSUME=NOPOINTER_TO_GLOBALS, and possibly
additional optimizations as well.
The default is /ASSUME=NOWHOLE_PROGRAM.
[NO]WRITABLE_STRING_LITERALS
Stores string constants in a writable psect. Otherwise, such
constants will be placed in non-writable psect.
For /STANDARD=VAXC or /STANDARD=COMMON, the default is
/ASSUME=WRITABLE_STRING_LITERALS. For all other compiler
modes, the default is /ASSUME=NOWRITABLE_STRING_LITERALS.
9 /CHECK
/CHECK[=ALL|NONE|([NO]UNINITIALIZED_VARIABLES, [NO]BOUNDS,
[NO]POINTER_SIZE[=(option,...)], [NO]FP_MODE, [NO]ARG_INFO)]
/NOCHECK (D)
This qualifier is for use only as a debugging aid. It should not be used
to build production code without carefully assessing its performance impact
on the application in question for each platform on which the application
runs. For example, the I64-only FP_MODE check can add significant overhead
to every function in the compilation, even if the application uses little
or no floating point.
/CHECK=NONE is equivalent to /NOCHECK.
/CHECK=ALL is equivalent to
/CHECK=(UNINITIALIZED_VARIABLES,BOUNDS,POINTER_SIZE=ALL,FP_MODE,ARG_INFO).
/CHECK=UNINITIALIZED_VARIABLES initializes all automatic variables to the
value 0x7ff580057ff58005. This value is a double signaling NaN and, if
used as a floating-point value in certain double operations, causes a
floating-point trap if traps are enabled. Traps are not enabled if the
program is compiled /FLOAT=IEEE and the /IEEE value is something other than
FAST.
On I64 systems:
o Traps are not caused when values are converted to an integer type.
o The float type does not trap.
/CHECK=BOUNDS enables run-time checking of array bounds. Array-bounds
processing is performed in the following way:
o Checks are done only when accessing an array.
o Checks are not done when accessing a pointer, even if that access is
done using the subscript operator. This means that checks are not done
on arrays declared as formal parameters because they are considered
pointers in the C language. If a formal parameter is a multi-dimension
array, all bounds except the first are checked.
o If an array is accessed using the subscript operator (as either the
left or right operand), and the subscript operator is not the operand
of an address-of operator, the check is for the index to be between 0
and the number of array elements minus one, inclusive.
o If an array is accessed using the subscript operator (as either the
left or right operand), and the subscript operator is the operand of
the address-of operator, the check is for the index to be between 0 and
the number of elements in the array, inclusive.
The reason for treating the address-of case differently is that it is
common programming practice to have a loop such as:
int a[10];
int *b;
for (b = a ; b < &a[10] ; b++) { .... }
In this case, access to &a[10] is allowed even though it is outside the
range of the array.
o If the array is being accessed using pointer addition, the check is for
the value being added to be between 0 and the number of elements in the
array, inclusive.
o If the array is being accessed using pointer subtraction (that is, the
subraction of an integer value from a pointer, not the subtraction of
one pointer from another), the check is for the value being subtracted
to be between the negation of the number of elements in the array and
0, inclusive.
o In the previous three cases, an optional compile-time message (ident
SUBSCRBOUNDS2) can be enabled to detect the case where an array has
been accessed using either a constant subscript or constant pointer
arithmetic, and the element accessed is exactly one past the end of the
array.
o Bounds checking is not done for arrays declared with one element.
(Because ANSI C does not allow arrays without dimensions inside
structs, it is common practice to declare such arrays with a bounds
specifier of 1.)
In this case, an optional compile-time message (ident SUBSCRBOUNDS1)
can be enabled to detect the case where an array declared with a single
element is accessed using either a constant subscript or constant
pointer arithmetic, and the element accessed is not part of the array.
o VSI C emits run-time checks for arrays indexed by constants, even
though the compiler can and does detect this situation at compile-time.
An exeption is that no run-time check is made if the compiler can
determine that the access is valid.
o If a multi-dimension array is accessed, the compiler performs checks on
each of the subscript expressions, making sure each is within the
corresponding bound. So for the following code, the compiler checks
that both x and y are between 0 and 9. It does not check that 10 * x +
y is between 0 and 99:
int a[10][10];
int x,y,z;
x = a[x][y];
/CHECK=POINTER_SIZE directs the compiler to check 32-bit pointer values to
make sure they will fit in a 32-bit pointer. If such a value cannot be
represented by a 32-bit pointer, the run-time code signals a range error
(SS$_RANGEERR).
Use one or more of the following POINTER_SIZE option keywords to determine
the pointer-size checks you want made:
[NO]ASSIGNMENT Check whenever a 64-bit pointer is assigned to a
32-bit pointer (including use as an actual argument).
[NO]CAST Check whenever a 64-bit pointer is cast to a 32-bit
pointer.
[NO]INTEGER_CAST Check whenever a long pointer is cast to a 32-bit
integer.
[NO]PARAMETER Check all formal parameters at function startup to
make sure that all formal parameters declared to be
32-bit pointers are 32-bit values.
ALL Do all checks.
NONE Do no checks.
/CHECK=FP_MODE generates code in the prologue of every function defined in
the compilation to compare the current values of certain fields in the
processor's floating-point status register (FPSR) with the values expected
in those fields based on the command-line qualifiers with which the
function was compiled.
The values checked are the rounding mode and the trap-enable bits:
o If the rounding mode is not consistent with the value of the
/ROUNDING_MODE qualifier specified at compile time, an informational
message SYSTEM-I-FPMODERC is issued at runtime, citing the current mode
and the compile-time specified mode (Note that /ROUNDING_MODE=DYNAMIC
is treated the same as /ROUNDING_MODE=NEAREST for this purpose).
o If the trap-enable flags are not consistent with the setting of the
/IEEE qualifier (for /FLOAT=IEEE_FLOAT compilations) or with the
setting used to implement VAX floating types (for /FLOAT=G_FLOAT or
/FLOAT=D_FLOAT compilations), an informational message
SYSTEM-I-FPMODECTL is issued at run time, citing the current
trap-enable flags as well as the trap-enable flags expected by the
compilation. To identify the point of failure, you need to rerun the
program under DEBUG and issue "SET BREAK/EXCEPTION".
Note that the checking code generated for /CHECK=FP_MODE includes a
standard call to OTS$CHECK_FP_MODE within the prologue of each function,
and OTS$CHECK_FP_MODE itself assumes the standard calling conventions
(described in the OpenVMS Calling Standard). Because of this, it is not
possible to use this checking option when compiling function definitions
that have a nonstandard linkage (see #pragma linkage and #pragma
use_linkage) specifying conventional scratch registers with the PRESERVED
or NOTUSED attribute. Doing so will cause the compiler to issue the
"REGCONFLICT" E-level diagnostic at the opening brace of such function
definitions. To compile such functions successfully, the FP_MODE keyword
must be removed from the list of /CHECK= keywords.
/CHECK=ARG_INFO generates code to verify the input parameters to functions
defined in the compiled source. This code checks for datatype consistency
between the caller and its called function.
When the runtime does parameter-type checking, it categorizes the actual
type information into one of six possibilities:
VAX single-precision floating-point
VAX double-precision floating-point - D_floating
VAX double-precision floating-point - G_floating
IEEE single-precision floating-point
IEEE double-precision floating-point
none-of-the-above "bucket"
It is only a mismatch of these types that is considered. So while the
run-time code will catch a case of a VAX D_floating number passed to a
function that expects a VAX single-precision number, it will not detect the
case of an int passed to a function that expects a long double type
(because both int and long double are viewed as the same type; that is,
they both fall into the none-of-the-above bucket).
When a mismatch is found, a %SYSTEM-I-ARGTYP1 is output at runtime for each
argument slot whose type does not match the expected type.
This checking applies only to arguments passed in the first eight argument
slots, and will not check that the number of arguments passed matches the
number expected.
If the /CHECK qualifier is omitted, the default is /NOCHECK, which equates
to /CHECK=(NOUNINITIALIZED_VARIABLE, NOBOUNDS, NOPOINTER_SIZE, NOFP_MODE,
NOARGINFO).
If you specify /CHECK, the default is /CHECK=(UNINITIALIZED_VARIABLES,
BOUNDS, POINTER_SIZE=(ASSIGNMENT,PARAMETER), FP_MODE, ARG_INFO).
10 /COMMENTS
/COMMENTS={AS_IS | SPACE}
/COMMENTS=SPACE (D) (ANSI89, RELAXED, and MIA compiler modes)
/NOCOMMENTS (D) (all other compiler modes)
Governs whether or not comments appear in preprocess output files
and, if they are to appear, whether they appear themselves or are
replaced by a single space. Specify one of the following qualifier
options:
AS_IS Specifies that the comment appears in the output file.
SPACE Specifies that a single space replaces the comment in
the output file.
NOCOMMENTS specifies that nothing replaces the comment in the output
file. This can result in inadvertent token pasting.
The VSI C preprocessor might replace a comment at the end of a line
or on a line by itself with nothing, even if /COMMENTS=SPACE is
specified. Doing so does not change the meaning of the program.
The default is /COMMENTS=SPACE for the ANSI89, RELAXED, and MIA
compiler modes. The default is /NOCOMMENTS for all other compiler
modes.
Specifying just /COMMENTS defaults to /COMMENTS=AS_IS.
11 /CROSS_REFERENCE
/NOCROSS_REFERENCE (D) Specifies whether the compiler generates cross-references. If you specify /CROSS_REFERENCE, the compiler lists, for each variable referenced in the procedure, the line numbers of the lines on which the variable is referenced. You must use the /CROSS_REFERENCE qualifier with either the /SHOW=SYMBOLS or the /SHOW=BRIEF qualifiers. To obtain any type of listing, you must specify /LIST.
12 /DEBUG
/DEBUG[=(option[,...])]
/DEBUG=(TRACEBACK,NOSYMBOLS) (D)
/NODEBUG
Includes information in the object module for use by the OpenVMS
Debugger. You can select the following options:
ALL Includes all possible debugging information.
On Alpha systems, /DEBUG=ALL is equivalent to
/DEBUG=(TRACEBACK,SYMBOLS).
On VAX systems, /DEBUG=ALL is equivalent to
/DEBUG=(TRACEBACK,SYMBOLS,INLINE).
NONE Excludes any debugging information.
NOSYMBOLS Suppresses generation of symbol table records.
SYMBOLS Generates symbol table records.
NOTRACEBACK Suppresses generation of traceback records.
TRACEBACK Generates traceback records.
Specifying /DEBUG with no options is equivalent to specifying
/DEBUG=ALL.
If the /DEBUG qualifier is not specified, the default is
/DEBUG=(TRACEBACK,NOSYMBOLS).
13 /DECC
The /DECC qualifier is provided for compatibility with HP C on OpenVMS VAX systems. On OpenVMS Alpha systems, CC and CC/DECC are always equivalent.
14 /DEFINE
/DEFINE=(identifier[=definition][,...])
/NODEFINE (D)
Performs the same function as the #define preprocessor directive.
That is, /DEFINE defines a token string or macro to be substituted
for every occurrence of a given identifier in the program.
DCL converts all input to uppercase unless it is enclosed in
quotation marks.
The simplest form of a /DEFINE definition is:
/DEFINE=true
This results in a definition like the one that would result from
the following definition:
#define TRUE 1
Macro definitions must be enclosed in quotation marks as shown in
the following definition:
/DEFINE="funct(a)=a+sin(a)"
This definition produces the same results as the following
definition:
#define funct(a) a+sin(a)
When more than one /DEFINE is present on the CC command line or in
a single compilation unit, only the last /DEFINE is used.
When both /DEFINE and /UNDEFINE are present in a command line,
/DEFINE is evaluated before /UNDEFINE.
The default is /NODEFINE.
15 /DIAGNOSTICS
/DIAGNOSTICS[=file-spec]
/NODIAGNOSTICS (D)
Creates a file containing compiler diagnostic messages. The
default file extension for a diagnostics file is .DIA. The
diagnostics file is used with the DEC Language-Sensitive Editor
(LSE). To display a diagnostics file, enter the command
REVIEW/FILE=file-spec while in LSE.
16 /ENDIAN
/ENDIAN={BIG | LITTLE}
/ENDIAN=LITTLE (D)
Controls whether big or little endian ordering of bytes is carried
out in character constants.
17 /ERROR_LIMIT
/ERROR_LIMIT[=number]
/NOERROR_LIMIT
Limits the number of Error-level diagnostic messages that are
acceptable during program compilation. Compilation terminates when
the limit (number) is exceeded. /NOERROR_LIMIT specifies that
there is no limit on error messages.
The default is /ERROR_LIMIT=30, which specifies that compilation
terminates after 31 error messages.
18 /EXTERN_MODEL
/EXTERN_MODEL=option
/EXTERN_MODEL=RELAXED_REFDEF (D)
In conjunction with the /SHARE_GLOBALS qualifier, controls the
initial extern model of the compiler. Conceptually, the compiler
behaves as if the first line of the program being compiled was a
#pragma extern_model directive with the model and psect name, if
any, specified by the /EXTERN_MODEL qualifier and with the shr or
noshr keyword specified by the /SHARE_GLOBALS qualifier.
For example, assume the command line contains the following
qualifier:
/EXTERN_MODEL=STRICT_REFDEF="MYDATA"/NOSHARE
The compiler will act as if the program began with the following
line:
#pragma extern_model strict_refdef "MYDATA" noshr
See also #pragma extern_model.
The /EXTERN_MODEL qualifier takes the following options, which have
the same meaning as for the #pragma extern_model directive:
COMMON_BLOCK
RELAXED_REFDEF
STRICT_REFDEF
STRICT_REFDEF="NAME"
GLOBALVALUE
The default model on VSI C is relaxed/refdef with the noshare
attribute. This is different from the model used by VAX C, which
is common block, share.
19 /FIRST_INCLUDE
FIRST_INCLUDE=(file[,...])
NOFIRST_INCLUDE (D)
Includes the specified files before any source files. This
qualifier corresponds to the Tru64 UNIX -FI switch.
This qualifier is useful if you have command lines to pass to the C
compiler that are exceeding the DCL command-line length limit.
Using the /FIRST_INCLUDE qualifier can help solve this problem by
replacing lengthy /DEFINE and /WARNINGS qualifiers with #define and
#pragma message directives placed in a /FIRST_INCLUDE file.
The default is NOFIRST_INCLUDE.
20 /FLOAT
/FLOAT=option
Controls the format of floating-point variables.
Options:
D_FLOAT Double variables are represented in D_FLOAT
format. The __D_FLOAT macro is predefined.
G_FLOAT Double variables are represented in G_FLOAT
format. The __G_FLOAT macro is predefined.
IEEE_FLOAT Float and double variables are represented in IEEE
floating-point format (S_FLOAT and T_FLOAT,
respectively). The __IEEE_FLOAT macro or _IEEE_FP
macro (if/IEEE_MODE=DENORM_RESULTS) is predefined.
See also the /IEEE_MODE qualifier for selecting an
IEEE floating-point mode.
If /IEEE_MODE is not specified, the default
behavior is /IEEE_MODE=FAST for Alpha systems and
DENORM_RESULTS for I64 systems.
On OpenVMS I64 systems, /FLOAT=IEEE_FLOAT is the default
floating-point representation. The _IEEE_FP macro is predefined by
default, IEEE format data is assumed, and IEEE floating-point
instructions are used. There is no hardware support for
floating-point representations other than IEEE, although you can
specify the /FLOAT=D_FLOAT or /FLOAT=G_FLOAT compiler option.
These VAX floating-point formats are supported in the I64 compiler
by generating run-time code that converts VAX floating-point
formats to IEEE format to perform arithmetic operations, and then
converts the IEEE result back to the appropriate VAX floating-point
format. This imposes additional run-time overhead and some loss of
accuracy compared to performing the operations in hardware on Alpha
and VAX systems. The software support for the VAX formats is
provided to meet an important functional compatibility requirement
for certain applications that need to deal with on-disk binary
floating-point data.
On I64 systems, the default for /IEEE_MODE is DENORM_RESULTS. This
is a change from the default of /IEEE_MODE=FAST on Alpha systems.
This means that by default, floating-point operations may silently
generate values that print as Infinity or Nan (the
industry-standard behavior), instead of issuing a fatal run-time
error as they would when using VAX floating-point format or
/IEEE_MODE=FAST. Also, the smallest-magnitude nonzero value in
this mode is much smaller because results are allowed to enter the
denormal range instead of being flushed to zero as soon as the
value is too small to represent with normalization.
The conversion of VAX floating-point formats to IEEE single and
IEEE double floating-point types on the Intel Itanium architecture
is a transparent process that will not impact most applications.
All you need to do is recompile your application. Because IEEE
floating-point format is the default, unless your build explicitly
specifies VAX floating-point format options, a simple rebuild for
I64 systems will use the native IEEE formats directly. For the
large class of programs that do not directly depend on the VAX
formats for correct operation, this is the most desirable way to
build for I64 systems.
When you compile an OpenVMS application that specifies an option to
use VAX floating-point on the Itanium architecture, the compiler
automatically generates code for converting floating-point formats.
Whenever the application performs a sequence of arithmetic
operations, this code does the following:
o Converts VAX floating-point formats to either IEEE single or
IEEE double floating-point formats.
o Performs arithmetic operations in IEEE floating-point
arithmetic.
o Converts the resulting data from IEEE formats back to VAX
formats.
Where no arithmetic operations are performed (VAX float fetches
followed by stores), no conversion will occur. The code handles
such situations as moves.
VAX floating-point formats have the same number of bits and
precision as their equivalent IEEE floating-point formats. For
most applications the conversion process will be transparent and
thus a non-issue.
In a few cases, arithmetic calculations might have different
results because of the following differences between VAX and IEEE
formats:
o Values of numbers represented
o Rounding rules
o Exception behavior
These differences might cause problems for applications that do any
of the following:
o Depend on exception behavior
o Measure the limits of floating-point behaviors
o Implement algorithms at maximal processor-specific accuracy
o Perform low-level emulations of other floating-point processors
o Use direct equality comparisons between floating-point values,
instead of appropriately ranged comparisons (a practice that is
extremely vulnerable to changes in compiler version or compiler
options, as well as architecture)
You can test an application's behavior with IEEE floating-point
values by compiling it on an OpenVMS Alpha system using
/FLOAT=IEEE_FLOAT/IEEE_MODE=DENORM. If that produces acceptable
results, simply build the application on the I64 system using the
same qualifier.
If you determine that simply recompiling with an /IEEE_MODE
qualifier is not sufficient because your application depends on the
binary representation of floating-point values, then first try
building for your I64 system by specifying the VAX floating-point
option that was in effect for your VAX or Alpha build. This causes
the representation seen by your code and on disk to remain
unchanged, with some additional runtime cost for the conversions
generated by the compiler. If this is not an efficient approach
for your application, you can convert VAX floating-point binary
data in disk files to IEEE floating-point formats before moving the
application to an I64 system.
21 /GRANULARITY
/GRANULARITY=option
/GRANULARITY=QUADWORD (D)
Determines how much memory to effectively cache for memory
reference by the combination of the compiler and the underlying
system. For example, quadword granularity may require that the
system cache quadword values in registers. If access to data in
the same granularity unit occurs simultaneously, corruption (by
storing back stale values) can occur.
Granularity has two aspects: references inside a particular data
segment and references between data segments.
The options are:
o BYTE
o LONGWORD
o QUADWORD
The default is /GRANULARITY=QUADWORD.
22 /IEEE_MODE
/IEEE_MODE=option
/IEEE_MODE=DENORM_RESULTS (D)
Selects the IEEE floating-point mode to be used.
Options:
FAST During program execution, only finite values (no
infinities, NaNs, or denorms) are created.
Exceptional conditions, such as floating point
overflow and divide by zero, are fatal.
UNDERFLOW_TO_ZERO Generate infinities and NaNs. Flush
denormalized results and underflow to zero
without exceptions.
DENORM_RESULTS Same as UNDERFLOW_TO_ZERO, except that denorms
are generated. This is the default for I64
systems.
INEXACT Same as DENORM_RESULTS, except that inexact
values are trapped. This is the slowest mode.
On Alpha sytems, the /IEEE_MODE qualifier generally has its
greatest effect on the generated code of a compilation. When calls
are made between functions compiled with different /IEEE_MODE
qualifiers, each function produces the /IEEE_MODE behavior with
which it was compiled.
On I64 systems, the /IEEE_MODE qualifier primarily affects only the
setting of a hardware register at program startup. In general, the
/IEEE_MODE behavior for a given function is controlled by the
/IEEE_MODE option specified on the compilation that produced the
main program: the startup code for the main program sets the
hardware register according the command-line qualifiers used to
compile the main program.
When applied to a compilation that does not contain a main program,
the /IEEE_MODE qualifier does have some effect: it might affect
the evaluation of floating-point constant expressions, and it is
used to set the EXCEPTION_MODE used by the math library for calls
from that compilation. But the qualifier has no effect on the
exceptional behavior of floating-point calculations generated as
inline code for that compilation. Therefore, if floating-point
exceptional behavior is important to an application, all of its
compilations, including the one containing the main program, should
be compiled with the same /IEEE_MODE setting.
Even on Alpha systems, the particular setting of
/IEEE_MODE=UNDERFLOW_TO_ZERO has this characteristic: its primary
effect requires the setting of a runtime status register, and so it
needs to be specified on the compilation containing the main
program in order to be effective in other compilations.
23 /INCLUDE_DIRECTORY
/INCLUDE_DIRECTORY=(place[,...])
/NOINCLUDE_DIRECTORY (D)
Provides similar functionality to the -I option of the cc command
on DIGITAL UNIX systems. This qualifier allows you to specify
additional places to search for include files. A place can be one
of the following:
o OpenVMS file-spec to be used as a default file-spec to RMS file
services (example: DISK$:[directory])
o UNIX style pathname in quotation marks (example: "/sys")
o Empty string ("")
If one of the places is specified as an empty string, the compiler
is not to search any of its conventionally-named places
(DECC$USER_INCLUDE, DECC$SYSTEM_INCLUDE, DECC$LIBRARY_INCLUDE,
SYS$COMMON:[DECC$LIB.INCLUDE.*], DECC$TEXT_LIBRARY,
DECC$RTLDEF.TLB, SYS$STARLET_C.TLB). It searches only places
specified explicitly on the command line by the /INCLUDE_DIRECTORY
and /LIBRARY qualifiers (or by the location of the primary source
file, depending on the /NESTED_INCLUDE_DIRECTORY qualifier).
The basic search order depends on the form of the header-file name
(after macro expansion). Additional aspects of the search order
are controlled by other command-line qualifiers and the presence or
absence of logical name definitions.
All forms of header-file inclusion are affected:
o In quotes (example: "stdio.h")
o In angle brackets (example: <stdio.h>)
o An identifier to be treated as a text-module name (example:
stdio)
Except where otherwise specified, searching a "place" means that
the string designating the place is used as the default file-spec
in a call to an RMS system service (for example, $SEARCH/$PARSE),
with a file-spec consisting of the name in the #include directive
without enclosing delimiters. The search terminates successfully
as soon as a file can be opened for reading.
For the quoted form, the search order is:
1. One of the following:
o If /NESTED_INCLUDE_DIRECTORY=INCLUDE_FILE (the default) is
in effect, search the directory containing the file in
which the #include directive itself occurred. The meaning
of "directory containing" is: the RMS "resultant string"
obtained when the file in which the #include occurred was
opened, except that the filename and subsequent components
are replaced by the default file type for headers (".H", or
just "." if /ASSUME=NOHEADER_TYPE_DEFAULT is in effect).
The "resultant string" will not have translated any
concealed device logical.
o If /NESTED_INCLUDE_DIRECTORY=PRIMARY_FILE is in effect,
search the default file type for headers using the context
of the primary source file. This means that just the file
type (".H" or ".") is used for the default file-spec but,
in addition, the chain of "related file-specs" used to
maintain the sticky defaults for processing the next
top-level source file is applied when searching for the
include file.
o If /NESTED_INCLUDE_DIRECTORY=NONE is in effect, this entire
step (Step 1) is bypassed.
2. Search the places specified in the /INCLUDE_DIRECTORY
qualifier, if any. A place that can be parsed successfuly as
an OpenVMS file-spec and that does not contain an explicit file
type or version specification is edited to append the default
header file type specification (".H" or ".").
A place containing a "/" character is considered to be a
UNIX-style name. If the name in the #include directive also
contains a "/" character that is not the first character and is
not preceded by a "!" character (that is, it is not an absolute
UNIX-style pathname), then the name in the #include directive
is appended to the named place, separated by a "/" character,
before applying the decc$to_vms pathname translation function.
3. If "DECC$USER_INCLUDE" is defined as a logical name, search
"DECC$USER_INCLUDE:.H", or just "DECC$USER_INCLUDE:." if
/ASSUME=NOHEADER_TYPE_DEFAULT is in effect.
4. If the file is not found, follow the steps for the
angle-bracketed form of inclusion.
For the angle-bracketed form, the search order is:
1. Search the place "/". This is a UNIX-style name that can
combine only with UNIX names specified explicitly in the
#include directive. It causes a specification like
<sys/types.h> to be considered first as /sys/types.h, which is
translated to SYS:TYPES.H.
2. Search the places specified in the /INCLUDE_DIRECTORY
qualifier, exactly as in Step 2 for the quoted form of
inclusion.
3. If "DECC$SYSTEM_INCLUDE" is defined as a logical name, search
"DECC$SYSTEM_INCLUDE:.H", or just "DECC$SYSTEM_INCLUDE:." if
/ASSUME=NOHEADER_TYPE_DEFAULT is in effect.
4. If "DECC$LIBRARY_INCLUDE" is defined as a logical name and
"DECC$SYSTEM_INCLUDE" is NOT defined as a logical name, search
"DECC$LIBRARY_INCLUDE:.H", or just "DECC$LIBRARY_INCLUDE:." if
/ASSUME=NOHEADER_TYPE_DEFAULT is in effect.
5. If neither "DECC$LIBRARY_INCLUDE" nor "DECC$SYSTEM_INCLUDE" are
defined as logical names, then search the default list of
places for plain text-file copies of compiler header files as
follows:
SYS$COMMON:[DECC$LIB.INCLUDE.DECC$RTLDEF]*.H
SYS$COMMON:[DECC$LIB.INCLUDE.SYS$STARLET_C]*.H
If the file is not found, perform the text library search
described in the next step.
6. Extract the simple filename and file type from the #include
specification and use the filename as the module name to search
a list of text libraries associated with that file type.
For any file type, the initial text libraries searched consist
of those named on the command line with /LIBRARY qualifiers.
If the /INCLUDE_DIRECTORY qualifier contained an empty string,
no further text libraries are searched. Otherwise,
DECC$TEXT_LIBRARY is searched for all file types.
If "DECC$LIBRARY_INCLUDE" is defined as a logical name, then no
further text libraries are searched. Otherwise, the subsequent
libraries searched for each file type are:
For ".H" or ".":
SYS$LIBRARY:DECC$RTLDEF.TLB
SYS$LIBRARY:SYS$STARLET_C.TLB
For any file type other then ".H" or ".":
SYS$LIBRARY:SYS$STARLET_C.TLB
7. If the previous step fails, search:
SYS$LIBRARY:.H
Under /ASSUME=NOHEADER_TYPE_DEFAULT, the default file type is
modified as usual.
For the text-module (non-portable) form of #include:
The name can only be an identifier. It, therefore, has no
associated "file type". The identifier is used as a module name to
search the following:
1. The text libraries named on the command line with /LIBRARY
qualifiers, in left-to-right order.
2. The following list of text libraries in the order shown
(unless the /INCLUDE_DIRECTORY qualifier contains an empty
string, in which case no further text libraries are
searched):
DECC$TEXT_LIBRARY
SYS$LIBRARY:DECC$RTLDEF.TLB
SYS$LIBRARY:SYS$STARLET_C.TLB
24 /L_DOUBLE_SIZE
/L_DOUBLE_SIZE=option
/L_DOUBLE_SIZE=128 (D)
Determines how the compiler interprets the long double type. The
qualifier options are 64 and 128.
/L_DOUBLE_SIZE=64 treats all long double references as G_FLOAT,
D_FLOAT, or T_FLOAT, depending on the value of the /FLOAT
qualifier.
/L_DOUBLE_SIZE=128 treats all long double references as X_FLOAT.
25 /LIBRARY
Indicates that the associated input file is a library containing source text modules specified in #include directives. The compiler searches the specified library for all #include module names that are not enclosed in angle brackets or quotation marks. The name of the library must be concatenated with the file specification using a plus sign. For example: CC DATAB/LIBRARY+APPLIC
26 /LINE_DIRECTIVES
/LINE_DIRECTIVES (D)
/NOLINE_DIRECTIVES
Controls whether or not #line directives appear in preprocess
output files.
27 /LIST
/LIST[=file-spec] (Batch default)
/NOLIST (Interactive default)
Controls whether a listing file is produced. The default output
file extension is .LIS.
28 /MACHINE_CODE
/MACHINE_CODE
/NOMACHINE_CODE (D)
Controls whether the listing produced by the compiler includes the
machine language code generated during the compilation. If you use
this qualifier you also need to use the /LIST qualifier.
29 /MAIN=POSIX_EXIT
/MAIN
/NOMAIN (D)
Directs the compiler to call __posix_exit instead of exit when
returning from main.
30 /MEMBER_ALIGNMENT
/MEMBER_ALIGNMENT (D)
/NOMEMBER_ALIGNMENT
Directs the compiler to naturally align data structure members.
This means that data structure members are aligned on the next
boundary appropriate to the type of the member, rather than on the
next byte. For instance, a long variable member is aligned on the
next longword boundary; a short variable member is aligned on the
next word boundary.
Any use of the #pragma member_alignment or #pragma
nomember_alignment directives within the source code overrides the
setting established by this qualifier. Specifying
/NOMEMBER_ALIGNMENT causes data structure members to be
byte-aligned (with the exception of bit-field members).
For 64-bit systems, the default is /MEMBER_ALIGNMENT.
For OpenVMS VAX systems, the default is /NOMEMBER_ALIGNMENT.
31 /MMS_DEPENDENCIES
/MMS_DEPENDENCIES[=(option[,option)]]
/NOMMS_DEPENDENCIES (D)
Directs the compiler to produce a dependency file. Dependency
files list all source files and included files for each object
module. Note that the /OBJECT qualifier has no impact on the
dependency file. The dependency file format is:
object_file_name :<tab><source file name>
object_file_name :<tab><full path to first include file>
object_file_name :<tab><full path to second include file>
You can specify none, one, or all of the following qualifier
options:
FILE[=filespec] Specifies where to save the dependency
file. The default file extension for a
dependency file is .mms. Other than using
a different default extension, this
qualifier uses the same procedure that
/OBJECT and /LIST use for determining the
name of the output file.
SYSTEM_INCLUDE_FILES Specifies whether or not to include
dependency information about system include
files (that is, those included with
#include <filename>). The default is to
include dependency information about system
include files.
Note that the /OBJECT qualifier has no
impact on the dependency file.
TARGET=string Specifies the target that appears in the
output .mms file. The default is TARGET=""
in which case the target is the source file
name with an .OBJ extension, as in previous
versions of the compiler. If you specify
any string other than .OBJ, that string is
used as the target. For the special case
of .OBJ, the compiler uses the name of the
object file, stripped of any version number
and path, for the MMS target.
32 /NAMES
/NAMES=(option1,option2)
/NAMES=(UPPERCASE,TRUNCATED) (D)
Option1 converts all definitions and references of external symbols
and psects to the specified case:
o /NAMES=UPPERCASE (default) converts to uppercase.
o /NAMES=AS_IS leaves the case unchanged.
Option2 controls whether or not long external names greater than 31
characters get truncated or shortened:
o /NAMES=TRUNCATED (default) truncates long external names
o /NAMES=SHORTENED shortens long external names.
A shortened name consists of the first 23 characters of the
name followed by a 7-character Cyclic Redundancy Check (CRC)
computed by looking at the full name, and then a "$".
The CRC is generated by calling lib$crc as follows:
long initial_crc = -1;
crc_result = lib$crc(good_crc_table,
&initial_crc,
<descriptor of string to CRC>);
where good_crc_table is:
/*
** Default CRC table:
**
** This table was taken from Ada's generalized name generation
** algorithm. It represents a commonly used CRC polynomial
** known as AUTODIN-II. For more information see the VAX
** Macro OpenVMS documentation under the CRC VAX instruction.
*/
static const unsigned int good_crc_table[16] =
{0x00000000, 0x1DB71064, 0x3B6E20C8, 0x26D930AC,
0x76DC4190, 0x6B6B51F4, 0x4DB26158, 0x5005713C,
0xEDB88320, 0xF00F9344, 0xD6D6A3E8, 0xCB61B38C,
0x9B64C2B0, 0x86D3D2D4, 0xA00AE278, 0xBDBDF21C};
By default, the compiler issues a warning and truncates the name to
31 characters.
The /NAMES qualifier does not affect the names of the $ABS$, $BSS$,
$CODE$, $DATA$, $LINK$, $LITERAL$, and $READONLY$ psects.
33 /NESTED_INCLUDE_DIRECTORY
/NESTED_INCLUDE_DIRECTORY[=option]
/NESTED_INCLUDE_DIRECTORY=INCLUDE_FILE (D)
Controls the first step in the search algorithm the compiler uses
when looking for files included using the quoted form of the
#include preprocessing directive: #include "file-spec"
/NESTED_INCLUDE_DIRECTORY has the following options:
PRIMARY_FILE Directs the compiler to search the default file type
for headers using the context of the primary source
file (the .C file). This means that just the file
type (".H" or ".") is used for the default file-spec
but, in addition, the chain of "related file-specs"
used to maintain the sticky defaults for processing
the next top-level source file is applied when
searching for the include file.
INCLUDE_FILE Directs the compiler to search the directory
containing the file in which the #include directive
itself occurred. The meaning of "directory
containing" is: the RMS "resultant string" obtained
when the file in which the #include occurred was
opened, except that the filename and subsequent
components are replaced by the default file type for
headers (".H", or just "." if
/ASSUME=NOHEADER_TYPE_DEFAULT is in effect). The
"resultant string" will not have translated any
concealed device logical.
NONE Directs the compiler to skip the first step of
processing #include "file.h" directives. The
compiler starts its search for the include file in
the /INCLUDE_DIRECTORY directories.
See also /INCLUDE_DIRECTORY.
34 /OBJECT
/OBJECT[=file-spec] (D)
/NOOBJECT
Controls whether the compiler produces an output object module.
The default output file extension is .OBJ.
Note that the /OBJECT qualifier has no impact on the output file of
the /MMS_DEPENDENCIES qualifier.
35 /OPTIMIZE
/OPTIMIZE[=option] (D)
/NOOPTIMIZE
Controls the level of code optimization that the compiler performs.
/OPTIMIZE has the following options:
LEVEL=n Selects the level of optimization. Specify an
integer from 0 (no optimization) to 5 (full
optimization, including pipelining).
[NO]INLINE[=keyword] Provides inline expansion of functions that
yield optimized code when they are expanded. You
can specify one of the following keywords:
NONE No inlining is done, even if requested
by the language syntax.
/OPTIMIZE=INLINE=NONE is equivalent to
/OPTIMIZE=NOINLINE.
MANUAL Inlines only those function calls for
which the program explicitly requests
inlining.
AUTOMATIC Inlines all of the function calls in
the MANUAL category, plus additional
calls that the compiler determines are
appropriate on this platform. On
Alpha systems, this is the same as
SIZE; on I64 systems, this is the same
as SPEED. AUTOMATIC is the default.
SIZE Inlines all of the function calls in
the MANUAL category plus any
additional calls that the compiler
determines would improve run-time
performance without significantly
increasing the size of the program.
SPEED Performs more aggressive inlining for
run-time performance, even when it
might significantly increase the size
of the program.
ALL Inlines every call that can be inlined
while still generating correct code.
Recursive routines, however, will not
cause an infinite loop at compile
time.
Note that /OPT=INLINE=ALL is not
recommended for general use, because
it performs very aggressive inlining
and can cause the compiler to exhaust
virtual memory or take an unacceptably
long time to compile
[NO]INTRINSICS Controls whether or not certain functions are
handled as intrinsic functions without explicitly
enabling each of them as an intrinsic through the
#pragma intrinsic preprocessor directive.
Functions that can be handled as intrinsics are:
Main Group - ANSI:
abs atanl atan2l ceill cosl floorf memcpy sinf
atan atan2 ceil cos fabs floorl memmove sinl
atanf atan2f ceilf cosf floor labs memset strcpy
sin strlen
Main Group - Non-ANSI:
alloca atand2 bzero sind
atand bcopy cosd
Printf functions:
fprintf printf sprintf
Printf non-ANSI:
snprintf
ANSI math functions that set errno,
thereby requiring /ASSUME=NOMATH_ERRNO:
acos asinf coshl log log10f powl sqrt tanf
acosf asinl exp logf log10l sinh sqrtf tanl
acosl cosh expf logl pow sinhf sqrtl tanh
asin coshf expl log10 powf sinhl tan tanhf
tanhl
Non-ANSI math functions that set errno,
thereby requiring /ASSUME=NOMATH_ERRNO:
log2
tand
The /OPTIMZE=INTRINSICS qualifier works together
with /OPTIMIZE=LEVEL=n and some other qualifiers
to determine how intrinsics are handled:
o If the optimization level specified is less
than 4, the intrinsic-function prototypes and
call formats are checked, but normal run-time
calls are still made.
o If the optimization level is 4 or higher,
intrinsic code is generated.
o If /STANDARD=ANSI89 is specified,
non-ANSI-Standard functions are not
automatically intrinsic and do not even have
their prototypes checked. They are only
checked if the non-ANSI-Standard functions
are made intrinsic through #pragma intrinsic.
o Intrinsic code is not generated for math
functions that set the errno variable unless
/ASSUME=NOMATH_ERRNO is specified. Such math
functions, however, do have their prototypes
and call formats checked.
The default is /OPTIMIZE=INTRINSICS, which turns
on this handling.
To turn it off, specify /NOOPTIMIZE or
/OPTIMIZE=NOINTRINSICS.
[NO]PIPELINE Controls Activation of the software pipelining
optimization. The software pipelining
optimization applies instruction scheduling to
certain innermost loops, allowing instructions
within a loop to "wrap around" and execute in a
different iteration of the loop. This can reduce
the impact of long-latency operations, resulting
in faster loop execution.
Software pipelining can be more effective when
you combine /OPTIMIZE=PIPELINE with the
appropriate /OPTIMIZE=TUNE keyword for the target
Alpha processor generation.
Software pipelining also enables the prefetching
of data to reduce the impact of cache misses.
Software pipelining is a subset of the
optimizations activated by optimization level 5.
To determine whether using /OPTIMIZE=PIPELINE
benefits your particular program, you should time
program execution for the same program (or
subprogram) compiled with and without software
pipelining.
For programs that contain loops that exhaust
available registers, longer execution times can
result with optimization level 5, requiring use
of /OPTIMIZE=UNROLL=n to limit loop unrolling.
UNROLL=n Controls loop unrolling done by the optimizer.
UNROLL=n means to unroll loop bodies n times.
The default is UNROLL=0, which means the
optimizer will use its own default unroll amount.
TUNE=keyword Selects processor-specific instruction tuning for
implementations of the Alpha or Itanium
architecture. Regardless of the setting of the
/OPTIMIZE=TUNE flag, the generated code will run
correctly on all implementations of the Alpha
architecture. Tuning for a specific
implementation can provide improvements in
run-time performance. Code tuned for a specific
target might run slower on another target.
For Itanium systems, you can specify the
following keyword:
ITANIUM2 Generates code for the Intel Itanium 2 processor.
The default is /OPTIMIZE, which is equivalent to
/OPTIMIZE=(INLINE=AUTOMATIC,LEVEL=4,UNROLL=0,TUNE=GENERIC).
36 /PDSC_MASK
/PDSC_MASK=option
Forces the compiler to set the PDSC$V_EXCEPTION_MODE field of the
procedure descriptor for each function in the compilation unit to
the specified value, regardless of the setting of any other
qualifiers.
Ordinarily the PDSC$V_EXCEPTION_MODE field gets set automatically
by the compiler, depending on which /IEEE mode is specified on the
command line. The /PDSC_MASK qualifier overrides the /IEEE_MODE
qualifer setting of this field.
NOTE:
The /PDSC_MASK qualifier is a low-level systems-programming
feature that is seldom necessary. Its usage can produce object
modules that do not conform to the OpenVMS common language
environment and, within C, it can produce non-standard and
seemingly incorrect floating-point behaviors at runtime.
The qualifier option keywords are exactly the allowed values
defined in the OpenVMS Calling Standard for this field, stripped of
the PDSC$V_EXCEPTION_MODE prefix (for example, /PDSC_MASK=SIGNAL
sets the field to PDSC$V_EXCEPTION_MODE_SIGNAL).
The qualifier options are:
SIGNAL Maps to PDSC$K_EXCEPTION_MODE_SIGNAL. Raise
exceptions for all except underflow (which
equals 0).
SIGNAL_ALL Maps to PDSC$K_EXCEPTION_MODE_SIGNAL_ALL.
Raise exceptions for all.
SILENT Maps to PDSC$K_EXCEPTION_MODE_SILENT. Raise
no exceptions. Create only finite values:
no infinities, no denorms, no NaNs. The
function result or errno needs to be
examined.)
FULL_IEEE Maps to PDSC$K_EXCEPTION_MODE_FULL_IEEE.
Raise no exceptions except as controlled by
separate IEEE exception-enabling bits.
Create exceptional values according to the
IEEE standard.
CALLER Maps to PDSC$K_EXCEPTION_MODE_CALLER.
Emulate the same mode as the caller.
In the absence the /PDSC_MASK qualifier, the compiler sets the
PDSC$V_EXCEPTION_MODE field automatically, depending on the
/IEEE_MODE qualifier setting:
o If /IEEE_MODE is specified with UNDERFLOW_TO_ZERO,
DENORM_RESULTS, or INEXACT, then /PDSC_MASK is set to
FULL_IEEE.
o In all other cases, /PDSC_MASK is set to SILENT. This setting
differs from the calling-standard-specified default of SIGNAL
used by Fortran, and is largly responsible for the ANSI C
conforming behavior of the math library when called from C or
C++ programs.
37 /PLUS_LIST_OPTIMIZE
/PLUS_LIST_OPTIMIZE
/NOPLUS_LIST_OPTIMIZE (D)
Provides improved optimization and code generation across file
boundaries that would not be available if the files were compiled
seperately.
When you specify /PLUS_LIST_OPTIMIZE on the command line in
conjunction with a series of file specifications separated by plus
signs, the compiler does not concatenate each of the specified
source files together. Instead, each file is treated separately
for purposes of parsing, except that the compiler will issue
diagnostics about conflicting external declarations and function
definitions that occur in different files. For purposes of code
generation, the compiler treats the files as one application.
The default is /NOPLUS_LIST_OPTIMIZE.
38 /POINTER_SIZE
/POINTER_SIZE=option
/NOPOINTER_SIZE (D)
Controls whether or not pointer-size features are enabled, and
whether pointers are 32 bits or 64 bits long.
The default is /NOPOINTER_SIZE, which disables pointer-size
features, such as the ability to use #pragma pointer_size, and
directs the compiler to assume that all pointers are 32-bit
pointers. This default represents no change over previous versions
of the compiler.
You must specify one of the following options:
SHORT The compiler assumes 32-bit pointers.
32 Same as SHORT.
LONG[=ARGV] The compiler assumes 64-bit pointers. If the ARGV option to
LONG or 64 is present, the main argument argv will be an
array of long pointers instead of an array of short pointers.
64[=ARGV] Same as LONG.
Specifying /POINTER_SIZE=32 directs the compiler to assume that all
pointers are 32-bit pointers. But unlike the default of
/NOPOINTER_SIZE, /POINTER_SIZE=32 enables use of the #pragma
pointer_size long and #pragma pointer_size short preprocessor
directives to control pointer size throughout your program.
Specifying /POINTER_SIZE=64 directs the compiler to assume that all
pointers are 64-bit pointers, and also enables use of the #pragma
pointer_size directives.
39 /PRECISION
/PRECISION={SINGLE | DOUBLE}
Controls whether floating-point operations on float variables are
performed in single or double precision.
The default is /PRECISION=DOUBLE for /STANDARD=VAXC and
/STANDARD=COMMON modes.
The default is /PRECISION=SINGLE for /STANDARD=ANSI89 and
/STANDARD=RELAXED modes.
40 /PREFIX_LIBRARY_ENTRIES
Controls the VSI C RTL name prefixing.
The VSI C Run-Time Library (RTL) shareable image (DECC$SHR.EXE)
resides in IMAGELIB.OLB with a DECC$ prefix for its entry points.
Every external name in IMAGELIB.OLB has a DECC$ prefix, and,
therefore, has an OpenVMS conformant name space (a requirement for
inclusion in IMAGELIB). The /[NO]PREFIX_LIBRARY_ENTRIES qualifier
lets you control the VSI C RTL name prefixing.
The qualifier options are:
EXCEPT=(name,...) The names specified are not prefixed.
ALL_ENTRIES All C RTL names, as well as C99 names not
supported by the underlying C RTL, are
prefixed.
ANSI_C89_ENTRIES Only ANSI library names are prefixed.
C99_ENTRIES Only ISO C Standard 99 (C99) library names
are prefixed. These are a superset of the
external names prefixed under
/PREFIX=ANSI_C89_ENTRIES and a subset of
those prefixed under /PREFIX=ALL_ENTRIES.
Note: The compiler prefixes C99 entries
based on their inclusion in the standard, not
on the availability of their implementations
in the run-time library. So calling
functions introduced in C99 that are not yet
implemented in the VSI C RTL will produce
unresolved references to symbols prefixed by
DECC$ when the program is linked. In
addition, the compiler issues a
CC-W-NOTINCRTL message when it prefixes a
name that is not in the current C RTL.
RTL="name" Generates references to the C RTL indicated
by the "name" keyword. If no keyword is
specified, then references to the VSI C RTL
are generated by default. To use an
alternate RTL, see its documentation for the
name to use.
If you want no names prefixed, specify /NOPREFIX_LIBRARY_ENTRIES.
For /STANDARD=ANSI89, the default is /PREFIX=ANSI_C89_ENTRIES.
For /STANDARD=C99, the default is /PREFIX=C99_ENTRIES.
For all other compiler modes, the default is /PREFIX=ALL.
41 /PREPROCESS_ONLY
/PREPROCESS_ONLY[=filename]
/NOPREPROCESS_ONLY (D)
Causes the compiler to perform only the actions of the preprocessor
phase and write the resulting processed text out to a file.
Furthermore, no object file or analysis file can be produced.
42 /PROTOTYPE
/PROTOTYPE[=(option[,...])]
/NOPROTOTYPE (D)
Creates an output file containing function prototypes for all
global functions defined in the module being compiled.
The qualifier options are:
[NO]IDENTIFIERS Indicates that identifier names are to be
included in the prototype declarations that
appear in the output file. The default is
NOIDENTIFIERS.
[NO]STATIC_FUNCTIONS Indicates that prototypes for static function
definitions are to be included in the output
file. The default is NOSTATIC_FUNCTIONS.
FILE=filename Specifies the output file name. When not
specified, the output file name has the same
defaults as the listing file, except that the
file extension is .CH instead of .LIS.
The default is /NOPROTOTYPES.
43 /PSECT_MODEL
/PSECT_MODEL=MULTILANGUAGE
/PSECT_MODEL=NOMULTILANGUAGE (D)
Controls whether the compiler allocates the size of overlaid psects
to ensure compatibility when the psect is shared by code created by
other HP compilers.
The problem this switch solves can occur when a psect generated by
a Fortran COMMON block is overlaid with a psect consisting of a C
struct. Because Fortran COMMON blocks are not padded, if the C
struct is padded, the inconsistent psect sizes can cause linker
error messages.
Compiling with /PSECT_MODEL=MULTILANGUAGE ensures that VSI C uses a
consistent psect size allocation scheme. The corresponding Fortran
switch is /ALIGN=COMMON=[NO]MULTILANGUAGE.
The default is /PSECT=NOMULTILANGUAGE, which is the old default
behavior of the compiler, and is sufficient for most applications.
44 /REENTRANCY
/REENTRANCY=option
/REENTRANCY=TOLERANT (D)
Controls the type of reentrancy that reentrant VSI C RTL routines
will exhibit.
(See also the decc$set_reentrancy RTL routine.)
This qualifier is for use only with a module containing the main
routine.
The reentrancy level is set at run time according to the
/REENTRANCY qualifier specified while compiling the module
containing the main routine.
You can specify one of the following options:
AST Uses the __TESTBITSSI builtin to perform simple
locking around critical sections of RTL code, and
may additionally disable asynchronous system
traps (ASTs) in locked region of codes. This
type of locking should be used when AST code
contains calls to VSI C RTL I/O routines.
MULTITHREAD Designed to be used in conjunction with the
DECthreads product. It performs DECthreads
locking and never disables ASTs.
NONE Gives optimal performance in the RTL, but does
absolutely no locking around critical sections of
RTL code. It should only be used in a single
threaded environment when there is no chance that
the thread of execution will be interrupted by an
AST that would call the VSI C RTL.
TOLERANT Uses the __TESTBITSSI builtin to perform simple
locking around critical sections of RTL code, but
ASTs are not disabled. This type of locking
should be used when ASTs are used and must be
delivered immediately. This is also the default
reentrancy type.
45 /REPOSITORY
Specifies a repository for the compiler to store shortened external name information. When /NAMES=SHORTENED is specified, the compiler stores to the repository any external names that were shortened. The demangler utility can then be used to map the shortened names back to the names used in the original C program. By default, the qualifier is not active unless /NAMES=SHORTENED has been specified, in which case the default is /REPOSITORY=[.CXX_REPOSITORY]. Note that the default name of the repository is the same as that used by the HP C++ compiler for decoding mangled names. This is intentional. A C++ mangled name cannot match a shortened name, so a single repository can be used by both the VSI C and HP C++ compilers.
46 /ROUNDING_MODE
/ROUNDING_MODE=option
/ROUNDING_MODE=NEAREST (D)
For /FLOAT=IEEE_MODE, the /ROUNDING_MODE qualifier lets you select
one of the following IEEE rounding modes:
o NEAREST (default)
o DYNAMIC
o MINUS_INFINITY
o CHOPPED
For /FLOAT=G_FLOAT or /FLOAT=D_FLOAT, rounding defaults to
/ROUNDING_MODE=NEAREST, with no other choice of rounding mode.
47 /SHARE_GLOBALS
/NOSHARE_GLOBALS (D)
Performs two functions:
o Controls whether the compiler treats declarations of objects
with the globaldef keyword as shared or not shared.
o Controls whether the initial extern_model is shared or not
shared (for those extern_models where it is allowed). The
initial extern_model of the compiler is a fictitious pragma
constructed from the settings of the /EXTERN_MODEL and
/SHARE_GLOBALS.
The default value is /NOSHARE_GLOBALS. This default value is
different from VAX C (which treated externs as SHR by default), and
has the following impact:
1. When linking old object files or object libraries with newly
produced object files, you might get "conflicting attributes
for psect" messages, which can be safely ignored as long as you
are not building shareable libraries.
2. The /NOSHARE_GLOBALS default makes building shareable libraries
easier.
48 /SHOW
/SHOW=(option[,...])
/SHOW=SOURCE (D)
Used with the /LIST qualifier to set or cancel specific listing
options. You can select the following options:
ALL Print all listing information.
[NO]BRIEF Print a brief symbol table, listing only those
identifiers that are referenced in the program.
[NO]CROSS_REFERENCE
Specifies whether the compiler generates
cross-references. If you specify
/SHOW=CROSS_REFERENCE, the compiler lists, for
each variable referenced in the procedure, the
line numbers of the lines on which the variable
is referenced.
You may use /SHOW=CROSS_REFERENCE with
/SHOW=SYMBOLS. Otherwise, specifying
/SHOW=CROSS_REFERENCE also gives you /SHOW=BRIEF.
To obtain any type of listing, you must specify
/LIST. /SHOW=CROSS_REFERENCE is the same as
specifying /[NO]CROSS_REFERENCE. (D =
NOCROSS_REFERENCE)
[NO]DICTIONARY Print/do not print Common Data Dictionary
definitions. (D = NODICTIONARY)
[NO]EXPANSION Print/do not print macro expansions.
(D = NOEXPANSION)
[NO]HEADER Print/do not print header lines at the top of
each page. (D = HEADER)
[NO]INCLUDE Print/do not print contents of #include files.
(D = NOINCLUDE)
[NO]MESSAGES Print/do not print a list of all messages that
are in effect at compilation (based on the
settings of /STANDARD, /WARNINGS, and #pragma
message). (D = NOMESSAGES)
NONE Print no listing information.
[NO]SOURCE Print/do not print source file statements.
(D = SOURCE)
[NO]STATISTICS Print/do not print compiler performance
statistics. (D = NOSTATISTICS)
[NO]SYMBOLS Print/do not print symbol table information in
the listing file. (D = NOSYMBOLS)
49 /STANDARD
/STANDARD=(option)
/STANDARD=RELAXED (equivalent to /NOSTANDARD) (D)
/NOSTANDARD (D)
Defines the compilation mode. You can select the following
options:
ANSI89 Places the compiler in strict ANSI C Standard 89
(C89) mode. This mode compiles the C language as
defined by the American National Standard for C,
along with any extensions not prohibited by that
standard.
C99 On OpenVMS Alpha and I64 systems, places the
compiler in strict ISO/IEC C Standard 99 (C99)
mode. This mode accepts just the C99 language
without extensions, and diagnoses violations of
the C99 standard. /STANDARD=C99 defines the
__STDC_VERSION__ macro to the C99-specified value
of 199901L, because C99 is a superset of
Amendment 1 to the C89 standard, and the default
mode of RELAXED is a superset of C99.
On OpenVMS VAX systems, produces a warning and
places the compiler in /STANDARD=RELAXED ANSI89
mode.
LATEST On OpenVMS Alpha and I64 systems, places the
compiler in the latest ISO C standard dialect.
/STANDARD=LATEST is currently equivalent to
/STANDARD=C99, but is subject to change when
newer versions of the ISO C standard are
released.
RELAXED Places the compiler in relaxed ANSI C Standard
mode. The compiler accepts ANSI/ISO C Standard
C89 and C99 features, as well as nearly all
language extensions (such as additional VSI C
keywords and predefined macros that do not begin
with an underscore). It excludes only K&R
(COMMON mode), VAX C, and Microsoft features that
conflict with standard C.
This is the default mode of the compiler, and is
equivalent to /NOSTANDARD.
MS Places the compiler in Microsoft compatibility
mode, which interprets source programs according
to certain language rules followed by the C
compiler provided with the Microsoft Visual C++
compiler product.
ISOC94 Places the compiler in ISO C 94 mode, which
enables digraph processing. It also defines the
predefined macro __STDC_VERSION__=199409 when
specified alone or in combination with the
ANSI89, MIA, RELAXED, MS, COMMON, or PORTABLE
keywords.
This option can be specified alone or with any
other /STANDARD option except VAXC. If it is
specified alone, the default major mode is
RELAXED.
COMMON Places the compiler in K & R language mode; that
is, compatibility with older UNIX compilers such
as pcc and gcc. This mode is close to a subset
of /STANDARD=VAXC mode.
VAXC Places the compiler in VAX C mode. There are
differences in the C language as implemented in
previous versions of VAX C and the C language as
defined by ANSI (the differences are primarily
concerned with how the preprocessor works). This
mode provides compatibility for programs that
depend on old VAX C behavior.
PORTABLE Places the compiler in RELAXED mode, and enables
the issuance of diagnostics that warn of any
nonportable usages encountered.
Note that /STANDARD=PORTABLE is supported for
VAX C compatibility only. It is equivalent to
the recommended combination of qualifiers
/STANDARD=RELAXED /WARNINGS=ENABLE=PORTABLE.
MIA Places the compiler in strict ANSI C mode with
the following behavior differences to conform to
the Multivendor Integration Architecture (MIA)
standard:
o On OpenVMS VAX systems, G_FLOAT becomes the
default floating-point format for double
variables. (On OpenVMS Alpha systems, G_FLOAT
is already the default.)
o In structures, zero-length bit fields cause
the next bit field to start on an integer
boundary, rather than on a character boundary.
If the /STANDARD qualifier is not specified, the default is
/NOSTANDARD, which is equivalent to /STANDARD=RELAXED.
If you specify the /STANDARD qualifier, you must supply an option.
With one exception, the /STANDARD qualifier options are mutually
exclusive. Do not combine them. The exception is that you can
specify /STANDARD=ISOC94 with any other option except VAXC.
VSI C modules compiled in different modes can be linked and
executed together.
50 /TIE
/NOTIE (D) Enables the compiled code to be used in combination with translated images, either because the code might call into a translated image or might be called from a translated image.
51 /UNDEFINE
/UNDEFINE=(identifier[,...])
/NOUNDEFINE (D)
Performs the same function as the #undef preprocessor directive:
it cancels a macro definition.
The /UNDEFINE qualifier is useful for undefining the predefined VSI
C preprocessor constants. For example, if you use a preprocessor
constant (such as vaxc, VAXC, VAX11C, or vms) to conditionally
compile segments of code specific to VSI C for OpenVMS Systems, you
can undefine constants to see how the portable sections of your
program execute. For example:
/UNDEFINE="vaxc"
When both /DEFINE and /UNDEFINE are present on the CC command line,
/DEFINE is evaluated before /UNDEFINE.
The default is /NOUNDEFINE.
52 /UNSIGNED_CHAR
/NOUNSIGNED_CHAR (D) Changes the default for all char types from signed to unsigned. This qualifier causes all plain char declarations to have the same representation and set of values as signed char declarations. The default is /NOUNSIGNED_CHAR.
53 /VERSION
/VERSION
/NOVERSION (D)
Directs the compiler to print out the compiler version and
platform. The compiler version is the same as in the listing file.
This qualifier helps you to report what compiler you are using.
When this qualifier is specified, the compiler just prints its
version and exits. No other qualifiers are processed, no source
file is read, and no object module is produced.
The syntax for using this qualifier is:
CC/VERSION
The default is /NOVERSION.
54 /WARNINGS
/WARNINGS[=(option[,...])]
/WARNINGS (D)
/NOWARNINGS
Controls the issuance of compiler diagnostic messages, or groups of
messages. The default qualifier, /WARNINGS, enables all warning
and informational messages for the compiler mode you are using.
The /NOWARNINGS qualifier suppresses the informational and warning
messages. Also see the #pragma message preprocessor directive.
The options are:
DISABLE=msg-list Suppresses the issuance of the indicated
messages.
Only messages of severity Warning (W) or
Information (I) can be disabled. If the
message has severity of Error (E) or
Fatal (F), it is issued regardless of any
attempt to disable it.
ENABLE=msg-list Enables the issuance of the indicated
messages.
NOINFORMATIONALS Suppresses informational messages.
EMIT_ONCE=msg-list Emits the specified messages only once
per compilation. Errors and Fatals are
always emitted. You cannot set them to
EMIT_ONCE.
EMIT_ALWAYS=msg-list Emits the specified messages at every
occurrence of the condition.
ERRORS=msg-list Sets the severity of each message in the
message-list to Error.
Note that supplied Error messages and
Fatal messages cannot be made less
severe. (Exception: A message can be
upgraded from Error to Fatal, then later
downgraded to Error again, but it can
never be downgraded from Error.)
Warnings and Informationals can be made
any severity.
FATALS=msg-list Sets the severity of each message on the
message-list to Fatal.
INFORMATIONALS=msg-list Sets the severity of each message in the
message-list to Informational. Note that
Fatal and Error messages cannot be made
less severe.
WARNINGS=msg-list Sets the severity of each message in the
message-list to Warning. Note that Fatal
and Error messages cannot be made less
severe.
VERBOSE Displays the full message information for
every compiler message encountered. This
information includes the message
description and user action, as well as
the identifier, severity, and message
text.
When /WARNINGS=VERBOSE is used with
/LIST/SHOW=MESSAGES, a list of all
messages in effect at compilation are
added to the listing file, showing the
full information for each message.
The msg-list can be any one of the following:
o A single message identifier (within parentheses, or not). The
message identifier is the name following the severity at the
start of a line when a message is issued. For example, in the
following message, the message identifier is GLOBALEXT:
%CC-W-GLOBALEXT, a storage class of globaldef,
globalref, or globalvalue is a language extension.
o A single message-group name (within parentheses, or not).
Message-group names are:
ALL All the messages in the compiler
ALIGNMENT Messages about unusual or inefficient data
alignment.
C_TO_CXX Messages reporting the use of C features
that would be invalid or have a different
meaning if compiled by a C++ compiler.
CDD Messages about CDD (Common Data
Dictionary) support.
CHECK Messages reporting code or practices that,
although correct and perhaps portable, are
sometimes considered ill-advised because
they can be confusing or fragile to
maintain. For example, assignment as the
test expression in an "if" statement.
NOTE: The check group gets defined by
enabling LEVEL5 messages.
DEFUNCT Messages reporting the use of obsolete
features: ones that were commonly
accepted by early C compilers but were
subsequently removed from the language.
NEWC99 Messages reporting the use of the new C99
Standard features.
NOANSI This is a deprecated message group. It is
an obsolete synonym for NOC89. Also see
message groups NEWC99, NOC89, NOC99.
NOC89 Messages reporting the use of non-C89
Standard features.
NOC99 Messages reporting the use of non-C99
Standard features.
OBSOLESCENT Messages reporting the use of features
that are valid in ANSI Standard C, but
which were identified in the standard as
being obsolescent and likely to be removed
from the language in a future version of
the standard.
OVERFLOW Messages that report assignments and/or
casts that can cause overflow or other
loss of data significance.
PERFORMANCE Messages reporting code that might result
in poor run-time performance.
PORTABLE Messages reporting the use of language
extensions or other constructs that might
not be portable to other compilers or
platforms.
PREPROCESSOR Messages reporting questionable or
non-portable use of preprocessing
constructs.
QUESTCODE Messages reporting questionable coding
practices. Similar to the CHECK group,
but messages in this group are more likely
to indicate a programming error rather
than just a non-robust style.
Enabling the QUESTCODE group provides
lint-like checking.
RETURNCHECKS Messages related to function return
values.
UNINIT Messages related to using uninitialized
variables.
UNUSED Messages reporting expressions,
declarations, header files, CDD records,
static functions, and code paths that are
not used.
o A single message-level name (within parentheses, or not).
Note: There is a core of very important compiler messages that
are enabled by default, regardless of what you specify with
/WARNINGS or #pragma message. Referred to as message level 0,
it includes all messages issued in header files, and comprises
what is known as the nostandard group. All other message
levels add additional messages to this core of enabled
messages.
You cannot modify level 0 (You cannot disable it, enable it,
change its severity, or change its EMIT_ONCE characteristic).
However, you can modify individual messages in level 0,
provided such modification is allowed by the action. For
example, you can disable a warning or informational in level 0,
or you can change an error in level 0 to a fatal, and so on.
(See above restrictions on modifying individual messages.)
Message-level names are:
LEVEL1 Important messages. These are less
important than the level 0 core messages,
because messages in this group are not
displayed if #pragma nostandard is active.
LEVEL2 Moderately important messages.
LEVEL3 Less important messages. LEVEL3 is the
default message level.
LEVEL4 Useful check/portable messages.
LEVEL5 Not so useful check/portable messages.
LEVEL6 Additional "noisy" messages.
Enabling a level also enables all the messages in the levels
below it. So enabling LEVEL3 messages also enables messages
in LEVEL2 and LEVEL1.
Disabling a level also disables all the messages in the
levels above it. So disabling LEVEL4 messages also disables
messages in LEVEL5 and LEVEL6.
o A comma-separated list of message identifiers, group names, and
messages levels, freely mixed, enclosed in parentheses.
The default is /WARNINGS. This enables all diagnostic messages for
the selected compiler mode.
Notes:
o If a message is on both the enabled and disabled list, it is
disabled.
o If a message is on both the EMIT_ONCE and the EMIT_ALWAYS list,
it is considered to be on the EMIT_ONCE list.
o If a message is on more than one of the FATALS, ERRORS,
WARNINGS, or INFORMATIONALS lists, the message is given the
least severe level.
o The NOINFORMATIONALS option is not the negation of
INFORMATIONALS=msg-list. It is valid to say:
/WARN=(INFORMATIONALS=message_list,NOINFORMATIONALS)
This has the effect of making the messages on the message_list
informationals, and causing the compiler to suppress any
informational messages.
55 – Message Groups
VSI C compiler message groups The following tables list all compiler messages by message group. For a description of each compiler message, see the Messages section of this online help.
55.1 – 64BIT
CVTU32TO64 FUNCMIXPTR LONGLONGSUFX LONGLONGTYPE POINTERINTCAST PRAGIGNORE PTRINTTOLONG PTRLONGTOINT TRUNCLONGCAST TRUNCLONGINT
55.2 – 64BITPOINTERS
POINTERINTCAST
55.3 – ALIGNMENT
ALIGNCONFLICT ALIGNCONFLICT1 ALIGNCONST ALIGNEXT MISALGNDMEM MISALGNDSTRCT NONMULTALIGN UNALIGNEXT
55.4 – C_TO_CXX
CLASSNOINIT CONSTNOINIT CONSTSTOCLS CXXKEYWORD INTIMPLIED KNRFUNC NESTEDENUM NESTEDTYPE NONEWTYPE NONULINIT NOPARMLIST STORCLSDCL STORMODDCL TENTREDEF
55.5 – CDD
CDDEXT TEXTARRAY TEXTARRAYN TEXTCHAR
55.6 – DEFUNCT
DEFPARMTYPE DUPENUM EMBEDCOMMENT LONGFLOATEXT MAINPROGEXT READONLYEXT
55.7 – NEWC99
ADDRCONSTEXT ARRNOTLVALUE BOOLEXT COMPLEXEXT CXXCOMMENT DECLAFTERSTMT DECLINFOR DEFRETURNTYPE DESIGNATORUSE DOLLARID DUPTYPQUAL FUTUREKEYWD2 FUTUREKEYWORD IMPLICITFUNC INCOMPARRY2 INTCONSTSIGNED LONGLONGSUFX LONGLONGTYPE NEEDCONSTEXT RESTRICTEXT2 TRAILCOMMA TYPQUALNOT2 UCNUNSUPP UCNUSED VLAEXTENSION WCHARCAT XTRALARGE
55.8 – NOC89
ADDRCONSTEXT ADDRSUBCONST ALIGNEXT ARGADDR ARRNOTLVALUE ASSIGNEXT BADCMMNTPSTNG BADREGISTER BITNOTINT BOOLEXT CDDEXT CMPPTRFUNVOID COMPLEXEXT CONSTCOMPLIT CONSTFUNC CONVARASLIT CXXCOMMENT DECLAFTERSTMT DECLINFOR DECLSPECEXT DESIGNATORUSE DOLLARID DUPENUM DUPTYPEDEF DUPTYPQUAL ELLIPSEARG ELLIPSEPARM EMPTYCHARCONST ENUMSNOTCOMPAT EXPANDEDDEFINED EXTENDTYPE FLEXARRAYELEM FLEXARRAYMEM FUNCREDECL FUTUREKEYWD2 FUTUREKEYWORD GLOBALEXT HEXOCTSIGN IDINPARENSEXT INCARRAYPARM1 INCOMPARRY INCOMPARRY1 INCOMPARRY2 INCOMPDEREF INLINESTOCLSMOD INTCONSTTOOBIG LABELWOSTMT LONGFLOATEXT LONGLONGSUFX LONGLONGTYPE LVALUECAST MACROREDEF MAINNOTINT MAINPROGEXT MISMATPARAM MISPARAMCOUNT MIXFUNCVOID NEEDCONSTEXT NODCL NONAMEMEMBERS NONINTENUM NONOCTAL NONPORTLINEDIR NONSTANDCAST NOSEMISTRUCT NOSHAREEXT NOTADDRCAST OKCPPINARGS PARENLITERAL PRAGMAIDENT PRAGMAMOD PTRMISMATCH1 READONLYEXT RESTRICTEXT RESTRICTEXT1 RESTRICTEXT2 SAMEASTYPEDEF TEXTMODULE TRAILCOMMA TYPEDEFNA TYPEOFEXT TYPQUALNOT2 UCNUNSUPP UCNUSED UNALIGNEXT UNDEFENUM UNSIGNEDPRES UNSTRUCTMEM VARIANTEXT VLAEXTENSION VOLATILEFUNC WCHARCAT XTRALARGE
55.9 – NOC99
ADDRSUBCONST ALIGNEXT ARGADDR ASSIGNEXT BADCMMNTPSTNG BADREGISTER BITNOTINT CDDEXT CMPPTRFUNVOID CONSTCOMPLIT CONSTFUNC CONVARASLIT DECLSPECEXT DUPENUM DUPTYPEDEF ELLIPSEARG ELLIPSEPARM EMPTYCHARCONST ENUMSNOTCOMPAT EXPANDEDDEFINED EXTENDTYPE FLEXARRAYELEM FLEXARRAYMEM FUNCREDECL GLOBALEXT HEXOCTSIGN IDINPARENSEXT INCARRAYPARM1 INCOMPARRY INCOMPARRY1 INCOMPDEREF INLINESTOCLSMOD INTCONSTTOOBIG INTCONSTUNSIGN LABELWOSTMT LONGFLOATEXT LVALUECAST MACROREDEF MAINNOTINT MAINPROGEXT MISMATPARAM MISPARAMCOUNT MIXFUNCVOID NODCL NONAMEMEMBERS NONINTENUM NONOCTAL NONPORTLINEDIR NONSTANDCAST NOSEMISTRUCT NOSHAREEXT NOTADDRCAST OKCPPINARGS PARENLITERAL PRAGMAIDENT PRAGMAMOD PTRMISMATCH1 READONLYEXT RESTRICTEXT RESTRICTEXT1 SAMEASTYPEDEF TEXTMODULE TYPEDEFNA TYPEOFEXT UNALIGNEXT UNDEFENUM UNSIGNEDPRES UNSTRUCTMEM VARIANTEXT VOLATILEFUNC
55.10 – OBSOLESCENT
DEFRETURNTYPE INTIMPLIED KNRFUNC STONOTFIRST
55.11 – OVERFLOW
BITCONSTSIGN INPTRTYPE INTCONCASTSGN INTCONCASTTRU INTCONSTSIGN INTCONSTTRUNC MAYHIDELOSS NONOCTAL OUTSTRINGTYPE OUTTYPELEN RIGHTSHIFTOVR TRUNCFLTASN TRUNCFLTINT TRUNCINTASN TRUNCINTCAST
55.12 – PERFORMANCE
ALIGNCONFLICT ALIGNCONFLICT1 BLTINIMPLRET MISALGNDMEM MISALGNDSTRCT NONMULTALIGN
55.13 – PORTABLE
ADDRARRAY ADDRCONSTEXT ADDRSUBCONST ALIGNCONST ALIGNEXT ARGADDR ARRNOTLVALUE ASSIGNEXT BADCMMNTPSTNG BADREGISTER BITNOTINT BOOLEXT CDDEXT CMPPTRFUNVOID COMPLEXEXT CONSTCOMPLIT CONSTFUNC CONVARASLIT CXXCOMMENT DECLAFTERSTMT DECLINFOR DECLSPECEXT DESIGNATORUSE DOLLARID DUPENUM DUPSTORCLS DUPTYPEDEF DUPTYPQUAL ELLIPSEARG ELLIPSEPARM EMBEDCOMMENT EMPTYCHARCONST ENUMSANDINT ENUMSNOTCOMPAT EXPANDEDDEFINED EXTENDTYPE FLEXARRAYELEM FLEXARRAYMEM FUNCREDECL FUTUREKEYWD2 FUTUREKEYWORD GLOBALEXT HEXOCTSIGN HEXOCTUNSIGN IDINPARENSEXT INCARRAYPARM INCARRAYPARM1 INCOMPARRY INCOMPARRY1 INCOMPARRY2 INCOMPDEREF INCOMPELMNT INLINESTOCLSMOD INTCONSTSIGNED INTCONSTTOOBIG INTCONSTUNSIGN LABELWOSTMT LONGFLOATEXT LONGLONGSUFX LONGLONGTYPE LVALUECAST MACROREDEF MAINNOTINT MAINPROGEXT MISMATPARAM MISPARAMCOUNT MIXFUNCVOID MULTICHAR NAMESHORTENED NEEDCONSTEXT NONAMEMEMBERS NONINTENUM NONOCTAL NONPORTLINEDIR NONSTANDCAST NOSEMISTRUCT NOSHAREEXT NOTADDRCAST OKCPPINARGS PARENLITERAL PRAGMA PRAGMAIDENT PRAGMAMOD QUALNA READONLYEXT RESTRICTEXT RESTRICTEXT1 RESTRICTEXT2 SAMEASTYPEDEF SWITCHLONG TEXTMODULE TRAILCOMMA TYPEDEFNA TYPEOFEXT TYPQUALNOT2 UCNUNSUPP UCNUSED UNALIGNEXT UNDEFENUM UNSTRUCTMEM VALUEPRES VARIANTEXT VLAEXTENSION VOLATILEFUNC WCHARCAT
55.14 – PREPROCESSOR
BADCMMNTPSTNG CDDEXT EMBEDCOMMENT EXPANDEDDEFINED MACROREDEF NESTINCL NONPORTLINEDIR OKCPPINARGS PRAGMAIDENT PRAGMAMOD TEXTMODULE UNKNOWNMACRO UNNECCDD UNNECINCL UNUSEDCDD UNUSEDINCL UNUSEDTOP VAARGSBODY XTRALARGE
55.15 – QUESTCODE
BADCMMNTPSTNG BADREGISTER BITCONSTSIGN CONSTFUNC CONSTNOINIT CONTROLASSIGN DUPENUM ELLIPSEARG ELLIPSEPARM EMPTYCHARCONST ENUMCALC ENVIRSTKDIRTY EXPRNOTUSED FALLOFFEND FUNCMIXPTR FUNCREDECL IMPFNCFALLOFF IMPFNCMSSNGRET INCOMPDEREF INTCONCASTSGN INTCONCASTTRU INTCONSTSIGN INTCONSTTRUNC INTIMPLIED LVALUECAST MACROREDEF MISSPELLDEF MULTICHAR NESTEDCOMMENT NODCL NONOCTAL NONULINIT NORETURNVAL1 OKCPPINARGS PTRMISMATCH1 QUALFUNCRET QUESTCOMPARE QUESTCOMPARE1 QUESTCOMPARE2 RIGHTSHIFTOVR SAMEASTYPEDEF SHORTCIRCUIT SUBSCRBOUNDS1 SUBSCRBOUNDS2 TYPEDEFNA UNDEFENUM UNDEFESCAP UNINIT2 UNINIT3 UNINIT4 UNINIT5 UNKNOWNMACRO UNREACHCODE USELESSTYPEQUAL VOLATILEFUNC
55.16 – RETURNCHECKS
DEFRETURNTYPE FALLOFFEND IGNORECALLVAL IMPFNCFALLOFF IMPFNCMSSNGRET NORETURNVAL1 QUALFUNCRET
55.17 – UNINIT
UNINIT2 UNINIT3 UNINIT4 UNINIT5
55.18 – UNUSED
CONSTFUNC EXPNOTRES EXPRNOTUSED MISSPELLDEF NESTEDCOMMENT NESTINCL PRAGIGNORE QUALFUNCRET QUALNA SHORTCIRCUIT UNCALLED UNNECCDD UNNECINCL UNREACHCODE UNREFADECL UNREFDECL UNREFLABEL UNREFSDECL UNREFSFUNC UNREFTYP UNUSEDCDD UNUSEDINCL UNUSEDTOP VOLATILEFUNC
56 – Messages
Compiler messages - HP C V7.1
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.
56.1 – ABSTRACTDCL
Message Invalid abstract declarator.
Description An identifier was encountered in an abstract
declarator. An abstract declarator is used to
specify a type only and must not contain an
identifier that specifies a declarator.
User Action Correct the abstract declarator.
56.2 – ADDRARRAY
Message <Context> & before array "<expression>" is ignored.
Description In certain modes, HP C will ignore an address-of
operator used on an entire array. This is for
compatibility with other compilers that have this
behavior.
User Action Remove the address-of operator.
56.3 – ADDRCONSTEXT
Message <Context> "<name>" does not have a constant address,
but occurs in a context that requires an address
constant. This is an extension of the language.
Description The C89 standard requires that an initializer for a
pointer-type member of an automatic aggregate or
union-type object have an initializer that is an
address constant. Other C compilers might not
successfully compile a program that uses this
extension.
User Action Be aware of this if you wish to port the program.
56.4 – ADDRESSOFVOID
Message <Context> taking the address of a void type is a
language extension.
Description The HP C compiler will allow taking the address of a
void type for compatibility with other compilers.
This is an extension to the standard. Other
compilers may reject this.
User Action Be aware of this if you plan to port this source to
another compiler.
56.5 – ADDRSUBCONST
Message <Context> accepting the expression "<expr>" as a
constant is a language extension.
Description In many cases HP C accepts the subtraction of two
addresses within the same array or struct/union as a
constant. The C standard does not consider such an
expression to be a constant. Therefore, this program
does not conform to the standard and may be rejected
by other compilers.
User Action Change the expression to be a constant.
56.6 – ALIGNCONFLICT
Message <Context> the address "<expr>" has alignment of
<align> which is less than the alignment requirements
of the destination pointer. Dereferencing the
destination pointer may cause an alignment fault.
Description The compiler has detected a situation where a pointer
to an aligned data type is being assigned an address
that may not be properly aligned. A later
dereference of this pointer could cause an alignment
fault.
User Action There are a number of possible actions. The best is
to correct the condition that is causing the source
to have the wrong alignment, as access to an
unaligned data structure involves additional run-time
overhead. Other options would be to modify the
declaration of the destination pointer such that its
referenced type has the __unaligned type qualifier,
or use the compiler option that tells the compiler to
assume all pointer references are unaligned. It is
also possible to cast the source to the destination
type to silence this message. However, that solution
will not correct any unaligned access.
56.7 – ALIGNCONFLICT1
Message <Context> the address "<expr>" has alignment of
<align> which is less than the alignment requirements
of the pointer type it is cast to. Dereferencing the
resulting pointer may cause an alignment fault.
Description The compiler has detected a situation where an
address is being cast to a pointer type with a
greater alignment requirement than the type of the
address expression implies. A later dereference of
this pointer type value could cause an alignment
fault.
User Action There are a number of possible actions. The best is
to correct the condition that is causing the source
to have the wrong alignment, as access to an
unaligned data structure involves additional run-time
overhead. Other options would be to change the type
of the pointer used in the cast such that its
referenced type has the __unaligned type qualifier,
or use the compiler option that tells the compiler to
assume all pointer references are unaligned. It is
also possible to cast the address expression to (void
*) before casting it to the specified type to silence
this message. However, that solution will not
correct any unaligned access.
56.8 – ALIGNCONST
Message Integer constant alignment <number> is not
necessarily supported on all platforms.
Description Although the specified alignment value is valid on
this system, it might not be valid on other systems.
For example, 16 is a valid alignment value on Alpha
systems but would not be valid on VAX systems.
User Action Be aware of this potential portability issue.
56.9 – ALIGNEXT
Message _align is a language extension.
Description The _align storage class modifier is a language
extension of HP C. Other C compilers might not
successfully compile a program that uses the
extension.
User Action Be aware of this extension if you wish to port the
code.
56.10 – ALIGNPOP
Message This "restore" has underflowed the member alignment's
stack. No corresponding "save" was found.
Description The member_alignment stack, managed by the #pragma
member_alignment and #pragma environment directives,
contains more restores than saves. This could
signify a coding or logic error in the program.
User Action Make sure each restore has a corresponding save.
56.11 – ALREADYTLS
Message The identifier "<name>" has already appeared in an
omp threadprivate directive.
Description The same identifier appears more than once in a
single omp threadprivate directive, or appears in
more than one omp threadprivate clause.
User Action Remove the duplicate identifiers
56.12 – ANSIALIASCAST
Message <Context> a pointer to <type1> is being cast to a
pointer to <type2>. Using ANSI aliasing rules, the
compiler may subsequently assume that the two pointer
types are pointing to different storage locations.
Description The C standard allows a compiler to assume that these
two pointer types will point to different storage
locations. The compiler will make this assumption
whenever ansi aliasing is enabled on the command
line, either directly or via another switch. The
cast in itself does not violate aliasing rules, e.g.
you might cast the pointer value back to an allowed
type before you use it to access memory. But the
compiler cannot generally determine whether or not
you do that. If your code accesses the memory
designated by this pointer value using both of these
pointer types, you may get unexpected results when
ansi aliasing is enabled.
User Action Casting through pointer to void will silence this
message. But if the end result is that the same
memory still gets accessed through different types
that are not permitted under the aliasing rules, you
may still get unexpected results. If compiling
without ansi aliasing corrects the behavior of your
program, your code almost certainly violates the
aliasing rules in a way that the compiler cannot
detect.
56.13 – ARGADDR
Message <Context> taking the address of the constant
expression "<expression>" in an argument list is a
language extension.
Description The HP C compiler will allow the address of a
constant to be passed as an argument to a function
call. This is an extension to standard C. Other C
compilers might not successfully compile a program
that uses this extension.
User Action Assign the constant to a variable, and pass the
address of the variable.
56.14 – ARGLISGTR255
Message <Context> the function call specifies an argument
list whose length exceeds maximum specified by the
calling standard. Any use of va_count by the called
function will be wrong.
Description The OpenVMS calling standard uses a byte-sized field
to specify the size of the argument list. The
argument list to this function call requires more
storage than can be represented in this size. As a
result, any use of va_count in the called function
will return inaccurate information.
User Action Either reduce the size of the argument list, or do
not use va_count in the called function.
56.15 – ARGLISTOOLONG
Message <Context> the function call specifies an argument
list whose length exceeds the VAX architecture limit.
This call allocates stack space that is never
deallocated by the called program.
Description The OpenVMS VAX Calling Standard requires that the
called program deallocate the storage allocated for
its arguments. This is done by looking at the
byte-size value that holds the argument list size.
However, the argument list to this function call
requires more storage than can be represented in a
byte. As a result, the called function will not
deallocate the proper amount of storage. This could
result in unpredictable behavior.
User Action Reduce the size of the argument list.
56.16 – ARGSIZE
Message <Context> the argument being passed to this function
is too small.
Description A function parameter of array type has been declared
with the keyword "static" in its outermost bound to
indicate that the function may generate code that
assumes that when it is called the actual argument
will have at least as many elements as specified in
the parameter declaration. The argument provided in
this call has fewer array elements than specified in
the parameter declaration with static bound.
User Action Check the size of the argument passed to the function
and/or modify or remove the static bound on the
function parameter.
56.17 – ARRAYBRACE
Message <Context> a required set of braces is missing.
Description The initializer for this array was not enclosed in
braces. While some compilers allow this, standard C
requires braces around the initializer.
User Action Enclose the initializer in braces.
56.18 – ARRAYLIMITSUP
Message <Context> HP C provides only limited support for
array types larger than <n> bytes.
Description This array type is larger than can be represented by
size_t. While HP C will allow a type declared to be
this size, uses of the type are not fully supported
and may cause unpredictable behavior.
User Action Reduce the size of the array type. It may be
possible to use a pointer type instead of a large
array. The storage can still be accessed using array
syntax.
56.19 – ARRAYOVERFLOW
Message Integer overflow occurred when computing the size of
an array type.
Description An array type is larger than allowed on this
platform.
User Action Reduce the size of the array type. It may be
possible to use a pointer type instead of a large
array. The storage can still be accessed using array
syntax.
56.20 – ARRNOTLVALUE
Message <Context> accepting a non-lvalue array in a subscript
operator is an extension to the C89 standard.
Description The C89 standard states that one of the operands to
the subscript operator must be a pointer. However,
the array used in this operator could not be
converted to a pointer because it is not an lvalue.
Therefore this code does not conform to the C89
standard and may not be accepted by other compilers.
Note that the C99 standard allows this because all
arrays are converted to pointers, not just lvalue
arrays.
User Action Be aware of this difference if you plan to port this
source to another compiler.
56.21 – ASMCOMEXP
Message Comma expected while processing <text> instruction
Description The asm directive parser was expecting a comma, but
one was not found.
User Action Correct the asm directive.
56.22 – ASMENDEXP
Message Semicolon or asm end expected while processing <text>
instruction
Description The asm directive parser was expecting a semicolon to
end an instruction, but one was not found.
User Action Correct the asm directive.
56.23 – ASMFIMMDOTS
Message Floating point load-immediate instructions require a
.s file
Description Using a floating point load immediate instruction in
this asm directive will require the compiler to
produce an .s file and invoke the assembler to
process this source.
User Action Do not use floating point load immediate instructions
in asm directives.
56.24 – ASMFREGEXP
Message Float register expected while processing <text>
instruction
Description The asm directive parser was expecting a valid
floating register, but one was not found.
User Action Correct the asm directive.
56.25 – ASMHINTDOTS
Message Hint on <text> instruction requires a .s file
Description Using a hint in a transfer instruction in this asm
directive will require the compiler to produce an .s
file and invoke the assembler to process this source.
User Action Do not use hints in asm directives.
56.26 – ASMICONEXP
Message Integer constant expected while processing <text>
instruction
Description The asm directive parser was expecting a valid
integer constant, but one was not found.
User Action Correct the asm directive.
56.27 – ASMIDEXP
Message Identifier expected while processing <text>
instruction
Description The asm directive parser was expecting an identifier,
but one was not found.
User Action Correct the asm directive.
56.28 – ASMINSTEXP
Message Instruction mnemonic expected (found <text>)
Description The asm directive parser was expecting an instruction
mnemonic, but one was not found.
User Action Correct the asm directive.
56.29 – ASMLABEXP
Message Label expected while processing <text> instruction
Description The asm directive parser was expecting a label, but
one was not found.
User Action Correct the asm directive.
56.30 – ASMLABMULDEF
Message Multiple definitions of label in asm (<text>)
Description The asm directive parser has detected the same label
defined more than once.
User Action Change one of the label names.
56.31 – ASMLABUNDEF
Message Reference to undefined label in asm (<text>)
Description The asm directive parser has detected a reference to
an undefined label.
User Action Correct the asm directive.
56.32 – ASMLDGPDOTS
Message Unusual ldgp requires a .s file
Description This indicates that a ldgp pseudo-instruction was
encountered in an unusual place or with unusual
arguments. The assembler will be invoked on the .s
file.
User Action Correct the asm directive.
56.33 – ASMLPAREXP
Message Left paren expected while processing <text>
instruction
Description The asm directive parser was expecting a left paren,
but one was not found.
User Action Correct the asm directive.
56.34 – ASMNOTAVAIL
Message In-line assembly code directive <name> is not
available on this platform.
Description In-line assembly code is not available on the IA64
platform.
User Action See documentation for alternatives.
56.35 – ASMNOTINST
Message <text> instruction is not supported in asms on <text>
Description The asm directive parser does not recognizes a
pseudo-opcode on this platform.
User Action Correct the asm directive.
56.36 – ASMNOTREG
Message <text> is not a register name on <text>
Description The asm directive parser has noticed that a special
register used in the directive is not valid on this
platform.
User Action Correct the asm directive.
56.37 – ASMNOTSUP
Message Support for <text> (<text>) in asms is not
implemented on <text>
Description The asm directive parser does not support the feature
in question on this platform.
User Action Rewrite the asm so that the feature is not used.
56.38 – ASMPALTRUNC
Message PALcode function has been truncated to <number>
Description The asm directive call_pal instruction is followed by
an integer beyond the range of call_pal values
expected by the compiler.
User Action Use a valid call_pal argument.
56.39 – ASMRAWREG
Message <text> uses <text> before it is defined
Description The asm directive parser has noticed that an
instruction uses a register as a source before it is
given a value.
User Action Correct the asm directive.
56.40 – ASMREGEXP
Message Fixed register expected while processing <text>
instruction
Description The asm directive parser was expecting a valid
integer register, but one was not found.
User Action Correct the asm directive.
56.41 – ASMREGOVRLAPSC
Message Destination register overlaps input for <text>
(software completion) instruction
Description An asm directive contains an instruction that may
require a software completion routine in case of a
runtime exception. Such an instruction requires that
the result register be different than any input
register.
User Action Modify the asm so that the destination register is
different than the sources.
56.42 – ASMRPAREXP
Message Right paren expected while processing <text>
instruction
Description The asm directive parser was expecting a right paren,
but one was not found.
User Action Correct the asm directive.
56.43 – ASMSYMDOTS
Message Use of symbolic addresses with <text> instruction
requires a .s file
Description Using a symbolic operand in this asm directive will
require the compiler to produce an .s file and invoke
the assembler to process this source.
User Action Do not use symbolic operands in asm directives.
56.44 – ASMUNKNOWNARCH
Message Unknown architecture (<text>) specified in <text>
assembler directive
Description The asm directive parser has detected an unexpected
argument to a .tune or .arch directive.
User Action Correct the asm directive.
56.45 – ASMUNKSETOPT
Message Unsupported or illegal .set option (<text>)
Description The asm directive parser has detected an unexpected
argument to a .set directive.
User Action Correct the asm directive.
56.46 – ASSERTFAIL
Message The assertion "<assertion>" was not true, <reason>.
Description The expression in a #pragma assert
non_zero(expression) directive was found to be zero.
User Action Correct the condition that caused the expression to
be zero.
56.47 – ASSERTION
Message <text>
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.48 – ASSIGNEXT
Message <Context> relaxed struct or union type compatibility
is a language extension.
Description In certain modes, the compiler will allow assignments
or comparisons between structs or unions of different
types if their sizes are the same. This is an
extension to standard C. Other C compilers might not
successfully compile a program that uses this
extension.
User Action Recode the operation to use one of the memxxx
run-time library functions.
56.49 – ASSUMEONEELEM
Message The type of the tentatively-defined array "<name>" is
incomplete at the end of the compilation unit. The
compiler will assume one array element.
Description The C standard requires that the type of all
tentative definitions must be completed before the
end of the compilation unit. For compatibility with
some other C compilers, HP C will give the array one
element.
User Action Complete the type.
56.50 – AUTOALIGN
Message The alignment boundary of an automatic cannot be
greater than longword.
Description For automatic variables, the storage class modifier
_align cannot specify an alignment greater than
longword on VAX systems. The alignment will be set
to longword.
User Action Decrease the alignment. If a larger alignment is
required, declare the variable with static storage
class.
56.51 – AUTOEXTERNAL
Message <Context> a storage class of "auto" or "register" is
illegal at file scope.
Description The storage classes auto and register can only be
used in a declaration that appears inside a function.
They cannot be used in a declaration at file scope.
User Action Remove the storage class specifier or move the
declaration inside a function body.
56.52 – BADALIAS
Message Reference through restricted pointer <text> uses a
pointer value based on different restricted pointer,
<text>
Description The C language requires that restricted pointers
always point to different storage. The compiler has
detected a case where an access using a restricted
pointer is referencing memory pointed to a different
restricted pointer. This may cause unexpected
behavior.
User Action Make sure restricted pointers point at unique
storage.
56.53 – BADALIGN
Message Invalid alignment boundary.
Description The _align storage class modifier was given an
invalid value. See documentation for valid values on
each platform.
User Action Supply a correct value or remove the _align storage
class modifier.
56.54 – BADANSIALIAS
Message This statement accesses an object <frag1>. The
statement at <loc> accesses the same storage location
<frag2>.
Description The standard allows a compiler to assume that since
these two statements use different types, these two
statements reference different storage locations.
The HP C compiler does so whenever ansi aliasing is
enabled. Since your code relies on these two
statements accessing the same storage location you
should disable ansi aliasing. If you do not do so,
optimization may cause your program to behave
unexpectedly.
User Action Specify noansi_alias on the command line.
56.55 – BADBOUNDCHK
Message <Context> pointer arithmetic was performed more than
once in computing an array element. The bounds
checking code output by the compiler will only verify
the "<expr>" expression.
Description When an array is accessed using pointer arithmetic
and run-time array bounds checking is enabled, the HP
C compiler is only able to output the checking code
for the first pointer arithmetic operation performed
on the array. This can result in an incorrect check
if the resulting pointer value is again operated on
by pointer arithmetic. Consider the expression a = b
+ c - d; where a is a pointer, b an array, and c and
d integers. When bounds checking is enabled the
compiler will output a check to verify that c within
the bounds of the array. This will lead to an
incorrect runtime trap in cases where c is outside
the bounds of the array and c - d is not.
User Action Recode the pointer expression so that the integer
part is in parenthesis. This way the expression will
contain only one pointer arithmetic operation. In
the earlier example the expression would be changed
to a = b + (c - d);
56.56 – BADBOUNDS
Message <Context> the array bounds are incorrectly specified.
Description A multi-dimensional array declaration contains a
missing dimension specifier in a dimension other than
the first.
User Action Correct the declaration.
56.57 – BADBREAK
Message This break statement is not within a for, while, do,
or switch statement.
Description A break statement can only appear inside a for,
while, do, or switch statement.
User Action Remove the break statement, or replace it with a goto
statement.
56.58 – BADC99PRAGOP
Message Invalid syntax for the C99 _Pragma operator, its
operands cannot be recognized.
Description After macro expansion and whitespace has been
removed, the C99 _Pragma keyword must be followed by
exactly three tokens: left-parenthesis,
string-literal (or wide-string), right-parenthesis.
Any other sequence cannot be processed, and will
likely produce other spurious compile-time
diagnostics.
User Action Correct the syntax, or compile in a language mode
that does not recognize the C99_Pragma operator (e.g.
if your code has used this reserved identifier for
some other purpose).
56.59 – BADCHARSINHDR
Message Illegal characters after header name.
Description While processing an #include directive whose argument
did not start with either a '<' or '"' character, the
compiler encountered a character it did not expect.
This most often occurs when the directive argument is
a macro and there is an error during the expansion of
that macro.
User Action Correct the argument to the #include directive.
56.60 – BADCMMNTPSTNG
Message Token concatenation with comments might not be
portable -- use ## operator.
Description A macro body contains a comment between two tokens
with no white space either before or after the
comment. Older C compilers allowed this as a form of
token pasting. This type of token pasting might not
give the desired results with newer compilers.
User Action Use the standard C form of token pasting by replacing
the comment with the ## token pasting operator.
56.61 – BADCOMLITTYPE
Message <Context> the type "<type>" cannot be used to specify
the type of a compound literal.
Description The type of a compound literal must be an object type
or an array of unknown size.
User Action Use a valid type.
56.62 – BADCOMPLEXTYPE
Message <Context> "<spelling>" is an invalid complex type
specifier.
Description The valid complex type specifiers are float _Complex,
double _Complex, and long double _Complex.
User Action Use on of the valid complex type specifiers.
56.63 – BADCONDIT
Message <Context> a common type could not be determined for
the 2nd and 3rd operands ("<true expression>" and
"<false expression>") of a conditional operator.
Description The types of the second and third operands of the
conditional operator must conform to a set of rules
that define what the type of the result of the
conditional operator itself will be. If the types of
these operands do not conform to those rules, the
compiler cannot determine the type of the result,
which is an error. Refer to the language
documentation for a complete list of valid
combinations of types for the second and third
operands of the conditional operator.
User Action Modify the conditional expression so that the types
of the second and third operands conform to the
language rules.
56.64 – BADCONSTEXPR
Message Syntax error in constant expression.
Description A preprocessing constant expression contained a
syntax error. The preprocessor was expecting to find
a constant value or a left parenthesis. The
preprocessor will assume a value of zero was
encountered.
User Action Correct the preprocessing constant expression.
56.65 – BADCONTINUE
Message This continue statement is not within a for, while,
or do statement.
Description A continue statement can only appear inside a for,
while, or do statement.
User Action Remove the continue statement, or replace it with a
goto statement.
56.66 – BADCONVSPEC
Message <Context> this argument to <function name> contains a
bad conversion specification "<incorrect conversion>"
that will cause unpredictable behavior.
Description The compiler has detected an illformed conversion
specification (flags, width, precision, length
modifier) or an unknown conversion specifier (not
diouxefgcspn...) that will cause unpredictable
behavior. This might not have been what you
intended.
User Action Review the documentation for this function and modify
the conversion specification as appropriate.
56.67 – BADDCL
Message The name "<name>" cannot be undefined.
Description The code has tried to #undef a macro that is
predefined by the C standard. This is not allowed.
The #undef will be ignored.
User Action Remove the #undef directive.
56.68 – BADDECLSPEC
Message Invalid argument to __declspec. Valid arguments are
"thread" or "__thread".
Description The only valid arguments to the __declspec storage
class modifier are "thread" or "__thread".
User Action Either use one of the valid arguments, or remove the
storage class modifier.
56.69 – BADDEFARG
Message Bad argument for "defined" operator.
Description The defined preprocessing operator was given an
invalid argument. The operator expects an identifier
optionally enclosed in parenthesis. The value of the
operator is undefined.
User Action Supply a valid argument to the preprocessing
operator.
56.70 – BADENUM
Message Invalid enumerator.
Description While processing an enumerator list, the compiler was
expecting to encounter an identifier, but it found
something else instead.
User Action Correct the program syntax.
56.71 – BADENUMREDECL
Message <Context> the enum "<tag>" cannot be given a type
other than signed int because the tag was declared
earlier at <where>.
Description This enum tag would normally be given a type other
than signed int because the enumeration constants
used in the declaration exceed the range of signed
int. The compiler cannot use the extended type
because the enum tag was declared earlier, and given
signed int type at that point.
User Action Remove the earlier tag declaration.
56.72 – BADEXPR
Message Invalid expression. Description An invalid expression was encountered. User Action Correct the program syntax.
56.73 – BADFATCOMMENT
Message The compiler cannot recover.
Description In certain cases, the compiler cannot proceed after
an unterminated comment. In these cases this message
will be issued. Note that this message is always
output after the opencomment error has been output.
User Action Terminate the comment before the end-of-file.
56.74 – BADFBDAT
Message <text> contains invalid feedback data
Description A feedback file contains data, but it was corrupt and
could not be used.
User Action Create a new feedback file.
56.75 – BADFBFILE
Message Invalid feedback file: <text>
Description The compiler was unable to read information from the
specified feedback file.
User Action Make sure the feedback file contains valid feedback
information.
56.76 – BADFBTYP
Message Unexpected file type for feedback file <text>
Description The file specified in the -feedback option does not
have the file type expected by the compiler.
User Action Use a valid feedback file.
56.77 – BADFLOATTYPE
Message <Context> this floating point type "<type>" is not
supported on this platform.
Description The IEEE floating types __s_float and __t_float are
not supported on the VAX platform.
User Action Change the type to a floating type that is supported
on VAX, or compile the application on a platform that
does support IEEE floating.
56.78 – BADFORMALPARM
Message This token may not appear in a formal parameter list.
Description While processing the formal parameter list of a macro
definition, the compiler encountered an invalid
formal parameter specifier. The macro will be be
defined and this token will ignored, but that may not
have been what you intended.
User Action Correct the formal parameter list so that it consists
of a comma separated list of identifiers.
56.79 – BADFORSTOCLS
Message The declaration in a for loop can only have storage
class auto or register.
Description The declaration in a for loop contains a storage
class specifier other than auto or register. This is
not allowed.
User Action Correct the storage class.
56.80 – BADFUNCSTOCLS
Message The storage class of function <name> cannot be
<storage_class>. This storage class has been changed
to 'extern'.
Description The globalref storage class cannot be used with a
function declaration. The compiler will use the
storage class extern.
User Action Remove the globalref storage class from the function
declaration.
56.81 – BADGLOBALTYPE
Message This declaration has type "<type>", which is invalid
for a globalvalue. The extern_model strict_refdef
will be used instead.
Description An object with globalvalue storage class can only
have a type of integer, enum, or pointer type. In
other cases, the compiler will change the storage
class from globalvalue to strict_refdef.
User Action Change the data type to be one that is valid for a
globalvalue.
56.82 – BADHEADERNM
Message Invalid include file or header name specification.
Description An #include directive was not followed by a valid
argument. The directive will be ignored. The
#include directive should be followed by either a
file specification enclosed in angle brackets, a file
specification enclosed in quotes, or an identifier
that specifies a text module (OpenVMS only), or a
macro to be expanded.
User Action Supply a valid argument to the #include directive.
56.83 – BADHEXCONST
Message Hex constant value too large.
Description A hex constant used in a preprocessor directive is
too large. The value of the constant will be
undefined.
User Action Decrease the value of the constant.
56.84 – BADIDENTUCN
Message Invalid UCN encountered in an identifier.
Description An identifier contained a Universal Character Name
(UCN) that did not conform to the requirements of C99
Annex D for use of UCNs in identifiers.
User Action Specify a valid UCN sequence.
56.85 – BADIFDEF
Message An #ifdef or #ifndef is not followed by an
identifier.
Description An #ifdef or #ifndef preprocessing directive was not
followed by an identifier. The compiler will
consider the preprocessor argument to be an
identifier that is not defined. Therefore, in these
cases an #ifdef will always be FALSE, and an #ifndef
will always be TRUE.
User Action Supply a valid identifier to the directive.
56.86 – BADIFNDEFARG
Message #ifndef argument is not an identifier.
Description An #ifndef preprocessing directive was not followed
by an identifier. The compiler will consider this to
be a TRUE condition.
User Action Supply a valid identifier to the directive.
56.87 – BADINCLDIR
Message The #pragma include_directory must not appear after
an #include directive or in a /FIRST_INCLUDE file
after the first /FIRST_INCLUDE file has been
processed. The directive will be ignored.
Description There are several restrictions on the placement of
the #pragma include_directory directive. It must not
appear after any #include directive has been
encountered. Also, if /FIRST_INCLUDE is specified on
the command line, all #pragma include_directory
directives must be placed in the first file in the
/FIRST_INCLUDE list (if there is more than one in the
list) or in the the main source before any #include
directives (if there is only one file in the
/FIRST_INCLUDE list).
User Action Place the directive in a valid location.
56.88 – BADINCLDIRSIZE
Message The include_directory string length must be at least
one and must be less than <max>. The directive will
be ignored.
Description The #pragma include_directory directive does not
support an empty string argument. Also the directory
must not exceed the longest directory specification
supported on this platform.
User Action Specify a valid length string.
56.89 – BADINCLUDE
Message An #include directive has illegal syntax.
Description An #include directive was not followed by a valid
argument. This message occurs when the argument
starts with a '<' or '"' character, but does not end
with a matching delimiter. In this case the compiler
will add the matching delimiter to the end of the
argument and process the directive normally.
User Action Correct the argument to the #include directive.
56.90 – BADLINEDIR
Message Missing argument for #line directive.
Description An argument was not supplied to a #line preprocessing
directive. This directive must be followed by a
digit sequence that specifies the line number or a
macro that expands to a digit sequence. The
directive will be ignored.
User Action Supply a valid argument to the directive.
56.91 – BADLINEDIRTV
Message Illegal token in #line directive.
Description A #line directive was followed by an invalid
argument. The #line directive should be followed by
either a digit sequence or a digit sequence followed
by a string literal. The #line directive will be
ignored.
User Action Supply a valid argument to the #line directive.
56.92 – BADLINKREG
Message Invalid register "<register>" for linkage pragma.
Pragma is ignored.
Description The compiler encountered bad register specifier in a
#pragma linkage directive. The message should point
at the offending specifier. The compiler will ignore
the entire pragma.
User Action Correct the directive.
56.93 – BADLINNUM
Message Ignoring the line number for the #line directive --
too small.
Description A #line preprocessing directive specified a line
value that is either zero or less than zero. This is
not valid. The directive will be ignored.
User Action Either remove the directive or supply a positive
value to the line specifier.
56.94 – BADLOCALE
Message The compiler could not set its locale to either the
locale-specific native environment or the "C" locale.
Description During start-up, the compiler was unable to set its
locale. As part of its initialization, the compiler
will issue the call setlocale(LC_ALL, ""). If this
call fails, the compiler will try to issue the call
setlocale(LC_ALL, "C"). If this call also fails, the
compiler will issue this message and abort.
User Action The best way to determine why the compiler is failing
is to write a small program that contains the same
library calls the compiler is making and then examine
the return values.
56.95 – BADMACROINLN
Message Illegal token from macro call in #line directive.
Description A #line directive was followed by a macro whose
expansion did not form a valid argument to the
directive. The #line directive should be followed by
either a digit sequence or a digit sequence followed
by a string literal. The #line directive will be
ignored.
User Action Supply a valid argument to the #line directive.
56.96 – BADMACRONAME
Message "<directive>" directive is not followed by an
identifier and is being ignored.
Description A #define or #undef preprocessing directive was not
followed by an identifier. The first argument to
these directives must be an identifier that specifies
the macro to define or undefine. The compiler will
ignore the directive.
User Action Correct the argument to the preprocessing directive.
56.97 – BADMBCOMMENT
Message An invalid multibyte character was encountered in a
comment.
Description An invalid multibyte character was found in a
comment. While this will not affect the program
execution, it might not have been what you intended.
User Action Correct the multibyte character.
56.98 – BADMCRORECURS
Message Recursive expansion of macro "<name>" exceeded <num>
levels and was terminated.
Description In certain cases, the compiler will allow a macro to
be recursively expanded. In these cases, the
compiler limits the level of the recursion to prevent
the compiler from looping to the point where it
consumes all available memory. When this level has
been reached, this message is output.
User Action Rewrite either the macro definition or the macro
invocation so that the recursion ends before the
compiler limit is reached. Note that the use of
recursive macros is not a feature of the C standard,
and most other C compilers will not support this.
56.99 – BADMEMBER
Message Invalid member declaration.
Description A struct or union contains an invalid member
declaration. In most cases this error occurs when a
semi-colon was omitted from the previous member
declaration.
User Action Correct the declaration.
56.100 – BADMEMOFF
Message <Context> multiple definitions of member "<name>"
found with different offsets.
Description In certain modes, the compiler will allow a struct or
union reference whose right operand is not a member
of the struct or union type of the left operand.
This is allowed for compatibility with other
compilers. However, in these cases the right operand
must specify a member name that is declared with the
same type and at the same offset in every struct or
union type that declares it. This message is issued
when the compiler finds member name it is looking for
declared with a different offset in more than one
struct or union type.
User Action HP recommends that the left operand or a struct or
union reference specify a member that is a member of
the type of the struct or union specified by the
right operand. If this modification cannot be made
then the member specified by the left operand must be
declared at the same offset and with the same data
type in all struct or union declarations that declare
that member.
56.101 – BADMEMTYP
Message <Context> multiple definitions of member "<name>"
found with different types.
Description In certain modes, the compiler will allow a struct or
union reference whose right operand is not a member
of the struct or union type of the left operand.
This is allowed for compatibility with other
compilers. However, in these cases the right operand
must specify a member name that is declared with the
same type and at the same offset in every struct or
union type that declares it. This message is issued
when the compiler finds a member name it is looking
for declared at the same offset but with different
types in more than one struct or union type.
User Action HP recommends that the left operand or a struct or
union reference specify a member that is a member of
the type of the struct or union specified by the
right operand. If this modification cannot be made
then the member specified by the left operand must be
declared at the same offset and with the same data
type in all struct or union declarations that declare
that member.
56.102 – BADMODULEID
Message Invalid identifier found immediately following
"#pragma module" or "#module" directive.
Description The #pragma module or #module directive must be
followed by an identifier that specifies the module
name used by the linker.
User Action Correct the directive.
56.103 – BADMULTIBYTE
Message An invalid multibyte character was encountered <in
type of construction>.
Description An invalid multibyte character was encountered. The
message will provide additional information about the
location and attempted use of the character.
User Action Correct the multibyte character.
56.104 – BADNUM
Message <text> Qualifier value '<text>' is not an integer
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.105 – BADOCTCONST
Message Octal constant value too large.
Description An octal constant used in a preprocessor directive is
too large. The value of the constant will be
undefined.
User Action Decrease the value of the constant.
56.106 – BADOPCCAP
Message <text> instruction used is not in the selected
instruction set
Description The compiler has output an instruction that is not in
the instruction set selected on the command line.
One way this can happen is to compile a program which
contains a floating point operation and specifying
that no floating point instructions should be
generated.
User Action Either modify the source so the instruction will not
be necessary, or use a different instruction set.
56.107 – BADOPENBRACE
Message This open brace may be missing a close brace and
causing the syntax error at <location>.
Description This message is always output to the terminal after
another syntax error. It is intended to provide the
programmer with additional information that may
identify the cause of the syntax error. This message
may, or may not, provide useful information. In
general, the more consistent the coding style in the
source function, the more likely this message will be
accurate.
User Action Correct the program syntax.
56.108 – BADPARSEDECL
Message In this declaration, "<id>" must specify a type.
Description In processing a declaration, the type of the
declarator has not been declared as a typedef.
User Action Either declare the type as a typedef, or correct the
spelling of the type specifier in this declaration.
56.109 – BADPARSEPARAM
Message In this parameter list, "<param>" must either be a
type or must be followed by a ",".
Description In processing a function declaration, the compiler
has found a case where the parameter list begins with
two identifiers not separated by a comma and where
the first identifier is not a type specifier. If
this is an old-style declaration the two identifiers
must be separated by a comma. If this is a prototype
declaration, the first identifier must specify a
type.
User Action Correct the function parameter specifiers.
56.110 – BADPPDIR
Message File ends in an unfinished pp directive.
Description An unexpected end-of-file was encountered during a
preprocessing directive.
User Action Correct the directive.
56.111 – BADPRAGMAARG
Message Unexpected or missing argument to #pragma <pragma
name>. Pragma is ignored.
Description An argument to a #pragma preprocessing directive is
either missing or is not correct. The compiler will
ignore the directive.
User Action Correct the directive.
56.112 – BADPRAGMAARG1
Message Unexpected token encountered in pragma. Found
"<found>" when expecting <expecting>. The pragma
will be ignored.
Description While parsing a #pragma directive, the compiler has
encountered something unexpected. The message will
contain information about what the compiler was
expecting as well as what it found.
User Action Correct the offending directive.
56.113 – BADPRAGMALINK
Message A bad linkage pragma was specified. Pragma is
ignored.
Description The compiler encountered a bad #pragma linkage
directive. The error message should point to the
place in the pragma that the compiler considers bad.
The compiler will ignore the entire pragma.
User Action Correct the directive.
56.114 – BADPRAGNAMES
Message Invalid argument to the pragma names directive.
Pragma is ignored.
Description An invalid argument has been specified for the
#pragma names preprocessing directive.
User Action Correct the argument to the pragma.
56.115 – BADPREFIX
Message Argument to extern_prefix is not a recognized keyword
or a quoted string. Pragma is ignored.
Description An invalid argument has been specified for the
#pragma extern_prefix preprocessing directive. The
directive expects either the identifiers "save",
"__save", "restore", "__restore", or a string
constant that specifies the external prefix to use.
The compiler will ignore the pragma.
User Action Correct the argument to the pragma.
56.116 – BADPROTYP
Message Unexpected file type for profile file <text>
Description The file specified in the -feedback option does not
have the file type expected by the compiler.
User Action Use a valid feedback file.
56.117 – BADPTRARITH
Message <Context> performing pointer arithmetic on a pointer
to void or a pointer to function is not allowed. The
compiler will treat the type as if it were pointer to
char.
Description Pointer arithmetic is not allowed on pointers to
function or void types For compatibility with some
other compilers, an output file is still created.
The result produced will be the same as if the
pointer were a pointer to char. This may or may not
be compatible with other compilers that accept this
syntax.
User Action Cast the pointer type to a pointer to object type
before performing the arithmetic.
56.118 – BADREGISTER
Message <Context> "<name>" has register storage class, but
occurs in a context that precludes register storage.
The storage class has been changed to auto.
Description An object that was declared with register storage
class has been referenced in a way that is not valid
for a register. The most common example is taking
the address of an object declared with register
storage class. As certain array accesses also
require taking the address of an array, this message
can also be output for accessing the element of an
array declared with register storage class. The
compiler will change the storage class from register
to auto.
User Action Either remove the register storage class from the
declaration, or change the reference to be one that
is valid for objects with register storage class.
56.119 – BADRETURNTYPE
Message <Context> a function cannot return <type> type.
Description A function return type cannot be an array or function
type.
User Action Correct the function declaration so that the return
type is valid.
56.120 – BADSEVERITY
Message The severity of message id <name> cannot be made less
severe. The severity for this message was not
changed.
Description The severities of the compiler's error and fatal
messages cannot be changed to a severity that is less
severe. The compiler's fatal messages cannot be
changed to any other severity. The compiler's error
messages can only be changed to fatals.
User Action Remove the pragma or compiler option that tried to
change the severity.
56.121 – BADSTATICCVT
Message <Context> the address cannot be converted to the
destination type.
Description A static initialization tried to convert a link-time
address to another type. However, the linker on this
platform will not support such a conversion.
User Action Rewrite the static initialization, or perform the
initialization using runtime code.
56.122 – BADSTDLINKAGE
Message If standard_linkage is used, it must be the only
characteristic specified.
Description The standard_linkage characteristic cannot be used
with any other linkage characteristic.
User Action Correct the pragma.
56.123 – BADSTMT
Message Invalid statement.
Description An invalid statement was encountered. The most
common cause of this error is when a declaration
appears after the first statement in a compound
statement.
User Action Correct the program syntax.
56.124 – BADSTMT1
Message Invalid statement. This condition may have been
caused by an open brace without a matching close
brace. The compiler will attempt to identify open
braces that might be missing a close brace.
Description An invalid statement was encountered. This condition
may have been caused missing close brace. This
message is followed by some number of additional
messages that attempt to identify
User Action Correct the program syntax.
56.125 – BADSUBSCRIPT
Message <Context> an array subscript expression is either
less than zero or greater than the largest value that
can be represented by the size_t type.
Description The compiler has detected an array subscript
expression that is outside the bounds of any valid
array. The array access might cause unpredictable
behavior.
User Action Specify a valid array subscript.
56.126 – BADTARGMACRO
Message The target macro "<name>" does not match the
compiler's target. This will likely cause incorrect
code paths to be taken.
Description On OpenVMS I64, some users have tried defining the
macro __ALPHA explicitly using /DEFINE or a #define
in a /FIRST_INCLUDE file as a quick way to deal with
source code conditionals that assume that if __ALPHA
is not defined then the target must be a VAX.
Defining __ALPHA will cause many of the CRTL and
other OpenVMS headers to take the wrong path for I64.
User Action Remove any definitions of Alpha target macros, and if
necessary correct the preprocessor conditionals that
seemed to require an Alpha target macro to get the
desired effect. E.g. change "#ifdef __ALPHA" to
"#ifndef __VAX" or "#if defined(__ALPHA) ||
defined(__ia64)".
56.127 – BADTKEN
Message Lexically invalid token.
Description An invalid token was encountered in a preprocessing
directive.
User Action Correct the preprocessing directive.
56.128 – BADUNKNOWNVLA
Message <Context> a "*" bounds specifier is invalid. Using a
"*" to specify a variable-length array of unknown
size is only valid in declarations with function
prototype scope.
Description Using a "*" as a bounds specifier to designate a
variable-length array with unknown size is only valid
in declarations with function prototype scope.
User Action Supply a valid bound specifier.
56.129 – BADUNROLLVAL
Message The #pragma unroll directive takes a value from zero
to 255. The value "<val>" is outside that range.
The directive will be ignored.
Description The value supplied to a #pragma unroll is outside the
range allowed for the directive. The #pragma
directive will be ignored.
User Action Use a valid value for the unroll count.
56.130 – BADUSELINK
Message A bad use_linkage pragma was specified. Pragma is
ignored.
Description The compiler encountered a bad #pragma use_linkage
directive. The error message should point to the
place in the pragma that the compiler considers bad.
The compiler will ignore the entire pragma.
User Action Correct the directive.
56.131 – BADUSERMACRO
Message The name "<name>" cannot be a user-defined macro.
Description The code has tried to #define either a macro that is
predefined by the C standard or the DEFINED
preprocessing keyword. This is not allowed. The
#define will be ignored.
User Action Remove the #define directive.
56.132 – BADVASTART
Message <Context> old-style parameter "<name>", with type
that requires default argument promotion, cannot be
used with va_start.
Description It is invalid for the parameter specified in va_start
to be one that requires default argument promotion.
User Action The recommended fix is to recode the function
definition to use a prototype-format definition. It
is also possible to change the parameter declaration
to use one of the default types, for example double.
56.133 – BIFENABLED
Message The function "<routine name>" is a builtin function
reserved to the compiler, and does not require a
#pragma intrinsic. The function will continue to be
treated as a builtin.
Description A function identifier specified in a #pragma function
intrinsic is the name of a builtin function. These
functions cannot be explicitly enabled, they are
always handled as builtin functions.
User Action Remove the inappropriate use of the pragma.
56.134 – BIFNEEDSSTD
Message <Context> use of "<function>" is not allowed in a
function with a non-standard linkage. This function
was given the linkage "<name>" by a #pragma
use_linkage directive.
Description Certain built-ins that return information about a
function call require that the function be called
with standard linkage. Because this function appears
in a #pragma use_linkage directive naming a linkage
that specifies attributes other than
standard_linkage, these builtins cannot be called
from this function.
User Action Use a standard linkage on this function, remove the
calls to the builtins, or move them to a different
function that is called with standard linkage.
56.135 – BIFNOTAVAIL
Message Built-in function <name> is not available on this
platform.
Description This Alpha built-in function is not available on the
IA64 platform.
User Action See documentation for alternatives.
56.136 – BIFPROTO
Message <Context> the built-in function, "<name>", requires a
prototype declaration from <filename>.
Description Invoking a built-in function requires that the
function be declared before it is invoked. This
should be done by including the header file noted in
the message.
User Action Include the header file before the function is
invoked.
56.137 – BITARRAY
Message The CDD description for <name> specifies that it is
an array of bitfields; It has been converted to a
scalar bitfield.
Description HP C does not allow arrays of bitfields. The
resulting C declaration will be a bitfield of the
same total size as that specified in the CDD
description.
User Action If a bitfield type is acceptable, then no user
action is necessary. If, however, the bitfield type
is not acceptable, then the CDD description should be
altered.
56.138 – BITBADREP
Message <Context> the bitfield type is not an integral type.
Description A bitfield has been declared with a non-integral
type. Standard C requires that all bitfields be
declared with either int, unsigned int, or signed int
type.
User Action Change the type of the bitfield.
56.139 – BITCONSTSIGN
Message <Context> the integer constant "<constant>" does not
have the same sign as the 1-bit bitfield it is being
converted to.
Description Either an unsigned 1-bit bitfield was assigned -1, or
a signed 1-bit bitfield was assigned 1. This may not
be what you intended.
User Action Change the constant to be the appropriate sign.
56.140 – BITFIELDSIZE
Message The CDD description for bitfield <name> specifies a
size greater than 32; The excess is declared
separately.
Description HP C does not allow individual bitfields larger than
32. As a result, a series of bitfields have been
declared whose total size matches that of the CDD
definition.
User Action If the generated definitions are acceptable, then no
user action is necessary. If, however, the generated
definitions are not acceptable, then the CDD
description should be altered.
56.141 – BITNOTINT
Message <Context> the bitfield type is not an int, signed
int, unsigned int or _Bool.
Description A bitfield has been declared with a type other than
int, signed int, unsigned int or _Bool. This is not
allowed by the C standard.
User Action Change the declaration to use one of the allowed
types or compile with a standard mode that allows
this behavior.
56.142 – BITWIDTH
Message <Context> the bitfield width expression
"<expression>" is outside the range <lower> to
<upper>.
Description A bitfield width specifier was either less than zero,
or is greater than the number of bits in an int. In
some modes, the compiler will assume a width
specifier equal to the number of bits in an int.
User Action Use a valid bitfield width specifier.
56.143 – BITWIDTHTYP
Message <Context> the bitfield width expression
"<expression>" does not have an integral type.
Description A bitfield width specifier does not have an integral
type. A bitfield width specifier must be an integral
constant expression.
User Action Correct the width specifier.
56.144 – BLOCKEXTVLA
Message <Context> the block scope identifier "<name>" cannot
be declared with a variably modified type because it
has extern storage class.
Description Only ordinary identifiers with block scope and
without storage class extern, or ordinary identifiers
with function prototype scope can be declared with a
variably modified type.
User Action Correct the declaration.
56.145 – BLOCKINL
Message Block level declarations of inline functions are not
allowed.
Description In C99 standard, block level declaration of inline
functions are prohibited.
User Action Move the inline function declaration to file scope.
56.146 – BLTINARGCNT
Message <Context> an incorrect number of arguments were
passed to the builtin function, "<function
expression>".
Description This message is output on OpenVMS systems when the
number of arguments passed to the builtin function is
not one.
User Action Correct the call to the builtin function.
56.147 – BLTINIMPLRET
Message <Context> for the function "<name>", the implicit
return type of "<type>" is not consistent with the
expected type of "<type>". It will be treated as an
ordinary implicitly defined external function.
Description A function that could be handled internally by the
compiler has not been declared, so an implicit
declaration has been created for the function. The
return value for the function is being used, and the
implicit return type does not agree with what the
compiler expected to see. In such cases, the
function will not be handled internally, but will
instead be called at run time in the usual manner.
This could result in a performance loss, or possibly
incorrect results if the implicit return type is
incorrect.
User Action If the function is intended to refer to the runtime
library routine, the appropriate header file should
be included in the source. Alternatively, a correct
prototype could be provided privately in the source
file. If the function is intended to be a
replacement for the runtime library routine, disable
the intrinsic version by specifying "#pragma
function(function_name)" in the source file.
56.148 – BOOLEXT
Message The _Bool data type is a new feature in the C99
standard. Other C compilers may not support this
feature.
Description This is a new language feature in C99. While having
a standard specification for portability, the feature
may not yet be available in all of the compilers you
use.
User Action Determine whether or not the use of this feature will
cause portability problems for this code.
56.149 – BOOLNA
Message The _Bool keyword is not supported in this language
mode. It will be treated as an identifier in this
compilation.
Description Support for the _Bool keyword is only available in
certain language modes. Support is not present when
the compiler is in VAX C, K & R (common), or strict
ANSI89 standard modes. In these language modes _Bool
will be treated as an identifier.
User Action Compile using one of the other compilation modes.
56.150 – BOUNDADJ
Message The CDD description for <name> specifies
non-zero-origin dimension bound(s); The bound(s) are
adjusted to zero-origin.
Description The CDD description specifies lower bounds(s) for an
array that is non-zero. The resulting C definition
will have the upper bound(s) adjusted for lower
bound(s) of zero.
User Action Verify that all subscript expressions are referencing
the correct array element(s).
56.151 – BOUNDNOTINT
Message <Context> the array bound "<expression>" does not
have an integral type.
Description The compiler has encountered an array-bounds
specifier that is not an integral type. Array-bounds
specifiers must be positive integer constants.
User Action Correct the array-bounds specifier
56.152 – BUGCHECK
Message Compiler bugcheck. Submit a problem report with a
problem description.
Description An unexpected condition occurred in the compiler.
This is most likely caused by a compiler bug.
User Action Reduce the program that is causing the failure as
much as possible. This often leads to a small test
case. Please submit a problem report containing
enough information for Engineering to reproduce the
problem. The problem report should include the small
test case.
56.153 – CALLNEEDSFUNC
Message <Context> "<expression>" is not a function.
Description In what appears to be a function call, the expression
denoting the the function to call is neither the
identifier for a function nor an expression of type
pointer to function.
User Action Correct the expression denoting the function. If the
expression is a simple identifier, perhaps a
function-like macro definition is missing.
56.154 – CANNOTREDEF
Message Cannot #define a macro that is currently expanding.
Description The program is trying to #define the same macro it is
currently expanding. The #define will be ignored.
User Action Remove the #define, or move it after the expansion of
the macro.
56.155 – CANNOTUNDEF
Message Cannot #undef a macro that is currently expanding.
Description The program is trying to #undef the same macro it is
currently expanding. The #undef will be ignored.
User Action Remove the #undef, or move it after the expansion of
the macro.
56.156 – CANTDISABLE
Message The message id <name> cannot be disabled.
Description The compiler's error and fatal messages cannot be
disabled.
User Action Remove this message id from the list of messages
being disabled on the command line or in the #pragma
message line.
56.157 – CANTMKRPSTORY
Message Attempt to create repository "<string>" for shortend
names failed; OpenVMS status: <reason>.
Description A compilation that used the /NAMES=SHORTENED
qualifier could not open the repository used to store
the shortened names. This could be because an
invalid name was specified in the /REPOSITORY
qualifier. The message will give additional
information about the failure.
User Action Correct whatever caused the failure.
56.158 – CDDATTR
Message One or more field descriptions in this CDD record
specify an attribute that is being ignored.
Description The CDD description specifies an attribute that is
not supported in HP C. The attribute is ignored.
User Action No action is required.
56.159 – CDDBADID
Message An invalid identifier, <name>, is being ignored in
the dictionary directive.
Description An unexpected identifier follows the dictionary
pathname in a dictionary preprocessing directive.
The identifier is ignored.
User Action Remove the invalid identifier(s) in the dictionary
directive.
56.160 – CDDEXT
Message #dictionary is a language extension.
Description The #dictionary directive is an extension of HP C on
OpenVMS. The program might not compile with other
compilers or on other platforms.
User Action Be aware of this if you wish to port the program.
56.161 – CDDPATH
Message A valid CDD pathname was not found. The CDD
directive has been ignored.
Description The #dictionary preprocessing directive was not
followed by an argument. The directive must be
followed by a character string that gives the path
name of a CDD record, or a macro that expands to the
path name of the record.
User Action Supply a valid argument to #dictionary. HP also
recommends that the #dictionary preprocessing
directive be replaced by the #pragma dictionary
operator.
56.162 – CDDTOODEEP
Message The attributes for the Common Data Dictionary record
description <name> exceed the implementation's limit
for record complexity.
Description The CDD description specifies more attributes than
the interface between the CDD and the compiler can
handle.
User Action Simplify the record description.
56.163 – CHARCONST
Message Ill-formed character constant. Description An invalid character constant was encountered. User Action Correct the character constant.
56.164 – CHAROVERFL
Message A character constant value requires more than
sizeof(int) bytes of storage.
Description A character constant is too long to fit in an int.
The compiler will ignore the extra characters.
User Action Remove the extra characters from the character
constant.
56.165 – CHKEXPAND
Message <number> integrity check error(s) after IL expansion
of routine <text>
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.166 – CHKINIT
Message <number> integrity check error(s) in initial IL & ST
for module <text>
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.167 – CHKOPT
Message <number> integrity check error(s) after <text>
optimization phase for routine <text>
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.168 – CLASSNOINIT
Message <Context> the struct or union object "<name>" is
uninitialized and has a const member.
Description An object of struct or union type has a const member
and has not been initialized. This might not have
been what you intended. HP recommends that you
initialize all objects with the const attribute. The
missing initializer will make this an invalid
declaration in C++.
User Action Initialize the struct or union object.
56.169 – CLOSBRACKET
Message Missing "]".
Description The compiler was expecting a closing bracket, but one
was not found.
User Action Correct the program syntax.
56.170 – CLOSEBRACE
Message Missing "}".
Description The compiler was expecting a closing brace, but one
was not found.
User Action Correct the program syntax.
56.171 – CLOSECOMMENT
Message This unmatched comment delimiter is ignored.
Description An unmatched comment delimiter (*/) is an illegal
combination of unary indirection and binary division
operators that would have caused your compilation to
fail.
User Action Remove the comment delimiter.
56.172 – CLOSEPAREN
Message Missing ")".
Description The compiler was expecting a closing parenthesis, but
one was not found.
User Action Correct the program syntax.
56.173 – CMPPTRFUNVOID
Message <Context> accepting the [in]equality comparison of a
pointer to void and a pointer to function type is a
language extension.
Description Under the C standard, it is a constraint violation to
perform an [in]equality comparison between a pointer
to void and a pointer to function type. Therefore
this code may not be accepted by other compilers.
User Action Cast one of the pointers to the type of the other.
56.174 – COLMAJOR
Message The CDD description for <name> specifies that it is a
column-major array; It has been converted to a
one-dimensional array.
Description The HP C compiler supports only row-major arrays.
Therefore the column-major array description in the
CDD has been converted to a one-dimensional array of
the same total size and with the same total number of
elements.
User Action Verify that all subscript references to the array
reference the correct array element.
56.175 – COMMANDMACRO
Message Extraneous text "<text>" at the end of the command
line macro "<macro>" is ignored.
Description A command line macro define contains an invalid macro
name. The compiler will define the macro name listed
in the message.
User Action Correct the command line invocation.
56.176 – COMPILERBUG
Message Bug found in compiler: <bug>.
Description This message indicates that the compiler detected a
bug within itself.
User Action Please report the compiler bug and include an example
program that reproduces the problem.
56.177 – COMPLEXEXT
Message The complex data type is a new feature in the C99
standard. Other C compilers may not support this
extension.
Description This is a new language feature in the C99 revision of
the standard. While having a standard specification
for portability, the feature may not yet be available
in all of the compilers you use.
User Action Determine whether or not the use of this feature will
cause portability problems for this code.
56.178 – COMPLEXNA
Message The complex data types are not supported in this
language mode. This will be treated as an identifier
in this compilation.
Description Support for the complex data types is only available
in certain language modes. Support is not present
when the compiler is in VAX C, K & R (common), or
strict ANSI89 standard modes. In these language
modes _Complex and _Complex_I will be treated as
identifiers.
User Action Compile using one of the other compilation modes.
56.179 – COMPLEXNA1
Message The complex data types are not supported on this
platform. This will be treated as an identifier in
this compilation.
Description The complex data type is not supported on the VAX
platform.
User Action Remove use of the complex types or compile the
application on a platform that does support the
complex data types.
56.180 – CONFLICTHINTS
Message <Context> this hint value contridicts a related hint
at <where>. The hints will be ignored.
Description This program has supplied hints for either both
branches of an if/else or both the second and third
operand of a conditional operator. In these cases
the two hint values must add to one.
User Action Correct the hints.
56.181 – CONLINKREG
Message Conflicting register usage between "<first set>" and
"<second set>". Pragma is ignored.
Description The same register was specified in two different
register lists of a #pragma linkage directive. The
compiler will ignore the entire pragma.
User Action Correct the directive.
56.182 – CONPSECTATTR
Message Conflicting psect attribute overrides previous
attribute.
Description A psect attribute specified in a #pragma extern_model
directive contradicts an attribute specified earlier
in the directive. This attribute will override the
one specified earlier.
User Action Remove one of the contradictory psect attributes.
56.183 – CONSTCOMPLIT
Message <Context> accepting a compound literal as a constant
is a language extension. The compound literal will
be treated as a cast expression.
Description A compound literal appears in a context where a
constant expression is required. The C standard does
not list compound literals as a form of operand that
is allowed in a constant expression, so using a
compound literal in this context is not maximally
portable. The compiler will treat the compound
literal as if it were a cast expression, which is a
form of operand that the standard lists as being
allowed in constant expressions.
User Action For maximum portability, replace the compound literal
with a cast expression.
56.184 – CONSTFOLDNS
Message <Context> the libraries on this platform do not yet
support compile-time evaluation of the constant
expression "<expression>".
Description Compile-time evaluation of constant expressions
requires underlying support in the libraries
available to the compiler at compile-time, and this
expression contains an operator that is not yet
implemented in those libraries.
User Action If possible, replace part of the constant expression
with a variable of the same value.
56.185 – CONSTFUNC
Message Ignoring const type qualifier in declaration of
<name>.
Description The const type qualifier cannot be used with a
function type. The compiler will ignore the type
qualifier.
User Action Remove the type qualifier.
56.186 – CONSTINWRT
Message Const variable resides in wrt extern model.
Description The current extern model places all external objects
in a modifiable section. Placing an object with a
const type qualifier in such a section means that
there is no run-time protection against writing to
the object. This might not have been what you
intended.
User Action Place const objects in sections that cannot be
modified.
56.187 – CONSTNOINIT
Message <Context> the const object "<name>" is uninitialized.
Description A defined or tentatively-defined const object has not
been initialized. This would not be valid in C++.
It is also considered good programming practice to
initialize all const objects with their value.
User Action Either remove the const type modifier, or supply an
initializer for the object.
56.188 – CONSTSTOCLS
Message <Context> the const object "<name>" has no explicit
storage class. In C, its storage class defaults to
"extern"; in C++, it defaults to "static". Add an
explicit "extern" or "static" keyword.
Description One of the more signifcant and confusing differences
between C and C++ is their treatment of file scope
const objects declared without a storage class. C
will give the object extern storage class, making the
object visible in other compilation units. C++ will
give the object static storage class. This can cause
an undefined symbol error when other compilation
units try to reference the symbol.
User Action Add an explicit "extern" or "static" keyword to the
declaration.
56.189 – CONTFILE
Message A file ends with a continuation character.
Description All source files, even those included via the
#include preprocessing directive, must not end with a
backslash continuation character.
User Action Either remove the continuation character or add an
additional line to the source program that does not
end in a continuation character.
56.190 – CONTROLASSIGN
Message <Context> the assignment expression "<expression>" is
used as the controlling expression of an if, while or
for statement.
Description A common user mistake is to accidentally use
assignment operator "=" instead of the equality
operator "==" in an expression that controls a
transfer. For example saying if (a = b) instead of
if (a == b). While using the assignment operator is
valid, it is often not what was intended. When this
message is enabled, the compiler will detect these
cases at compile-time. This can often avoid long
debugging sessions needed to find the bug in the
user's program.
User Action Make sure that the assignment operator is what is
expected.
56.191 – CONVARASLIT
Message <Context> the use of the const variable "<name>" in
place of a literal constant is a language extension.
Description HP C will allow a non-volatile const variable that
has been initialized to be used in contexts where a
constant is required. For example, as the bounds
specifier to a file scope array. This is an
extension to standard C. Other C compilers might not
successfully compile a program that uses this
extension.
User Action Use the constant value instead of the variable.
56.192 – CRXCOND
Message Common Data Dictionary description extraction
condition.
Description Something went wrong while trying to get the CDD
record description from the CDD. The error message
that follows gives more information about the nature
of the problem.
User Action If necessary, correct the indicated condition in the
CDD record description or with the user environment.
56.193 – CVIDXOVFL
Message module uses more than 65536 CodeView type indices
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.194 – CVTDIFTYPES
Message <Context> "<expression>" of type "<type>", is being
converted to "<target type>".
Description In certain modes, the compiler will allow assignments
or comparisons between pointer and integer types.
This is an extension to standard C. Other C
compilers might not successfully compile a program
that uses this extension.
User Action Use a cast operator to convert one operand to the
other.
56.195 – CVTU32TO64
Message <Context> an unsigned 32-bit integer constant that
has its high-order bit set has been converted to a
signed 64-bit type. The conversion will not
sign-extend.
Description This message indicates a conversion that may produce
unexpected results on this platform because the
destination type is a 64-bit type instead of a 32-bit
type.
User Action If this is the intended behavior, first cast the
constant to an unsigned 64-bit type.
56.196 – CXXCOMMENT
Message C++ style comments (//) may not be portable.
Description C++ style comments have been detected on this line.
Although they have been accepted by HP C in this
language mode, they will not be accepted by all
compilers or by HP C in strict C89 standard mode.
User Action Replace C++ style line comments (//) with equivalent
C comments (/* ... */) if portability is a concern.
56.197 – CXXKEYWORD
Message "<C++ keyword>" is a keyword in C++. Using it as an
identifier in your C program will prevent porting
your program to C++.
Description This identifier is a keyword in C++. The program is,
therefore, not a valid C++ program.
User Action Choose a different name for the identifier.
56.198 – CXXPRAGMANA
Message The HP C++ pragma "<pragma name>" is not supported by
HP C. The pragma will be ignored.
Description The compiler has encountered a pragma that is
supported by HP C++ but is not supported by HP C.
The compiler will ignore the pragma.
User Action Remove the pragma or compile the program with HP C++.
56.199 – DCLMISMATLNK
Message The declaration of "<name>" has <number> parameter(s)
but its linkage "<name>" has <number>. Standard
linkage will be used.
Description The number of parameters specified in a declaration
does not match the number of parameters specified by
the special linkage associated with this function or
typedef. The special linkage was specified via the
#pragma use_linkage directive. Because of this
mismatch, the compiler will ignore the special
linkage and use the standard linkage instead.
User Action Make sure the number of parameters specified by the
special linkage match the number of parameters in the
function.
56.200 – DCLMISMATLNK0
Message The declaration of "<name>" has an unknown number of
parameters and cannot be used with the linkage
"<name>". Standard linkage will be used.
Description If a special linkage specifies parameter information,
the declaration must not specify an unknown or
variable number of parameters. The special linkage
was specified via the #pragma use_linkage directive.
Because of this mismatch, the compiler will ignore
the special linkage and use the standard linkage
instead.
User Action Make sure the number of parameters specified by the
special linkage match the number of parameters in the
function type.
56.201 – DCLMISMATLNK1
Message <where> "<name>" <modifier>has a floating type but
its linkage "<name>" specifies an integer register.
Standard linkage will be used.
Description A parameter or return value of a function type is a
floating type, but the corresponding parameter or
return value in the special linkage specifies an
integer register. The special linkage was specified
via the #pragma use_linkage directive. Because of
this mismatch, the compiler will ignore the special
linkage and use the standard linkage instead.
User Action Make sure the register specified by the special
linkage matches the type of of the corresponding
parameter and return value of the function type.
56.202 – DCLMISMATLNK2
Message <where> "<name>" <modifier>requires an integer
register but its linkage "<name>" specifies a
floating register. Standard linkage will be used.
Description A parameter or return value of a function type is an
integer type, but the corresponding parameter or
return value in the special linkage specifies a
floating register. The special linkage was specified
via the #pragma use_linkage directive. Because of
this mismatch, the compiler will ignore the special
linkage and use the standard linkage instead.
User Action Make sure the register specified by the special
linkage matches the type of of the corresponding
parameter and return value of the function type.
56.203 – DCLMISMATLNK3
Message <where> "<name>" has a size that is incompatible with
the number of registers specified by its linkage
"<name>". Standard linkage will be used.
Description The size of a parameter or return value of a function
type is incompatible with the size specified by the
special linkage. The special linkage was specified
via the #pragma use_linkage directive. Because of
this mismatch, the compiler will ignore the special
linkage and use the standard linkage instead.
User Action Make sure the number of registers specified by the
special linkage match the type of the corresponding
parameter and return value.
56.204 – DCLMISMATLNK4
Message <where> "<name>" <modifier>has a type that is not
allowed because the it has the linkage "<name>".
Standard linkage will be used.
Description Using a special linkage places certain restrictions
on the type of a function's parameters and return
value. In general, the type must be a scalar type
that can be represented by a register or registers on
this platform. In cases where some other type is
used, the compiler will ignore the special linkage
and use the standard linkage instead.
User Action Either remove the name from the #pragma use_linkage
directive that specified the special linkage, or
modify the type to be acceptable to the special
linkage.
56.205 – DCLMISMATLNK5
Message "<name>" has a void return type but its linkage
"<name>" specifies a return location. Standard
linkage will be used.
Description If a special linkage specifies return value
information, the declaration must not specify a void
return type. The special linkage was specified via
the #pragma use_linkage directive. Because of this
mismatch, the compiler will ignore the special
linkage and use the standard linkage instead.
User Action Make sure the return value specified by the special
linkage matches the return type.
56.206 – DCLMISMATLNK6
Message <where> "<name>" <modifier>has float _Complex or
double _Complex type. The corresponding floating
point registers in linkage "<name>" must be
consecutive. Standard linkage will be used.
Description Using a special linkage places certain restrictions
on the type of a function's parameters and return
value. Whenever float _Complex or double _Complex
types are used, they linkage must specify two
consecutive floating point registers. The compiler
will ignore the special linkage and use the standard
linkage instead.
User Action Either remove the name from the #pragma use_linkage
directive that specified the special linkage, or
modify the linkage to use consecutive floating point
registers.
56.207 – DECCONSTLARGE
Message Decimal constant value too large.
Description A decimal constant used in a preprocessor directive
is too large. The value of the constant will be
undefined.
User Action Decrease the value of the constant.
56.208 – DECLAFTERSTMT
Message Placing a declaration after a statement is a new
feature in the C99 standard. Other C compilers may
not support this feature.
Description This is a new language feature in the C99 revision of
the standard. While having a standard specification
for portability, the feature may not yet be available
in all of the compilers you use.
User Action Determine whether or not the use of this feature will
cause portability problems for this code.
56.209 – DECLARATOR
Message Invalid declarator.
Description A declaration did not contain an identifier that
specifies the item to be declared.
User Action Specify a declarator in the declaration.
56.210 – DECLINFOR
Message Placing a declaration in a for loop is a new feature
in the C99 standard. Other C compilers may not
support this extension.
Description This is a new language feature in the C99 revision of
the standard. While having a standard specification
for portability, the feature may not yet be available
in all of the compilers you use.
User Action Determine whether or not the use of this feature will
cause portability problems for this code.
56.211 – DECLSPECEXT
Message __declspec is a language extension.
Description The __declspec storage class modifier is a language
extension of HP C. Other C compilers might not
successfully compile a program that uses the
extension.
User Action Be aware of this extension if you wish to port the
code.
56.212 – DEFINOTHER
Message Another file in this compilation contains an external
definition of a function named "<name>", or declares
it as a variable with external linkage, at <where>.
Description In a compilation where interfile optimization has
been selected (-ifo on UNIX, /PLUS_LIST_OPTIMIZE on
OpenVMS), the compiler has detected more than one
definition of a function using the same external
name, or has found that a function and a variable
have the same external name. An external function
can have only a single definition. And a given
identifier with external linkage can refer either to
a function or to a variable, but not both.
User Action Remove or rename one of the names.
56.213 – DEFINOTHER1
Message The external variable "<name>" was defined as an
external function in another module of this
compilation at <where>.
Description In a compilation where interfile optimization has
been selected (-ifo on UNIX, /PLUS_LIST_OPTIMIZE on
OpenVMS), the compiler has detected a name with
external linkage defined as a variable in one
compilation unit and a function in another.
User Action Remove or rename one of the definitions.
56.214 – DEFINOTHER2
Message This declaration of "<name>" specifies a different
type than the declaration in another module of this
compilation at <where>.
Description In a compilation where interfile optimization has
been selected (-ifo on UNIX, /PLUS_LIST_OPTIMIZE on
OpenVMS), the compiler has detected a name with
external linkage declared with different types in two
different modules. Although the runtime behavior may
be as intended and match the behavior when the
modules are separately compiled without interfile
optimization, the behavior is not well defined unless
the types are compatible.
User Action Modify one or more of the declarations to make the
types compatible.
56.215 – DEFINOTHER3
Message This declaration of "<name>" specifies a different
thread-local attribute than a declaration in another
module of this compilation at <where>.
Description In a compilation where interfile optimization has
been selected (-ifo on UNIX, /PLUS_LIST_OPTIMIZE on
OpenVMS), the compiler has detected a name with
external linkage declared thread-local in one module
and not thread-local in another. This can lead to
unexpected results at runtime.
User Action Modify one the declarations to make the thread-local
attributes match.
56.216 – DEFPARMTYPE
Message There is no declaration for the old-style function
parameter "<name>". Type defaulted to int. This is
a violation of the C99 standard.
Description The parameter of an old-style function definition was
not declared. It will default to int type. Omitting
the type specifier is not valid in C99, and is often
considered poor programming practice.
User Action Declare the parameter. HP also recommends that
old-style function definitions be replaced by
prototype-format definitions.
56.217 – DEFRETURNTYPE
Message The type of the function <name> defaults to "int".
Description A function definition did not include a type
specifier for the function's return value. It will
default to int. This might not be what you intend.
This is also a violation of the C99 Standard.
User Action It is a good programming practice to give all
function definitions explicit return types.
56.218 – DESIGBADARR
Message <Context> , a struct/union designator cannot be used
with an object of array type.
Description An initialization designator must match the type of
the object being initialized. In this
initialization, the current object is an array so a
struct/union designator is not allowed.
User Action Correct the initialization.
56.219 – DESIGBADCOMP
Message <Context> , an array designator cannot be used with
an object of struct or union type.
Description An initialization designator must match the type of
the object being initialized. In this
initialization, the current object is a struct or
union, so an array designator is not allowed.
User Action Correct the initialization.
56.220 – DESIGBADIND
Message <Context> , the constant expression "<expression>" in
an array element designator is not a positive
integer.
Description An array-element designator must be an constant
expression that yields a positive integer value.
User Action Correct the element designator.
56.221 – DESIGBADIND1
Message <Context> , the array element designator
"[<expression>]" specifies an element beyond the end
of the array.
Description An array element designator must specify a valid
array element.
User Action Correct the element designator.
56.222 – DESIGNATIONNA
Message The use of a designation in an initializer list is
not supported in this compilation mode.
Description Initializer lists that contain designations are a new
feature in the C99 revision of the C standard. HP C
will only support this extension in relaxed mode and
strict c99 mode.
User Action Use a compilation mode that supports the use of
designations.
56.223 – DESIGNATORUSE
Message The use of a designation in an initializer list is a
new feature in the C99 standard.
Description Initializer lists that contain designations are a new
feature in the C99 revision of the C standard. Other
compilers may not support this feature.
User Action Be aware of this portablility issue.
56.224 – DESIGNOMEMB
Message <Context> , the component designator "<name>" is not
a member of the current structure or union object
being initialized.
Description An initialization designator specifies a struct or
union member that is not a member of the current
struct or union object.
User Action Correct the initialization.
56.225 – DESIGSCALAR
Message <Context> , a designator cannot be used with an
object of scalar type.
Description An initialization designator can only be used on
objects of array, structure, or union type. In this
initialization, the current object being initialized
is a scalar type so a designator is not allowed.
User Action Correct the initialization.
56.226 – DIFFEXMODEL
Message This redeclaration of "<name>" specifies a different
extern model than a previous declaration of the
variable at <location>.
Description Two declarations of the same variable use different
extern models. The extern model is specified by a
#pragma extern_model directive that appears before
the declaration in the source. This redeclaration
may cause unexpected behavior.
User Action All declarations of a variable should use the same
extern model.
56.227 – DIFFTYPEQUALS
Message <Context> the type of "<name>" has different type
qualifiers than the previous declaration at
<location>. The resulting type will be the composite
of the two types.
Description The C standard permits redeclaration and formation of
a composite type only when the two types being
considered are compatible, and types with different
type qualifiers are not compatible. HP C allows this
redeclaration for consistency with some other C
compilers, and will form a composite type with all of
the type qualifiers from both declarations. Be aware
that these declarations may not be accepted by other
C compilers.
User Action Modify the declarations so that they use identically
qualified types.
56.228 – DIRECTVNOCPP
Message "<Directive text>" is not recognized as a
preprocessing directive in nopreprocessing mode, and
is being ignored.
Description An invalid preprocessing directive was encountered in
a compilation performed with the -nocpp option. When
using the -nocpp option, only a limited number of
preprocessing directives, such as #pragma and #line,
can appear in the program. The compiler will ignore
the rest of the line.
User Action Either remove the directive or compile without the
-nocpp option.
56.229 – DISREDECL
Message <Context> the type of the external "<name>" is not
compatible with the type of a declaration of "<name>"
in another name scope at <location>.
Description The same external identifier has been declared in
different scopes with incompatible types. This might
not have been what you intended.
User Action Change all declarations of the same external
identifier to use the same type.
56.230 – DOLLARID
Message Extension: A '$' was encountered in an identifier.
Description Accepting a "$" character in an identifier is an
extension of HP C. The program might not compile
with other C compilers.
User Action Be aware of this if you wish to port the program.
56.231 – DONOTAPPLY
Message linkage, assert or hint information for built-in
function <name> is ignored.
Description A built-in function is always handled specially.
There is no actual function call to which linkage,
assert or hint information could be applied.
User Action Remove the name of the built-in function from this
pragma.
56.232 – DUPCASE
Message The switch statement containing this case label
already has a case label for "<number>".
Description A switch statement contains more than one case label
for the same case value.
User Action Remove the duplicate case label.
56.233 – DUPDEFAULT
Message The switch statement containing this default label
already has a default label.
Description A switch statement can contain only one default
label.
User Action Remove the duplicate default label.
56.234 – DUPENUM
Message <Context> the enumerator "<name>" is not unique.
Description An enumerator constant is declared more than once
with the same value. While this is accepted by HP C,
it is not allowed by the C standard.
User Action Either use a different enumerator name or remove the
previous declaration of the name.
56.235 – DUPEXTERN
Message The declaration of "<name1>" will map to the same
external name as the declaration of "<name2>" at
<where>.
Description The compiler has detected a case where two different
names in a program will map to the same external name
in the output object file. This can cause
unpredictable results at runtime. This will most
often happen when the /NAMES=UPPERCASE or
/NAMES=LOWERCASE qualifier causes two names with
different case spellings to map to the same external
name.
User Action Either use the /NAMES=AS_IS qualifier, or modify one
of the names.
56.236 – DUPLABEL
Message The label "<name>" is already defined in this
procedure at <location>.
Description A label has already been defined. Each function can
define each label only once.
User Action Remove the duplicate label definition.
56.237 – DUPLINK
Message Duplicate linkage pragmas for linkage name "<linkage
name>".
Description The same linkage specifier has been defined in more
than one #pragma linkage directive.
User Action Declare each linkage only once.
56.238 – DUPLPRAGASS
Message #pragma assert directive specified for the function
name <name> while different #pragma assert was
specified for its type.
Description Duplicate assertion can't be specified for a
function. Check whether #pragma assert was
mistakenly specified for the same function more than
once, or function's type is declared in a typedef
which in turn has its own #pragma assert directive.
User Action Either remove duplicate #pragma assert directive, or
change assertions, or fix spelling of the function
name or typedef.
56.239 – DUPPARM
Message <Context> "<name>" is a duplicate parameter name.
Description The parameter identifier list of an old-style
function definition uses the same identifier more
than once.
User Action Each identifier in the parameter list must be unique.
HP also recommends that old-style function
definitions be replaced by prototype-format
definitions.
56.240 – DUPSTATIC
Message There is a redundant use of the keyword "static" in
this array declaration.
Description In C99 the keyword "static" may appear at most once
in the outermost array-bounds specifier of a function
parameter in a function prototype.
User Action Remove redundant occurrences(s) of "static" from the
array declaration
56.241 – DUPSTORCLS
Message <Context> the same storage class modifier occurs more
than once.
Description This declaration specifies the same storage class
modifier more than once.
User Action Remove the extra uses of the storage class modifier.
56.242 – DUPTYPEDEF
Message <Context> "<name>" has a duplicate typedef at
<where>. This might not be portable.
Description The same typedef has been declared to the same type
more than once. Standard C does not allow this and
other compilers might not accept it.
User Action Remove the redundant declaration.
56.243 – DUPTYPESPEC
Message <Context> the same type specifier occurs more than
once.
Description The same type specifier appears more than once in the
same declaration. The redundant specifier will be
ignored.
User Action Remove the duplicate type specifier.
56.244 – DUPTYPQUAL
Message <Context> there is a redundant use of type qualifier
"<const or volatile>".
Description The same type qualifier appears more than once in a
type specifier. This violates the C89 standard.
Other compilers may not accept this program. Note
that C99 will allow redundant qualifiers.
User Action Remove the redundant type qualifier.
56.245 – ELIFIGNORED
Message Out of place #elif directive ignored.
Description An #elif preprocessing directive was encountered
outside of an #if/#endif body. The directive will be
ignored.
User Action Remove the directive.
56.246 – ELLIPSEARG
Message Standard C does not permit the use of an ellipsis as
an only argument.
Description Standard C requires at least one formal parameter be
declared before the ellipses. This declaration might
not be portable to other C compilers.
User Action Recode the function declaration to contain at least
one formal parameter.
56.247 – ELLIPSEPARM
Message <Context> a parameter with type "<type>" matches an
ellipsis in previous declaration at <location>.
Description A function that has been previously declared as
taking variable arguments is now redeclared as using
a different number of formal parameters before the
start of the variable argument list. This
redeclaration might not be portable to other C
compilers.
User Action Recode the function declarations to match each other.
56.248 – ELLIPSISEND
Message No tokens may follow ... in a formal parameter list.
Description The ellipsis may only appear at the end of a formal
parameter list. Everything after that is being
ignored.
User Action Remove the unexpected token.
56.249 – ELSEIGNORED
Message Out of place #else directive ignored.
Description An #else preprocessing directive was encountered
outside of an #if/#endif body. The directive will be
ignored.
User Action Remove the directive.
56.250 – EMBEDCOMMENT
Message A comment is neither preceded nor followed by white
space.
Description A comment is neither preceded nor followed by white
space. In certain modes the compiler will paste the
tokens before and after the comment together to form
a single token. This behavior is not valid in
standard C. Writing programs that rely on this
behavior might prevent the program from being
compiled on other platforms.
User Action Add white space before or after the comment, or use
the ## operator to paste tokens together.
56.251 – EMPTYCHARCONST
Message Empty character constant.
Description In some modes the HP C compiler will allow a null
character constant. The compiler will give this
constant a value of zero. Accepting an empty
character constant is a language extension. Empty
character constants are not valid in standard C.
Writing programs that rely on this behavior might
prevent the program from being compiled on other
platforms.
User Action Replace the empty character constant with '\0'.
56.252 – EMPTYFILE
Message Source file does not contain any declarations.
Description This source file contains no declarations. This
might not have been what you intended. For example,
perhaps a necessary macro was not defined.
User Action Every source program should contain at least one
declaration.
56.253 – EMPTYINIT
Message An initializer list without an expression is not
valid. The compiler will replace the empty
expression with the constant 0.
Description The C standard requires that an initializer list
contain an expression. The compiler has encountered
one without an expression. The compiler will treat
the empty list ({}) as if it contained a single zero
({0}). This is for compatibility with some other C
compilers. Be aware that this syntax may not be
accepted by other C compilers.
User Action Supply an expression to the initializer.
56.254 – EMPTYOBJ
Message Empty object file due to errors.
Description An earlier condition will cause an empty object
module to be created.
User Action Correct the condition that was reported earlier.
56.255 – EMPTYSTRUCT
Message Allowing struct/union type with no members is a
language extension.
Description The C standard requires that a struct/union type have
at least one member. The HP C compiler will accept
this for compatibility with older compilers. The
struct/union type will be treated as if it were
declared { : 0; }
User Action Provide at least one member for the struct/union.
56.256 – ENUM16BIT
Message <Context> the enumeration constant <name> is out of
the range -32768 to 32767. This might not be
portable.
Description An enum constant is larger than can be represented in
16 bits. This would not be portable to a system with
an int size of 16 bits.
User Action Be aware of this if you wish to port to a system with
an int size of 16 bits.
56.257 – ENUMCALC
Message <Context> the enum variable "<expression>" is used in
an arithmetic operation.
Description An enumerated type variable was used in an arithmetic
operation. While this is valid in C, it might not
have been what you intended.
User Action Verify the use of the enum variable.
56.258 – ENUMINIT
Message <Context> the enumerator "<name>" is initialized to
the nonintegral value "<expression>".
Description An enum declaration contains an enumeration constant
initializer that does not have an integer type. The
initializer for an enumeration constant must be an
integral constant expression.
User Action Correct the initializer.
56.259 – ENUMRANGE
Message <Context> the enumeration constant "<name>" is out of
range INT_MIN to INT_MAX and will be truncated.
Description An enumeration constant must be representable as an
int type. The specified value is outside the range
of an int. In modes where this is a warning, the
compiler will use the low-order bits to form the int
value.
User Action Use a valid constant value.
56.260 – ENUMSANDINT
Message <Context> allowing an enumeration type and a signed
int to be compatible may not be portable.
Description The standard states that enumeration types shall be
compatible with an integer type. HP C, along with
most other C compilers, has chosen the signed int
type to be compatible with enumeration types. Other
compilers may chose another type such as unsigned int
(the C standard even allows an implementation to
choose different integer types depending on the
values of the enumeration constants defined for the
type). Therefore this program may not be accepted by
other C compilers.
User Action Insert a cast to make the types the same.
56.261 – ENUMSNOTCOMPAT
Message <Context> allowing two different enumeration types to
be compatible is a language extension.
Description The HP C compiler allows two objects of different
enumeration types to be compatible. The C standard
specifies that enumeration types are distinct types.
Therefore this program is not standard compliant and
other C compilers may not accept it.
User Action Use the same enumeration type or cast one type to the
other.
56.262 – ENUMUSED
Message <Context> the enumerator name "<name>" has been used
previously.
Description The specified enumerator name has been previously
declared as something other than an enumerator.
User Action Either use a different enumerator name or remove the
previous declaration of the name.
56.263 – ENVIRSTKDIRTY
Message At the end of the compilation the pragma <name> stack
was not empty. This may indicate a coding error.
Description The program being compiled has saved the named pragma
state more often than it has restored it. Good
coding practice calls for the pragma state to be
restored some point after it has been saved. This
condition may indicate the accidental failure to
restore the state.
User Action Make sure each pragma save has a corresponding pragma
restore.
56.264 – ERRORLIM
Message diagnostic message limit exceeded
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.265 – ERRORMESSAGE
Message #error<errormsg>
Description An #error directive was encountered. This message
will include the text that follows the directive in
the source program.
User Action Remove the #error directive, or supply the proper
macro definitions so that the compiler will skip the
directive.
56.266 – ESCOVERFL
Message Invalid escape sequence encountered.
Description An escape sequence in a character or string literal
specifies a value outside the range of a character or
wide character.
User Action Specify a valid escape sequence.
56.267 – EXPANDEDDEFINED
Message Macro expansion includes the token "defined", which
will be treated as an operator. This might not be
portable.
Description A macro expanded during the processing of a
preprocessor #if directive included the token
"defined". The HP C compiler will treat this as the
defined preprocessing operator. Other compilers
might treat this differently.
User Action Rewrite the macro not to use the "defined" operator.
56.268 – EXPNOTRES
Message expression does not contribute to result
Description The compiler has detected a source expression that
does not contribute to the result. This may not be
what you expected.
User Action Verify the expression is what you intend.
56.269 – EXPRCVTINT
Message The expression "<expression>" has been converted to
integer.
Description In certain modes, HP C will allow switch expressions
or case constants to be non-integer types. The
expression or constant will be converted to int. In
one of these cases, this warning will be issued.
User Action Cast the switch expression to an integer type or use
an integer case constant.
56.270 – EXPRNOTINT
Message The expression "<expression>" has <type> type, which
is not integral.
Description An expression that is required to have an integer
type had a type that is not integral. This is not
valid. An example of a situation where an integer is
required is that in most modes HP C requires that the
switch control expression have integer type.
User Action Modify or cast the expression so that it has integer
type.
56.271 – EXPRNOTUSED
Message <Context> the expression "<expr>" is never used.
Description The compiler has detected an expression that is not
used, and might not have a side-effect. This might
not have been what you intended.
User Action If the expression has a desired side-effect, the
message can be ignored. Otherwise, you might want to
consider removing the expression.
56.272 – EXTENDTYPE
Message This platform specific type is a language extension.
Description The use of the types __int8, __int16, __int32,
__int64, or other type specifiers beginning with
leading double underscores might not be portable to
other platforms or to other C compilers.
User Action Be aware of this portability concern.
56.273 – EXTERNINIT
Message HP C allows the initialization of a variable with
extern storage class. This differs from the VAX C
behavior.
Description VAX C does not allow a variable with extern storage
class to be initialized. HP C will allow this, even
in vaxc mode.
User Action Be aware of this difference if you plan to compile
the source with VAX C.
56.274 – EXTERNPOP
Message This "restore" has underflowed the extern model's
stack. No corresponding "save" was found.
Description The extern_model stack, managed by the #pragma
extern_model and #pragma environment directives,
contains more restores than saves. This could
signify a coding or logic error in the program.
User Action Make sure each restore has a corresponding save.
56.275 – EXTPREAFTER
Message This directive will not set the extern_prefix of
"<name>" because there is a previous declaration of
the identifer with external linkage at <where>.
Description When an identifier is specified in a #pragma
extern_prefix, the declaration of that identifier
must appear after the #pragma.
User Action Reorder the declaration and the #pragma so that the
#pragma comes first.
56.276 – EXTPREAGAIN
Message This directive overrides the extern_prefix for
"<name>" specified by an earlier #pragma
extern_prefix at <where>.
Description Two #pragma extern_prefix directives have specified
different non-empty extern_prefixes for the same
identifier. In such cases the later directive will
set the extern_prefix for the identifier.
User Action If it is necessary to respecify the extern_prefix for
an identifier, first remove the prefix (by setting it
to an empty string) and then specify the new prefix
in a subsequent #pragma.
56.277 – EXTPRENODECL
Message There is no identifier named "<name>" with external
linkage declared in this compilation unit.
Description A #pragma extern_prefix directive specifies an extern
prefix for an identifier that is not declared with
external linkage in the compilation unit. This may
not have been what you intented.
User Action Remove the identifier from the #pragma extern_prefix,
or declare it with external linkage, or set the
prefix for this identifier to an empty string.
56.278 – EXTRABRACES
Message <Context> , the value is enclosed within too many
pairs of braces.
Description An initializer contains too many open braces for the
object being initialized.
User Action Reduce the number of braces.
56.279 – EXTRAMODULE
Message Redundant "#pragma module" or "#module" directive
ignored.
Description A compilation unit can contain only one #pragma
module or #module directive. All subsequent
directives will be ignored.
User Action Remove the extra directives.
56.280 – EXTRAPRAGARGS
Message Extra pragma arguments to #pragma <pragma> were
found. Pragma is ignored.
Description Unexpected arguments were found at the end of a
#pragma directive. The directive will be ignored.
User Action Remove the extra arguments.
56.281 – EXTRASEMI
Message Extraneous semicolon.
Description An extra semicolon was found at the end of a
declaration. It will be ignored.
User Action Remove the extra semicolon.
56.282 – FALLOFFEND
Message The last statement in non-void function "<name>" is
not a return statement.
Description A function that returns a value does not end with a
return statement. If function execution reaches the
end of the function, the implied return statement
that executes will return an undefined value. This
might not have been what you intended.
User Action End the function with a return statement that
specifies a return value.
56.283 – FBFILENOTFOUND
Message Feedback file not found: <text>
Description The specified feedback file could not be found by the
compiler.
User Action Specify the correct file name.
56.284 – FILECLOSE
Message An error occurred while attempting to close a source
file: <problem>.
Description An unexpected error occurred while closing a source
file. The message text will contain additional
information about the failure.
User Action Correct the condition that caused the failure.
56.285 – FILENOTFOUND
Message File not found: <text>
Description The specified file could not be found by the
compiler.
User Action Specify the correct file name.
56.286 – FILEREAD
Message An error occurred while attempting to read a source
file: <problem>.
Description An unexpected error occurred while reading a source
file. The message text will contain additional
information about the failure.
User Action Correct the condition that caused the failure.
56.287 – FILESCOPEVLA
Message <Context> the file-scope identifier "<name>" cannot
be declared with a variably modified type.
Description Only ordinary identifiers with block scope and
without storage class extern, or ordinary identifiers
with function prototype scope can be declared with a
variably modified type.
User Action Correct the declaration.
56.288 – FINBRANCH
Message A goto to the label "<label>" branches into a finally
handler.
Description A goto statement tried to transfer into a finally
handler. This is illegal.
User Action Modify the goto or move the label outside the
handler.
56.289 – FLEXARRAYELEM
Message <Context> allowing an array element to be a struct
with a flexible array member is a language extension.
Description The C99 standard allows the final element of a struct
with more than one named member to have incomplete
array type. Such a member is called a flexible array
member. The standard does not allow such a struct
(and any union containing, possibly recursively, a
member that is such a struct) to be an array element.
Other C compilers may not support this extension.
User Action Be aware of this extension if you wish to port the
code.
56.290 – FLEXARRAYMEM
Message <Context> allowing the struct member, "<name>" to be
a struct with a flexible array member is a language
extension.
Description The C99 standard allows the final element of a struct
with more than one named member to have incomplete
array type. Such a member is called a flexible array
member. The standard does not allow such a struct
(and any union containing, possibly recursively, a
member that is such a struct) to be a member of
another structure. Other C compilers may not support
this extension.
User Action Be aware of this extension if you wish to port the
code.
56.291 – FLOATCONSQUAL
Message The <float_const_qual> is not valid in strict ANSI
mode and will be ignored.
Description The -float_const option cannot be used in strict ANSI
mode. The option will be ignored.
User Action Either remove the -float_const option or use a
different mode.
56.292 – FLOATCONST
Message Ill-formed floating constant. Description An invalid floating constant was encountered. User Action Correct the floating constant.
56.293 – FLOATERR
Message <Context> a floating point error occurs in evaluating
the expression "<expression>".
Description A floating-point error occurred while evaluating a
constant expression. This is often caused by an
invalid floating-point number. The value of the
expression is undefined.
User Action Correct the floating-point constant expression.
56.294 – FLOATOVERFL
Message <Context> floating-point overflow occurs in
evaluating the expression "<expression>".
Description A floating-point overflow occurred while evaluating a
constant expression. The value of the expression is
undefined.
User Action Correct the floating-point constant expression.
56.295 – FLOATTOINT
Message <Context> "<expr>" is being converted from <type>
type to int type.
Description The C language requires that this expression be of
integer type. In most cases the compiler will emit
an error for this case. In VAX C mode, the compiler
emits this warning and converts the expression to int
type. This matches the behavior of VAX C.
User Action If the VAX C behavior is what you intended, cast the
expression to int to silence the diagnostic.
Otherwise, recode the expression to reflect your
intent.
56.296 – FMTNOTSTR
Message argument <number> of this function is not of type
char * but corresponds to the format string specified
by the #pragma assert directive at <location>. The
format func_attr will be ignored.
Description The format attribute causes the format string to be
checked if it is a string constant. The format
parameter can't be a format string because it is not
declared as a char * type. The format attribute will
be ignored.
User Action Either remove the format assertion from the
directive, correct the position of the format
argument in the assertion, or declare the format
argument as a "char *" in the proper position in the
function prototype.
56.297 – FNAMETOOLONG
Message The file name "<name>" in this directive is too long.
Description A preprocessing directive has specified a file name
that is too long for this platform.
User Action Supply a valid file name
56.298 – FORMATATTR
Message <Context> the arguments to <function name> do not
match the assertions of its format attribute. The
format argument or the argument preceeding the first
argument to check is missing.
Description The format attribute of this function asserts that
the format argument exists and will be checked if it
is a string constant. The first argument to check,
if non-zero, identifies the argument corresponding to
the ellipsis in the function declaration and asserts
that the argument preceeding it exists.
User Action Modify either the function call or the format
attribute so that they match.
56.299 – FOUNDCR
Message A carriage-return character was encountered; it is
being treated as white space.
Description The compiler encountered a carriage-return character
some place other than inside a character or string
constant. The compiler will treat the
carriage-return as white space.
User Action The source might have been created by some
non-standard means. If possible, replace all
carriage-return characters outside of character or
string constants with white space.
56.300 – FREGNEEDSIEEE
Message Use of the floating register "<regnum>" in a #pragma
linkage directive requires the /FLOAT=IEEE_FLOAT
qualifier.
Description On IA64, VAX floating-point data is passed in general
registers. HP C requires that any program that uses
a floating point register in a linkage directive must
be compiled with IEEE floating-point.
User Action Compile with IEEE floating-point. Another option
would be to remove the floating point registers from
the linkage.
56.301 – FUNCELEMENT
Message <Context> the element type of an array type is a
function type.
Description The compiler has encountered an array with an element
type of function. An array element must be an object
type.
User Action Change the type of the array element.
56.302 – FUNCIDLIS
Message <Context> the identifier "<id>" is not the name of a
type. All parameter information in this declaration
will be ignored.
Description The declaration is most likely a malformed
prototype-style function declaration. In a
prototype-style declaration, each parameter must have
a type. The identifier named in the message might be
intended to be the (optional) name of a formal
parameter and the type specification was mistakenly
omitted, or it might be intended to be the name of a
type but no typedef declaration for it is visible.
Alternatively, the declaration might be intended to
correspond to an old-style function definition, and
mistakenly contains a formal parameter name in the
declaration. Old-style function definitions list the
names of formal parameters (without types) inside the
parentheses, but old-style function declarations
contain nothing inside the parentheses.
User Action Correct the declaration.
56.303 – FUNCINIT
Message The declaration of the function "<name>" includes an
initializer.
Description A function declaration cannot contain an initializer.
User Action Remove the initializer from the declaration.
56.304 – FUNCMEM
Message The member <name> has a function type.
Description A struct or union member is declared with function
type. This is not valid.
User Action Correct the member declaration.
56.305 – FUNCMIXPTR
Message <Context> function types differ because this
declaration specifies "<type1>" and a previous
declaration specifies "<type2>".
Description A function redeclaration differs from an earlier
declaration of the same function because the pointer
size of one of the arguments or the return result is
different.
User Action Use the same pointer size for all declarations of the
function.
56.306 – FUNCNOTDEF
Message The function "<name>" has non-extern storage class,
occurs in a context that requires its definition, and
has no definition. The storage class has been
changed to extern.
Description In certain modes, the compiler will allow a static
function to be declared within the scope of another
function. If this function is referenced, then it
must also be defined in the compilation unit. If the
function is not defined, this message will be output,
and the earlier static declaration will be changed to
extern.
User Action Define the static function with compilation unit.
56.307 – FUNCNOTFUNC
Message In this function definition, "<name>" has <type> type
instead of a function type.
Description A function definition does not have a function type.
This can occur if the definition did not contain an
open/close parenthesis pair.
User Action Change the definition to specify a function type.
56.308 – FUNCREDECL
Message <Context> function types differ because one has no
argument information and the other has an ellipsis.
Description Two function types, used in an operation or a
redeclaration of a function, are different because
one uses ellipses and the other does not. Older
compilers will accept this, but it is not valid
standard C.
User Action If used in an operation, a cast should be inserted.
If used in a redeclaration, the redeclaration should
be removed or modified.
56.309 – FUNCSTORCLS
Message <Context> a function has an explicit storage class
other than "static" or "extern".
Description This declaration specifies a storage class that is
not valid for a function. If an explicit storage
class is used in a function declaration, it must be
either static or extern.
User Action Either remove the storage class specifier, or use one
of the valid storage classes.
56.310 – FUNCSTORMOD
Message <Context> a function cannot have this storage class
modifier. Modifier ignored.
Description A function cannot be declared with this storage class
modifier. The only valid storage class modifier for
a function declaration is __inline. The modifier is
ignored by the compiler.
User Action Remove the storage class modifier from the function
declaration.
56.311 – FUNCSTRCLS
Message The block-level declaration of the function "<name>"
specifies an explicit storage class other than
extern.
Description A block-level declaration of a function has specified
an explicit storage class other than extern. HP C
will change the storage class to extern.
User Action Either remove the storage-class specifier, or change
it to extern.
56.312 – FUTUREKEYWD2
Message "inline" is a keyword in the C99 revision of the C
standard. Using it as an identifier will prevent
your program from conforming to that standard.
Description The token inline has been selected as a keyword in
the C99 release of the C standard. Because the
program uses it as an identifier, the program will
not conform to that standard.
User Action Change the name of the identifier.
56.313 – FUTUREKEYWORD
Message "restrict" is a keyword in the C99 revision of the C
standard. Using it as an identifier will prevent
your program from conforming to that standard.
Description The token restrict has been selected as a keyword in
the C99 release of the C standard. Because the
program uses it as an identifier, the program will
not conform to that standard.
User Action Change the name of the identifier.
56.314 – GBLOUTSIDEINT
Message <Context> the globalvalue constant <value> is outside
the range of type int. This may cause unexpected
results.
Description The C compiler does not support globalvalue constants
larger than int. The compiler preserves only the
low-order 32 bits of the value, which will be
sign-extended by the linker if the symbol is used in
a certain contexts requiring a 64-bit value. This
may cause unexpected results.
User Action Use constants within the range of type int to
initialize globalvalues, or use more portable
constructs such as macro definitions or global
const-qualified variables to share constant values
among compilation units.
56.315 – GBLREFINIT
Message The declaration of "<name>" specifies the globalref
storage class and includes an initializer.
Description A declaration with storage class globalref cannot
include an initializer.
User Action Either remove the initializer or use a storage class
that will allow an initializer.
56.316 – GCCINLINE
Message The inline and __inline keywords will be interpreted
with GCC style semantics. To get C99 semantics,
please specify -accept nogccinline.
Description The C99 standard has a slightly different
interpretation of the keyword inline than in GCC.
The GCC __inline keyword also differs from the HP C
__inline keyword.
User Action Use the command line specifier -accept nogccinline.
56.317 – GEMARGSIZE
Message <Context> the size of "<expression>" exceeds the
implementation's limit of 2147483647 bytes on the
size of a function argument.
Description The size of a function argument exceeds the HP C
implementation limit.
User Action Either reduce the size of the argument or consider
passing it by reference.
56.318 – GLOBALEXT
Message A storage class of globaldef, globalref, or
globalvalue is a language extension.
Description These storage classes are language extensions of HP
C. Other C compilers might not successfully compile
a program that uses the extension.
User Action These storage classes can be recoded using the more
portable #pragma extern model. <code_example>
globaldef int var1; globalref int var2; globalvalue
int var3; <endcode_example> Can be written as:
<code_example> #pragma extern_model save #pragma
extern_model strict_refdef int var1; extern int var2;
#pragma extern_model globalvalue extern int var3;
#pragma extern_model restore <endcode_example> For
more information, consult the #pragma extern_model
documentation.
56.319 – GOTSZOVFL
Message GOT table overflow for module <text>
Description The object file required for this module is too
complex.
User Action Break the source program into several pieces so the
individual objects will be simpler.
56.320 – HEXOCTSIGN
Message In VAX C mode, the compiler will give this constant a
signed type for compatibility with VAX C. This
differs from the behavior specified in the C
standard, which would give this constant an unsigned
type.
Description The C standard specifies that an octal or hexadecimal
integer constant has an unsigned type when its value
cannot be represented in a signed integer type, but
can be represented in the corresponding unsigned
integer type. Some older compilers, such as VAX C,
will treat this constant as having a signed type. In
VAX C mode, the compiler matches the behavior of VAX
C. In other modes the compiler matches the behavior
specified in the standard.
User Action Be aware that this difference may cause porting
problems if this program is compiled in a mode other
than VAX C mode, or with a compiler that does not
support this old behavior.
56.321 – HEXOCTUNSIGN
Message The HP C compiler conforms to the C standard and will
give this constant an unsigned type. Some older
compilers may give this constant a signed type.
Description The C standard specifies that an octal or hexadecimal
integer constant has an unsigned type when its value
cannot be represented in a signed integer type, but
can be represented in the corresponding unsigned
integer type. Some older compilers will treat this
constant as having a signed type.
User Action Be aware of this difference if you plan to port this
source to an older compiler.
56.322 – HINTNOTFUNC
Message The identifier "<ident>" is not a declared function.
It will be ignored in this #pragma hint func_attrs
list.
Description The identifiers in a #pragma hint func_attrs must be
declared functions.
User Action Either declare the function prior to the pragma or
remove the identifier from the pragma.
56.323 – HINTTOOBIG
Message <Context> this hint value must not be greater than
one. The hint will be ignored.
Description This #pragma hint directives must take positive
floating point values which is not greater than one.
User Action Correct the hint.
56.324 – IDEXPECTED
Message Identifier expected but not found.
Description The compiler was expecting an identifier, but one was
not found.
User Action Correct the program syntax.
56.325 – IDINPARENSEXT
Message <Context> accepting an identifier enclosed in
parentheses as the second argument to va_start is a
language extension.
Description The C standard states that the second argument to
va_start must be an identifier. For compatibility
with other C compilers, HP C will accept an
identifier enclosed in parentheses. Be aware that
this program does not conform to the standard and may
be rejected by other compilers.
User Action Remove the parentheses.
56.326 – IDPACKPOPPRAG
Message The identifier <name> from the pragma pack pop
directive was not found on the top of the pragma pack
stack.
Description The identifier specified in the #pragma pack (pop,
<identifier>) directive was not found on the top of
the pragma pack stack. A previous #pragma pack pop
or #pragma member_alignment restore may have already
popped this identifier off the stack, the identifier
may not have been previously pushed onto the stack,
or extra elements are pushed on the stack on the top
of element with the identifier, or the identifer may
be spelled incorrectly.
User Action Check the spelling of the identifier. Verify that
the identifier was previously pushed onto the pack
stack and not popped off by another #pragma pack pop
or #pragma member_alignment restore, and all elements
pushed on the top of the identifier are popped.
Correct the directive(s).
56.327 – IEEEASSUMED
Message Use of /ROUNDING_MODE qualifier implies /FLOAT=IEEE.
Compilation will be performed as if /FLOAT=IEEE were
specified on the command line.
Description This compilation has specified an IEEE floating-point
rounding mode without specifying /FLOAT=IEEE on the
command line. The compiler will set the
floating-point type to IEEE floating.
User Action Specify /FLOAT=IEEE on the command line.
56.328 – IEEEASSUMED1
Message Use of /IEEE_MODE qualifier implies /FLOAT=IEEE.
Compilation will be performed as if /FLOAT=IEEE were
specified on the command line.
Description This compilation has specified an IEEE floating-point
mode without specifying /FLOAT=IEEE on the command
line. The compiler will set the floating-point type
to IEEE floating.
User Action Specify /FLOAT=IEEE on the command line.
56.329 – IGNORECALLVAL
Message <Context> the value returned from the function
"<expression>" is not used - if this is intended, it
should be cast to "void".
Description A function that returns a value has been invoked, yet
the value was not used. This might not have been
what you intended.
User Action Cast the function to void to suppress the message.
56.330 – IGNOREEXTRA
Message Spurious token(s) ignored on preprocessor directive
line.
Description A preprocessing directive was supplied more arguments
than it expects. The extra arguments will be
ignored.
User Action Remove the extra arguments.
56.331 – IGNORETAG
Message <Context> the tag "<name>" is redeclared, but will be
ignored.
Description The "struct" or "union" before the tag used in this
declaration does not match that in the declaration of
the tag. The "struct" or "union" at the earlier
declaration of the tag will be used in this
declaration.
User Action Either change the current declaration to match the
declaration of the tag, or create a new tag
containing the different type.
56.332 – IGNORETOKENS
Message # not in column 1 is ignored, skipping to end of
line.
Description In K & R mode, white space is not allowed before a
preprocessing directive. The compiler will ignore
this source line.
User Action Either remove the white space or compile in a mode
other than K & R.
56.333 – IGNORSYSREG
Message Ignoring system register specified in routine's
linkage.
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.334 – IMAGINARYNA
Message The _Imaginary keyword is not supported by HP C. It
will be treated as an identifier in this compilation.
Description Support for the _Imaginary keyword is an optional
extension to the C standard. HP C does not support
this extension. All occurrences of _Imaginary will
be treated as an identifier.
User Action Do not use the _Imaginary type.
56.335 – IMPFNCFALLOFF
Message The last statement in non-void function "<name>" is
not a return statement.
Description This message indicates that a function with an
implicit return type of it does not end with a return
statement. If function execution reaches the end of
the function, the implied return statement that
executes will return an undefined value. This might
not have been what you intended.
User Action Consider declaring the function to be a void
function. If it is supposed to return a value, add a
return statement with the value the function is to
return.
56.336 – IMPFNCMSSNGRET
Message Non-void function "<name>" with implicit return type
int does not contain a return statement.
Description This message indicates that a function with an
implicit return type of int does not contain a return
statement. This message is not issued for functions
with an explicit return type. See message
MISSINGRETURN.
User Action Consider declaring the function to be a void
function. If it is supposed to return a value, add a
return statement with the value the function is to
return.
56.337 – IMPLICITFUNC
Message <Context> the identifier "<name>" is implicitly
declared as a function.
Description A expression contained a reference to a function that
has not been declared. The C99 standard requires
that all referenced functions must be declared before
they are referenced.
User Action Declare the function before it is referenced.
56.338 – INCARGTYP
Message Type of actual argument inconsistent with formal
parameter declaration in <text>
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.339 – INCARRAYPARM
Message <Context> using array syntax to declare a parameter
that is a pointer to an incomplete array type may not
be portable.
Description Although this array parameter declaration conforms to
the C standard (since it is equivalent to a pointer
to the inner array), other C compilers may not accept
it.
User Action Be aware of this difference if you plan to port this
source to another compiler.
56.340 – INCARRAYPARM1
Message <Context> allowing an array parameter that has more
than two unspecified element counts is a language
extension.
Description Because this parameter declaration will cause an
array of incomplete types to be created, it does not
conform to the C standard. Although some other C
compilers will accept this declaration, many
compilers will reject it.
User Action Be aware of this difference if you plan to port this
source to another compiler.
56.341 – INCLUDENOPEA
Message A non-default pointer size or member alignment is
specified, and the header files in <directory> are
not protected. This might yield unpredictable
results. The protect_headers_setup script can help.
See the protect_headers_setup(8) man page for
details.
Description Using a non-default pointer size or member alignment
can cause unpredictable results for system header
files that are not protected and that rely on the
default pointer size or alignment.
User Action Examine the man page referenced in the message for
more information.
56.342 – INCLUDEOPEN
Message An error occurred while attempting to open the
include file <name>: <problem>.
Description An unexpected error occurred during the opening of an
include file. The message text will contain
additional information about the failure.
User Action Correct the condition that caused the failure.
56.343 – INCLUDEPROEPI
Message Cannot include files in a prologue or epilogue file.
Description It is not possible for a prologue or epilogue file to
perform an #include directive. This might lead to
nested inclusion.
User Action Remove the #include directive from the
prologue/epilogue file.
56.344 – INCOMPARRY
Message <Context> the member <name> has incomplete array
type. This is not strictly conformant with the C
standard and might not be portable.
Description The compiler has detected an array without a bounds
specifier to be part of a struct or union type. The
C89 standard does not allow members of this type.
The C99 standard will allow only the final member of
a struct with more than one named member to be of
this type. Other C compilers might not successfully
compile a program that uses this extension.
User Action Specify the bounds if possible.
56.345 – INCOMPARRY1
Message <Context> the last member of a union, or a struct
with only one named member, <name>, has incomplete
array type. This is not strictly conformant with the
C standard and might not be portable.
Description The compiler has detected an array without a bounds
specifier to be part of a struct or union type. The
C89 standard does not allow members of this type.
The C99 standard will allow only the final member of
a struct with more than one named member to be of
this type. Other C compilers might not successfully
compile a program that uses this
User Action Be aware of this extension if you wish to port the
code.
56.346 – INCOMPARRY2
Message <Context> the last member of a struct with more than
one named member, <name>, has incomplete array type.
This does not conform to the C89 standard.
Description The C89 standard does not allow struct members to be
an array without a bounds specifier. The C99
standard will allow the final member of a struct with
more than one named member to be an incompete type.
Other C compilers may not support this C99 extension.
User Action Be aware of this if you wish to port the code to a
compiler that does not support C99.
56.347 – INCOMPCALL
Message <Context> the return type of "<expression>" is
incomplete.
Description A function with an incomplete return type other than
void cannot be invoked.
User Action Complete the function return type before the function
is invoked.
56.348 – INCOMPDEREF
Message <Context> "<expression>" is a pointer to an
incomplete struct or union and should not be used as
the left operand of a member dereference.
Description In certain modes, HP C will allow the struct or union
specifier of a member dereference operator (->) to
specify a struct or union that does not contain the
element specified by the right operand. While this
is considered poor programming practice, it was
common with older C compilers. In cases where the
left operand is a pointer to an incomplete type, the
practice is considered even worse. While HP C will
accept the construct in certain modes, the code
should be modified. Further, this program does not
conform to the C standard and might not be accepted
by other C compilers.
User Action Be aware of this if you wish to port the program.
56.349 – INCOMPELINIT
Message <Context> , an array's element type is incomplete,
which precludes its initialization.
Description In order to initialize an array, the array element
type must not be incomplete.
User Action Either remove the initializer or complete the array
element type before this point in the program.
56.350 – INCOMPELMNT
Message <Context> the element type of an array type is
incomplete.
Description The element type of an array type is incomplete at
the point in the program where the array is declared.
While HP C will allow this if the element type is
completed later, other compilers might require the
type to be complete at this point in the program.
User Action Either complete the type before the array
declaration, or be aware of this if you wish to port
the program.
56.351 – INCOMPMEM
Message The member "<name>" has an incomplete type.
Description A struct or union member must not have an incomplete
type. An exception is that HP C will accept a member
that is an array with unspecified bounds, although
warnings are often generated for this case.
User Action Complete the type before it is used in as a member of
a struct or union.
56.352 – INCOMPNOLINK
Message In this declaration, "<name>" has no linkage and is
of an incomplete type.
Description A declaration with no linkage cannot specify an
incomplete type. Incomplete types can only be used
for identifiers with external or internal linkage.
User Action Either complete the type before the declaration or
modify the declaration to specify an external or
internal linkage.
56.353 – INCOMPPARM
Message In the definition of the function "<function name>",
the parameter "<parameter name>" has an incomplete
type.
Description This function definition contains a parameter with an
incomplete type other than an array whose bounds are
not specified. This is not valid.
User Action Complete the type before the function definition.
56.354 – INCOMPRETURN
Message In the definition of the function "<name>", the
return type is an incomplete type other than void.
Description A function definition cannot specify a return type
that is an incomplete type except for the void type.
User Action Complete the type before the function definition.
56.355 – INCOMPSTAT
Message The static declaration of "<name>" is a tentative
definition and specifies an incomplete type.
Description This file scope static declaration declares an
identifier with incomplete type. This is not valid
because a static declaration will allocate storage
for the object, but the object's size is not known at
this point in the compilation.
User Action Complete the type before the static declaration.
56.356 – INCOMPSTATARR
Message Allowing the declaration of a static array with an
incomplete type is a language extension.
Description The HP C compiler will allow an incomplete array type
to appear in a static file scope declaration for
compatibility with other compilers. This is an
extension to the standard. Other compilers may
reject this declaration.
User Action Either use a complete type in this declaration, or
change the storage class to extern.
56.357 – INCOMPTENT
Message The type of the tentatively-defined variable "<name>"
is incomplete at the end of the compilation unit.
Description This file-scope declaration with no storage-class
specifier declares an identifier with incomplete
type. The type must be completed before the end of
the compilation unit.
User Action Complete the type.
56.358 – INCOMPVALUE
Message <Context> "<expression>" has incomplete type, and so
cannot be used as an rvalue.
Description It is not possible to get the value of an expression
with incomplete type.
User Action Complete the type before its value is used.
56.359 – INCOMPVOID
Message <Context> the element type of an array type is
incomplete. The void type cannot be completed.
Description The compiler has encountered an array with an element
type of void. An array element must be an object
type.
User Action Change the type of the array element.
56.360 – INCONSASSFUN
Message A function "<name>" appeared in more than one #pragma
assert/hint func_attrs specifying the same
assertion/hints.
Description A function can appear on more than one #pragma assert
or #pragma hint func_attrs as long as each #pragma
specifies a different assertion/hint about the
function. The assertion will be ignored.
User Action Either remove the #pragma, or remove the function
name from the pragma, or correct its spelling.
56.361 – INITCONFLICT
Message Overlapping static storage initializations detected
at Psect <text> + <number>
Description The compiler back-end as detected a case where the
same storage location has been initialized to more
than one value. This can occur when inter-file
optimization has been enabled.
User Action Remove one of the initializers.
56.362 – INITOVERLAP1
Message <Context> , this initializer list will provide a
value for a subobject that was initialized by the
earlier initializer "<init>".
Description This initializer list will provide a value for a
subobject that has already been initialized. While
this is valid, it might not have been what was
intended.
User Action Initialize each subobject only once.
56.363 – INITVLA
Message A variable-length array declaration cannot contain an
initializer. The initializer will be ignored.
Description A variable-length array declaration cannot contain an
initializer.
User Action Initialize the array using assignment statements
after the declaration.
56.364 – INLINEIG
Message An inline specifier may only be used to declare an
identifier for a function. The inline keyword will
be ignored.
Description The inline, __inline or __forceinline keywords have
been used on a non-function type. Or a non-function
type has been listed in a #pragma inline or #pragma
forceinline directive
User Action Remove the keyword or remove the identifier from the
pragma.
56.365 – INLINESTOCLSMOD
Message The <__inline or __forceinline> storage class
modifier is a language extension and might not be
portable.
Description The __inline and __forceinline storage class
modifiers are an extension of HP C. Other C
compilers might not successfully compile a program
that uses the extension.
User Action Be aware of this extension if you wish to port the
code.
56.366 – INPTRTYPE
Message <Context> this argument to <function name> is of
"<type name>" type and is not appropriate for the
conversion specifier "<incorrect conversion>". The
value may overwrite other data or produce unexpected
results.
Description The compiler has detected an input conversion
specifier that does not match its corresponding
argument. The corresponding argument may not be a
pointer or may point to data that is wider or
narrower than that specified by the conversion
specifier. This might not have been what you
intended.
User Action Modify either the argument or the conversion
specifier so that they match.
56.367 – INSUFALN
Message Alignment specified for extern model is insufficient
for variable. Extern model alignment updated.
Description The current extern model places all external objects
in a section whose alignment is not sufficient for
the alignment of an object being placed in that
section. The compiler will update the alignment of
the section so that it is adequate for the object.
User Action Either increase the alignment of the section or move
the object to another section.
56.368 – INTBADLINKAGE
Message #pragma use_linkage was applied to the intrinsic
function "<routine name>". The function will be
treated as an ordinary external function.
Description Trying to optimize a pointer argument passed to an
intrinsic function, the compiler discovered that
#pragma use_linkage had been applied to the function
declaration. The intrinsic function of this name
that is understood by the compiler does not allow you
specify a linkage. Therefore the compiler must
assume that you are supplying your own function
definition, and treat this as a call to an external
function with no special properties.
User Action If you want to call the intrinsic function, remove
the #pragma use_linkage directive. If you are
supplying your own function definition, you may want
to rename the function or add a #pragma function
directive for it.
56.369 – INTCONCASTSGN
Message <Context> casting of the constant "<constant>" to
<type> type will cause a change in sign.
Description Either a negative constant value has been cast to an
unsigned type, or a positive value has been cast to a
signed type and will be treated as a negative number
after the cast.
User Action Change the constant so that the sign will match the
type of the cast.
56.370 – INTCONCASTTRU
Message <Context> casting of the constant "<constant>" to
<type> type will cause data loss.
Description A constant is cast to a type that is too small to
hold the constant value. Data will be lost in the
conversion.
User Action Remove the cast, or use a smaller constant.
56.371 – INTCONST
Message Ill-formed integer constant. Description An invalid integer constant was encountered. User Action Correct the integer constant.
56.372 – INTCONSTSIGN
Message <Context> conversion of the constant "<constant>" to
<type> type will cause a change in sign.
Description Either an unsigned type was assigned a negative
constant value, or a signed type was assigned a
positive contant value which will be evalated as a
negative number after the assignment. Note that this
message is not output for assignments to 1-bit
bitfields. The message bitconstsign is generated in
that case.
User Action If this is what you intended, cast the constant to
the desired type. You might also want to change the
constant to the correct signed or unsigned value in
order to avoid the optional message intconcastsgn,
which reports sign changes caused by casts.
56.373 – INTCONSTSIGNED
Message This integer constant value will be given the type
long long int. This is compatible with the C99
standard. Older versions of the compiler would have
given this unsigned long int type.
Description With the introduction of the long long int type, the
C99 standard changed the rules for how the type of
certain integer constants are determined. Unsuffixed
decimal constants which are too large for long int,
but could fit in an unsigned long int are given the
type long long int in C99. Prior to C99 these would
be given unsigned long int type.
User Action Be aware of this difference.
56.374 – INTCONSTTOOBIG
Message This integer constant is too large for the long long
type. It will be given the unsigned long long type.
Description The C99 standard specifies that a decimal constant
must fit in a signed type. This constant is too
large for the long long int type. For compatibility
with older versions of the compiler, the constant
will be given the unsigned long long type.
User Action Append a 'U' suffix to the constant. This will force
it to be unsigned.
56.375 – INTCONSTTRUNC
Message <Context> conversion of the constant "<constant>" to
<type> type will cause data loss.
Description A constant is converted to a type that is too small
to hold the constant value. Data will be lost in the
conversion.
User Action If this is what you intended, cast the constant to
the desired type. You might also want to mask off
the high-order bits before casting in order to avoid
optional message intconcasttru, which reports data
loss caused by casts.
56.376 – INTCONSTUNSIGN
Message This integer constant value will be given the type
unsigned long int. This is compatible with the C89
standard and older compilers. The C99 standard
requires this to be a signed long long int.
Description With the introduction of the long long int type, the
C99 standard changed the rules for how the type of
certain integer constants are determined. Unsuffixed
decimal constants which are too large for long int,
but could fit in an unsigned long int are given the
type long long int in C99. Prior to C99 these would
be given unsigned long int type.
User Action Be aware of this difference.
56.377 – INTERNALPRAGMA
Message This is an internal pragma which should only be used
by the compiler development team. It should not
appear in user programs as it may cause unexpected
behavior.
Description This pragma exists only to allow the compiler
developers to test certain functionality of the
compiler. Its use outside the development team is
unsupported.
User Action Remove the pragma.
56.378 – INTIMPLIED
Message In the declaration of "<name>", no type was
specified. Type defaulted to int. This is a
violation of the C99 standard.
Description The declaration contains a storage-class specifier,
but no type was specified. The compiler will assume
a type of int. Omitting the type specifier is not
valid in C++ or in C99, and is often considered poor
programming practice.
User Action Add a type specifier to the declaration.
56.379 – INTOVERFL
Message <Context> integer overflow occurs in evaluating the
expression "<expression>".
Description An integer overflow occurred while evaluating a
constant expression. The value of the expression is
undefined.
User Action Correct the constant expression so that it does not
overflow.
56.380 – INTRINSICCALL
Message <Context> an apparent invocation of intrinsic
function "<name>", <problem>. It will be treated as
an ordinary external call.
Description A function that could be handled internally by the
compiler has been called in a manner that is
inconsistent with expected usage. In such a case,
the compiler will generate a run-time call to the
function. This could result in performance loss.
User Action If the function is intended to refer to the runtime
library routine, the appropriate header file should
be included in the source to provide the full
function prototype and allow certain types of
argument conversions. Alternatively, call arguments
could be type cast as specified in the error message,
or the function prototype could be added by hand. If
the function is not intended to refer to the runtime
library routine, the intrinsic version can be
disabled by means of the "#pragma function
(function_name)" directive.
56.381 – INTRINSICDECL
Message <Context> the declaration for intrinsic function
"<name>" referenced at <location>, <problem>. It
will be treated as an ordinary external function.
Description A function that could be handled internally by the
compiler has been declared with a prototype that does
not agree with what the compiler expected to see, or
has been declared at block scope instead of file
scope. The function might in fact be a
similarly-named replacement for the expected
function, or the prototype might be incorrect or
misplaced. In such cases, the function will not be
handled internally, but will instead be called at run
time in the usual manner. This could result in a
performance loss.
User Action If the function is intended to refer to the runtime
library routine, the appropriate header file should
be included in the source (note that it is not
portable to include standard headers at other than
file scope). Alternatively, the prototype could be
modified as specified in the error message. If the
function is intended to be a replacement for the
runtime library routine, disable the intrinsic
version by specifying "#pragma
function(function_name)" in the source file.
56.382 – INTRINSICDECLER
Message <Context> the declaration for the prototyped
intrinsic function "<name>" is incorrect: <problem>.
Description A function that could be handled internally by the
compiler and requires a prototype, has been declared
with a prototype that does not agree with what the
compiler expected to see. The function might be
intended as a similarly-named replacement for the
compiler-known function, or the prototype might be
incorrect. The source must be modified to specify
the intended behavior.
User Action If the function is intended to refer to the
compiler-known routine, the appropriate header file
should be included in the source. Alternatively, the
prototype could be modified as specified in the error
message. If the function is intended to be a
replacement for the compiler-known routine, disable
the intrinsic version by specifying "#pragma
function(function_name)" in the source file.
56.383 – INTRINSICINT
Message <Context> the <place> type for intrinsic "<name>" is
being changed from "size_t" to "int".
Description A function that is handled internally by the compiler
expects an argument type or return type of "size_t",
but the prototype for the function uses "int". The
compiler will use "int" in this case.
User Action Declare the function by including the appropriate
header file. Alternatively, provide a private
declaration (or modify an existing private
declaration) with "size_t" in the appropriate
location(s), and with "size_t" defined as it is in
the standard system header files. If the function is
not intended to refer to the runtime library routine,
the intrinsic version can be disabled by means of the
"#pragma function (function_name)" directive.
56.384 – INTUNDFUN
Message There is no function declaration visible for the
identifier "<name>" at the point of this #pragma
<pragma type>.
Description An identifier specified in a #pragma intrinsic or
#pragma function directive must refer to a function
declaration visible at the point of the pragma. The
identifier will be ignored.
User Action Either remove the identifer from the pragma, correct
its spelling, or reorder the source to ensure that a
declaration of the identifier as a function is
visible at the point of the pragma.
56.385 – INVALIDARG
Message Invalid argument to <pragma> pragma. Pragma is
ignored.
Description An invalid argument has been specified for a pragma
directive. The compiler will ignore the directive.
User Action Correct the directive.
56.386 – INVALIDSTR
Message The # operator produced an invalid string.
Description During the expansion of a macro, the # stringize
operator produced a token that is not a valid string.
The operand to the stringize operator must contain
characters that form a valid string.
User Action Correct the operand to the stringize operator.
56.387 – INVALTOKEN
Message Invalid token discarded.
Description An unexpected token was encountered by the compiler.
The token has been ignored. An example is the
preprocessing operator "#" appearing outside a macro
body (int #a;).
User Action Remove the unexpected token.
56.388 – INVCPPINARGS
Message Possible directive "#<directive>" within a macro
argument list. The directive is treated as part of
the argument list, and not as a preprocessing
directive.
Description The compiler has encountered a directive as part of
the argument list of a macro invocation. This
directive will be treated as part of the argument
list, and not as a preprocessing directive. The
behavior might be different than other compilers.
User Action Rewrite the macro invocation so that it does not
include the directive.
56.389 – INVDUPENUM
Message <Context> the value of the enumerator "<name>"
conflicts with a previous declaration.
Description The specified enumerator name has been previously
declared with a different value.
User Action Either use a different enumerator name or remove the
previous declaration of the name.
56.390 – INVNOMEMPRAG
Message Invalid argument to nomember_alignment pragma.
Pragma is ignored.
Description The compiler was unable to parse a #pragma
nomember_alignment directive. The directive will be
ignored.
User Action Correct the directive.
56.391 – INVPACKPRAG
Message Invalid pack pragma. Pragma is ignored.
Description The compiler was unable to parse a #pragma pack
directive. The directive will be ignored.
User Action Correct the directive.
56.392 – INVPPDIRPEA
Message The preprocessor directive <name> is not allowed in a
prologue or epilogue file. The directive is ignored.
Description It is not possible for a prologue or epilogue file to
have this preprocessor directive in it.
User Action Remove the offending preprocessor directive from the
prologue/epilogue file.
56.393 – INVSTATIC1
Message <Context> the keyword "static" and/or type qualifiers
may appear only in the outermost array-bounds
specifier of a function parameter. Keyword/qualifier
ignored.
Description The keyword "static" or a type specifier appeared in
an array-bound specifier that was either not part of
the declarator for a function parameter or it was not
the outermost array-bound specifier of a function
parameter.
User Action Remove the keywords or confine them to use in the
outermost array-bound specifier of a function
parameter.
56.394 – INVSTATIC3
Message The keyword "static" may not appear in an array-bound
specifier for a declaration of an array of unknown
size. Keyword ignored.
Description The keyword "static" appeared in the declaration of
an array whose size was not known, either because
array has in incomplete type or because the array has
a star bounds specifier.
User Action Remove the keyword.
56.395 – INVSTATIC4
Message An expression specifying the bound is required when
the keyword "static" is used in an array-bounds
specifer. Keyword ignored.
Description The keyword "static" appeared in an array-bounds
specifier that did not have an expression describing
the array bound. The keyword tells the compiler that
actual arguments passed to this parameter will always
have at least as many elements as specified in the
formal parameter. It is inconsistent to specify the
keyword without also supplying a value for the bound.
User Action Remove the keyword or supply a value for the bound.
56.396 – INVSTATIC5
Message <Context> the static bound value differs from the
static bound value in another declaration at
<location>. The smaller static bound value will be
used.
Description In a previous declaration of a function one or more
parameters with array type were declared with a
different static bound value than in the current
declaration. This can occur if one of the sizes of
the corresponding static arrays differ between the
two declarations.
User Action Remove the keyword "static" from the declarations, or
give all function declarations the same static bound
value.
56.397 – INVSTATIC6
Message <Context> neither the keyword "static" nor a type
qualifier may be used in array-bounds for old-style
function parameters. Keyword/qualifiers ignored.
Description Use of the keyword "static" or a type specifier
within the outermost array bound specifier of a
formal parameter is a new feature in the C99
statndard. It cannot be used in old-style function
definitions.
User Action Remove the keywords or convert the code to use
prototype-style function declarations and
definitions.
56.398 – IVDEPNOFOR
Message This #pragma directive was not followed by a for
statement. The directive will be ignored.
Description The #pragma ivdep and #pragma unroll directives
modify the for loop which follows them. The compile
has encoutered one of the directives without a
following for loop. The directive will be ignored.
User Action Remove the directive.
56.399 – KEYCOMB
Message Illegal combination of keywords.
Description An invalid combination of Microsoft keywords was
encountered during a declaration. In most cases this
is because the keywords contradict each other. One
example would be using the __fastcall and __stdcall
modifiers in the same function declaration. This
message is only output when the compiler is in
Microsoft mode.
User Action Remove one of the contradictory modifiers.
56.400 – KNRFUNC
Message The function "<name>" is defined using the old style
K&R syntax. The C standard has marked this syntax as
obsolescent, and it is not supported in C++.
Consider using the standard C prototype syntax.
Description The function uses an old style function definition.
HP recommends that old style function definitions be
replaced by prototype-format definitions.
User Action Recode the function definition to use the recommended
prototype-format definition.
56.401 – LABELWOSTMT
Message Accepting a label without a following statement is a
language extension.
Description The C standard states that a label must be followed
by a statement. For compatibility with other C
compilers, HP C will accept a label without a
statement. Be aware that this program does not
conform to the standard and may be rejected by other
compilers.
User Action Add a semicolon after the label to create a null
statement.
56.402 – LCRXCOND
Message Common Data Dictionary description extraction
condition. <msg>.
Description Something went wrong while trying to get the CDD
record description from the CDD. The error message
that follows gives more information about the nature
of the problem.
User Action If necessary, correct the indicated condition in the
CDD record description or with the user environment.
56.403 – LDCOMPLEXNYI
Message <Context> the type long double _Complex is not fully
supported on this platform. The type is only
accepted when the compilation specifies the option to
make the long double type 64-bits in size.
Description On some platforms HP C does not support the long
double _Complex type where the real and imaginary
component are 128-bits in size. As HP C requires
that each component of a long double _Complex be the
same size as a long double, this compilation must
specify the option to treat long double as 64-bits.
User Action Either specify the correct compiler option or use the
double _Complex type instead of the long double
_Complex type.
56.404 – LEXNESTPAR
Message Lexically nested parallel at scope <text> is not
supported
Description Nested parallel directives are not supported.
User Action Remove the nested parallel directive.
56.405 – LISTOPEN
Message An error occurred while attempting to open the
listing file: <reason>.
Description An unexpected error occurred during the creation of
the listing file. The message text will contain
additional information about the failure.
User Action Correct the condition that caused the failure.
56.406 – LOCALEXTINI
Message The block-level declaration of "<name>" includes an
initializer and specifies storage class extern.
Description A block-level declaration with extern storage class
cannot contain an initializer.
User Action Remove the initializer from the declaration or move
the declaration to file scope.
56.407 – LONGDEBUG
Message The identifier name exceeds <number> characters; name
passed to the debugger will be truncated to
"<truncated spelling>".
Description On some platforms, the name length supported by the
compiler is greater than the length supported by the
debugger. In this case the compiler must truncate
the name when it is output to the debugger symbol
table for this compilation.
User Action Reduce the size of the name.
56.408 – LONGDOUBLENY1
Message <Context> type long double has the same
representation as type double on this platform and is
treated as a synonym for type double in this
compilation mode.
Description HP C does not support the long double type on this
platform. In this compilation mode, the compiler
will treat the long double type as a synonym for the
double type.
User Action Be aware of this.
56.409 – LONGDOUBLENYI
Message <Context> type long double has the same
representation as type double on this platform.
Description Although HP C will recognize the long double type as
a different type than double in this compilation
mode, on this platform they will both use the same
representation. Using long double will not provide
any additional precision or range.
User Action Be aware of this.
56.410 – LONGEXTERN
Message The external identifier name exceeds <number>
characters; truncated to "<truncated spelling>".
Description The length of an identifier with external linkage
exceeds the maximum allowed on this platform. The
name used in an output object file will be truncated
to meet the platform restrictions. Note that the
debugger name will be unchanged.
User Action Reduce the size of the name. On OpenVMS platforms
the /NAMES=SHORTENED qualifier can also be used.
When the qualifier is specified, the compiler will
encode long external names instead of truncating
them.
56.411 – LONGFLOATEXT
Message <Context> long float as a synonym for double is a
language extension.
Description Certain standard modes allow the use of the long
float type as a synonym for double. This is not
allowed by the C standard. This message indicates
this use of long float as a potential portability
problem.
User Action Change long float to double.
56.412 – LONGLINE
Message A <type> source line longer than <number> characters
was encountered.
Description The length of a source line has exceeded the maximum
length supported by the HP C compiler.
User Action Reduce the size of the line.
56.413 – LONGLONGSUFX
Message The integer constant is of type "<type>", which is a
new feature of C99 might not be portable.
Description The use of the suffix ULL or LL on an integer
constant does not conform to the C89 standard and
might not be accepted by other C compilers.
User Action Be aware of this if you wish to port the program.
56.414 – LONGLONGTYPE
Message <Context> type "<type>" is a new feature in C99.
Description On some platforms, HP C will accept the [unsigned]
long long type as a way to declare [unsigned] 64-bit
integers. The long long int type is a new feature of
C99 and other compilers might not accept this
declaration.
User Action Be aware of this portability concern.
56.415 – LONGMODULEID
Message Identifier "<name>" in a #pragma module or #module
directive exceeds 31 characters.
Description A module or identification name specified in the
#pragma module or #module directive must be less than
32 characters. The compiler will truncate the name
to the first 31 characters specified.
User Action Shorten the module or identification name.
56.416 – LONGMODULESTR
Message The identification string <string> in a #pragma
module or #module directive exceeds 31 characters.
The compiler will ignore the directive.
Description An identification string specified in the #pragma
module or #module directive must be less than 32
characters. The compiler will ignore the directive.
User Action Shorten the identification string.
56.417 – LONGPREFIX
Message Prefix string too long. Truncated to "<newprefix>".
Description The specified prefix to the #pragma extern_prefix
directive is too large for this platform. The prefix
will be truncated.
User Action Reduce the size of the specified extern prefix.
56.418 – LONGPSECT
Message Psect name is too long (maximum is 31 characters).
Description The psect name specified in a globaldef declaration
was longer than 31 characters. This exceeds the
maximum allowed length.
User Action Either reduce the psect name to 31 characters or
remove the psect specifier.
56.419 – LONGTOKEN
Message An individual token longer than <number> characters
was encountered.
Description The length of an individual token has exceeded the
maximum length supported by the HP C compiler.
User Action Reduce the size of the token; perhaps it can be
converted into two or more smaller tokens.
56.420 – LVALUECAST
Message <Context> the result of the cast "<cast>" is used as
an lvalue.
Description The result of a cast has been used as an lvalue.
This is a language extension of HP C. The program
does not conform to the C standard, and might not be
accepted by other compilers.
User Action Remove the cast.
56.421 – MACROREDEF
Message The redefinition of the macro "<name>" conflicts with
a current definition because <reason>. The
redefinition is now in effect.
Description A macro has been redefined with either different
formal parameters and/or a different body than a
previous definition of the macro.
User Action Either make all definitions of the same macro
identical, or undefine the macro using the #undef
preprocessing directive before it is redefined.
56.422 – MACROREDEFIN
Message Macro redefined.
Description A #define preprocessing directive has redefined a
macro whose previous definition contained an error or
warning. Normally, the compiler will issue a warning
if a macro is redefined to something other than the
previous definition. However, if the previous
definition caused a warning or error to be generated,
this informational message is output instead.
User Action Do not redefine a macro without first undefining it.
56.423 – MAINNOTINT
Message Strict standard C extension: The declaration of the
"main" function has a return type other than int.
Description Standard C requires that the "main" function be
defined with a return type of int. HP C will accept
other return types, but the program does not conform
to the C standard. The status value returned to the
environment may not be what you expect, and other C
compilers may not accept the definition as written.
User Action Define the "main" function with a return type of int
for maximal portability.
56.424 – MAINPARM
Message Strict standard C extension: The declaration of the
"main" function has more than two parameters.
Description Standard C requires that the "main" function takes no
more than two parameters. HP C will accept more, but
the program does not conform to the C standard.
User Action Modify the declaration if you want the program to be
standard conformant.
56.425 – MAINPROGEXT
Message MAIN_PROGRAM is a language extension.
Description The use of MAIN_PROGRAM to designate a function as
the main program is a language extension of HP C.
Other C compilers might not successfully compile a
program that uses the extension.
User Action The main program should be declared by naming the
function main.
56.426 – MAPREGIGNORED
Message The linkage register "<registers>" has no effect on
Alpha and will not be mapped to any register on IA64.
This condition may cause the SHOWMAPLINKAGE message
output for this directive to be incorrect.
Description The use of an Alpha argument register (R16-R21) in a
linkage characteristic other than "parameters" or
"results" has no effect on Alpha. No mapping to an
IA64 register will be done for this register. This
may cause the mapped linkage shown in the
showmaplinkage message to be incorrect.
User Action Remove the register from the characteristic.
56.427 – MATHERRNO
Message <Context> function <name> is defined to set errno
when a domain error or range error occurs. As an
intrinsic, it may not be able to do so.
Description Any code that tests the value of errno set by this
function may not work properly due to the
optimizations that are possible when this function is
an intrinsic.
User Action If the value of errno set by this function is
ignored, tell the compiler via its command line
qualifiers to assume nomath_errno. Otherwise,
disable the intrinsic by using a #pragma
function(func-name).
56.428 – MAYHIDELOSS
Message <Context> "<expression>" has a larger data size than
"<target type>". The use of a cast operator can
suppress the message that this assignment might
result in data loss.
Description In a cast of a pointer to one of the integer types,
or a cast of one of the integer types to a pointer,
or a cast of one pointer type to another, the size of
the source is greater than the size of the type being
cast to. This cast could result in a loss of data if
it is used as the source of an assignment. This
potential loss of data can be verified by removing
the cast and seeing if the compiler emits a loss of
data message on the assignment.
User Action If the cast cannot lose precision, it is safe to
ignore this warning.
56.429 – MAYLOSEDATA
Message <Context> "<expression>" has a larger data size than
"<target type>". Assignment can result in data loss.
Description In an assignment of a pointer to one of the integer
types, or one of the integer types to a pointer, the
size of the source is greater than the size of the
destination. The assignment can result in a loss of
data. This might not have been what you intended.
User Action If this was the intended operation, cast the source
to the type of the destination before the assignment.
56.430 – MAYLOSEDATA2
Message <Context> "<expression>" has a larger data size than
"<target type>". Assignment can result in data loss.
Description In an assignment of two pointers, the size of the
source is greater than the size of the destination.
The assignment can result in a loss of data. This
might not have been what you intended.
User Action If this was the intended operation, cast the source
to the type of the destination before the assignment.
56.431 – MECHMISMATCH
Message Argument passing mechanism does not match formal
parameter mechanism for <text>
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.432 – MEMBERVLA
Message <Context> the struct or union member "<name>" cannot
be declared with a variably modified type.
Description Only ordinary identifiers with block scope and
without storage class extern, or ordinary identifiers
with function prototype scope can be declared with a
variably modified type.
User Action Correct the declaration.
56.433 – MISALGNDMEM
Message This member is at offset <offset>, which is not a
multiple of the member's alignment of <align>.
Consider padding before this member, rearranging the
order of member declarations, or using #pragma
member_alignment.
Description A member of a struct or union requires an alignment
for efficient access but will be allocated at an
offset that is not a multiple of that alignment.
User Action Use one of the suggestions made in the message.
56.434 – MISALGNDSTRCT
Message This member requires <align1> alignment for efficient
access, but is contained in a struct containing
<align2> alignment. Consider using #pragma
nomember_alignment <align1>.
Description A member of a struct or union requires an alignment
for efficient access that is more strict than the
alignment of the enclosing struct or union. Even
though this member is correctly aligned within the
struct or union, if the struct or union is enclosed
within another type, the member in question might be
placed at a position with incorrect alignment for its
type.
User Action Use either the #pragma member_alignment directive or
#pragma nomember_alignment directive with an argument
equal to or greater than the alignment of the member.
56.435 – MISDEFARG
Message Missing argument for "defined" operator.
Description The defined preprocessing operator was not supplied
with an argument. The operator expects an identifier
optionally enclosed in parenthesis. The value of the
operator is undefined.
User Action Supply a valid argument to the preprocessing
operator.
56.436 – MISDEFPAR
Message Missing right parenthesis for "defined" operator.
Description The defined preprocessing operator began with a left
parenthesis, but no matching right parenthesis was
found. The value of the operator is undefined.
User Action Add the right parenthesis after the preprocessing
operator argument.
56.437 – MISMATPARAM
Message <Context> parameter <number> has a different type
than specified in an earlier declaration of this
function.
Description A function has been redeclared with a parameter whose
type is different than the type specified in a
previous declaration of the function. This generally
leads to additional errors.
User Action Correct the function declarations so that the
parameter information is the same in each
declaration.
56.438 – MISMATPRSRET
Message "<name>" has a non-void return type but its linkage
"<name>" preserves the return register(s). Standard
linkage will be used.
Description The function or typedef's special linkage specifies
that the register(s) used to return the function
value are to be preserved. This is invalid as the
register can either be preserved, or hold the return
value, but not both.
User Action Modify the #pragma linkage directive to either remove
the register from the preserved list or to specify
another register to hold the return value.
56.439 – MISMATTHREAD
Message <Context> the __declspec(thread) storage class
modifier of "<name>" is different from a previous
declaration of "<name>" at <location>.
Description If an object is declared with thread-local storage,
then all declarations of that object must declare it
with thread-local storage.
User Action Either remove the invalid redeclaration or modify it
to match the previous declaration.
56.440 – MISPARAMCOUNT
Message <Context> the number of parameters differs from an
earlier declaration of this function.
Description A function has been redeclared with a different
number of parameters than a previous declaration of
the function. This message generally proceeds
additional errors.
User Action Correct the function declarations so that the
parameter information is the same in each
declaration.
56.441 – MISSINGCASE
Message Was the 'case' keyword omitted Within a switch
statement, "<label>" defines an unreferenced label
that matches an enumeration constant.
Description This user label has been defined, but there are no
references to it. As the label is defined inside a
switch statement, and the label name matches an
enumumeration constant name, there is a chance you
intended this to be a case label.
User Action Remove the label or add the 'case' keyword before it.
56.442 – MISSINGCOMMA
Message This parameter is not preceded by a comma.
Description The compiler has encountered a parameter specifier
that is missing a preceding comma. The parameter
will be defined anyway, though this may not have been
what you intended.
User Action Correct the formal parameter list so that it consists
of a comma separated list of identifiers (possibly
followed by ", ...").
56.443 – MISSINGFUNC
Message The function "<name>" has internal linkage, occurs in
a context that requires its definition, and has no
definition.
Description The program has referenced a function declared with
static storage class, but the function is not defined
in the compilation unit. If a program references a
static function, the function must be defined in the
compilation unit.
User Action Either define the function or change the function
declaration to have extern storage class.
56.444 – MISSINGLABEL
Message The label "<label name>" is the target of a goto
statement within the function "<function name>", but
has no definition within "<function name>".
Description Every label referenced in a goto statement must be
defined in the same function.
User Action Either change the name of the label in the goto
statement, or define the label.
56.445 – MISSINGRETURN
Message Non-void function "<name>" does not contain a return
statement.
Description This message indicates that a function with an
explicit return type does not contain a return
statement. This message is not issued for functions
with an implicit return type of int. See message
IMPFNCMSSNGRET.
User Action Consider declaring the function to be a void
function. If it is supposed to return a value, add a
return statement with the value the function is to
return.
56.446 – MISSINGTYPE
Message Missing type specifier or type qualifier.
Description The compiler was expecting a type specifier or type
qualifier, but one was not found.
User Action Correct the program syntax.
56.447 – MISSPELLDEF
Message The user label "<label>", defined within a switch
statement, is never referenced.
Description This user label has been defined, but there are no
references to it. As the label is defined inside a
switch statement, there is a chance this is a
misspelling of "default".
User Action Remove the label or correct the spelling.
56.448 – MIXALLOCAVLA
Message <Context> this call to __ALLOCA occurs in a block
that contains <vlaallocafrag1>. The storage
allocated by this __ALLOCA call will
<vlaallocafrag2>vla or aligned automatic declaration
was at <where>.
Description Storage allocated for arrays of variable length and
for automatics whose alignment is greater than
octaword have their storage deallocated when the
block they are declared in exits. Storage allocated
by __ALLOCA is not normally deallocated until
function exit. HP C cannot support both types of
deallocation in the same block. Therefore, when both
appear in the same block, the storage for both will
be deallocated with the block exits.
User Action Be aware of this. If the storage allocated for
__ALLOCA must remain allocated until function exit,
move the __ALLOCA call outside the block declaring
the vla or the aligned auto.
56.449 – MIXALLOCAVLAV
Message <Context> using __ALLOCA and variable-length arrays
in the same function is not allowed on this platform.
The first variable-length array declaration is at
<where>.
Description Because they place different requirements on stack
allocation on VAX systems, __ALLOCA and
variable-length arrays cannot be used in the same
function.
User Action Recode the function to use either variable-length
arrays or __ALLOCA.
56.450 – MIXFUNCVOID
Message <Context> compatibility of a pointer to void and a
pointer to a function is not portable under the C
standard.
Description The C standard defines pointer to void as being
assignment compatible only with pointers to object or
incomplete types. An implementation may represent
function pointers in a way that cannot be stored in a
pointer to void (or vice-versa). Thus even an
explicit cast between a function pointer and a
pointer to void is not portable.
User Action If a generic pointer to function is needed, declare a
typedef for some pointer to function type, and always
use explicit casts to assign to and from that type.
56.451 – MIXINLINE
Message The function <name> is declared both <this> and
<that>.
Description A function is declared with more than one of the
forceinline, inline, or noinline attributes. It will
be given the attribute that will provide the most
optimization.
User Action Make sure each function has only one of the
attributes.
56.452 – MIXLINKAGE
Message <Context> "<name>" is declared with both internal and
external linkage. The previous declaration is at
<location>.
Description This warning is output in certain cases when the
linkage of a declaration conflicts with the linkage
specified in an earlier declaration.
User Action Change one of the declarations so that the linkages
match.
56.453 – MIXLINKAGE1
Message <Context> "<name>" is declared with both internal and
external linkage. The previous declaration is at
<location>.
Description This informational is output when a function
previously declared to have extern storage class is
redeclared to have internal storage class and the
mode of the compiler is common (K & R) mode.
User Action Change one of the declarations so that the linkages
match.
56.454 – MIXOLDNEW
Message The definition of the function <name> includes both a
prototype and a declaration list.
Description A function has been defined using both a declaration
list and a prototype. This is not valid.
User Action Correct the declaration.
56.455 – MIXSTORCLS
Message <Context> a storage class has already been specified.
This storage class is ignored.
Description The same declaration contains more than one storage
class specifier. The compiler will ignore all
storage class specifiers after the first one.
User Action Change the declaration to use only one storage class
specifier.
56.456 – MIXVLAALLOCA
Message Declaring <vlaallocafrag1> in the same block as a
call to __ALLOCA will cause the storage allocated by
any __ALLOCA call to <vlaallocafrag2>previous call to
__ALLOCA was at <where>.
Description Storage allocated for arrays of variable length and
for automatics whose alignment is greater than
octaword have their storage deallocated when the
block they are declared in exits. Storage allocated
by __ALLOCA is not normally deallocated until
function exit. HP C can not support both types of
deallocation in the same block. Therefore, when both
appear in the same block, the storage for both will
be deallocated with the block exits.
User Action Be aware of this. If the storage allocated for
__ALLOCA must remain allocated until function exit,
move the __ALLOCA call outside the block declaring
the vla or the aligned auto.
56.457 – MIXVLAALLOCAV
Message Using both __ALLOCA and variable-length arrays in the
same function is not allowed on this platform. The
first call to __ALLOCA is at <where>.
Description Because they place different requirements on stack
allocation on VAX systems, __ALLOCA and
variable-length arrays cannot be used in the same
function.
User Action Recode the function to use either variable-length
arrays or __ALLOCA.
56.458 – MODNOIDSTR
Message Invalid identifier or character-string constant
specification.
Description If specified, the second argument to the #pragma
module or #module directive must be either an
identifier or a string constant.
User Action Correct the directive.
56.459 – MODSTORCLS
Message Storage class modifier noshare has no meaning with
this storage class. Modifier is ignored.
Description The storage class modifier noshare is only valid for
variables with a storage class of static, extern, or
globaldef. It is ignored for other storage classes.
User Action Remove the noshare storage class modifier.
56.460 – MODULEFIRST
Message "#pragma module" or "#module" directive must precede
any language text.
Description The #pragma module or #module directive must appear
before any declarations. The directive will be
ignored.
User Action Move the directive to the top of the compilation
unit.
56.461 – MSGPOP
Message This "restore" has underflowed the message stack. No
corresponding "save" was found.
Description The message stack, managed by the #pragma message and
#pragma environment directives, contains more
restores than saves. This could signify a coding or
logic error in the program.
User Action Make sure each restore has a corresponding save.
56.462 – MSGSFRMEXLCODE
Message Enabling this message may cause additional messages
from excluded code to be output.
Description This message is never output by the compiler.
Instead it is used to control whether other messages
will be output. Normally, the compiler will not
output some messages when it is processing code that
it knows will never be executed. One example of this
would be the second operand of the conditional
operator when the first operand is FALSE. This
suppression of these messages can be overridden by
enabling this message.
User Action Decide if you want the additional messages.
56.463 – MULTICHAR
Message A character constant includes more than one character
or wide character.
Description A character constant includes more than one
character. While this is valid, it might not have
been what you intended.
User Action Verify that the constant should contain more than one
character.
56.464 – MULTILINK
Message Multiple linkage pragmas specified for "<routine
name>".
Description The same routine appeared in more than one #pragma
use_linkage directive. Each routine can only be
given one linkage.
User Action Remove the routine from all but one #pragma
use_linkage directive.
56.465 – MULTILINKREG
Message The register "<register>" is specified more than once
in the linkage pragma. Pragma is ignored.
Description The same register was specified more than once in the
same register list in a #pragma linkage directive.
The compiler will ignore the entire pragma.
User Action Correct the directive.
56.466 – MULTIMAIN
Message More than one main program has been defined.
Description The compiler has encountered more than one main
program in this compilation unit. Each program can
have only one main program.
User Action Remove one of the main programs.
56.467 – MULTIPSECTNAME
Message Multiple <psect_type> names specified. The name
"<new_name>" supersedes "<old_name>".
Description More than one #pragma code_psect or #pragma
linkage_psect was encountered. The psect specified
by the later #pragma supersedes the one specified
earlier. This message is only output for C compilers
on OpenVMS Alpha.
User Action Each program should contain at most one #pragma
code_psect and one #pragma linkage_psect.
56.468 – NAMESHORTENED
Message The external identifier or module name "<name>"
exceeds 31 characters. The name has been shortened
to "<shortened spelling>".
Description A compilation that used the /NAMES=SHORTENED
qualifier or #pragma names shortened directive has
encountered a name that needs to be shortened. The
external name will be different than the internal
name. Also, because the external name exceeds the
length specified by standard C as the minimum
external length an implementation must support, this
program does not strictly conform to standard C and
might not be accepted by other C compilers.
User Action Be aware of these items.
56.469 – NAMESLOWER1
Message The /NAMES=LOWERCASE qualifier is no longer
supported. The qualifier /NAMES=AS_IS will be used.
Description While the C language has always required identifiers
with internal linkage to be treated case sensitively.
It traditionally permitted implementations to
monocase identifiers with external linkage. Modern
standards require C/C++ implementations to preserve
the case of identifiers with external linkage. As
VMS and other operating systems that traditionally
implemented monocasing chose uppercase as the
convention, /NAMES=LOWERCASE runs contrary both to
the C and C++ standards and to traditional
conventions. Continued support for this option
interferes with support for compatibility between old
code compiled with /NAMES=UPPERCASE and new code
compiled with /NAMES=AS_IS.
User Action Use /NAMES=AS_IS, making source code changes as
needed.
56.470 – NEEDADDRCONT
Message <Context> "<name>" does not have a constant address,
but occurs in a context that requires an address
constant.
Description A variable with static storage has been initialized
to the address of an object whose address is not
constant. This can happen if a static pointer
variable is initialized to the address of an
automatic variable.
User Action Either make the initialize a constant, or, if
possible, initialize the static storage using a
run-time assignment.
56.471 – NEEDARITH
Message <Context> "<expression>" has <type> type, which is
not arithmetic.
Description An expression that must be an arithmetic type was not
an arithmetic type. For example, the operands of an
arithmetic operator such as * must be arithmetic
type.
User Action Modify the expression so that it is an arithmetic
type.
56.472 – NEEDCONSTEXPR
Message <Context> "<name>" is not constant, but occurs in a
context that requires a constant expression.
Description An expression that must evaluate to a compile-time is
not a constant.
User Action Modify the constant expression so that it will
evaluate as a compile-time constant.
56.473 – NEEDCONSTEXT
Message <Context> "<name>" is not constant, but occurs in a
context that requires a constant expression. This is
an extension of the language.
Description The C89 standard requires that an initializer for an
automatic aggregate or union type object have an
initializer that is a list of constant expressions.
HP C allows non-constants in these initializers.
This is an extension to C89. Although this is
allowed by the C99 standard, other C compilers might
not successfully compile a program that uses this
extension.
User Action Be aware of this if you wish to port the program.
56.474 – NEEDDFLOAT
Message The CDD description for <name> specifies the
D_Floating data type. The data can only be
represented when compiling with /FLOAT=D_FLOAT.
Description The /FLOAT command-line qualifier specified a
floating type other than D_floating format. The CDD
description specified was D_floating type, which did
not match the floating type specified on the command
line.
User Action Specify the correct command-line qualifier, or change
the description of the item in the CDD.
56.475 – NEEDFUNCPTR
Message <Context> "<expression>" points to <type> type, but
occurs in a context that requires a pointer to a
function type.
Description An expression that must be a pointer to a function
type is a pointer to an object or incomplete type.
For example, if a function invocation expression is a
pointer, it must be a pointer to a function type.
User Action Modify the expression so that it is a pointer to a
function type.
56.476 – NEEDGFLOAT
Message The CDD description for <name> specifies the
G_Floating data type. The data can only be
represented when compiling with /FLOAT=G_FLOAT.
Description The /FLOAT command-line qualifier specified a
floating type other than G_floating format. The CDD
description specified was G_floating type, which did
not match the floating type specified on the command
line.
User Action Specify the correct command line qualifier, or change
the description of the item in the CDD.
56.477 – NEEDIEEE
Message The CDD description for <name> specifies a VAX
floating data type. The data cannot be represented
when compiling with /FLOAT=IEEE_FLOAT.
Description The command-line qualifier /FLOAT=IEEE_FLOAT was
specified, indicating that all floating-point data
should be represented in IEEE-floating format, yet
the CDD description specified a non-IEEE_floating
type.
User Action Specify the correct command-line qualifier, or change
the description of the item in the CDD.
56.478 – NEEDIEEE1
Message The CDD description for <name> specifies an IEEE
floating data type. The data can only be represented
when compiling with /FLOAT=IEEE_FLOAT.
Description The CDD description for an item specifies an IEEE
floating point type. However this module was not
compiled with the /FLOAT=IEEE_FLOAT qualifier.
User Action Specify the correct command-line qualifier, or change
the description of the item in the CDD.
56.479 – NEEDINTEXPR
Message <Context> "<expression>" has <type> type, which is
not integral.
Description An expression that must be an integer type was not
integral. For example, an array-index specifier must
be an integral type.
User Action Modify the expression so that it is an integral type.
56.480 – NEEDLVALUE
Message <Context> "<expression>" is not an lvalue, but occurs
in a context that requires one.
Description An expression that must be an lvalue was not an
lvalue. For example, the operand of the address-of
operator must be an lvalue.
User Action Modify the expression so that it is an lvalue.
56.481 – NEEDMEMBER
Message <Context> "<name>" is not a member of "<struct or
union expression>".
Description The second operand of a . or -> operator specifies a
member name that is not a member of the struct or
union type specified by the first operand. Note that
in certain modes, HP C will search all other visible
struct/union types for a matching member name. If it
finds one, a diagnostic will be issued, and the
offset of that name will be used.
User Action Specify a valid member name.
56.482 – NEEDNONBLTIN
Message <Context> "<name>" is a builtin and cannot be used in
this context.
Description A program has used a builtin function in a way that
is invalid for builtin functions. For example, a
program cannot take the address of a builtin.
User Action Remove the improper use of the builtin.
56.483 – NEEDNONCONST
Message <Context> "<expression>" has const-qualified type,
but occurs in a context that requires a modifiable
lvalue.
Description The code has attempted to modify an object that is
either a const-qualified type or has been declared
with the readonly storage-class modifier. This is
not valid. A typical example is assigning a value to
a const variable.
User Action Either remove the const qualifier from the object's
type, remove the readonly storage-class modifier from
the object declaration, or rework the code so that
the object is not written to.
56.484 – NEEDNONVOID
Message <Context> "<expression>" has void type, but occurs in
a context that requires a non-void result.
Description An expression that must not be a void type was void.
For example, the control expression for an if
statement must not have void type.
User Action Modify the expression so that it has the required
type.
56.485 – NEEDPOINTER
Message <Context> "<expression>" has <type> type, but occurs
in a context that requires a pointer.
Description An expression that must be a pointer type was not a
pointer type. For example, the operand of the
dereference operator must be a pointer type.
User Action Modify the expression so that it has a pointer type.
56.486 – NEEDPTROBJ
Message <Context> "<expression>" does not point to an object
type.
Description An expression that must be a pointer to an object
type is a pointer to a function or incomplete type.
For example, if a pointer is the operand of the
postincrement operator, it must point to an object
type.
User Action Modify the expression so that it is a pointer to an
object type.
56.487 – NEEDSCALAR
Message <Context> "<expression>" has <type> type, which is
not scalar.
Description An expression that must be a scalar type was not
scalar. For example, only scalars can be cast to
other types.
User Action Modify the expression so that it is a scalar type.
56.488 – NEEDSCALARTYP
Message <Context> "<source type>" is <type> type, which is
not scalar.
Description In a cast expression, the destination type of the
cast is not a scalar type. This is not valid. Both
the source and target type of a cast must be scalars.
User Action Modify the cast destination type so that it is a
scalar type.
56.489 – NEEDSIMPLEASM
Message This asm is unsupported or illegal. Description The argument to the asm intrinsic is invalid. User Action Supply a valid argument to the asm instrinsic.
56.490 – NEEDSTRCONST
Message <Context> "<name>" is not a legal asm string, a
string constant is required.
Description The argument to the asm intrinsic must be a string
constant.
User Action Change the argument to be a string constant.
56.491 – NEEDSTRUCT
Message <Context> "<expression>" has <type> type, but occurs
in a context that requires a union or struct.
Description The left operand of the . or -> operator does not
have struct or union type.
User Action Correct the operand.
56.492 – NEGATIVEHINT
Message <Context> a negative hint value is not allowed. The
hint will be ignored.
Description All #pragma hint directives must take positive
floating point values.
User Action Correct the hint.
56.493 – NESTEDCOMMENT
Message Opening comment delimiter found inside a delimited
comment; a previous comment may be missing its
closing delimiter.
Description C comments delimited by /* */ do not nest. When /*
is encountered inside a delimited comment it usually
means that the previous comment is missing its
terminating */ or that the user has ill-advisedly
attempted to "comment out" a section of code that
contains a delimited comment.
User Action It is traditional in C to use #if 0 to conditionalize
out large sections of code. You may also want to
consider //-style comments if the compiler modes you
care about recognize them.
56.494 – NESTEDENUM
Message The type "<type>" is declared nested within
"<enclosing type>". In C, the nesting is ignored and
<type> and its enumerator constants can be accessed
as if they were not nested. <However, the type and
its enumerators are members in C++>. <Fix>.
Description C allows types to be declared within other types.
For example: struct S { int a; enum E { first,
second, third} b; int c; }; In C++ the enum E would
not be accessible without using the :: operator.
User Action Declare the nested type before declaring the
enclosing type.
56.495 – NESTEDTYPE
Message The type "<type>" is declared nested within
"<enclosing type>". In C, the nesting is ignored and
<type> can be accessed as if it were not nested.
<However, the type is a member in C++>. <Fix>.
Description C allows types to be declared within other types.
For example: struct S { int x; struct S1 { int a;
int b; } y; }; In C++ the struct S1 would not be
accessible without using the :: operator.
User Action Declare the nested type before declaring the
enclosing type.
56.496 – NESTINCL
Message Files included by this file are referenced. However
nothing else appears to be referenced from this file.
Description When compiling with the current set of compilation
options, to improve compilation efficiency, you may
wish to include the files which this file includes
directly, rather than including them from this file.
User Action For compilation efficiency, you may exclude this
include file when compiling with the current set of
compilation options.
56.497 – NEWLOCALE
Message The compiler could not set its locale to the
locale-specific native environment. This problem
might be caused by an incorrect value for a name
defined in your process environment such as "LC_ALL"
or "LANG". The "C" locale will be used.
Description During start-up, the compiler was unable to set its
locale to the locale-specific environment. As part
of its initialization, the compiler will issue the
call setlocale(LC_ALL, ""). If this call fails, the
compiler will set its locale to the "C" locale. In
general, this message is output because the
locale-specific native environment has been set
incorrectly.
User Action The best way to determine why the compiler was unable
to set the locale is to write a small program that
contains the library call setlocale(LC_ALL, "") and
then examine the return value from the call.
56.498 – NLCHAR
Message An unexpected newline character is present in a
character constant.
Description An end of line was encountered during the scanning of
a character constant.
User Action Terminate the character constant with a closing
single quote character before the end of line.
56.499 – NLHEADER
Message A newline occurs inside of a header name.
Description An end of line was encountered before the closing
double quote or angle bracket of an #include
directive.
User Action Terminate the directive argument properly.
56.500 – NLSTRING
Message An unexpected newline character is present in a
string literal.
Description An end of line was encountered during the scanning of
a string literal.
User Action Terminate the string constant with a closing double
quote character before the end of line, or continue
the line with a continuation character.
56.501 – NOADD
Message <Context> "<expression1>" and "<expression2>" cannot
be added.
Description Because of their types, the two expressions cannot be
used as the operands of the addition operator.
Either both operands must be arithmetic type, or one
operand must be a pointer to an object type and the
other must be an integral type.
User Action Modify the addition to use valid types.
56.502 – NOBIFDISABLE
Message The function "<routine name>" is a builtin function
reserved to the compiler, and cannot be used with
#pragma function. The function will continue to be
treated as a builtin.
Description A function identifier specified in a #pragma function
directive is the name of a builtin function. These
functions cannot be explicitly disabled, they are
always handled as builtin functions.
User Action Remove the inappropriate use of the pragma, and
change the name of the function in order to have it
treated as an ordinary callable function.
56.503 – NOBITFIELD
Message <Context> "<expression>" is a bitfield, but occurs in
a context that precludes bitfields.
Description An expression that must not be a bitfield was a
bitfield. For example, the operand of the address-of
operator must not be a bitfield.
User Action Modify the expression so that its type is not a
bitfield type.
56.504 – NOCASEHERE
Message This case label occurs outside of any switch
statement.
Description A case label can only occur inside of a switch
statement.
User Action Remove the case label.
56.505 – NOCDDHERE
Message CDD is not available on this platform. The
#dictionary directive has been ignored.
Description The #dictionary directive requires CDD to be present
on the platform. This directive will only be
recognized on OpenVMS systems.
User Action Remove the directive.
56.506 – NOCOLON
Message Missing ":".
Description The compiler was expecting a colon, but one was not
found.
User Action Correct the program syntax.
56.507 – NOCOLONINEXPR
Message Missing colon for conditional expression.
Description A conditional expression that occurs as part of a
preprocessing expression was missing the ":" that
separates the second from the third operand. The
value of the resulting expression is undefined.
User Action Correct the conditional expression.
56.508 – NOCOMMA
Message Missing ",".
Description The compiler was expecting a comma, but one was not
found.
User Action Correct the program syntax.
56.509 – NOCONDEXPR
Message Missing #if conditional expression.
Description An argument was not supplied to an #if or #elif
preprocessing directive. The missing argument will
cause the compiler to consider these as FALSE
conditionals.
User Action Supply a valid argument to the directive.
56.510 – NOCONVERT
Message <Context> "<expression>" is of type "<type>", and
cannot be converted to "<target type>".
Description An expression of one type cannot be converted to the
type required by this expression. This most often
occurs when the source type of an assignment or cast
cannot be converted to the destination type. The
rules for which types can be converted are rather
complicated and differ based upon the compiler mode.
Refer to the language documentation for a complete
list of valid combinations.
User Action Modify the conversion to use valid types.
56.511 – NOCONVERTCLS
Message <Context> "<expression>" is of type "<type>", and
cannot be converted to a different "<type>" type.
Description A struct or union of one type cannot be converted to
a different struct or union type.
User Action Modify the conversion to use valid types.
56.512 – NODCL
Message <Context> nothing is declared.
Description The C standard requires that a declaration must
declare at least a tag, an enumeration constant, or a
declarator. This declaration contains none of these.
This might not have been what you intended.
User Action Correct or remove the declaration.
56.513 – NODEFAULTHERE
Message This default label occurs outside of any switch
statement.
Description A case default label can only occur inside of a
switch statement.
User Action Remove the case default label.
56.514 – NOENDIF
Message Missing #endif directive.
Description The compiler encountered an #if, #ifdef, or #ifndef
preprocessing directive without a matching #endif.
This might not have been what you intended. The
compiler will add the necessary #endif directive at
the end of the compilation unit.
User Action Make sure every #if, #ifdef and #ifndef has a
matching #endif.
56.515 – NOEQUAL
Message Missing "=".
Description The compiler was expecting to see an "=" after the
secondary_name specification of a #pragma weak or
#pragma external_name directive. This message is
only output on UNIX.
User Action Correct the #pragma directive.
56.516 – NOEQUALITY
Message <Context> "<expression1>" and "<expression2>" cannot
be compared for equality or inequality.
Description Because of their types, the two expressions cannot be
compared for equality or inequality. The rules for
which types can be compared are rather complicated
and differ based upon the compiler mode. Refer to
the language documentation for a complete list of
valid combinations.
User Action Modify the comparison to use valid types. This can
often be done by casting one of the expressions to
the type of the other.
56.517 – NOEXCEPTFLTR
Message <Context> this exception handling call is not within
an exception filter of a try block.
Description The exception handling call must appear within an
exception filter of a try statement block.
User Action Either remove the exception handling call, or place
it in a try statement block.
56.518 – NOFBDAT
Message <text> does not contain feedback data
Description The file indicated by the -feedback switch exists,
but does not contain feedback data. This is probably
an error on the users part, although it might be seen
as part of the bootstrapping process.
User Action Create a valid feedback file
56.519 – NOFBFIL
Message Feedback file <text> does not exist
Description The file specified after the -feedback option does
not exist. This is normal during the bootstrapping
process.
User Action Either correct the spelling of the feedback option,
or create the required feedback file.
56.520 – NOFBOPT
Message Compilation will proceed without feedback
optimizations
Description A condition has occurred that has prevented the
compiler from using feedback optimizations. This
message is most often preceded by another message
that will provide additional information.
User Action Correct the condition that prevented the feedback
optimizations.
56.521 – NOFBRTN
Message Feedback inactive for <text> in this compilation
Description Feedback information has gone stale for a particular
routine (the source for the routine has changed).
Feedback optimizations will not be applied to this
routine.
User Action Create a new feedback file
56.522 – NOFIFILE
Message Cannot find include file <filename> specified on the
command line.
Description The header file name specified in the UNIX -FI
command line option or the OpenVMS /FIRST_INCLUDE
qualifier was not found using the search rules in
effect for the quoted form of #include directives.
User Action Either change the name of the file following the
option or create the file.
56.523 – NOFNTPDEFDECL
Message There is no identifier named "<name>" declared as a
function or function typedef in this compilation
unit.
Description A #pragma assert and/or #pragma linkage directive(s)
contains an identifier that is not declared as a
function or function typedef in the compilation unit.
This may not have been what you intented.
User Action Remove the identifier from the #pragma assert and/or
#pragma linkage, or declare it as a function or
function typedef. empty string.
56.524 – NOFORMALPARM
Message Missing formal parameter specifier.
Description While processing the formal parameter list of a macro
definition, the compiler encountered a missing formal
parameter specifier. The macro will be be defined
and this parameter ignored, but that may not have
been what you intended.
User Action Correct the formal parameter list so that it consists
of a comma separated list of identifiers.
56.525 – NOFUNC
Message There is no function named <name> defined in this
compilation unit.
Description A function that appears in a #pragma weak and is not
defined in the compilation unit.
User Action Either define the function or remove the function
name from the pragma.
56.526 – NOFUNC1
Message There is no definition for the inline function named
<name> in this compilation unit.
Description A function that appears in a #pragma inline or
#pragma noinline, or is declared with the __inline or
__forceinline storage class modifier, is not defined
in the compilation unit.
User Action Either define the function or remove the function
name from the pragma, or remove the storage class
modifier or the function specifier from the
declaration.
56.527 – NOIDFOUND
Message <Context> an identifier was expected but not found.
Description The compiler was expecting an identifier, but one was
not found.
User Action Correct the program syntax.
56.528 – NOIDINPACKPOP
Message pragma pack pop directive has no identifier <name>
which was found on the top of the pack stack.
Description The #pragma pack (pop) directive has no identifier
specified while the top element of the pack stack has
one. Either this #pragma pack pop should have the
identifier found on the stack, or this is an extra
pragma pack pop, or the identifier should not be
pushed by the corresponding #pragma pack push.
User Action Check whether the pragma pack pop should have the
identifier. Verify that there's no extra #pragma
pack pop or #pragma member_alignment restore which
popped the identifier to the top of the pack stack.
Correct the directive(s).
56.529 – NOINCLFILE
Message Cannot find file <filename> specified in #include
directive.
Description The specified include file does not exist.
User Action Either change the name of the file in the #include
preprocessing directive, or create the include file.
56.530 – NOINCLFILEF
Message Cannot find file <filename> specified in #include
directive.
Description The specified include file does not exist.
User Action Either change the name of the file in the #include
preprocessing directive, or create the include file.
56.531 – NOINCLUDEARG
Message #include directive missing argument.
Description An argument was not supplied to an #include
preprocessing directive. The directive will be
ignored.
User Action Supply a valid argument to the directive.
56.532 – NOINIT
Message The type of <variable> does not permit
initialization.
Description This type cannot be initialized. Only objects and
arrays of unknown size can be initialized.
User Action Remove the initializer.
56.533 – NOINLFUNC
Message There is no definition for the inline function named
<name> in this compilation unit.
Description A function is declared with an __inline or inline
keyword and is not defined in the compilation unit.
User Action Either define the function or remove the __inline or
inline keyword from the declaration.
56.534 – NOINLINEM
Message The main function cannot be inlined.
Description The C99 standard prohibits the inline keyword from
being used on the main function.
User Action Remove the inline keyword.
56.535 – NOINLINEREF
Message <Context> "<name>" has internal linkage and is
referenced from an an inline auxiliary function.
This is a violation of the C99 Standard.
Description A function declared with the inline keyword and
without a declaration containing the keyword, extern,
or without a declaration which lacks the inline
keyword and the static keyword declares an auxiliary
inline declaration. A definition of an auxiliary
inline shall not contain a definition of a modifiable
object with static storage duration, and shall not
contain a reference to an identifier with internal
linkage.
User Action Remove the inline keyword from all declarations of
the parent function, or if it is appropriate, change
the declaration of the referenced item to a
declaration which has something other than internal
linkage.
56.536 – NOINLINEST
Message In an inline auxiliary function, the modifiable
object "<name>" is declared with static storage
duration. This is a violation of the C99 standard.
Description A function declared with the inline keyword and
without a declaration containing the keyword, extern,
or without a declaration which lacks the inline
keyword and the static keyword declares an auxiliary
inline declaration. A definition of an auxiliary
inline shall not contain a definition of a modifiable
object with static storage duration, and shall not
contain a reference to an identifier with internal
linkage.
User Action Remove the inline keyword from all declarations of
the parent function, or if it is appropriate, add the
const keyword to the declaration to create an
non-modifiable object.
56.537 – NOLEAVETARG
Message This leave statement is not within a try statement.
Description The exception handling statement leave must appear
within a try statement block.
User Action Either remove the leave statement, or place it in a
try statement block.
56.538 – NOLEFTOPERND
Message Token pasting operator missing left operand.
Description The preprocessing token pasting operator "##" appears
in a macro body without the preceeding token
argument.
User Action Either remove the operator or supply it with two
tokens that will be pasted together.
56.539 – NOLINKAGE
Message <Context> "<name>" has no linkage and has a prior
declaration in this scope at <where>.
Description A declaration within a function body redeclares an
identifier declared earlier in the current scope, and
both declarations did not have the extern storage
class.
User Action Either remove the extra declarations, or have all
declarations for the identifier use the extern
storage class.
56.540 – NOLONGLONG
Message <Context> 64-bit integral types are not supported on
this platform.
Description 64-bit integer types are not supported on the VAX
platform.
User Action Change the type to an integer type that is supported
on VAX, or compile the application on a platform that
does support 64-bit integers.
56.541 – NOMACRONAME
Message #define directive is missing macro name identifier.
Description The #define preprocessing directive was not supplied
with an argument. The directive should be followed
with an identifier that specifies the macro name to
be defined. The directive will be ignored.
User Action Supply a valid argument to the preprocessing
directive.
56.542 – NOMAINUFLO
Message No main function encountered within module.
/IEEE_MODE=UNDERFLOW_TO_ZERO is ignored.
Description Use of the /IEEE_MODE=UNDERFLOW_TO_ZERO is only
meaningful for compilation units that contain a main
program. The compiler will ignore the qualifier.
User Action Remove the qualifier from the command line.
56.543 – NOMAPPOSSIBLE
Message The register "<register>" cannot be mapped to a
register on the target platform.
Description The pragma linkage directive contains
architecture-specific information. The Alpha
register conventions are different from the IA64
registers conventions. The compiler will normally
try to map the Alpha registers to the corresponding
registers on IA64. In this case this register cannot
be mapped because there is no corresponding IA64
register.
User Action Update the linkage to use a register that can be
mapped, or specify the linkage to use the
linkage_ia64 directive.
56.544 – NONAMEMEMBERS
Message <Context> a struct or union has no named members.
This is undefined behavior according to the C
standard.
Description The C standard requires that a struct or union
contain at least one named member. Because this
struct/union contains no named members, it does not
conform to the C standard and might not be portable.
User Action Make sure at least one member has a name.
56.545 – NONATOMIC
Message Unable to generate code for atomic access
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.546 – NONEWTYPE
Message The type "<type>" is being declared as part of
<context>. C++ does not permit a new type to be
declared in this context. <Fix>.
Description C++ does not allow types to be declared in certain
contexts that are valid in C. One example is the
declaration of a type within a function prototype.
User Action Declare the type before its use.
56.547 – NONGRNACC
Message Unable to generate code for requested granularity
Description The compiler has generated a call a routine that
performs longword operations on some data that is
requested to be accessed with byte granularity.
Because of this, the requested granularity will not
be met for this data access. This routine may be
generated for a memory copy routine (such as memcpy).
The call can also be generated for certain struct
assignments.
User Action If the data must be accessed with byte granularity
then write your own routine that does the required
action using byte objects. If byte granularity is
not needed at this point, the message can be ignored.
56.548 – NONINTENUM
Message <Context> the enumeration type, and all associated
enumeration constants will have type <type> because
at least one enumeration constant had a value that
could not be represented in the type signed int.
Description The standard requires that enumeration constants have
a value representable as an int. Other C compilers
will allow enumeration constants to have values
outside this range. In some modes the HP C compiler
will allow this extension. To identify exactly which
constants are outside the range, enable the
nonintenumcon message.
User Action Be aware that other compilers may not support this
extension.
56.549 – NONINTENUMCON
Message <Context> allowing an enumeration constant outside
the range of signed int is a language extension.
Description The standard requires that enumeration constants have
a value representable as an int. Other C compilers
will allow enumeration constants to have values
outside the range. In some modes the HP C compiler
will allow this extension.
User Action Be aware that other compilers may not support this
extension.
56.550 – NONINTENUMCON1
Message <Context> this enumeration constant and its
associated enumeration type will not have the type
signed int. This behavior differs from earlier
versions of the compiler.
Description This message will only be output when the "enumrange"
message is disabled. This version of the HP C
compiler will allow enum constants to have a type
other than signed int. This is for compatibility
with other compilers. Programs that rely on the
compiler to truncate enum constants may not work as
expected. For more information, enable the
nonintenum message.
User Action If your program relies on this truncation, cast the
constant to int.
56.551 – NONLBEFOREEOF
Message File does not end in unescaped newline.
Description The final character of a file was not a newline
character. This could indicate that the file has
been corrupted. The compiler will insert a newline
character at this point in the input stream.
User Action Update the source file so that it ends with a
newline.
56.552 – NONMULTALIGN
Message The size of this structure is <size> bytes, which is
not a multiple of its alignment of <align>.
Respecify the alignment of the structure or add
<bytes> bytes of additional padding.
Description The size of a struct or union is not a multiple of
its alignment. This could cause unaligned accesses
if an array of these structs or unions is declared.
User Action Modify the struct/union or the alignment so that the
size of the struct or union is a multiple of the
alignment.
56.553 – NONOCTAL
Message An octal constant contains non-octal digits.
Description An octal constant contains a non-octal digit. The
compiler will convert this non-octal digit to its
corresponding octal value and use that value instead.
For example, 0190 will be converted to 0210 (decimal
136) as the non-octal digit 9 is converted to the
octal 11.
User Action Correct the octal constant to use only octal digits.
56.554 – NONPORTDEFINED
Message "defined" is treated as an identifier here, not an
operator.
Description For compatibility with older C compilers, in certain
modes the compiler will treat #ifdef defined(foo) as
#ifdef defined, and #ifndef defined(foo) as #ifndef
defined. This might not have been what you intended.
User Action Do not mix #ifdef/#ifndef with the defined operator.
56.555 – NONPORTLINEDIR
Message Non-standard #line directive.
Description Accepting the line directive without the "line"
preprocessing keyword is an extension of HP C. The
program does not conform to the C standard, and might
not be accepted by other compilers.
User Action Add the "line" preprocessing keyword to the
directive.
56.556 – NONSTANDCAST
Message <Context> "<expression>" of type "<type>", is being
converted to "<target type>". Such a cast is not
permitted by the standard.
Description The standard only permits casts from a pointer to an
object incomplete type to another pointer to an
object or incomplete type, or from a pointer to
function type to another pointer to function type.
Note that void is considered an incomplete type, so
casts between pointer to void and pointer to function
types are not permitted by the C standard.
User Action Be aware of this difference if you plan to port this
source to another compiler.
56.557 – NONULINIT
Message <Context> , there is no room for the terminating
'\0'. Standard C allows this, but C++ does not.
Description This declaration initializes an object to a strict
literal. Although the object is large enough to hold
the characters in the literal, it is not large enough
to hold the terminating null character. This might
not have been what you intended. This practice is
also not valid in C++.
User Action Increase the size of the object, or reduce the size
of the initializer.
56.558 – NOOPERAND
Message Stringization operator missing operand.
Description The preprocessing stringization operator "#" appears
in a macro body without a token argument after the
operator.
User Action Either remove the operator or supply it with a token
that will be stringized.
56.559 – NOOPERANDS
Message Token pasting operator missing both operands.
Description The preprocessing token pasting operator "##" appears
in a macro body without either the preceeding or
following token arguments.
User Action Either remove the operator or supply it with two
tokens that will be pasted together.
56.560 – NOPARENARGLST
Message Missing right parenthesis for macro argument list.
Description A macro invocation's argument list did not end in a
right parenthesis.
User Action Correct the program syntax.
56.561 – NOPARM
Message This declaration does not declare a parameter.
Description The parameter declaration list of an old-style
function definition included a type but no parameter
identifier.
User Action Replace the old-style function definition with the
recommended prototype-format declaration. If this is
not possible, include the correct identifier after
the parameter type.
56.562 – NOPARMLIST
Message The declaration of <function> has an empty parameter
list. If the function has parameters, they should be
declared here; if it has no parameters, "void" should
be specified in the parameter list.
Description The recommended way to declare a function that takes
no parameters is to use "void" in the parameter list.
User Action Make the recommended change.
56.563 – NOPRAGARG
Message No argument for #pragma <pragma> was found. Pragma
is ignored.
Description A #pragma directive was not followed by one of the
expected arguments. The directive will be ignored.
User Action Supply all required arguments to the directive.
56.564 – NOPSECT
Message Missing psect name.
Description The psect specifier in a globaldef declaration must
be a string constant.
User Action Either make the psect a string constant or remove the
psect specifier.
56.565 – NOREGAVAIL
Message Unable to satisfy program register allocation
requirements.
Description The compiler is unable to allocate all the registers
requested by the program. This most often happens
when asm directives require too many registers.
User Action Rework the asm directives so they use fewer registers
56.566 – NORELATIONAL
Message <Context> "<expression1>" and "<expression2>" cannot
be compared with a relational operator.
Description Because of their types, the two expressions cannot be
used as the operands of a relational operator. The
rules for which types can be used in a relational are
rather complicated and differ based upon the compiler
mode. Refer to the language documentation for a
complete list of valid combinations.
User Action Modify the relational to use valid types. This can
often be done by casting one of the expressions to
the type of the other.
56.567 – NORETNONVOID
Message noreturn assertion of #pragma assert directive can't
be specified for non-void function.
Description noreturn assertion was specified in #pragma assert
directive for non-void function; the noreturn
assertion will be ignored.
User Action Either remove noreturn assertion from the directive,
or change return type for the function to void.
56.568 – NORETURNVAL
Message The function "<name>" returns a value, but no value
is given in this return statement.
Description A function that returns a value contains a return
statement that is missing a return value. Therefore,
the returned value will be undefined. This might not
have been what you intended.
User Action Supply a return value for the return statement.
56.569 – NORETURNVAL1
Message The function "<name>" has an implicit return type of
int, but no value is given in this return statement.
Description A function that has an implicit return type of int
contains a return statement that is missing a return
value. Therefore, the returned value will be
undefined. This might not have been what you
intended.
User Action Supply a return value for the return statement or
define the function with a void return type.
56.570 – NORETVAL
Message routine <text> does not return a value
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.571 – NORGHTPAREN
Message No right parenthesis for parameter list.
Description A macro definition's formal parameter list did not
end in a right parenthesis. A right parenthesis has
been assumed.
User Action End the formal parameter list with a right
parenthesis.
56.572 – NORIGHTOPERND
Message Token pasting operator missing right operand.
Description The preprocessing token pasting operator "##" appears
in a macro body without a token argument after the
operator.
User Action Either remove the operator or supply it with two
tokens that will be pasted together.
56.573 – NORIGHTPAREN
Message Missing ")".
Description A right parenthesis was expected at this point in the
program, but none was found.
User Action Correct the program syntax.
56.574 – NOSEHHAND
Message Missing exception handler.
Description The __builtin_try clause must specify an exception
handler of either __builtin_finally or
__builtin_except. This message is only generated on
UNIX systems.
User Action Correct the __builtin_try clause.
56.575 – NOSEMI
Message Missing ";".
Description The compiler was expecting a semicolon, but one was
not found.
User Action Correct the program syntax.
56.576 – NOSEMI1
Message Missing ";". This condition may have been caused by
an open brace without a matching close brace. The
compiler will attempt to identify open braces that
might be missing a close brace.
Description The compiler was expecting a semicolon, but one was
not found. This condition may have been caused
missing close brace. This message is followed by
some number of additional messages that attempt to
identify the bad open brace.
User Action Correct the program syntax.
56.577 – NOSEMISTRUCT
Message Missing ";" after last structure or union member.
Description Accepting a struct/union type without a semicolon
after the last member specifier is a language
extension of HP C provided for compatiblity with
older C compilers. This syntax is not valid in
standard C, and may not be accepted by other C
compilers.
User Action Add the semicolon at the end of the last member.
56.578 – NOSFILE
Message Cannot create .s file: overlapping static storage
initializations at Psect <text> + <number>
Description When producing an output assembly file, the compiler
back-end as detected a case where the same storage
location has been initialized to more than one value.
This can occur when inter-file optimization has been
enabled.
User Action Remove one of the initializers.
56.579 – NOSHAREEXT
Message noshare is a language extension.
Description The noshare storage class modifier is a language
extension of HP C. Other C compilers might not
successfully compile a program that uses the
extension.
User Action Be aware of this extension if you wish to port the
code.
56.580 – NOSHRINSHR
Message Noshare variable resides in shr extern model -
noshare ignored.
Description The current extern model places all external objects
in a shareable section. Placing an object with a
noshare type qualifier in such a section is invalid.
The compiler will ignore the noshare type qualifier
User Action Place noshare objects in sections with the noshare
attribute.
56.581 – NOSTRING
Message Missing string literal.
Description The compiler was expecting a string literal, but one
was not found.
User Action Correct the program syntax.
56.582 – NOSUBTRACT
Message <Context> "<expression2>" cannot be subtracted from
"<expression1>".
Description Because of their types, the two expressions cannot be
used as the operands of the subtraction operator.
Either both operands must be arithmetic type, or both
operands must be pointers to qualified or unqualified
versions of compatible object types, or the left
operand must be a pointer type and the right operand
must be an integral type.
User Action Modify the subtraction to use valid types.
56.583 – NOTADDRCAST
Message <Context> the address constant "<expression>" can be
cast only to a pointer type, but "<type>" is <type
class> type.
Description An address constant can only be cast to a pointer
type.
User Action Correct the cast.
56.584 – NOTAREDUCTION
Message bad reduction path from fetch of <text>
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.585 – NOTCOMPAT
Message <Context> the type of "<name>" is not compatible with
the type of a previous declaration of "<name>" at
<location>.
Description The same identifier has been redeclared with a type
that is incompatible with the type given in a
previous visible declaration. In some modes, the
compiler will use the redeclared type as the type of
the identifier.
User Action Change the declarations to use compatible types.
56.586 – NOTCOMPATIMP
Message <Context> the type of the function "<name>" is not
compatible with the earlier implicit declaration of
"<name>" at <location>.
Description The declared type of a function does not match the
type given to the function by its earlier implicit
declaration. This may cause unexpected behavior.
User Action Make sure that a valid function declaration is
visible at the point in the source where the function
is first called.
56.587 – NOTCOMPFUNC
Message <Context> an invalid redeclaration of "<name>" to or
from a function type is being ignored.
Description In certain modes, the compiler will allow an
identifier to be redeclared with a different type.
In this case, the type of the redeclaration is used.
However, in cases where the identifier is redeclared
to or from a function type, the redeclaration is
ignored.
User Action Remove the redeclaration of the identifier.
56.588 – NOTCONSTQUAL
Message <Context> the referenced type of the pointer value
"<expression>" is const, but the referenced type of
the target of this assignment is not.
Description In an assignment of two pointer types, the type
pointed to by the destination operand must have all
the type qualifiers of the type pointed to by the
source operand. In this case, the type pointed to by
the source has the const type qualifier, but the type
pointed to by the destination does not.
User Action Correct the assignment to use compatible types. This
can be done by inserting a cast operand.
56.589 – NOTEXPECTING
Message Error parsing <what>. Found "<found>" when expecting
<expecting>.
Description While parsing the program, the compiler has
encountered something unexpected. The message will
detail what the compiler was trying to parse and the
item that was invalid, and will also produce a list
of those items it was expecting to find.
User Action Correct the offending section of the program.
56.590 – NOTINCRTL
Message Identifier "<id>" is reserved by the
<C89|C99|C2010...> standard and will be mapped to
"<name>" although it is not available in the CRTL
available to the compiler.
Description The specified identifier is reserved for use as an
identifer with external lingage in the specified
version of the C standard. But according to the CRTL
mapping table available to the compiler, that
identifier is not defined in the CRTL you expect to
link against. This may be because the function or
object is not yet implemented in the current
DECC$SHR, or because you have used logical
DECC$CRTLMAP to specify a CRTL mapping table for a
version of the CRTL that does not implement it.
User Action If you intended to use the identifier as defined by
the C standard, and you have not defined the logical
DECC$CRTLMAP, then the identifier is not defined in
the DECC$SHR available to the compiler. If this is
the latest released DECC$SHR, then the identifier is
not yet implemented and you need to consider
workarounds; otherwise you should upgrade to the
latest available CRTL that does implement it. If you
did not intend to use the identifier as defined by
the C standard (i.e. it is an identifier you
expected to be defined by your application), then you
have a name clash with the specified version of the
standard and you should change the spelling of the
identifier; alternatively, you could disable
prefixing for it using /PREFIX=EXCEPT=, or specify an
older version of the standard with either /PREFIX= or
/STANDARD=.
56.591 – NOTINTRINSIC
Message The function "<routine name>" is not a known
intrinsic function and cannot be used with #pragma
function. The function is unaffected by this pragma.
Description A function identifier specified in a #pragma function
directive is not a valid intrinsic function on this
platform. The function is thus never treated as an
intrinsic, and so #pragma function can never be
applicable to it. Perhaps the name was misspelled,
or perhaps the function was thought to be intrinsic,
possibly because it is intrinsic on some other
platform. In the latter case, the desired result,
that the function not be treated as intrinsic, would
happen with or without the pragma.
User Action Either correct the identifier spelling or remove the
use of the pragma.
56.592 – NOTLOCALPARM
Message <Context> "<identifier>" is not a local parameter.
Description The second argument to the variable argument list
va_start macro is not a formal parameter of the
current function. The second argument to va_start
should be the rightmost parameter in the function
definition.
User Action Correct the second argument to va_start.
56.593 – NOTONEORZERO
Message <Context> the value of "<expression>" is neither 0
nor 1.
Description The __builtin_va_start macro has been used
incorrectly.
User Action Correct the use of the macro.
56.594 – NOTPARM
Message <Context> <name> is not a parameter.
Description The identifier name in the parameter declaration does
not match a name in the identifier list of an
old-style function definition.
User Action Correct either the identifier in the declaration or
in the identifier list so that they match. HP also
recommends that old-style function definitions be
replaced by prototype-format definitions.
56.595 – NOTPOSINT
Message <Context> the array bound "<expression>" is not a
positive integer.
Description The compiler has encountered an array-bounds
specifier that is either zero or negative.
Array-bounds specifiers must be positive integer
constants.
User Action Correct the array-bounds specifier
56.596 – NOTRESTQUAL
Message <Context> the referenced type of the pointer value
"<expression>" is restrict, but the referenced type
of the target of this assignment is not.
Description In an assignment of two pointer types, the type
pointed to by the destination operand must have all
the type qualifiers of the type pointed to by the
source operand. In this case, the type pointed to by
the source has the restrict type qualifier, but the
type pointed to by the destination does not.
User Action Correct the assignment to use compatible types. This
can be done by inserting a cast operand. Note that
care should be taken in assigning to a restricted
pointer type.
56.597 – NOTRIGHTMOST
Message <Context> "<identifier>" is not the rightmost
parameter to "<function>".
Description The second argument to va_start was not the rightmost
parameter in the variable parameter list in the
function definition. This is an invalid argument to
va_start. Other compilers might not accept this
program.
User Action Update the second argument to va_start to use the
rightmost parameter.
56.598 – NOTSCALARCTRL
Message The controlling expression "<expression>" has <type>
type, which is not scalar.
Description An execution control expression does not have scalar
type. This is not valid. An example of an execution
control expression is the expression following the
while keyword in a while statement.
User Action Change the control expression to have scalar type.
56.599 – NOTTYPEDEF
Message <Context> "<name>" does not name a type.
Description This message is output when the compiler encounters
an identifier that it believes is a typedef and no
valid typedef by this name is defined in the current
scope. This most often occurs when there was an
error in the declaration of the typedef name.
User Action Correct the declaration of typedef.
56.600 – NOTUNALQUA
Message <Context> the referenced type of the pointer value
"<expression>" is __unaligned, but the referenced
type of the target of this assignment is not.
Description In an assignment of two pointer types, the type
pointed to by the destination operand must have all
the type qualifiers of the type pointed to by the
source operand. In this case, the type pointed to by
the source has the __unaligned type qualifier, but
the type pointed to by the destination does not.
User Action Correct the assignment to use compatible types. This
can be done by inserting a cast operand.
56.601 – NOTVOLQUAL
Message <Context> the referenced type of the pointer value
"<expression>" is volatile, but the referenced type
of the target of this assignment is not.
Description In an assignment of two pointer types, the type
pointed to by the destination operand must have all
the type qualifiers of the type pointed to by the
source operand. In this case, the type pointed to by
the source has the volatile type qualifier, but the
type pointed to by the destination does not.
User Action Correct the assignment to use compatible types. This
can be done by inserting a cast operand.
56.602 – NOTYPES
Message Declaration has no type or storage class.
Description A file-scope declaration contains no type and no
storage-class specifier. In some modes, the HP C
compiler will treat this as a tentative definition of
an int variable. Accepting this declaration is an
extension to standard C provided for compatibility
with other compilers.
User Action Rewrite the declaration to contain a data type and/or
storage class.
56.603 – NOUNIQFORMALS
Message Non-unique formal parameter definition.
Description The same name has been used for more than one formal
parameter in a macro definition. Any occurrence of
the name in the macro body will correspond to the
last formal parameter given this name.
User Action Each macro formal parameter should have a unique
name.
56.604 – NOWHILE
Message Missing "while".
Description While processing a do statement, the compiler did not
find a while clause.
User Action Supply a while clause for the do statement.
56.605 – NOWRTWRITTEN
Message Readonly psect <text> is written
Description The compiler has detected an attempt to write to
read-only storage.
User Action Either remove the write or make the storage
read/write.
56.606 – OBJECTTOOBIG
Message The size of "<name>" exceeds the maximum size of an
object allowed on this platform which is <size>
bytes.
Description An object has been declared with a size that is too
large for this platform.
User Action Reduce the size of the object.
56.607 – OKCPPINARGS
Message "#<directive>" directive within a macro argument list
is not portable.
Description HP C will allow certain directives to appear within
the argument list of a macro invocation. This might
not be portable.
User Action If possible, rewrite the macro invocation.
56.608 – OPENBRACE
Message Missing "{".
Description The compiler was expecting an open brace, but one was
not found.
User Action Correct the program syntax.
56.609 – OPENCOMMENT
Message A comment is not terminated.
Description The end of a file was reached while within a comment.
The message will indicate the start of the comment.
All source files, even those included via the
#include preprocessing directive, must not end in a
pending comment.
User Action Terminate the comment before the end of the source
file.
56.610 – OPENPAREN
Message Missing "(".
Description The compiler was expecting an open parenthesis, but
one was not found.
User Action Correct the program syntax.
56.611 – OPTIMIZEPOP
Message This "restore" has underflowed the pragma optimize
stack. No corresponding "save" was found.
Description The optimize stack, managed by the #pragma optimize
and #pragma environment directives, contains more
restores than saves. This could signify a coding or
logic error in the program.
User Action Make sure each restore has a corresponding save.
56.612 – OPTLEVEL
Message Invalid optimization level <number>, defaulted to
<number>.
Description An optimization level that is outside the range of
valid optimization levels has been specified. The
compiler will default to the stated level.
User Action Supply a valid optimization level on the command
line.
56.613 – OTHERDECLUSED
Message <Context> "<name>" is not declared in a scope active
at this point in the compilation. However, there is
a declaration of this identifer with extern storage
class in another scope at <where>. This declaration
will be used.
Description In some modes, if the compiler cannot find the
declaration of an object in the current scope, it
will search other scopes for extern declarations of
that object. If it finds such a declaration, it will
be used. Note that this is a language extension
provided for compatibility with other compilers.
User Action Declare the object so that it is visible at all
places it is referenced.
56.614 – OTHERMEMBER
Message <Context> "<name>" is a member of another struct or
union.
Description In certain modes, the compiler will allow a struct or
union reference whose right operand is not a member
of the struct or union type of the left operand.
This is allowed for compatibility with other
compilers.
User Action Correct the struct or union reference so that the
member specifier is a member of the type of the left
operand.
56.615 – OUTARGPREC
Message <Context> the type of this argument to <function
name> is not appropriate for the precision argument
of the conversion specifier "<incorrect conversion>".
Behavior can be unpredictable.
Description This argument corresponds to an output precision
specification. C requires that this argument have
integer type, and it does not.
User Action Cast the argument to an int type.
56.616 – OUTARGWIDTH
Message <Context> the type of this argument to <function
name> is not appropriate for the width argument of
the conversion specifier "<incorrect conversion>".
Behavior can be unpredictable.
Description This argument corresponds to an output width
specifier. C requires that this argument have
integer type, and it does not.
User Action Cast the argument to an int type.
56.617 – OUTFLOATINT
Message <Context> this argument to <function name> and
conversion specifier "<incorrect conversion>" combine
integer and floating-point types. Behavior can be
unpredictable.
Description The compiler has detected an output conversion
specifier whose data type does not match its
corresponding argument in a way that will cause
unpredictable behavior.
User Action Modify either the argument or the conversion
specifier so that they match.
56.618 – OUTSTRINGTYPE
Message <Context> this argument to <function name> is of
"<type name>" type and is not appropriate for the
conversion specifier "<incorrect conversion>". The
value will be formatted in an unintended manner.
Description The compiler has detected a string conversion
specifier that does not match its corresponding
argument. This might not have been what you
intended.
User Action Modify either the argument or the conversion
specifier so that they match.
56.619 – OUTTOOFEW
Message <Context> the number of conversion specifiers to
<function name> exceeds the number of values to be
converted. Conversion specifiers from "<last valid
conversion>" onward will process meaningless and
perhaps invalid data.
Description The number of conversion specifiers is greater than
the number of values to be converted as specified in
the parameter list. This is probably not what you
intended.
User Action Make sure the number of conversion specifiers match
the values to be converted.
56.620 – OUTTOOMANY
Message <Context> additional arguments to <function name> are
provided for which there are no conversion specifiers
in the format string. Arguments from "<last
expression>" onward will be evaluated, but not
processed by <function name>.
Description The number of conversion specifiers is less than the
number of values to be converted as specified in the
parameter list. This is probably not what you
intended.
User Action Make sure the number of conversion specifiers match
the values to be converted.
56.621 – OUTTYPELEN
Message <Context> this argument to <function name> is of
"<typeclass>" type and is not appropriate for the
conversion specifier "<incorrect conversion>". The
value might be truncated or formatted in an
unintended manner.
Description The compiler has detected an output conversion
specifier that does not match its corresponding
argument. This might not have been what you
intended.
User Action Modify either the argument or the conversion
specifier so that they match.
56.622 – OUTVARORDER
Message <Context> variable ordering is used in a conversion
specifier for <function name>. If variable ordering
is used, it must be specified for all conversions.
Description A conversion specification can contain only one type
of conversion specification - % or %n$. Mixing them
will cause unpredictable behavior.
User Action Change the format specification to use only one type
of conversion specification.
56.623 – PACKSTACKPOP
Message This "pop" has underflowed the pragma <stack name>
stack. No corresponding "push" was found.
Description The member_alignment/pack stack, managed by the
#pragma pack and #pragma member_alignment directives,
contains more pops/restores than pushes/saves, This
could signify a coding or logic error in the program.
User Action Make sure each pop/restore has a corresponding
push/save.
56.624 – PARAMREDECL
Message <Context> "<name>" overrides a formal parameter
declared at <where>.
Description A declaration within a function body redeclares a
formal parameter.
User Action Change the name of either the formal parameter or the
declared variable.
56.625 – PARENLITERAL
Message <Context> accepting a string literal in parentheses
as the initializer for a character array is a
language extension.
Description The compiler accepts this kind of initializer for
compatibility with many other C compilers. According
to the C standard, a string literal in parentheses is
a character pointer. Therefore, this program does
not conform to the standard and may be rejected by
other compilers.
User Action Remove the parentheses.
56.626 – PARMINCOMP
Message <Context> the parameter <name> has an incomplete
type.
Description The parameter of an old-style function definition has
an incomplete type. This is not valid.
User Action Complete the type before the declaration of the
parameter. HP also recommends that old-style
function definitions be replaced by prototype-format
definitions.
56.627 – PARMINIT
Message <Context> a parameter declaration cannot include an
initializer.
Description The parameter declaration list of an old-style
function definition included an initializer. This is
not valid.
User Action Remove the initializer from the declaration and
initialize the parameter in the function body. HP
also recommends that old-style function definitions
be replaced by prototype-format definitions.
56.628 – PARMSTORCLS
Message <Context> a parameter has an explicit storage class
other than "register".
Description The only storage class that can be specified for a
formal parameter is "register".
User Action Either remove the storage class or use "register" if
that is desired.
56.629 – PARMSTORMOD
Message <Context> a parameter cannot have a storage class
modifier.
Description A formal parameter cannot be declared with a storage
class modifier.
User Action Remove the storage class modifier.
56.630 – PARMTYPLIST
Message Ill-formed parameter type list.
Description While processing a function declaration, an invalid
parameter type list was encountered.
User Action Correct the program syntax.
56.631 – PARNOIDENT
Message Missing identifier.
Description While processing an old-style function definition,
the compiler was expecting an identifier, but one was
not found.
User Action Correct the program syntax. HP also recommends that
old-style function definitions be replaced by
prototype-format definitions.
56.632 – PDBOPERR
Message Error opening PDB file <text>: <text>
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.633 – PDBTYPERR
Message Error adding type record to PDB file: <text>
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.634 – PDOINDEXNOTPRIV
Message index variable of PDO <text> is not a private
variable
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.635 – PDONEINSTATIC
Message pdone <text> in statically-scheduled PDO will be
ignored
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.636 – PDONENOTINPDO
Message pdone <text> is not nested in a PDO
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.637 – PLUSWSTOCLS
Message The use of the <spelling> option has prevented this
redeclaration of "<variable>" from changing its
linkage. The linkage will be that specified by the
earlier declaration at <location>.
Description In many cases, the compiler will allow a
redeclaration of an item to change its linkage. For
example, in most modes, if an object is declared with
extern linkage and later with static linkage, the
compiler will give it static linkage. This changing
of linkage usually causes a warning to be issued.
However, in cases where interfile optimization has
been selected (-ifo on UNIX, /PLUS_LIST_OPTIMIZE on
OpenVMS), the compiler cannot allow a later
declaration to modify the linkage of a previous
declaration.
User Action Change all declarations to use the same linkage.
56.638 – POINTERINTCAST
Message <Context> the 64-bit pointer "<expression>" is being
cast to an integer type that is only <size> bits in
size. This behavior is undefined.
Description Casting a 64-bit pointer to a shorter integer type is
undefined behavior. This also could indicate code
that relies on pointers and integers being the same
size. The code will cause an unexpected loss of data
on 64-bit platforms.
User Action If this is the intended behavior, first cast the
pointer to a 64-bit integer, then cast the result to
the desired integer type.
56.639 – POPMISMATCH
Message The member alignment popped/restored with pragma
<pragma name> was saved using pragma <pragma name>.
The member alignment restored will take effect.
Description HP C supports two forms of the member alignment
directives. One begins with #pragma pack, the other
with #pragma member_alignment. A program has mixed
the pack and the member_alignment form of the
directives in a way that is not recommended. This
might indicate a programming error.
User Action If a member alignment has been saved by one form of
the member-alignment directive, it should be restored
by the same form of the directive.
56.640 – PRAGIGNORE
Message The pointer size control <name> pragma is not active.
Pragma is ignored.
Description Either one of the pragmas that used to control
pointer size has been specified on a platform that
does not support mixed pointer sizes, or the #pragma
pointer_size directive has been used without the
appropriate command-line option or qualifier. In all
cases, the directive is ignored.
User Action Either remove the directive or add the appropriate
command-line option.
56.641 – PRAGMA
Message Strict standard C extension: A #pragma directive was
encountered.
Description As the purpose of a #pragma directive is to specify
implementation-defined behavior, it is likely that
other C compilers will not treat this pragma in the
same way HP C will.
User Action Be aware of this if you wish to port the program.
56.642 – PRAGMAIDENT
Message Please use the preferred "#pragma ident" directive in
place of the "#ident" directive.
Description The #ident directive is a language extension. Other
C compilers might not accept it.
User Action Use the portable #pragma ident directive instead.
56.643 – PRAGMAINBLK
Message The pragma <name> cannot be used inside a function
block.
Description This #pragma directive is only permitted at file
scope, outside of all function definitions.
User Action Move the directive to file scope, preceding the
function definition that is to be affected. To limit
the pragma to just that particular function, sandwich
the #pragma and the function definition between a
pair of matching pragmas with the save and restore
keywords.
56.644 – PRAGMAMOD
Message Please use the preferred "#pragma module" directive
in place of the "#module" directive.
Description The #module directive is a language extension. Other
C compilers are unlikely to accept it.
User Action Use the portable #pragma module directive instead.
56.645 – PRAGMAOPTDUP
Message This #pragma optimize has already modified this
optimization setting. This setting will replace the
old.
Description A #pragma optimize has specified the same
optimization setting more than once. The later
setting will replace the previous one.
User Action Remove the earlier setting.
56.646 – PRAGMAOPTLVL
Message The level set by a #pragma optimize directive must be
between 0 and 5. Pragma is ignored.
Description A #pragma optimize has tried to set the optimization
level to a value outside the valid range. The
compiler will ignore the directive.
User Action Set the optimization level to a number from 0 to 5.
56.647 – PRAGMAOPTSPEC
Message Setting speculation control is not available on this
platform. The setting will be ignored.
Description Setting speculation control in only available on
certain platforms. Trying to modify the setting on
other platforms will have no effect.
User Action Remove the speculation setting.
56.648 – PRAGMAOPTZERO
Message If a #pragma optimize specifies level=0, that must be
the only optimization setting specified by the
pragma. Pragma is ignored.
Description If a #pragma optimize specifies level=0, that must be
the only optimization setting specified by the
pragma. The compiler will ignore the directive.
User Action Remove the other settings specified by the directive.
56.649 – PREOPTE
Message An error was detected in the processing of a <option
spelling> option: <#define or #undefine problem>
Description An error was encountered during the processing of a
macro definition specified on the command line. The
message should provide additional information about
the error.
User Action Correct the command line argument.
56.650 – PREOPTW
Message A problem was detected in the processing of a <option
spelling> option: <#define or #undefine problem>
Description A problem was encountered during the processing of a
macro definition specified on the command line. The
message should provide additional information about
the problem.
User Action Correct the command-line argument.
56.651 – PREPROCOUT
Message An error occurred while attempting to open either the
preprocessor output file or the dependency file:
<problem>.
Description An unexpected error occurred during the creation of a
preprocessor output file or a dependency file. The
message text will contain additional information
about the failure.
User Action Correct the condition that caused the failure.
56.652 – PRIVATENOTSHARE
Message variable <text> on a local or lastlocal list is not
declared in a shared scope.
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.653 – PROMOTMATCH
Message <Context> the promoted type of <name> is incompatible
with the type of the corresponding parameter in a
prior declaration.
Description The promoted type of a parameter of an old-style
function declaration does not match the type given
earlier in a prototype declaration of the function.
User Action Correct the data types so they match. HP also
recommends that old-style function definitions be
replaced by prototype-format definitions.
56.654 – PROMOTMATCHW
Message <Context> the promoted type of <name> is incompatible
with the type of the corresponding parameter in a
prior declaration.
Description The promoted interger or floating type of a parameter
of an old-style function declaration does not match
the integer or floating type given earlier in a
prototype declaration of the function.
User Action Correct the data types so they match. HP also
recommends that old-style function definitions be
replaced by prototype-format definitions.
56.655 – PROTOF
Message An error occurred while attempting to open the
prototype output file: <problem>.
Description An unexpected error occurred during the creation of a
prototype output file. The message text will contain
additional information about the failure.
User Action Correct the condition that caused the failure.
56.656 – PROTOSCOPE
Message The type "<type>" has been declared within and is
limited to a function prototype scope. It will not
be compatible with an identical type declared in
another scope. This might not be what you intended.
Description A type is declared within a function prototype. The
type is local to the function prototype and will not
be visible outside the prototype. This might cause
unexpected errors later in the compilation.
User Action Declare the type before the function prototype.
56.657 – PROTOSCOPE2
Message <Context> the struct type was previously declared
with prototype scope in this function. Now it is
declared with a different prototype scope.
Description This function declaration contains a parameter that
is a pointer to a type that has prototype scope, and
an earlier declaration of the function contains a
parameter that is also a pointer to a type that has a
different prototype scope. In most compiler modes
this will cause the function redeclarations to
differ.
User Action Avoid declaring types with function prototype scope.
56.658 – PROTOSCOPE3
Message <Context> the struct type was previously declared in
this function with prototype scope. Now it is
declared with file scope.
Description This message is generated when the compiler first
encounters a function prototype that declares a type
with prototype scope, and then later sees a second
declaration or definition of that same function with
the parameter declared using the same type declared
at file scope. For example: void foo(struct S { int
a; int b;} *s); struct S { int a; int b;} s; void
foo(struct S *s);
User Action Declare the type at file scope before the first
prototype declaration.
56.659 – PROTOSTATIC
Message The extracted header file contains prototypes for
static functions, which should be removed before
including the header in a source file other than the
originator.
Description When extracting function prototype declarations, the
compiler has encountered a static function. The
prototype declaration placed in the output .H file
should be removed if the .H file is included in any
source other than that used to create the .H file.
This is because those static functions may not be
declared in the other files. This message can only
be generated when the compiler has been invoked with
the option to extract function prototype
declarations, and the suboption to generate
prototypes for static functions has also been
specified.
User Action Be aware of this if you wish to use the output .H
file in a file other than the one from which the .H
file was generated.
56.660 – PROTOTAG
Message The extracted header file contains prototypes with
tag names, which should be moved to after the tag
name declaration.
Description When extracting function prototype declarations, the
compiler has encountered a parameter type specifier
that references a tag. Because the created prototype
will use this tag, it should be moved after the tag
declaration in the final compilation source. This
message can only be generated when the compiler has
been invoked with the option to extract function
prototype declarations.
User Action Be aware of this if you wish to use the output .H
file.
56.661 – PROTOTYPEDEF
Message The extracted header file contains prototypes with
typedefs, which should be moved to after the typedef
declaration.
Description When extracting function prototype declarations, the
compiler has encountered a parameter type specifier
that is defined by a typedef. Because the created
prototype will use this typedef, it should be moved
after the typedef declaration in the final
compilation source. This message can only be
generated when the compiler has been invoked with the
option to extract function prototype declarations.
User Action Be aware of this if you wish to use the output .H
file.
56.662 – PROTOVLA
Message The extracted header file contains prototypes for
functions which have formal parameters with variably
modified type. All variable length bound specifiers
have been replaced by a "*" signifying a variable
length array of unspecified size.
Description When extracting function prototype declarations, the
compiler has encountered a function or functions
which have a formal parameter with variably modified
type. The compiler is unable to recreate the source
that specified the number of array elements.
Instead, the output prototype will use the "*" bounds
specifier. Note that the output prototype is valid
for the function.
User Action Be aware that the compiler has made this minor change
to the function declaration.
56.663 – PSECTFIRST
Message "#pragma <psect_type>" directive must precede any
declarations.
Description The #pragma code_psect or #pragma linkage_psect
directives must appear before any function or
external data definitions.
User Action Place the directive earlier in the source program.
56.664 – PSECTTOOLONG
Message Psect name is too long (maximum is 31 characters).
Pragma is ignored.
Description A psect name specified in a #pragma code_psect,
#pragma linkage_psect, or #pragma extern_model
directive must be less than 32 characters in length.
The compiler will ignore the directive.
User Action Shorten the psect name.
56.665 – PTRINTTOLONG
Message <Context> "<expression>", a pointer to a 32-bit
integer, is being cast to a pointer to a 64-bit
integer. This may lead to unintended results.
Description On many platforms long integers are the same size as
integers, and casting a pointer to int to a pointer
to long int is not a problem. On this platform long
integers are 64-bits. This cast could indicate a
potential porting problem.
User Action Verify that this is the intended behavior.
56.666 – PTRLONGTOINT
Message <Context> "<expression>", a pointer to a 64-bit
integer, is being cast to a pointer to a 32-bit
integer. This may lead to unintended results.
Description On many platforms long integers are the same size as
integers, and casting a pointer to long int to a
pointer to int is not a problem. On this platform
long integers are 64-bits. This cast could indicate
a potential porting problem.
User Action Verify that this is the intended behavior.
56.667 – PTRMISMATCH
Message <Context> the referenced type of the pointer value
"<expression>" is "<type>", which is not compatible
with "<target type>".
Description In a pointer assignment, the type pointed to by the
source pointer is different than the type pointed to
by the destination pointer.
User Action Correct the assignment to use compatible types. This
can be done by inserting a cast operand.
56.668 – PTRMISMATCH1
Message <Context> the referenced type of the pointer value
"<expression>" is "<type>", which is not compatible
with "<target type>" because they differ by
signed/unsigned attribute.
Description In a pointer assignment, the type pointed to by the
source pointer is different than the type pointed to
by the destination pointer. In this case the types
differ because the signed/unsigned type attributes
are different.
User Action Correct the assignment to use compatible types. This
can be done by inserting a cast operand.
56.669 – QUALAFTCOMMA
Message Type qualifier(s) after a comma ignored.
Description In Microsoft mode, the compiler used to accept a type
qualifier after a comma used for separating
declarators. Because Microsoft no longer accepts
this type of declaration, HP C will no longer accept
it. The type qualifier is ignored.
User Action Remove the type qualifier.
56.670 – QUALFUNCRET
Message The return type of "<name>" is a qualified type.
Type qualifiers have no meaning for function return
values.
Description A type qualifier has been used as part of the type of
a function return value. The type qualifiers have no
meaning for function return values.
User Action Remove the type qualifier.
56.671 – QUALISPTR
Message <Context> "<expression>" has a pointer type, but
occurs in a context that expects a struct or union.
Description The left operand of the struct/union member operator
(.) is a pointer type instead of a struct or union
type.
User Action Specify the correct struct or union type object as
the left operand. In cases where the left operand is
a pointer to a struct or union, it might be possible
to use the struct/union pointer operator (->) instead
of the member operator.
56.672 – QUALNA
Message The <qualifier name> qualifier is not available on
this platform and will be ignored.
Description The specified qualifier is not supported on this
platform.
User Action Remove the qualifier from the command line.
56.673 – QUALNOTUS
Message <Context> the qualifier for "<name>" is not a struct
or union.
Description In certain modes, the compiler will allow the left
operand of a struct/union member reference to be
certain types other than a struct or union type. In
these cases the compiler will issue a warning that
this non-standard syntax is being accepted.
User Action Modify the left operand to be a struct or union type.
56.674 – QUESTCOMPARE
Message <Context> the unsigned expression "<expr>" is being
compared with a relational operator to a constant
whose value is not greater than zero. This might not
be what you intended.
Description An ordered comparison between an unsigned value and a
constant that is less than or equal to zero often
indicates a programming error. Humans consider an
unsigned value to be larger than any negative value.
But in C a negative value is converted to an unsigned
value before the comparison, so any negative value
compares larger than most unsigned values. An
ordered comparison of an unsigned value to zero
suggests a programming error because the value can
only be greater than or equal to zero. If the code
is correct, the comparison could be more clearly
coded by testing for equality with zero.
User Action Cast (or otherwise rewrite) one of the operands of
the compare to match the signedness of the other
operand, or compare for equality with zero.
56.675 – QUESTCOMPARE1
Message <Context> the unsigned expression "<expr>" is being
compared with an equality operator to a constant
whose value is negative. This might not be what you
intended.
Description An unsigned value and a signed constant whose value
is negative are being compared for equality.
Logically, these value would never be equal. But in
C the negative constant value is converted to an
unsigned value before the comparison, and may well
compare equal.
User Action Cast (or otherwise rewrite) one of the operands of
the compare to match the signedness of the other
operand.
56.676 – QUESTCOMPARE2
Message <Context> the unsigned expression "<expr>" is being
tested to see if it is greater than zero. This might
not be what you intended.
Description An ordered comparison between an unsigned value and a
constant that is zero may indicate a programming
error. Often C programmers do not realize that an
expression has an unsigned type. If the code is
correct, the comparison could be more clearly coded
by testing for equality with zero.
User Action Cast (or otherwise rewrite) one of the operands of
the compare to match the signedness of the other
operand, or compare for equality with zero.
56.677 – READONLYEXT
Message readonly is a language extension.
Description The readonly storage class modifier is a language
extension of HP C. Other C compilers might not
successfully compile a program that uses the
extension.
User Action Be aware of this extension if you wish to port the
code.
56.678 – REDECLNOPARAM
Message <Context> the declaration of the function "<name>"
containing no parameter information replaces an
earlier declaration of "<name>" at <location>.
Description A function which was previously declared with a
function prototype has been redeclared without
parameter information. This is a violation of the C
standard. The HP C compiler will accept this for
compatibility with older compilers.
User Action Remove one of the declarations.
56.679 – REDEF
Message This declaration contains a redefinition of "<name>".
The previous declaration is at <location>.
Description This declaration has tried to redefine an identifier
that was defined earlier. This is not valid.
User Action Remove one of the definitions.
56.680 – REDEFSTRUCT
Message <Context> the struct "<name>" is redefined.
Description The struct tag declared in this declaration is
already declared as a struct tag by another
declaration.
User Action Change the name of the struct tag.
56.681 – REDEFTAG
Message <Context> the tag "<name>" is redeclared.
Description The tag declared in this declaration is already
declared.
User Action Change the name of the tag.
56.682 – REDEFUNION
Message <Context> the union "<name>" is redefined.
Description The union tag declared in this declaration is already
declared as a union tag by another declaration.
User Action Change the name of the union tag.
56.683 – REFBEFORETLS
Message <Context> the reference to the variable "<var>"
lexically precedes its use in a #pragma omp
threadprivate directive. This is not allowed.
Description An OpenMP threadprivate directive must lexically
precede all references to any varible in its variable
list. The compiler had detected a reference to a
variable which appears in a subsequent threadprivate
directive.
User Action Move the threadprivate directive before the
reference.
56.684 – REGCONFLICT
Message Conflicting required uses of register(s): <text>
Description The special linkage associated with a function has
specified that one of the standard calling convention
registers be used in a nonstandard way without also
replacing its standard use with another register. An
example would be a function that returns an int value
using a special linkage that states R0 is not used,
and does not specify another register to hold the
return value.
User Action Correct the #pragma linkage directive that specifies
the special linkage.
56.685 – REGNOSHARE
Message <Context> noshare cannot be used with the register
storage class. Modifier noshare is ignored.
Description The storage class modifier noshare is meaningless for
objects declared with register storage class. The
compiler ignores the noshare.
User Action Remove the noshare storage class modifier.
56.686 – RELOCALIGNMENT
Message An initialization requiring relocation is not
correctly aligned at Psect <text> + <number>
Description On some platforms, initializing an object to an
address requires that the object be aligned on a
natural boundary.
User Action Either remove the static initializer or align the
object being initialized.
56.687 – RESMISMATCH
Message The pointer size restored with pragma <pragma name>
was saved using pragma <pragma name>. The pointer
size restored will take effect.
Description HP C supports two forms of the pointer-size
directives. One begins with #pragma pointer_size,
the other with #pragma required_pointer_size. A
program has mixed the required_pointer_size and the
pointer_size form of the pointer-size directives in a
way that is not recommended. This might indicate a
programming error.
User Action If a pointer size has been saved by one form of the
pointer-size directive, it should be restored by the
same form of the directive.
56.688 – RESTRICTEXT
Message The __restrict type qualifier is a language
extension.
Description The use of the __restrict type qualifier might not be
portable to other C compilers.
User Action Be aware of this portability concern.
56.689 – RESTRICTEXT1
Message Placement of the __restrict qualifier within the
array-bound specifier of a formal parameter
declaration is a language extension.
Description The use of the restrict type qualifier within the
array bound specifier of a formal parameter is a
language extension supported by HP C. Other C
compilers might not successfully compile a program
that uses this extension.
User Action Be aware of this if you wish to port the program.
56.690 – RESTRICTEXT2
Message The restrict type qualifier is a new feature in C99.
Other C compilers might not successfully compile a
program that uses this feature.
Description The use of the restrict type qualifier might not be
portable to other C compilers.
User Action Be aware of this portability concern.
56.691 – RESTRICTNOP
Message The restrict type qualifier can only be applied to a
pointer type that points to an object or incomplete
type. Qualifier is ignored.
Description The restrict type qualifier has been used with an
invalid type. Only pointers to object or incomplete
types can have the restrict type qualifier. The
compiler will ignore the type qualifier in all other
cases.
User Action Remove the type qualifier or change the type to one
that accepts the qualifier.
56.692 – RETLOCALADDR
Message This return statement returns the address of a local
variable. The address returned cannot be used by the
caller in any meaningful way.
Description The storage for all local variables is undefined
after a function has returned. Returning the address
of a local variable will cause undefined behavior
when the return value is used in the calling program.
User Action Either change the variable to have static storage
duration, use malloc to allocate the storage (and
free it after its use), or change the interface to
have the caller pass in the address at which data is
to be stored.
56.693 – RETRYCONV
Message Built-in function <retry-name> is not available on
this platform. It has been converted to
<nonretry-name> by ignoring the retry count and
setting the retry status to 1.
Description The version of this built-in function with retry
capability is not available on the IA64 platform.
User Action Use the non-retry version of this built-in function.
56.694 – RETRYNOTAVAIL
Message Built-in function <name> with retry count is not
available on this platform. The retry count is
ignored.
Description The retry capability of this built-in function is not
available on the IA64 platform.
User Action Remove retry count from built-in function call.
56.695 – RETVALTOOBIG
Message The size of return value of "<name>" exceeds the
maximum size of an object allowed on this platform
which is <size> bytes.
Description A function's return value is too large for this
platform.
User Action Reduce the size of the return value.
56.696 – RIGHTSHIFTOVR
Message <Context> the right shift count "<number>" is greater
than or equal to the size of the unpromoted operand
"<expression>".
Description The compiler has detected a right shift count that is
greater than or equal to the size of the operand to
be shifted (before application of the integral
promotions). This might not be what you intended, as
the result contains none of the original bits of the
operand. For an unsigned operand, the result is
always 0. For a signed operand, the result is either
0 or -1, depending on whether or not the operand had
a negative value. The same result would be achieved
by shifting a signed operand one fewer bits.
User Action Correct the shift count (or replace the expression by
0 if appropriate).
56.697 – RTEXCEPT
Message <Context> the floating-point constant named "<name>"
will cause an exception at runtime.
Description The IEEE trap mode of this program will cause an
exception at runtime if this floating-point constant
is used in an expression.
User Action If you do not choose to cause a runtime exception,
replace the named constant with a conventional
floating point constant. The HUGE_VAL macros defined
by <math.h> may be used in place of IEEE Infinities
with any floating-point representation.
56.698 – RTLMAPNOTFOUND
Message C RTL mapping information for RTL <name> not found.
Could not access <image_name>.
Description In most cases, the HP C compiler will automatically
map names of C standard library functions to their
corresponding names in the HP C RTL shareable image.
In many cases, this is done simply by adding a
"DECC$" prefix to the name. In order for this
mapping to work, the compiler accesses an RTL mapping
table. This message is issued if the compiler was
unable to open the mapping table. In these cases, no
name mapping will be performed. The most common
cause of this message is specifying bad name in the
/PREFIX=RTL="name" compiler qualifier.
User Action Specify a valid RTL on the /PREFIX=RTL qualifier. If
no qualifier was used, it might be necessary to
reinstall the compiler and/or RTL. For more
information consult the HP C Run-time Library Manual
for OpenVMS Systems.
56.699 – RTLMISMATCH
Message HP C RTL prefix table version mismatch: RTL table is
V<major>.<minor>, compiler needs V<major>.<minor>.
Description In most cases, the HP C compiler will automatically
map names of C standard library functions to their
corresponding names in the HP C RTL shareable image.
In many cases, this is done simpl by adding a "DECC$"
prefix to the name. In order for this mapping to
work, the compiler accesses an RTL mapping table.
The compiler also requires that the version of the
RTL mapping table be compatible with the version of
the compiler. In cases where the versions are
incompatible, this message is generated. In these
cases, no name mapping will be performed. The most
common cause of this message is specifying an old RTL
name in the /PREFIX=RTL="name" compiler qualifier.
User Action Specify a new RTL on the /PREFIX=RTL qualifier. If
no qualifier was used, it might be necessary to
reinstall the compiler and/or RTL. For more
information, consult the HP C Run-time Library Manual
for OpenVMS Systems.
56.700 – SAMEASTYPEDEF
Message <Context> the extern has the same name as a
file-scope typedef. This is a language extension.
Description The program has declared an extern inside a function
whose name matches a file-scope typedef. This is not
allowed by the C standard, but is accepted for
compatibility with other C compilers.
User Action Change the name of the variable or the typedef.
56.701 – SCACALL
Message This function contains too many parameters for SCA to
handle. Function parameter info will be truncated.
Description The parameter information for this function contains
more data than SCA can process. The compiler will
truncate the parameter information. Be aware that
the parameter information will be incomplete.
User Action Simplify the parameter information.
56.702 – SCAID2LONG
Message The identifier exceeds the SCA limit of <number>
characters. In the SCA file the name will be
truncated to "<truncated spelling>".
Description The length of an identifier supported by SCA is less
than the length of an identifier supported by the HP
C compiler. Because of this, the compiler will
truncate an identifier name to fit the SCA limits.
User Action Either reduce the identifier name, or be aware of
this when using SCA.
56.703 – SCALEFACTOR
Message The CDD description for <name> specifies a scale
factor of <number>. The scale factor is being
ignored.
Description HP C does not support scaled arithmetic.
User Action Verify that all computations involving this item are
correctly scaled.
56.704 – SCAOVFLO
Message Compiler Internal Error: SCA event buffer
overflowed. Please submit a problem report.
Description When building SCA information, the compiler
overflowed its internal buffer. This should not
happen.
User Action Please submit a problem report detailing the failure.
56.705 – SEQUENCEEXT
Message <Context> allowing a comma operator is a language
extension.
Description In this context the C standard does not allow the
comma (sequence) operator. HP C allows this syntax
for compatibility with some other C compilers. Be
aware that this syntax may not be accepted by other C
compilers.
User Action If the intent is to use an expression that is not
necessarily a constant expression, then enclose it in
parentheses. But if the intent of the declaration is
to use a constant expression, then the comma operator
cannot be used.
56.706 – SESEMULTIEXITS
Message parallel directive scope <text> has multiple exits
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.707 – SESEMULTIPREDS
Message parallel directive scope <text> has multiple entry
paths
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.708 – SESEVFLOW
Message parallel directive scope <text> is crossed by a
VBRANCH
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.709 – SHARECONST
Message In this declaration, noshare has been ignored due to
the presence of const or readonly.
Description A variable declared with the readonly storage class
modifier, or the const type modifier cannot also have
the noshare storage class modifier. The compiler
will ignore the noshare storage class modifier.
User Action Remove either the noshare storage class modifier or
the const or readonly modifiers.
56.710 – SHIFTCOUNT
Message <Context> the shift count "<number>" is negative or
is greater than or equal to the promoted size of the
operand "<expression>".
Description The compiler has detected a shift count that is
negative or is greater than or equal to the promoted
size of the operand to be shifted. This behavior is
undefined.
User Action Correct the shift count.
56.711 – SHORTCIRCUIT
Message <Context> potential side effects from the evaluation
of "<operand>" will not take place. This is because
the first operand of a logical operator is a constant
whose value requires that this expression must not be
evaluated.
Description The C language requires that if the first operand of
a logical || or && operator determines the result of
the expression, the second operand must not be
evaluated. This behavior is different from other
operators. The compiler has noticed that the second
operand will generate code that may produce side
effects that the programmer expects to take place.
This message is to inform the user that the code
generated for the second operand will not be
executed.
User Action Replace the logical expression with its first
operand.
56.712 – SHOWMAPLINKAGE
Message The linkage has been mapped to: #pragma linkage_ia64
<name> = (<stuff>).
Description The pragma linkage directive contains
architecture-specific information. The Alpha
register conventions are different from the IA64
register conventions. The compiler will try to map
the Alpha registers to the corresponding registers on
IA64. This message details the mapping.
User Action Replace the linkage directive with the linkage_ia64
directive that appears in the message.
56.713 – SIGNEDKNOWN
Message <Context> HP C recognizes the standard keyword
"signed". This differs from the VAX C behavior.
Description VAX C does not recognize the "signed" keyword. HP C
will allow this, even in vaxc mode.
User Action Be aware of this difference if you plan to compile
the source with VAX C.
56.714 – SIGNEDMEMBER
Message <Context> HP C recognizes the standard C keyword
"signed" in member declarations. The VAX C compiler
does not and would treat the member as unsigned.
Description VAX C does not recognize the "signed" keyword in a
member declaration. VAX C will treat the member as
an unsigned type. HP C will recognize the keyword
and declare the member as a signed type.
User Action Be aware of this difference if you plan to compile
the source with VAX C.
56.715 – SIMPLEMESSAGE
Message <user text>
Description The compiler has encountered a #pragma message
(<quoted string>)directive. It will output the
message in the quoted string.
User Action Remove the pragma message.
56.716 – SIZEBIT
Message <Context> "<expression>" is a bitfield, and so has no
size.
Description A bitfield expression cannot be used as the argument
to the sizeof operator or the __builtin_alignof
builtin.
User Action Pass an expression with a valid type to the operator
or builtin.
56.717 – SIZEINCOMP
Message <Context> "<expression>" is of an incomplete type,
and so has no size.
Description An expression that has incomplete type has no size
and therefore cannot be used as the argument to the
sizeof operator.
User Action Pass an expression with a valid type to the sizeof
operator.
56.718 – SIZEINCOMPTYP
Message <Context> "<type>" is an incomplete type, and so has
no size.
Description A incomplete type has no size and therefore cannot be
used as the argument to the sizeof operator.
User Action Pass a valid type to the sizeof operator.
56.719 – SIZFUNVOIDTYP
Message <Context> "<type>" has function or void type and may
not appear in this context. The compiler will treat
the type as if it were char.
Description A function or void type cannot be used as the
argument of the sizeof operator or the
__builtin_alignof builtin. For compatibility with
some other compilers, an output file is still
created. The result produced will be the same as if
a char type was passed. This may or may not be
compatible with other compilers that accept this
syntax.
User Action Pass a valid type to the operator or builtin.
56.720 – STACKPOP
Message This "restore" has underflowed the pragma <stack
name> stack. No corresponding "save" was found.
Description One of the pointer-size stacks, managed by the
#pragma pointer_size, #pragma require_pointer_size,
#pragma required_vptr_size, and #pragma environment
directives, contains more restores than saves. This
could signify a coding or logic error in the program.
User Action Make sure each restore has a corresponding save.
56.721 – STATICIFLOAT
Message <Context> conversion of a link-time address constant
to a floating type is required. This is not allowed.
Description The initialization of an object with static extent
requires a value that is a link-time constant
expresion. Link-time constant expressions cannot
involve values of floating types (other than floating
constants that are the immediate operands of casts).
User Action Remove the floating point types from the
initialization.
56.722 – STATICVLA
Message <Context> the static object "<name>" cannot be a
variable length array.
Description Only ordinary identifiers with block scope and
without storage class extern or static, or ordinary
identifiers with function prototype scope can be
declared as variable-length arrays.
User Action Correct the declaration.
56.723 – STATINITWARN
Message <Context> the linker will be unable to perform this
static initialization if the initializer is defined
in a sharable image.
Description A static initialization will require that a link-time
constant be truncated. If the constant is resolved
in a sharable image, the linker will issue a
diagnostic and be unable to perform the
initialization. This message is output on OpenVMS
systems only.
User Action Rewrite the static initialization so that the
link-time constant will not be truncated.
56.724 – STDARG
Message <Context> stdarg.h macros might be required if the
address of the parameter <name> is used to index
through a parameter list.
Description Some older C programs will traverse a function's
parameter list by taking the address of one of the
parameters and then adjusting it to get to subsequent
parameters. In most cases, this technique will not
produce the desired results on Alpha. This message
is specific to UNIX, and is only output if -varargs
option is specified.
User Action If the address is used to walk the parameter list,
recode the function to use the standard stdarg.h
macros.
56.725 – STKALLEXC
Message Allocations to stack exceeded maximum stack size
Description A routine uses more stack space than is available on
this platform. This is most often caused by
declaring too many large automatic variables.
User Action Reduce the size required by the automatic variables.
56.726 – STOALNERR
Message Psect <text> alignment is insufficient for allocation
of <text>
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.727 – STONOTFIRST
Message The placement of a storage-class specifier other than
at the beginning of the declaration specifiers in a
declaration is an obsolescent feature.
Description The standard states that this style of declaration is
obsolescent.
User Action Place the storage-class specifier first in the
declaration.
56.728 – STORCLSDCL
Message <Context> a storage class without a declarator is
meaningless.
Description This message is generated when the compiler
encounters certain declarations that contain a
storage class but no declarator. For example:
extern struct S { int a;};
User Action Either remove the storage class or add a declarator
to the declaration.
56.729 – STOREBIF
Message Built-in function <store-bif> is not available on
this platform. It may be converted to <swap-bif> if
the source and dest parameters are identical.
Description The STORE version of this built-in function is not
available on the IA64 platform.
User Action Use the SWAP version of this built-in function.
56.730 – STOREQEXC
Message Allocations to <text> section exceeded growth bounds
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.731 – STORISSTAT
Message This redeclaration of the static initialized variable
"<name>" will have static storage class that differs
from the VAX C behavior. The previous declaration is
at <location>.
Description In VAX C mode, if a variable is first declared static
and then declared extern, the variable will be given
extern storage class. This matches the VAX C
behavior. If, however, the static variable is
initialized, the storage class will remain static.
User Action Be aware of this difference.
56.732 – STORMODDCL
Message <Context> a storage class modifier without a
declarator is meaningless.
Description This message is generated when the compiler
encounters certain declarations that contain a
storage class modifier but no declarator. For
example: readonly struct S { int a;};
User Action Either remove the storage class modifier or add a
declarator to the declaration.
56.733 – STRCTPADDING
Message An additional <number> bytes of padding have been
implicitly inserted prior to this member for proper
alignment of this member.
Description The compiler has added pad bytes before a member so
that it will be accessed efficiently. This might not
have been what you intended.
User Action Consider rearranging the order of member
declarations.
56.734 – STRINGCONST
Message Ill-formed string constant. Description An invalid string constant was encountered. User Action Correct the string constant.
56.735 – STRUCTBRACE
Message <Context> a required set of braces is missing.
Description The initializer for this struct was not enclosed in
braces. While some compilers allow this, standard C
requires braces around the initializer.
User Action Enclose the initializer in braces.
56.736 – STRUCTLIMITSUP
Message <Context> HP C provides only limited support for
struct/union types larger than <n> bytes.
Description This struct/union type is larger than can be
represented by size_t. While HP C will allow a type
declared to be this size, uses of the type are not
fully supported and may cause unpredictable behavior.
User Action Reduce the size of the type.
56.737 – STRUCTOVERFLOW
Message Integer overflow occurred when computing the size of
a struct or union type.
Description An struct or union type is larger than allowed on
this platform. Note that as the compiler computes
the size of the type in bits, the limit on the size
of struct/union types is eight times smaller than the
size of other types.
User Action Reduce the size of the struct/union type.
56.738 – SUBINVALIDCHR
Message Parameter substitution produced an invalid character
constant.
Description In certain modes, the compiler will replace
identifiers found within a character constant if they
match a macro argument name. This form of "old-style
stringization" is provided for compatibility with
older C compilers. This message is output if this
replacement forms an invalid character constant.
User Action Modify the macro argument so that a valid character
constant is formed.
56.739 – SUBINVALIDSTR
Message Parameter substitution produced an invalid string
literal.
Description In certain modes, the compiler will replace
identifiers found within a string literal if they
match a macro argument name. This form of "old-style
stringization" is provided for compatibility with
older C compilers. This message is output if this
replacement forms an invalid string literal.
User Action Modify the macro argument so that a valid string is
formed. HP also recommends that the macro body be
rewritten to use the standard C stringize operator
(#).
56.740 – SUBSCRBOUNDS
Message <Context> an array is being accessed outside the
bounds specified for the array type.
Description The compiler has detected an array access that is
outside the bounds of the array. The array access
might cause unpredictable behavior. Note that in C,
an array is declared using the number of elements,
but the first element has subscript 0. It is a
common coding error to attempt to access the last
element of an array of "n" elements using a subscript
of "n" instead of "n - 1". However, there are two
common practices that intentionally employ
out-of-bounds subscripts to useful/correct effects
that are not reported by this message, but have
separate optional messages. First, taking the
address of an array element that is exactly one
beyond the last element of an array is completely
valid in standard C as long as the address is not
used to access memory. The optional subscrbounds2
message can be enabled to report taking the address
of the array element exactly one beyond the last
element. Second, it is a somewhat common practice to
declare the last member of a struct as an array with
one element, and then allocate such structs at
runtime with different sizes, recording the actual
size in an earlier member of the struct. The
optional subscrbounds1 message can be enabled to
report subscripts greater than zero applied to arrays
declared with only one element.
User Action Specify an array subscript that is within the bounds
of the array type.
56.741 – SUBSCRBOUNDS1
Message <Context> an array type declared with one element is
being accessed beyond the end of the array.
Description An array declared with one element is being accessed
beyond the end of the array. The array access can
cause unpredictable behavior. Note that in C, an
array is declared using the number of elements, but
the first element has subscript 0. It is a common
coding error to attempt to access the last element of
an array of "n" elements using a subscript of "n"
instead of "n - 1".
User Action Specify an array subscript that is within the bounds
of the array type.
56.742 – SUBSCRBOUNDS2
Message <Context> accessing the address of an array element
that is exactly one beyond the end of the array might
not be what you intended.
Description Accessing the address of an array element that is
exactly one beyond the end of the array might be a
coding error (e.g. if the address is then used to
access memory), or it might be fully correct (e.g.
to compute a pointer value to be used as the upper
bound on a loop).
User Action Specify an array addressthat is within the bounds of
the array type.
56.743 – SWAPBIF
Message Built-in function <store-bif> is not available on
this platform. The compiler was able to convert it
to <swap-bif> because the source and dest parameters
are identical.
Description The STORE version of this built-in function is not
available on the IA64 platform.
User Action Use the SWAP version of this built-in function.
56.744 – SWITCHLONG
Message The signed or unsigned long expression "<expression>"
is used in a switch statement.
Description A switch value has an integer type of signed or
unsigned long int. While this is perfectly portable
under the C standard, the original K&R definition of
C required that the expression have type int. HP C
accepts this usage in all modes, but there may be
older C compilers that require type int in this
context.
User Action Be aware that older, non-standard compilers might not
accept this construct, or force the result to type
int.
56.745 – SYSREGUSED
Message System register specified as external register.
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.746 – SYSTEM
Message <text>
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.747 – TAGDIFFER
Message <Context> the tag "<name>" differs from the tag
"<name>" used in an earlier declaration of this
function.
Description This function declaration contains a parameter that
is a pointer to a struct or union type whose tag
differs from the tag of the struct or union type
referenced by a pointer type in an earlier
declaration of this function. In most modes of the
compiler, this will cause the function declarations
to be incompatible.
User Action Multiple declarations of a function should use
exactly the same parameter types.
56.748 – TAGORBRACE
Message Missing tag or "{".
Description The enum, struct, and union keywords must be followed
by either an open brace or a tag.
User Action Correct the program syntax.
56.749 – TENTREDEF
Message This <definition or tentative definition> of "<name>"
is redefining the <definition or tentative
definition> on <location>. This is not allowed in
C++. <compiler__declare_tent_redef1>.
Description C will allow a tentative definition to be redefined
later in the compilation unit. C++ does not have the
concept of a tentative definition. Therefore this
redefinition is invalid in C++.
User Action Either remove the previous tentative definition, or
modify it to match the later redefinition.
56.750 – TEXTARRAY
Message The CDD description for <name> specifies that it is
text 1; It has been translated into an array of char.
Description When the CDD type "TEXT" is of length one, HP C will
normally convert this to type "char" in order to be
compatible with VAX C. If however, the nullterminate
or text1toarray keywords are specified in a HP C
dictionary directive, the CDD type TEXT will be
converted to type "array of char".
User Action No action is necessary as long as the type "array of
char" is the desired datatype.
56.751 – TEXTARRAYN
Message The CDD description for <name> specified that it is
text 1; It has been translated into an array of char
because null_terminate was used.
Description The CDD type "TEXT" is of length 1 and has been
converted to the C type "array of char" of size 2
because the null_terminate keyword was specified on
the dictionary directive.
User Action No action is necessary as long as the type "array of
char" of size two is the desired C datatype.
56.752 – TEXTCHAR
Message The CDD description for <name> specified that it is
text 1; It has been translated into a type char.
Description When the CDD type "TEXT" is of length one, HP C will
normally convert this to type "char" in order to be
compatible with VAX C. However, when the length of
the CDD type "TEXT" is greater than one, the C type
"array of char" is generated. This means that CDD
type "TEXT" will result in different C datatypes
depending upon the length of the TEXT stored in the
dictionary.
User Action No action is necessary as long as the type "char" is
the desired datatype.
56.753 – TEXTMODULE
Message The text library module form of #include is an
extension.
Description On OpenVMS systems, an #include directive whose file
specifier is not enclosed in either quotation marks
or angle brackets denotes an include from a text
library. This is an extension of HP C. This
directive will not work as expected on non-VMS
systems.
User Action Be aware of this if you wish to port the program.
56.754 – THREADFUNC
Message <Context> the __declspec(thread) storage class
modifier cannot be used with a function type.
Modifier is ignored.
Description Only objects can be declared with thread-local
storage. The storage class modifier is ignored when
applied to an identifier with function type.
User Action Either remove the storage class modifier or change
the type to one that is valid for __declspec(thread).
56.755 – THREADNYI
Message <Context> the __declspec(thread) storage class
modifier is not implemented on this platform. It
will be ignored except to verify correct compile-time
usage.
Description Thread-local storage is only supported on UNIX
platforms. The compiler will ignore the storage
class modifier except to verify that it is correctly
used.
User Action Remove the __declspec(thread) storage class modifier
or compile the program on a platform that supports
the modifier.
56.756 – THREADSTO1
Message <Context> the __declspec(thread) storage class
modifier requires a storage class of extern, static,
or none. Modifier is ignored.
Description Declaring a file-scope object with thread-local
storage requires that the object have a storage class
of extern, static or none. In other cases, the
compiler will ignore the __declspec(thread) storage
class modifier.
User Action Either remove the storage class modifier or change
the storage class to one that is valid for
__declspec(thread).
56.757 – THREADSTO2
Message <Context> the __declspec(thread) storage class
modifier requires a storage class of extern, or
static. Modifier is ignored.
Description Declaring a local object with thread-local storage
requires that the object have a storage class of
extern, or static. In other cases, the compiler will
ignore the __declspec(thread) storage class modifier.
User Action Either remove the storage class modifier or change
the storage class to one that is valid for
__declspec(thread).
56.758 – TLSANDSTATIC
Message <Context> the storage class modifier
__declspec(thread) cannot be used with the -static
option. The storage class modifier is ignored.
Description Thread-local storage cannot be declared in
compilations that are performed with the -static
option. The compiler will ignore the
__declspec(thread) storage class modifier.
User Action Either remove the __declspec(thread) storage class
modifier or do not compile with the -static option.
56.759 – TOOFEWACTUALS
Message Too few actual parameters in the invocation of the
macro "<name>".
Description A macro invocation supplied fewer actual arguments
than the macro expects. The macro arguments not
specified in the call will be given a null value.
User Action Supply all arguments in the macro invocation.
56.760 – TOOFEWARGS
Message <Context> "<function expression>" expects <correct
number> arguments, but <actual number> are supplied.
Description A function has been invoked with fewer arguments than
it expects. In some modes this is a warning message,
and the compiler will compile the program. In this
case, the function being called might not produce the
expected results.
User Action Make sure the number of arguments passed to a
function match those specified in the function
declaration.
56.761 – TOOFEWARGSO
Message <Context> "<function expression>", which was declared
with an old-style function definition, expects
<correct number> arguments, but <actual number> are
supplied.
Description A function that was declared with an old-style
function definition has been invoked with fewer
arguments than it expects. While this is valid C, it
might not have been what you intended.
User Action Make sure the number of arguments passed to a
function match those specified in the function
declaration. If the function is to be called with a
variable number of arguments, it should use the
facilities of <varargs.h> for old-style definitions.
HP generally recommends that old-style function
definitions be replaced by prototype-format
definitions, in which case variable argument lists
are specified using the ... notation and the
definition uses the facilities of <stdarg.h>.
56.762 – TOOLONG
Message <Context> , "<expression>" is too long by <count>
character(s).
Description A string initializer for a char array contains more
characters than the array can hold. This is not
valid.
User Action Reduce the number of characters to be less than or
equal to the number of elements in the char array.
56.763 – TOOMANY
Message <Context> , there are <actual number> elements, which
is <extra number> too many. The extra initializers
will be ignored.
Description An initializer list contains more initializers than
there are objects to be initialized. This is not
valid.
User Action Reduce the number of initializers to be less than or
equal to the number of objects being initialized.
56.764 – TOOMANYACTLS
Message Too many actual parameters in the invocation of the
macro "<name>".
Description A macro invocation supplied more actual arguments
than the macro expects. The additional arguments
will be ignored.
User Action Remove the extra arguments from the macro invocation.
56.765 – TOOMANYARGS
Message <Context> "<function expression>" expects <correct
number> arguments, but <actual number> are supplied.
Description A function has been invoked with more arguments than
it expects. In some modes this is a warning message,
and the compiler will compile the program.
User Action Make sure the number of arguments passed to a
function match those specified in the function
declaration.
56.766 – TOOMANYARGSO
Message <Context> "<function expression>", which was declared
with an old-style function definition, expects
<correct number> arguments, but <actual number> are
supplied.
Description A function that was declared with an old-style
function definition has been invoked with more
arguments than it expects. While this is valid C, it
might not have been what you intended.
User Action Make sure the number of arguments passed to a
function match those specified in the function
declaration. If the function is to be called with a
variable number of arguments, it should use the
facilities of <varargs.h> for old-style definitions.
HP generally recommends that old-style function
definitions be replaced by prototype-format
definitions, in which case variable argument lists
are specified using the ... notation and the
definition uses the facilities of <stdarg.h>.
56.767 – TOOMANYERR
Message More than <number> errors were encountered in the
course of compilation.
Description After emitting a certain number of errors, the
compiler will stop the compilation and issue this
message. The number of errors output before the
compilation stops can be changed using the
/ERROR_LIMIT qualifier on OpenVMS systems, or the
-error_limit option on UNIX systems.
User Action Either reduce the number of errors generated by the
program or give a larger value for the error limit.
56.768 – TOOMANYGATES
Message only 64 gates maybe be used within a parallel region
Description For each parallel region there is a limit of 64
different gates that can be specified in a #pragma
enter gate/#pragma exit gate pair.
User Action Reduce the number of gates
56.769 – TOOMANYTOKENS
Message Too many tokens in macro expansion.
Description An argument to the #line preprocessing directive
contained a macro whose expansion generated more
tokens than the #line directive expects.
User Action Either modify the macro definition or change the
arguments to the #line directive.
56.770 – TOOMANYTXTLIB
Message Too many text libraries. Library <library name> and
subsequent will not be searched.
Description The compiler has tried to open more text libraries
than it can support in its internal data structures.
The specified library, and all subsequent libraries
will not be opened.
User Action Reduce the number of text libraries the compilation
requires.
56.771 – TOOMNYREL
Message Object file section <text> has <number> relocations;
maximum allowed is <number>
Description This message is emitted by the code generator. It
should never be output when compiling a C program.
User Action Please submit a problem report if you encounter this
message when compiling a C program.
56.772 – TRAILCOMMA
Message Trailing comma found in enumerator list.
Description Accepting an enumerator list that contains a trailing
comma is an extension of HP C provided for
compatibility with other C compilers. An enumerator
list with a trailing comma is not valid in C89, nor
in C++. The C99 standard does permit this syntax.
User Action Remove the trailing comma.
56.773 – TRUNCFLTASN
Message <Context> "<expression>" has more precision than
"<target type>". Assignment might result in loss of
precision and/or range.
Description The destination of a floating-point assignment has
less range and/or precision than the expression being
assigned to the destination. Because of this, the
assignment might cause a loss of range and/or
precision.
User Action Verify that no unexpected data can be lost by the
assignment. If not, cast the expression to the type
of the destination.
56.774 – TRUNCFLTINT
Message <Context> "<expression>" is a floating-point type
being assigned to an integer type. The assignment
might result in data loss.
Description A floating-point expression is being assigned to an
integer type. This assignment might cause a loss of
range and/or precision.
User Action Verify that no unexpected data can be lost by the
assignment. If not, cast the expression to the type
of the destination.
56.775 – TRUNCINTASN
Message <Context> "<expression>" has a larger data size than
"<target type>". Assignment might result in data
loss.
Description The destination of an integer or pointer assignment
is smaller than the expression being assigned to the
destination. Because of this, the assignment might
cause data to be lost.
User Action Verify that no unexpected data can be lost by the
assignment.
56.776 – TRUNCINTCAST
Message <Context> "<expression>" has a larger data size than
"<target type>". Cast might result in data loss.
Description An integer or pointer expression is being cast to a
size that is smaller than the expression. Because of
this, the cast might cause data to be lost.
User Action Verify that no unexpected data can be lost by the
cast.
56.777 – TRUNCLONGCAST
Message <Context> "<expression>", a 64-bit integer, is being
cast to a 32-bit integer. The cast might result in
data loss.
Description On many platforms long integers are the same size as
integers. On this platform long integers are
64-bits. This cast could indicate a potential
porting problem.
User Action Verify that no unexpected data can be lost by the
cast.
56.778 – TRUNCLONGINT
Message <Context> "<expression>", a 64-bit integer, is being
assigned to a 32-bit integer. Assignment might
result in data loss.
Description On many platforms long integers are the same size as
integers. On this platform long integers are
64-bits. This assignment could indicate a potential
porting problem.
User Action Verify that no unexpected data can be lost by the
assignment.
56.779 – TUNEOVERRIDE
Message tune setting <text> overridden by arch setting
<text>, tune forced to <text>
Description The program has specified a tune architecture that is
older than the arch setting. The arch setting is the
oldest architecture that the code should ever run on.
Asking the compiler to tune for an even older
architecture is not reasonable. The compiler will
use the arch setting for the tune option as well
User Action Specify a tune architecture that is at least as new
as the arch architecture.
56.780 – TYPEALIGN
Message <Context> _align cannot be used with the typedef
storage class. Modifier _align is ignored.
Description The storage class modifier _align is meaningless for
typedefs. The compiler ignores the _align.
User Action Remove the _align storage class modifier.
56.781 – TYPECONFLICT
Message <Context> "<typespec1>" cannot be combined with
"<typespec2>".
Description Two type keywords used in the same type specifier
cannot be combined. In some modes, the compiler will
use the most recent keyword as the type specifier.
User Action Correct the type specifier.
56.782 – TYPEDEFFUNC
Message In this function definition, "<name>" acquires its
type from a typedef.
Description A function definition acquires its type from a
typedef. This is not allowed.
User Action Correct the function definition.
56.783 – TYPEDEFINIT
Message The declaration of the typedef "<name>" contains an
initializer. The initializer is ignored.
Description A typedef declaration must not contain an
initializer.
User Action Remove the initializer from the declaration.
56.784 – TYPEDEFNA
Message Accepting an old-style parameter name that matches a
typedef is a language extension.
Description The HP C compiler will allow old-style parameters to
have the same name as a typedef. Many other
compilers will not allow this.
User Action Recode the function definition to use the standard C
prototype syntax.
56.785 – TYPEDEFNOTDEF
Message In this declaration, "<name>" appears to be used as
if it named a type, but there is no declared type of
that name visible.
Description The compiler has encountered what appears to be a
typedef declaration that provides a new name for an
existing type, but the identifier used to specify the
existing type is not the name of a type that is
visible.
User Action Declare the identifier for the first type, or correct
its spelling.
56.786 – TYPEEXPR
Message <Context> "<name>" is declared as <a label, tag, or
typedef>, and so cannot occur as an expression.
Description An identifier declared as a typedef has been used in
an expression when an object or function was
required.
User Action Correct the expression.
56.787 – TYPEOFEXT
Message The use of __typeof__ is a language extension.
Description Support for __typeof__ is a language extension
provided for compatibilty with some other C
compilers. Although some other C compilers will
accept this syntax, many compilers will reject it.
User Action Be aware of this difference if you plan to port this
source to another compiler.
56.788 – TYPQUALNOT
Message A type qualifier is not allowed in this context.
Description In Microsoft mode, the compiler used to accept a type
qualifier after a comma used to separate declarators.
This was refered to as a local type qualifier. This
message is output when a local type qualifier is
applied to a declarator that can not be qualified.
User Action Remove the local type qualifier because this is no
longer accepted.
56.789 – TYPQUALNOT2
Message Use of the keyword "static" or a type qualifier
within the outermost array-bounds specifier of a
formal parameter declaration is a new feature in the
C99 standard.
Description The C99 construct may not be available in other
compilers you use to build your application, in which
case they will likely report it as a syntax error.
User Action You may want to conditionalize your code with the
preprocessor so that you can take advantage of the
feature on platforms that support it, without getting
syntax errors from older compilers or language modes
that do not support it.
56.790 – TYPQUALNOT3
Message Use of the keyword "static" or a type qualifier in an
array-bounds specifier is invalid in this compilation
mode. Keyword/qualifier ignored.
Description Use of the keyword "static" or a type qualifier
within the outermost array bound specifier of a
formal parameter is a new feature in the C99 standard
and is not supported in this language mode.
User Action Either compile in a mode that supports C99 features,
or remove the construct from your code.
56.791 – TYPQUALNOT4
Message Use of this type qualifier in an array-bounds
specifier is invalid. Qualifier ignored.
Description Use of this type qualifier is not a permitted in the
array bound specifier of a formal parameter.
User Action Remove the keyword.
56.792 – UABORT
Message Compilation terminated by user.
Description This message is often output when the compilation was
aborted by the user by hitting Control C.
User Action Do not abort the compilation.
56.793 – UCNICONVOPN
Message The call iconv_open(<CODESET>, "UCS-4") failed
because: <STRERROR>. UCNs will not be mapped to the
native character set.
Description To translate Universal Character Name escape
sequences to the codeset of the current locale, the
compiler needs to call the iconv_open library routine
with the specified parameters. This call failed, for
the reason shown. Thus no UCN escape sequences in
this program can be translated.
User Action Make sure your system has the specified codeset
converter installed, or set your locale to use a
codeset for which a converter from UCS-4 is
available. Alternatively, change your code to avoid
the use of UCNs, e.g. using hexadecimal escape
sequences.
56.794 – UCNNOMAP
Message A UCN escape sequence was recognized, but there was
no translation for it into the current codeset. The
escape sequence will be used verbatim.
Description A Universal Character Name (UCN) escape sequence was
recognized, but there was no translation for it into
the current codeset using the iconv library routine.
The complete escape sequence itself, including the
backslash, will be used in the object module.
User Action Make sure your locale is set at compile-time to use a
codeset for which a converter from UCS-4 is
available, and which supports all of the characters
that are expressed as UCNs in your program.
Alternatively, change your code to avoid the use of
UCNs, e.g. using hexadecimal escape sequences.
56.795 – UCNUNSUPP
Message An apparent UCN escape sequence was encountered, but
UCNs are not supported in this language mode. The
backslash will be ignored.
Description Universal Character Name (UCN) escape sequences were
added to C in the C99 standard. The language mode of
the current compilation does not process UCNs, so
they will be treated as unrecognized escape
sequences, which ignore the backslash.
User Action Compile in a mode that processes UCNs (C99, or the
default "relaxed" mode), or remove the backslash.
Relying on apparent escape sequences to be
unrecognized is not good practice.
56.796 – UCNUSED
Message A UCN escape sequence was encountered.
Description Universal Character Name (UCN) escape sequences were
added to C in the C99 standard, and are processed in
this language mode. C compilers and dialects that do
not specifically process UCNs will treat them as
unrecognized escape sequences, and may silently
ignore the backslash.
User Action Be aware of this if you wish to port the program.
56.797 – UNALIGNEDFUNC
Message Ignoring __unaligned type qualifier in declaration of
<name>.
Description The __unaligned type qualifier has no meaning for
function types. It is being ignored.
User Action Remove the type qualifier.
56.798 – UNALIGNEXT
Message The __unaligned type qualifier is a language
extension.
Description The use of the __unaligned type qualifier might not
be portable to other C compilers.
User Action Be aware of this portability concern.
56.799 – UNAVAILPRAGMA
Message The pragma "<pragma name>" is not available on this
platform.
Description The compiler has encountered a pragma that is not
currently supported on this platform. The compiler
will ignore the pragma.
User Action Compile the program on a platform that does support
the pragma. Otherwise, understand that this pragma
will have no effect.
56.800 – UNAVOLACC
Message volatile access appears unaligned, but must be
aligned at run-time to ensure atomicity and byte
granularity
Description The compiler has detected an unaligned access to a
volatile variable. In order to meet atomicity and
granularity requirements of volatile, the access will
be done using an aligned instruction. This may cause
an alignment fault at runtime if the access is
unaligned.
User Action Make sure volatile objects are aligned on a natural
boundary.
56.801 – UNCALLED
Message routine <text> can never be called
Description The compiler has detected a static function that is
never referenced.
User Action Remove the unused function.
56.802 – UNDECLARED
Message <Context> "<name>" is not declared.
Description An identifier used in an expression has not been
declared. The only time an identifier can be used
and not previously declared is when the identifier
specifies the function name in a function call.
User Action Either declare the identifier or remove its use.
56.803 – UNDECLFUN
Message There is no function declaration for the identifier
"<name>" at the point of this #pragma <pragma type>
<attributes>.
Description An identifier specified in a #pragma assert/hint
func_attrs directive must refer to a function
declaration at the point of the pragma.
User Action Either remove the identifer from the pragma, correct
its spelling, or reorder the source to ensure that a
declaration of the identifier as a function is
visible at the point of the pragma. Identifier must
be a function declaration; no other kind of
declaration (i.e. typedef, var, etc.) is allowed for
func_attrs.
56.804 – UNDECLVAR
Message There is no global declaration visible for the
variable "<name>" at the point of this #pragma assert
global_status_variable.
Description An identifier specified in a #pragma assert directive
must refer to a global variable declaration visible
at the point of the pragma. The identifier will be
ignored.
User Action Either remove the identifer from the pragma, correct
its spelling, or reorder the source to ensure that a
declaration of the identifier as a global_variable is
visible at the point of the pragma.
56.805 – UNDEFENUM
Message <Context> the enum "<name>" is not defined.
Description The enum tag used to declare an enum variable is not
defined at this point in the compilation.
User Action Define the enum tag before using it.
56.806 – UNDEFESCAP
Message An undefined escape sequence was encountered; the
backslash is being ignored.
Description The character or characters following a backslash do
not form a valid escape sequence. The compiler will
ignore the backslash.
User Action Correct the escape sequence.
56.807 – UNDEFINEDTYPE
Message The compiler was expecting a "<token>", but one was
not found. This condition could have occured because
"<id>" is used in what might be a type cast, but
there is no declared type of that name visible.
Description The compiler has discoverd a syntax error. This
error may have been caused because a cast operator
used an unknown type.
User Action Correct the syntax error.
56.808 – UNDEFVARFETCH
Message <Context> the expression "<expr>" modifies "<var>",
and fetches its value in a computation that is not
used to produce the modified value without an
intervening sequence point. This behavior is
undefined.
Description The compiler has detected a case where the same
variable has been modified and fetched in a
computation that does not later modify that same
variable. Because the order of the variable fetch
and store is not defined, this expression might
produce different results on different platforms.
User Action Rewrite the expression so that if a variable is
stored to, it is fetched only to determine the value
to be stored.
56.809 – UNDEFVARMOD
Message <Context> the expression "<expr>" modifies the
variable "<var>" more than once without an
intervening sequence point. This behavior is
undefined.
Description The compiler has detected a case where the same
variable has been modified more than once in an
expression without a sequence point between the
modifications. Because what modification will occur
last is not defined, this expression might produce
different results on different platforms.
User Action Rewrite the expression so that each variable is
modified only once.
56.810 – UNDERFLOW
Message <Context> underflow occurs in evaluating the
expression "<expression>".
Description A floating-point underflow occurred while evaluating
a constant expression. The value of the expression
is undefined.
User Action Correct the floating-point constant expression.
56.811 – UNINIT1
Message The scalar variable "<var>"<declared in> is fetched
but not initialized<inlineinfo>. And there may be
other such fetches of this variable that have not
been reported in this compilation.
Description A variable's value has been used without being set.
This might not have been what you intended. The
algorithms that detect this situation only report it
once for a given variable, and not necessarily at the
first use of the uninitialized value.
User Action Provide the variable with a value before the variable
is used. If you only provide a value for the use
reported here, you may find that when you recompile
your program another uninitialized use is detected.
It is best to initialize variables as close as
possible to the point of declaration.
56.812 – UNINIT2
Message Part or all of the non-scalar variable
"<var>"<declared in> is fetched but not
initialized<inlineinfo>. And there may be other such
fetches of this variable that have not been reported
in this compilation.
Description A non-scalar variable has had its value used and some
or all of the variable has not been given a value.
This might not have been what you intended. The
algorithms that detect this situation only report it
once for a given variable, and not necessarily at the
first use of the uninitialized value.
User Action Provide the variable with a value before the variable
is used. If you only provide a value for the use
reported here, you may find that when you recompile
your program another uninitialized use is detected.
It is best to initialize variables as close as
possible to the point of declaration.
56.813 – UNINIT3
Message Variable "<var>"<declared in> is fetched but not
initialized<inlineinfo>. And there may be other such
fetches of this field that have not been reported in
this compilation.
Description The specified member of a struct variable has been
used without being set. This might not have been
what you intended. The algorithms that detect this
situation only report it once for a given field, and
not necessarily at the first use of the uninitialized
value.
User Action Provide the struct member with a value before the
variable is used. If you only provide a value for
the use reported here, you may find that when you
recompile your program another uninitialized use is
detected. It is best to initialize variables as
close as possible to the point of declaration.
56.814 – UNINIT4
Message Byte offsets <start> to <end> of "<var>"<declared in>
are fetched but not initialized<inlineinfo>. And
there may be other such fetches of this field that
have not been reported in this compilation.
Description The specified byte offsets of a variable have been
used without being set. This might not have been
what you intended. The algorithms that detect this
situation only report it once for a given field, and
not necessarily at the first use of the uninitialized
value.
User Action Provide the full variable with values before the
variable is used. If you only provide a value for
the use reported here, you may find that when you
recompile your program another uninitialized use is
detected. It is best to initialize variables as
close as possible to the point of declaration.
56.815 – UNINIT5
Message <fragment uninit5a><inlineinfo>. Also the variable
itself is not initialized. And there may be other
fetches of this variable that have not been reported
in this compilation.
Description The specified storage location has been used without
being set. This might not have been what you
intended. In addition, as this fetch is outside the
storage allocated to the variable, the behavior is
undefined.
User Action First verify that the fetch is correct(code that uses
the address of a declared object to access memory
outside the address range allocated to that object is
not likely to be reliable). Then initialize the
storage being fetched and, if necessary, the variable
noted in the message. If you only provide a value
for the use reported here, you may find that when you
recompile your program another uninitialized use is
detected, since the algorithms that detect this
situation only report it once for a given variable,
and not necessarily at the first use of the
uninitialized value. It is best to initialize
variables as close as possible to the point of
declaration.
56.816 – UNIONBRACE
Message <Context> a required set of braces is missing.
Description The initializer for this union was not enclosed in
braces. While some compilers allow this, standard C
requires braces around the initializer.
User Action Enclose the initializer in braces.
56.817 – UNKEXTMOD
Message Unknown extern model. Pragma is ignored.
Description The compiler was unable to parse a #pragma
extern_model directive. The extern_model must be an
identifier that specifies one of the valid extern
models. The directive will be ignored.
User Action Correct the directive.
56.818 – UNKINTRIN
Message The function "<routine name>" is not a known
intrinsic function and cannot be used with #pragma
intrinsic. Pragma not applied to this function.
Description A function identifier specified in a #pragma
intrinsic directive is not a valid intrinsic function
on this platform. The pragma will not be applied to
this identifier, leaving it to be treated as an
ordinary function.
User Action Either correct the function name to specify an
intrinsic supported for this platform, or remove it
from the pragma.
56.819 – UNKMSGCMD
Message Bad or missing command in pragma message. Pragma is
ignored.
Description The #pragma message directive must be followed by an
identifier that specifies message-related action for
the compiler to perform. Either something other than
an identifier was found, or the identifier did not
specify one of the valid actions. The compiler will
ignore the pragma.
User Action Specify a valid action for #pragma message.
56.820 – UNKMSGID
Message Unknown message id or group "<id>" is ignored.
Description A message identifier in a #pragma message directive
did not specify a valid message id or message group.
The identifier will be ignored.
User Action Update the identifier so that it specifies a valid
message id or message group.
56.821 – UNKNOWNLINK
Message The specified linkage is undefined. Pragma is
ignored.
Description The linkage specified in a #pragma use_linkage
directive has not been defined by an earlier #pragma
linkage directive. The compiler will ignore the
entire pragma.
User Action Either define the linkage first or change the linkage
name.
56.822 – UNKNOWNMACRO
Message "<name>" is not currently defined as a macro. It has
been replaced by the constant zero.
Description An identifier found in an #if or #elif is not
defined. This might not have been what you intended.
The compiler will replace the identifier with the
constant zero.
User Action Verify the use of the identifier.
56.823 – UNKNOWNPRAGMA
Message The pragma "<pragma text>" is unrecognized.
Description A pragma that has no meaning to HP C was encountered.
The pragma will be ignored.
User Action Make sure that you did not misspell the pragma.
Also, make certain you are running the correct
version of HP C. If the spelling and compiler
version are correct, understand that this pragma will
have no effect.
56.824 – UNKNOWNPRGMA
Message Unrecognized #pragma directive.
Description This #pragma preprocessing directive is not
recognized by HP C. The directive will be ignored.
User Action Make sure that this is the intended behavior.
56.825 – UNKPSECTATTR
Message Unknown psect attribute for extern model. Attribute
is ignored.
Description A psect attribute specified in a #pragma extern_model
is invalid. In general, the psect attributes
accepted by HP C match those accepted by the
assembler. The psect attribute will be ignored.
User Action Correct the psect attribute.
56.826 – UNMATCHENDIF
Message Out of place #endif directive ignored.
Description An #endif preprocessing directive was encountered
without a previous #if directive. The directive will
be ignored.
User Action Remove the directive.
56.827 – UNNAMEDMEM
Message An unnamed member does not have a bitfield, struct,
or union type. Member is ignored.
Description An unnamed member of a struct or union type has no
meaning unless it is a bitfield or a struct/union
type. The compiler will ignore this member.
User Action If the member is desired, give it a name. Otherwise
remove the unnamed member.
56.828 – UNNAMEPARM
Message In the definition of the function <name>, a parameter
has no name.
Description This function declaration contained a parameter type
but no parameter name.
User Action Provide a name for the formal parameter.
56.829 – UNNECCDD
Message It is not necessary to include this dictionary
directive, if other unused dictionary directives and
unused include directives are removed.
Description There is some reference to this file from an unused
include file or from an unused dictionary directive
when using the current set of compilation options.
If you remove the unused include files and unused
dictionary directives, this dictionary directive
could also be eliminated when compiling with the
current set of compilation options.
User Action When compiling with the current set of compilation
options, to increase compilation efficiency you may
exclude this dictionary directive if you also remove
other unused files.
56.830 – UNNECINCL
Message It is not necessary to include this file, if other
unused include directives are removed.
Description There is some reference to this file from another
include file or dictionary directive that is not used
when using the current set of compilation options.
If you remove the unused include files and unused
dictionary directives, this include file could also
be eliminated when compiling with the current set of
compilation options.
User Action When compiling with the current set of compilation
options, to increase compilation efficiency you may
exclude this include file if you also remove other
unused files.
56.831 – UNREACHCODE
Message Code at or just after this location can never be
executed<inline info>.
Description The compiler has detected code that can never be
executed. Often unreachable code represents a real
coding error such as a label that is incorrectly
spelled, or a statement that was inserted on the
wrong line. But sometimes it occurs in good code as
a result of logical expressions that depend only on
the values of constants (typically through macro
expansion).
User Action Usually any code correction is obvious. And often it
is straightforward to rewrite compile-time logical
expressions in terms of preprocessing constructs to
avoid this diagnostic. But in some programs it may
be necessary to suppress this informational message
explicitly in order to obtain a diagnostic-free
compilation of production code, since rewriting the
expression not to be evaluated at compile time would
impact performance.
56.832 – UNREFADECL
Message This local identifier is declared but not referenced
in this module.
Description A declaration was found for an identifier which is
not referenced in this module
User Action Examine your code to determine if this declaration is
needed in this module.
56.833 – UNREFDECL
Message This identifier is declared but not defined or
referenced in this module.
Description A declaration was found for an identifier which is
not defined or referenced in this module
User Action Examine your code to determine if this declaration is
needed in this module.
56.834 – UNREFLABEL
Message The user label "<label>" is never referenced.
Description This user label has been defined, but there are no
references to it.
User Action Remove the label.
56.835 – UNREFSDECL
Message A static variable is declared but never referenced in
this module.
Description This identifier is defined but never referenced when
using the current set of compilation options.
User Action Examine your code to determine if this definition is
needed in this module.
56.836 – UNREFSFUNC
Message A static function definition or prototype is found,
but never referenced.
Description A static function declaration was found in this
module, but is unused when compiling with the current
settings.
User Action Examine your code to determine if this function is
needed in this module.
56.837 – UNREFTYP
Message This type is never referenced in this module.
Description A type is declared but never referenced when using
the current set of compilation options.
User Action Examine your code to determine if this declaration is
needed in this module.
56.838 – UNRLINKATTR
Message Unrecognized attribute for linkage pragma. Pragma is
ignored.
Description The compiler encountered an attribute in a #pragma
linkage directive that it did not recognize. The
message should point to the offending attribute. The
compiler will ignore the entire pragma.
User Action Correct the directive.
56.839 – UNSIGNEDPRES
Message <Context> the conversion of the unsigned char/short
value "<expression>" to unsigned int shows one
example of this program's use of unsigned-preserving
integral promotion. This differs from the
value-preserving semantics of standard C compilers.
Description This expression shows one of possibly many places
where this compilation uses unsigned-preserving
semantics for small integer promotions rather than
value-preserving semantics required of standard C
compilers. In cases where an unsigned char or
unsigned short int is promoted to an integer, there
are two different ways the convert could happen.
Standard C requires that the type be converted to a
signed int (value-preserving semantics) while some
older compilers will convert to an unsigned int
(unsigned-preserving semantics). The difference in
the choice of int or unsigned int can have an impact
on results of expressions that use the converted
value. The compiler cannot determine whether or not
a particular instance of this usage will cause an
observable behavior difference in the program. For
more information, consult Section 3.2.1.1 of the
Rationale for ANSI C.
User Action Be aware that standard compilers might interpret this
expression differently.
56.840 – UNSTRUCTMEM
Message The declaration of a member that is an unnamed struct
or union type is an extension and might not be
portable.
Description HP C allows a member of a struct or union to be an
unnamed struct or union type. This is an extension
of HP C that other compilers might not support. In
addition this behavior does not conform to the C
standard.
User Action If portability is desired, provide a name for the
struct/union member.
56.841 – UNSUPCONV
Message Hexadecimal floating point constants are not yet
implemented.
Description Hexadecimal floating point constants are a new C99
feature that is not yet supported on this platform.
User Action Please use traditional syntax for floating point
numbers.
56.842 – UNSUPCONVSPEC
Message <Context> this argument to <function name> has a
conversion specification "<incorrect conversion>"
that is not supported or not fully supported on this
platform.
Description The compiler has detected a conversion specification
that will not work as specified on this platform.
User Action Review the documentation for this function and modify
the conversion specification as necessary to
accomplish your objective.
56.843 – UNSUPCONVV
Message Hexadecimal floating point constants are not
supported on this platform.
Description Hexadecimal floating point constants are a new
feature in C99 that is not being implemented on the
VAX platform.
User Action Please use traditional syntax for floating point
numbers.
56.844 – UNSUPIEEE
Message The _FASTMATH version of this function has been
specified, but _FASTMATH routines do not support the
IEEE behaviors requested and will simply trap and
terminate when given arguments or computing values
outside the normal range.
Description The compiler has recognized a math intrinsic function
that has a _FASTMATH version and the compilation has
defined the macro _FASTMATH, but command line options
have also specified IEEE trapping behaviors other
than the default of flushing underflow to zero and
aborting on all others.
User Action If the body of your code relies on IEEE denormals,
infinities, or nans, but is careful to condition the
arguments to math library functions to avoid passing
or computing these values, you may ignore or suppress
this warning. Otherwise, you should either remove
the options specifying non-default IEEE behavior or
else undefine the _FASTMATH macro.
56.845 – UNSUPPTYPE
Message The CDD description for <name> specifies a data type
not supported in C.
Description There is no HP C datatype to exactly represent this
type. HP C has created a declaration of the same
total size as the unsupported data type.
User Action If the type provided by the HP C compiler is not
satisfactory, change the CDD description to one that
the compiler can represent more exactly.
56.846 – UNUSEDCDD
Message This CDD record appears to be unused.
Description The contents of this CDD record are not used by the
rest of the compilation.
User Action For compilation efficiency, you can exclude this
dictionary directive when compiling with the current
set of compilation options.
56.847 – UNUSEDINCL
Message This nested include file appears to be unused.
Description The contents of this include file are not used by the
rest of the compilation.
User Action For compilation efficiency, you can exclude this
include file when compiling with the current set of
compilation options.
56.848 – UNUSEDTOP
Message This include directive does not contribute to the
compilation, perhaps because the file has already
been included.
Description The contents of this top-level include file are not
used by the rest of the compilation. This message
can occur when the include file has already been
included, perhaps by a nested include file.
User Action For compilation efficiency, you can exclude this
include file when compiling with the current set of
compilation options.
56.849 – USELESSALIGN
Message <Context> _align cannot be used with the <class>
storage class. Modifier _align is ignored.
Description The storage class modifier _align is meaningless for
objects declared with register, globalref, or
globalvalue storage class. The compiler ignores the
_align.
User Action Remove the _align storage class modifier.
56.850 – USELESSSTOMOD
Message <Context> <noshare or readonly> cannot be used with
the typedef storage class. Modifier is ignored.
Description The storage class modifiers noshare and readonly are
meaningless for typedefs. The compiler ignores the
storage class modifier.
User Action Remove the storage class modifier.
56.851 – USELESSTYPED
Message This typedef declaration is useless because it does
not declare a typedef name.
Description This typedef declaration does not declare a typedef
name. This case can occur when a declaration tries
to declare both a tag and a typedef, but the name of
the typedef is not included.
User Action Either remove the typedef keyword or add a typedef
name.
56.852 – USELESSTYPEQUAL
Message <Context> this type qualifier will have no effect.
Description A type qualifier is applied only to the declarators
in a declaration. Declarations that lack declarators
are permitted if they declare a tag or an enumeration
constant, but in such cases type qualifiers are not
useful.
User Action Remove the type qualifier, or change this to a
typedef declaration that declares a name for the type
and use that typedef name to refer to the qualified
type.
56.853 – VAARGSBODY
Message __VA_ARGS__ may not appear except in a function-like
macro that uses the ellipsis notation in the
parameters.
Description The identifier __VA_ARGS__ may only appear in the
replacement list of a function-like macro definion
that uses ellipsis notation in the parameters.
User Action Either remove __VA_ARGS__ or change its spelling.
56.854 – VAARGSFORMAL
Message __VA_ARGS__ may not be used as a formal parameter.
Description The identifier __VA_ARGS__ may only appear in the
replacement list of a function-like macro definion
that uses ellipsis notation in the parameters.
User Action Rename the formal parameter.
56.855 – VALUENOTSUP
Message <Context> the floating-point constant named "<name>"
is not supported in "<fpmode>" representation.
Description The representation of an IEEE Infinity or NaN has no
special meaning when used with non-IEEE
floating-point operations.
User Action Replace the named constant with a conventional
floating point constant. The HUGE_VAL macros defined
by <math.h> may be used in place of IEEE Infinities
with any floating-point representation.
56.856 – VALUEPRES
Message <Context> the conversion of the unsigned char/short
value "<expression>" to signed int shows one example
of this program's use of value-preserving integral
promotion. This differs from the unsigned-preserving
semantics of some older C compilers.
Description This expression shows one of possibly many places
where this compilation uses value-preserving
semantics for small integer promotions rather than
unsigned-preserving semantics used by some older
compilers. In cases where an unsigned char or
unsigned short int is promoted to an integer, there
are two different ways the convert could happen.
Standard C requires that the type be converted to a
signed int (value-preserving semantics) while some
older compilers will convert to an unsigned int
(unsigned-preserving semantics). The difference in
the choice of int or unsigned int can have an impact
on results of expressions that use the converted
value. The compiler cannot determine whether or not
a particular instance of this usage will cause an
observable behavior difference in the program. For
more information, consult Section 3.2.1.1 of the
Rationale for ANSI C.
User Action Be aware that older, non-standard compilers might
interpret this expression differently.
56.857 – VARIANTDCL
Message A declaration of a variant struct or variant union
must have a single declarator that is an identifier.
Description A variant_struct or variant_union member was either
not followed by a declarator or followed by more than
one declarator. This is not valid.
User Action Declare the variant_struct or variant_union member
with a single identifier.
56.858 – VARIANTDUP
Message The anonymous struct or union member "<member name>"
duplicates the name of a member in the enclosing
struct or union.
Description As members of an anonymous structure or union are
promoted to membership of the enclosing struct/union
type, the names of each element of the anonymous
struct/union must not match an element name in the
enclosing struct/union. This message can also be
output when the variant_struct or variant_union
syntax is used instead of the anonymous struct/union.
User Action Choose a new name for either the offending anonymous
struct/union member or the matching member of the
enclosing type.
56.859 – VARIANTEXT
Message variant struct or union is a language extension.
Description Declaring a member to be a variant_struct or
variant_union is a language extension of HP C. Other
C compilers might not successfully compile a program
that uses the extension.
User Action Consider using an anonymous struct or union (one
without a tag or declarator) instead: anonymous
structs/unions are supported by HP C and some other
vendors' C compilers.
56.860 – VARIANTTAG
Message A variant struct or union cannot have a tag.
Description A variant_struct or variant_union declaration
specified a tag name. This is not allowed.
User Action Either remove the tag or change the declaration to be
a regular struct or union instead of a variant struct
or union.
56.861 – VARNOMEM
Message A variant struct or variant union can occur only as a
member of a struct or union.
Description A declaration contained a variant_struct or
variant_union in some place other than a member of a
struct or union. This is not valid.
User Action Correct the offending declaration.
56.862 – VERTICALSPDIR
Message Vertical whitespace within pp directive.
Description Unexpected vertical white space as been encountered
within a preprocessing directive.
User Action Remove the vertical white space from the directive.
56.863 – VLAEXTENSION
Message <Context> variable length arrays are a new feature in
the C99 standard. Other C compilers may not support
this extension.
Description This is a new language feature in the C99 revision of
the standard. While having a standard specification
for portability, the feature may not yet be available
in all of the compilers you use.
User Action Determine whether or not the use of this feature will
cause portability problems for this code.
56.864 – VOIDRETURN
Message The function "<name>" has return type void, and so
must not contain a return statement with an
expression.
Description The current function was declared with a void return
type. The expression specified in the return value
will be evaluated but will not be returned to the
caller.
User Action Either change the return type in the function
declaration or remove the return value from the
return statement.
56.865 – VOIDRETURN1
Message The function "<name>" has return type void. The
return statement must not specify a return value even
if the return expression has void type.
Description The current function was declared with a void return
type. Although some C compilers allow such a
function to return a void expression, this is a
violation of the C standard and may not be portable.
User Action Modify the program so that the return statement does
not specify a return value.
56.866 – VOLATILEFUNC
Message Ignoring volatile type qualifier in declaration of
<name>.
Description The volatile type qualifier cannot be used with a
function type. The compiler will ignore the type
qualifier.
User Action Remove the type qualifier.
56.867 – WCHARCAT
Message A character string literal was concatenated with a
wide string literal.
Description The C99 standard defines the behavior of adjacent
string concatenation between character string
literals and wide string literals, basically
promoting the character string to a wide string
before forming the wide string result. The older C90
standard gave this construct undefined behavior - it
only defined concatenation between adjacent strings
of the same kind (all character or all wide).
Although this version of HP C always gives the C99
behavior with diagnostics optional, some compilers
(including previous versions of HP C) may give more
severe diagnostics and/or different behaviors.
User Action Be aware of this if you wish to port the program.
56.868 – WRTINNOWRT
Message Writable variable resides in nowrt extern model.
Description The current extern model places all external objects
in a read-only section. An object without a const
type qualifier in such a section means that while the
compiler will not diagnose writes to the object, any
attempt to modify the object at runtime will cause
the program to fail. This might not have been what
you intended.
User Action Place non-const objects in sections that can be
modified.
56.869 – XFERINTOVLA
Message This statement performs an invalid transfer into a
block that declares a variably modified type or
object. The identifier "<name>" is variably
modified, and declared at <where>.
Description It is invalid to transfer control into a block after
that block declares a variably modified type.
User Action Either remove the transfer, or move the declaration
of the variably modified type.
56.870 – XTRALARGE
Message Line number is greater than the 32767 specified by
the C standard and might not be portable.
Description A #line preprocessing directive specified a line
value that is greater than 32767. While the value is
supported by HP C, the C89 standard specifies that
the value must not be greater than 32767. Therefore,
this program does not conform to the C89 standard,
and the directive might not be accepted by other C
compilers.
User Action Be aware of this if you wish to port the program.
56.871 – ZERODIV
Message <Context> division by zero occurs in evaluating the
expression "<expression>".
Description A divide by zero occurred while evaluating a constant
expression. The value of the expression is
undefined.
User Action Correct the constant expression so that it does not
contain a division by zero.
56.872 – ZERODIVIDE
Message Division by zero in expression.
Description A divide by zero occurs in a preprocessor constant
expression. The result of the divide will be zero.
User Action Correct the preprocessor constant expression.
56.873 – ZEROELEMENTS
Message <Context> zero cannot be used as an element count
specifier. The specifier will be ignored, (leaving
the member/parameter with an incomplete array type)
in this context.
Description The C standard states that if an element count
specifier is a constant expression then it shall have
a value greater than zero. For compatibility with
some other C compilers, HP C will accept a zero
element count specifier. When appearing in a
struct/union member or a parameter, the specifier
will be ignored.
User Action Remove the zero.
56.874 – ZEROELEMENTS1
Message <Context> zero cannot be used as an element count
specifier. It will be replaced with the constant one
in this context.
Description The C standard states that if an element count
specifier is a constant expression then it shall have
a value greater than zero. For compatibility with
some other C compilers, HP C will accept a zero
element count specifier. When appearing outside a
struct/union member or a parameter, the compiler will
replace the zero with the value one. This may or may
not be compatible with the behavior of other C
compilers.
User Action Use a valid element count specifier.
57 – Language topics
VSI C language topics
57.1 – Block
A block is a compound statement. It allows more than one statement
to appear where a single statement ordinarily is used. It is made
up of a list of declarations and statements, enclosed in braces:
{ [declaration ...] [statement ...] }
The declaration list is optional; if it is included, all
declarations of variables are local to the block and supersede
previous declarations for the duration of the block. A block is
entered normally when control flows into it, or when a goto
statement transfers control to a label at the beginning of the
block. Each time the block is entered normally, storage is
allocated for auto or register variables. If, on the other hand, a
goto statement transfers control to a label inside the block or if
the block is the body of a switch statement, these storage
allocations do not occur. Blocks can be used wherever single
statements are valid -- for example, as the action clause of an if
statement:
if ( i < 1 )
{ /* BEGINNING OF BLOCK */
char x;
for (x = 'a'; x <= 'z'; x++)
printf("char = %c\n", x);
} /* END OF BLOCK */
57.2 – Valid File Specifications
In VSI C source programs, you can include both OpenVMS and UNIX*
style file specifications. Combinations of the two specifications
are not supported by VSI C.
Example of a valid UNIX* file specification:
beatle!/dba0/lennon/songs.lis.3
Example of an invalid UNIX* file specification:
BEATLE::DBA0:[LENNON.C]/songs.lis.3
----------
* UNIX is a trademark of The Open Group.
57.3 – Data Types
The data type of an object must be specified in its declaration.
The fundamental data types are the scalar types:
short int 16-bit signed integer
signed short int 16-bit signed integer
unsigned short int 16-bit unsigned integer
int 32-bit signed integer
signed int 32-bit signed integer
unsigned int 32-bit unsigned integer
long int 32-bit signed integer
signed long int 32-bit signed integer
unsigned long int 32-bit unsigned integer
long long int 64-bit signed integer
signed long long int 64-bit signed integer
unsigned long long int 64-bit unsigned integer
char 8-bit signed integer
signed char 8-bit signed integer
unsigned char 8-bit unsigned integer
wchar_t Long character (32-bit unsigned integer)
float 32-bit (single-precision) floating-point number
double 64-bit (double-precision) floating-point number
long double 128-bit (double-precision) floating-point
number
long float Interchangeable with double, but usage is
obsolete
_Bool An unsigned int that has the value 0 or 1
_Imaginary A C99-specified data type. In VSI C, use of
the _Imaginary keyword produces a warning,
which is resolved by treating it as an ordinary
identifier.
_Complex C99-specified data type available in all three
precisions: float _Complex, double _Complex,
or long double _Complex. A complex type has
the same representation and alignment
requirements as an array type containing
exactly two elements of the corresponding real
type; the first element is equal to the real
part, and the second element to the imaginary
part, of the complex number.
Note: This complex data type is similar to the
Fortran type, and has an associated header
file, <complex.h>. Although the fundamental
complex data types are implemented in the
compiler, the run-time support will not be
available until an OpenVMS Alpha release
following Version 7.3.
The signed keyword is the default. Declaring an object with int,
for example, is equivalent to declaring it with signed int.
However, char declarations should be explicitly declared, as the
compiler offers command-line options to change the default. If in
doubt, use signed char over char because signed char is more
portable.
Strings are arrays of characters terminated by the null character
(\0).
Also, view the contents of the <ints.h> header file for definitions
of platform-specific integer types.
57.3.1 – Array
An array is an aggregate of subscripted elements of the same type.
Elements of an array can have one of the fundamental data types or
can be structures, unions, or other arrays (multidimensional
arrays). An array is declared using square brackets. The
following example declares array1 to be an array of 10 integers.
The valid subscripts for array1 range from 0 to 9.
int array1[10];
The next example declares array2 to be a two-dimensional (2 by 3)
array of integers:
int array2[2][3];
The elements are stored in row-major order as follows:
array2[0][0], array2[0][1], ... array2[1][2].
57.3.2 – enum
An enumerated type is used to restrict the possible values of an
object to a predefined list. Elements of the list are called
enumeration constants.
The main use of enumerated types is to explicitly show the symbolic
names, and therefore the intended purpose, of objects that can be
represented with integer values. Objects of enumerated type are
interpreted as objects of type signed int, and are compatible with
objects of other integral types. The compiler automatically
assigns integer values to each of the enumeration constants,
beginning with 0.
An enumerated type is a set of scalar objects that have type names.
Variables are declared with enum specifiers in the place of the
type specifier. An enumerated type can have one of the following
forms:
enum { enumerator,... }
enum tag { enumerator,... }
enum tag
Each enumerator defines a constant of the enumerated type (tag).
The enumerator list forms an ordered list of the type's values.
Each enumerator has the form "identifier [= expression]", where the
"identifier" is the name to be used for the constant value and the
optional "expression" gives its integer equivalent. If a tag
appears but no list of enumerators, the enum-specifier refers to a
previous definition of the enumerated type, identified by the tag.
The following example declares an enumerated object
'background_color' with a list of enumeration constants:
enum colors { black, red, blue, green, } background_color;
Later in the program, a value can be assigned to the object
'background_color':
background_color = red;
In this example, the compiler automatically assigns the integer
values as follows: black = 0, red = 1, blue = 2, and green = 3.
Alternatively, explicit values can be assigned during the
enumerated type definition:
enum colors { black = 5, red = 10, blue, green = black+2 };
Here, black equals the integer value 5, red = 10, blue = 11, and
green = 7. Note that blue equals the value of the previous
constant (red) plus one, and green is allowed to be out of
sequential order.
Because the ANSI C standard is not strict about assignment to
enumerated types, any assigned value not in the predefined list is
accepted without complaint.
57.3.3 – Pointer
A pointer in C is a variable that holds the address of another
variable. Pointers are declared with the asterisk operator. For
example:
int i, *ip, *np; /* i IS AN INTEGER, ip AND np ARE
POINTERS TO INTEGERS */
The following operations are permitted on pointers:
o Assigning an address to the pointer (as in ip = &i;)
o Fetching the object of the pointer (by dereferencing the
pointer) with the asterisk operator (i = *ip;, which
assigns the addressed integer to i)
o Adding (as in ip += 5;, which makes ip point to the object
that is five longwords away from the initial address in ip)
o Subtracting (as in i = np - ip;, which gives the number of
objects separating the objects pointed to by np and ip)
57.3.4 – Structure
A structure is an aggregate of members whose data types can differ.
Members can be scalar variables, arrays, structures, unions, and
pointers to any object. The size of a structure is the sum of the
sizes of its members, which are stored in the order of their
declarations. Structures are defined with the keyword struct,
followed by an optional tag, followed by a structure-declaration
list in braces. The syntax is:
struct [identifier] { struct-declaration ... }
Each struct-declaration is a type specifier (type keyword, struct
tag, union tag, enum tag, or typedef name) followed by a list of
member declarators:
type-specifier member-declarator,... ;
Each member declarator defines either an ordinary variable or a bit
field:
declarator
or
[declarator] : constant-expression
The following example declares a new structure employee with two
structure variables bob and susan of the structure type employee:
struct employee {
char *name;
int birthdate; /* name, birthdate, job_code, and salary are */
int job_code; /* treated as though declared with const. */
float salary;
};
struct employee bob, susan;
57.3.5 – typedef
Use the typedef keyword to define an abbreviated name, or
synonym, for a lengthy type definition. Grammatically,
typedef is a storage-class specifier, so it can precede any valid
declaration. In such a declaration, the identifiers name types
instead of variables. For example:
typedef char CH, *CP, STRING[10], CF();
In the scope of this declaration, CH is a synonym for "character,"
CP for "pointer to character," STRING for "10-element array of
characters," and CF for "function returning a character." Each of
the type definitions can be used in that scope to declare
variables. For example:
CF c; /* c IS A FUNCTION RETURNING A CHARACTER */
STRING s; /* s IS A 10-CHARACTER STRING */
57.3.6 – Union
A union is an aggregate of members whose data types can differ.
Members can be scalar variables, arrays, structures, unions, and
pointers to any object. The size of a union is the size of its
longest member plus any padding needed to meet alignment
requirements. All its members occupy the same storage. Unions are
defined with the union keyword, followed by an optional tag,
followed by a union-declaration list in braces. The syntax is:
union [identifier] { union-declaration ... }
Each union-declaration is a type specifier (type keyword, struct
tag, union tag, enum tag, or typedef name) followed by a list of
member declarators:
type-specifier member-declarator,... ;
Each member declarator defines either an ordinary variable or a bit
field:
declarator
or
[declarator] : constant-expression
Once a union is defined, a value can be assigned to any of the
objects declared in the union declaration. For example:
union name {
dvalue;
struct x { int value1; int value2; };
float fvalue;
} alberta;
alberta.dvalue = 3.141596; /*Assigns pi to the union object*/
Here, alberta can hold a double, struct, or float value. The
programmer has responsibility for tracking the current type
contained in the union. The type is maintained until explicitly
changed. An assignment expression can be used to change the type of
value held in the union.
57.3.7 – Void
You can use the void data type to declare functions that do not return a value. Functions declared to be of this type cannot contain return statements and cannot be used in statements where a return value is expected. The void data type can be used in the cast operation if casting to a "function without a return value ...". You can also use the void data type with pointers.
57.4 – Declarations
Declarations specify the functions and variables referenced in a
program. Declarations in C have the following syntax:
declaration:
declaration-specifiers [init-declarator-list];
declaration-specifiers:
storage-class-specifier [declaration-specifiers]
type-specifier [declaration-specifiers]
type-qualifier [declaration-specifiers]
init-declarator-list:
init-declarator
init-declarator-list, init-declarator
init-declarator:
declarator
declarator = initializer
Note the following items about the general syntax of a declaration:
o The storage-class-specifier, type-qualifier, and type-specifier
can be listed in any order. All are optional, but, except for
function declarations, at least one such specifier or qualifier
must be present. Placing the storage-class-specifier anywhere
but at the beginning of the declaration is an obsolete style.
o Storage-class keywords are auto, static, extern, and register.
o Type qualifiers are const, volatile, __restrict, and
__unaligned.
o The declarator is the name of the object being declared. A
declarator can be as simple as a single identifier, or can be a
complex construction declaring an array, structure, pointer,
union, or function (such as *x, tree(), and treebar[10]).
o Initializers are optional and provide the initial value of an
object. An initializer can be a single value or a
brace-enclosed list of values, depending on the type of object
being declared.
o A declaration determines the beginning of an identifier's
scope.
o An identifier's linkage is determined by the declaration's
placement and its specified storage class.
Consider the following example:
volatile static int var_number = 10;
This declaration shows a qualified type (a type, int, with a type
qualifier, volatile), a storage class (static), a declarator (data),
and an initializer (10). This declaration is also a definition,
because storage is reserved for the data object var_number.
For more information, see HELP CC LANGUAGE_TOPICS DATA_TYPES, HELP
CC LANGUAGE_TOPICS STORAGE_CLASSES, and HELP CC LANGUAGE_TOPICS
TYPE_QUALIFIERS.
57.4.1 – Interpretation
The symbols used in declarations are C operators, subject to the
usual rules of precedence and associativity. These operators are
parentheses, brackets, and asterisks for "function returning...",
"array of...", and "pointer to...", respectively. Parentheses and
brackets associate left to right; asterisk operators associate
right to left. Parentheses and brackets have the same precedence,
which is higher than that of asterisks. Parentheses are also used
to change the associativity of the other operators.
The following declaration, for example, is a "function returning a
pointer to an array of pointers to char":
char * ( *x() ) [];
This is how the declaration is broken down to determine what it is:
char * ( *x() ) [];
* ( *x() ) [] is char
( *x() ) [] is (pointer to) char
*x() is (array of) (pointer to) char
x() is (pointer to) (array of) (pointer to)
char
x is (function returning) (pointer to)
(array of) (pointer to) char
In this sort of breakdown, lower precedence operators are removed
first. With two equal precedence operators, remove the rightmost
if they are left-to-right operators, and the leftmost if they are
right-to-left operators. For example, "[]()" means "array of
functions returning...".
57.5 – Functions
Functions consist of one or more blocks of statements that perform
one logical operation. They can be called from other functions
either in the same program or in different programs. A function
may exchange values with the calling function by use of parameters.
Function declarations have the following syntax:
function_name()
or
function_name(arg1, arg2,...)
or
function_name(data-type arg1, data-type arg2,...)
In the first form of the function declaration, the function takes
no arguments. In the second form, the function takes arguments;
the arguments are declared outside the parameter list. In the
third form, the function declaration is a function prototype that
specifies the type of its arguments in the identifier list; the
prototype form is recommended. In all three cases, the parenthesis
after the function name are required.
VSI C for OpenVMS Systems provides a library of common functions.
These functions perform standard I/O operations, character and
string handling, mathematical operations, miscellaneous system
services, and UNIX* system emulation. For more information, see
HELP CRTL.
----------
* UNIX is a trademark of The Open Group.
57.6 – Builtin Functions
Built-in functions allow you to directly access hardware and machine instructions to perform operations that are cumbersome, slow, or impossible in pure C. These functions are very efficient because they are built into the VSI C compiler. This means that a call to one of these functions does not result in a reference to a function in the C run-time library or in your programs. Instead, the compiler generates the machine instructions necessary to carry out the function directly at the call site. Because most of these built-in functions closely correspond to single VAX, Alpha, or Itanium machine instructions, the result is small, fast code. Some of these functions (such as those that operate on strings or bits) are of general interest. Others (such as the functions dealing with process context) are of interest if you are writing device drivers or other privileged software. Some of the functions are privileged and unavailable to user mode programs. Be sure to include the <builtins.h> header file in your source program to access these built-in functions. VSI C supports the #pragma builtins preprocessor directive for compatibility with VAX C, but it is not required. Some of the built-in functions have optional arguments or allow a particular argument to have one of many different types. To describe different valid combinations of arguments, the description of each built-in function may list several different prototypes for the function. As long as a call to a built-in function matches one of the prototypes listed, the call is valid. Furthermore, any valid call to a built-in function acts as if the corresponding prototype was in scope, so the compiler performs the argument checking and argument conversions specified by that prototype. The majority of the built-in functions are named after the machine instruction that they generate. For more information on these built-in functions, see the documentation on the corresponding machine instruction. In particular, see that reference for the structure of queue entries manipulated by the queue built-in functions.
57.6.1 – Alpha Compatibility
The VSI C built-in functions available on OpenVMS Alpha systems are
also available on I64 systems, with some differences:
o There is no support for the asm, fasm, and dasm intrinsics
(declared in the <c_asm.h> header file).
o The functionality provided by the special-case treatment of R26
on an Alpha system asm, as in asm("MOV R26,R0"), is provided by
a new built-in function for I64 systems:
__int64 __RETURN_ADDRESS(void);
o The only PAL function calls implemented as built-in functions
within the compiler are the 24 queue-manipulation builtins.
The queue manipulation builtins generate calls to new OpenVMS
system services SYS$<name>, where <name> is the name of the
builtin with the leading underscores removed.
Any other OpenVMS PAL calls are supported through macros
defined in the <pal_builtins.h> header file included in the
<builtins.h> header file. Typically, the macros in
<pal_builtins.h> transform an invocation of an Alpha system
builtin into a call to a system service that performs the
equivalent function on an I64 system. Two notable exceptions
are __PAL_GENTRAP and __PAL_BUGCHK, which instead invoke the
I64 specific compiler builtin __break2.
o There is no support for the various floating-point built-in
functions used by the OPenVMS math library (for example,
operations with chopped rounding and conversions).
o For most built-in functions that take a retry count, the
compiler issues a warning message, evaluates the count for
possible side effects, ignores it, and then invokes the same
function without a retry count. This is necessary because the
retry behavior allowed by Alpha load-locked/store-conditional
sequences does not exist on I64 systems. There are two
exceptions to this: __LOCK_LONG_RETRY and
__ACQUIRE_SEM_LONG_RETRY; in these cases, the retry behavior
involves comparisons of data values, not just
load-locked/store-conditional.
o The __CMP_STORE_LONG and __CMP_STORE_QUAD built-in functions
produce either a warning or an error, depending on whether or
not the compiler can determine if the source and destination
addresses are identical. If the addresses are identical, the
compiler treats the builtin as the new __CMP_SWAP_ form and
issues a warning. Otherwise it is an error.
57.6.2 – <builtins.h>
The <builtins.h> header file contains a section at the top
conditionalized to just __ia64 with the support for built-in
functions specific to I64 systems. This includes macro definitions
for all of the registers that can be specified to the __getReg,
__setReg, __getIndReg, and __setIndReg built-in functions.
Parameters that are const-qualified require an argument that is a
compile-time constant.
Notes:
o The <builtins.h> header file contains comments noting which
built-in functions are not available or are not the
preferred form for I64 systems. The compiler issues
diagnostics where using a different built-in function for
I64 systems would be preferable.
o The comments in <builtins.h> reflect only what is explicitly
present in that header file itself, and in the compiler
implementation. You should also consult the content and
comments in <pal_builtins.h> to determine more accurately
what functionality is effectively provided by including
<builtins.h>. For example, if a program explicitly declares
one of the Alpha built-in functions and invokes it without
having included <builtins.h>, the compiler might issue a
BIFNOTAVAIL error message, regardless of whether or not the
function is available through a system service. If the
compilation does include <builtins.h>, and BIFNOTAVAIL is
issued, then either there is no support at all for the
built-in function or a new version of <pal_builtins.h> is
needed.
57.6.3 – __break
Generates a break instruction with an immediate.
Syntax:
void __break (const int __break_arg);
57.6.4 – __break2
Implements the Alpha __PAL_GENTRAP and __PAL_BUGCHK built-in
functions on OpenVMS I64 systems.
The __break2 function is equivalent to the __break function with
the second parameter passed in general register 17:
R17 = __R17_value; __break (__break_code);
Syntax:
void __break2 (__Integer_Constant __break_code, unsigned
__int64 __r17_value);
57.6.5 – CMP SWAP LONG
Performs a conditional atomic compare and exchange operation on a
longword. The longword pointed to by source is read and compared
with the longword old_value. If they are equal, the longword
new_value is written into the longword pointed to by source. The
read and write is performed atomically, with no intervening access
to the same memory region.
The function returns 1 if the write occurs, and 0 otherwise.
Syntax:
int __CMP_SWAP_LONG (volatile void *source, int old_value, int
new_value);
57.6.6 – CMP SWAP QUAD
Performs a conditional atomic compare and exchange operation on a
quadword. The quadword pointed to by source is read and compared
with the quadword old_value. If they are equal, the quadword
new_value is written into the quadword pointed to by source. The
read and write is performed atomically, with no intervening access
to the same memory region.
The function returns 1 if the write occurs, and 0 otherwise.
Syntax:
int __CMP_SWAP_QUAD (volatile void *source, int old_value, int
new_value);
57.6.7 – CMP SWAP LONG ACQ
Performs a conditional atomic compare and exchange operation with
acquire semantics on a longword. The longword pointed to by source
is read and compared with the longword old_value. If they are
equal, the longword new_value is written into the longword pointed
to by source. The read and write is performed atomically, with no
intervening access to the same memory region.
Acquire memory ordering guarantees that the memory read/write is
made visible before all subsequent data accesses to the same memory
location by other processors.
The function returns 1 if the write occurs, and 0 otherwise.
Syntax:
int __CMP_SWAP_LONG_ACQ (volatile void *source, int old_value,
int new_value);
57.6.8 – CMP SWAP QUAD ACQ
Performs a conditional atomic compare and exchange operation with
acquire semantics on a quadword. The quadword pointed to by source
is read and compared with the quadword old_value. If they are
equal, the quadword new_value is written into the quadword pointed
to by source. The read and write is performed atomically, with no
intervening access to the same memory region.
Acquire memory ordering guarantees that the memory read/write is
made visible before all subsequent memory data accesses to the same
memory location by other processors.
The function returns 1 if the write occurs, and 0 otherwise.
Syntax:
int __CMP_SWAP_QUAD_ACQ (volatile void *source, int old_value,
int new_value);
57.6.9 – CMP SWAP LONG REL
Performs a conditional atomic compare and exchange operation with
release semantics on a longword. The longword pointed to by source
is read and compared with the longword old_value. If they are
equal, the longword new_value is written into the longword pointed
to by source. The read and write is performed atomically, with no
intervening access to the same memory region.
Release memory ordering guarantees that the memory read/write is
made visible after all previous data memory acceses to the same
memory location by other processors.
The function returns 1 if the write occurs, and 0 otherwise.
Syntax:
int __CMP_SWAP_LONG_REL (volatile void *source, int old_value,
int new_value);
57.6.10 – CMP SWAP QUAD REL
Performs a conditional atomic compare and exchange operation with
release semantics on a quadword. The quadword pointed to by source
is read and compared with the quadword old_value. If they are
equal, the quadword new_value is written into the quadword pointed
to by source. The read and write is performed atomically, with no
intervening access to the same memory region.
Release memory ordering guarantees that the memory read/write is
made visible after all previous data memory acceses to the same
memory location by other processors.
The function returns 1 if the write occurs, and 0 otherwise.
Syntax:
int __CMP_SWAP_QUAD_REL (volatile void *source, int old_value,
int new_value);
57.6.11 – RETURN ADDRESS
Produces the address to which the function containing the built-in
call will return as a 64-bit integer (on Alpha systems, the value
of R26 on entry to the function; on I64 systems, the value of B0 on
entry to the function).
This built-in function cannot be used within a function specified
to use nonstandard linkage.
Syntax:
__int64 __RETURN_ADDRESS (void);
57.6.12 – __dsrlz
Serializes data. Maps to the srlz.d instruction.
Syntax:
void __dsrlz (void);
57.6.13 – __fc
Flushes a cache line associated with the address given by the
argument. Maps to the fcr instruction.
Syntax:
void __fc (__int64 __address);
57.6.14 – __flushrs
Flushes the register stack.
Syntax:
void __flushrs (void);
57.6.15 – __fwb
Flushes the write buffers. Maps to the fwb instruction.
Syntax:
void __fwb (void);
57.6.16 – getIndReg
Returns the value of an indexed register. The function accesses a
register (index) in a register file (whichIndReg) of 64-bit
registers.
Syntax:
unsigned __int64 __getIndReg (const int whichIndReg, __int64
index);
57.6.17 – getReg
Gets the value from a hardware register based on the register index
specified. This function produces a corresponding mov = r
instruction.
Syntax:
unsigned __int64 __getReg (const int whichReg);
57.6.18 – InterlockedCompareExchange acq
Atomically compares and exchanges the value specified by the first
argument (a 64-bit pointer). This function maps to the
cmpxchg4.acq instruction with appropriate setup.
The value at *Destination is compared with the value specified by
Comparand. If they are equal, Newval is written to *Destination,
and Oldval is returned. The exchange will have taken place if the
value returned is equal to the Comparand. The following algorithm
is used:
ar.ccv = Comparand;
Oldval = *Destination; //Atomic
if (ar.ccv == *Destination) //Atomic
*Destination = Newval; //Atomic
return Oldval;
Those parts of the algorithm marked "Atomic" are performed
atomically by the cmpxchg4.acq instruction. This instruction has
acquire ordering semantics; that is, the memory read/write is made
visible prior to all subsequent data memory accesses of the
Destination by other processors.
Syntax:
unsigned __int64 _InterlockedCompareExchange_acq (volatile
unsigned int *Destination, unsigned __int64 Newval, unsigned
__int64 Comparand);
57.6.19 – InterlockedCompareExchange64 acq
Same as the _InterlockedCompareExchange_acq function, except that
those parts of the algorithm that are marked "Atomic" are performed
by the cmpxchg8.acq instruction.
Syntax:
unsigned __int64 _InterlockedCompareExchange64_acq (volatile
unsigned int64 *Destination, unsigned __int64 Newval, unsigned
__int64 Comparand);
57.6.20 – InterlockedCompareExchange rel
Same as the _InterlockedCompareExchange_acq function except that
those parts of the algorithm that are marked "Atomic" are performed
by the cmpxchg4.rel instruction with release ordering semantics;
that is, the memory read/write is made visible after all previous
memory accesses of the Destination by other processors.
Syntax:
unsigned __int64 _InterlockedCompareExchange_rel (volatile
unsigned int *Destination, unsigned __int64 Newval, unsigned
__int64 Comparand);
57.6.21 – InterlockedCompareExchange64 rel
Same as the _InterlockedCompareExchange_rel function, except that
those parts of the algorithm that are marked "Atomic" are performed
by the cmpxchg8.rel instruction.
Syntax:
unsigned __int64 _InterlockedCompareExchange64_rel (volatile
unsigned int64 *Destination, unsigned __int64 Newval, unsigned
__int64 Comparand);
57.6.22 – __invalat
Invalidates ALAT. Maps to the invala instruction.
Syntax:
void __invalat (void);
57.6.23 – __invala
Same as the __invalat function.
Syntax:
void __invala (void);
57.6.24 – __isrlz
Executes the serialize instruction. Maps to the srlz.i
instruction.
Syntax:
void __isrlz (void);
57.6.25 – __itcd
Inserts an entry into the data translation cache. Maps to the
itc.d instruction
Syntax:
void __itcd (__int64 pa);
57.6.26 – __itci
Inserts an entry into the instruction translation cache. Maps to
the itc.i instruction.
Syntax:
void __itci (__int64 pa);
57.6.27 – __itrd
Maps to the itr.d instruction.
Syntax:
void __itrd (__int64 whichTransReg, __int64 pa);
57.6.28 – __itri
Maps to the itr.i instruction.
Syntax:
void __itri (__int64 whichTransReg, __int64 pa);
57.6.29 – __loadrs
Loads the register stack.
Syntax:
void __loadrs (void);
57.6.30 – __prober
Determines whether read access to the virtual address specified by
__address bits {60:0} and the region register indexed by __address
bits {63:61} is permitted at the privilege level given by __mode
bits {1:0}. It returns 1 if the access is permitted, and 0
otherwise.
This function can probe only with equal or lower privilege levels.
If the specified privilege level is higher (lower number), then the
probe is performed with the current privilege level.
This function is the same as the Intel __probe_r function.
Syntax:
int __prober (__int64 __address, unsigned int __mode);
57.6.31 – __probew
Determines whether write access to the virtual address specified by
__address bits {60:0} and the region register indexed by __address
bits {63:61}, is permitted at the privilege level given by __mode
bits {1:0}. It returns 1 if the access is permitted, and 0
otherwise.
This function can probe only with equal or lower privilege levels.
If the specified privilege level is higher (lower number), then the
probe is performed with the current privilege level.
This function is the same as the Intel __probe_w function.
Syntax:
int __probew (__int64 __address, unsigned int __mode);
57.6.32 – __ptce
Maps to the ptc.e instruction.
Syntax:
void __ptce (__int64 va);
57.6.33 – __ptcl
Purges the local translation cache. Maps to the ptc.l r,r
instruction.
Syntax:
void __ptcl (__int64 va, __int64 pagesz);
57.6.34 – __ptcg
Purges the global translation cache. Maps to the ptc.g r,r
instruction.
Syntax:
void __ptcg (__int64 va, __int64 pagesz);
57.6.35 – __ptcga
Purges the global translation cache and ALAT. Maps to the ptc.ga
r,r instruction.
Syntax:
void __ptcga (__int64 va, __int64 pagesz);
57.6.36 – __ptri
Purges the instruction translation register. Maps to the ptr.i r,r
instruction.
Syntax:
void __ptri (__int64 va, __int64 pagesz);
57.6.37 – __ptrd
Purges the data translation register. Maps to the ptr.d r,r
instruction.
Syntax:
void __ptrd (__int64 va, __int64 pagesz);
57.6.38 – __rum
Resets the user mask.
Syntax:
void __rum (int mask);
57.6.39 – __rsm
Resets the system mask bits of the PSR. Maps to the rsm imm24
instruction.
Syntax:
void __rsm (int mask);
57.6.40 – setIndReg
Copies a value into an indexed register. The function accesses a
register (index) in a register file (whichIndReg) of 64-bit
registers.
Syntax:
void __setIndReg (const int whichIndReg, __int64 index,
unsigned __int64 value);
57.6.41 – setReg
Sets the value for a hardware register based on the register index
specified. This function produces a corresponding mov = r
instruction.
Syntax:
void __int64 __setReg (const int whichReg, unsigned __int64
value);
57.6.42 – __ssm
Sets the system mask.
Syntax:
void __ssm (int mask);
57.6.43 – __sum
Sets the user mask bits of the PSR. Maps to the sum imm24
instruction.
Syntax:
void __sum (int mask);
57.6.44 – __synci
Enables memory synchronization. Maps to the sync.i instruction.
Syntax:
void __synci (void);
57.6.45 – __tak
Returns the translation access key.
Syntax:
unsigned int __tak (__int64 __address);
57.6.46 – __tpa
Translates a virtual address to a physical address.
Syntax:
__int64 __tpa(__int64 __address);
57.6.47 – __thash
Generates a translation hash entry address. Maps to the thash r =
r instruction.
Syntax:
void __thash(__int64 __address);
57.6.48 – __ttag
Generates a translation hash entry tag. Maps to the ttag r=r
instruction.
Syntax:
void __ttag(__int64 __address);
57.7 – Variable Length Argument Lists
The set of functions and macros defined and declared in the
<varargs.h> and the <stdarg.h> header files provide a method of
accessing variable-length argument lists. (Note that the
<stdarg.h> functions are defined by the ANSI C standard and are,
therefore, portable as compared with those defined in <varargs.h>.)
The VSI C RTL functions such as printf and execl, for example, use
variable-length argument lists. User-defined functions with
variable-length argument lists that do not use <varargs.h> or
<stdarg.h> are not portable due to the different argument-passing
conventions of various machines.
To use these functions and macros in <stdarg.h>, you must include
the <stdarg.h> header file with the following preprocessor
directive:
#include <stdarg.h>
The <stdarg.h> header file declares a type (va_list) and three
macros (va_start, va_arg, and va_end) for advancing through a list
of function arguments of varying number and type. The macros have
the following syntax:
void va_start(va_list ap, parmN);
type va_arg(va_list ap, type);
void va_end(va_list ap);
The va_start macro initializes the object ap of type va_list for
subsequent use by va_arg and va_end. The va_start macro must be
invoked before any access to the unnamed arguments. The parameter
parmN is the identifier of the rightmost parameter in the variable
parameter list of the function definition. If parmN is declared
with the register storage class, with a function or array type, or
with a type that is not compatible with the type that results after
application of the default arguments promotions, the behavior is
undefined. The va_start macro returns no value.
The va_arg macro expands to an expresion that has the type and
value of the next argument in the call. The parameter ap is the
same as the one initialized by va_start. Each invocation of va_arg
modifies ap so that the values of successive arguments are returned
in turn. The parameter "type" is a type name specified such that
the type of a pointer to an object that has the specified type can
be obtained by postfixing an asterisk (*) to "type". If there is
no actual next argument, or if type is not compatible with the type
of the next actual argument (as promoted according to the default
argument promotions), the behavior is undefined. The first
invocation of va_arg after that of va_start returns the value of
the argument after that specified by parmN. Successive invocations
return the values of the remaining arguments in turn.
The va_end macro facilitates a normal return from the function
whose variable argument list was referred to by the expansion of
va_start that initialized the va_list ap object. The va_end macro
can modify ap) so that it can no longer be used (without an
intervening invocation of va_start). If there is no corresponding
invocation of va_start or if va_end is not invoked before the
return, the behavior is undefined. The va_end macro returns no
value.
57.8 – Preprocessor
The VSI C preprocessor uses directives to affect the compilation of a source file. For VSI C on OpenVMS systems, these directives are processed by an early phase of the compiler, not by a separate program. The preprocessor directives begin with a number sign (#) and do not end with a semicolon. The number sign must appear in the first column of the source line.
57.8.1 – Null directive (#)
A preprocessing directive of the form # <newline> is a null directive and has no effect.
57.8.2 – Conditional Compilation
Conditional compilation is provided by the following directives:
#if constant-expression
Checks whether the constant expression is nonzero (true).
#ifdef identifier
Checks whether the identifier is defined.
#ifndef identifier
Checks whether the identifier is undefined.
#else
Introduces source lines to be compiled as an alternative to the
conditions tested by the previous directives.
#elif constant-expression
Delimits alternative source lines to be compiled if the constant
expression in the corresponding #if, #ifdef, or #ifndef
directive is false and if the additional constant expression
presented in the #elif directive is true. An #elif directive is
optional.
#endif
Ends the scope of the previous directives.
If the condition checked by #if, #ifdef, or #ifndef is true, then
all lines between the #else, #elif, and #endif are ignored. If the
condition is false, then any lines between the conditional
directive and the #else or #elif (if any) are ignored. If there is
no #else, then the lines between the conditional and the #endif are
ignored.
57.8.3 – #define
The #define preprocessor directive has the form:
#define identifier token-string
The preprocessor substitutes the token string everywhere in the
program that it finds the identifier except within comments,
character constants, or string constants.
Macro replacements are defined in a #define directive of the
following form:
#define name([parm1[,parm2,...]]) token-string
Within the program, all macro references that have the following
form are replaced by the token string. The arguments in the macro
reference replace the corresponding parameters in the token string.
name([arg1[,arg2,...]])
57.8.4 – #dictionary
The #dictionary directive is retained for compatibility with VAX C
and is supported only when running the VSI C compiler in VAX C mode
(/STANDARD=VAXC). See also the ANSI C equivalent #pragma
dictionary directive.
The #dictionary directive extracts Common Data Dictionary (CDD)
definitions from the specified dictionary. These definitions are
then translated into VSI C and included in the program.
The #dictionary directive has the following form:
#dictionary "cdd_path"
The cdd_path is a character string that gives the path name of the
CDD record. It can also be a macro that resolves to such a
character string.
57.8.5 – #error
The #error directive issues an optional diagnostic message, and
ends compilation. This directive has the following form:
#error [message] <newline>
57.8.6 – #include
The #include directive instructs the preprocessor to insert the
contents of the specified file or module into the program. An
#include directive can have one of three forms:
#include "filespec"
#include <filespec>
#include module-name
The first two forms are ANSI-compliant methods of file inclusion
and are therefore more portable. In these forms, .h is the default
file type, unless the compiler is instructed to supply no default
type (that is, a type of just ".") by the
/ASSUME=NOHEADER_TYPE_DEFAULT qualifier.
The third form is specific to OpenVMS systems for specifying the
inclusion of a module from a text library, and is not generally
needed or recommended because the ANSI forms also cause the text
libraries to be searched.
For the order of search, see /INCLUDE_DIRECTORY.
There is no defined limit to the nesting level of #include files
and modules.
57.8.7 – #line
The #line directive applies a specified line number and optional
file specification to the next line of source text. This can be
useful for diagnostic messages. The #line directive has the
following forms:
#line integer-constant <newline>
#line integer-constant "filename" <newline>
#line pp-tokens <newline>
In the first two forms, the compiler gives the line following a
#line directive the number specified by the integer constant. The
optional filename in quotation marks indicates the name of the
source file that the compiler will provide in its diagnostic
messages. If the filename is omitted, the file name used is the
name of the current source file or the last filename specified in a
previous #line directive.
In the third form, macros in the #line directive are expanded
before it is interpreted. This allows a macro call to expand into
the integer-constant, filename, or both. The resulting #line
directive must match one of the other two forms, and is then
processed as appropriate.
57.8.8 – #module
The #module directive is retained for compatibility with VAX C and
is supported only when running the VSI C compiler in VAX C mode
(/STANDARD=VAXC). See also the ANSI C equivalent #pragma module
directive.
The #module directive passes information about an object module to
the compiler.
The #module directive can have one of the following forms:
#module identifier identifier
#module identifier string
The first argument of the directive is an VSI C identifier or macro
that resolves to an identifier. It gives the system-recognized
(for example, internally recognized by the debugger and the
librarian) name of the module; the object file name remains the
same. The second argument specifies the optional identification
that appears on listings. This may be either a VAX C identifier, a
character-string constant with no more than 31 characters, or a
macro that resolves to one of these.
There can be only one #module directive per compilation. It can
appear anywhere before the C language text.
57.8.9 – #pragma
The #pragma preprocessor directive performs compiler-specific tasks
as designated by each implementation of the C language.
All pragmas have a <pragma-name>_m version, which makes the pragma
subject to macro replacement. For example, #pragma assert is not
subject to macro expansion, but #pragma assert_m is.
All pragmas also have a <pragma-name>_nm version, which prevents
macro expansion. For example, #pragma inline is subject to macro
expansion, but #pragma inline_nm is not.
There is also a _Pragma operator (C99 Standard), which destringizes
its string literal argument, effectively allowing #pragma
directives to be produced by macro expansion. When specified using
this operator, the tokens of the pragma, which appear together
within a single string literal in this form, are not macro
expanded, even if they have an "_m" suffix. But macro expansion
can be accomplished if desired by using the stringization operator
(#) to form the string.
The _Pragma operator has the following syntax:
_Pragma ( string-literal )
VSI C for OpenVMS Systems supports the following #pragma
directives:
#pragma assert[_m|_nm]
Lets you specify assertions that the compiler can make about a
program to generate more efficient code.
The #pragma assert directive is never needed to make a program
execute correctly, however if a #pragma assert is specified,
the assertions must be valid or the program might behave
incorrectly.
Syntax:
#pragma assert func_attrs(identifier-list)function-assertions
#pragma assert global_status_variable(variable-list)
#pragma assert non_zero(constant-expression) string-literal
Descriptions follow.
The #pragma assert func_attrs directive:
The identifier-list is a list of function identifiers about
which the compiler can make assertions. If more than one
identifier is specified, separate them by commas.
The function-assertions specify the assertions for the compiler
to make about the functions. Specify one or more of the
following, separating multiple assertions with whitespace:
noreturn
The compiler can assert that any call to the routine will
never return.
nocalls_back
The compiler can assert that no routine in the source
module will be called before control is returned from this
function.
nostate
The compiler can assert that the value returned by the
function and any side-effects the function might have are
determined only by the function's arguments. If a
function is marked as having both noeffects and nostate,
the compiler can eliminate redundant calls to the
function.
noeffects
The compiler can assert that any call to this function
will have no effect except to set the return value of the
function. If the compiler determines that the return
value from a function call is never used, it can remove
the call.
file_scope_vars(option)
The compiler can make assertions about how a function will
access variables declared at file scope (with either
internal or external linkage).
The file_scope_vars option is one of the following:
o none - The function will not read nor write to any
file-scope variables except those whose type is
volatile or those listed in a #pragma assert
global_status_variable.
o noreads - The function will not read any file-scope
variables except those whose type is volatile or those
listed in a #pragma assert global_status_variable.
o nowrites - The function will not write to any
file-scope variables except those whose type is
volatile or those listed in a #pragma assert
global_status_variable.
format (<style>, <format-index>, <first-to-check-index>)
Asserts to the compiler that this function takes printf-
or scanf-style arguments to be type-checked against a
format string. Specify the parameters as follows:
o <style> -- PRINTF or SCANF.
This determines how the format string is interpreted.
o <format-index> -- {1|2|3|...}
This specifies which argument is the format-string
argument (starting from 1).
o <first-to-check-index> -- {0|1|2|...}
This is the number of the first argument to check
against the format string. For functions where the
arguments are not available to be checked (such as
vprintf), specify the third parameter as 0. In this
case, the compiler only checks the format string for
consistency.
The #pragma assert global_status_variable directive:
Use the #pragma assert global_status_variable(variable-list)
form of the pragma to specify variables that are to be
considered global status variables, which are exempt from any
assertions given to functions by #pragma assert func_attrs
file_scope_vars directives.
The variable-list is a list of variables.
The #pragma assert non_zero directive:
When the compiler encounters this directive, it evaluates the
constant-expression. If the expression is zero, the compiler
generates a message that contains both the specified
string-literal and the compile-time constant-expression. For
example:
#pragma assert non_zero(sizeof(a) == 12) "a is the wrong size"
In this example, if the compiler determines that the sizeof a
is not 12, the following diagnostic message is output:
CC-W-ASSERTFAIL, The assertion "(sizeof(a) == 12)" was not
true. a is the wrong size.
Unlike the #pragma assert options func_attrs and
global_status_variable, #pragma assert non_zero can appear
either inside or outside a function body. When used inside a
function body, the pragma can appear wherever a statement can
appear, but the pragma is not treated as a statement. When
used outside a function body, the pragma can appear anywhere a
declaration can appear, but the pragma is not treated as a
declaration.
Because macro replacement is not performed on #pragma assert,
you might need to use the #pragma assert_m directive to obtain
the results you want. Consider the following program that
verifies both the size of a struct and the offset of one of its
elements:
#include <stddef.h>
typedef struct {
int a;
int b;
} s;
#pragma assert non_zero(sizeof(s) == 8) "sizeof assert failed"
#pragma assert_m non_zero(offsetof(s,b) == 4) "offsetof assert
failed"
Because offsetof is a macro, the second pragma must be #pragma
assert_m so that offsetof will expand correctly.
#pragma builtins[_m|_nm]
Enables the VSI C built-in functions that directly access
processor instructions.
The #pragma builtins directive is provided for VAX C
compatibility.
VSI C implements #pragma builtins by including the <builtins.h>
header file, and is equivalent to #include <builtins.h> on
OpenVMS systems.
This header file contains prototype declarations for the
built-in functions that allow them to be used properly. By
contrast, VAX C implemented this pragma with special-case code
within the compiler, which also supported a #pragma nobuiltins
preprocessor directive to turn off the special processing.
Because declarations cannot be "undeclared", VSI C does not
support #pragma nobuiltins. Furthermore, the names of all the
built-in functions use a naming convention defined by ANSI C to
be in a namespace reserved to the C language implementation.
#pragma dictionary[_m|_nm]
Allows you to extract CDD data definitions and include these
definitions in your program.
The ANSI C compliant #pragma dictionary directive is equivalent
to the VAX C compatible #dictionary directive, but is supported
in all compiler modes. (The #dictionary directive is retained
for compatibility and is supported only when compiling with the
/STANDARD=VAXC qualifier.)
Syntax:
#pragma dictionary "cdd_path" [null_terminate]
[name(structure_name)] [text1_to_array | text1_to_char]
The cdd_path is a character string that gives the path name of
the CDD record. It can also be a macro that resolves to such a
character string.
The optional null_terminate keyword can be used to specify that
all string data types should be null-terminated.
The optional name() can be used to supply an alternate tag name
or a declarator, struct_name for the outer level of a CDD
structure.
The optional text1_to_char keyword forces the CDD type "text"
to be translated to char, rather than "array of char" if the
size is 1. This is the default if null_terminate is not
specified.
The optional text1_to_array keyword forces the CDD type "text"
to be translated to type "array of char" even when the size
is 1. This is the default when null_terminate is specified.
#pragma environment[_m|_nm]
Sets, saves, or restores the states of context pragmas. This
directive protects include files from contexts set by
encompassing programs, and protects encompassing programs from
contexts that could be set in header files that they include.
The #pragma environment directive affects the following
pragmas:
o #pragma extern_model
o #pragma extern_prefix
o #pragma member_alignment
o #pragma message
o #pragma names
o #pragma pointer_size
o #pragma required_pointer_size
Syntax:
#pragma environment command_line
#pragma environment header_defaults
#pragma environment restore
#pragma environment save
command_line
Sets, as specified on the command line, the states of all
the context pragmas. You can use this pragma to protect
header files from environment pragmas that take effect
before the header file is included.
header_defaults
Sets the states of all the context pragmas to their
default values. This is almost equivalent to the
situation in which a program with no command-line options
and no pragmas is compiled, except that this pragma sets
the pragma message state to #pragma nostandard, as is
appropriate for header files.
save
Saves the current state of every pragma that has an
associated context.
restore
Restores the current state of every pragma that has an
associated context.
#pragma extern_model[_m|_nm]
Controls the compiler's interpretation of objects that have
external linkage. This pragma lets you choose the global
symbol model to be used for externs.
Syntax:
#pragma extern_model common_block [attr[,attr]...]
#pragma extern_model relaxed_refdef [attr[,attr]...]
#pragma extern_model strict_refdef "name" [attr[,attr]...]
#pragma extern_model strict_refdef
#pragma extern_model globalvalue
#pragma extern_model save
#pragma extern_model restore
The default model on VSI C is #pragma relaxed_refdef noshr.
This is different from the model used by VAX C, which is common
block, shr.
The [attr[,attr]...] are optional psect attribute
specifications chosen from the following (at most one from each
line):
o gbl lcl (Not allowed with relaxed_refdef)
o shr noshr
o wrt nowrt
o pic nopic (Not meaningful for Alpha)
o ovr con
o rel abs
o exe noexe
o vec novec
o noreorder (named strict_refdef only)
o natalgn (named strict_refdef only)
o 0 byte 1 word 2 long 3 quad 4 octa 5 6 7 8 9 10 11 12 13 14
15 16 page
See the HP C User's Guide for more information on the #pragma
extern_model directive.
#pragma extern_prefix[_m|_nm]
Controls the compiler's synthesis of external names, which the
linker uses to resolve external name requests.
When you specify #pragma extern_prefix with a string argument,
the compiler prepends the string to all external names
produced by the declarations that follow the pragma
specification.
This pragma is useful for creating libraries where the
facility code can be attached to the external names in the
library.
Syntax:
#pragma extern_prefix "string" [(id[,id]...)]
#pragma extern_prefix {NOCRTL|RESTORE_CRTL} (id[,id]...)
#pragma extern_prefix save
#pragma extern_prefix restore
Where "string" prepends the quoted string to external names in
the declarations that follow the pragma specification.
You can also specify an extern prefix for specific identifiers
using the optional list [(<emphasis>(id)[,<emphasis>(id)]...)].
The NOCRTL and RESTORE_CRTL keywords control whether or not the
compiler applies its default RTL prefixing to the names
specified in the id-list, required for this form of the pragma.
The effect of NOCRTL is like that of the EXCEPT=keyword of the
/PREFIX_LIBRARY_ENTRIES command-line qualifier. The effect of
RESTORE_CRTL is to undo the effect of a #pragma extern_prefix
NOCRTL or a /PREFIX=EXCEPT= on the command line.
The save and restore keywords can be used to save the current
pragma prefix string and to restore the previously saved pragma
prefix string, respectively.
The default external prefix, when none has been specified by a
pragma, is the null string.
#pragma function[_m|_nm]
Specifies that calls to the specified functions are not
intrinsic but are, in fact, function calls. This pragma has
the opposite effect of #pragma intrinsic.
Syntax:
#pragma function[_m|_nm] (function1[, function2, ...])
#pragma include_directory[_m|_nm]
The effect of each #pragma include_directory is as if its
string argument (including the quotes) were appended to the
list of places to search that is given its initial value by the
/INCLUDE_DIRECTORY qualifier, except that an empty string is
not permitted in the pragma form.
Syntax:
#pragma include_directory <string-literal>
This pragma is intended to ease DCL command-line length
limitations when porting applications from POSIX-like
environments built with makefiles containing long lists of -I
options specifying directories to search for headers. Just as
long lists of macro definitions specified by the /DEFINE
qualifier can be converted to #define directives in a source
file, long lists of places to search specified by the
/INCLUDE_DIRECTORY qualifier can be converted to #pragma
include_directory directives in a source file.
Note that the places to search, as described in the help text
for the /INCLUDE_DIRECTORY qualifier, include the use of
POSIX-style pathnames, for example "/usr/base". This form can
be very useful when compiling code that contains POSIX-style
relative pathnames in #include directives. For example,
#include <subdir/foo.h> can be combined with a place to search
such as "/usr/base" to form "/usr/base/subdir/foo.h", which
will be translated to the filespec "USR:[BASE.SUBDIR]FOO.H"
This pragma can appear only in the main source file or in the
first file specified on the /FIRST_INCLUDE qualifier. Also, it
must appear before any #include directives.
#pragma [no]inline[_m|_nm]
Expands function calls inline. The function call is replaced
with the function code itself.
Syntax:
#pragma inline (id,...)
#pragma noinline (id,...)
If a function is named in an inline directive, calls to that
function will be expanded as inline code, if possible.
If a function is named in a noinline directive, calls to that
function will not be expanded as inline code.
If a function is named in both an inline and a noinline
directive, an error message is issued.
For calls to functions named in neither an inline nor a
noinline directive, DEC C expands the function as inline code
whenever appropriate as determined by a platform-specific
algorithm.
#pragma intrinsic[_m|_nm]
Specifies that calls to the specified functions are intrinsic
(that is, handled internally by the compiler, allowing it to
generate inline code, move or eliminate calls, or do various
other optimizations). This pragma is only valid for functions
that are known to the compiler.
Syntax:
#pragma intrinsic (function1[, function2, ...])
#pragma linkage[_m|_nm]
Specifies special linkage types for function calls. This
pragma is used with the #pragma use_linkage directive, which
associates a previously defined special linkage with a
function.
Syntax:
#pragma linkage linkage-name = (characteristics)
#pragma linkage_ia64 linkage-name = (characteristics)
On I64 systems, these two formats behave differently:
o The #pragma linkage_ia64 format requires I64 register names
be specified.
o The #pragma linkage format requires Alpha register names be
specified, which are automatically mapped, where possible,
to specific I64 registers.
The two formats are further described after the description of
the characteristics.
The characteristics specify information about where parameters
will be passed, where the results of the function are to be
received, and what registers are modified by the function call.
Specify these characteristics as a parenthesized list of items
of the following forms:
parameters (register-list)
result (simple-register-list)
preserved (simple-register-list)
nopreserve (simple-register-list)
notused (simple-register-list)
notneeded (ai, lp)
standard_linkage
You can supply the option keywords in any order.
Description of Options:
simple-register-list
A comma-separated list of register names, either Rn or Fn.
Example:
nopreserve(F5, F6)
For the #pragma linkage format, valid registers for the
preserved, nopreserve, and notused options include
general-purpose registers R0 through R30, and
floating-point registers F0 through F30.
Valid registers for the result and parameters options
include general-purpose registers R0 through R25, and
floating-point registers F0 through F30.
For the #pragma linkage_ia64 format, see below for an
explanation of register usage.
register-list
Similar to a simple-register-list except that it can
contain parenthesized sublists. Use the register-list to
describe arguments and function result types that are
structs, where each member of the struct is passed in a
single register. Example:
parameters(R5, (F5, F6))
parameters
Use this option to pass arguments to the parameters of a
routine in specific registers.
result
Use this option to specify the register to be used to
return the value for the function. If a function has a
return type of void, do not specify the result option as
part of the linkage.
preserved
A preserved register contains the same value after a call
to the function as it did before the call.
nopreserve
A nopreserve register does not necessarily contain the
same value after a call to the function as it did before
the call.
notused
A notused register is not used in any way by the called
function.
notneeded
Indicates that certain items are not needed by the
routines using this linkage. Valid options are:
AI -- Specifies that the Argument Information
register (R25) does not need to be set up when
calling the specified functions.
LP -- Specifies that the Linkage Pointer register
does not need to be set up when calling the specified
functions. Note that for I64 systems, there is no
linkage pointer, so this setting is accepted but does
not change the behavior of the pragma.
standard_linkage
Tells the compiler to use the standard linkage appropriate
to the target platform. This can be useful to confine
conditional compilation to the pragmas that define
linkages, without requiring the corresponding #pragma
use_linkage directives to be conditionally compiled as
well.
If the standard_linkage keyword is specified, it must be
the only option in the parenthesized list following the
linkage name. For example:
#pragma linkage special1 = (standard_linkage)
If the standard_linkage keyword is not specified, you can
supply the parameters, result, preserved, nopreserve, and
notused options in any order, separated by commas.
Description of the two formats of this pragma:
The #pragma linkage_ia64 format of this preprocessor directive
requires register names to be specified in terms of an OpenVMS
I64 system. The register names are never mapped to a different
architecture. This form of the pragma always produces an error
if encountered on a different architecture.
For this format of the pragma, valid registers for the
preserved, nopreserve, notused, parameters, and result options
are:
o Integer registers R3 through R12 and R19 through R31
o Floating-point registers F2 through F31
In addition, the parameters and result options also permit
integer registers R32 through R39 to be specified, according to
the following convention. On IA64, the first eight integer
input/output slots are allocated to stacked registers, and thus
the calling routine refers to them using different names than
the called routine. The convention for naming these registers
in either the parameters or result option of a #pragma
linkage_ia64 directive is always to use the hardware names as
they would be used within the called routine: R32 through R39.
The compiler automatically compensates for the fact that within
the calling routine these same registers are designated using
different hardware names.
The #pragma linkage format of this preprocessor directive
accepts Alpha register names and conventions and automatically
maps them, where possible, to specific I64 registers. So
whenever VSI C for I64 encounters a #pragma linkage directive,
it attempts to map the Alpha registers specified in the linkage
to corresponding I64 registers, and emits a SHOWMAPLINKAGE
informational message showing the I64 specific form of the
directive, #pragma linkage_ia64, with the I64 register names
that replaced the Alpha register names. The SHOWMAPLINKAGE
message is suppressed under the #pragma nostandard directive,
normally used within system header files.
Code compiled on I64 systems that deliberately relies on the
register mapping performed by #pragma linkage should either
ignore the SHOWMAPLINKAGE informational, or disable it.
The following shows the mapping that VSI C applies to the Alpha
integer register names used in #pragma linkage format
directives when they are encountered on an I64 system. Note
that the six standard parameter registers on Alpha (R16-R21)
are mapped to the first six (of eight) standard parameter
registers on I64 systems, which happen to be stacked registers:
Integer Register Mapping:
Alpha -> I64 Alpha -> I64
R0 -> R8 R16 -> R32 *
R1 -> R9 R17 -> R33 *
R2 -> R28 R18 -> R34 *
R3 -> R3 R19 -> R35 *
R4 -> R4 R20 -> R36 *
R5 -> R5 R21 -> R37 *
R6 -> R6 R22 -> R22
R7 -> R7 R23 -> R23
R8 -> R26 R24 -> R24
R9 -> R27 R25 -> R25
R10 ->R10 R26 - no mapping
R11 ->R11 R27 - no mapping
R12 ->R30 R28 - no mapping
R13 ->R31 R29 -> R29
R14 ->R20 R30 -> R12
R15 ->R21 R31 -> R0
* In parameters or result; else ignored
The following shows the mapping that VSI C applies to the Alpha
floating-point register names used in #pragma linkage
directives when they are encountered on an I64 system:
Floating-Point Register Mapping:
Alpha -> I64 Alpha -> I64
F0 -> F8 F16 -> F8
F1 -> F9 F17 -> F9
F2 -> F2 F18 -> F10
F3 -> F3 F19 -> F11
F4 -> F4 F20 -> F12
F5 -> F5 F21 -> F13
F6 -> F16 F22 -> F22
F7 -> F17 F23 -> F23
F8 -> F18 F24 -> F24
F9 -> F19 F25 -> F25
F10 ->F6 F26 - F26
F11 ->F7 F27 - F27
F12 ->F20 F28 - F28
F13 ->F21 F29 -> F29
F14 ->F14 F30 -> F30
F15 ->F15
Mapping Diagnostics:
In some cases, the HP C compiler on Alpha systems silently
ignores linkage registers if, for example, a standard parameter
register like R16 is specified in a preserved option. When you
compile on an I64 system, this situation emits an MAPREGIGNORED
informational message, and the SHOWMAPLINKAGE output might not
be correct. If there is no valid mapping to I64 registers, the
NOMAPPOSSIBLE error message is output. There are two special
situations that can arise when floating-point registers are
specified in a linkage:
o Only IEEE-format values are passed in floating-point
registers under the OpenVMS Calling Standard for I64: VAX
format values are passed in integer registers. Therefore,
a compilation that specifies /FLOAT=D_FLOAT or
/FLOAT=G_FLOAT produces an error for any linkage that
specifies floating-point registers. Note that this
includes use in options that do not involve passing values,
such as the preserved and notused options.
o The mapping of floating-point registers is many-to-one in
two cases:
- Alpha registers F0 and F16 both map to I64 register F8
- Alpha F1 and F17 both map to I64 register F9.
A valid Alpha linkage may well specify uses for both F0 and
F16, and/or both F1 and F17. Such a linkage cannot be
mapped on an I64 system. But because of the way this
situation is detected, the MULTILINKREG warning message
that is produced can only identify the second occurrence of
an Alpha register that got mapped to the same I64 register
as some previous Alpha register. The actual pair of Alpha
registers in the source is not identified, and so the
message can be confusing. For example, an option like
preserved(F1,F17) gets a MULTILINKREG diagnostic saying
that F17 was specified more than once.
#pragma [no]member_alignment[_m|_nm]
Tells the compiler to align structure members on the next
boundary appropriate to the type of the member rather than the
next byte. For example, a long variable is aligned on the next
longword boundary; a short variable on the next word boundary.
Syntax:
#pragma nomember_alignment [base_alignment]
#pragma member_alignment [save | restore]
The optional base_alignment parameter can be used with #pragma
nomember_alignment to specify the base alignment of the
structure. Use one of the following keywords to specify the
base_alignment:
o BYTE (1 byte)
o WORD (2 bytes)
o LONGWORD (4 bytes)
o QUADWORD (8 bytes)
o OCTAWORD (16 bytes)
The optional save and restore keywords can be used to save the
current state of the member_alignment and to restore the
previous state, respectively. This feature is necessary for
writing header files that require member_alignment or
nomember_alignment, or that require inclusion in a
member_alignment that is already set.
#pragma message[_m|_nm]
Controls the issuance of individual diagnostic messages or
groups of messages. Use of this pragma overrides any
command-line options that may affect the issuance of messages.
Syntax:
#pragma message option1 message-list
#pragma message option2
#pragma message (quoted-string)
where option1 is:
disable Suppresses the issuance of the indicated
messages.
Only messages of severity Warning (W) or
Information (I) can be disabled. If the
message has severity of Error (E) or
Fatal (F), it is issued regardless of
any attempt to disable it.
enable Enables the issuance of the indicated
messages.
emit_once Emits the specified messages only once
per compilation.
emit_always Emits the specified messages at every
occurrence of the condition.
error Sets the severity of each message in the
message-list to Error.
fatal Sets the severity of each message on the
message-list to Fatal.
informational Sets the severity of each message in the
message-list to Informational.
warning Sets the severity of each message in the
message-list to Warning.
The message-list can be any one of the following:
o A single message identifier (within parentheses or not).
o A single message-group name (within parentheses or not).
Message-group names are:
ALL All the messages in the compiler
ALIGNMENT Messages about unusual or inefficient
data alignment.
C_TO_CXX Messages reporting the use of C features
that would be invalid or have a
different meaning if compiled by a C++
compiler.
CDD Messages about CDD (Common Data
Dictionary) support.
CHECK Messages reporting code or practices
that, although correct and perhaps
portable, are sometimes considered
ill-advised because they can be
confusing or fragile to maintain. For
example, assignment as the test
expression in an "if" statement.
NOTE: The check group gets defined by
enabling level5 messages.
DEFUNCT Messages reporting the use of obsolete
features: ones that were commonly
accepted by early C compilers but were
subsequently removed from the language.
NEWC99 Messages reporting the use of the new
C99 Standard features.
NOANSI Messages reporting the use of non-ANSI
Standard features. The NOANSI message
group is a synonym for NOC89. Also see
message groups NEWC99, NOC89, NOc99.
NOC89 Messages reporting the use of non-C89
Standard features.
NOC99 Messages reporting the use of non-C99
Standard features.
OBSOLESCENT Messages reporting the use of features
that are valid in ANSI Standard C, but
which were identified in the standard as
being obsolescent and likely to be
removed from the language in a future
version of the standard.
OVERFLOW Messages that report assignments and/or
casts that can cause overflow or other
loss of data significance.
PERFORMANCE Messages reporting code that might
result in poor run-time performance.
PORTABLE Messages reporting the use of language
extensions or other constructs that
might not be portable to other compilers
or platforms.
PREPROCESSOR Messages reporting questionable or
non-portable use of preprocessing
constructs.
QUESTCODE Messages reporting questionable coding
practices. Similar to the check group,
but messages in this group are more
likely to indicate a programming error
rather than just a non-robust style.
Enabling the QUESTCODE group provides
lint-like checking.
RETURNCHECKS Messages related to function return
values.
UNINIT Messages related to using uninitialized
variables.
UNUSED Messages reporting expressions,
declarations, header files, CDD records,
static functions, and code paths that
are not used.
Note, however, that unlike any other
messages, these messages must be enabled
on the command line
(/WARNINGS=ENABLE=UNUSED) to be
effective.
o A single message-level name (within parentheses or not).
Note: There is a core of very important compiler messages
that are enabled by default, regardless of anything
specified with /WARNINGS or #pragma message. Referred to as
message level 0, it includes all messages issued in header
files, and comprises what is known as the nostandard group.
All other message levels add additional messages to this
core of enabled messages.
You cannot disable level 0. However, you can disable
individual messages in level 0 that are not errors or
fatals.
Message-level names are:
LEVEL1 Important messages. These are less
important than level 0, because messages
in this group are not displayed if #pragma
nostandard is active.
LEVEL2 Moderately important messages. This level
is used to introduce new messages that
will be output in the DIGITAL UNIX V4.0
release. LEVEL2 is the default for
DIGITAL UNIX and Tru64 UNIX platforms.
LEVEL3 Less important messages. In general,
these are the messages output by default
in DEC C Version 5.5 for OpenVMS Systems.
LEVEL3 is the default message level for
VSI C for OpenVMS systems.
LEVEL4 Useful check/portable messages.
LEVEL5 Not so useful check/portable messages.
LEVEL6 All messages in LEVEL5 plus additional
"noisy" messages.
Enabling a level also enables all the messages in the levels
below it. So enabling LEVEL3 messages also enables messages
in LEVEL2 and LEVEL1.
Disabling a level also disables all the messages in the
levels above it. So disabling LEVEL4 messages also disables
messages in LEVEL5 and LEVEL6.
o A comma-separated list of message identifiers, group names,
and messages levels, freely mixed, enclosed in parentheses.
option2 is:
save -- saves the current state of which messages are
enabled and disabled.
restore -- restores the previous state of which messages
are enabled and disabled.
The save and restore options are useful primarily within header
files.
The #pragma message (quoted-string) form outputs the
quoted-string as a compiler message. This form of the pragma is
subject to macro replacement. For example, the following is
valid:
#pragma message ("Compiling file " __FILE__)
#pragma module[_m|_nm]
The ANSI C compliant #pragma module directive is equivalent to
the VAX C compatible #module directive, but is supported in all
compiler modes. (The #module directive is retained for
compatibility and is supported only when compiling with the
/STANDARD=VAXC qualifier.) The #pragma module directive is
specific to VSI C for OpenVMS Systems and is not portable.
Use the #pragma module directive to change the
system-recognized module name and version number. You can find
the module name and version number in the compiler listing file
and the linker load map.
Syntax:
#pragma module identifier identifier
#pragma module identifier string
The first parameter must be a valid VSI C identifier. It
specifies the module name to be used by the linker. The second
parameter specifies the optional identification that appears on
listings and in the object file. It must be either a valid VSI
C identifier of 31 characters or less, or a character-string
constant of 31 characters or less.
Only one #pragma module directive can be processed per
compilation unit, and that directive must appear before any C
language text. The #pragma module directive can follow other
directives, such as #define, but it must precede any function
definitions or external data definitions.
#pragma names[_m|_nm]
Provides the same kinds of control over the mapping of external
identifiers' object-module symbols as does the /NAMES
command-line qualifier, and it uses the same keywords. But as
a pragma, the controls can be applied selectively to regions of
declarations.
This pragma should only be used in header files and is intended
for use by developers who supply libraries and/or header files
to their customers.
The pragma has a save/restore stack that is also managed by
#pragma environment, and so it is well-suited for use in header
files. The effect of #pragma environment header_defaults is to
set NAMES to "uppercase,truncated", which is the compiler
default.
Syntax:
#pragma names <stack-option>
#pragma names <case-option>
#pragma names <length-option>
Where
<stack-option> is one of:
o save - save the current names state
o restore - restore a saved names state
<case-option> is one of:
o uppercase - uppercase external names
o as_is - do not change case
<length-option> is one of:
o truncated - truncate at 31 characters
o shortened - shorten to 31 using CRC
#pragma optimize[_m|_nm]
Sets the optimization characteristics of function definitions
that follow the directive. It allows optimization-control
options that are normally set on the command line for the
entire compilation to be specified in the source file for
individual functions.
Syntax:
#pragma optimize <settings>
#pragma optimize save
#pragma optimize restore
#pragma optimize command_line
Where <settings> is any combination of the following:
o <level settings>
Set the optimization level. Specify as:
level=n
Where n is an integer from 0 to 5.
o <unroll settings>
Control loop unrolling. Specify as:
unroll=n
Where n is a nonnegative integer.
o <ansi-alias settings>
Control ansi-alias assumptions. Specify one of the following:
ansi_alias=on
ansi_alias=off
o <intrinsic settings>
Control recognition of intrinsics. Specify one of the
following:
intrinsics=on
intrinsics=off
Use the save, restore, and command_line keywords as follows:
o save -- Saves the current pointer size
o restore -- Restores the current pointer size to its last
saved state
o command_line -- Sets the optimization settings to what was
specified on the command line
Example:
#pragma optimize level=5 unroll=6
Usage Notes:
o If the level=0 clause is present, it must be the only
clause present.
o The #pragma optimize directive must appear at file scope,
outside any function body.
o The #pragma environment save and restore operations include
the optimization state.
o The #pragma environment command_line directive resets the
optimization state to that specified on the command line.
o If #pragma optimize does not specify a setting for one of
the optimization states, that state remains unchanged.
o When a function definition is encountered, it is compiled
using the optimization settings that are current at that
point in the source.
o When a function is compiled under level=0, the compiler
will not inline that function. In general, when functions
are inlined, the inlined code is optimized using the
optimization controls in effect at the call site instead of
using the optimization controls specified for the function
being inlined.
o When the OpenVMS command line specifies /NOOPT (or
/OPTIMIZE=LEVEL=0), the #pragma optimize directive has no
effect (except that its arguments are still validated).
#pragma pack[_m|_nm]
Specifies the byte boundary for packing members of C
structures.
Syntax:
#pragma pack [n]
The n specifies the new alignment restriction in bytes:
1 - align to byte
2 - align to word
4 - align to longword
8 - align to quadword
16 - align to octaword
A structure member is aligned to either the alignment specified
by #pragma pack or the alignment determined by the size of the
structure member, whichever is smaller. For example, a short
variable in a structure gets byte-aligned if #pragma pack 1 is
specified. If #pragma pack 2, 4, or 8 is specified, the short
variable in the structure gets aligned to word.
When #pragma pack is specified without a value or with a value
of 0, packing reverts to that specified by the
/[NO]MEMBER_ALIGNMENT qualifier setting (either explicitly
specified or by default) on the command line. Note that when
specifying #pragma pack without a value, you must use
parentheses: #pragma pack ().
#pragma pointer_size[_m|_nm]
Controls whether pointers are 32-bit pointers or 64-bit
pointers.
Syntax:
#pragma pointer_size keyword
Where keyword is one of the following:
o short -- 32-bit pointer
o long -- 64-bit pointer
o system_default -- 32-bit pointers on OpenVMS systems;
64-bit pointers on Tru64 UNIX systems
o save -- Saves the current pointer size
o restore -- Restores the current pointer size to its last
saved state
This directive is enabled only when the /POINTER_SIZE command-line
qualifier is specified. Otherwise, #pragma pointer_size has the
same effect as #pragma required_pointer_size.
#pragma required_pointer_size[_m|_nm]
Intended for use by developers of header files to control
pointer size within header files.
Syntax:
#pragma required_pointer_size keyword
Where keyword is one of the following:
o short -- 32-bit pointer
o long -- 64-bit pointer
o system_default -- 32-bit pointers on OpenVMS systems;
64-bit pointers on Tru64 UNIX systems
o save -- Saves the current pointer size
o restore -- Restores the current pointer size to its last
saved state
This directive is always enabled, even if the /POINTER_SIZE
command-line qualifier is omitted. Otherwise, #pragma
required_pointer_size has the same effect as #pragma pointer_size.
#pragma [no]standard[_m|_nm]
Directs the compiler to define regions of source code where
portability diagnostics are not to be issued.
Use #pragma nostandard to suppress diagnostics about non-ANSI C
extensions, regardless of the /STANDARD qualifier specified,
until a #pragma standard directive is encountered.
Use #pragma standard to reinstate the setting of the /STANDARD
qualifier that was in effect before before the last #pragma
nostandard was encountered.
Every #pragma standard directive must be preceded by a
corresponding #pragma nostandard directive.
Note that this pragma does not change the current mode of the
compiler or enable any extensions not already supported in that
mode.
#pragma unroll[_m|_nm]
Directs the compiler to unroll the for loop that follows it by
the number of times specified in the unroll_factor argument.
The #pragma unroll directive must be followed by a for
statement.
Syntax:
#pragma unroll (unroll_factor)
The unroll_factor is an integer constant in the range 0 to 255.
If a value of 0 is specified, the compiler ignores the
directive and determines the number of times to unroll the loop
in its normal way. A value of 1 prevents the loop from being
unrolled. The directive applies only to the for loop that
follows it, not to any subsequent for loops.
#pragma use_linkage[_m|_nm]
Associates a special linkage, defined by the #pragma linkage
directive, with the specified functions.
Syntax:
#pragma use_linkage linkage-name (routine1, routine2, ...)
The linkage-name is the name of a linkage previously defined by
the #pragma linkage directive.
The parenthesized list contains the names of functions you want
to associated with the named linkage.
The list can also contain typedef names of function type, in
which case functions or pointers to functions declared using
that type will have the specified linkage.
57.8.10 – #undef
The #undef directive cancels a previously defined macro
replacement. Any other macro replacements that occurred before the
#undef directive remain.
The #undef directive has the following syntax:
#undef identifier
57.9 – Predefined Macros
In addition to the ANSI-compliant, implementation-independent macros described in the HP C Language Reference Manual, The VSI C compiler provides the following predefined macros:
57.9.1 – System Identification Macros
Each implementation of the VSI C compiler automatically defines
macros that you can use to identify the system on which the program
is running. These macros can assist in writing code that executes
conditionally, depending on the architecture or operating system on
which the program is running.
The following table lists the traditional and new spellings of
these predefined macro names for VSI C on OpenVMS systems. Both
spellings are defined for each macro unless ANSI C mode is in
effect (/STANDARD=ANSI89), in which case only the new spellings are
defined.
Traditional spelling New spelling
vms __vms
VMS __VMS
vms_version __vms_VERSION
VMS_VERSION __VMS_VERSION
__VMS_VER
__DECC_VER
__DECCXX_VER
vaxc __vaxc
VAXC __VAXC
vax11c __vax11C
VAX11C __VAX11C
--- __DECC
--- __STDC__
__STDC_HOSTED__
__STDC_VERSION__
__STDC_ISO_10646__
__MIA
On OpenVMS I64 Systems, VSI C also supports the following
predefined system identification macro names in all compiler modes:
__ia64
__ia64__
__32BITS
__INITIAL_POINTER_SIZE
Predefined macros (with the exception of __STDC_VERSION__,
__STDC_ISO_10646__, vms_version, VMS_VERSION, __vms_version,
__VMS_VERSION, and __INITIAL_POINTER_SIZE) are defined as 1 or 0,
depending on the system you're compiling on (VAX or Alpha
processor), the compiler defaults, and the qualifiers used. For
example, if you compiled using G_floating format, then __D_FLOAT
and __IEEE_FLOAT (Alpha processors only) are predefined to be 0,
and __G_FLOAT is predefined as if the following were included
before every compilation unit:
#define __G_FLOAT 1
These macros can assist in writing code that executes
conditionally. They can be used in #elif, #if, #ifdef, and #ifndef
directives to separate portable and nonportable code in a VSI C
program. The vms_version, VMS_VERSION, __vms_version, and
__VMS_VERSION macros are defined with the value of the OpenVMS
version on which you are running (for example, Version 6.0).
The __STDC__ macro is defined to 1 for /STANDARD options ANSI89,
C99, LATEST and MIA. It is defined to 2 for /STANDARD=RELAXED and
to 0 for /STANDARD=MS. It is not defined for /STANDARD options
VAXC and COMMON.
The __STDC_HOSTED__ macro is defined to 1 for /STANDARD=c99 and
/STANDARD=LATEST. It is not defined for all other /STANDARD
keywords.
The __STDC_VERSION__ macro is defined to 199901L for /STANDARD
keywords C99, LATEST, RELAXED, MS, PORTABLE. It is defined to
199409L when the ISOC94 keyword is specified alone or with the
ANSI89, MIA, RELAXED, MS, PORTABLE, or COMMON modes. The macro is
undefined for the VAXC keyword or for keywords ANSI89, MIA, or
COMMON without ISOC94 specified.
The __STDC_ISO_10646__ macro evaluates to an integer constant of
the form yyyymmL (for example, 199712L), intended to indicate that
values of type wchar_t are the coded representations of the
characters defined by ISO/IEC 10646, along with all amendments and
technical corrigenda as of the specified year and month.
57.9.2 – Compiler Mode Macros
The following predefined macros are defined as 1 if the corresponding compiler mode is selected (Otherwise, they are undefined): __DECC_MODE_STRICT ! /STANDARD=ANSI89 __DECC_MODE_RELAXED ! /STANDARD=RELAXED __DECC_MODE_VAXC ! /STANDARD=VAXC __DECC_MODE_COMMON ! /STANDARD=COMMON __STDC__ ! /STANDARD=ANSI89, /STANDARD=RELAXED __STDC_VERSION__ ! /STANDARD=ISOC94 __MS ! /STANDARD=MS
57.9.3 – Floating Point Macros
VSI C automatically defines the following predefined macros pertaining to the format of floating-point variables. You can use them to identify the format with which you are compiling your program: __D_FLOAT __G_FLOAT __IEEE_FLOAT _IEEE_FP __X_FLOAT
57.9.4 – RTL Standards Macros
VSI C defines the following macros that you can explicitly define (using the /DEFINE qualifier or the #define preprocessor directive) to control which VSI C RTL functions are declared in header files and to obtain standards conformance checking: _XOPEN_SOURCE_EXTENDED _XOPEN_SOURCE _POSIX_C_SOURCE _ANSI_C_SOURCE _VMS_V6_SOURCE _DECC_V4_SOURCE __BSD44_CURSES __VMS_CURSES _SOCKADDR_LEN
57.9.5 – HIDE FORBIDDEN NAMES
The ANSI C standard specifies exactly what identifiers in the
normal name space are declared by the standard header files. A
compiler is not free to declare additional identifiers in a header
file unless the identifiers follow defined rules (the identifier
must begin with an underscore followed by an uppercase letter or
another underscore).
When you compile with VSI C using any values of /STANDARD that set
strict C standard conformance (ANSI89, MIA, C99, and LATEST),
versions of the standard header files are included that hide many
identifiers that do not follow the rules. The header file
<stdio.h>, for example, hides the definition of the macro TRUE.
The compiler accomplishes this by predefining the macro
__HIDE_FORBIDDEN_NAMES for the above-mentioned /STANDARD values.
You can use the command line qualifier
/UNDEFINE="__HIDE_FORBIDDEN_NAMES" to prevent the compiler from
predefining this macro, thus including macro definitions of the
forbidden names.
The header files are modified to only define additional VAX C names
if __HIDE_FORBIDDEN_NAMES is undefined. For example, <stdio.h>
might contain the following:
#ifndef __HIDE_FORBIDDEN_NAMES
#define TRUE 1
#endif
57.9.6 – CC$gfloat
When you compile using the /G_FLOAT qualifier, CC$gfloat is defined as 1. When you compile without the /G_FLOAT qualifier, CC$gfloat is defined as 0. The CC$gfloat macro is provided for compatiblity with VAX C. The __G_FLOAT predefined macro should be used instead.
57.9.7 – DATE
The __DATE__ macro evaluates to a string specifying the date on
which the compilation started. The string presents the date in the
form "Mmm dd yyyy" The names of the months are those generated by
the asctime library function. The first d is a space if dd is less
than 10.
Example:
printf("%s",__DATE__);
57.9.8 – FILE
The __FILE__ macro evaluates to a string literal specifying the
file specification of the current source file.
Example:
printf("file %s", __FILE__);
57.9.9 – LINE
The __LINE__ macro evaluates to a decimal constant specifying the
number of the line in the source file containing the macro
reference.
Example:
printf("At line %d in file %s", __LINE__, __FILE__);
57.9.10 – TIME
The __TIME__ macro evaluates to a string specifying the time that
the compilation started. The time has the following format:
hh:mm:ss
Example:
printf("%s", __TIME__);
The value of this macro remains constant throughout the translation
unit.
57.10 – Predeclared Identifiers
57.10.1 – __func__
The __func__ predeclared identifier evaluates to a static array of
char, initialized with the spelling of the function's name. It is
visible anywhere within the body of a function definition.
Example:
void foo(void) {printf("%s\n", __func__);}
This function prints "foo".
57.11 – Statements
Statements are the executable instructions performed by the program. Statements produce values and control program flow. A group of statements enclosed in braces makes up a block. Any valid expression or declaration terminated by a semicolon is considered a statement. The statements that control program flow are described in further HELP frames. See also HELP CC LANGUAGE_TOPICS DECLARATION and HELP CC LANGUAGE_TOPICS PREPROCESSOR.
57.11.1 – break
The break statement terminates the immediately enclosing while, do,
for, or switch statement. Control passes to the statement
following the terminated statement.
Syntax:
break ;
57.11.2 – continue
The continue statement passes control to the test portion of the
immediately enclosing while, do, or for statement.
Syntax:
continue ;
In each of the following statements, a continue statement is
equivalent to "goto label;":
while (expression) { statement ... label: ; }
do { statement ... label: ; } while (expression);
for (expression; expression; expression)
{ statement ... label: ; }
The continue statement is not intended for switches. A continue
statement inside a switch statement inside a loop causes
reiteration of the loop.
57.11.3 – do
The do statement executes a statement one or more times, as long as
a stated condition expression is true.
Syntax:
do statement while ( expression ) ;
The do statement is executed at least once. The expression is
evaluated after each execution of the statement. If the expression
is not 0, the statement is executed again. The statement following
the do statement (the body of the do statement) is not optional;
the null statement (a lone semicolon) is provided for specifying a
do statement with an empty body.
57.11.4 – for
The for statement executes a statement zero or more times, with
three specified control expressions. Expression-1 is evaluated
only once, before the first iteration; expression-2 is evaluated
before every iteration; expression-3 is evaluated after every
iteration. The for loop terminates if, on evaluation, expression-2
is 0.
Syntax:
for ( [expression-1] ; [expression-2] ; [expression-3] )
statement
The for statement is equivalent to the following format:
expression-1;
while ( expression-2 ) { statement expression-3; }
You can omit any of the three expressions. If expression-2 is
omitted, the while condition is true.
57.11.5 – goto
The goto statement transfers control unconditionally to a labeled
statement.
Syntax:
goto identifier ;
The identifier must be a label located in the current function.
You may use goto to branch into a block, but no initializations are
performed on variables declared in the block.
57.11.6 – if
The if statement is a conditional statement. It can be written
with or without an else clause as follows:
if ( expression ) statement
if ( expression ) statement else statement
In both cases, the expression is evaluated, and if it is not 0, the
first statement is executed. If the else clause is included and
the expression is 0, the statement following else is executed
instead. In a series of if-else clauses, the else matches the most
recent else-less if.
57.11.7 – Labeled
Any statement can be preceded by a label prefix of the following
form:
identifier:
This declares the identifier as a label. The scope of such a
declaration is the current function. Labels are used only as the
targets of goto statements.
57.11.8 – Null
A null statement is a semicolon:
;
The null statement provides a null action -- for example, the body
of a for loop that takes no action:
for(i=0; i < ARRAYSIZE && x[i] == 5; i++)
;
57.11.9 – return
The return statement causes a return from a function, with or
without a return value.
Syntax:
return ;
return expression ;
The return value is undefined if not specified in a return
statement. If an expression is specified in the return statement,
it is evaluated and the value is returned to the calling function;
the value is converted, if necessary, to the type with which the
called function was declared. If a function does not have a return
statement, the effect (on reaching the end of the function) is the
same as with a return statement that does not specify an
expression. Functions declared as void may not contain return
statements specifying an expression.
57.11.10 – switch
The switch statement executes one or more of a series of cases,
based on the value of an integer expression.
Syntax:
switch ( expression ) body
The switch's body typically is a block, within which any statement
can be prefixed with one or more case labels as follows:
case constant-expression :
At most one statement in the body may have the label as follows:
default :
The switch expression is evaluated and compared to the cases. If
there is a case matching the expression's value, it is executed; if
not, the default case is executed. The switch is normally
terminated by a break, return, or goto statement in one of the
cases. If there is no matching case and no default, the body of
the switch statement is skipped.
57.11.11 – while
The while statement executes a statement 0 or more times, as long
as a stated condition is true.
Syntax:
while ( expression ) statement
The expression is evaluated before each execution, and the
statement is executed if the expression is not 0. The statement
following the parentheses (the body of the while statement) is not
optional; the null statement (a lone semicolon) is provided for
specifying a while statement with an empty body.
57.12 – Storage Classes
The storage class of a variable determines when its storage is allocated, whether its contents are preserved across different blocks or functions, and what link-time scope the variable has. Auto variables are allocated at run time. They are not preserved across functions. Auto is the default storage class for variables declared within a function. Extern variables are allocated at compile time. They are preserved across functions. There can be only 65,532 extern variables per program. Extern is the default storage class for variables declared outside a function. Globaldef, globalref, and globalvalue variables are allocated at compile time. They are preserved across functions. The number of global symbols is unlimited. Register variables are allocated at run time. They cannot be referenced from other separately compiled functions. Static variables are allocated at compile time. If externally declared, they retain their values across functions. If internally declared (inside of a function), they cannot be referenced from other functions; if control passes from the defining function, to other functions, and then passed back to the defining function, the variable retains its previous value and is not reinitialized.
57.13 – Type Qualifiers
Data-type qualifiers affect the allocation or access of data storage. The data-type qualifiers are const, volatile, __restrict, and __unaligned.
57.13.1 – const
The const data-type qualifier restricts access to stored data. If
you declare an object to be of type const, you cannot modify that
object. You can use the const data-type qualifier with the
volatile data-type qualifier or with any of the storage-class
specifiers or modifiers. The following example declares the
variable x to be a constant integer:
int const x;
57.13.2 – volatile
The volatile data-type qualifier prevents an object from being stored in a machine register, forcing it to be allocated in memory. This data-type qualifier is useful for declaring data that is to be accessed asynchronously. A device driver application often uses volatile data storage. Like const, you can specify the volatile data-type qualifier with any of the storage-class specifiers or modifiers with the exception of the register storage class.
57.13.3 – __restrict
The __restrict data-type qualifier is used to designate a pointer as pointing to a distinct object, thus allowing compiler optimizations to be made.
57.13.4 – __unaligned
This data-type qualifier is used in pointer definitions, indicating to the compiler that the data pointed to is not properly aligned on a correct address. (To be properly aligned, the address of an object must be a multiple of the size of the type. For example, two-byte objects must be aligned on even addresses.) When data is accessed through a pointer declared __unaligned, the compiler generates the additional code necessary to copy or store the data without causing alignment errors. It is best to avoid use of misaligned data altogether, but in some cases the usage may be justified by the need to access packed structures, or by other considerations.
57.14 – Storage Class Modifiers
The storage-class modifiers allow individual attributes of a
variable to change without changing the other default attributes
connected with a given storage class. Storage-class keywords and
storage-class modifiers can be specified in either order.
Syntax:
modifier storage_class_keyword identifier;
If you specify a storage-class modifier but not a storage class
keyword, the storage class defaults to extern.
57.14.1 – noshare
Noshare variables are assigned the PSECT attribute NOSHR. Noshare
variables may not be shared between processes. This modifier is
used when linking variables that are not to be shared within a
shareable image. You can use the noshare modifier with the
storage-class keywords static, [extern], globaldef, and
globaldef{"name"}.
57.14.2 – readonly
Readonly variables are assigned the PSECT attribute NOWRT and are
stored in the PSECT $READONLY$ which is a nonwritable data area.
Other programs can access the PSECT directly, but none of the
information can be overwritten. You can use the readonly modifier
with the storage-class keywords [extern], static, globaldef, and
globaldef{"name"}.
You can use both the readonly and noshare modifiers with the
[extern] and the globaldef{"name"} specifiers. If you use both
modifiers with either the static or the globaldef specifiers, the
compiler ignores noshare and accepts readonly.
57.14.3 – _align
The _align modifier allows you to align objects of any of the VSI C
data types on a specified storage boundary. Use the _align
modifier in a data declaration or definition.
When specifying the boundary of the data alignment, you can use a
predefined constant: BYTE or byte, WORD or word, LONGWORD or
longword, QUADWORD or quadword, OCTAWORD or octaword, and PAGE or
page.
You can also specify an integer value that is a power of two. The
power of two tells VSI C the number of bytes to pad in order to
align the data:
For OpenVMS VAX systems, specify a constant 0, 1, 2, 3, 4, or 9.
For OpenVMS Alpha systems, specify any constant from 0 to 16.
57.14.4 – __align
The __align storage-class modifier has the same semantic meaning as the _align keyword. The difference is that __align is a keyword in all compiler modes while _align is a keyword only in modes that recognize VAX C keywords. For new programs, using __align is recommended.
57.14.5 – __forceinline
Similar to the __inline storage-class modifier, the __forceinline
storage-class modifier marks a function for inline expansion.
However, using __forceinline on a function definition and prototype
tells the compiler that it must substitute the code within the
function definition for every call to that function. (With
__inline, such substitution occurs at the discretion of the
compiler.)
Syntax:
__forceinline [type] function_definition
57.14.6 – __inline
The __inline modifier marks a function for inline expansion. Using
__inline on a function definition and prototype tells the compiler
that it can substitute the code within the function definition for
every call to that function. Substitution occurs at the discretion
of the compiler. The __inline storage-class specifier has the same
effect as the #pragma inline preprocessor directive, except that
the latter attempts to provide inline expansion for all functions
in a translation unit, rather than for selected functions.
Syntax:
__inline [type] function_definition
57.14.7 – inline
Similar to the __inline storage-class modifier, the inline
storage-class modifier can be used as a declaration specifier in
the declaration of a function. This modifier is supported in
relaxed ANSI C mode (/STANDARD=RELAXED) or if the
/ACCEPT=C99_KEYWORDS or /ACCEPT=GCCINLINE qualifier is specified.
With static functions, inline has the same effect as applying
__inline or #pragma inline to the function.
However, when inline is applied to a function with external
linkage, besides allowing calls within that translation unit to be
inlined, the inline semantics provide additional rules that also
allow calls to the function to be inlined in other translation
units or for the function to be called as an external function, at
the compiler's discretion:
o If the inline keyword is used on a function declaration with
external linkage, then the function must also be defined in the
same translation unit.
o If all of the file scope declarations of the function use the
inline keyword but do not use the extern keyword, then the
definition in that translation unit is called an inline
definition, and no externally-callable definition is produced
by that compilation unit.
Otherwise, the compilation unit does produce an
externally-callable definition.
o An inline definition must not contain a definition of a
modifiable object with static storage duration, and it must not
refer to an identifier with internal linkage. These
restrictions do not apply to the externally-callable
definition.
o As usual, at most one compilation unit in an entire program can
supply an externally-callable definition of a given function.
o Any call to a function with external linkage may be translated
as a call to an external function, regardless of the presence
of the inline qualifier. It follows from this and the previous
point that any function with external linkage that is called
must have exactly one externally-callable definition among all
the compilation units of an entire program.
o The address of an inline function with external linkage is
always computed as the address of the unique
externally-callable definition, never the address of an inline
definition.
o A call to inline function made through a pointer to the
externally-callable definition may still be inlined or
translated as a call to an inline definition, if the compiler
can determine the name of the function whose address was stored
in the pointer.
58 – Link libraries
The following describes how to link with the VSI C Run-Time Library
(RTL).
On I64 systems, you link to the VSI C RTL by using the C RTL
shareable image IA64$LIBRARY:DECC$SHR.EXE, which the linker
automatically finds through IMAGELIB.OLB.
Because DECC$SHR.EXE has only prefixed names (no unprefixed names),
to successfully link against it, make sure you cause prefixing to
occur for all VSI C RTL entry points. Do this by compiling in one
of two ways:
1. Compile with the /PREFIX_LIBRARY_ENTRIES=ALL_ENTRIES qualifier.
2. Compile with the /STANDARD=VAXC or /STANDARD=COMMON qualifier.
You get /PREFIX_LIBRARY_ENTRIES=ALL_ENTRIES as the default.
After making sure that all VSI C RTL entry points are prefixed,
link against the shareable image using the LINK command. For
example:
$ CC/DECC/PREFIX_LIBRARY_ENTRIES=ALL_ENTRIES PROG1
$ LINK PROG1
The linker automatically searches IMAGELIB.OLB to find
DECC$SHR.EXE, and resolves all C RTL references.
59 – Run-time functions
For help on the C run-time library (C RTL) functions supplied with
your OpenVMS operating system, enter the following:
$ HELP CRTL
Also see the HP C Run-Time Library Reference Manual for OpenVMS
Systems.
60 – Release Notes
The release notes for VSI C are contained in the following files: SYS$HELP:CC.RELEASE_NOTES SYS$HELP:CC_RELEASE_NOTES.PS
61 – Socket Routines
For help on the socket routines used for writing Internet
application programs for the TCP/IP Services protocol, enter the
following:
$ HELP TCPIP_Services Programming_Interfaces Sockets_API
Also see the HP TCP/IP Services for OpenVMS product documentation.