Return to float.c CVS log

Up to [Research Unix] / researchv9 / cmd / sun / pcc

Annotation of researchv9/cmd/sun/pcc/float.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char sccsid[] = "@(#)float.c 1.1 86/02/03 Copyr 1983 Sun Micro";
        !             3: #endif
        !             4: 
        !             5: /*
        !             6:  * Copyright (c) 1983 by Sun Microsystems, Inc.
        !             7:  */
        !             8: 
        !             9: /*
        !            10:  *     float.c
        !            11:  */
        !            12: 
        !            13: #include "cpass1.h"
        !            14: 
        !            15: /* routine for decoding from "native", CC-internal floating point format
        !            16:  * to object format -- in this case MOTOROLA FFP.
        !            17:  * This gets invoked in local.68 if fpflag is not the same as NATIVEFP.
        !            18:  */
        !            19: fpdecoder( p, sz )
        !            20:     register * p;
        !            21: {
        !            22: 
        !            23:     struct mit { 
        !            24:        unsigned
        !            25:            sign:1,
        !            26:            exp :8,
        !            27:            fract:23; /* has hidden high-order bit! */
        !            28:     };
        !            29:     struct motor {
        !            30:        unsigned
        !            31:            fract:24, /* no hidden bit here */
        !            32:            sign :1,
        !            33:            exp  :7;
        !            34:     };
        !            35:     struct doubleieee {
        !            36:        unsigned
        !            37:            sign:1,
        !            38:            exp: 11,
        !            39:            fract: 20,
        !            40:            fmore;
        !            41:     };
        !            42:     struct doubleint {
        !            43:        unsigned n,m;
        !            44:     };
        !            45: #define MITEXCESS      (1<<7)
        !            46: #define MOTOREXCESS    (1<<6)
        !            47: /* 
        !            48:  * the following two constants appear to be one two low. This is
        !            49:  * deceiving. The hidden bit in IEEE form is on the left-hand-side
        !            50:  * of the decimal point. The hidden bit in MIT form is on the 
        !            51:  * right-hand-side of the decimal point. Thus the discrepiency.
        !            52:  */
        !            53: #define IEEEXCESS      (126)
        !            54: #define DPEXCESS       (1022)
        !            55:     union {
        !            56:        struct motor motor;
        !            57:        struct doubleieee dp;
        !            58:        struct mit mit;
        !            59:        struct doubleint i;
        !            60:     } new;
        !            61:     union {
        !            62:        struct mit mit;
        !            63:        struct doubleint i;
        !            64:     } old;
        !            65:     int x;
        !            66: 
        !            67:     if (NATIVEFP == MIT)
        !            68:     switch( fpflag ){
        !            69:     case Motorola:
        !            70:        old.i.n = *p;
        !            71:        if (old.i.n == 0) return;
        !            72:        new.motor.sign = old.mit.sign;
        !            73:        x = old.mit.exp - MITEXCESS;
        !            74:        if (x >= MOTOREXCESS || x <= -MOTOREXCESS)
        !            75:            uerror("floating-point constant out of range");
        !            76:        new.motor.exp = x + MOTOREXCESS;
        !            77:        x = old.mit.fract | (1<<23); /* restore hidden bit */
        !            78:        new.motor.fract = x;
        !            79:        *p = new.i.n;
        !            80:        *(p+1) = 0; /* s-p only, thank you */
        !            81:        return;
        !            82:     case IEEE:
        !            83:        if (sz == SZDOUBLE ){
        !            84:            old.i.n = *p;
        !            85:            old.i.m = *(p+1);
        !            86:            if (old.i.n == 0 && old.i.m == 0) return;
        !            87:            new.dp.sign = old.mit.sign;
        !            88:            new.dp.exp  = old.mit.exp -MITEXCESS + DPEXCESS;
        !            89:            new.dp.fract = old.mit.fract >> 3;
        !            90:            new.dp.fmore = (old.mit.fract << 29) | (old.i.m >>3);
        !            91:            /* not actually a good approximation, but ... */
        !            92:            *p     = new.i.n;
        !            93:            *(p+1) = new.i.m;
        !            94:            return;
        !            95:        } else {
        !            96:            /* trivial conversion */
        !            97:            new.i.n = *p;
        !            98:            if (new.i.n == 0) return;
        !            99:            new.mit.exp += IEEEXCESS - MITEXCESS;
        !           100:            *p = new.i.n;
        !           101:            return;
        !           102:        }
        !           103:     }
        !           104:     cerror("incomprehensable floating-point conversion");
        !           105: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.