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

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