From fcc2dcbb21743447d9f51f40283892da0075f751 Mon Sep 17 00:00:00 2001 From: Corinna Vinschen Date: Thu, 19 Nov 2015 17:09:58 +0100 Subject: [PATCH] ldtoa.c: Reindent to GNU style * libc/stdlib/ldtoa.c: Convert to GNU style so as not to get crazy reading the code. Signed-off-by: Corinna Vinschen --- newlib/ChangeLog | 5 + newlib/libc/stdlib/ldtoa.c | 4612 ++++++++++++++++++------------------ 2 files changed, 2354 insertions(+), 2263 deletions(-) diff --git a/newlib/ChangeLog b/newlib/ChangeLog index ecf52f167..7f39a191d 100644 --- a/newlib/ChangeLog +++ b/newlib/ChangeLog @@ -1,3 +1,8 @@ +2015-11-19 Corinna Vinschen + + * libc/stdlib/ldtoa.c: Convert to GNU style so as not to get crazy + reading the code. + 2015-11-19 Corinna Vinschen * libc/stdlib/rpmatch.c: Include sys/types.h to make GCC happy. diff --git a/newlib/libc/stdlib/ldtoa.c b/newlib/libc/stdlib/ldtoa.c index 76b4638ff..60ca1e80c 100644 --- a/newlib/libc/stdlib/ldtoa.c +++ b/newlib/libc/stdlib/ldtoa.c @@ -11,37 +11,38 @@ /* These are the externally visible entries. */ /* linux name: long double _IO_strtold (char *, char **); */ long double _strtold (char *, char **); -char * _ldtoa_r (struct _reent *, long double, int, int, int *, int *, char **); -int _ldcheck (long double *); +char *_ldtoa_r (struct _reent *, long double, int, int, int *, int *, + char **); +int _ldcheck (long double *); #if 0 -void _IO_ldtostr(long double *, char *, int, int, char); +void _IO_ldtostr (long double *, char *, int, int, char); #endif /* Number of 16 bit words in external x type format */ - #define NE 10 +#define NE 10 /* Number of 16 bit words in internal format */ - #define NI (NE+3) +#define NI (NE+3) /* Array offset to exponent */ - #define E 1 +#define E 1 /* Array offset to high guard word */ - #define M 2 +#define M 2 /* Number of bits of precision */ - #define NBITS ((NI-4)*16) +#define NBITS ((NI-4)*16) /* Maximum number of decimal digits in ASCII conversion * = NBITS*log10(2) */ - #define NDEC (NBITS*8/27) +#define NDEC (NBITS*8/27) /* The exponent of 1.0 */ - #define EXONE (0x3fff) +#define EXONE (0x3fff) /* Maximum exponent digits - base 10 */ - #define MAX_EXP_DIGITS 5 +#define MAX_EXP_DIGITS 5 /* Control structure for long double conversion including rounding precision values. * rndprc can be set to 80 (if NE=6), 64, 56, 53, or 24 bits. @@ -60,24 +61,30 @@ typedef struct unsigned short equot[NI]; } LDPARMS; -static void esub(_CONST short unsigned int *a, _CONST short unsigned int *b, short unsigned int *c, LDPARMS *ldp); -static void emul(_CONST short unsigned int *a, _CONST short unsigned int *b, short unsigned int *c, LDPARMS *ldp); -static void ediv(_CONST short unsigned int *a, _CONST short unsigned int *b, short unsigned int *c, LDPARMS *ldp); -static int ecmp(_CONST short unsigned int *a, _CONST short unsigned int *b); -static int enormlz(short unsigned int *x); -static int eshift(short unsigned int *x, int sc); -static void eshup1(register short unsigned int *x); -static void eshup8(register short unsigned int *x); -static void eshup6(register short unsigned int *x); -static void eshdn1(register short unsigned int *x); -static void eshdn8(register short unsigned int *x); -static void eshdn6(register short unsigned int *x); -static void eneg(short unsigned int *x); -static void emov(register _CONST short unsigned int *a, register short unsigned int *b); -static void eclear(register short unsigned int *x); -static void einfin(register short unsigned int *x, register LDPARMS *ldp); -static void efloor(short unsigned int *x, short unsigned int *y, LDPARMS *ldp); -static void etoasc(short unsigned int *x, char *string, int ndigs, int outformat, LDPARMS *ldp); +static void esub (_CONST short unsigned int *a, _CONST short unsigned int *b, + short unsigned int *c, LDPARMS * ldp); +static void emul (_CONST short unsigned int *a, _CONST short unsigned int *b, + short unsigned int *c, LDPARMS * ldp); +static void ediv (_CONST short unsigned int *a, _CONST short unsigned int *b, + short unsigned int *c, LDPARMS * ldp); +static int ecmp (_CONST short unsigned int *a, _CONST short unsigned int *b); +static int enormlz (short unsigned int *x); +static int eshift (short unsigned int *x, int sc); +static void eshup1 (register short unsigned int *x); +static void eshup8 (register short unsigned int *x); +static void eshup6 (register short unsigned int *x); +static void eshdn1 (register short unsigned int *x); +static void eshdn8 (register short unsigned int *x); +static void eshdn6 (register short unsigned int *x); +static void eneg (short unsigned int *x); +static void emov (register _CONST short unsigned int *a, + register short unsigned int *b); +static void eclear (register short unsigned int *x); +static void einfin (register short unsigned int *x, register LDPARMS * ldp); +static void efloor (short unsigned int *x, short unsigned int *y, + LDPARMS * ldp); +static void etoasc (short unsigned int *x, char *string, int ndigs, + int outformat, LDPARMS * ldp); union uconv { @@ -86,13 +93,17 @@ union uconv }; #if LDBL_MANT_DIG == 24 -static void e24toe(short unsigned int *pe, short unsigned int *y, LDPARMS *ldp); +static void e24toe (short unsigned int *pe, short unsigned int *y, + LDPARMS * ldp); #elif LDBL_MANT_DIG == 53 -static void e53toe(short unsigned int *pe, short unsigned int *y, LDPARMS *ldp); +static void e53toe (short unsigned int *pe, short unsigned int *y, + LDPARMS * ldp); #elif LDBL_MANT_DIG == 64 -static void e64toe(short unsigned int *pe, short unsigned int *y, LDPARMS *ldp); +static void e64toe (short unsigned int *pe, short unsigned int *y, + LDPARMS * ldp); #else -static void e113toe(short unsigned int *pe, short unsigned int *y, LDPARMS *ldp); +static void e113toe (short unsigned int *pe, short unsigned int *y, + LDPARMS * ldp); #endif /* econst.c */ @@ -100,23 +111,26 @@ static void e113toe(short unsigned int *pe, short unsigned int *y, LDPARMS *ldp) #if NE == 10 /* 0.0 */ -static _CONST unsigned short ezero[NE] = - {0x0000, 0x0000, 0x0000, 0x0000, - 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,}; +static _CONST unsigned short ezero[NE] = { 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, +}; /* 1.0E0 */ -static _CONST unsigned short eone[NE] = - {0x0000, 0x0000, 0x0000, 0x0000, - 0x0000, 0x0000, 0x0000, 0x0000, 0x8000, 0x3fff,}; +static _CONST unsigned short eone[NE] = { 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x8000, 0x3fff, +}; #else /* 0.0 */ static _CONST unsigned short ezero[NE] = { -0, 0000000,0000000,0000000,0000000,0000000,}; + 0, 0000000, 0000000, 0000000, 0000000, 0000000, +}; + /* 1.0E0 */ static _CONST unsigned short eone[NE] = { -0, 0000000,0000000,0000000,0100000,0x3fff,}; + 0, 0000000, 0000000, 0000000, 0100000, 0x3fff, +}; #endif @@ -126,15 +140,16 @@ static _CONST unsigned short eone[NE] = { * messages is bound to the error codes defined * in mconf.h. */ -static _CONST char * _CONST ermsg[7] = { -"unknown", /* error code 0 */ -"domain", /* error code 1 */ -"singularity", /* et seq. */ -"overflow", -"underflow", -"total loss of precision", -"partial loss of precision" +static _CONST char *_CONST ermsg[7] = { + "unknown", /* error code 0 */ + "domain", /* error code 1 */ + "singularity", /* et seq. */ + "overflow", + "underflow", + "total loss of precision", + "partial loss of precision" }; + #define mtherr(name, code) printf( "\n%s %s error\n", name, ermsg[code] ); #else #define mtherr(name, code) @@ -356,17 +371,17 @@ static _CONST char * _CONST ermsg[7] = { #define ERANGE 34 typedef struct - { - double r; - double i; - }cmplx; +{ + double r; + double i; +} cmplx; /* Type of computer arithmetic */ #ifndef DEC #ifdef __IEEE_LITTLE_ENDIAN #define IBMPC 1 -#else /* !__IEEE_LITTLE_ENDIAN */ +#else /* !__IEEE_LITTLE_ENDIAN */ #define MIEEE 1 #endif /* !__IEEE_LITTLE_ENDIAN */ #endif /* !DEC */ @@ -377,7 +392,7 @@ typedef struct #define ANSIC 1 /*define VOLATILE volatile*/ -#define VOLATILE +#define VOLATILE #define NANS #define USE_INFINITY @@ -393,36 +408,45 @@ typedef struct #define LONGBITS (8 * sizeof(long)) -static void eaddm(short unsigned int *x, short unsigned int *y); -static void esubm(short unsigned int *x, short unsigned int *y); -static void emdnorm(short unsigned int *s, int lost, int subflg, long int exp, int rcntrl, LDPARMS *ldp); -static int asctoeg(char *ss, short unsigned int *y, int oprec, LDPARMS *ldp); -static void enan(short unsigned int *nan, int size); +static void eaddm (short unsigned int *x, short unsigned int *y); +static void esubm (short unsigned int *x, short unsigned int *y); +static void emdnorm (short unsigned int *s, int lost, int subflg, + long int exp, int rcntrl, LDPARMS * ldp); +static int asctoeg (char *ss, short unsigned int *y, int oprec, + LDPARMS * ldp); +static void enan (short unsigned int *nan, int size); #if LDBL_MANT_DIG == 24 -static void toe24(short unsigned int *x, short unsigned int *y); +static void toe24 (short unsigned int *x, short unsigned int *y); #elif LDBL_MANT_DIG == 53 -static void toe53(short unsigned int *x, short unsigned int *y); +static void toe53 (short unsigned int *x, short unsigned int *y); #elif LDBL_MANT_DIG == 64 -static void toe64(short unsigned int *a, short unsigned int *b); +static void toe64 (short unsigned int *a, short unsigned int *b); #else -static void toe113(short unsigned int *a, short unsigned int *b); +static void toe113 (short unsigned int *a, short unsigned int *b); #endif -static void eiremain(short unsigned int *den, short unsigned int *num, LDPARMS *ldp); -static int ecmpm(register short unsigned int *a, register short unsigned int *b); -static int edivm(short unsigned int *den, short unsigned int *num, LDPARMS *ldp); -static int emulm(short unsigned int *a, short unsigned int *b, LDPARMS *ldp); -static int eisneg(_CONST short unsigned int *x); -static int eisinf(_CONST short unsigned int *x); -static void emovi(_CONST short unsigned int *a, short unsigned int *b); -static void emovo(short unsigned int *a, short unsigned int *b, LDPARMS *ldp); -static void emovz(register short unsigned int *a, register short unsigned int *b); -static void ecleaz(register short unsigned int *xi); -static void eadd1(_CONST short unsigned int *a, _CONST short unsigned int *b, short unsigned int *c, int subflg, LDPARMS *ldp); -static int eisnan(_CONST short unsigned int *x); -static int eiisnan(short unsigned int *x); +static void eiremain (short unsigned int *den, short unsigned int *num, + LDPARMS * ldp); +static int ecmpm (register short unsigned int *a, + register short unsigned int *b); +static int edivm (short unsigned int *den, short unsigned int *num, + LDPARMS * ldp); +static int emulm (short unsigned int *a, short unsigned int *b, + LDPARMS * ldp); +static int eisneg (_CONST short unsigned int *x); +static int eisinf (_CONST short unsigned int *x); +static void emovi (_CONST short unsigned int *a, short unsigned int *b); +static void emovo (short unsigned int *a, short unsigned int *b, + LDPARMS * ldp); +static void emovz (register short unsigned int *a, + register short unsigned int *b); +static void ecleaz (register short unsigned int *xi); +static void eadd1 (_CONST short unsigned int *a, _CONST short unsigned int *b, + short unsigned int *c, int subflg, LDPARMS * ldp); +static int eisnan (_CONST short unsigned int *x); +static int eiisnan (short unsigned int *x); #ifdef DEC -static void etodec(), todec(), dectoe(); +static void etodec (), todec (), dectoe (); #endif /* @@ -432,12 +456,13 @@ static void etodec(), todec(), dectoe(); ; eclear( x ); */ -static void eclear(register short unsigned int *x) +static void +eclear (register short unsigned int *x) { -register int i; + register int i; -for( i=0; irndprc < NBITS ) + for (i = 0; i < NE - 1; i++) + *x++ = 0xffff; + *x |= 32766; + if (ldp->rndprc < NBITS) + { + if (ldp->rndprc == 113) { - if (ldp->rndprc == 113) - { - *(x - 9) = 0; - *(x - 8) = 0; - } - if( ldp->rndprc == 64 ) - { - *(x-5) = 0; - } - if( ldp->rndprc == 53 ) - { - *(x-4) = 0xf800; - } - else - { - *(x-4) = 0; - *(x-3) = 0; - *(x-2) = 0xff00; - } + *(x - 9) = 0; + *(x - 8) = 0; } + if (ldp->rndprc == 64) + { + *(x - 5) = 0; + } + if (ldp->rndprc == 53) + { + *(x - 4) = 0xf800; + } + else + { + *(x - 4) = 0; + *(x - 3) = 0; + *(x - 2) = 0xff00; + } + } #endif } /* Move in external format number, * converting it to internal format. */ -static void emovi(_CONST short unsigned int *a, short unsigned int *b) +static void +emovi (_CONST short unsigned int *a, short unsigned int *b) { -register _CONST unsigned short *p; -register unsigned short *q; -int i; + register _CONST unsigned short *p; + register unsigned short *q; + int i; -q = b; -p = a + (NE-1); /* point to last word of external number */ + q = b; + p = a + (NE - 1); /* point to last word of external number */ /* get the sign bit */ -if( *p & 0x8000 ) - *q++ = 0xffff; -else - *q++ = 0; + if (*p & 0x8000) + *q++ = 0xffff; + else + *q++ = 0; /* get the exponent */ -*q = *p--; -*q++ &= 0x7fff; /* delete the sign bit */ + *q = *p--; + *q++ &= 0x7fff; /* delete the sign bit */ #ifdef USE_INFINITY -if( (*(q-1) & 0x7fff) == 0x7fff ) - { + if ((*(q - 1) & 0x7fff) == 0x7fff) + { #ifdef NANS - if( eisnan(a) ) - { - *q++ = 0; - for( i=3; i *(--b) ) - return(1); -else - return(-1); + if (*(--a) > *(--b)) + return (1); + else + return (-1); } @@ -770,24 +808,25 @@ else ; Shift significand down by 1 bit */ -static void eshdn1(register short unsigned int *x) +static void +eshdn1 (register short unsigned int *x) { -register unsigned short bits; -int i; + register unsigned short bits; + int i; -x += M; /* point to significand area */ + x += M; /* point to significand area */ -bits = 0; -for( i=M; i>= 1; - if( bits & 2 ) - *x |= 0x8000; - bits <<= 1; - ++x; - } + bits = 0; + for (i = M; i < NI; i++) + { + if (*x & 1) + bits |= 1; + *x >>= 1; + if (bits & 2) + *x |= 0x8000; + bits <<= 1; + ++x; + } } @@ -796,24 +835,25 @@ for( i=M; i>= 8; - *x |= oldbyt; - oldbyt = newbyt; - ++x; - } + x += M; + oldbyt = 0; + for (i = M; i < NI; i++) + { + newbyt = *x << 8; + *x >>= 8; + *x |= oldbyt; + oldbyt = newbyt; + ++x; + } } /* ; Shift significand up by 8 bits */ -static void eshup8(register short unsigned int *x) +static void +eshup8 (register short unsigned int *x) { -int i; -register unsigned short newbyt, oldbyt; + int i; + register unsigned short newbyt, oldbyt; -x += NI-1; -oldbyt = 0; + x += NI - 1; + oldbyt = 0; -for( i=M; i> 8; - *x <<= 8; - *x |= oldbyt; - oldbyt = newbyt; - --x; - } + for (i = M; i < NI; i++) + { + newbyt = *x >> 8; + *x <<= 8; + *x |= oldbyt; + oldbyt = newbyt; + --x; + } } /* ; Shift significand up by 16 bits */ -static void eshup6(register short unsigned int *x) +static void +eshup6 (register short unsigned int *x) { -int i; -register unsigned short *p; + int i; + register unsigned short *p; -p = x + M; -x += M + 1; + p = x + M; + x += M + 1; -for( i=M; i> 16) + (m >> 16) + *pp; - *pp = (unsigned short )carry; - *(pp-1) = carry >> 16; - } + --ps; + --pp; + *(pp - 1) = 0; } -for( i=M; i> 16) + (m >> 16) + *pp; + *pp = (unsigned short) carry; + *(pp - 1) = carry >> 16; + } + } + for (i = M; i < NI; i++) + c[i] = p[i]; } @@ -1000,55 +1047,56 @@ for( i=M; iequot; + int i; + register unsigned short *p; + unsigned long tnum; + unsigned short j, tdenm, tquot; + unsigned short tprod[NI + 1]; + unsigned short *equot = ldp->equot; -p = &equot[0]; -*p++ = num[0]; -*p++ = num[1]; + p = &equot[0]; + *p++ = num[0]; + *p++ = num[1]; -for( i=M; i tdenm ) tquot = 0xffff; */ - /* Multiply denominator by trial quotient digit. */ - m16m( tquot, den, tprod ); - /* The quotient digit may have been overestimated. */ - if( ecmpm( tprod, num ) > 0 ) - { - tquot -= 1; - esubm( den, tprod ); - if( ecmpm( tprod, num ) > 0 ) - { - tquot -= 1; - esubm( den, tprod ); - } - } + /* Multiply denominator by trial quotient digit. */ + m16m (tquot, den, tprod); + /* The quotient digit may have been overestimated. */ + if (ecmpm (tprod, num) > 0) + { + tquot -= 1; + esubm (den, tprod); + if (ecmpm (tprod, num) > 0) + { + tquot -= 1; + esubm (den, tprod); + } + } /* if( ecmpm( tprod, num ) > 0 ) { @@ -1058,7 +1106,7 @@ for( i=M; i= 0 ) { @@ -1068,64 +1116,65 @@ for( i=M; iequot; + unsigned short *p, *q; + unsigned short pprod[NI]; + unsigned short j; + int i; + unsigned short *equot = ldp->equot; -equot[0] = b[0]; -equot[1] = b[1]; -for( i=M; i NBITS ) - { - ecleazs( s ); - return; - } + if (j > NBITS) + { + ecleazs (s); + return; + } #endif -exp -= j; + exp -= j; #ifndef USE_INFINITY -if( exp >= 32767L ) - goto overf; + if (exp >= 32767L) + goto overf; #else -if( (j > NBITS) && (exp < 32767L) ) - { - ecleazs( s ); - return; - } + if ((j > NBITS) && (exp < 32767L)) + { + ecleazs (s); + return; + } #endif -if( exp < 0L ) + if (exp < 0L) + { + if (exp > (long) (-NBITS - 1)) { - if( exp > (long )(-NBITS-1) ) - { - j = (int )exp; - i = eshift( s, j ); - if( i ) - lost = 1; - } - else - { - ecleazs( s ); - return; - } + j = (int) exp; + i = eshift (s, j); + if (i) + lost = 1; } + else + { + ecleazs (s); + return; + } + } /* Round off, unless told not to by rcntrl. */ -if( rcntrl == 0 ) - goto mdfin; + if (rcntrl == 0) + goto mdfin; /* Set up rounding parameters if the control register changed. */ -if( ldp->rndprc != ldp->rlast ) + if (ldp->rndprc != ldp->rlast) + { + ecleaz (ldp->rbit); + switch (ldp->rndprc) { - ecleaz( ldp->rbit ); - switch( ldp->rndprc ) - { - default: - case NBITS: - ldp->rw = NI-1; /* low guard word */ - ldp->rmsk = 0xffff; - ldp->rmbit = 0x8000; - ldp->rebit = 1; - ldp->re = ldp->rw - 1; - break; - case 113: - ldp->rw = 10; - ldp->rmsk = 0x7fff; - ldp->rmbit = 0x4000; - ldp->rebit = 0x8000; - ldp->re = ldp->rw; - break; - case 64: - ldp->rw = 7; - ldp->rmsk = 0xffff; - ldp->rmbit = 0x8000; - ldp->rebit = 1; - ldp->re = ldp->rw-1; - break; + default: + case NBITS: + ldp->rw = NI - 1; /* low guard word */ + ldp->rmsk = 0xffff; + ldp->rmbit = 0x8000; + ldp->rebit = 1; + ldp->re = ldp->rw - 1; + break; + case 113: + ldp->rw = 10; + ldp->rmsk = 0x7fff; + ldp->rmbit = 0x4000; + ldp->rebit = 0x8000; + ldp->re = ldp->rw; + break; + case 64: + ldp->rw = 7; + ldp->rmsk = 0xffff; + ldp->rmbit = 0x8000; + ldp->rebit = 1; + ldp->re = ldp->rw - 1; + break; /* For DEC arithmetic */ - case 56: - ldp->rw = 6; - ldp->rmsk = 0xff; - ldp->rmbit = 0x80; - ldp->rebit = 0x100; - ldp->re = ldp->rw; - break; - case 53: - ldp->rw = 6; - ldp->rmsk = 0x7ff; - ldp->rmbit = 0x0400; - ldp->rebit = 0x800; - ldp->re = ldp->rw; - break; - case 24: - ldp->rw = 4; - ldp->rmsk = 0xff; - ldp->rmbit = 0x80; - ldp->rebit = 0x100; - ldp->re = ldp->rw; - break; - } - ldp->rbit[ldp->re] = ldp->rebit; - ldp->rlast = ldp->rndprc; + case 56: + ldp->rw = 6; + ldp->rmsk = 0xff; + ldp->rmbit = 0x80; + ldp->rebit = 0x100; + ldp->re = ldp->rw; + break; + case 53: + ldp->rw = 6; + ldp->rmsk = 0x7ff; + ldp->rmbit = 0x0400; + ldp->rebit = 0x800; + ldp->re = ldp->rw; + break; + case 24: + ldp->rw = 4; + ldp->rmsk = 0xff; + ldp->rmbit = 0x80; + ldp->rebit = 0x100; + ldp->re = ldp->rw; + break; } + ldp->rbit[ldp->re] = ldp->rebit; + ldp->rlast = ldp->rndprc; + } /* Shift down 1 temporarily if the data structure has an implied * most significant bit and the number is denormal. @@ -1269,94 +1320,94 @@ if( ldp->rndprc != ldp->rlast ) * But Intel long double denormals lose one bit of significance even so. */ #if IBMPC -if( (exp <= 0) && (ldp->rndprc != NBITS) ) + if ((exp <= 0) && (ldp->rndprc != NBITS)) #else -if( (exp <= 0) && (ldp->rndprc != 64) && (ldp->rndprc != NBITS) ) + if ((exp <= 0) && (ldp->rndprc != 64) && (ldp->rndprc != NBITS)) #endif - { - lost |= s[NI-1] & 1; - eshdn1(s); - } + { + lost |= s[NI - 1] & 1; + eshdn1 (s); + } /* Clear out all bits below the rounding bit, * remembering in r if any were nonzero. */ -r = s[ldp->rw] & ldp->rmsk; -if( ldp->rndprc < NBITS ) + r = s[ldp->rw] & ldp->rmsk; + if (ldp->rndprc < NBITS) + { + i = ldp->rw + 1; + while (i < NI) { - i = ldp->rw + 1; - while( i < NI ) - { - if( s[i] ) - r |= 1; - s[i] = 0; - ++i; - } + if (s[i]) + r |= 1; + s[i] = 0; + ++i; } -s[ldp->rw] &= ~ldp->rmsk; -if( (r & ldp->rmbit) != 0 ) + } + s[ldp->rw] &= ~ldp->rmsk; + if ((r & ldp->rmbit) != 0) + { + if (r == ldp->rmbit) { - if( r == ldp->rmbit ) - { - if( lost == 0 ) - { /* round to even */ - if( (s[ldp->re] & ldp->rebit) == 0 ) - goto mddone; - } - else - { - if( subflg != 0 ) - goto mddone; - } - } - eaddm( ldp->rbit, s ); + if (lost == 0) + { /* round to even */ + if ((s[ldp->re] & ldp->rebit) == 0) + goto mddone; + } + else + { + if (subflg != 0) + goto mddone; + } } + eaddm (ldp->rbit, s); + } mddone: #if IBMPC -if( (exp <= 0) && (ldp->rndprc != NBITS) ) + if ((exp <= 0) && (ldp->rndprc != NBITS)) #else -if( (exp <= 0) && (ldp->rndprc != 64) && (ldp->rndprc != NBITS) ) + if ((exp <= 0) && (ldp->rndprc != 64) && (ldp->rndprc != NBITS)) #endif - { - eshup1(s); - } -if( s[2] != 0 ) - { /* overflow on roundoff */ - eshdn1(s); - exp += 1; - } + { + eshup1 (s); + } + if (s[2] != 0) + { /* overflow on roundoff */ + eshdn1 (s); + exp += 1; + } mdfin: -s[NI-1] = 0; -if( exp >= 32767L ) - { + s[NI - 1] = 0; + if (exp >= 32767L) + { #ifndef USE_INFINITY -overf: + overf: #endif #ifdef USE_INFINITY - s[1] = 32767; - for( i=2; irndprc < 64) || (ldp->rndprc == 113) ) - { - s[ldp->rw] &= ~ldp->rmsk; - if( ldp->rndprc == 24 ) - { - s[5] = 0; - s[6] = 0; - } - } -#endif - return; + s[1] = 32766; + s[2] = 0; + for (i = M + 1; i < NI - 1; i++) + s[i] = 0xffff; + s[NI - 1] = 0; + if ((ldp->rndprc < 64) || (ldp->rndprc == 113)) + { + s[ldp->rw] &= ~ldp->rmsk; + if (ldp->rndprc == 24) + { + s[5] = 0; + s[6] = 0; + } } -if( exp < 0 ) - s[1] = 0; -else - s[1] = (unsigned short )exp; +#endif + return; + } + if (exp < 0) + s[1] = 0; + else + s[1] = (unsigned short) exp; } @@ -1369,133 +1420,137 @@ else ; esub( a, b, c, ldp ); c = b - a */ -static void esub(_CONST short unsigned int *a, _CONST short unsigned int *b, short unsigned int *c, LDPARMS *ldp) +static void +esub (_CONST short unsigned int *a, _CONST short unsigned int *b, + short unsigned int *c, LDPARMS * ldp) { #ifdef NANS -if( eisnan(a) ) - { - emov (a, c); - return; - } -if( eisnan(b) ) - { - emov(b,c); - return; - } + if (eisnan (a)) + { + emov (a, c); + return; + } + if (eisnan (b)) + { + emov (b, c); + return; + } /* Infinity minus infinity is a NaN. * Test for subtracting infinities of the same sign. */ -if( eisinf(a) && eisinf(b) && ((eisneg (a) ^ eisneg (b)) == 0)) - { - mtherr( "esub", DOMAIN ); - enan( c, NBITS ); - return; - } + if (eisinf (a) && eisinf (b) && ((eisneg (a) ^ eisneg (b)) == 0)) + { + mtherr ("esub", DOMAIN); + enan (c, NBITS); + return; + } #endif -eadd1( a, b, c, 1, ldp ); + eadd1 (a, b, c, 1, ldp); } -static void eadd1(_CONST short unsigned int *a, _CONST short unsigned int *b, short unsigned int *c, int subflg, LDPARMS *ldp) +static void +eadd1 (_CONST short unsigned int *a, _CONST short unsigned int *b, + short unsigned int *c, int subflg, LDPARMS * ldp) { -unsigned short ai[NI], bi[NI], ci[NI]; -int i, lost, j, k; -long lt, lta, ltb; + unsigned short ai[NI], bi[NI], ci[NI]; + int i, lost, j, k; + long lt, lta, ltb; #ifdef USE_INFINITY -if( eisinf(a) ) - { - emov(a,c); - if( subflg ) - eneg(c); - return; - } -if( eisinf(b) ) - { - emov(b,c); - return; - } + if (eisinf (a)) + { + emov (a, c); + if (subflg) + eneg (c); + return; + } + if (eisinf (b)) + { + emov (b, c); + return; + } #endif -emovi( a, ai ); -emovi( b, bi ); -if( subflg ) - ai[0] = ~ai[0]; + emovi (a, ai); + emovi (b, bi); + if (subflg) + ai[0] = ~ai[0]; /* compare exponents */ -lta = ai[E]; -ltb = bi[E]; -lt = lta - ltb; -if( lt > 0L ) - { /* put the larger number in bi */ - emovz( bi, ci ); - emovz( ai, bi ); - emovz( ci, ai ); - ltb = bi[E]; - lt = -lt; - } -lost = 0; -if( lt != 0L ) - { - if( lt < (long )(-NBITS-1) ) - goto done; /* answer same as larger addend */ - k = (int )lt; - lost = eshift( ai, k ); /* shift the smaller number down */ - } -else - { + lta = ai[E]; + ltb = bi[E]; + lt = lta - ltb; + if (lt > 0L) + { /* put the larger number in bi */ + emovz (bi, ci); + emovz (ai, bi); + emovz (ci, ai); + ltb = bi[E]; + lt = -lt; + } + lost = 0; + if (lt != 0L) + { + if (lt < (long) (-NBITS - 1)) + goto done; /* answer same as larger addend */ + k = (int) lt; + lost = eshift (ai, k); /* shift the smaller number down */ + } + else + { /* exponents were the same, so must compare significands */ - i = ecmpm( ai, bi ); - if( i == 0 ) - { /* the numbers are identical in magnitude */ - /* if different signs, result is zero */ - if( ai[0] != bi[0] ) - { - eclear(c); - return; - } - /* if same sign, result is double */ - /* double denomalized tiny number */ - if( (bi[E] == 0) && ((bi[3] & 0x8000) == 0) ) - { - eshup1( bi ); - goto done; - } - /* add 1 to exponent unless both are zero! */ - for( j=1; j 0 ) - { /* put the larger number in bi */ - emovz( bi, ci ); - emovz( ai, bi ); - emovz( ci, ai ); + ltb += 1; + break; } + } + bi[E] = (unsigned short) ltb; + goto done; } -if( ai[0] == bi[0] ) - { - eaddm( ai, bi ); - subflg = 0; + if (i > 0) + { /* put the larger number in bi */ + emovz (bi, ci); + emovz (ai, bi); + emovz (ci, ai); } -else - { - esubm( ai, bi ); - subflg = 1; - } -emdnorm( bi, lost, subflg, ltb, 64, ldp ); + } + if (ai[0] == bi[0]) + { + eaddm (ai, bi); + subflg = 0; + } + else + { + esubm (ai, bi); + subflg = 1; + } + emdnorm (bi, lost, subflg, ltb, 64, ldp); done: -emovo( bi, c, ldp ); + emovo (bi, c, ldp); } @@ -1507,99 +1562,101 @@ emovo( bi, c, ldp ); ; LDPARMS *ldp; ; ediv( a, b, c, ldp ); c = b / a */ -static void ediv(_CONST short unsigned int *a, _CONST short unsigned int *b, short unsigned int *c, LDPARMS *ldp) +static void +ediv (_CONST short unsigned int *a, _CONST short unsigned int *b, + short unsigned int *c, LDPARMS * ldp) { -unsigned short ai[NI], bi[NI]; -int i; -long lt, lta, ltb; + unsigned short ai[NI], bi[NI]; + int i; + long lt, lta, ltb; #ifdef NANS /* Return any NaN input. */ -if( eisnan(a) ) - { - emov(a,c); - return; - } -if( eisnan(b) ) - { - emov(b,c); - return; - } + if (eisnan (a)) + { + emov (a, c); + return; + } + if (eisnan (b)) + { + emov (b, c); + return; + } /* Zero over zero, or infinity over infinity, is a NaN. */ -if( ((ecmp(a,ezero) == 0) && (ecmp(b,ezero) == 0)) - || (eisinf (a) && eisinf (b)) ) - { - mtherr( "ediv", DOMAIN ); - enan( c, NBITS ); - return; - } + if (((ecmp (a, ezero) == 0) && (ecmp (b, ezero) == 0)) + || (eisinf (a) && eisinf (b))) + { + mtherr ("ediv", DOMAIN); + enan (c, NBITS); + return; + } #endif /* Infinity over anything else is infinity. */ #ifdef USE_INFINITY -if( eisinf(b) ) - { - if( eisneg(a) ^ eisneg(b) ) - *(c+(NE-1)) = 0x8000; - else - *(c+(NE-1)) = 0; - einfin(c, ldp); - return; - } -if( eisinf(a) ) - { - eclear(c); - return; - } + if (eisinf (b)) + { + if (eisneg (a) ^ eisneg (b)) + *(c + (NE - 1)) = 0x8000; + else + *(c + (NE - 1)) = 0; + einfin (c, ldp); + return; + } + if (eisinf (a)) + { + eclear (c); + return; + } #endif -emovi( a, ai ); -emovi( b, bi ); -lta = ai[E]; -ltb = bi[E]; -if( bi[E] == 0 ) - { /* See if numerator is zero. */ - for( i=1; i 64 -static void e113toe(short unsigned int *pe, short unsigned int *y, LDPARMS *ldp) +static void +e113toe (short unsigned int *pe, short unsigned int *y, LDPARMS * ldp) { -register unsigned short r; -unsigned short *e, *p; -unsigned short yy[NI]; -int denorm, i; + register unsigned short r; + unsigned short *e, *p; + unsigned short yy[NI]; + int denorm, i; -e = pe; -denorm = 0; -ecleaz(yy); + e = pe; + denorm = 0; + ecleaz (yy); #ifdef IBMPC -e += 7; + e += 7; #endif -r = *e; -yy[0] = 0; -if( r & 0x8000 ) - yy[0] = 0xffff; -r &= 0x7fff; + r = *e; + yy[0] = 0; + if (r & 0x8000) + yy[0] = 0xffff; + r &= 0x7fff; #ifdef USE_INFINITY -if( r == 0x7fff ) - { + if (r == 0x7fff) + { #ifdef NANS #ifdef IBMPC - for( i=0; i<7; i++ ) - { - if( pe[i] != 0 ) - { - enan( y, NBITS ); - return; - } - } -#else /* !IBMPC */ - for( i=1; i<8; i++ ) - { - if( pe[i] != 0 ) - { - enan( y, NBITS ); - return; - } - } + for (i = 0; i < 7; i++) + { + if (pe[i] != 0) + { + enan (y, NBITS); + return; + } + } +#else /* !IBMPC */ + for (i = 1; i < 8; i++) + { + if (pe[i] != 0) + { + enan (y, NBITS); + return; + } + } #endif /* !IBMPC */ #endif /* NANS */ - eclear( y ); - einfin( y, ldp ); - if( *e & 0x8000 ) - eneg(y); - return; - } -#endif /* INFINITY */ -yy[E] = r; -p = &yy[M + 1]; + eclear (y); + einfin (y, ldp); + if (*e & 0x8000) + eneg (y); + return; + } +#endif /* INFINITY */ + yy[E] = r; + p = &yy[M + 1]; #ifdef IBMPC -for( i=0; i<7; i++ ) - *p++ = *(--e); -#else /* IBMPC */ -++e; -for( i=0; i<7; i++ ) - *p++ = *e++; -#endif /* IBMPC */ + for (i = 0; i < 7; i++) + *p++ = *(--e); +#else /* IBMPC */ + ++e; + for (i = 0; i < 7; i++) + *p++ = *e++; +#endif /* IBMPC */ /* If denormal, remove the implied bit; else shift down 1. */ -if( r == 0 ) - { - yy[M] = 0; - } -else - { - yy[M] = 1; - eshift( yy, -1 ); - } -emovo(yy,y,ldp); + if (r == 0) + { + yy[M] = 0; + } + else + { + yy[M] = 1; + eshift (yy, -1); + } + emovo (yy, y, ldp); } /* move out internal format to ieee long double */ -static void toe113(short unsigned int *a, short unsigned int *b) +static void +toe113 (short unsigned int *a, short unsigned int *b) { -register unsigned short *p, *q; -unsigned short i; + register unsigned short *p, *q; + unsigned short i; #ifdef NANS -if( eiisnan(a) ) - { - enan( b, 113 ); - return; - } + if (eiisnan (a)) + { + enan (b, 113); + return; + } #endif -p = a; + p = a; #ifdef MIEEE -q = b; + q = b; #else -q = b + 7; /* point to output exponent */ + q = b + 7; /* point to output exponent */ #endif /* If not denormal, delete the implied bit. */ -if( a[E] != 0 ) - { - eshup1 (a); - } + if (a[E] != 0) + { + eshup1 (a); + } /* combine sign and exponent */ -i = *p++; + i = *p++; #ifdef MIEEE -if( i ) - *q++ = *p++ | 0x8000; -else - *q++ = *p++; + if (i) + *q++ = *p++ | 0x8000; + else + *q++ = *p++; #else -if( i ) - *q-- = *p++ | 0x8000; -else - *q-- = *p++; + if (i) + *q-- = *p++ | 0x8000; + else + *q-- = *p++; #endif /* skip over guard word */ -++p; + ++p; /* move the significand */ #ifdef MIEEE -for (i = 0; i < 7; i++) - *q++ = *p++; + for (i = 0; i < 7; i++) + *q++ = *p++; #else -for (i = 0; i < 7; i++) - *q-- = *p++; + for (i = 0; i < 7; i++) + *q-- = *p++; #endif } #endif /* LDBL_MANT_DIG > 64 */ #if LDBL_MANT_DIG == 64 -static void e64toe(short unsigned int *pe, short unsigned int *y, LDPARMS *ldp) +static void +e64toe (short unsigned int *pe, short unsigned int *y, LDPARMS * ldp) { -unsigned short yy[NI]; -unsigned short *p, *q, *e; -int i; + unsigned short yy[NI]; + unsigned short *p, *q, *e; + int i; -e = pe; -p = yy; + e = pe; + p = yy; -for( i=0; i>= 4; -/* If zero exponent, then the significand is denormalized. - * So, take back the understood high significand bit. */ -if( r == 0 ) + if (((pe[3] & 0xf) != 0) || (pe[2] != 0) + || (pe[1] != 0) || (pe[0] != 0)) { - denorm = 1; - yy[M] &= ~0x10; + enan (y, NBITS); + return; + } +#else /* !IBMPC */ + if (((pe[0] & 0xf) != 0) || (pe[1] != 0) + || (pe[2] != 0) || (pe[3] != 0)) + { + enan (y, NBITS); + return; } -r += EXONE - 01777; -yy[E] = r; -p = &yy[M+1]; -#ifdef IBMPC -*p++ = *(--e); -*p++ = *(--e); -*p++ = *(--e); -#else /* !IBMPC */ -++e; -*p++ = *e++; -*p++ = *e++; -*p++ = *e++; #endif /* !IBMPC */ -(void )eshift( yy, -5 ); -if( denorm ) - { /* if zero exponent, then normalize the significand */ - if( (k = enormlz(yy)) > NBITS ) - ecleazs(yy); - else - yy[E] -= (unsigned short )(k-1); - } -emovo( yy, y, ldp ); +#endif /* NANS */ + eclear (y); + einfin (y, ldp); + if (yy[0]) + eneg (y); + return; + } +#endif + r >>= 4; +/* If zero exponent, then the significand is denormalized. + * So, take back the understood high significand bit. */ + if (r == 0) + { + denorm = 1; + yy[M] &= ~0x10; + } + r += EXONE - 01777; + yy[E] = r; + p = &yy[M + 1]; +#ifdef IBMPC + *p++ = *(--e); + *p++ = *(--e); + *p++ = *(--e); +#else /* !IBMPC */ + ++e; + *p++ = *e++; + *p++ = *e++; + *p++ = *e++; +#endif /* !IBMPC */ + (void) eshift (yy, -5); + if (denorm) + { /* if zero exponent, then normalize the significand */ + if ((k = enormlz (yy)) > NBITS) + ecleazs (yy); + else + yy[E] -= (unsigned short) (k - 1); + } + emovo (yy, y, ldp); #endif /* !DEC */ } @@ -2078,94 +2142,97 @@ emovo( yy, y, ldp ); #ifdef DEC -static void etoe53( x, e ) -unsigned short *x, *e; +static void +etoe53 (x, e) + unsigned short *x, *e; { -etodec( x, e ); /* see etodec.c */ + etodec (x, e); /* see etodec.c */ } -static void toe53( x, y ) -unsigned short *x, *y; +static void +toe53 (x, y) + unsigned short *x, *y; { -todec( x, y ); + todec (x, y); } #else -static void toe53(short unsigned int *x, short unsigned int *y) +static void +toe53 (short unsigned int *x, short unsigned int *y) { -unsigned short i; -unsigned short *p; + unsigned short i; + unsigned short *p; #ifdef NANS -if( eiisnan(x) ) - { - enan( y, 53 ); - return; - } + if (eiisnan (x)) + { + enan (y, 53); + return; + } #endif -p = &x[0]; + p = &x[0]; #ifdef IBMPC -y += 3; + y += 3; #endif #ifdef DEC -y += 3; + y += 3; #endif -*y = 0; /* output high order */ -if( *p++ ) - *y = 0x8000; /* output sign bit */ + *y = 0; /* output high order */ + if (*p++) + *y = 0x8000; /* output sign bit */ -i = *p++; -if( i >= (unsigned int )2047 ) - { /* Saturate at largest number less than infinity. */ + i = *p++; + if (i >= (unsigned int) 2047) + { /* Saturate at largest number less than infinity. */ #ifdef USE_INFINITY - *y |= 0x7ff0; + *y |= 0x7ff0; #ifdef IBMPC - *(--y) = 0; - *(--y) = 0; - *(--y) = 0; + *(--y) = 0; + *(--y) = 0; + *(--y) = 0; #else /* !IBMPC */ - ++y; - *y++ = 0; - *y++ = 0; - *y++ = 0; + ++y; + *y++ = 0; + *y++ = 0; + *y++ = 0; #endif /* IBMPC */ #else /* !USE_INFINITY */ - *y |= (unsigned short )0x7fef; + *y |= (unsigned short) 0x7fef; #ifdef IBMPC - *(--y) = 0xffff; - *(--y) = 0xffff; - *(--y) = 0xffff; + *(--y) = 0xffff; + *(--y) = 0xffff; + *(--y) = 0xffff; #else /* !IBMPC */ - ++y; - *y++ = 0xffff; - *y++ = 0xffff; - *y++ = 0xffff; + ++y; + *y++ = 0xffff; + *y++ = 0xffff; + *y++ = 0xffff; #endif #endif /* !USE_INFINITY */ - return; - } -if( i == 0 ) - { - (void )eshift( x, 4 ); - } -else - { - i <<= 4; - (void )eshift( x, 5 ); - } -i |= *p++ & (unsigned short )0x0f; /* *p = xi[M] */ -*y |= (unsigned short )i; /* high order output already has sign bit set */ + return; + } + if (i == 0) + { + (void) eshift (x, 4); + } + else + { + i <<= 4; + (void) eshift (x, 5); + } + i |= *p++ & (unsigned short) 0x0f; /* *p = xi[M] */ + *y |= (unsigned short) i; /* high order output already has sign bit set */ #ifdef IBMPC -*(--y) = *p++; -*(--y) = *p++; -*(--y) = *p; + *(--y) = *p++; + *(--y) = *p++; + *(--y) = *p; #else /* !IBMPC */ -++y; -*y++ = *p++; -*y++ = *p++; -*y++ = *p++; + ++y; + *y++ = *p++; + *y++ = *p++; + *y++ = *p++; #endif /* !IBMPC */ } @@ -2179,158 +2246,160 @@ i |= *p++ & (unsigned short )0x0f; /* *p = xi[M] */ ; unsigned short x[N+2]; ; dtox( &d, x ); */ -void e24toe( short unsigned int *pe, short unsigned int *y, LDPARMS *ldp ) +void +e24toe (short unsigned int *pe, short unsigned int *y, LDPARMS * ldp) { -register unsigned short r; -register unsigned short *p, *e; -unsigned short yy[NI]; -int denorm, k; + register unsigned short r; + register unsigned short *p, *e; + unsigned short yy[NI]; + int denorm, k; -e = pe; -denorm = 0; /* flag if denormalized number */ -ecleaz(yy); + e = pe; + denorm = 0; /* flag if denormalized number */ + ecleaz (yy); #ifdef IBMPC -e += 1; + e += 1; #endif #ifdef DEC -e += 1; + e += 1; #endif -r = *e; -yy[0] = 0; -if( r & 0x8000 ) - yy[0] = 0xffff; -yy[M] = (r & 0x7f) | 0200; -r &= ~0x807f; /* strip sign and 7 significand bits */ + r = *e; + yy[0] = 0; + if (r & 0x8000) + yy[0] = 0xffff; + yy[M] = (r & 0x7f) | 0200; + r &= ~0x807f; /* strip sign and 7 significand bits */ #ifdef USE_INFINITY -if( r == 0x7f80 ) - { + if (r == 0x7f80) + { #ifdef NANS #ifdef MIEEE - if( ((pe[0] & 0x7f) != 0) || (pe[1] != 0) ) - { - enan( y, NBITS ); - return; - } -#else /* !MIEEE */ - if( ((pe[1] & 0x7f) != 0) || (pe[0] != 0) ) - { - enan( y, NBITS ); - return; - } -#endif /* !MIEEE */ -#endif /* NANS */ - eclear( y ); - einfin( y, ldp ); - if( yy[0] ) - eneg(y); - return; - } -#endif -r >>= 7; -/* If zero exponent, then the significand is denormalized. - * So, take back the understood high significand bit. */ -if( r == 0 ) + if (((pe[0] & 0x7f) != 0) || (pe[1] != 0)) { - denorm = 1; - yy[M] &= ~0200; + enan (y, NBITS); + return; } -r += EXONE - 0177; -yy[E] = r; -p = &yy[M+1]; +#else /* !MIEEE */ + if (((pe[1] & 0x7f) != 0) || (pe[0] != 0)) + { + enan (y, NBITS); + return; + } +#endif /* !MIEEE */ +#endif /* NANS */ + eclear (y); + einfin (y, ldp); + if (yy[0]) + eneg (y); + return; + } +#endif + r >>= 7; +/* If zero exponent, then the significand is denormalized. + * So, take back the understood high significand bit. */ + if (r == 0) + { + denorm = 1; + yy[M] &= ~0200; + } + r += EXONE - 0177; + yy[E] = r; + p = &yy[M + 1]; #ifdef IBMPC -*p++ = *(--e); + *p++ = *(--e); #endif #ifdef DEC -*p++ = *(--e); + *p++ = *(--e); #endif #ifdef MIEEE -++e; -*p++ = *e++; + ++e; + *p++ = *e++; #endif -(void )eshift( yy, -8 ); -if( denorm ) - { /* if zero exponent, then normalize the significand */ - if( (k = enormlz(yy)) > NBITS ) - ecleazs(yy); - else - yy[E] -= (unsigned short )(k-1); - } -emovo( yy, y, ldp ); + (void) eshift (yy, -8); + if (denorm) + { /* if zero exponent, then normalize the significand */ + if ((k = enormlz (yy)) > NBITS) + ecleazs (yy); + else + yy[E] -= (unsigned short) (k - 1); + } + emovo (yy, y, ldp); } -static void toe24(short unsigned int *x, short unsigned int *y) +static void +toe24 (short unsigned int *x, short unsigned int *y) { -unsigned short i; -unsigned short *p; + unsigned short i; + unsigned short *p; #ifdef NANS -if( eiisnan(x) ) - { - enan( y, 24 ); - return; - } + if (eiisnan (x)) + { + enan (y, 24); + return; + } #endif -p = &x[0]; + p = &x[0]; #ifdef IBMPC -y += 1; + y += 1; #endif #ifdef DEC -y += 1; + y += 1; #endif -*y = 0; /* output high order */ -if( *p++ ) - *y = 0x8000; /* output sign bit */ + *y = 0; /* output high order */ + if (*p++) + *y = 0x8000; /* output sign bit */ -i = *p++; -if( i >= 255 ) - { /* Saturate at largest number less than infinity. */ + i = *p++; + if (i >= 255) + { /* Saturate at largest number less than infinity. */ #ifdef USE_INFINITY - *y |= (unsigned short )0x7f80; + *y |= (unsigned short) 0x7f80; #ifdef IBMPC - *(--y) = 0; + *(--y) = 0; #endif #ifdef DEC - *(--y) = 0; + *(--y) = 0; #endif #ifdef MIEEE - ++y; - *y = 0; + ++y; + *y = 0; #endif #else /* !USE_INFINITY */ - *y |= (unsigned short )0x7f7f; + *y |= (unsigned short) 0x7f7f; #ifdef IBMPC - *(--y) = 0xffff; + *(--y) = 0xffff; #endif #ifdef DEC - *(--y) = 0xffff; + *(--y) = 0xffff; #endif #ifdef MIEEE - ++y; - *y = 0xffff; + ++y; + *y = 0xffff; #endif #endif /* !USE_INFINITY */ - return; - } -if( i == 0 ) - { - (void )eshift( x, 7 ); - } -else - { - i <<= 7; - (void )eshift( x, 8 ); - } -i |= *p++ & (unsigned short )0x7f; /* *p = xi[M] */ -*y |= i; /* high order output already has sign bit set */ + return; + } + if (i == 0) + { + (void) eshift (x, 7); + } + else + { + i <<= 7; + (void) eshift (x, 8); + } + i |= *p++ & (unsigned short) 0x7f; /* *p = xi[M] */ + *y |= i; /* high order output already has sign bit set */ #ifdef IBMPC -*(--y) = *p; + *(--y) = *p; #endif #ifdef DEC -*(--y) = *p; + *(--y) = *p; #endif #ifdef MIEEE -++y; -*y = *p; + ++y; + *y = *p; #endif } #endif /* LDBL_MANT_DIG == 24 */ @@ -2345,64 +2414,65 @@ i |= *p++ & (unsigned short )0x7f; /* *p = xi[M] */ * -1 if a < b * -2 if either a or b is a NaN. */ -static int ecmp(_CONST short unsigned int *a, _CONST short unsigned int *b) +static int +ecmp (_CONST short unsigned int *a, _CONST short unsigned int *b) { -unsigned short ai[NI], bi[NI]; -register unsigned short *p, *q; -register int i; -int msign; + unsigned short ai[NI], bi[NI]; + register unsigned short *p, *q; + register int i; + int msign; #ifdef NANS -if (eisnan (a) || eisnan (b)) - return( -2 ); + if (eisnan (a) || eisnan (b)) + return (-2); #endif -emovi( a, ai ); -p = ai; -emovi( b, bi ); -q = bi; + emovi (a, ai); + p = ai; + emovi (b, bi); + q = bi; -if( *p != *q ) - { /* the signs are different */ + if (*p != *q) + { /* the signs are different */ /* -0 equals + 0 */ - for( i=1; i 0 ); + return (0); + nzro: + if (*p == 0) + return (1); + else + return (-1); + } +/* both are the same sign */ + if (*p == 0) + msign = 1; + else + msign = -1; + i = NI - 1; + do + { + if (*p++ != *q++) + { + goto diff; + } + } + while (--i > 0); -return(0); /* equality */ + return (0); /* equality */ diff: -if( *(--p) > *(--q) ) - return( msign ); /* p is bigger */ -else - return( -msign ); /* p is littler */ + if (*(--p) > *(--q)) + return (msign); /* p is bigger */ + else + return (-msign); /* p is littler */ } @@ -2412,64 +2482,65 @@ else ; Shifts significand area up or down by the number of bits ; given by the variable sc. */ -static int eshift(short unsigned int *x, int sc) +static int +eshift (short unsigned int *x, int sc) { -unsigned short lost; -unsigned short *p; + unsigned short lost; + unsigned short *p; -if( sc == 0 ) - return( 0 ); + if (sc == 0) + return (0); -lost = 0; -p = x + NI-1; + lost = 0; + p = x + NI - 1; -if( sc < 0 ) + if (sc < 0) + { + sc = -sc; + while (sc >= 16) { - sc = -sc; - while( sc >= 16 ) - { - lost |= *p; /* remember lost bits */ - eshdn6(x); - sc -= 16; - } - - while( sc >= 8 ) - { - lost |= *p & 0xff; - eshdn8(x); - sc -= 8; - } - - while( sc > 0 ) - { - lost |= *p & 1; - eshdn1(x); - sc -= 1; - } + lost |= *p; /* remember lost bits */ + eshdn6 (x); + sc -= 16; } -else + + while (sc >= 8) { - while( sc >= 16 ) - { - eshup6(x); - sc -= 16; - } - - while( sc >= 8 ) - { - eshup8(x); - sc -= 8; - } - - while( sc > 0 ) - { - eshup1(x); - sc -= 1; - } + lost |= *p & 0xff; + eshdn8 (x); + sc -= 8; } -if( lost ) - lost = 1; -return( (int )lost ); + + while (sc > 0) + { + lost |= *p & 1; + eshdn1 (x); + sc -= 1; + } + } + else + { + while (sc >= 16) + { + eshup6 (x); + sc -= 16; + } + + while (sc >= 8) + { + eshup8 (x); + sc -= 8; + } + + while (sc > 0) + { + eshup1 (x); + sc -= 1; + } + } + if (lost) + lost = 1; + return ((int) lost); } @@ -2480,68 +2551,69 @@ return( (int )lost ); ; Shift normalizes the significand area pointed to by argument ; shift count (up = positive) is returned. */ -static int enormlz(short unsigned int *x) +static int +enormlz (short unsigned int *x) { -register unsigned short *p; -int sc; + register unsigned short *p; + int sc; -sc = 0; -p = &x[M]; -if( *p != 0 ) - goto normdn; -++p; -if( *p & 0x8000 ) - return( 0 ); /* already normalized */ -while( *p == 0 ) - { - eshup6(x); - sc += 16; + sc = 0; + p = &x[M]; + if (*p != 0) + goto normdn; + ++p; + if (*p & 0x8000) + return (0); /* already normalized */ + while (*p == 0) + { + eshup6 (x); + sc += 16; /* With guard word, there are NBITS+16 bits available. * return true if all are zero. */ - if( sc > NBITS ) - return( sc ); - } + if (sc > NBITS) + return (sc); + } /* see if high byte is zero */ -while( (*p & 0xff00) == 0 ) - { - eshup8(x); - sc += 8; - } + while ((*p & 0xff00) == 0) + { + eshup8 (x); + sc += 8; + } /* now shift 1 bit at a time */ -while( (*p & 0x8000) == 0) + while ((*p & 0x8000) == 0) + { + eshup1 (x); + sc += 1; + if (sc > (NBITS + 16)) { - eshup1(x); - sc += 1; - if( sc > (NBITS+16) ) - { - mtherr( "enormlz", UNDERFLOW ); - return( sc ); - } + mtherr ("enormlz", UNDERFLOW); + return (sc); } -return( sc ); + } + return (sc); /* Normalize by shifting down out of the high guard word of the significand */ normdn: -if( *p & 0xff00 ) - { - eshdn8(x); - sc -= 8; - } -while( *p != 0 ) - { - eshdn1(x); - sc -= 1; + if (*p & 0xff00) + { + eshdn8 (x); + sc -= 8; + } + while (*p != 0) + { + eshdn1 (x); + sc -= 1; - if( sc < -NBITS ) - { - mtherr( "enormlz", OVERFLOW ); - return( sc ); - } + if (sc < -NBITS) + { + mtherr ("enormlz", OVERFLOW); + return (sc); } -return( sc ); + } + return (sc); } @@ -2555,8 +2627,7 @@ return( sc ); #define MAXP 4096 #if NE == 10 -static _CONST unsigned short etens[NTEN + 1][NE] = -{ +static _CONST unsigned short etens[NTEN + 1][NE] = { {0x6576, 0x4a92, 0x804a, 0x153f, 0xc94c, 0x979a, 0x8a20, 0x5202, 0xc460, 0x7525,}, /* 10**4096 */ {0x6a32, 0xce52, 0x329a, 0x28ce, @@ -2585,8 +2656,7 @@ static _CONST unsigned short etens[NTEN + 1][NE] = 0x0000, 0x0000, 0x0000, 0x0000, 0xa000, 0x4002,}, /* 10**1 */ }; -static _CONST unsigned short emtens[NTEN + 1][NE] = -{ +static _CONST unsigned short emtens[NTEN + 1][NE] = { {0x2030, 0xcffc, 0xa1c3, 0x8123, 0x2de3, 0x9fde, 0xd2ce, 0x04c8, 0xa6dd, 0x0ad8,}, /* 10**-4096 */ {0x8264, 0xd2cb, 0xf2ea, 0x12d4, @@ -2615,36 +2685,36 @@ static _CONST unsigned short emtens[NTEN + 1][NE] = 0xcccc, 0xcccc, 0xcccc, 0xcccc, 0xcccc, 0x3ffb,}, /* 10**-1 */ }; #else -static _CONST unsigned short etens[NTEN+1][NE] = { -{0xc94c,0x979a,0x8a20,0x5202,0xc460,0x7525,},/* 10**4096 */ -{0xa74d,0x5de4,0xc53d,0x3b5d,0x9e8b,0x5a92,},/* 10**2048 */ -{0x650d,0x0c17,0x8175,0x7586,0xc976,0x4d48,}, -{0xcc65,0x91c6,0xa60e,0xa0ae,0xe319,0x46a3,}, -{0xddbc,0xde8d,0x9df9,0xebfb,0xaa7e,0x4351,}, -{0xc66f,0x8cdf,0x80e9,0x47c9,0x93ba,0x41a8,}, -{0x3cbf,0xa6d5,0xffcf,0x1f49,0xc278,0x40d3,}, -{0xf020,0xb59d,0x2b70,0xada8,0x9dc5,0x4069,}, -{0x0000,0x0000,0x0400,0xc9bf,0x8e1b,0x4034,}, -{0x0000,0x0000,0x0000,0x2000,0xbebc,0x4019,}, -{0x0000,0x0000,0x0000,0x0000,0x9c40,0x400c,}, -{0x0000,0x0000,0x0000,0x0000,0xc800,0x4005,}, -{0x0000,0x0000,0x0000,0x0000,0xa000,0x4002,}, /* 10**1 */ +static _CONST unsigned short etens[NTEN + 1][NE] = { + {0xc94c, 0x979a, 0x8a20, 0x5202, 0xc460, 0x7525,}, /* 10**4096 */ + {0xa74d, 0x5de4, 0xc53d, 0x3b5d, 0x9e8b, 0x5a92,}, /* 10**2048 */ + {0x650d, 0x0c17, 0x8175, 0x7586, 0xc976, 0x4d48,}, + {0xcc65, 0x91c6, 0xa60e, 0xa0ae, 0xe319, 0x46a3,}, + {0xddbc, 0xde8d, 0x9df9, 0xebfb, 0xaa7e, 0x4351,}, + {0xc66f, 0x8cdf, 0x80e9, 0x47c9, 0x93ba, 0x41a8,}, + {0x3cbf, 0xa6d5, 0xffcf, 0x1f49, 0xc278, 0x40d3,}, + {0xf020, 0xb59d, 0x2b70, 0xada8, 0x9dc5, 0x4069,}, + {0x0000, 0x0000, 0x0400, 0xc9bf, 0x8e1b, 0x4034,}, + {0x0000, 0x0000, 0x0000, 0x2000, 0xbebc, 0x4019,}, + {0x0000, 0x0000, 0x0000, 0x0000, 0x9c40, 0x400c,}, + {0x0000, 0x0000, 0x0000, 0x0000, 0xc800, 0x4005,}, + {0x0000, 0x0000, 0x0000, 0x0000, 0xa000, 0x4002,}, /* 10**1 */ }; -static _CONST unsigned short emtens[NTEN+1][NE] = { -{0x2de4,0x9fde,0xd2ce,0x04c8,0xa6dd,0x0ad8,}, /* 10**-4096 */ -{0x4925,0x2de4,0x3436,0x534f,0xceae,0x256b,}, /* 10**-2048 */ -{0x87a6,0xc0bd,0xda57,0x82a5,0xa2a6,0x32b5,}, -{0x7133,0xd21c,0xdb23,0xee32,0x9049,0x395a,}, -{0xfa91,0x1939,0x637a,0x4325,0xc031,0x3cac,}, -{0xac7d,0xe4a0,0x64bc,0x467c,0xddd0,0x3e55,}, -{0x3f24,0xe9a5,0xa539,0xea27,0xa87f,0x3f2a,}, -{0x67de,0x94ba,0x4539,0x1ead,0xcfb1,0x3f94,}, -{0x4c2f,0xe15b,0xc44d,0x94be,0xe695,0x3fc9,}, -{0xfdc2,0xcefc,0x8461,0x7711,0xabcc,0x3fe4,}, -{0xd3c3,0x652b,0xe219,0x1758,0xd1b7,0x3ff1,}, -{0x3d71,0xd70a,0x70a3,0x0a3d,0xa3d7,0x3ff8,}, -{0xcccd,0xcccc,0xcccc,0xcccc,0xcccc,0x3ffb,}, /* 10**-1 */ +static _CONST unsigned short emtens[NTEN + 1][NE] = { + {0x2de4, 0x9fde, 0xd2ce, 0x04c8, 0xa6dd, 0x0ad8,}, /* 10**-4096 */ + {0x4925, 0x2de4, 0x3436, 0x534f, 0xceae, 0x256b,}, /* 10**-2048 */ + {0x87a6, 0xc0bd, 0xda57, 0x82a5, 0xa2a6, 0x32b5,}, + {0x7133, 0xd21c, 0xdb23, 0xee32, 0x9049, 0x395a,}, + {0xfa91, 0x1939, 0x637a, 0x4325, 0xc031, 0x3cac,}, + {0xac7d, 0xe4a0, 0x64bc, 0x467c, 0xddd0, 0x3e55,}, + {0x3f24, 0xe9a5, 0xa539, 0xea27, 0xa87f, 0x3f2a,}, + {0x67de, 0x94ba, 0x4539, 0x1ead, 0xcfb1, 0x3f94,}, + {0x4c2f, 0xe15b, 0xc44d, 0x94be, 0xe695, 0x3fc9,}, + {0xfdc2, 0xcefc, 0x8461, 0x7711, 0xabcc, 0x3fe4,}, + {0xd3c3, 0x652b, 0xe219, 0x1758, 0xd1b7, 0x3ff1,}, + {0x3d71, 0xd70a, 0x70a3, 0x0a3d, 0xa3d7, 0x3ff8,}, + {0xcccd, 0xcccc, 0xcccc, 0xcccc, 0xcccc, 0x3ffb,}, /* 10**-1 */ }; #endif @@ -2654,51 +2724,52 @@ static _CONST unsigned short emtens[NTEN+1][NE] = { #if 0 -void _IO_ldtostr(x, string, ndigs, flags, fmt) -long double *x; -char *string; -int ndigs; -int flags; -char fmt; +void +_IO_ldtostr (x, string, ndigs, flags, fmt) + long double *x; + char *string; + int ndigs; + int flags; + char fmt; { -unsigned short w[NI]; -char *t, *u; -LDPARMS rnd; -LDPARMS *ldp = &rnd; + unsigned short w[NI]; + char *t, *u; + LDPARMS rnd; + LDPARMS *ldp = &rnd; -rnd.rlast = -1; -rnd.rndprc = NBITS; + rnd.rlast = -1; + rnd.rndprc = NBITS; -if (sizeof(long double) == 16) - e113toe( (unsigned short *)x, w, ldp ); -else - e64toe( (unsigned short *)x, w, ldp ); + if (sizeof (long double) == 16) + e113toe ((unsigned short *) x, w, ldp); + else + e64toe ((unsigned short *) x, w, ldp); -etoasc( w, string, ndigs, -1, ldp ); -if( ndigs == 0 && flags == 0 ) - { - /* Delete the decimal point unless alternate format. */ - t = string; - while( *t != '.' ) - ++t; - u = t + 1; - while( *t != '\0' ) - *t++ = *u++; - } -if (*string == ' ') - { - t = string; - u = t + 1; - while( *t != '\0' ) - *t++ = *u++; - } -if (fmt == 'E') - { - t = string; - while( *t != 'e' ) - ++t; - *t = 'E'; - } + etoasc (w, string, ndigs, -1, ldp); + if (ndigs == 0 && flags == 0) + { + /* Delete the decimal point unless alternate format. */ + t = string; + while (*t != '.') + ++t; + u = t + 1; + while (*t != '\0') + *t++ = *u++; + } + if (*string == ' ') + { + t = string; + u = t + 1; + while (*t != '\0') + *t++ = *u++; + } + if (fmt == 'E') + { + t = string; + while (*t != 'e') + ++t; + *t = 'E'; + } } #endif @@ -2706,154 +2777,155 @@ if (fmt == 'E') /* This routine will not return more than NDEC+1 digits. */ char * -_ldtoa_r (struct _reent *ptr, long double d, int mode, int ndigits, int *decpt, - int *sign, char **rve) +_ldtoa_r (struct _reent *ptr, long double d, int mode, int ndigits, + int *decpt, int *sign, char **rve) { -unsigned short e[NI]; -char *s, *p; -int i, j, k; -int orig_ndigits; -LDPARMS rnd; -LDPARMS *ldp = &rnd; -char *outstr; -char outbuf[NDEC + MAX_EXP_DIGITS + 10]; -union uconv du; -du.d = d; + unsigned short e[NI]; + char *s, *p; + int i, j, k; + int orig_ndigits; + LDPARMS rnd; + LDPARMS *ldp = &rnd; + char *outstr; + char outbuf[NDEC + MAX_EXP_DIGITS + 10]; + union uconv du; + du.d = d; -orig_ndigits = ndigits; -rnd.rlast = -1; -rnd.rndprc = NBITS; + orig_ndigits = ndigits; + rnd.rlast = -1; + rnd.rndprc = NBITS; - _REENT_CHECK_MP(ptr); + _REENT_CHECK_MP (ptr); /* reentrancy addition to use mprec storage pool */ -if (_REENT_MP_RESULT(ptr)) - { - _REENT_MP_RESULT(ptr)->_k = _REENT_MP_RESULT_K(ptr); - _REENT_MP_RESULT(ptr)->_maxwds = 1 << _REENT_MP_RESULT_K(ptr); - Bfree (ptr, _REENT_MP_RESULT(ptr)); - _REENT_MP_RESULT(ptr) = 0; - } + if (_REENT_MP_RESULT (ptr)) + { + _REENT_MP_RESULT (ptr)->_k = _REENT_MP_RESULT_K (ptr); + _REENT_MP_RESULT (ptr)->_maxwds = 1 << _REENT_MP_RESULT_K (ptr); + Bfree (ptr, _REENT_MP_RESULT (ptr)); + _REENT_MP_RESULT (ptr) = 0; + } #if LDBL_MANT_DIG == 24 -e24toe( &du.pe, e, ldp ); + e24toe (&du.pe, e, ldp); #elif LDBL_MANT_DIG == 53 -e53toe( &du.pe, e, ldp ); + e53toe (&du.pe, e, ldp); #elif LDBL_MANT_DIG == 64 -e64toe( &du.pe, e, ldp ); + e64toe (&du.pe, e, ldp); #else -e113toe( &du.pe, e, ldp ); + e113toe (&du.pe, e, ldp); #endif -if( eisneg(e) ) - *sign = 1; -else - *sign = 0; + if (eisneg (e)) + *sign = 1; + else + *sign = 0; /* Mode 3 is "f" format. */ -if( mode != 3 ) - ndigits -= 1; + if (mode != 3) + ndigits -= 1; /* Mode 0 is for %.999 format, which is supposed to give a minimum length string that will convert back to the same binary value. For now, just ask for 20 digits which is enough but sometimes too many. */ -if( mode == 0 ) - ndigits = 20; + if (mode == 0) + ndigits = 20; /* This sanity limit must agree with the corresponding one in etoasc, to keep straight the returned value of outexpon. */ -if( ndigits > NDEC ) - ndigits = NDEC; + if (ndigits > NDEC) + ndigits = NDEC; -etoasc( e, outbuf, ndigits, mode, ldp ); -s = outbuf; -if( eisinf(e) || eisnan(e) ) - { - *decpt = 9999; - goto stripspaces; - } -*decpt = ldp->outexpon + 1; + etoasc (e, outbuf, ndigits, mode, ldp); + s = outbuf; + if (eisinf (e) || eisnan (e)) + { + *decpt = 9999; + goto stripspaces; + } + *decpt = ldp->outexpon + 1; /* Transform the string returned by etoasc into what the caller wants. */ /* Look for decimal point and delete it from the string. */ -s = outbuf; -while( *s != '\0' ) - { - if( *s == '.' ) - goto yesdecpt; - ++s; - } -goto nodecpt; + s = outbuf; + while (*s != '\0') + { + if (*s == '.') + goto yesdecpt; + ++s; + } + goto nodecpt; yesdecpt: /* Delete the decimal point. */ -while( *s != '\0' ) - { - *s = *(s+1); - ++s; - } + while (*s != '\0') + { + *s = *(s + 1); + ++s; + } nodecpt: /* Back up over the exponent field. */ -while( *s != 'E' && s > outbuf) - --s; -*s = '\0'; + while (*s != 'E' && s > outbuf) + --s; + *s = '\0'; stripspaces: /* Strip leading spaces and sign. */ -p = outbuf; -while( *p == ' ' || *p == '-') - ++p; + p = outbuf; + while (*p == ' ' || *p == '-') + ++p; /* Find new end of string. */ -s = outbuf; -while( (*s++ = *p++) != '\0' ) - ; ---s; + s = outbuf; + while ((*s++ = *p++) != '\0') + ; + --s; /* Strip trailing zeros. */ -if( mode == 2 ) - k = 1; -else if( ndigits > ldp->outexpon ) - k = ndigits; -else - k = ldp->outexpon; + if (mode == 2) + k = 1; + else if (ndigits > ldp->outexpon) + k = ndigits; + else + k = ldp->outexpon; -while( *(s-1) == '0' && ((s - outbuf) > k)) - *(--s) = '\0'; + while (*(s - 1) == '0' && ((s - outbuf) > k)) + *(--s) = '\0'; /* In f format, flush small off-scale values to zero. Rounding has been taken care of by etoasc. */ -if( mode == 3 && ((ndigits + ldp->outexpon) < 0)) - { - s = outbuf; - *s = '\0'; - *decpt = 0; - } + if (mode == 3 && ((ndigits + ldp->outexpon) < 0)) + { + s = outbuf; + *s = '\0'; + *decpt = 0; + } /* reentrancy addition to use mprec storage pool */ /* we want to have enough space to hold the formatted result */ -if (mode == 3) /* f format, account for sign + dec digits + decpt + frac */ - i = *decpt + orig_ndigits + 3; -else /* account for sign + max precision digs + E + exp sign + exponent */ - i = orig_ndigits + MAX_EXP_DIGITS + 4; + if (mode == 3) /* f format, account for sign + dec digits + decpt + frac */ + i = *decpt + orig_ndigits + 3; + else /* account for sign + max precision digs + E + exp sign + exponent */ + i = orig_ndigits + MAX_EXP_DIGITS + 4; -j = sizeof (__ULong); -for (_REENT_MP_RESULT_K(ptr) = 0; sizeof (_Bigint) - sizeof (__ULong) + j <= i; j <<= 1) - _REENT_MP_RESULT_K(ptr)++; -_REENT_MP_RESULT(ptr) = Balloc (ptr, _REENT_MP_RESULT_K(ptr)); + j = sizeof (__ULong); + for (_REENT_MP_RESULT_K (ptr) = 0; + sizeof (_Bigint) - sizeof (__ULong) + j <= i; j <<= 1) + _REENT_MP_RESULT_K (ptr)++; + _REENT_MP_RESULT (ptr) = Balloc (ptr, _REENT_MP_RESULT_K (ptr)); /* Copy from internal temporary buffer to permanent buffer. */ -outstr = (char *)_REENT_MP_RESULT(ptr); -strcpy (outstr, outbuf); + outstr = (char *) _REENT_MP_RESULT (ptr); + strcpy (outstr, outbuf); -if( rve ) - *rve = outstr + (s - outbuf); + if (rve) + *rve = outstr + (s - outbuf); -return outstr; + return outstr; } /* Routine used to tell if long double is NaN or Infinity or regular number. @@ -2864,345 +2936,347 @@ return outstr; int _ldcheck (long double *d) { -unsigned short e[NI]; -LDPARMS rnd; -LDPARMS *ldp = &rnd; + unsigned short e[NI]; + LDPARMS rnd; + LDPARMS *ldp = &rnd; -union uconv du; + union uconv du; -rnd.rlast = -1; -rnd.rndprc = NBITS; -du.d = *d; + rnd.rlast = -1; + rnd.rndprc = NBITS; + du.d = *d; #if LDBL_MANT_DIG == 24 -e24toe( &du.pe, e, ldp ); + e24toe (&du.pe, e, ldp); #elif LDBL_MANT_DIG == 53 -e53toe( &du.pe, e, ldp ); + e53toe (&du.pe, e, ldp); #elif LDBL_MANT_DIG == 64 -e64toe( &du.pe, e, ldp ); + e64toe (&du.pe, e, ldp); #else -e113toe( &du.pe, e, ldp ); + e113toe (&du.pe, e, ldp); #endif -if( (e[NE-1] & 0x7fff) == 0x7fff ) - { + if ((e[NE - 1] & 0x7fff) == 0x7fff) + { #ifdef NANS - if( eisnan(e) ) - return( 1 ); + if (eisnan (e)) + return (1); #endif - return( 2 ); - } -else - return( 0 ); -} /* _ldcheck */ + return (2); + } + else + return (0); +} /* _ldcheck */ -static void etoasc(short unsigned int *x, char *string, int ndigits, int outformat, LDPARMS *ldp) +static void +etoasc (short unsigned int *x, char *string, int ndigits, int outformat, + LDPARMS * ldp) { -long digit; -unsigned short y[NI], t[NI], u[NI], w[NI]; -_CONST unsigned short *p, *r, *ten; -unsigned short sign; -int i, j, k, expon, rndsav, ndigs; -char *s, *ss; -unsigned short m; -unsigned short *equot = ldp->equot; + long digit; + unsigned short y[NI], t[NI], u[NI], w[NI]; + _CONST unsigned short *p, *r, *ten; + unsigned short sign; + int i, j, k, expon, rndsav, ndigs; + char *s, *ss; + unsigned short m; + unsigned short *equot = ldp->equot; -ndigs = ndigits; -rndsav = ldp->rndprc; + ndigs = ndigits; + rndsav = ldp->rndprc; #ifdef NANS -if( eisnan(x) ) - { - sprintf( string, " NaN " ); - expon = 9999; - goto bxit; - } + if (eisnan (x)) + { + sprintf (string, " NaN "); + expon = 9999; + goto bxit; + } #endif -ldp->rndprc = NBITS; /* set to full precision */ -emov( x, y ); /* retain external format */ -if( y[NE-1] & 0x8000 ) - { - sign = 0xffff; - y[NE-1] &= 0x7fff; - } -else - { - sign = 0; - } -expon = 0; -ten = &etens[NTEN][0]; -emov( eone, t ); + ldp->rndprc = NBITS; /* set to full precision */ + emov (x, y); /* retain external format */ + if (y[NE - 1] & 0x8000) + { + sign = 0xffff; + y[NE - 1] &= 0x7fff; + } + else + { + sign = 0; + } + expon = 0; + ten = &etens[NTEN][0]; + emov (eone, t); /* Test for zero exponent */ -if( y[NE-1] == 0 ) + if (y[NE - 1] == 0) + { + for (k = 0; k < NE - 1; k++) { - for( k=0; k>= 1; + ediv (p, u, t, ldp); + efloor (t, w, ldp); + for (j = 0; j < NE - 1; j++) + { + if (t[j] != w[j]) + goto noint; + } + emov (t, u); + expon += (int) m; + noint: + p += NE; + m >>= 1; } -while( m != 0 ); + while (m != 0); /* Rescale from integer significand */ - u[NE-1] += y[NE-1] - (unsigned int )(EXONE + NBITS - 1); - emov( u, y ); + u[NE - 1] += y[NE - 1] - (unsigned int) (EXONE + NBITS - 1); + emov (u, y); /* Find power of 10 */ - emov( eone, t ); - m = MAXP; - p = &etens[0][0]; - while( ecmp( ten, u ) <= 0 ) - { - if( ecmp( p, u ) <= 0 ) - { - ediv( p, u, u, ldp ); - emul( p, t, t, ldp ); - expon += (int )m; - } - m >>= 1; - if( m == 0 ) - break; - p += NE; - } + emov (eone, t); + m = MAXP; + p = &etens[0][0]; + while (ecmp (ten, u) <= 0) + { + if (ecmp (p, u) <= 0) + { + ediv (p, u, u, ldp); + emul (p, t, t, ldp); + expon += (int) m; + } + m >>= 1; + if (m == 0) + break; + p += NE; } -else - { /* Number is less than 1.0 */ + } + else + { /* Number is less than 1.0 */ /* Pad significand with trailing decimal zeros. */ - if( y[NE-1] == 0 ) - { - while( (y[NE-2] & 0x8000) == 0 ) - { - emul( ten, y, y, ldp ); - expon -= 1; - } - } - else - { - emovi( y, w ); - for( i=0; i 0 ) - { - if( ecmp( p, w ) >= 0 ) - { - emul( r, w, w, ldp ); - emul( r, t, t, ldp ); - expon += k; - } - k /= 2; - if( k == 0 ) - break; - p += NE; - r += NE; - } - ediv( t, eone, t, ldp ); + if (y[NE - 1] == 0) + { + while ((y[NE - 2] & 0x8000) == 0) + { + emul (ten, y, y, ldp); + expon -= 1; + } } + else + { + emovi (y, w); + for (i = 0; i < NDEC + 1; i++) + { + if ((w[NI - 1] & 0x7) != 0) + break; +/* multiply by 10 */ + emovz (w, u); + eshdn1 (u); + eshdn1 (u); + eaddm (w, u); + u[1] += 3; + while (u[2] != 0) + { + eshdn1 (u); + u[1] += 1; + } + if (u[NI - 1] != 0) + break; + if (eone[NE - 1] <= u[1]) + break; + emovz (u, w); + expon -= 1; + } + emovo (w, y, ldp); + } + k = -MAXP; + p = &emtens[0][0]; + r = &etens[0][0]; + emov (y, w); + emov (eone, t); + while (ecmp (eone, w) > 0) + { + if (ecmp (p, w) >= 0) + { + emul (r, w, w, ldp); + emul (r, t, t, ldp); + expon += k; + } + k /= 2; + if (k == 0) + break; + p += NE; + r += NE; + } + ediv (t, eone, t, ldp); + } isone: /* Find the first (leading) digit. */ -emovi( t, w ); -emovz( w, t ); -emovi( y, w ); -emovz( w, y ); -eiremain( t, y, ldp ); -digit = equot[NI-1]; -while( (digit == 0) && (ecmp(y,ezero) != 0) ) - { - eshup1( y ); - emovz( y, u ); - eshup1( u ); - eshup1( u ); - eaddm( u, y ); - eiremain( t, y, ldp ); - digit = equot[NI-1]; - expon -= 1; - } -s = string; -if( sign ) - *s++ = '-'; -else - *s++ = ' '; + emovi (t, w); + emovz (w, t); + emovi (y, w); + emovz (w, y); + eiremain (t, y, ldp); + digit = equot[NI - 1]; + while ((digit == 0) && (ecmp (y, ezero) != 0)) + { + eshup1 (y); + emovz (y, u); + eshup1 (u); + eshup1 (u); + eaddm (u, y); + eiremain (t, y, ldp); + digit = equot[NI - 1]; + expon -= 1; + } + s = string; + if (sign) + *s++ = '-'; + else + *s++ = ' '; /* Examine number of digits requested by caller. */ -if( outformat == 3 ) - ndigs += expon; + if (outformat == 3) + ndigs += expon; /* else if( ndigs < 0 ) ndigs = 0; */ -if( ndigs > NDEC ) - ndigs = NDEC; -if( digit == 10 ) + if (ndigs > NDEC) + ndigs = NDEC; + if (digit == 10) + { + *s++ = '1'; + *s++ = '.'; + if (ndigs > 0) { - *s++ = '1'; - *s++ = '.'; - if( ndigs > 0 ) - { - *s++ = '0'; - ndigs -= 1; - } - expon += 1; - if( ndigs < 0 ) - { - ss = s; - goto doexp; - } + *s++ = '0'; + ndigs -= 1; } -else + expon += 1; + if (ndigs < 0) { - *s++ = (char )digit + '0'; - *s++ = '.'; + ss = s; + goto doexp; } + } + else + { + *s++ = (char) digit + '0'; + *s++ = '.'; + } /* Generate digits after the decimal point. */ -for( k=0; k<=ndigs; k++ ) - { + for (k = 0; k <= ndigs; k++) + { /* multiply current number by 10, without normalizing */ - eshup1( y ); - emovz( y, u ); - eshup1( u ); - eshup1( u ); - eaddm( u, y ); - eiremain( t, y, ldp ); - *s++ = (char )equot[NI-1] + '0'; - } -digit = equot[NI-1]; ---s; -ss = s; + eshup1 (y); + emovz (y, u); + eshup1 (u); + eshup1 (u); + eaddm (u, y); + eiremain (t, y, ldp); + *s++ = (char) equot[NI - 1] + '0'; + } + digit = equot[NI - 1]; + --s; + ss = s; /* round off the ASCII string */ -if( digit > 4 ) - { + if (digit > 4) + { /* Test for critical rounding case in ASCII output. */ - if( digit == 5 ) - { - emovo( y, t, ldp ); - if( ecmp(t,ezero) != 0 ) - goto roun; /* round to nearest */ - if( ndigs < 0 || (*(s-1-(*(s-1)=='.')) & 1) == 0 ) - goto doexp; /* round to even */ - } -/* Round up and propagate carry-outs */ -roun: - --s; - k = *s & 0x7f; -/* Carry out to most significant digit? */ - if( ndigs < 0 ) - { - /* This will print like "1E-6". */ - *s = '1'; - expon += 1; - goto doexp; - } - else if( k == '.' ) - { - --s; - k = *s; - k += 1; - *s = (char )k; -/* Most significant digit carries to 10? */ - if( k > '9' ) - { - expon += 1; - *s = '1'; - } - goto doexp; - } -/* Round up and carry out from less significant digits */ - k += 1; - *s = (char )k; - if( k > '9' ) - { - *s = '0'; - goto roun; - } + if (digit == 5) + { + emovo (y, t, ldp); + if (ecmp (t, ezero) != 0) + goto roun; /* round to nearest */ + if (ndigs < 0 || (*(s - 1 - (*(s - 1) == '.')) & 1) == 0) + goto doexp; /* round to even */ } +/* Round up and propagate carry-outs */ + roun: + --s; + k = *s & 0x7f; +/* Carry out to most significant digit? */ + if (ndigs < 0) + { + /* This will print like "1E-6". */ + *s = '1'; + expon += 1; + goto doexp; + } + else if (k == '.') + { + --s; + k = *s; + k += 1; + *s = (char) k; +/* Most significant digit carries to 10? */ + if (k > '9') + { + expon += 1; + *s = '1'; + } + goto doexp; + } +/* Round up and carry out from less significant digits */ + k += 1; + *s = (char) k; + if (k > '9') + { + *s = '0'; + goto roun; + } + } doexp: #ifdef __GO32__ -if( expon >= 0 ) - sprintf( ss, "e+%02d", expon ); -else - sprintf( ss, "e-%02d", -expon ); + if (expon >= 0) + sprintf (ss, "e+%02d", expon); + else + sprintf (ss, "e-%02d", -expon); #else - sprintf( ss, "E%d", expon ); + sprintf (ss, "E%d", expon); #endif bxit: -ldp->rndprc = rndsav; -ldp->outexpon = expon; + ldp->rndprc = rndsav; + ldp->outexpon = expon; } @@ -3227,7 +3301,8 @@ ldp->outexpon = expon; ; asctoq( string, q ); */ -long double _strtold (char *s, char **se) +long double +_strtold (char *s, char **se) { union uconv x; LDPARMS rnd; @@ -3237,7 +3312,7 @@ long double _strtold (char *s, char **se) rnd.rlast = -1; rnd.rndprc = NBITS; - lenldstr = asctoeg( s, &x.pe, LDBL_MANT_DIG, ldp ); + lenldstr = asctoeg (s, &x.pe, LDBL_MANT_DIG, ldp); if (se) *se = s + lenldstr; return x.d; @@ -3246,222 +3321,221 @@ long double _strtold (char *s, char **se) #define REASONABLE_LEN 200 static int -asctoeg(char *ss, short unsigned int *y, int oprec, LDPARMS *ldp) +asctoeg (char *ss, short unsigned int *y, int oprec, LDPARMS * ldp) { -unsigned short yy[NI], xt[NI], tt[NI]; -int esign, decflg, sgnflg, nexp, exp, prec, lost; -int k, trail, c, rndsav; -long lexp; -unsigned short nsign; -_CONST unsigned short *p; -char *sp, *s, *lstr; -int lenldstr; -int mflag = 0; -char tmpstr[REASONABLE_LEN]; + unsigned short yy[NI], xt[NI], tt[NI]; + int esign, decflg, sgnflg, nexp, exp, prec, lost; + int k, trail, c, rndsav; + long lexp; + unsigned short nsign; + _CONST unsigned short *p; + char *sp, *s, *lstr; + int lenldstr; + int mflag = 0; + char tmpstr[REASONABLE_LEN]; /* Copy the input string. */ -c = strlen (ss) + 2; -if (c <= REASONABLE_LEN) - lstr = tmpstr; -else - { - lstr = (char *) calloc (c, 1); - mflag = 1; - } -s = ss; -lenldstr = 0; -while( *s == ' ' ) /* skip leading spaces */ - { - ++s; - ++lenldstr; - } -sp = lstr; -for( k=0; krndprc; -ldp->rndprc = NBITS; /* Set to full precision */ -lost = 0; -nsign = 0; -decflg = 0; -sgnflg = 0; -nexp = 0; -exp = 0; -prec = 0; -ecleaz( yy ); -trail = 0; + rndsav = ldp->rndprc; + ldp->rndprc = NBITS; /* Set to full precision */ + lost = 0; + nsign = 0; + decflg = 0; + sgnflg = 0; + nexp = 0; + exp = 0; + prec = 0; + ecleaz (yy); + trail = 0; nxtcom: -k = *s - '0'; -if( (k >= 0) && (k <= 9) ) - { + k = *s - '0'; + if ((k >= 0) && (k <= 9)) + { /* Ignore leading zeros */ - if( (prec == 0) && (decflg == 0) && (k == 0) ) - goto donchr; + if ((prec == 0) && (decflg == 0) && (k == 0)) + goto donchr; /* Identify and strip trailing zeros after the decimal point. */ - if( (trail == 0) && (decflg != 0) ) - { - sp = s; - while( (*sp >= '0') && (*sp <= '9') ) - ++sp; + if ((trail == 0) && (decflg != 0)) + { + sp = s; + while ((*sp >= '0') && (*sp <= '9')) + ++sp; /* Check for syntax error */ - c = *sp & 0x7f; - if( (c != 'e') && (c != 'E') && (c != '\0') - && (c != '\n') && (c != '\r') && (c != ' ') - && (c != ',') ) - goto error; - --sp; - while( *sp == '0' ) - *sp-- = 'z'; - trail = 1; - if( *s == 'z' ) - goto donchr; - } + c = *sp & 0x7f; + if ((c != 'e') && (c != 'E') && (c != '\0') + && (c != '\n') && (c != '\r') && (c != ' ') && (c != ',')) + goto error; + --sp; + while (*sp == '0') + *sp-- = 'z'; + trail = 1; + if (*s == 'z') + goto donchr; + } /* If enough digits were given to more than fill up the yy register, * continuing until overflow into the high guard word yy[2] * guarantees that there will be a roundoff bit at the top * of the low guard word after normalization. */ - if( yy[2] == 0 ) - { - if( decflg ) - nexp += 1; /* count digits after decimal point */ - eshup1( yy ); /* multiply current number by 10 */ - emovz( yy, xt ); - eshup1( xt ); - eshup1( xt ); - eaddm( xt, yy ); - ecleaz( xt ); - xt[NI-2] = (unsigned short )k; - eaddm( xt, yy ); - } - else - { - /* Mark any lost non-zero digit. */ - lost |= k; - /* Count lost digits before the decimal point. */ - if (decflg == 0) - nexp -= 1; - } - prec += 1; - goto donchr; - } - -switch( *s ) + if (yy[2] == 0) { - case 'z': - break; - case 'E': - case 'e': - goto expnt; - case '.': /* decimal point */ - if( decflg ) - goto error; - ++decflg; - break; - case '-': - nsign = 0xffff; - if( sgnflg ) - goto error; - ++sgnflg; - break; - case '+': - if( sgnflg ) - goto error; - ++sgnflg; - break; - case ',': - case ' ': - case '\0': - case '\n': - case '\r': - goto daldone; - case 'i': - case 'I': - goto infinite; - default: - error: -#ifdef NANS - enan( yy, NI*16 ); -#else - mtherr( "asctoe", DOMAIN ); - ecleaz(yy); -#endif - goto aexit; + if (decflg) + nexp += 1; /* count digits after decimal point */ + eshup1 (yy); /* multiply current number by 10 */ + emovz (yy, xt); + eshup1 (xt); + eshup1 (xt); + eaddm (xt, yy); + ecleaz (xt); + xt[NI - 2] = (unsigned short) k; + eaddm (xt, yy); } + else + { + /* Mark any lost non-zero digit. */ + lost |= k; + /* Count lost digits before the decimal point. */ + if (decflg == 0) + nexp -= 1; + } + prec += 1; + goto donchr; + } + + switch (*s) + { + case 'z': + break; + case 'E': + case 'e': + goto expnt; + case '.': /* decimal point */ + if (decflg) + goto error; + ++decflg; + break; + case '-': + nsign = 0xffff; + if (sgnflg) + goto error; + ++sgnflg; + break; + case '+': + if (sgnflg) + goto error; + ++sgnflg; + break; + case ',': + case ' ': + case '\0': + case '\n': + case '\r': + goto daldone; + case 'i': + case 'I': + goto infinite; + default: + error: +#ifdef NANS + enan (yy, NI * 16); +#else + mtherr ("asctoe", DOMAIN); + ecleaz (yy); +#endif + goto aexit; + } donchr: -++s; -goto nxtcom; + ++s; + goto nxtcom; /* Exponent interpretation */ expnt: -esign = 1; -exp = 0; -++s; + esign = 1; + exp = 0; + ++s; /* check for + or - */ -if( *s == '-' ) + if (*s == '-') + { + esign = -1; + ++s; + } + if (*s == '+') + ++s; + while ((*s >= '0') && (*s <= '9')) + { + exp *= 10; + exp += *s++ - '0'; + if (exp > 4977) { - esign = -1; - ++s; - } -if( *s == '+' ) - ++s; -while( (*s >= '0') && (*s <= '9') ) - { - exp *= 10; - exp += *s++ - '0'; - if (exp > 4977) - { - if (esign < 0) - goto zero; - else - goto infinite; - } - } -if( esign < 0 ) - exp = -exp; -if( exp > 4932 ) - { -infinite: - ecleaz(yy); - yy[E] = 0x7fff; /* infinity */ - goto aexit; - } -if( exp < -4977 ) - { -zero: - ecleaz(yy); - goto aexit; + if (esign < 0) + goto zero; + else + goto infinite; } + } + if (esign < 0) + exp = -exp; + if (exp > 4932) + { + infinite: + ecleaz (yy); + yy[E] = 0x7fff; /* infinity */ + goto aexit; + } + if (exp < -4977) + { + zero: + ecleaz (yy); + goto aexit; + } daldone: -nexp = exp - nexp; + nexp = exp - nexp; /* Pad trailing zeros to minimize power of 10, per IEEE spec. */ -while( (nexp > 0) && (yy[2] == 0) ) - { - emovz( yy, xt ); - eshup1( xt ); - eshup1( xt ); - eaddm( yy, xt ); - eshup1( xt ); - if( xt[2] != 0 ) - break; - nexp -= 1; - emovz( xt, yy ); - } -if( (k = enormlz(yy)) > NBITS ) - { - ecleaz(yy); - goto aexit; - } -lexp = (EXONE - 1 + NBITS) - k; -emdnorm( yy, lost, 0, lexp, 64, ldp ); + while ((nexp > 0) && (yy[2] == 0)) + { + emovz (yy, xt); + eshup1 (xt); + eshup1 (xt); + eaddm (yy, xt); + eshup1 (xt); + if (xt[2] != 0) + break; + nexp -= 1; + emovz (xt, yy); + } + if ((k = enormlz (yy)) > NBITS) + { + ecleaz (yy); + goto aexit; + } + lexp = (EXONE - 1 + NBITS) - k; + emdnorm (yy, lost, 0, lexp, 64, ldp); /* convert to external format */ @@ -3471,107 +3545,107 @@ emdnorm( yy, lost, 0, lexp, 64, ldp ); * For 0 <= n <= 999, the peak relative error is 1.4e-19 at 10**947. * For 0 >= n >= -999, it is -1.55e-19 at 10**-435. */ -lexp = yy[E]; -if( nexp == 0 ) - { - k = 0; - goto expdon; + lexp = yy[E]; + if (nexp == 0) + { + k = 0; + goto expdon; + } + esign = 1; + if (nexp < 0) + { + nexp = -nexp; + esign = -1; + if (nexp > 4096) + { /* Punt. Can't handle this without 2 divides. */ + emovi (etens[0], tt); + lexp -= tt[E]; + k = edivm (tt, yy, ldp); + lexp += EXONE; + nexp -= 4096; } -esign = 1; -if( nexp < 0 ) - { - nexp = -nexp; - esign = -1; - if( nexp > 4096 ) - { /* Punt. Can't handle this without 2 divides. */ - emovi( etens[0], tt ); - lexp -= tt[E]; - k = edivm( tt, yy, ldp ); - lexp += EXONE; - nexp -= 4096; - } - } -p = &etens[NTEN][0]; -emov( eone, xt ); -exp = 1; -do - { - if( exp & nexp ) - emul( p, xt, xt, ldp ); - p -= NE; - exp = exp + exp; - } -while( exp <= MAXP ); + } + p = &etens[NTEN][0]; + emov (eone, xt); + exp = 1; + do + { + if (exp & nexp) + emul (p, xt, xt, ldp); + p -= NE; + exp = exp + exp; + } + while (exp <= MAXP); -emovi( xt, tt ); -if( esign < 0 ) - { - lexp -= tt[E]; - k = edivm( tt, yy, ldp ); - lexp += EXONE; - } -else - { - lexp += tt[E]; - k = emulm( tt, yy, ldp ); - lexp -= EXONE - 1; - } + emovi (xt, tt); + if (esign < 0) + { + lexp -= tt[E]; + k = edivm (tt, yy, ldp); + lexp += EXONE; + } + else + { + lexp += tt[E]; + k = emulm (tt, yy, ldp); + lexp -= EXONE - 1; + } expdon: /* Round and convert directly to the destination type */ -if( oprec == 53 ) - lexp -= EXONE - 0x3ff; -else if( oprec == 24 ) - lexp -= EXONE - 0177; + if (oprec == 53) + lexp -= EXONE - 0x3ff; + else if (oprec == 24) + lexp -= EXONE - 0177; #ifdef DEC -else if( oprec == 56 ) - lexp -= EXONE - 0201; + else if (oprec == 56) + lexp -= EXONE - 0201; #endif -ldp->rndprc = oprec; -emdnorm( yy, k, 0, lexp, 64, ldp ); + ldp->rndprc = oprec; + emdnorm (yy, k, 0, lexp, 64, ldp); aexit: -ldp->rndprc = rndsav; -yy[0] = nsign; -switch( oprec ) - { + ldp->rndprc = rndsav; + yy[0] = nsign; + switch (oprec) + { #ifdef DEC - case 56: - todec( yy, y ); /* see etodec.c */ - break; + case 56: + todec (yy, y); /* see etodec.c */ + break; #endif #if LDBL_MANT_DIG == 53 - case 53: - toe53( yy, y ); - break; + case 53: + toe53 (yy, y); + break; #elif LDBL_MANT_DIG == 24 - case 24: - toe24( yy, y ); - break; + case 24: + toe24 (yy, y); + break; #elif LDBL_MANT_DIG == 64 - case 64: - toe64( yy, y ); - break; + case 64: + toe64 (yy, y); + break; #elif LDBL_MANT_DIG == 113 - case 113: - toe113( yy, y ); - break; + case 113: + toe113 (yy, y); + break; #else - case NBITS: - emovo( yy, y, ldp ); - break; + case NBITS: + emovo (yy, y, ldp); + break; #endif - } -lenldstr += s - lstr; -if (mflag) - free (lstr); -return lenldstr; + } + lenldstr += s - lstr; + if (mflag) + free (lstr); + return lenldstr; } - + /* y = largest integer not greater than x * (truncated toward minus infinity) * @@ -3581,99 +3655,101 @@ return lenldstr; * efloor( x, y, ldp ); */ static _CONST unsigned short bmask[] = { -0xffff, -0xfffe, -0xfffc, -0xfff8, -0xfff0, -0xffe0, -0xffc0, -0xff80, -0xff00, -0xfe00, -0xfc00, -0xf800, -0xf000, -0xe000, -0xc000, -0x8000, -0x0000, + 0xffff, + 0xfffe, + 0xfffc, + 0xfff8, + 0xfff0, + 0xffe0, + 0xffc0, + 0xff80, + 0xff00, + 0xfe00, + 0xfc00, + 0xf800, + 0xf000, + 0xe000, + 0xc000, + 0x8000, + 0x0000, }; -static void efloor(short unsigned int *x, short unsigned int *y, LDPARMS *ldp) +static void +efloor (short unsigned int *x, short unsigned int *y, LDPARMS * ldp) { -register unsigned short *p; -int e, expon, i; -unsigned short f[NE]; + register unsigned short *p; + int e, expon, i; + unsigned short f[NE]; -emov( x, f ); /* leave in external format */ -expon = (int )f[NE-1]; -e = (expon & 0x7fff) - (EXONE - 1); -if( e <= 0 ) - { - eclear(y); - goto isitneg; - } + emov (x, f); /* leave in external format */ + expon = (int) f[NE - 1]; + e = (expon & 0x7fff) - (EXONE - 1); + if (e <= 0) + { + eclear (y); + goto isitneg; + } /* number of bits to clear out */ -e = NBITS - e; -emov( f, y ); -if( e <= 0 ) - return; + e = NBITS - e; + emov (f, y); + if (e <= 0) + return; -p = &y[0]; -while( e >= 16 ) - { - *p++ = 0; - e -= 16; - } + p = &y[0]; + while (e >= 16) + { + *p++ = 0; + e -= 16; + } /* clear the remaining bits */ -*p &= bmask[e]; + *p &= bmask[e]; /* truncate negatives toward minus infinity */ isitneg: -if( (unsigned short )expon & (unsigned short )0x8000 ) + if ((unsigned short) expon & (unsigned short) 0x8000) + { + for (i = 0; i < NE - 1; i++) { - for( i=0; iequot; + long ld, ln; + unsigned short j; + unsigned short *equot = ldp->equot; -ld = den[E]; -ld -= enormlz( den ); -ln = num[E]; -ln -= enormlz( num ); -ecleaz( equot ); -while( ln >= ld ) + ld = den[E]; + ld -= enormlz (den); + ln = num[E]; + ln -= enormlz (num); + ecleaz (equot); + while (ln >= ld) + { + if (ecmpm (den, num) <= 0) { - if( ecmpm(den,num) <= 0 ) - { - esubm(den, num); - j = 1; - } - else - { - j = 0; - } - eshup1(equot); - equot[NI-1] |= j; - eshup1(num); - ln -= 1; + esubm (den, num); + j = 1; } -emdnorm( num, 0, 0, ln, 0, ldp ); + else + { + j = 0; + } + eshup1 (equot); + equot[NI - 1] |= j; + eshup1 (num); + ln -= 1; + } + emdnorm (num, 0, 0, ln, 0, ldp); } /* NaN bit patterns @@ -3681,102 +3757,112 @@ emdnorm( num, 0, 0, ln, 0, ldp ); #ifdef MIEEE #if !defined(__mips) static _CONST unsigned short nan113[8] = { - 0x7fff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}; + 0x7fff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff +}; + static _CONST unsigned short nan64[6] = { - 0x7fff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}; -static _CONST unsigned short nan53[4] = {0x7fff, 0xffff, 0xffff, 0xffff}; -static _CONST unsigned short nan24[2] = {0x7fff, 0xffff}; -#elif defined(__mips_nan2008) /* __mips */ -static _CONST unsigned short nan113[8] = {0x7fff, 0x8000, 0, 0, 0, 0, 0, 0}; -static _CONST unsigned short nan64[6] = {0x7fff, 0xc000, 0, 0, 0, 0}; -static _CONST unsigned short nan53[4] = {0x7ff8, 0, 0, 0}; -static _CONST unsigned short nan24[2] = {0x7fc0, 0}; + 0x7fff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff +}; +static _CONST unsigned short nan53[4] = { 0x7fff, 0xffff, 0xffff, 0xffff }; +static _CONST unsigned short nan24[2] = { 0x7fff, 0xffff }; +#elif defined(__mips_nan2008) /* __mips */ +static _CONST unsigned short nan113[8] = { 0x7fff, 0x8000, 0, 0, 0, 0, 0, 0 }; +static _CONST unsigned short nan64[6] = { 0x7fff, 0xc000, 0, 0, 0, 0 }; +static _CONST unsigned short nan53[4] = { 0x7ff8, 0, 0, 0 }; +static _CONST unsigned short nan24[2] = { 0x7fc0, 0 }; #else /* __mips && !__mips_nan2008 */ static _CONST unsigned short nan113[8] = { - 0x7fff, 0x7fff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}; + 0x7fff, 0x7fff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff +}; + static _CONST unsigned short nan64[6] = { - 0x7fff, 0xbfff, 0xffff, 0xffff, 0xffff, 0xffff}; -static _CONST unsigned short nan53[4] = {0x7ff7, 0xffff, 0xffff, 0xffff}; -static _CONST unsigned short nan24[2] = {0x7fbf, 0xffff}; + 0x7fff, 0xbfff, 0xffff, 0xffff, 0xffff, 0xffff +}; +static _CONST unsigned short nan53[4] = { 0x7ff7, 0xffff, 0xffff, 0xffff }; +static _CONST unsigned short nan24[2] = { 0x7fbf, 0xffff }; #endif /* __mips && !__mips_nan2008 */ #else /* !MIEEE */ #if !defined(__mips) || defined(__mips_nan2008) -static _CONST unsigned short nan113[8] = {0, 0, 0, 0, 0, 0, 0x8000, 0x7fff}; -static _CONST unsigned short nan64[6] = {0, 0, 0, 0, 0xc000, 0x7fff}; -static _CONST unsigned short nan53[4] = {0, 0, 0, 0x7ff8}; -static _CONST unsigned short nan24[2] = {0, 0x7fc0}; +static _CONST unsigned short nan113[8] = { 0, 0, 0, 0, 0, 0, 0x8000, 0x7fff }; +static _CONST unsigned short nan64[6] = { 0, 0, 0, 0, 0xc000, 0x7fff }; +static _CONST unsigned short nan53[4] = { 0, 0, 0, 0x7ff8 }; +static _CONST unsigned short nan24[2] = { 0, 0x7fc0 }; #else /* __mips && !__mips_nan2008 */ static _CONST unsigned short nan113[8] = { - 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x7fff, 0x7fff}; + 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x7fff, 0x7fff +}; + static _CONST unsigned short nan64[6] = { - 0xffff, 0xffff, 0xffff, 0xffff, 0xbfff, 0x7fff}; -static _CONST unsigned short nan53[4] = {0xffff, 0xffff, 0xffff, 0x7ff7}; -static _CONST unsigned short nan24[2] = {0xffff, 0x7fbf}; + 0xffff, 0xffff, 0xffff, 0xffff, 0xbfff, 0x7fff +}; +static _CONST unsigned short nan53[4] = { 0xffff, 0xffff, 0xffff, 0x7ff7 }; +static _CONST unsigned short nan24[2] = { 0xffff, 0x7fbf }; #endif /* __mips && !__mips_nan2008 */ #endif /* !MIEEE */ -static void enan (short unsigned int *nan, int size) +static void +enan (short unsigned int *nan, int size) { -int i, n; -_CONST unsigned short *p; + int i, n; + _CONST unsigned short *p; -switch( size ) - { + switch (size) + { #ifndef DEC - case 113: - n = 8; - p = nan113; - break; + case 113: + n = 8; + p = nan113; + break; - case 64: - n = 6; - p = nan64; - break; + case 64: + n = 6; + p = nan64; + break; - case 53: - n = 4; - p = nan53; - break; + case 53: + n = 4; + p = nan53; + break; - case 24: - n = 2; - p = nan24; - break; + case 24: + n = 2; + p = nan24; + break; - case NBITS: + case NBITS: #if !defined(__mips) || defined(__mips_nan2008) - for( i=0; i