ISO/ IEC JTC1/SC22/WG14 N749

                           Document Number:  WG14 N749/J11 97-112


                               C9X Revision Proposal
                               =====================

       Title: LIA-1 Binding: <stdlia.h>
       Author: Fred J. Tydeman
       Author Affiliation: Tydeman Consulting
       Postal Address: 3711 Del Robles Dr., Austin, Texas, USA, 78727
       E-mail Address: tydeman@tybor.com
       Telephone Number: +1 (512) 255-8696
       Fax Number: +1 (512) 255-8696
       Sponsor: WG14
       Date: 1997-09-21
       Proposal Category:
          __ Editorial change/non-normative contribution
          __ Correction
          Y_ New feature
          __ Addition to obsolescent feature list
          __ Addition to Future Directions
          __ Other (please specify)  ______________________________
       Area of Standard Affected:
          __ Environment
          __ Language
          __ Preprocessor
          Y_ Library
             Y_ Macro/typedef/tag name
             Y_ Function
             Y_ Header
          __ Other (please specify)  ______________________________
       Prior Art: None known.
       Target Audience: Programmers writing programs that perform a
       significant amount of numeric processing.___________________
       Related Documents (if any):
        WG14/N758 C9X and LIA-1 informative annex.
        WG14/N756 LIA-1 Binding: Arithmetic exception => SIGFPE,
        WG14/N755 LIA-1 Binding: <fenv.h> to <stdmath.h>,
        WG14/N753 LIA-1 Binding: Rationale,
        WG14/N752 LIA-1 Binding: Optional parts annex,
        WG14/N751 LIA-1 Binding: Combined LIA-1 + IEC-559 annex,
        WG14/N750 LIA-1 Binding: LIA-1 annex,
        WG14/N748 LIA-1 Binding: Adding 'pole' from LIA-2,
        WG14/N747 IEC 559 Binding: Signaling NaNs,
        WG14/N693 Type-Generic Math Functions,
        WG14/N528 C Binding for LIA-1,
        WG14/N488 LIA-2 (math library),
        WG14/N487 LIA-1 (arithmetic),
        WG14/N486 LIA Overview,
        WG14/N463 Impact of adding LIA-1,
        WG14/N461 C Binding of LIA-1
       Proposal Attached: _Y Yes __ No, but what's your interest?

       Abstract: These changes are the fundamental changes to C to
       allow support of ISO 10967-1 (LIA-1).  They are being added
       in their own header <stdlia.h>

       Proposal:

       Note: The '*' characters in the lefthand column are not part
       of the proposal (they are useful for emacs M-x outline mode)

       In the following, bold text, italic text,
       <TT>code sample</TT> are the conventions used to indicate
       text different from normal.

*      -- Add to 6.8.6 Pragma directive:

           #pragma STDC LIA_NOTIFY { UNDEF | IGNORE | FLAGS | TRAP }

       and add to the list of forward references:

       the LIA_NOTIFY pragma (7.x.4.1.1)

*      -- Add a new library section (here called 7.x)
**     7.x Notification and additional utilities <stdlia.h>.

       The header <stdlia.h> declares several macros and functions
       to support Language Independent Arithmetic.  These are
       additional limits (characteristics of the integer and
       floating-point types), general integer utilities,
       mathematical functions, notification and access to the
       integer environment.  The integer environment refers
       collectively to any integer status flags and control modes
       supported by the implementation[footnote].  An integer
       status flag is a system variable whose value is set as a
       side effect of the arithmetic to provide auxiliary
       information.  An integer control mode is a system
       variable whose value may be set by the user to affect the
       subsequent behavior of the arithmetic.

       [footnote].  This header is designed to support the
       notification indicators (here called exception status flags)
       required by LIA-1, and other similar integer state
       information.  Also it is designed to facilitate code
       portability among all systems.

***    7.x.1 Limits

       Several macros are declared to provide additional
       information beyond <limits.h> and <float.h>
       about the characteristics of the integer and floating-point
       types.

       All integral values in the <stdlia.h> header, shall be
       constant expressions suitable for use in #if preprocessing
       directives; all floating values shall be constant
       expressions.  Most floating-point related macros have
       separate names for all three floating-point types.

****   7.x.1.1 Integer limits

       The treatment of out-of-bounds results

           0   undefined behavior
           1   wrap (similar to unsigned)
           2   notification

       for the signed integer types int, long and
       long long are characterized by

           INT_OUT_OF_BOUNDS

****   7.x.1.2 Floating-point limits

       The values given in the following list shall be replaced by
       implementation-defined expressions that shall be equal or
       lesser in magnitude (absolute value) to those shown, with
       the same sign:

       -- maximum rounding error of, at least the operations,
       +, -, *, and /, in terms of Units in Last Place (ULPs),
       for each floating-point type,

           FLT_RND_ERR   7.0

       In general, for normal results, the rounding error, re, is
       defined by:

          | tr - cr | <= re * ulp(cr)

       where

          tr = infinitely precise true result
          cr = computed result

       For the full details, including difference between normals
       and subnormals, see LIA-1 subclause 5.2.8 Rounding
       constants.

       The values given in the following list shall be replaced by
       implementation-defined expressions that shall be equal or
       greater in magnitude (absolute value) to those shown, with
       the same sign:

       -- minimum positive floating-point number, b**emin-p if
       subnormalized numbers are supported, else b**emin-1,

           FLT_TRUE_MIN   1E-37
           DBL_TRUE_MIN   1E-37
           LDBL_TRUE_MIN  1E-37

       The level of support for subnormalized numbers is
       characterized by the values

          -1   indeterminable
           0   not supported
           1   fully supported
           2   treated as zero

       for the floating types float, double, long double

           FLT_SUBNORMAL
           DBL_SUBNORMAL
           LDBL_SUBNORMAL

       respectively.

       All other negative values for *_SUBNORMAL
       characterize implementation-defined behavior.

       The values given in the following list shall be replaced by
       implementation-defined expressions:

       -- boolean value (0 or 1) to indicate if the corresponding
       type conforms to IEC 559,

           FLT_IEC_559
           DBL_IEC_559
           LDBL_IEC_559

       Example 2 in <float.h> is supplemented with these:

           FLT_RND_ERR    0.5
           FLT_IEC_559    1
           FLT_SUBNORMAL  1
           FLT_TRUE_MIN   1.40129846E-45
           DBL_IEC_559    1
           DBL_SUBNORMAL  1
           DBL_TRUE_MIN   4.94065646E-324


***    7.x.2 Mathematics

       Several functions are declared to provide additional
       capability beyond <math.h>.  Most synopses specify a
       function which takes one or more double arguments and
       returns a double value; for each such function, there
       are functions with the same name but with f and
       l suffixes which are corresponding functions with
       float and long double arguments and return
       values.

****   7.x.2.1 Exponential and logarithmic functions

*****  7.x.2.1.1 The fracrep function

       Synopsis

           #include <stdlia.h>
           double fracrep(double x);

       Description

       The fracrep function extracts the fraction of the
       model representation of x, as a signed normalized
       fraction in the format of x.

       Returns

       The fracrep function returns the value y, such
       that y is a double with magnitude in the
       interval [1/FLT_RADIX, 1) or zero, and x equals
       y times FLT_RADIX raised to the power
       (logb(x)+1.0).  The value returned for zero is 0.0.


*****  7.x.2.1.2 The ulp function

       Synopsis

           #include <stdlia.h>
           double ulp(double x);

       Description

       The ulp function computes the value of a Unit in the
       Last Place of x.  A domain error occurs if the
       argument is zero.  A range error occurs if the magnitude of
       x is too small and subnormals are not supported.

       Returns

       The ulp function returns the value FLT_RADIX
       raised to the power (logb(x)+1-p).  p
       is the precision of the floating type and is one of
       *_MANT_DIG.

****   7.x.2.2 Sign function

*****  7.x.2.2.1 The fsgn function

       Synopsis

           #include <stdlia.h>
           double fsgn(double x);

       Description

       The fsgn function computes the sign of a
       floating-point number x.  Positive floating-point
       numbers have a sign of +1.0, negative floating-point numbers
       have a sign of -1.0, and zero has a sign of 0.0.

       Returns

       The fsgn function returns the sign.

****   7.x.2.3 Manipulation functions

*****  7.x.2.3.1 The fsucc function

       Synopsis

           #include <stdlia.h>
           double fsucc(double x);

       Description

       The fsucc function determines the next representable
       value, in the type of the function, after x in the
       direction of +infinity.  A range error occurs if x is
       the largest positive finite number.

       Returns

       The fsucc function returns the smallest representable
       value, of the same type, greater than x.


*****  7.x.2.3.2 The fpred function

       Synopsis

           #include <stdlia.h>
           double fpred(double x);

       Description

       The fpred function determines the next representable
       value, in the type of the function, after x in the
       direction of -infinity.  A range error occurs if x is
       the largest negative finite number.

       Returns

       The fpred function returns the largest representable
       value, of the same type, less than x.


*****  7.x.2.3.3 The truncto function

       Synopsis

           #include <stdlia.h>
           double truncto(double x, int n);

       Description

       The truncto function truncates (rounds toward zero)
       x to n digits of precision.

       Returns

       The truncto function returns the value for normal
       numbers: sign(x) * floor(|x|/(FLT_RADIX**(expon(x)-n))) *
       FLT_RADIX**(expon(x)-n) and for subnormal numbers: sign(x) *
       floor(|x|/(FLT_RADIX**(emin-n))) * FLT_RADIX**(emin-n).  If
       n is less than 1, returns 0.  If n is greater
       than precision of x, returns x.


*****  7.x.2.3.4 The roundto function

       Synopsis

           #include <stdlia.h>
           double roundto(double x, int n);

       Description

       The roundto function rounds (rounds to biased nearest
       with ties going away from zero) x to n digits
       of precision.  A range error may occur.

       Returns

       The roundto function returns the value for normal
       numbers: sign(x) * floor(|x|/(FLT_RADIX**(expon(x)-n))+0.5)
       * FLT_RADIX**(expon(x)-n) and for subnormal numbers: sign(x)
       * floor(|x|/(FLT_RADIX**(emin-n))+0.5) * FLT_RADIX**(emin-n).
       If n is less than 1, returns 0.  If n is
       greater than precision of x, returns x.


****   7.x.2.4 Conversion macros

       The following subclauses provide macros that convert from
       floating-point type to integral type using round to nearest
       rounding.  The round to nearest can be biased (ties round
       away from zero) or unbiased (such as IEC 559 round to
       nearest even).  In the synopses in this subclause,
       real-floating indicates that the argument must be an
       expression of real floating type.

*****  7.x.2.4.1 The icvt macro

       Synopsis

           #include <stdlia.h>
           int icvt(real-floating x);

       Description

       The icvt macro rounds its argument to the nearest
       integral value.  If the rounded value is outside the range
       of int, the numeric result is unspecified.  A
       range error may occur if the magnitude of x
       is too large.

       Returns

       The icvt macro returns the rounded integral value.

*****  7.x.2.4.2 The lcvt macro

       Synopsis

           #include <stdlia.h>
           long lcvt(real-floating x);

       Description

       The lcvt macro is equivalent to the icvt
       macro, except that the returned value has type long.

*****  7.x.2.4.3 The llcvt macro

       Synopsis

           #include <stdlia.h>
           long long llcvt(real-floating x);

       Description

       The llcvt macro is equivalent to the icvt
       macro, except that the returned value has type long
       long.

*****  7.x.2.4.4 The uicvt macro

       Synopsis

           #include <stdlia.h>
           unsigned int uicvt(real-floating x);

       Description

       The uicvt macro rounds its argument to the nearest
       integral value.  If the rounded value is outside the range
       of unsigned int, the rounded value is wrapped modulo
       (UINT_MAX+1).

       Returns

       The uicvt macro returns the rounded integral value.

*****  7.x.2.4.5 The ulcvt macro

       Synopsis

           #include <stdlia.h>
           unsigned long ulcvt(real-floating x);

       Description

       The ulcvt macro is equivalent to the uicvt
       macro, except that the returned value has type unsigned
       long.

*****  7.x.2.4.6 The ullcvt macro

       Synopsis

           #include <stdlia.h>
           unsigned long long ullcvt(real-floating x);

       Description

       The ullcvt macro is equivalent to the uicvt
       macro, except that the returned value has type unsigned
       long long.


***    7.x.3 General utilities

       Several functions are declared to provide additional
       capability beyond <stdlib.h>.

****   7.x.3.1 The sgn function

       Synopsis

           #include <stdlia.h>
           int sgn(int j);

       Description

       The sgn function computes the sign of an integer
       j.  Positive integers have a sign of +1, negative
       integers have a sign of -1, and zero has a sign of 0.

       Returns

       The sgn function returns the sign.


****   7.x.3.2 The lsgn function

       Synopsis

           #include <stdlia.h>
           long int lsgn(long int j);

       Description

       The lsgn function is similar to the sgn
       function, except that the argument and returned value each
       have type long int.


****   7.x.3.3 The llsgn function

       Synopsis

           #include <stdlia.h>
           long long int llsgn(long long int j);

       Description

       The llsgn function is similar to the sgn
       function, except that the argument and returned value each
       have type long long int.


****   7.x.3.4 The modulo function

       Synopsis

           #include <stdlia.h>
           int modulo(int numer, int denom);

       Description

       The modulo function computes the modulus, that is,
       [Ed: math equation] numer-(floor(numer/denom)*denom).
       If denom is zero, the behavior is undefined.

       Returns

       The modulo function returns the modulus.


****   7.x.3.5 The lmodulo function

       Synopsis

           #include <stdlia.h>
           long int lmodulo(long int numer, long int denom);

       Description

       The lmodulo function is similar to the modulo
       function, except that the arguments and returned value each
       have type long int.


****   7.x.3.6 The llmodulo function

       Synopsis

           #include <stdlia.h>
           long long int llmodulo(long long int numer,
                                     long long int denom);

       Description

       The llmodulo function is similar to the modulo
       function, except that the arguments and returned value each
       have type long long int.


***    7.x.4 Notification

       Each macro

           INT_OVERFLOW
           INT_DIVBYZERO
           INT_INVALID

       is defined if and only if the implementation supports the
       exception by means of the functions in 7.x.4.2. The defined
       macros expand to integral constant expressions whose values
       are distinct powers of 2.

       The macro

           INT_ALL_EXCEPT

       is simply the bitwise OR of all integer exception macros
       defined by the implementation.

       These next three macros describe what notifications happen
       for conversions of values from floating-point types to
       integral types for some specific values.

       -- value to indicate what notification happens for
       NaNs,

           FP2INT_OF_NAN

       It should be INT_INVALID, but may be FE_INVALID or another
       exception indicator macro.

       -- value to indicate what notification happens for
       infinities,

           FP2INT_OF_INF

       It should be INT_INVALID, but may be FE_INVALID or another
       exception indicator macro.

       -- value to indicate what notification happens for
       out-of-bounds integral values,

           FP2INT_OF_LARGE

       It should be INT_OVERFLOW, but may be FE_INVALID or another
       exception indicator macro, when INT_OUT_OF_BOUNDS is 2
       (notify).

       The FP2INT_OF_LARGE macro shall be 0 (meaning no exception)
       when INT_OUT_OF_BOUNDS is 1 (wrap).

       The macro

           DISTINGUISH_INT_DIV_BY_ZERO

       has a boolean value (0 or 1) to indicate if 0/0 can be
       distinguished from non-zero/zero.  If this is true,
       then 0/0 will notify as invalid, else, as divbyzero.

       The macro

           DISTINGUISH_FP_DIV_BY_ZERO

       has a boolean value (0 or 1) to indicate if 0.0/0.0 can be
       distinguished from finite non-zero/zero.  If this is true,
       then 0.0/0.0 will notify as invalid, else, as divbyzero.

****   7.x.4.1 The LIA_NOTIFY pragma and macro

*****  7.x.4.1.1 The LIA_NOTIFY pragma

       Synopsis

           #include <stdlia.h>
           #pragma STDC LIA_NOTIFY { UNDEF | IGNORE | FLAGS | TRAP }

       Description

       The LIA_NOTIFY pragma provides a means to inform the
       implementation which notification mechanism is to be
       used[footnote].  The pragma can occur either outside
       external declarations or preceding all explicit declarations
       and statements inside a compound statement.  When outside
       external declarations, the pragma takes effect from its
       occurrence until another LIA_NOTIFY pragma is encountered,
       or until the end of the translation unit.  When inside a
       compound statement, the pragma takes effect from its
       occurrence until another LIA_NOTIFY pragma is encountered
       (within a nested compound statement), or until the end of
       the compound statement; at the end of a compound statement
       the state for the pragma is restored to its condition just
       before the compound statement.  The effect of this pragma in
       any other context is undefined.  If part of a program tests
       flags or runs under non-default mode settings, but was
       translated with the state for the LIA_NOTIFY pragma UNDEF,
       then the behavior of that program is undefined.  

       UNDEF shall cause notifications to be undefined behaviour.
       This matches C89/C95.

       IGNORE shall cause notifications to be ignored.  Traps shall
       not be taken.  It is implementation defined if status flags
       will be set.  An implementation defined continuation value
       will be used in place of the failing arithmetic operation.
       This causes the final check of the status flags at program
       termination to be suppressed. This allows the optimizations
       mentioned in the subsection on "FENV_ACCESS off" to be done.

       FLAGS shall cause notifications to set a status flag and
       proceed with a continuation value in place of the arithmetic
       failure.  It is implementation defined if the final check of
       some status flags at program termination will be performed.

       TRAP shall cause notifications to trap.  It is
       implementation defined if a trap shall be turned into a
       raise of some signal, or result in program termination.

       Until <stdlia.h> is included, the default state for the
       pragma shall be UNDEF.  Once <stdlia.h> is included, the
       default state for the pragma is implementation-defined and
       shall be one of FLAGS, TRAP, (or DYNAMIC if supported).

       It is implementation defined if the different translation
       units that comprise a program are translated with different
       LIA_NOTIFY states.

       It is implementation defined which of INT_OVERFLOW,
       INT_DIVBYZERO, INT_INVALID, FE_INEXACT,
       FE_UNDERFLOW, FE_OVERFLOW,
       FE_DIVBYZERO, and FE_INVALID are defined.
       Those defined determine the set of notifications being
       checked.

       [footnote]Notification is the process by which a program is
       informed that an arithmetic operation cannot be performed.

*****  7.x.4.1.2 The LIA_NOTIFY macro

       The macro

           LIA_NOTIFY

       has one of these values (with corresponding meaning)

        0 Undefined, like C89/C95
        1 Notifications are ignored
        2 All notifications will set flags
        3 All notifications will trap
        4 Program switches between flags and traps at runtime

       to indicate the current way notifications are being handled.
       That is, the macro tracks the state of the LIA_NOTIFY
       pragma.

****   7.x.4.2 Exception flags

       The following functions provide access to the integer
       exception flags.  They support the basic abstraction of
       flags that are either set or clear.  The int input
       argument for the functions represents a subset of integer
       exceptions, and can be constructed by bitwise ORs of the
       integer exception macros, for example (INT_DIVBYZERO |
       INT_INVALID).  For other argument values the behavior of
       these functions is undefined.


*****  7.x.4.2.1 The ieclearexcept function

       Synopsis

           #include <stdlia.h>
           void ieclearexcept(int excepts);

       Description

       The ieclearexcept function clears the supported integer
       exceptions represented by its argument.

*****  7.x.4.2.2 The ieraiseexcept function

       Synopsis

           #include <stdlia.h>
           void ieraiseexcept(int excepts);

       Description

       The ieraiseexcept function raises the supported integer
       exceptions represented by its argument.  The order in which
       these exceptions are raised is unspecified.

*****  7.x.4.2.3 The ietestexcept function

       Synopsis

           #include <stdlia.h>
           int ietestexcept(int excepts);

       Description

       The ietestexcept function determines which of a specified
       subset of the integer exception flags are currently set.
       The excepts argument specifies the integer exception
       flags to be queried.[footnote]

       [footnote].  This mechanism allows testing several
       exceptions with just one function call.

       Returns

       The ietestexcept function returns the value of the bitwise
       OR of the integer exception macros corresponding to the
       currently set exceptions included in excepts.


*      -- Add to 7.? Type-generic math <tgmath.h>:
       <stdlia.h> after all occurances of <math.h>

**     -- Add to 7.?.1 Type-generic macros
***    -- Add to the list of real (but not complex) functions that
       starts atan2, exp2:

           fracrep
           ulp
           fsgn
           fsucc
           fpred
           truncto
           roundto


*      -- Add to Annex D Library summary
**     -- Add new subclause: D.x Notification and additional utilities <stdlia.h>
***    -- Add new subclause: D.x.1 Limits
****   -- Add new subclause: D.x.1.1 Integral limits

           INT_OUT_OF_BOUNDS

****   -- Add new subclause: D.x.1.2 Floating-point limits

           FLT_RND_ERR
           FLT_TRUE_MIN
           DBL_TRUE_MIN
           LDBL_TRUE_MIN
           FLT_SUBNORMAL
           DBL_SUBNORMAL
           LDBL_SUBNORMAL
           FLT_IEC_559
           DBL_IEC_559
           LDBL_IEC_559

***    -- Add new subclause: D.x.2 Mathematics

       [Note to editor: If we need to include the float and long
       double versions, here, and in <math.h> and <complex.h>,
       please add them.]

           double fracrep(double x);
           double ulp(double x);
           double fsgn(double x);
           double fsucc(double x);
           double fpred(double x);
           double truncto(double x, int n);
           double roundto(double x, int n);

***    -- Add new subclause: D.x.3 General utilities

           int icvt(real-floating x);
           long lcvt(real-floating x);
           long long llcvt(real-floating x);
           unsigned int uicvt(real-floating x);
           unsigned long ulcvt(real-floating x);
           unsigned long long ullcvt(real-floating x);
           int sgn(int j);
           long int lsgn(long int j);
           long long int llsgn(long long int j);
           int modulo(int numer, int denom);
           long int lmodulo(long int numer, long int denom);
           long long int llmodulo(long long int numer,
                                     long long int denom);

***    -- Add new subclause: D.x.4 Notification

           INT_OVERFLOW
           INT_DIVBYZERO
           INT_INVALID
           INT_ALL_EXCEPT
           FP2INT_OF_NAN
           FP2INT_OF_INF
           FP2INT_OF_LARGE
           DISTINGUISH_INT_DIV_BY_ZERO
           DISTINGUISH_FP_DIV_BY_ZERO
           #pragma STDC LIA_NOTIFY { UNDEF | IGNORE | FLAGS | TRAP }
           LIA_NOTIFY
           void ieclearexcept(int excepts);
           void ieraiseexcept(int excepts);
           int ietestexcept(int excepts);


*      -- Add to Annex F IEC 559 Floating-Point Arithmetic:
**     -- Add new subclause F.10 <stdlia.h>:
***    F.10.1 Exponential and logarithmic functions

****   F.10.1.1 The fracrep function

           fracrep(-0.0) returns -0.0
           fracrep(+/-INFINITY) returns +/-INFINITY

****   F.10.1.2 The ulp function

           ulp(-0.0) returns a NaN and raises the invalid
               exception.
           ulp(+/-INFINITY) returns a NaN and raises the invalid
               exception.
           ulp(1.0) returns DBL_EPSILON.

***    F.10.2 Sign function

****   F.10.2.1 The fsgn function

           fsgn(-0.0) returns -0.0
           fsgn(+INFINITY) returns +1.0
           fsgn(-INFINITY) returns -1.0
           fsgn(NaN) returns the same NaN.

***    F.10.3 Manipulation functions

****   F.10.3.1 The fsucc function

           fsucc(-0.0) returns +DBL_TRUE_MIN
           fsucc(+INFINITY) returns +INFINITY
           fsucc(+DBL_MAX) returns +INFINITY and raises overflow.

****   F.10.3.2 The fpred function

           fpred(-0.0) returns -DBL_TRUE_MIN
           fpred(-INFINITY) returns -INFINITY
           fpred(-DBL_MAX) returns -INFINITY and raises overflow.

****   F.10.3.3 The truncto function

           truncto(-0.0, n) returns -0.0 for any n.
           truncto(+/-INFINITY, n) returns +/-INFINITY for any n.
           truncto(NaN, n) returns the same NaN for any n.

****   F.10.3.4 The roundto function

           roundto(-0.0, n) returns -0.0 for any n.
           roundto(+/-INFINITY, n) returns +/-INFINITY for any n.
           roundto(NaN, n) returns the same NaN for any n.

***    F.10.4 Conversion macros

****   F.10.4.1 The icvt macro

           icvt(NaN) returns an unspecified value and raises
               FP2INT_OF_NAN.
           icvt(+/-INFINITY) returns an unspecified value and
               raises FP2INT_OF_INF.

****   F.10.4.2 The lcvt macro

           lcvt(NaN) returns an unspecified value and raises
               FP2INT_OF_NAN.
           lcvt(+/-INFINITY) returns an unspecified value and
               raises FP2INT_OF_INF.

****   F.10.4.3 The llcvt macro

           llcvt(NaN) returns an unspecified value and raises
               FP2INT_OF_NAN.
           llcvt(+/-INFINITY) returns an unspecified value and
               raises FP2INT_OF_INF.

****   F.10.4.4 The uicvt macro

           uicvt(NaN) returns an unspecified value and raises
               FP2INT_OF_NAN.
           uicvt(+/-INFINITY) returns an unspecified value and
               raises FP2INT_OF_INF.

****   F.10.4.5 The ulcvt macro

           ulcvt(NaN) returns an unspecified value and raises
               FP2INT_OF_NAN.
           ulcvt(+/-INFINITY) returns an unspecified value and
               raises FP2INT_OF_INF.

****   F.10.4.6 The ullcvt macro

           ullcvt(NaN) returns an unspecified value and raises
               FP2INT_OF_NAN.
           ullcvt(+/-INFINITY) returns an unspecified value and
               raises FP2INT_OF_INF.