Cross Reference: /ast/src/lib/libast/features/float

	float revision 3f54fd611f536639ec30dd53c48e5ec1897cc7d9
set prototyped
set nooptimize
set stdio FEATURE/standards
hdr float,limits,math,values
lib,npt frexp,frexpl,ldexp,ldexpl,finite,finitel,isinfl,isnanl,copysign,copysignl FEATURE/standards math.h -lm
lib fpclassify -lm note{ fpclassify present and works }end link{
        #include <sys/types.h>
        #include <sys/stat.h>
        #include <stdlib.h>
        #include <unistd.h>
        #include <math.h>
        int main() { return fpclassify(-0.0); }
    }end
lib isinf -lm note{ isinf present and works }end link{
        #include <sys/types.h>
        #include <sys/stat.h>
        #include <stdlib.h>
        #include <unistd.h>
        #include <math.h>
        int main() { return isinf(-0.0); }
    }end
lib isnan -lm note{ isnan present and works }end link{
        #include <sys/types.h>
        #include <sys/stat.h>
        #include <stdlib.h>
        #include <unistd.h>
        #include <math.h>
        int main() { return isnan(-0.0); }
    }end
lib signbit -lm note{ signbit present and works }end link{
        #include <sys/types.h>
        #include <sys/stat.h>
        #include <stdlib.h>
        #include <unistd.h>
        #include <math.h>
        int main() { return signbit(-0.0); }
    }end

tst ast_no_um2fm note{ no unsigned intmax => floatmax cast }end nolink{
    #include "FEATURE/common"
    int
    main()
    {
        _ast_fltmax_t       f = 0;
        unsigned _ast_intmax_t  i = 0;
        f = i;
        i = f;
        return f == i;
    }
}end

tst ast_mpy_overflow_fpe note{ fpe on mpy overflow }end noexecute{
    int
    main()
    {
        float   f;
        float   p;
        int i;

        i = 0;
        p = f = 1.0;
        do
        {
            p = f;
            f *= 2.0;
        } while (f != p && ++i < 1024);
        return 0;
    }
}end

tst ast_div_underflow_fpe note{ fpe on div underflow }end noexecute{
    int
    main()
    {
        float   f;
        float   p;
        int i;

        i = 0;
        p = f = 1.0;
        do
        {
            p = f;
            f /= 2.0;
        } while (f != p && ++i < 1024);
        return 0;
    }
}end

macro{
    #if _hdr_float
    #include <float.h>
    #endif
    #if _hdr_limits
    #include <limits.h>
    #endif
    #if _hdr_math
    #include <math.h>
    #endif
    #if _hdr_values
    #include <values.h>
    #endif

    #if !defined(FLT_MIN_EXP) && defined(FMINEXP)
    #define FLT_MIN_EXP FMINEXP
    #endif
    #if !defined(FLT_MIN) && defined(MINFLOAT)
    #define FLT_MIN     MINFLOAT
    #endif
    #if !defined(FLT_MAX_EXP) && defined(FMAXEXP)
    #define FLT_MAX_EXP FMAXEXP
    #endif
    #if !defined(FLT_MAX) && defined(MAXFLOAT)
    #define FLT_MAX     MAXFLOAT
    #endif

    #if !defined(DBL_MIN_EXP) && defined(DMINEXP)
    #define DBL_MIN_EXP DMINEXP
    #endif
    #if !defined(DBL_MIN) && defined(MINDOUBLE)
    #define DBL_MIN     MINDOUBLE
    #endif
    #if !defined(DBL_MAX_EXP) && defined(DMAXEXP)
    #define DBL_MAX_EXP DMAXEXP
    #endif
    #if !defined(DBL_MAX) && defined(MAXDOUBLE)
    #define DBL_MAX     MAXDOUBLE
    #endif

    <<"#include <ast_common.h>">>
    #if _hdr_float
    <<"#include <float.h>">>
    #endif
    #if _hdr_math
    <<"#include <math.h>">>
    #endif
    #ifdef FLT_DIG
    <<"#ifndef FLT_DIG">>
    <<"#define FLT_DIG">>       FLT_DIG
    <<"#endif">>
    #endif
    #ifdef FLT_MAX
    <<"#ifndef FLT_MAX">>
    <<"#define FLT_MAX">>       FLT_MAX
    <<"#endif">>
    #endif
    #ifdef FLT_MAX_10_EXP
    <<"#ifndef FLT_MAX_10_EXP">>
    <<"#define FLT_MAX_10_EXP">>    FLT_MAX_10_EXP
    <<"#endif">>
    #endif
    #ifdef FLT_MAX_EXP
    <<"#ifndef FLT_MAX_EXP">>
    <<"#define FLT_MAX_EXP">>   FLT_MAX_EXP
    <<"#endif">>
    #endif
    #ifdef FLT_MIN
    <<"#ifndef FLT_MIN">>
    <<"#define FLT_MIN">>       FLT_MIN
    <<"#endif">>
    #endif
    #ifdef FLT_MIN_10_EXP
    <<"#ifndef FLT_MIN_10_EXP">>
    <<"#define FLT_MIN_10_EXP">>    FLT_MIN_10_EXP
    <<"#endif">>
    #endif
    #ifdef FLT_MIN_EXP
    <<"#ifndef FLT_MIN_EXP">>
    <<"#define FLT_MIN_EXP">>   FLT_MIN_EXP
    <<"#endif">>
    #endif

    #ifdef DBL_DIG
    <<"#ifndef DBL_DIG">>
    <<"#define DBL_DIG">>       DBL_DIG
    <<"#endif">>
    #endif
    #ifdef DBL_MAX
    <<"#ifndef DBL_MAX">>
    <<"#define DBL_MAX">>       DBL_MAX
    <<"#endif">>
    #endif
    #ifdef DBL_MAX_10_EXP
    <<"#ifndef DBL_MAX_10_EXP">>
    <<"#define DBL_MAX_10_EXP">>    DBL_MAX_10_EXP
    <<"#endif">>
    #endif
    #ifdef DBL_MAX_EXP
    <<"#ifndef DBL_MAX_EXP">>
    <<"#define DBL_MAX_EXP">>   DBL_MAX_EXP
    <<"#endif">>
    #endif
    #ifdef DBL_MIN
    <<"#ifndef DBL_MIN">>
    <<"#define DBL_MIN">>       DBL_MIN
    <<"#endif">>
    #endif
    #ifdef DBL_MIN_10_EXP
    <<"#ifndef DBL_MIN_10_EXP">>
    <<"#define DBL_MIN_10_EXP">>    DBL_MIN_10_EXP
    <<"#endif">>
    #endif
    #ifdef DBL_MIN_EXP
    <<"#ifndef DBL_MIN_EXP">>
    <<"#define DBL_MIN_EXP">>   DBL_MIN_EXP
    <<"#endif">>
    #endif

    #ifdef LDBL_DIG
    <<"#ifndef LDBL_DIG">>
    <<"#define LDBL_DIG">>      LDBL_DIG
    <<"#endif">>
    #endif
    #ifdef LDBL_MAX
    <<"#ifndef LDBL_MAX">>
    <<"#define LDBL_MAX">>      LDBL_MAX
    <<"#endif">>
    #endif
    #ifdef LDBL_MAX_10_EXP
    <<"#ifndef LDBL_MAX_10_EXP">>
    <<"#define LDBL_MAX_10_EXP">>   LDBL_MAX_10_EXP
    <<"#endif">>
    #endif
    #ifdef LDBL_MAX_EXP
    <<"#ifndef LDBL_MAX_EXP">>
    <<"#define LDBL_MAX_EXP">>  LDBL_MAX_EXP
    <<"#endif">>
    #endif
    #ifdef LDBL_MIN
    <<"#ifndef LDBL_MIN">>
    <<"#define LDBL_MIN">>      LDBL_MIN
    <<"#endif">>
    #endif
    #ifdef LDBL_MIN_10_EXP
    <<"#ifndef LDBL_MIN_10_EXP">>
    <<"#define LDBL_MIN_10_EXP">>   LDBL_MIN_10_EXP
    <<"#endif">>
    #endif
    #ifdef LDBL_MIN_EXP
    <<"#ifndef LDBL_MIN_EXP">>
    <<"#define LDBL_MIN_EXP">>  LDBL_MIN_EXP
    <<"#endif">>
    #endif
}end

tst - note{ missing floating point limits }end output{
    #include "FEATURE/common"
    #include <stdio.h>
    #if _hdr_float
    #include <float.h>
    #endif
    #if _hdr_limits
    #include <limits.h>
    #endif
    #if _hdr_math
    #include <math.h>
    #endif
    #if _hdr_values
    #include <values.h>
    #endif
    #include <signal.h>
    #ifdef SIGFPE
    static int caught = 0;
    #if _STD_
    static void catch(int sig)
    #else
    static void catch(sig) int sig;
    #endif
    {
        signal(sig, SIG_IGN);
        caught++;
    }
    #endif
    int
    main()
    {
        register int        i;
        register int        s;
        float           f;
        float           pf;
        float           mf;
        float           xf;
        double          d;
        double          pd;
        double          md;
        char*           fp;
    #if _ast_fltmax_double
        char*           fs = "";
        char*           ds = "";
    #else
        _ast_fltmax_t       l;
        _ast_fltmax_t       pl;
        _ast_fltmax_t       ml;
        char*           fs = "F";
        char*           ds = "";
        char*           ls = "L";
    #endif
        unsigned long       u;
        unsigned _ast_intmax_t  w;
        unsigned _ast_intmax_t  pw;
        unsigned _ast_intmax_t  x;
        unsigned short      us;
        unsigned int        ui;
        unsigned long       ul;
        unsigned _ast_intmax_t  uq;

    #ifdef SIGFPE
        signal(SIGFPE, catch);
    #endif
        printf("\n");
        printf("\n");
        us = 0;
        us = ~us;
        i = 0;
        while (us /= 10)
            i++;
        printf("#define USHRT_DIG       %d\n", i);
        ui = 0;
        ui = ~ui;
        i = 0;
        while (ui /= 10)
            i++;
        printf("#define UINT_DIG        %d\n", i);
        ul = 0;
        ul = ~ul;
        i = 0;
        while (ul /= 10)
            i++;
        printf("#define ULONG_DIG       %d\n", i);
        if (sizeof(uq) > sizeof(ul))
        {
            uq = 0;
            uq = ~uq;
            i = 0;
            while (uq /= 10)
                i++;
            printf("#define ULLONG_DIG      %d\n", i);
            printf("#define UINTMAX_DIG     ULLONG_DIG\n");
        }
        else
            printf("#define UINTMAX_DIG     ULONG_DIG\n");
        printf("\n");
        w = 1;
        do
        {
            pw = w;
            w *= 2;
            f = (_ast_intmax_t)w;
            x = (_ast_intmax_t)f;
        } while (w > pw && w == x);
        w = (pw - 1) + pw;
        u = ~0;
        if (u > w)
            u = w;
        printf("#define FLT_ULONG_MAX       %lu.0F\n", u);
        if (sizeof(w) > sizeof(u))
        {
            printf("#define FLT_ULLONG_MAX      %llu.0F\n", w);
            printf("#define FLT_UINTMAX_MAX     FLT_ULLONG_MAX\n");
        }
        else
        {
            printf("#define FLT_ULLONG_MAX      FLT_ULONG_MAX\n");
            printf("#define FLT_UINTMAX_MAX     FLT_ULONG_MAX\n");
        }
        u /= 2;
        w /= 2;
        printf("#define FLT_LONG_MAX        %lu.0F\n", u);
        if (sizeof(w) > sizeof(u))
        {
            printf("#define FLT_LLONG_MAX       %llu.0F\n", w);
            printf("#define FLT_INTMAX_MAX      FLT_LLONG_MAX\n");
        }
        else
        {
            printf("#define FLT_LLONG_MAX       FLT_LONG_MAX\n");
            printf("#define FLT_INTMAX_MAX      FLT_LONG_MAX\n");
        }
        u++;
        w++;
        printf("#define FLT_LONG_MIN        (-%lu.0F)\n", u);
        if (sizeof(w) > sizeof(u))
        {
            printf("#define FLT_LLONG_MIN       (-%llu.0F)\n", w);
            printf("#define FLT_INTMAX_MIN      FLT_LLONG_MIN\n");
        }
        else
        {
            printf("#define FLT_LLONG_MIN       FLT_LONG_MIN\n");
            printf("#define FLT_INTMAX_MIN      FLT_LONG_MIN\n");
        }
    #ifdef FLT_DIG
        s = FLT_DIG;
    #else
        f = pf = 1.0;
        s = -1;
        do
        {
            s++;
            f *= 10.0;
        } while (f != (f + pf));
    #endif
    #if defined(FLT_MIN) && defined(FLT_MIN_EXP)
        i = FLT_MIN_EXP;
        mf = FLT_MIN;
    #else
        i = 3;
        f = pf = 1.0;
        do
        {
            i--;
            mf = pf;
            pf = f;
            f /= 2.0;
        } while (f < pf);
    #ifdef FLT_MIN_EXP
        i = FLT_MIN_EXP;
    #endif
    #ifdef FLT_MIN
        mf = FLT_MIN;
    #endif
    #endif
    #ifndef FLT_DIG
        printf("#ifndef FLT_DIG\n");
        printf("#define FLT_DIG         %d\n", s);
        printf("#endif\n");
    #endif
    #ifndef FLT_MIN
        printf("#ifndef FLT_MIN\n");
        printf("#define FLT_MIN         %.*E%s\n", s + 1, mf, fs);
        printf("#endif\n");
    #endif
    #ifndef FLT_MIN_EXP
        printf("#ifndef FLT_MIN_EXP\n");
        printf("#define FLT_MIN_EXP     (%d)\n", i);
        printf("#endif\n");
    #endif

    #if defined(FLT_MAX) && defined(FLT_MAX_EXP)
        i = FLT_MAX_EXP;
        f = FLT_MAX;
    #else
        i = -1;
        f = pf = 1.0;
        do
        {
            i++;
            mf = pf;
            pf = f;
            f *= 2.0;
        } while (f > pf);
    #ifdef FLT_MAX_EXP
        i = FLT_MAX_EXP;
    #endif
    #ifdef FLT_MAX
        f = FLT_MAX;
    #endif
    #endif
    #ifdef FLT_MAX_EXP
        i = FLT_MAX_EXP;
    #else
        f = 1;
        do
        {
            f *= 2.0;
        } while (mf == (mf + f));
        f = (mf - f) * 2.0 + f;
    #endif
        xf = f;
    #ifndef FLT_MAX
        printf("#ifndef FLT_MAX\n");
        printf("#define FLT_MAX         %.*E%s\n", s + 1, f, fs);
        printf("#endif\n");
    #endif
    #ifndef FLT_MAX_EXP
        printf("#ifndef FLT_MAX_EXP\n");
        printf("#define FLT_MAX_EXP     %d\n", i);
        printf("#endif\n");
    #endif

    #ifdef FLT_MIN_10_EXP
        i = FLT_MIN_10_EXP;
    #else
        i = 2;
        f = 1.0;
        do
        {
            i--;
            pf = f;
            f /= 10.0;
        } while (f < pf);
    #endif
    #ifndef FLT_MIN_10_EXP
        printf("#ifndef FLT_MIN_10_EXP\n");
        printf("#define FLT_MIN_10_EXP      (%d)\n", i);
        printf("#endif\n");
    #endif

    #ifdef FLT_MAX_10_EXP
        i = FLT_MAX_10_EXP;
    #else
        i = -2;
        f = 1.0;
        do
        {
            i++;
            pf = f;
            f *= 10.0;
        } while (f > pf);
    #endif
    #ifndef FLT_MAX_10_EXP
        printf("#ifndef FLT_MAX_10_EXP\n");
        printf("#define FLT_MAX_10_EXP      %d\n", i);
        printf("#endif\n");
    #endif

        printf("\n");
        w = 1;
        do
        {
            pw = w;
            w *= 2;
            d = (_ast_intmax_t)w;
            x = (_ast_intmax_t)d;
        } while (w > pw && w == x);
        w = (pw - 1) + pw;
        u = ~0;
        if (u > w)
            u = w;
        printf("#define DBL_ULONG_MAX       %lu.0\n", u);
        if (sizeof(w) > sizeof(u))
        {
            printf("#define DBL_ULLONG_MAX      %llu.0\n", w);
            printf("#define DBL_UINTMAX_MAX     DBL_ULLONG_MAX\n");
        }
        else
        {
            printf("#define DBL_ULLONG_MAX      DBL_ULONG_MAX\n");
            printf("#define DBL_UINTMAX_MAX     DBL_ULONG_MAX\n");
        }
        u /= 2;
        w /= 2;
        printf("#define DBL_LONG_MAX        %lu.0\n", u);
        if (sizeof(w) > sizeof(u))
        {
            printf("#define DBL_LLONG_MAX       %llu.0\n", w);
            printf("#define DBL_INTMAX_MAX      DBL_LLONG_MAX\n");
        }
        else
        {
            printf("#define DBL_LLONG_MAX       DBL_LONG_MAX\n");
            printf("#define DBL_INTMAX_MAX      DBL_LONG_MAX\n");
        }
        u++;
        w++;
        printf("#define DBL_LONG_MIN        (-%lu.0)\n", u);
        if (sizeof(w) > sizeof(u))
        {
            printf("#define DBL_LLONG_MIN       (-%llu.0)\n", w);
            printf("#define DBL_INTMAX_MIN      DBL_LLONG_MIN\n");
        }
        else
        {
            printf("#define DBL_LLONG_MIN       DBL_LONG_MIN\n");
            printf("#define DBL_INTMAX_MIN      DBL_LONG_MIN\n");
        }
    #ifdef DBL_DIG
        s = DBL_DIG;
    #else
        d = pd = 1.0;
        s = -1;
        do
        {
            s++;
            d *= 10.0;
        } while (d != (d + pd));
    #endif
    #if defined(DBL_MIN) && defined(DBL_MIN_EXP)
        i = DBL_MIN_EXP;
        md = DBL_MIN;
    #else
        i = 3;
        d = pd = 1.0;
        do
        {
            i--;
            md = pd;
            pd = d;
            d /= 2.0;
        } while (d < pd);
    #ifdef DBL_MIN_EXP
        i = DBL_MIN_EXP;
    #endif
    #ifdef DBL_MIN
        md = DBL_MIN;
    #endif
    #endif
    #ifndef DBL_DIG
        printf("#ifndef DBL_DIG\n");
        printf("#define DBL_DIG         %d\n", s);
        printf("#endif\n");
    #endif
    #ifndef DBL_MIN
        printf("#ifndef DBL_MIN\n");
        printf("#define DBL_MIN         %.*E%s\n", s + 1, md, ds);
        printf("#endif\n");
    #endif
    #ifndef DBL_MIN_EXP
        printf("#ifndef DBL_MIN_EXP\n");
        printf("#define DBL_MIN_EXP     (%d)\n", i);
        printf("#endif\n");
    #endif

    #if defined(DBL_MAX) && defined(DBL_MAX_EXP)
        i = DBL_MAX_EXP;
        d = DBL_MAX;
    #else
        i = -1;
        d = pd = 1.0;
        do
        {
            i++;
            md = pd;
            pd = d;
            d *= 2.0;
        } while (d > pd);
        d = 1.0;
        do
        {
            d *= 2.0;
        } while (md == (md + d));
        d = (md - d) * 2.0 + d;
    #ifdef DBL_MAX_EXP
        i = DBL_MAX_EXP;
    #endif
    #ifdef DBL_MAX
        d = DBL_MAX;
    #endif
    #endif
    #ifndef DBL_MAX
        printf("#ifndef DBL_MAX\n");
        printf("#define DBL_MAX         %.*E%s\n", s + 1, d, ds);
        printf("#endif\n");
    #endif
    #ifndef DBL_MAX_EXP
        printf("#ifndef DBL_MAX_EXP\n");
        printf("#define DBL_MAX_EXP     %d\n", i);
        printf("#endif\n");
    #endif

    #ifdef DBL_MIN_10_EXP
        i = DBL_MIN_10_EXP;
    #else
        i = 2;
        d = 1.0;
        do
        {
            i--;
            pd = d;
            d /= 10.0;
        } while (d < pd);
    #endif
    #ifndef DBL_MIN_10_EXP
        printf("#ifndef DBL_MIN_10_EXP\n");
        printf("#define DBL_MIN_10_EXP      (%d)\n", i);
        printf("#endif\n");
    #endif

    #ifdef DBL_MAX_10_EXP
        i = DBL_MAX_10_EXP;
    #else
        i = -2;
        d = 1.0;
        do
        {
            i++;
            pd = d;
            d *= 10.0;
        } while (d > pd);
    #endif
    #ifndef DBL_MAX_10_EXP
        printf("#ifndef DBL_MAX_10_EXP\n");
        printf("#define DBL_MAX_10_EXP      %d\n", i);
        printf("#endif\n");
    #endif

    #if !_ast_fltmax_double
        printf("\n");
        w = 1;
        do
        {
            pw = w;
            w *= 2;
            l = (_ast_intmax_t)w;
            x = (_ast_intmax_t)l;
        } while (w > pw && w == x);
        w = (pw - 1) + pw;
        u = ~0;
        if (u > w)
            u = w;
        printf("#define LDBL_ULONG_MAX      %lu.0L\n", u);
        if (sizeof(w) > sizeof(u))
        {
            printf("#define LDBL_ULLONG_MAX     %llu.0L\n", w);
            printf("#define LDBL_UINTMAX_MAX    LDBL_ULLONG_MAX\n");
        }
        else
        {
            printf("#define LDBL_ULLONG_MAX     LDBL_ULONG_MAX\n");
            printf("#define LDBL_UINTMAX_MAX    LDBL_ULONG_MAX\n");
        }
        u /= 2;
        w /= 2;
        printf("#define LDBL_LONG_MAX       %lu.0L\n", u);
        if (sizeof(w) > sizeof(u))
        {
            printf("#define LDBL_LLONG_MAX      %llu.0L\n", w);
            printf("#define LDBL_INTMAX_MAX     LDBL_LLONG_MAX\n");
        }
        else
        {
            printf("#define LDBL_LLONG_MAX      LDBL_LONG_MAX\n");
            printf("#define LDBL_INTMAX_MAX     LDBL_LONG_MAX\n");
        }
        u++;
        w++;
        printf("#define LDBL_LONG_MIN       (-%lu.0L)\n", u);
        if (sizeof(w) > sizeof(u))
        {
            printf("#define LDBL_LLONG_MIN      (-%llu.0L)\n", w);
            printf("#define LDBL_INTMAX_MIN     LDBL_LLONG_MIN\n");
        }
        else
        {
            printf("#define LDBL_LLONG_MIN      LDBL_LONG_MIN\n");
            printf("#define LDBL_INTMAX_MIN     LDBL_LONG_MIN\n");
        }
    #ifdef LDBL_DIG
        s = LDBL_DIG;
    #else
        l = pl = 1.0L;
        s = -1;
        do
        {
            s++;
            l *= 10.0L;
        } while (l != (l + pl));
    #endif
    #if defined(LDBL_MIN) && defined(LDBL_MIN_EXP)
        i = LDBL_MIN_EXP;
        ml = LDBL_MIN;
    #else
        i = 3;
        l = pl = 1.0L;
        do
        {
            i--;
            ml = pl;
            pl = l;
            l /= 2.0L;
        } while (l < pl);
    #ifdef LDBL_MIN_EXP
        i = LDBL_MIN_EXP;
    #endif
    #ifdef LDBL_MIN
        ml = LDBL_MIN;
    #endif
    #endif
    #ifndef LDBL_DIG
        printf("#ifndef LDBL_DIG\n");
        printf("#define LDBL_DIG        %d\n", s);
        printf("#endif\n");
    #endif
    #ifndef LDBL_MIN
        printf("#ifndef LDBL_MIN\n");
        printf("#define LDBL_MIN        %.*LE%s\n", s + 1, ml, ls);
        printf("#endif\n");
    #endif
    #ifndef LDBL_MIN_EXP
        printf("#ifndef LDBL_MIN_EXP\n");
        printf("#define LDBL_MIN_EXP        (%d)\n", i);
        printf("#endif\n");
    #endif

    #if defined(LDBL_MAX) && defined(LDBL_MAX_EXP)
        i = LDBL_MAX_EXP;
        l = LDBL_MAX;
    #else
        i = -1;
        l = pl = 1.0L;
        do
        {
            i++;
            ml = pl;
            pl = l;
            l *= 2.0L;
        } while (l > pl);
        l = 1.0L;
        do
        {
            l *= 2.0L;
        } while (ml == (ml + l));
        l = (ml - l) * 2.0L + l;
    #ifdef LDBL_MAX_EXP
        i = LDBL_MAX_EXP;
    #endif
    #ifdef LDBL_MAX
        l = LDBL_MAX;
    #endif
    #endif
    #ifndef LDBL_MAX
        printf("#ifndef LDBL_MAX\n");
        printf("#define LDBL_MAX        %.*LE%s\n", s + 1, l, ls);
        printf("#endif\n");
    #endif
    #ifndef LDBL_MAX_EXP
        printf("#ifndef LDBL_MAX_EXP\n");
        printf("#define LDBL_MAX_EXP        %d\n", i);
        printf("#endif\n");
    #endif

    #ifdef LDBL_MIN_10_EXP
        i = LDBL_MIN_10_EXP;
    #else
        i = 2;
        l = 1.0L;
        do
        {
            i--;
            pl = l;
            l /= 10.0L;
        } while (l < pl);
    #endif
    #ifndef LDBL_MIN_10_EXP
        printf("#ifndef LDBL_MIN_10_EXP\n");
        printf("#define LDBL_MIN_10_EXP     (%d)\n", i);
        printf("#endif\n");
    #endif

    #ifdef LDBL_MAX_10_EXP
        i = LDBL_MAX_10_EXP;
    #else
        i = -2;
        l = 1.0L;
        do
        {
            i++;
            pl = l;
            l *= 10.0L;
        } while (l > pl);
    #endif
    #ifndef LDBL_MAX_10_EXP
        printf("#ifndef LDBL_MAX_10_EXP\n");
        printf("#define LDBL_MAX_10_EXP     %d\n", i);
        printf("#endif\n");
    #endif
        fp = "LDBL";
    #else
        fp = "DBL";
    #endif

    printf("\n");
    printf("#define FLTMAX_UINTMAX_MAX  %s_UINTMAX_MAX\n", fp);
    printf("#define FLTMAX_INTMAX_MAX   %s_INTMAX_MAX\n", fp);
    printf("#define FLTMAX_INTMAX_MIN   %s_INTMAX_MIN\n", fp);

    #ifdef SIGFPE
        if (!caught)
        {
    #if !__MVS__
            f = xf;
            f *= 2;
            if (!f)
    #endif
                caught = 1;
        }
        if (caught)
            printf("\n#define _ast_fltsig       %d\n", SIGFPE);
    #endif

        printf("\n");
    #if !_lib_frexp || _npt_frexp
        printf("extern double       frexp(double, int*);\n");
    #endif
    #if !_lib_frexpl || _npt_frexpl
        printf("extern _ast_fltmax_t    frexpl(_ast_fltmax_t, int*);\n");
    #endif
    #if !_lib_ldexp || _npt_ldexp
        printf("extern double       ldexp(double, int);\n");
    #endif
    #if !_lib_ldexpl || _npt_ldexpl
        printf("extern _ast_fltmax_t    ldexpl(_ast_fltmax_t, int);\n");
    #endif

        return 0;
    }
}end

tst - note{ double exponent bitfoolery }end output{
    #include "FEATURE/common"
    #include <stdio.h>
    typedef union _dbl_exp_u
    {
        unsigned _ast_int4_t    e[sizeof(double) / 4];
        double          f;
    } _ast_dbl_exp_t;
    int
    main()
    {
        int         i;
        int         j;
        unsigned _ast_int4_t    e;
        _ast_dbl_exp_t      a;
        _ast_dbl_exp_t      b;
        a.f = 1;
        b.f = 2;
        for (i = 0; i < sizeof(a.e) / sizeof(a.e[0]); i++)
            if (e = a.e[i] ^ b.e[i])
            {
                for (j = i + 1; j < sizeof(a.e) / sizeof(a.e[0]); j++)
                    if (a.e[j] ^ b.e[j])
                        return 0;
                printf("typedef union _ast_dbl_exp_u\n{\n\tuint32_t\t\te[sizeof(double)/4];\n\tdouble\t\t\tf;\n} _ast_dbl_exp_t;\n\n");
                printf("#define _ast_dbl_exp_index  %d\n", i);
                for (i = 0; !(e & 1); e >>= 1, i++);
                printf("#define _ast_dbl_exp_shift  %d\n\n", i);
                return 0;
            }
        return 0;
    }
}end

tst - note{ long double exponent bitfoolery }end output{
    #include "FEATURE/common"
    #include <stdio.h>
    typedef union _ast_fltmax_exp_u
    {
        unsigned _ast_int4_t    e[sizeof(_ast_fltmax_t) / 4];
        _ast_fltmax_t       f;
    } _ast_fltmax_exp_t;
    int
    main()
    {
        int         i;
        int         j;
        unsigned _ast_int4_t    e;
        _ast_fltmax_exp_t   a;
        _ast_fltmax_exp_t   b;
        a.f = 1;
        b.f = 2;
        for (i = 0; i < sizeof(a.e) / sizeof(a.e[0]); i++)
            if (e = a.e[i] ^ b.e[i])
            {
                for (j = i + 1; j < sizeof(a.e) / sizeof(a.e[0]); j++)
                    if (a.e[j] ^ b.e[j])
                        return 0;
                printf("typedef union _fltmax_exp_u\n{\n\tuint32_t\t\te[sizeof(_ast_fltmax_t)/4];\n\t_ast_fltmax_t\t\tf;\n} _ast_fltmax_exp_t;\n\n");
                printf("#define _ast_fltmax_exp_index\t%d\n", i);
                for (i = 0; !(e & 1); e >>= 1, i++);
                printf("#define _ast_fltmax_exp_shift\t%d\n\n", i);
                return 0;
            }
        return 0;
    }
}end

tst - -DN=1 - -DN=2 note{ _ast_fltmax_t maximum integral type }end output{
    #include <stdio.h>
    int
    main()
    {
    #if N == 1
        unsigned long long  m;
        long double     f = 123.456;

        m = f;
        if (!m || f == m)
            return 1;
        printf("#define _ast_flt_unsigned_max_t unsigned long long\n");
    #else
        printf("#define _ast_flt_unsigned_max_t unsigned long\n");
    #endif
        return 0;
    }
}end

tst - -DSCAN=1 - -lm -DSTRTO=1 - -DMAC=1 - -DDIV=1 - -DEXP=1 - -DADD=1 - -DMPY=1 note{ INF and NAN memory representations }end output{
    #if MAC
    #define _AIX_COMPATIBILITY  1
    #define _FP_MODE_VARIABLE   1
    #endif
    #include "FEATURE/common"
    #include <stdio.h>
    #include <sys/types.h>
    #include <signal.h>
    #if _hdr_float
    #include <float.h>
    #endif
    #if _hdr_limits
    #include <limits.h>
    #endif
    #if _hdr_math
    #include <math.h>
    #endif
    #if _hdr_values
    #include <values.h>
    #endif
    #if STRTO && _hdr_stdlib
    #include <stdlib.h>
    #endif
    #if !defined(FLT_MAX) && defined(MAXFLOAT)
    #define FLT_MAX     MAXFLOAT
    #endif
    #if !defined(DBL_MAX) && defined(MAXDOUBLE)
    #define DBL_MAX     MAXDOUBLE
    #endif
    #if _ast_fltmax_double
    #undef  LDBL_MAX
    #endif
    static void
    #if _STD_
    list(const char* typ, const char* var, void* val, int siz)
    #else
    list(typ, var, val, siz)
    char* typ;
    char* var;
    void* val;
    int siz;
    #endif
    {
        register unsigned char* u = (unsigned char*)val;
        register unsigned char* e = u + siz;

        printf("#define _ast_%s_%s_init\t0x%02x", typ, var, *u);
        while (++u < e)
            printf(",0x%02x", *u);
        printf("\n");
    }
    int
    main()
    {
    #if SCAN || STRTO
    #undef  NAN
    #define NAN "NaN"
    #undef  INF
    #define INF "INF"
    {
        float   f;

    #if SCAN
        if (sscanf(NAN, "%g", &f) != 1)
            return 1;
    #else
        f = atof(NAN);
    #endif
        list("flt", "nan", &f, sizeof(f));
    #if SCAN
        if (sscanf(INF, "%g", &f) != 1)
            return 1;
    #else
        f = atof(INF);
    #endif
        list("flt", "inf", &f, sizeof(f));
    }
    {
        double  f;
    #if STRTO
        char*   e;
    #endif

    #if SCAN
        if (sscanf(NAN, "%lg", &f) != 1)
            return 1;
    #else
        f = strtod(NAN, &e);
        if (*e)
            return 1;
    #endif
        list("dbl", "nan", &f, sizeof(f));
    #if SCAN
        if (sscanf(INF, "%lg", &f) != 1)
            return 1;
    #else
        f = strtod(INF, &e);
        if (*e)
            return 1;
    #endif
        list("dbl", "inf", &f, sizeof(f));
    }
    #ifdef LDBL_MAX
    {
        long double f;
    #if STRTO
        char*   e;
    #endif

    #if SCAN
        if (sscanf(NAN, "%Lg", &f) != 1)
            return 1;
    #else
        f = strtold(NAN, &e);
        if (*e)
            return 1;
    #endif
        list("ldbl", "nan", &f, sizeof(f));
    #if SCAN
        if (sscanf(INF, "%Lg", &f) != 1)
            return 1;
    #else
        f = strtold(INF, &e);
        if (*e)
            return 1;
    #endif
        list("ldbl", "inf", &f, sizeof(f));
    }
    #endif
    #else
    #ifdef SIGFPE
        signal(SIGFPE, SIG_IGN);
    #endif
    #ifdef FLT_MAX
        {
            float   f = FLT_MAX;
    #if DIV
            float   z = 0;

            f = 0.0 / z;
            if (!f)
                return 1;
            list("flt", "nan", &f, sizeof(f));
            f = 1.0 / z;
            list("flt", "inf", &f, sizeof(f));
    #else
    #if ADD
            f += f;
    #endif
    #if EXP
            f = exp(f);
    #endif
    #if MPY
            f *= 2;
    #endif
    #if MAC
            f = FLT_QNAN;
    #endif
            list("flt", "nan", &f, sizeof(f));
    #if MAC
            f = FLT_INFINITY;
    #endif
            list("flt", "inf", &f, sizeof(f));
    #endif
        }
    #endif
    #ifdef DBL_MAX
        {
            double  f = DBL_MAX;
    #if DIV
            double  z = 0;

            f = 0.0 / z;
            if (!f)
                return 1;
            list("dbl", "nan", &f, sizeof(f));
            f = 1.0 / z;
            list("dbl", "inf", &f, sizeof(f));
    #else
    #if ADD
            f += f;
    #endif
    #if EXP
            f = exp(f);
    #endif
    #if MPY
            f *= 2;
    #endif
    #if MAC
            f = DBL_QNAN;
    #endif
            list("dbl", "nan", &f, sizeof(f));
    #if MAC
            f = DBL_INFINITY;
    #endif
            list("dbl", "inf", &f, sizeof(f));
    #endif
        }
    #endif
    #ifdef LDBL_MAX
        {
            long double f = LDBL_MAX;
    #if DIV
            long double z = 0;

            f = 0.0 / z;
            if (!f)
                return 1;
            list("ldbl", "nan", &f, sizeof(f));
            f = 1.0 / z;
            list("ldbl", "inf", &f, sizeof(f));
    #else
    #if ADD
            f += f;
    #endif
    #if EXP
            f = exp(f);
    #endif
    #if MPY
            f *= 2;
    #endif
    #if MAC
            f = LDBL_QNAN;
    #endif
            list("ldbl", "nan", &f, sizeof(f));
    #if MAC
            f = LDBL_INFINITY;
    #endif
            list("ldbl", "inf", &f, sizeof(f));
    #endif
        }
    #endif
    #endif
        return 0;
    }
}end