|
HP OpenVMS SystemsC Programming Language |
|
HP C
|
| Previous | Contents | Index |
The <float.h> and <limits.h> header files define several macros that expand to various implementation-specific limits and parameters. This appendix contains the contents of these header files for HP C for OpenVMS Systems.
The <float.h> header file has the following contents:
#ifndef __FLOAT_LOADED
#define __FLOAT_LOADED 1
/****************************************************************************
**
** <float.h> - Characteristics of floating types
**
*****************************************************************************
** Header introduced by the ANSI C Standard
*****************************************************************************
**
** Copyright 2001, 2004 Hewlett-Packard Development Company, L.P.
**
** Confidential computer software. Valid license from HP required for
** possession, use or copying. Consistent with FAR 12.211 and 12.212,
** Commercial Computer Software, Computer Software Documentation, and
** Technical Data for Commercial Items are licensed to the U.S. Government
** under vendor's standard commercial license.
**
******************************************************************************
*/
#include <decc$types.h>
#pragma __nostandard
#ifdef __cplusplus
extern "C" {
#endif
/*
** The following literals and routines are available on OpenVMS for
** Alpha, but only after OpenVMS V7.1 or with C++.
*/
#if defined __ALPHA && !defined _ANSI_C_SOURCE
# if (defined(__DECCXX) || (__CRTL_VER >= 70100000))
/*
** Values for the IEEE Rounding Modes (IEEE ANSI Values)
**
** RZ = Round toward zero (chopped)
** RN = Round toward nearest (default, normal)
** RP = Round toward plus infinity
** RM = Round toward minus infinity
*/
# define FP_RND_RZ 0
# define FP_RND_RN 1
# define FP_RND_RP 2
# define FP_RND_RM 3
/*
** IEEE Constants
*/
# ifdef _IEEE_FP
# pragma __extern_model __save
# pragma __extern_model __strict_refdef
extern double decc$gt_dinfinity;
extern double decc$gt_dqnan;
extern double decc$gt_dsnan;
extern float decc$gs_sinfinity;
extern float decc$gs_sqnan;
extern float decc$gs_ssnan;
# if __X_FLOAT
# if (__CRTL_VER >= 60200000)
extern long double decc$gx_long_dbl_infinity;
# endif
extern long double decc$gx_long_dbl_qnan;
extern long double decc$gx_long_dbl_snan;
# endif
# pragma __extern_model __restore
# define DBL_INFINITY decc$gt_dinfinity
# define LDBL_INFINITY DBL_INFINITY
# define DBL_QNAN decc$gt_dqnan
# define DBL_SNAN decc$gt_dsnan
# define FLT_INFINITY decc$gs_sinfinity
# define FLT_QNAN decc$gs_sqnan
# define FLT_SNAN decc$gs_ssnan
# if __X_FLOAT
# if (__CRTL_VER >= 60200000)
# define LDBL_INFINITY decc$gx_long_dbl_infinity
# else
# define LDBL_INFINITY DBL_INFINITY
# endif
# define LDBL_QNAN decc$gx_long_dbl_qnan
# define LDBL_SNAN decc$gx_long_dbl_snan
# else
# define LDBL_INFINITY DBL_INFINITY
# define LDBL_QNAN DBL_QNAN
# define LDBL_SNAN DBL_SNAN
# endif
# endif
/*
** Macros to get decc$ names
*/
# if (__CRTL_VER < 70100000)
# define write_rnd(__p1) decc$write_rnd(__p1)
# define read_rnd decc$read_rnd
# endif
/*
** Functions to read and write floating point rounding mode
*/
unsigned int write_rnd(unsigned int __rnd);
unsigned int read_rnd(void);
# endif
#endif
/*
** Rounding mode for floating point addition:
*/
#ifdef __BIASED_FLT_ROUNDS
# define FLT_ROUNDS (__BIASED_FLT_ROUNDS-1) /* use compiler generated
value, if present */
#else
# define FLT_ROUNDS 1
#endif
/*
** Radix of exponent representation:
*/
#define FLT_RADIX 2
/*
** Number of FLT_RADIX digits in the mantissa including the hidden bit:
*/
#define __F_FLT_MANT_DIG 24
#define __G_DBL_MANT_DIG 53
#ifdef __ALPHA
#define __S_FLT_MANT_DIG 24
#define __T_FLT_MANT_DIG 53
#define __X_FLT_MANT_DIG 113
#endif
/*
** Number of decimal digits of precision:
*/
#define __F_FLT_DIG 6
#define __G_FLT_DIG 15
#ifdef __ALPHA
#define __S_FLT_DIG 6
#define __T_FLT_DIG 15
#define __X_FLT_DIG 33
#endif
/*
** Minimum negative integer such that FLT_RADIX raised to that power
** minus 1 is a normalized floating-point number:
*/
#define __F_FLT_MIN_EXP (-127)
#define __G_FLT_MIN_EXP (-1023)
#ifdef __ALPHA
#define __S_FLT_MIN_EXP (-125)
#define __T_FLT_MIN_EXP (-1021)
#define __X_FLT_MIN_EXP (-16381)
#endif
/*
** Minimum negative integer such that 10 raised to that power is in the
** range of normalized floating-point numbers:
*/
#define __F_FLT_MIN_10_EXP (-38)
#define __G_FLT_MIN_10_EXP (-308)
#ifdef __ALPHA
#define __S_FLT_MIN_10_EXP (-37)
#define __T_FLT_MIN_10_EXP (-307)
#define __X_FLT_MIN_10_EXP (-4931)
#endif
/*
** Maximum integer such that FLT_RADIX raised to that power minus 1 is a
** representable finite floating point number:
*/
#define __F_FLT_MAX_EXP 127
#define __G_FLT_MAX_EXP 1023
#ifdef __ALPHA
#define __S_FLT_MAX_EXP 128
#define __T_FLT_MAX_EXP 1024
#define __X_FLT_MAX_EXP 16384
#endif
/*
** Maximum integer such that 10 raised to that power is in the range of
** representable finite floating-point numbers:
*/
#define __F_FLT_MAX_10_EXP 38
#define __G_FLT_MAX_10_EXP 307
#ifdef __ALPHA
#define __S_FLT_MAX_10_EXP 38
#define __T_FLT_MAX_10_EXP 308
#define __X_FLT_MAX_10_EXP 4932
#endif
/*
** Maximum representable finite floating-point number:
*/
#define __F_FLT_MAX 1.7014117e+38f
#define __G_FLT_MAX 8.98846567431157854e+307
#ifdef __ALPHA
#define __S_FLT_MAX 3.40282347e+38f
#define __T_FLT_MAX 1.79769313486231570e+308
#define __X_FLT_MAX 1.189731495357231765085759326628007016196477e4932l
#endif
/*
** The difference between 1.0 and the least value greater than 1.0 that
** is representable in the given floating-point type
** (i.e. 1.0 + epsilon != 1.0):
*/
#define __F_FLT_EPSILON ((float)(1.0 / (1 << 23)))
#define __G_FLT_EPSILON (1.0 / (1 << 30) / (1 << 22))
#ifdef __ALPHA
#define __S_FLT_EPSILON 1.19209290e-07f
#define __T_FLT_EPSILON 2.2204460492503131e-16
#define __X_FLT_EPSILON 1.9259299443872358530559779425849273185381e-34l
#endif
/*
** Minimum normalized positive floating-point number:
*/
#define __F_FLT_MIN ((float) 2.93873587705571877e-39)
#define __G_FLT_MIN 5.56268464626800346e-309
#ifdef __ALPHA
#define __S_FLT_MIN 1.17549435e-38f
#define __T_FLT_MIN 2.2250738585072014e-308
#define __X_FLT_MIN ((long double)
3.3621031431120935062626778173217526025981e-4932l)
#endif
/*
** Define the FLT values to be either the __S or __F values based on IEEE
*/
#if __IEEE_FLOAT
# define FLT_MANT_DIG __S_FLT_MANT_DIG
# define FLT_DIG __S_FLT_DIG
# define FLT_MIN_EXP __S_FLT_MIN_EXP
# define FLT_MIN_10_EXP __S_FLT_MIN_10_EXP
# define FLT_MAX_EXP __S_FLT_MAX_EXP
# define FLT_MAX_10_EXP __S_FLT_MAX_10_EXP
# define FLT_MAX __S_FLT_MAX
# define FLT_EPSILON __S_FLT_EPSILON
# define FLT_MIN __S_FLT_MIN
#else
# define FLT_MANT_DIG __F_FLT_MANT_DIG
# define FLT_DIG __F_FLT_DIG
# define FLT_MIN_EXP __F_FLT_MIN_EXP
# define FLT_MIN_10_EXP __F_FLT_MIN_10_EXP
# define FLT_MAX_EXP __F_FLT_MAX_EXP
# define FLT_MAX_10_EXP __F_FLT_MAX_10_EXP
# define FLT_MAX __F_FLT_MAX
# define FLT_EPSILON __F_FLT_EPSILON
# define FLT_MIN __F_FLT_MIN
#endif
/*
** Define the DBL values to be either the __S or __F values based on IEEE
*/
#if __IEEE_FLOAT
# define DBL_MANT_DIG __T_FLT_MANT_DIG
# define DBL_DIG __T_FLT_DIG
# define DBL_MIN_EXP __T_FLT_MIN_EXP
# define DBL_MIN_10_EXP __T_FLT_MIN_10_EXP
# define DBL_MAX_EXP __T_FLT_MAX_EXP
# define DBL_MAX_10_EXP __T_FLT_MAX_10_EXP
# define DBL_MIN __T_FLT_MIN
#elif __G_FLOAT
# define DBL_MANT_DIG __G_DBL_MANT_DIG
# define DBL_DIG __G_FLT_DIG
# define DBL_MIN_EXP __G_FLT_MIN_EXP
# define DBL_MIN_10_EXP __G_FLT_MIN_10_EXP
# define DBL_MAX_EXP __G_FLT_MAX_EXP
# define DBL_MAX_10_EXP __G_FLT_MAX_10_EXP
# define DBL_MIN __G_FLT_MIN
#else
# define DBL_MANT_DIG 56
# define DBL_DIG 16
# define DBL_MIN_EXP __F_FLT_MIN_EXP
# define DBL_MIN_10_EXP __F_FLT_MIN_10_EXP
# define DBL_MAX_EXP __F_FLT_MAX_EXP
# define DBL_MAX_10_EXP __F_FLT_MAX_10_EXP
# define DBL_MIN 2.93873587705571877e-39
#endif
#if __IEEE_FLOAT
# define DBL_MAX __T_FLT_MAX
#elif __G_FLOAT
# define DBL_MAX __G_FLT_MAX
#else
# ifndef __ALPHA
# define DBL_MAX 1.70141183460469229e+38
# else
# define DBL_MAX 1.70141183460469213e+38
# endif
#endif
#if __IEEE_FLOAT
# define DBL_EPSILON __T_FLT_EPSILON
#elif __G_FLOAT || (__D_FLOAT && defined(__ALPHA))
# define DBL_EPSILON (1.0 / (1 << 20) / (1 << 16) / (1 << 16))
#else
# define DBL_EPSILON (1.0 / (1 << 23) / (1 << 16) / (1 << 16))
#endif
/*
** Define the LDBL values based on __X_FLOAT
*/
#if __X_FLOAT
# define LDBL_MANT_DIG __X_FLT_MANT_DIG
# define LDBL_DIG __X_FLT_DIG
# define LDBL_MIN_EXP __X_FLT_MIN_EXP
# define LDBL_MIN_10_EXP __X_FLT_MIN_10_EXP
# define LDBL_MAX_EXP __X_FLT_MAX_EXP
# define LDBL_MAX_10_EXP __X_FLT_MAX_10_EXP
# define LDBL_MAX __X_FLT_MAX
# define LDBL_EPSILON __X_FLT_EPSILON
# define LDBL_MIN 3.3621031431120935062626778173217526025981e-4932l
#else
# define LDBL_MANT_DIG DBL_MANT_DIG
# define LDBL_DIG DBL_DIG
# define LDBL_MIN_EXP DBL_MIN_EXP
# define LDBL_MIN_10_EXP DBL_MIN_10_EXP
# define LDBL_MAX_EXP DBL_MAX_EXP
# define LDBL_MAX_10_EXP DBL_MAX_10_EXP
# define LDBL_MAX DBL_MAX
# define LDBL_EPSILON DBL_EPSILON
# define LDBL_MIN DBL_MIN
#endif
#ifdef __cplusplus
}
#endif
#pragma __standard
#endif /* __FLOAT_LOADED */
|
The <limits.h> header file has the following contents:
#ifndef __LIMITS_LOADED
#define __LIMITS_LOADED 1
/****************************************************************************
**
** <limits.h> - Sizes of integral types
**
*****************************************************************************
** Header introduced by the ANSI C Standard
*****************************************************************************
**
** Copyright 2001, 2004 Hewlett-Packard Development Company, L.P.
**
** Confidential computer software. Valid license from HP required for
** possession, use or copying. Consistent with FAR 12.211 and 12.212,
** Commercial Computer Software, Computer Software Documentation, and
** Technical Data for Commercial Items are licensed to the U.S. Government
** under vendor's standard commercial license.
**
******************************************************************************
** Note
******************************************************************************
**
** Section 2.2.4.2 of the Rationale states "The limits for the maxima and
** minima of unsigned types are specified as unsigned constants..."
**
** The alert reader will notice there are no minima for the unsigned types,
** but we will follow the Rationale's advice anyway.
**
******************************************************************************
** Implementors Note
******************************************************************************
**
** Some constants in this file such as INT_MIN is defined in terms of an
** expression involving an INT_MAX which is a constant value. Please do
** not be tempted to speed processing up by evaluating those expressions
** into constant values. This will cause things to not work correctly.
******************************************************************************
*/
#include <decc$types.h>
#pragma __nostandard
/*
** Number of bits for the smallest object that is not a bit-field (byte)
*/
#define CHAR_BIT 8
/*
** Minimum and maximum values for "signed/unsigned char"
*/
#define UCHAR_MAX 255u
#define SCHAR_MAX 127
#define SCHAR_MIN (-SCHAR_MAX - 1)
/*
** Minimum and maximum values for "char" affected by /unsigned_char qualifier
*/
#ifdef __UNSIGNED_CHAR
#define CHAR_MIN 0
#define CHAR_MAX UCHAR_MAX
#else
#define CHAR_MIN SCHAR_MIN
#define CHAR_MAX SCHAR_MAX
#endif
/*
** Minimum and maximum values for "signed/unsigned short int"
*/
#define USHRT_MAX 65535u
#define SHRT_MAX 32767
#define SHRT_MIN (-SHRT_MAX - 1)
/*
** Minimum and maximum values for "signed/unsigned int"
*/
#define UINT_MAX 4294967295u
#define INT_MAX 2147483647
#define INT_MIN (-INT_MAX - 1)
/*
** Minimum and maximum values for "signed/unsigned long int"
*/
#define ULONG_MAX 4294967295u
#define LONG_MAX 2147483647
#define LONG_MIN (-LONG_MAX - 1)
/*
** Minimum and maximum values for "signed/unsigned __intxx"
*/
#define __UINT16_MAX 65535u
#define __INT16_MAX 32767
#define __INT16_MIN (-__INT16_MAX - 1)
#define __UINT32_MAX 4294967295u
#define __INT32_MAX 2147483647
#define __INT32_MIN (-__INT32_MAX - 1)
#ifdef __ALPHA
#define __UINT64_MAX 18446744073709551615u
#define __INT64_MAX 9223372036854775807
#define __INT64_MIN (-__INT64_MAX - 1)
#endif
#if __CRTL_VER < 60200000
# define MB_LEN_MAX 1 /* Before OpenVMS V6.2 */
#else
# define MB_LEN_MAX 8 /* After OpenVMS V6.2 */
#endif
/*
** Limits which changed beginning with OpenVMS V6.2
*/
# if defined(_XOPEN_SOURCE) || !defined(_ANSI_C_SOURCE)
# define COLL_WEIGHTS_MAX 5 /* Max collate weights */
# define NL_TEXTMAX 8192
# define NL_SETMAX 65535
# define NL_MSGMAX 65535
# define CHARCLASS_NAME_MAX 14
# define NL_ARGMAX 9
# define NL_LANGMAX 14
# define TZNAME_MAX 15
# define SSIZE_MAX INT_MAX
/*
** Limits needed to support *conf() functions.
*/
# define BC_BASE_MAX -1 /* Max ibase and obase values
** for bc not implemented */
# define BC_DIM_MAX -1 /* Max num elements in array
** for bc not implemented */
# define BC_SCALE_MAX -1 /* Max scale value allowed by
** bc not implemented */
# define BC_STRING_MAX -1 /* Max len of string constant
** by bc not implemented */
# define EXPR_NEST_MAX (-1) /* Max num expression nested
for expr */
# define LINE_MAX (-1) /* Max len of utility input
** line */
# define RE_DUP_MAX (-1) /* Max num repeated reg for
** interval */
# define NGROUPS_MAX 0 /* User can be in no extra groups */
# define PASS_MAX 31 /* Max bytes in a password */
# define ARG_MAX 4096 /* Max len of arg to exec rtns */
/*
** These are used by pathconf() as well as others
*/
# define LINK_MAX 1 /* Only 1 link to a file */
# define MAX_CANON 511 /* Max bytes in terminal canonical
** input */
# define MAX_INPUT 511 /* Max bytes required as input
** before reading */
# define NAME_MAX 255 /* Max bytes in filename */
# define PATH_MAX 255 /* Max bytes in pathname */
# define PIPE_BUF 512 /* Max atomic bytes on write to pipe */
/*
** New limits with DEC C V5.2
*/
# define _POSIX_PIPE_BUF 512
#endif /* XOPEN_SOURCE */
#if defined(_XOPEN_SOURCE_EXTENDED) || !defined(_ANSI_C_SOURCE)
# define ATEXIT_MAX 32767 /* Max number of functions that
** may be registered with atexit().
** essentially unlimited
*/
# define IOV_MAX (-1) /* Maximum number of iovec
** structures that one process
** has available for use with
** readv() or writev() */
#endif
/*
** Macros defined by the POSIX 1003.1c-1995 formally approved at
** the June 1995 meeting of the IEEE Standards Board. The correct
** feature test macro for strictly conforming POSIX 1003.1c-1995
** applications is:
**
** #define _POSIX_C_SOURCE 199506L
*/
#if _POSIX_C_SOURCE >= 199506 || !defined _ANSI_C_SOURCE
# ifndef _POSIX_THREAD_DESTRUCTOR_ITERATIONS
# define _POSIX_THREAD_DESTRUCTOR_ITERATIONS 4
# endif
# ifndef _POSIX_THREAD_KEYS_MAX
# define _POSIX_THREAD_KEYS_MAX 128
# endif
# ifndef _POSIX_THREAD_THREADS_MAX
# define _POSIX_THREAD_THREADS_MAX 64
# endif
# ifndef PTHREAD_DESTRUCTOR_ITERATIONS
# define PTHREAD_DESTRUCTOR_ITERATIONS
_POSIX_THREAD_DESTRUCTOR_ITERATIONS
# endif
# ifndef PTHREAD_KEYS_MAX
# define PTHREAD_KEYS_MAX 255
# endif
# ifndef PTHREAD_STACK_MIN
# if defined __ALPHA
# define PTHREAD_STACK_MIN 8192
# else
# define PTHREAD_STACK_MIN 1024
# endif
# endif
#endif /* _POSIX_C_SOURCE >= 199506 */
#pragma __standard
#endif /* __LIMITS_LOADED */
|
additive operator: An operator that performs addition
(+) or subtraction (--). These operators perform arithmetic conversion
on each of the operands, if necessary. See also arithmetic
conversion rules.
aggregate: A data structure (array, structure, or
union) composed of segments called members. You declare the members to
be of either a scalar or aggregate data type. Members of an array are
called elements and must be of the same data type. A structure has
named members that can be of different data types. A union is a
structure that is as long as its longest declared member and that
contains the value of only one member at a time.
ampersand (&): As a unary operator, computes the
address of its operand. As a binary operator, performs a bitwise AND on
two operands; both must be of an integral type. As an assignment
operator (&=), performs a bitwise AND on two expressions and
assigns the result to the left object. The double ampersand
(&&), a binary operator, performs a logical AND on two
operands. See also binary operator, bitwise operator, logical
operator, and unary operator.
argument: An expression that appears within the
parentheses of a function call. The expression is evaluated and the
result is copied into the corresponding parameter of the called
function. See also argument passing and parameter.
argument passing: The mechanism by which the value of
the argument in a function call is copied to a parameter in the called
function. In C, all arguments are passed by value; that is, the
parameter receives a copy of the argument's value. Therefore, a
function called in C cannot modify the value of an argument except by
using its address. In general, addresses are passed using the ampersand
operator (see ampersand (&)) in the function call or by
passing a pointer variable. In addition, using an array or function
name (an array with no brackets or function identifier with no
parentheses) as an argument results in the passing of the address of
the array or function.
arithmetic conversion rules: The set of rules that
govern the changing of a value of an operand from one data type to
another in arithmetic expressions. Conversions take place in
assignments by changing the type of the right operand's result to that
of the object referred to by the left operand; the resultant type also
applies to the assignment expression. Conversions are also performed
when arguments are passed to functions.
arithmetic operator: A C operator that performs a
mathematical operation. In an expression, certain operations take
precedence (are performed first) over other operations. The unary minus
operator (--) is at the highest level of precedence. At the next level
are the binary operators for multiplication (*), division (/), and mod
(%). At the next level are addition (+) and subtraction (--). There is
no unary plus operator, and there is no exponentiation operator. If
necessary, all the binary operators perform the arithmetic conversions
on their operands. See also arithmetic conversion rules.
arithmetic type: One of the integral data types,
enumerated types,
float
, or
double
.
array: An aggregate data type consisting of
subscripted members, called elements, all of the same type. Elements of
an array can be one of the fundamental types or can be structures,
unions, or other arrays (to form multidimensional arrays).
assignment expression: An expression that has the following form:
|
E1 asgnop E2 |
Expression E1 must evaluate to an lvalue, the asgnop operator is an
assignment operator, and E2 is an expression. The type of an assignment
expression is that of its left operand. The value of an assignment
expression is that of the left operand after the assignment takes
place. If the operator is of the form op=, then the operation E1 op
(E2) is performed, and the result is assigned to the object referred to
by E1; E1 is evaluated once.
assignment operator: The combination of an arithmetic
or bitwise operator with the assignment symbol (=); also, the
assignment symbol by itself. See also assignment expression.
asterisk (*): As a unary operator, treats its operand
as an address and results in the contents of that address. As a binary
operator, multiplies two operands, performing the arithmetic
conversions, if necessary. As an assignment operator (*=), multiplies
an expression by the value of the object referred to by the left
operand, and assigns the product to that object. See also
binary operator and unary operator.
binary operator: An operator that is placed between
two operands. The binary operators include arithmetic operators, shift
operators, relational operators, equality operators, bitwise operators
(AND, OR, and XOR), logical connectives, and the comma operator, in
that order of precedence. All binary operators group from left to
right. HP C has no exponentiation operator. The
exp
library function must be used instead.
bitwise operator: An operator that performs Boolean
algebra on the binary values of two operands, which must be integral.
If necessary, the operators perform the arithmetic conversions. Both
operands are evaluated. All bitwise operators are associative, and
expressions using them may be rearranged. The operators include, in
order of precedence, the single ampersand (&) (bitwise AND), the
circumflex (^) (bitwise exclusive OR), and the single bar (|) (bitwise
inclusive OR).
block: See compound statement.
block activation: The run-time activation of a block
or function, in which local
auto
and
register
variables are allocated storage and, if they are declared with
initializers, given initial values. Variables of storage class
static
,
extern
,
globaldef
, and
globalvalue
are allocated and initialized at link time. The block activation
precedes the execution of any executable statements in the function or
block. Functions are activated when they are called. Internal blocks
(compound statements) are activated when the program control flows into
them. Internal blocks are not activated if they are entered by a
goto
statement, unless the
goto
target is the label of the block rather than the label of some
statement within the block. If a block is entered by a
goto
statement, references to
auto
and
register
variables declared in the block are still valid references, but the
variables may not be properly initialized. Blocks that make up the body
of a
switch
statement are not activated;
auto
or
register
variables declared in the block are not initialized.
built-in functions: The function definitions that are
part of the HP C compiler for OpenVMS systems. A call to one
of these functions does not call a function in a run-time library or in
your program. Most of the built-in functions access the VAX hardware
instructions to perform operations quickly that are cumbersome, slow,
or impossible in the C language.
cast: An expression preceded by a cast operator of the
form (type_name). The cast operator forces the conversion of the
evaluated expression to the given type. The expression is assigned to a
variable of the specified type, which is then used in place of the
whole construction. The cast operator has the same precedence as the
other unary operators.
CDD/Repository: An optional OpenVMS software product,
available under a separate license, that maintains a set of data
structure definitions that many programs on a system, written in many
languages, can access. The language-independent definitions are
translated into the target language when they are included in the
program stream. You can include the CDD records in HP C
programs using the
#dictionary
preprocessor directive. This directive is specific to HP C for OpenVMS Systems,
and is not portable.
character:
See also string.
comma operator: A C operator used to separate two expressions as follows:
|
E1, E2 |
The expressions E1 and E2 are evaluated left to right, and the value of
E1 is discarded. The type and value of the comma expression are those
of E2.
comment: A sequence of characters introduced by the
pair /* and terminated by */. Comments are ignored during compilation.
They may not be nested.
Common Data Dictionary (CDD): See
CDD/Repository.
compilation unit: All the source files compiled to
form a single object module. In other C documentation, the term source
file is synonymous with the OpenVMS compilation unit, which is not
necessarily a single source file. Declarations and definitions within a
compilation unit determine the lexical scope of functions and variables.
compound statement: Valid C statements enclosed in
braces ({ }). Compound statements can also include declarations. The
scope of these variables is local to the compound statement. A compound
statement, when it is not the body of a function, is called a block.
conditional operator: The C operator (?:), which is used in conditional expressions of the following form:
|
E1 ? E2 : E3 |
| Previous | Next | Contents | Index |