 |
dec_c_help.HLP
Command_Parameters
file-spec,...
One or more HP 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, HP 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, HP C assumes the .TLB default file
extension.
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[,...])]
/ACCEPT
/ACCEPT=(option[,option])
Allows the compiler to accept C language syntax that it might not
normally accept.
HP 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)
/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.
/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).
/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.
/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.
/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.
/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 HP 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).
/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 HP 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.
/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.
/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).
/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.
/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.
/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.
/ENDIAN
/ENDIAN={BIG | LITTLE}
/ENDIAN=LITTLE (D)
Controls whether big or little endian ordering of bytes is carried
out in character constants.
/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.
/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 HP C is relaxed/refdef with the noshare
attribute. This is different from the model used by VAX C, which
is common block, share.
/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.
/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.
/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.
/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.
/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
/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.
/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
/LINE_DIRECTIVES
/LINE_DIRECTIVES (D)
/NOLINE_DIRECTIVES
Controls whether or not #line directives appear in preprocess
output files.
/LIST
/LIST[=file-spec] (Batch default)
/NOLIST (Interactive default)
Controls whether a listing file is produced. The default output
file extension is .LIS.
/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.
/MAIN=POSIX_EXIT
/MAIN
/NOMAIN (D)
Directs the compiler to call __posix_exit instead of exit when
returning from main.
/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.
/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.
/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.
/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.
/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.
/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).
/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.
/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.
/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.
/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.
/PREFIX_LIBRARY_ENTRIES
Controls the HP C RTL name prefixing.
The HP 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 HP 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 HP 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 HP 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.
/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.
/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.
/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 HP 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.
/REENTRANCY
/REENTRANCY=option
/REENTRANCY=TOLERANT (D)
Controls the type of reentrancy that reentrant HP 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 HP 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 HP 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.
/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 HP C and HP C++
compilers.
/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.
/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.
/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)
/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 HP 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.
HP C modules compiled in different modes can be linked and executed
together.
/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.
/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 HP
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 HP 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.
/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.
/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.
/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.
Message_Groups
HP 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.
Additional Information on:
64BIT
64BITPOINTERS
ALIGNMENT
C_TO_CXX
CDD
DEFUNCT
NEWC99
NOC89
NOC99
OBSOLESCENT
OVERFLOW
PERFORMANCE
PORTABLE
PREPROCESSOR
QUESTCODE
RETURNCHECKS
UNINIT
UNUSED
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.
Additional Information on:
ABSTRACTDCL
ADDRARRAY
ADDRCONSTEXT
ADDRESSOFVOID
ADDRSUBCONST
ALIGNCONFLICT
ALIGNCONFLICT1
ALIGNCONST
ALIGNEXT
ALIGNPOP
ALREADYTLS
ANSIALIASCAST
ARGADDR
ARGLISGTR255
ARGLISTOOLONG
ARGSIZE
ARRAYBRACE
ARRAYLIMITSUP
ARRAYOVERFLOW
ARRNOTLVALUE
ASMCOMEXP
ASMENDEXP
ASMFIMMDOTS
ASMFREGEXP
ASMHINTDOTS
ASMICONEXP
ASMIDEXP
ASMINSTEXP
ASMLABEXP
ASMLABMULDEF
ASMLABUNDEF
ASMLDGPDOTS
ASMLPAREXP
ASMNOTAVAIL
ASMNOTINST
ASMNOTREG
ASMNOTSUP
ASMPALTRUNC
ASMRAWREG
ASMREGEXP
ASMREGOVRLAPSC
ASMRPAREXP
ASMSYMDOTS
ASMUNKNOWNARCH
ASMUNKSETOPT
ASSERTFAIL
ASSERTION
ASSIGNEXT
ASSUMEONEELEM
AUTOALIGN
AUTOEXTERNAL
BADALIAS
BADALIGN
BADANSIALIAS
BADBOUNDCHK
BADBOUNDS
BADBREAK
BADC99PRAGOP
BADCHARSINHDR
BADCMMNTPSTNG
BADCOMLITTYPE
BADCOMPLEXTYPE
BADCONDIT
BADCONSTEXPR
BADCONTINUE
BADCONVSPEC
BADDCL
BADDECLSPEC
BADDEFARG
BADENUM
BADENUMREDECL
BADEXPR
BADFATCOMMENT
BADFBDAT
BADFBFILE
BADFBTYP
BADFLOATTYPE
BADFORMALPARM
BADFORSTOCLS
BADFUNCSTOCLS
BADGLOBALTYPE
BADHEADERNM
BADHEXCONST
BADIDENTUCN
BADIFDEF
BADIFNDEFARG
BADINCLDIR
BADINCLDIRSIZE
BADINCLUDE
BADLINEDIR
BADLINEDIRTV
BADLINKREG
BADLINNUM
BADLOCALE
BADMACROINLN
BADMACRONAME
BADMBCOMMENT
BADMCRORECURS
BADMEMBER
BADMEMOFF
BADMEMTYP
BADMODULEID
BADMULTIBYTE
BADNUM
BADOCTCONST
BADOPCCAP
BADOPENBRACE
BADPARSEDECL
BADPARSEPARAM
BADPPDIR
BADPRAGMAARG
BADPRAGMAARG1
BADPRAGMALINK
BADPRAGNAMES
BADPREFIX
BADPROTYP
BADPTRARITH
BADREGISTER
BADRETURNTYPE
BADSEVERITY
BADSTATICCVT
BADSTDLINKAGE
BADSTMT
BADSTMT1
BADSUBSCRIPT
BADTARGMACRO
BADTKEN
BADUNKNOWNVLA
BADUNROLLVAL
BADUSELINK
BADUSERMACRO
BADVASTART
BIFENABLED
BIFNEEDSSTD
BIFNOTAVAIL
BIFPROTO
BITARRAY
BITBADREP
BITCONSTSIGN
BITFIELDSIZE
BITNOTINT
BITWIDTH
BITWIDTHTYP
BLOCKEXTVLA
BLOCKINL
BLTINARGCNT
BLTINIMPLRET
BOOLEXT
BOOLNA
BOUNDADJ
BOUNDNOTINT
BUGCHECK
CALLNEEDSFUNC
CANNOTREDEF
CANNOTUNDEF
CANTDISABLE
CANTMKRPSTORY
CDDATTR
CDDBADID
CDDEXT
CDDPATH
CDDTOODEEP
CHARCONST
CHAROVERFL
CHKEXPAND
CHKINIT
CHKOPT
CLASSNOINIT
CLOSBRACKET
CLOSEBRACE
CLOSECOMMENT
CLOSEPAREN
CMPPTRFUNVOID
COLMAJOR
COMMANDMACRO
COMPILERBUG
COMPLEXEXT
COMPLEXNA
COMPLEXNA1
CONFLICTHINTS
CONLINKREG
CONPSECTATTR
CONSTCOMPLIT
CONSTFOLDNS
CONSTFUNC
CONSTINWRT
CONSTNOINIT
CONSTSTOCLS
CONTFILE
CONTROLASSIGN
CONVARASLIT
CRXCOND
CVIDXOVFL
CVTDIFTYPES
CVTU32TO64
CXXCOMMENT
CXXKEYWORD
CXXPRAGMANA
DCLMISMATLNK
DCLMISMATLNK0
DCLMISMATLNK1
DCLMISMATLNK2
DCLMISMATLNK3
DCLMISMATLNK4
DCLMISMATLNK5
DCLMISMATLNK6
DECCONSTLARGE
DECLAFTERSTMT
DECLARATOR
DECLINFOR
DECLSPECEXT
DEFINOTHER
DEFINOTHER1
DEFINOTHER2
DEFINOTHER3
DEFPARMTYPE
DEFRETURNTYPE
DESIGBADARR
DESIGBADCOMP
DESIGBADIND
DESIGBADIND1
DESIGNATIONNA
DESIGNATORUSE
DESIGNOMEMB
DESIGSCALAR
DIFFEXMODEL
DIFFTYPEQUALS
DIRECTVNOCPP
DISREDECL
DOLLARID
DONOTAPPLY
DUPCASE
DUPDEFAULT
DUPENUM
DUPEXTERN
DUPLABEL
DUPLINK
DUPLPRAGASS
DUPPARM
DUPSTATIC
DUPSTORCLS
DUPTYPEDEF
DUPTYPESPEC
DUPTYPQUAL
ELIFIGNORED
ELLIPSEARG
ELLIPSEPARM
ELLIPSISEND
ELSEIGNORED
EMBEDCOMMENT
EMPTYCHARCONST
EMPTYFILE
EMPTYINIT
EMPTYOBJ
EMPTYSTRUCT
ENUM16BIT
ENUMCALC
ENUMINIT
ENUMRANGE
ENUMSANDINT
ENUMSNOTCOMPAT
ENUMUSED
ENVIRSTKDIRTY
ERRORLIM
ERRORMESSAGE
ESCOVERFL
EXPANDEDDEFINED
EXPNOTRES
EXPRCVTINT
EXPRNOTINT
EXPRNOTUSED
EXTENDTYPE
EXTERNINIT
EXTERNPOP
EXTPREAFTER
EXTPREAGAIN
EXTPRENODECL
EXTRABRACES
EXTRAMODULE
EXTRAPRAGARGS
EXTRASEMI
FALLOFFEND
FBFILENOTFOUND
FILECLOSE
FILENOTFOUND
FILEREAD
FILESCOPEVLA
FINBRANCH
FLEXARRAYELEM
FLEXARRAYMEM
FLOATCONSQUAL
FLOATCONST
FLOATERR
FLOATOVERFL
FLOATTOINT
FMTNOTSTR
FNAMETOOLONG
FORMATATTR
FOUNDCR
FREGNEEDSIEEE
FUNCELEMENT
FUNCIDLIS
FUNCINIT
FUNCMEM
FUNCMIXPTR
FUNCNOTDEF
FUNCNOTFUNC
FUNCREDECL
FUNCSTORCLS
FUNCSTORMOD
FUNCSTRCLS
FUTUREKEYWD2
FUTUREKEYWORD
GBLOUTSIDEINT
GBLREFINIT
GCCINLINE
GEMARGSIZE
GLOBALEXT
GOTSZOVFL
HEXOCTSIGN
HEXOCTUNSIGN
HINTNOTFUNC
HINTTOOBIG
IDEXPECTED
IDINPARENSEXT
IDPACKPOPPRAG
IEEEASSUMED
IEEEASSUMED1
IGNORECALLVAL
IGNOREEXTRA
IGNORETAG
IGNORETOKENS
IGNORSYSREG
IMAGINARYNA
IMPFNCFALLOFF
IMPFNCMSSNGRET
IMPLICITFUNC
INCARGTYP
INCARRAYPARM
INCARRAYPARM1
INCLUDENOPEA
INCLUDEOPEN
INCLUDEPROEPI
INCOMPARRY
INCOMPARRY1
INCOMPARRY2
INCOMPCALL
INCOMPDEREF
INCOMPELINIT
INCOMPELMNT
INCOMPMEM
INCOMPNOLINK
INCOMPPARM
INCOMPRETURN
INCOMPSTAT
INCOMPSTATARR
INCOMPTENT
INCOMPVALUE
INCOMPVOID
INCONSASSFUN
INITCONFLICT
INITOVERLAP1
INITVLA
INLINEIG
INLINESTOCLSMOD
INPTRTYPE
INSUFALN
INTBADLINKAGE
INTCONCASTSGN
INTCONCASTTRU
INTCONST
INTCONSTSIGN
INTCONSTSIGNED
INTCONSTTOOBIG
INTCONSTTRUNC
INTCONSTUNSIGN
INTERNALPRAGMA
INTIMPLIED
INTOVERFL
INTRINSICCALL
INTRINSICDECL
INTRINSICDECLER
INTRINSICINT
INTUNDFUN
INVALIDARG
INVALIDSTR
INVALTOKEN
INVCPPINARGS
INVDUPENUM
INVNOMEMPRAG
INVPACKPRAG
INVPPDIRPEA
INVSTATIC1
INVSTATIC3
INVSTATIC4
INVSTATIC5
INVSTATIC6
IVDEPNOFOR
KEYCOMB
KNRFUNC
LABELWOSTMT
LCRXCOND
LDCOMPLEXNYI
LEXNESTPAR
LISTOPEN
LOCALEXTINI
LONGDEBUG
LONGDOUBLENY1
LONGDOUBLENYI
LONGEXTERN
LONGFLOATEXT
LONGLINE
LONGLONGSUFX
LONGLONGTYPE
LONGMODULEID
LONGMODULESTR
LONGPREFIX
LONGPSECT
LONGTOKEN
LVALUECAST
MACROREDEF
MACROREDEFIN
MAINNOTINT
MAINPARM
MAINPROGEXT
MAPREGIGNORED
MATHERRNO
MAYHIDELOSS
MAYLOSEDATA
MAYLOSEDATA2
MECHMISMATCH
MEMBERVLA
MISALGNDMEM
MISALGNDSTRCT
MISDEFARG
MISDEFPAR
MISMATPARAM
MISMATPRSRET
MISMATTHREAD
MISPARAMCOUNT
MISSINGCASE
MISSINGCOMMA
MISSINGFUNC
MISSINGLABEL
MISSINGRETURN
MISSINGTYPE
MISSPELLDEF
MIXALLOCAVLA
MIXALLOCAVLAV
MIXFUNCVOID
MIXINLINE
MIXLINKAGE
MIXLINKAGE1
MIXOLDNEW
MIXSTORCLS
MIXVLAALLOCA
MIXVLAALLOCAV
MODNOIDSTR
MODSTORCLS
MODULEFIRST
MSGPOP
MSGSFRMEXLCODE
MULTICHAR
MULTILINK
MULTILINKREG
MULTIMAIN
MULTIPSECTNAME
NAMESHORTENED
NAMESLOWER1
NEEDADDRCONT
NEEDARITH
NEEDCONSTEXPR
NEEDCONSTEXT
NEEDDFLOAT
NEEDFUNCPTR
NEEDGFLOAT
NEEDIEEE
NEEDIEEE1
NEEDINTEXPR
NEEDLVALUE
NEEDMEMBER
NEEDNONBLTIN
NEEDNONCONST
NEEDNONVOID
NEEDPOINTER
NEEDPTROBJ
NEEDSCALAR
NEEDSCALARTYP
NEEDSIMPLEASM
NEEDSTRCONST
NEEDSTRUCT
NEGATIVEHINT
NESTEDCOMMENT
NESTEDENUM
NESTEDTYPE
NESTINCL
NEWLOCALE
NLCHAR
NLHEADER
NLSTRING
NOADD
NOBIFDISABLE
NOBITFIELD
NOCASEHERE
NOCDDHERE
NOCOLON
NOCOLONINEXPR
NOCOMMA
NOCONDEXPR
NOCONVERT
NOCONVERTCLS
NODCL
NODEFAULTHERE
NOENDIF
NOEQUAL
NOEQUALITY
NOEXCEPTFLTR
NOFBDAT
NOFBFIL
NOFBOPT
NOFBRTN
NOFIFILE
NOFNTPDEFDECL
NOFORMALPARM
NOFUNC
NOFUNC1
NOIDFOUND
NOIDINPACKPOP
NOINCLFILE
NOINCLFILEF
NOINCLUDEARG
NOINIT
NOINLFUNC
NOINLINEM
NOINLINEREF
NOINLINEST
NOLEAVETARG
NOLEFTOPERND
NOLINKAGE
NOLONGLONG
NOMACRONAME
NOMAINUFLO
NOMAPPOSSIBLE
NONAMEMEMBERS
NONATOMIC
NONEWTYPE
NONGRNACC
NONINTENUM
NONINTENUMCON
NONINTENUMCON1
NONLBEFOREEOF
NONMULTALIGN
NONOCTAL
NONPORTDEFINED
NONPORTLINEDIR
NONSTANDCAST
NONULINIT
NOOPERAND
NOOPERANDS
NOPARENARGLST
NOPARM
NOPARMLIST
NOPRAGARG
NOPSECT
NOREGAVAIL
NORELATIONAL
NORETNONVOID
NORETURNVAL
NORETURNVAL1
NORETVAL
NORGHTPAREN
NORIGHTOPERND
NORIGHTPAREN
NOSEHHAND
NOSEMI
NOSEMI1
NOSEMISTRUCT
NOSFILE
NOSHAREEXT
NOSHRINSHR
NOSTRING
NOSUBTRACT
NOTADDRCAST
NOTAREDUCTION
NOTCOMPAT
NOTCOMPATIMP
NOTCOMPFUNC
NOTCONSTQUAL
NOTEXPECTING
NOTINCRTL
NOTINTRINSIC
NOTLOCALPARM
NOTONEORZERO
NOTPARM
NOTPOSINT
NOTRESTQUAL
NOTRIGHTMOST
NOTSCALARCTRL
NOTTYPEDEF
NOTUNALQUA
NOTVOLQUAL
NOTYPES
NOUNIQFORMALS
NOWHILE
NOWRTWRITTEN
OBJECTTOOBIG
OKCPPINARGS
OPENBRACE
OPENCOMMENT
OPENPAREN
OPTIMIZEPOP
OPTLEVEL
OTHERDECLUSED
OTHERMEMBER
OUTARGPREC
OUTARGWIDTH
OUTFLOATINT
OUTSTRINGTYPE
OUTTOOFEW
OUTTOOMANY
OUTTYPELEN
OUTVARORDER
PACKSTACKPOP
PARAMREDECL
PARENLITERAL
PARMINCOMP
PARMINIT
PARMSTORCLS
PARMSTORMOD
PARMTYPLIST
PARNOIDENT
PDBOPERR
PDBTYPERR
PDOINDEXNOTPRIV
PDONEINSTATIC
PDONENOTINPDO
PLUSWSTOCLS
POINTERINTCAST
POPMISMATCH
PRAGIGNORE
PRAGMA
PRAGMAIDENT
PRAGMAINBLK
PRAGMAMOD
PRAGMAOPTDUP
PRAGMAOPTLVL
PRAGMAOPTSPEC
PRAGMAOPTZERO
PREOPTE
PREOPTW
PREPROCOUT
PRIVATENOTSHARE
PROMOTMATCH
PROMOTMATCHW
PROTOF
PROTOSCOPE
PROTOSCOPE2
PROTOSCOPE3
PROTOSTATIC
PROTOTAG
PROTOTYPEDEF
PROTOVLA
PSECTFIRST
PSECTTOOLONG
PTRINTTOLONG
PTRLONGTOINT
PTRMISMATCH
PTRMISMATCH1
QUALAFTCOMMA
QUALFUNCRET
QUALISPTR
QUALNA
QUALNOTUS
QUESTCOMPARE
QUESTCOMPARE1
QUESTCOMPARE2
READONLYEXT
REDECLNOPARAM
REDEF
REDEFSTRUCT
REDEFTAG
REDEFUNION
REFBEFORETLS
REGCONFLICT
REGNOSHARE
RELOCALIGNMENT
RESMISMATCH
RESTRICTEXT
RESTRICTEXT1
RESTRICTEXT2
RESTRICTNOP
RETLOCALADDR
RETRYCONV
RETRYNOTAVAIL
RETVALTOOBIG
RIGHTSHIFTOVR
RTEXCEPT
RTLMAPNOTFOUND
RTLMISMATCH
SAMEASTYPEDEF
SCACALL
SCAID2LONG
SCALEFACTOR
SCAOVFLO
SEQUENCEEXT
SESEMULTIEXITS
SESEMULTIPREDS
SESEVFLOW
SHARECONST
SHIFTCOUNT
SHORTCIRCUIT
SHOWMAPLINKAGE
SIGNEDKNOWN
SIGNEDMEMBER
SIMPLEMESSAGE
SIZEBIT
SIZEINCOMP
SIZEINCOMPTYP
SIZFUNVOIDTYP
STACKPOP
STATICIFLOAT
STATICVLA
STATINITWARN
STDARG
STKALLEXC
STOALNERR
STONOTFIRST
STORCLSDCL
STOREBIF
STOREQEXC
STORISSTAT
STORMODDCL
STRCTPADDING
STRINGCONST
STRUCTBRACE
STRUCTLIMITSUP
STRUCTOVERFLOW
SUBINVALIDCHR
SUBINVALIDSTR
SUBSCRBOUNDS
SUBSCRBOUNDS1
SUBSCRBOUNDS2
SWAPBIF
SWITCHLONG
SYSREGUSED
SYSTEM
TAGDIFFER
TAGORBRACE
TENTREDEF
TEXTARRAY
TEXTARRAYN
TEXTCHAR
TEXTMODULE
THREADFUNC
THREADNYI
THREADSTO1
THREADSTO2
TLSANDSTATIC
TOOFEWACTUALS
TOOFEWARGS
TOOFEWARGSO
TOOLONG
TOOMANY
TOOMANYACTLS
TOOMANYARGS
TOOMANYARGSO
TOOMANYERR
TOOMANYGATES
TOOMANYTOKENS
TOOMANYTXTLIB
TOOMNYREL
TRAILCOMMA
TRUNCFLTASN
TRUNCFLTINT
TRUNCINTASN
TRUNCINTCAST
TRUNCLONGCAST
TRUNCLONGINT
TUNEOVERRIDE
TYPEALIGN
TYPECONFLICT
TYPEDEFFUNC
TYPEDEFINIT
TYPEDEFNA
TYPEDEFNOTDEF
TYPEEXPR
TYPEOFEXT
TYPQUALNOT
TYPQUALNOT2
TYPQUALNOT3
TYPQUALNOT4
UABORT
UCNICONVOPN
UCNNOMAP
UCNUNSUPP
UCNUSED
UNALIGNEDFUNC
UNALIGNEXT
UNAVAILPRAGMA
UNAVOLACC
UNCALLED
UNDECLARED
UNDECLFUN
UNDECLVAR
UNDEFENUM
UNDEFESCAP
UNDEFINEDTYPE
UNDEFVARFETCH
UNDEFVARMOD
UNDERFLOW
UNINIT1
UNINIT2
UNINIT3
UNINIT4
UNINIT5
UNIONBRACE
UNKEXTMOD
UNKINTRIN
UNKMSGCMD
UNKMSGID
UNKNOWNLINK
UNKNOWNMACRO
UNKNOWNPRAGMA
UNKNOWNPRGMA
UNKPSECTATTR
UNMATCHENDIF
UNNAMEDMEM
UNNAMEPARM
UNNECCDD
UNNECINCL
UNREACHCODE
UNREFADECL
UNREFDECL
UNREFLABEL
UNREFSDECL
UNREFSFUNC
UNREFTYP
UNRLINKATTR
UNSIGNEDPRES
UNSTRUCTMEM
UNSUPCONV
UNSUPCONVSPEC
UNSUPCONVV
UNSUPIEEE
UNSUPPTYPE
UNUSEDCDD
UNUSEDINCL
UNUSEDTOP
USELESSALIGN
USELESSSTOMOD
USELESSTYPED
USELESSTYPEQUAL
VAARGSBODY
VAARGSFORMAL
VALUENOTSUP
VALUEPRES
VARIANTDCL
VARIANTDUP
VARIANTEXT
VARIANTTAG
VARNOMEM
VERTICALSPDIR
VLAEXTENSION
VOIDRETURN
VOIDRETURN1
VOLATILEFUNC
WCHARCAT
WRTINNOWRT
XFERINTOVLA
XTRALARGE
ZERODIV
ZERODIVIDE
ZEROELEMENTS
ZEROELEMENTS1
Language_topics
HP C language topics
Additional Information on:
Block
Valid_File_Specifications
Data_Types
Declarations
Functions
Builtin_Functions
Variable_Length_Argument_Lists
Preprocessor
Predefined_Macros
Predeclared_Identifiers
Statements
Storage_Classes
Type_Qualifiers
Storage_Class_Modifiers
Link_libraries
The following describes how to link with the HP C Run-Time Library
(RTL).
On I64 systems, you link to the HP 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 HP 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 HP 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.
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.
Release_Notes
The release notes for HP C are contained in the following files:
SYS$HELP:CC.RELEASE_NOTES
SYS$HELP:CC_RELEASE_NOTES.PS
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.
|
