9.4 Error Codes (<errno.h>)

The <errno.h> header file defines several macros used for error reporting.

Macros

EDOM
ERANGE

• Error codes that can be stored in errno. They expand to integral constant expressions with unique nonzero values.

Variable or Macro

errno

• An external variable or a macro that expands to a modifiable lvalue with type int, depending on the operating system.
  The errno variable is used for holding implementation-defined error codes from library routines. All error codes are positive integers. The value of errno is 0 at program startup, but is never set to 0 by any library function. Therefore, errno should be set to 0 before calling a library function and then inspected afterward.

9.5 ANSI C Limits (<limits.h> and <float.h>)

The <limits.h> and <float.h> header files define several macros that expand to various implementation-specific limits and parameters, most of which describe integer and floating-point properties of the hardware. See your platform-specific HP C documentation for details.

9.6 Localization (<locale.h>)

The <locale.h> header file declares two functions and one type and defines several macros.

Type

struct lconv

• A structure containing members relating to the formatting of numeric values. The structure contains the following members in any order, with values shown in the comments:

  char *decimal_point; /* "." */ char *thousands_sep; /* "" */ char *grouping; /* "" */ char *int_curr_symbol; /* "" */ char *currency_symbol; /* "" */ char *mon_decimal_point; /* "" */ char *mon_thousands_sep; /* "" */ char *mon_grouping; /* "" */ char *positive_sign; /* "" */ char *negative_sign; /* "" */ char int_frac_digits; /* CHAR_MAX */ char frac_digits; /* CHAR_MAX */ char p_cs_precedes; /* CHAR_MAX */ char p_sep_by_space; /* CHAR_MAX */ char n_cs_precedes; /* CHAR_MAX */ char n_sep_by_space; /* CHAR_MAX */ char p_sign_posn; /* CHAR_MAX */ char n_sign_posn; /* CHAR_MAX */

  
  These members are described under the localeconv function in this section.

Macros

NULL
LC_ALL
LC_COLLATE
LC_CTYPE
LC_MONETARY
LC_NUMERIC
LC_TIME

• Expand to integral constant expressions with distinct values, and can be used as the first argument to the setlocale function.

Functions

char *setlocale(int category, const char *locale);

• Selects the appropriate portion of the program's locale as specified by the category and locale arguments. This function can be used to change or query the program's entire current locale or portions thereof.
  The following values can be specified for the category argument:
  • LC_ALL---affects the program's entire locale.
  • LC_COLLATE---affects the behavior of the strcoll and strxfrm functions.
  • LC_CTYPE---affects the behavior of the character-handling functions and multibyte functions.
  • LC_MONETARY---affects the monetary-formatting information returned by the localeconv function.
  • LC_NUMERIC---affects the decimal-point character for the formatted I/O functions and string-conversion functions, as well as the nonmonetary formatting information returned by the localeconv function.
  • LC_TIME---affects the behavior of the strftime function.
  
  The following values can be specified for the locale argument:
  • "C"---specifies the minimal environment for C translation
  • ""---specifies the use of the environment variable corresponding to category. If this environment variable is not set, the LANG environment variable is used. If LANG is not set, an error is returned.
  
  At program startup, the equivalent of the following is executed:

  setlocale(LC_ALL, "C");

  
  The setlocale function returns one of the following:

  • If a pointer to a string is specified for locale and the selection can be honored, setlocale returns a pointer to the string associated with the specified category for the new locale. If the selection cannot be honored, setlocale returns a null pointer and the program's locale is not changed.
  • If a null pointer is specified for locale, setlocale returns a pointer to the string associated with the category for the program's current locale. The program's locale is not changed.
  
  In either case, the returned pointer to the string is such that a subsequent call with that string value and its associated category will restore that part of the program's locale. This string must not be modified by the program, but it can be overwritten by subsequent calls to setlocale.

struct lconv *localeconv(void);

• Sets the components of an object with type struct lconv with values appropriate for formatting numeric quantities according to the rules of the current locale.
  The structure members with type char * are pointers to strings, any of which (except decimal_point) can point to "", which indicates that the value has zero length or is not available in the current locale. Structure members of type char are nonnegative numbers, any of which can be CHAR_MAX to indicate that the value is not available in the current locale. Structure members include the following:
  • char *decimal_point
    • The decimal-point character used to format nonmonetary quantities.
  • char *thousands_sep
    • The character used to separate groups of digits before the decimal point in formatted nonmonetary quantities.
  • char *grouping
    • A string whose elements indicate the size of each group of digits in formatted nonmonetary quantities.
  • char *int_curr_symbol
    • The international currency symbol applicable to the current locale. The first three characters contain the alphabetic international currency symbol in accordance with those specified in ISO 4217 Codes for the Representation of Currency and Funds. The fourth character (immediately preceding the null character) is the character used to separate the international currency symbol from the monetary quantity.
  • char *currency_symbol
    • The local currency symbol applicable to the current locale.
  • char *mon_decimal_point
    • The decimal-point character used to format monetary quantities.
  • char *mon_thousands_sep
    • The character used to separate groups of digits before the decimal point in formatted monetary quantities.
  • char *mon_grouping
    • A string whose elements indicate the size of each group of digits in formatted monetary quantities.
  • char *positive_sign
    • The string used to indicate a nonnegative formatted monetary quantity.
  • char *negative_sign
    • The string used to indicate a negative formatted monetary quantity.
  • char int_frac_digits
    • The number of fractional digits to be displayed in internationally formatted monetary quantities.
  • char frac_digits
    • The number of fractional digits to be displayed in formatted monetary quantities.
  • char p_cs_precedes
    • Set to 1 if the currency_symbol precedes the value for a nonnegative formatted monetary quantity; set to 0 if the currency_symbol follows the value.
  • char p_sep_by_space
    • Set to 1 if the currency_symbol is separated by a space from the value for a nonnegative formatted monetary quantity; set to 0 if there is no space.
  • char n_cs_precedes
    • Set to 1 if the currency_symbol precedes the value for a negative formatted monetary quantity; set to 0 if the currency_symbol follows the value.
  • char n_sep_by_space
    • Set to 1 if the currency_symbol is separated by a space from the value for a negative formatted monetary quantity; set to 0 if there is no space.
  • char p_sign_posn
    • Set to a value indicating the positioning of the positive_sign for a nonnegative formatted monetary quantity.
  • char n_sign_posn
    • Set to a value indicating the positioning of the negative_sign for a negative formatted monetary quantity.
  
  The elements of grouping and mon_grouping are interpreted according to the following:
  • CHAR_MAX---no further grouping is to be performed.
  • 0---the previous element is to be repeatedly used for the remainder of the digits.
  • other---the integer value is the number of digits that comprise the current group. The next element is examined to determine the size of the next group of digits before the current group.
  
  The value of p_sign_posn and n_sign_posn is interpreted as follows:
  • 0---parentheses surround the quantity and currency_symbol
  • 1---the sign string precedes the quantity and currency_symbol
  • 2---the sign string follows the quantity and currency_symbol
  • 3---the sign string immediately precedes the currency_symbol
  • 4---the sign string immediately follows the currency_symbol
  
  The localeconv function returns a pointer to the filled in structure. The structure must not be modified by the program, but might be overwritten by subsequent calls to localeconv or to setlocale with categories LC_ALL, LC_MONETARY, or LC_NUMERIC.

9.7 Mathematics (<math.h>)

The <math.h> header file defines types, macros, and several mathematical functions. The functions take double arguments and return double-precision values.

The behavior of the functions in this header is defined for all representable values of their input arguments. Each function executes as if it were a single operation, without generating any externally visible exceptions.

For all functions, a domain error occurs if an input argument is outside the domain over which the mathematical function is defined. The description of each function lists any domain errors. On a domain error, the function returns an implementation-defined value; the value of the EDOM macro is stored in errno.

For all functions, a range error occurs if the result of the function cannot be represented as a double value. If the result overflows (the magnitude of the result is so large that it cannot be represented in an object of the specified type), the function returns the value of the macro HUGE_VAL, with the same sign (except for the tan function) as the correct value of the function; the value of the ERANGE macro is stored in errno. If the result underflows (the magnitude of the result is so small that it cannot be represented in an object of the specified type), the function returns 0; whether the value of the ERANGE macro is stored in errno is implementation-defined.

Macros

HUGE_VAL

• Expands to a positive double expression.

INFINITY

• Expands to a constant expression of type float representing positive or unsigned infinity, if available; otherwise, expands to a positive constant of type float that overflows at translation time.

NAN

• Expands to a constant expression of type float representing a quiet NaN.

Trigonometric Functions

double acos(double x);

• Returns the value, in radians, of the arc cosine of x in the range [0, pi]. A domain error occurs for arguments not in the interval [ - 1,+1].

double asin(double x);

• Returns the value, in radians, of the arc sine of x in the range [-pi/2,+pi/2]. A domain error occurs for arguments not in the interval [ - 1,+1].

double atan(double x);

• Returns the value, in radians, of the arc tangent of x in the range [-pi/2,+pi/2].

double atan2(double y, double x);

• Returns the value, in radians, of the arc tangent of y/x, using the signs of both arguments to determine the quadrant of the return value. The value returned is in the range [-pi,+pi]. A domain error may occur if both arguments are 0.

double cos(double x);

• Returns the value, in radians, of the cosine of x.

double sin(double x);

• Returns the value, in radians, of the sine of x.

double tan(double x);

• Returns the value, in radians, of the tangent of x.

Hyperbolic Functions

double cosh(double x);

• Returns the value of the hyperbolic cosine of x. A range error occurs if the magnitude of x is too large.

double sinh(double x);

• Returns the value of the hyperbolic sine of x. A range error occurs if the magnitude of x is too large.

double tanh(double x);

• Returns the value of the hyperbolic tangent of x.

Exponential and Logarithmic Functions

double exp(double x);

• Returns the value of the exponential function of x. A range error occurs if the magnitude of x is too large.

double frexp(double value, int *eptr);

• Breaks the floating-point number value into a normalized fraction in the interval [1/2, 1) or 0, which it returns, and an integral power of 2, which it stores in the int object pointed to by eptr. If value is 0, both parts of the result are 0.

double ldexp(double x, int exp);

• Multiplies a floating-point number by an integral power of 2, and returns the value x x 2^exp. A range error may occur.

double log(double x);

• Returns the natural logarithm of x. A domain error occurs if the argument is negative. A range error may occur if the argument is 0.

double log10(double x);

• Returns the base-ten logarithm of x. A domain error occurs if x is negative. A range error may occur if x is 0.

double modf(double value, double *iptr);

• Breaks the argument value into integral and fractional parts, each of which has the same sign as the argument. The modf function returns the signed fractional part and stores the integral part as a double in the object pointed to by iptr.

Power Functions

double pow(double x, double y);

• Returns the value x^y. A domain error occurs if x is negative and y is not an integral value. A domain error occurs if the result cannot be represented when x is 0 and y is less than or equal to 0. A range error may occur.

double sqrt(double x);

• Returns the nonnegative square root of x. A domain error occurs if x is negative.

Nearest Integer, Absolute Value, and Remainder Functions

double ceil(double x);

• Returns the smallest integral value not less than x.

double fabs(double x);

• Returns the absolute value of a floating-point number x.

double floor(double x);

• Returns the largest integral value not greater than x.

double fmod(double x, double y);

• Computes the floating-point remainder of x/y. The fmod function returns the value x - i * y, for some integer i such that if y is nonzero, the result has the same sign as x and magnitude less than the magnitude of y. The function returns 0 if y is 0.

9.8 Nonlocal Jumps (<setjmp.h>)

The <setjmp.h> header file contains declarations that provide a way to avoid the normal function call and return sequence, typically to permit an intermediate return from a nested function call.

Macro

int setjmp(jmp_buf env)

• Sets up the local jmp_buf buffer and initializes it for the jump (the jump itself is performed with longjmp.) This macro saves the program's calling environment in the environment buffer specified by the env argument for later use by the longjmp function. If the return is from a direct invocation, setjmp returns 0. If the return is from a call to longjmp, setjmp returns a nonzero value.

Type

jmp_buf

• An array type suitable for holding the information needed to restore a calling environment.

Function

• Restores the context of the environment buffer env that was saved by invocation of the setjmp function in the same invocation of the program. The longjmp function does not work if called from a nested signal handler; the result is undefined.
  The value specified by value is passed from longjmp to setjmp. After longjmp is completed, program execution continues as if the corresponding invocation of setjmp had just returned value. If value is passed to setjmp as 0, it is converted to 1.

9.9 Signal Handling (<signal.h>)

The <signal.h> header file declares a type and two functions and defines several macros for handling exception conditions that might be reported during program execution.

Type

sig_atomic_t

• The integral type of an object that can be accessed as an atomic entity, even in the presence of asynchronous interrupts.

Macros

SIG_DFL
SIG_ERR
SIG_IGN

• Expand to constant expressions with distinct values that have a type compatible with the second argument to, and the return value of, the signal function, and whose value compares unequal to the address of any declarable function.

Functions

void (*signal(int sig, void (*handler) (int))) (int);

• Determines how subsequent signals are handled. Signals are handled in the following way:
  1. If the value of handler is SIG_DFL, default handling of that signal occurs.
  2. If the value of handler is SIG_IGN, the signal is ignored.
  3. Otherwise, when that signal occurs, a function pointed to by handler is called with the argument of the type of signal. Such a function is called a signal handler. Valid signals include:
     • SIGABRT---abnormal termination, such as from the abort function
     • SIGFPE---arithmetic error, such as zero divide or overflow
     • SIGILL---invalid function image, such as an invalid instruction
     • SIGINT---interactive attention, such as an interrupt
     • SIGSEGV---invalid access to storage, such as outside of memory limit
     • SIGTERM---termination request sent to the program
  
  Any other signals are operating-system dependent.
  If the request can be honored, the signal function returns the value of handler for the most recent call to signal for the specified signal sig. Otherwise, a value of SIG_ERR is returned and an implementation-defined positive value is stored in errno.

int raise(int sig);

• Sends the signal sig to the executing program. The raise function returns 0 if successful and nonzero if unsuccessful.