Return to fpp-unknown.h CVS log

Up to [HATARI the Atari ST Emulator] / hatari / src / uae-cpu

Annotation of hatari/src/uae-cpu/fpp-unknown.h, revision 1.1.1.1

1.1       root        1:  /*
                      2:   * UAE - The Un*x Amiga Emulator
                      3:   *
                      4:   * MC68881 emulation
                      5:   *
                      6:   * Conversion routines for hosts with unknown floating point format.
                      7:   *
                      8:   * Copyright 1996 Herman ten Brugge
                      9:   */
                     10: 
                     11: #ifndef HAVE_to_single
                     12: STATIC_INLINE double to_single (uae_u32 value)
                     13: {
                     14:     double frac;
                     15: 
                     16:     if ((value & 0x7fffffff) == 0)
                     17:         return (0.0);
                     18:     frac = (double) ((value & 0x7fffff) | 0x800000) / 8388608.0;
                     19:     if (value & 0x80000000)
                     20:         frac = -frac;
                     21:     return (ldexp (frac, ((value >> 23) & 0xff) - 127));
                     22: }
                     23: #endif
                     24: 
                     25: #ifndef HAVE_from_single
                     26: STATIC_INLINE uae_u32 from_single (double src)
                     27: {
                     28:     int expon;
                     29:     uae_u32 tmp;
                     30:     double frac;
                     31: 
                     32:     if (src == 0.0)
                     33:         return 0;
                     34:     if (src < 0) {
                     35:         tmp = 0x80000000;
                     36:         src = -src;
                     37:     } else {
                     38:         tmp = 0;
                     39:     }
                     40:     frac = frexp (src, &expon);
                     41:     frac += 0.5 / 16777216.0;
                     42:     if (frac >= 1.0) {
                     43:         frac /= 2.0;
                     44:         expon++;
                     45:     }
                     46:     return (tmp | (((expon + 127 - 1) & 0xff) << 23) |
                     47:             (((int) (frac * 16777216.0)) & 0x7fffff));
                     48: }
                     49: #endif
                     50: 
                     51: #ifndef HAVE_to_exten
                     52: STATIC_INLINE double to_exten(uae_u32 wrd1, uae_u32 wrd2, uae_u32 wrd3)
                     53: {
                     54:     double frac;
                     55: 
                     56:     if ((wrd1 & 0x7fff0000) == 0 && wrd2 == 0 && wrd3 == 0)
                     57:         return 0.0;
                     58:     frac = (double) wrd2 / 2147483648.0 +
                     59:         (double) wrd3 / 9223372036854775808.0;
                     60:     if (wrd1 & 0x80000000)
                     61:         frac = -frac;
                     62:     return ldexp (frac, ((wrd1 >> 16) & 0x7fff) - 16383);
                     63: }
                     64: #endif
                     65: 
                     66: #ifndef HAVE_from_exten
                     67: STATIC_INLINE void from_exten(double src, uae_u32 * wrd1, uae_u32 * wrd2, uae_u32 * wrd3)
                     68: {
                     69:     int expon;
                     70:     double frac;
                     71: 
                     72:     if (src == 0.0) {
                     73:         *wrd1 = 0;
                     74:         *wrd2 = 0;
                     75:         *wrd3 = 0;
                     76:         return;
                     77:     }
                     78:     if (src < 0) {
                     79:         *wrd1 = 0x80000000;
                     80:         src = -src;
                     81:     } else {
                     82:         *wrd1 = 0;
                     83:     }
                     84:     frac = frexp (src, &expon);
                     85:     frac += 0.5 / 18446744073709551616.0;
                     86:     if (frac >= 1.0) {
                     87:         frac /= 2.0;
                     88:         expon++;
                     89:     }
                     90:     *wrd1 |= (((expon + 16383 - 1) & 0x7fff) << 16);
                     91:     *wrd2 = (uae_u32) (frac * 4294967296.0);
                     92:     *wrd3 = (uae_u32) (frac * 18446744073709551616.0 - *wrd2 * 4294967296.0);
                     93: }
                     94: #endif
                     95: 
                     96: #ifndef HAVE_to_double
                     97: STATIC_INLINE double to_double(uae_u32 wrd1, uae_u32 wrd2)
                     98: {
                     99:     double frac;
                    100: 
                    101:     if ((wrd1 & 0x7fffffff) == 0 && wrd2 == 0)
                    102:         return 0.0;
                    103:     frac = (double) ((wrd1 & 0xfffff) | 0x100000) / 1048576.0 +
                    104:         (double) wrd2 / 4503599627370496.0;
                    105:     if (wrd1 & 0x80000000)
                    106:         frac = -frac;
                    107:     return ldexp (frac, ((wrd1 >> 20) & 0x7ff) - 1023);
                    108: }
                    109: #endif
                    110: 
                    111: #ifndef HAVE_from_double
                    112: STATIC_INLINE void from_double(double src, uae_u32 * wrd1, uae_u32 * wrd2)
                    113: {
                    114:     int expon;
                    115:     int tmp;
                    116:     double frac;
                    117: 
                    118:     if (src == 0.0) {
                    119:         *wrd1 = 0;
                    120:         *wrd2 = 0;
                    121:         return;
                    122:     }
                    123:     if (src < 0) {
                    124:         *wrd1 = 0x80000000;
                    125:         src = -src;
                    126:     } else {
                    127:         *wrd1 = 0;
                    128:     }
                    129:     frac = frexp (src, &expon);
                    130:     frac += 0.5 / 9007199254740992.0;
                    131:     if (frac >= 1.0) {
                    132:         frac /= 2.0;
                    133:         expon++;
                    134:     }
                    135:     tmp = (uae_u32) (frac * 2097152.0);
                    136:     *wrd1 |= (((expon + 1023 - 1) & 0x7ff) << 20) | (tmp & 0xfffff);
                    137:     *wrd2 = (uae_u32) (frac * 9007199254740992.0 - tmp * 4294967296.0);
                    138: }
                    139: #endif

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