Jump to 
content
HP.com Home Products and Services Support and Drivers Solutions How to Buy
»  Contact HP

 

HP C

HP C
User's Guide for OpenVMS Systems


Previous Contents Index


Appendix E
HP C Limits

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.

E.1 Contents of <float.h>

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 */ 
 

E.2 Contents of <limits.h>

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 */ 


Glossary


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:

  • A member of the ASCII character set.
  • An object of type char , which is stored in a single byte of memory. An object of type char always represents a single character, not a string.
  • A constant of type char consisting of up to four ASCII characters enclosed in apostrophes (' ') not quotation marks (" ").

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

Privacy statement Using this site means you accept its terms
© 2007 Hewlett-Packard Development Company, L.P.