.ref-BSD-4_3_Tahoe/usr/src/sys/vax/asnumber.h

/*
 * Copyright (c) 1982 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 *
 *      @(#)asnumber.h  5.1 (Berkeley) 4/30/85
 */

union Ib_int{           /* byte */
        u_char  Ib_uchar[1];
        char    Ichar;
};
union Iw_int{           /* word */
        u_char  Iw_uchar[2];
        u_short Iw_ushort[1];
        short   Iw_short;
};
union Il_int{           /* long word */
        u_char  Il_uchar[4];
        u_short Il_ushort[2];
        u_int   Il_ulong[1];
        int     Il_long;
};

union Iq_int{           /* quad word */
        u_char  Iq_uchar[8];
        u_short Iq_ushort[4];
        u_int   Iq_ulong[2];
};

union Io_int{           /* octal word */
        u_char  Io_uchar[16];
        u_short Io_ushort[8];
        u_int   Io_ulong[4];
        union   Iq_int  Io_quad[2];
};

union Ff_float{
        u_char  Ff_uchar[4];
        u_short Ff_ushort[2];
        u_int   Ff_ulong[1];
        float   Ff_value;
};

union Fd_float{
        u_char  Fd_uchar[8];
        u_short Fd_ushort[4];
        u_int   Fd_ulong[2];
        double  Fd_value;
};

union Fg_float{
        u_char  Fg_uchar[8];
        u_short Fg_ushort[4];
        u_int   Fg_ulong[2];
};

union Fh_float{
        u_char  Fh_uchar[16];
        u_short Fh_ushort[8];
        u_int   Fh_ulong[4];
};

struct  as_number{
        union {
                union Ib_int    numIb_int;
                union Iw_int    numIw_int;
                union Il_int    numIl_int;
                union Iq_int    numIq_int;
                union Io_int    numIo_int;
                union Ff_float  numFf_float;
                union Fd_float  numFd_float;
                union Fg_float  numFg_float;
                union Fh_float  numFh_float;
        }num_num;
        char    num_tag;                /* the key field: TYPB..TYPUNPACKED */
        char    num_sign;               /* when unpacked, the sign */
        short   num_exponent;           /* when unpacked, the unexcessed exp */
};
typedef struct as_number        Bignum;

extern  Bignum  Znumber;                /* one all zero'ed out */

#define num_uchar       num_num.numIq_int.Iq_uchar
#define num_uint        num_num.numIq_int.Iq_ulong
#define num_ulong       num_num.numIq_int.Iq_ulong
#define num_ushort      num_num.numIq_int.Iq_ushort
/*
 *      The following definitions must all be consistent.
 *      They define the granularity of working on longs, quad and octal
 *      words. Currently, the granularity is as large as it can be: 32 bits
 *      in a chunk.
 */
#define CH_N            4               /* number of pieces */
#define CH_BITS         32              /* number of bits per piece */
#define CH_FIELD(x)     ((x).num_num.numIo_int.Io_ulong)
typedef u_int           *chptr;         /* basic data type */
#define SIGNBIT         0x80000000

#define HOC             (CH_N - 1)      /* high order chunk */
#if 0
#define MAXINT_1        ((unsigned)(1<<(CH_BITS - 1)))
#define MAXINT_10       ((unsigned)((MAXINT_1/(unsigned)10)))
#define MAXINT_5        ((unsigned)((MAXINT_1/(unsigned)5)))
#else not 0
/*
 *      These values were computed using dc, so are exact.
 *      Only MAXINT_10 and MAXINT_5 are used in the programs.
 */
#define MAXINT_1        2147483648
#define MAXINT_10       214748364
#define MAXINT_5        429496729
#endif not 0

Bignum as_atoi();               /* converts string to integer */
Bignum as_atof();               /* converts string to float */
Bignum bigatof();               /* converts string to float */
Bignum floatconvert();  /* converts amongst float #s */
Bignum intconvert();            /* converts amongst float #s */
Bignum bignumconvert(); /* converts amongst float #s */
Bignum bignumpack();            /* converts UNPACKED bignum to bignum */
Bignum bignumunpack();  /* converts bignum to UNPACKED bignum */
\f
/*
 *      Definitions for overflows.
 */
typedef u_int   Ovf;

#define OVF_ADDV        (1<<0)  /* integer: adding two vectors overflowed */
#define OVF_LSHIFT      (1<<1)  /* integer: left shifting a vector lost bits */
#define OVF_POSOVF      (1<<2)  /* integer: positive number overflowed */
#define OVF_MAXINT      (1<<3)  /* integer: the number was the maxint + 1*/
#define OVF_F           (1<<4)  /* float: F overflow */
#define OVF_D           (1<<5)  /* float: D overflow */
#define OVF_G           (1<<6)  /* float: G overflow */
#define OVF_H           (1<<7)  /* float: H overflow */
#define OVF_OVERFLOW    (1<<9)  /* overflow in conversion */
#define OVF_UNDERFLOW   (1<<10) /* underflow in conversion */

Ovf     posovf();
Ovf     numclear();
Ovf     numshift();
Ovf     numaddv();
Ovf     numaddd();
Ovf     num1comp();
Ovf     numnegate();
\f
/*
 *      Definitions to unpack big numbers numbers into
 *      a 128 bit fraction and 16 bit excess-free exponent,
 *      and an 8 copy bits for the sign.
 *
 *      The fraction is represented as a normalized binary number,
 *      128 bits long, with the binary point between bits 127 and the
 *      hypothetical 128'th bit.  This hypothetical 128'th bit
 *      is always assumed to be one.
 */
/*
 *      A map entry is NOTAKE if the corresponding byte is
 *      not to be taken
 *
 *      The maps are for going from packed to unpacked format (b_up)
 *      and from unpacked to packed format (b_p)
 *      for the mantissa (b_upmmap) and for the exponent(b_upemap)
 *
 *      byte #i in the packed number goes to byte #b_upmmap[i] in the unpacked
 */
#define NOTAKE  -1
struct ty_bigdesc{
        char    b_upmmap[16];   /* byte x of float goes to up_mmap[x] in mant */
        char    b_pmmap[16];    /* inverse of upmmap */
        char    b_upemap[2];    /* byte x of float goes to up_emap[x] in exp */
        char    b_pemap[2];     /* inverse of upemap */
        char    b_mlshift;      /* left shift quantity to justify to left */
        char    b_ershift;      /* right shift quantity to r justify exponent */
        short   b_msigbits;     /* # sig bits in mantissa */
        char    b_esigbits;     /* # sig bits in exponent */
        short   b_eexcess;      /* exponent excess */
};
extern struct ty_bigdesc ty_bigdesc[];
/*
 *      Bit manipulations
 */
#define ONES(n) ((1 << (n)) - 1)
/*
 *      Assertions
 */
#if 1
#define assert(x, str) if (!(x)) panic("%s%s\n", "x", str)
#else
#define assert(x, str)
#endif