/* 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.
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
{
};
#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 */
#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
* 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)
#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 */
#define ANSIC 1
/*define VOLATILE volatile*/
-#define VOLATILE
+#define VOLATILE
#define NANS
#define USE_INFINITY
#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);
-#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 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);
#ifdef DEC
-static void etodec(), todec(), dectoe();
+static void etodec (), todec (), dectoe ();
#endif
/*
; 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; i<NE; i++ )
- *x++ = 0;
+ for (i = 0; i < NE; i++)
+ *x++ = 0;
}
* emov( a, b );
*/
-static void emov(register _CONST short unsigned int *a, register short unsigned int *b)
+static void
+emov (register _CONST short unsigned int *a, register short unsigned int *b)
{
-register int i;
+ register int i;
-for( i=0; i<NE; i++ )
- *b++ = *a++;
+ for (i = 0; i < NE; i++)
+ *b++ = *a++;
}
; eneg( x );
*/
-static void eneg(short unsigned int *x)
+static void
+eneg (short unsigned int *x)
{
#ifdef NANS
-if( eisnan(x) )
- return;
+ if (eisnan (x))
+ return;
#endif
-x[NE-1] ^= 0x8000; /* Toggle the sign bit */
+ x[NE - 1] ^= 0x8000; /* Toggle the sign bit */
}
/* Return 1 if external format number is negative,
* else return zero.
*/
-static int eisneg(_CONST short unsigned int *x)
+static int
+eisneg (_CONST short unsigned int *x)
{
#ifdef NANS
-if( eisnan(x) )
- return( 0 );
+ if (eisnan (x))
+ return (0);
#endif
-if( x[NE-1] & 0x8000 )
- return( 1 );
-else
- return( 0 );
+ if (x[NE - 1] & 0x8000)
+ return (1);
+ else
+ return (0);
}
/* Return 1 if external format number has maximum possible exponent,
* else return zero.
*/
-static int eisinf(_CONST short unsigned int *x)
+static int
+eisinf (_CONST short unsigned int *x)
{
-if( (x[NE-1] & 0x7fff) == 0x7fff )
- {
+ if ((x[NE - 1] & 0x7fff) == 0x7fff)
+ {
#ifdef NANS
- if( eisnan(x) )
- return( 0 );
+ if (eisnan (x))
+ return (0);
#endif
- return( 1 );
- }
-else
- return( 0 );
+ return (1);
+ }
+ else
+ return (0);
}
/* Check if e-type number is not a number.
*/
-static int eisnan(_CONST short unsigned int *x)
+static int
+eisnan (_CONST short unsigned int *x)
{
#ifdef NANS
-int i;
+ int i;
/* NaN has maximum exponent */
-if( (x[NE-1] & 0x7fff) != 0x7fff )
- return (0);
+ if ((x[NE - 1] & 0x7fff) != 0x7fff)
+ return (0);
/* ... and non-zero significand field. */
-for( i=0; i<NE-1; i++ )
- {
- if( *x++ != 0 )
- return (1);
- }
+ for (i = 0; i < NE - 1; i++)
+ {
+ if (*x++ != 0)
+ return (1);
+ }
#endif
-return (0);
+ return (0);
}
/*
; operations involving inifinity.
*/
-static void einfin(register short unsigned int *x, register LDPARMS *ldp)
+static void
+einfin (register short unsigned int *x, register LDPARMS * ldp)
{
-register int i;
+ register int i;
#ifdef USE_INFINITY
-for( i=0; i<NE-1; i++ )
- *x++ = 0;
-*x |= 32767;
-ldp = ldp;
+ for (i = 0; i < NE - 1; i++)
+ *x++ = 0;
+ *x |= 32767;
+ ldp = ldp;
#else
-for( i=0; i<NE-1; i++ )
- *x++ = 0xffff;
-*x |= 32766;
-if( ldp->rndprc < 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<NI; i++ )
- *q++ = *p--;
- return;
- }
-#endif
- for( i=2; i<NI; i++ )
- *q++ = 0;
- return;
+ if (eisnan (a))
+ {
+ *q++ = 0;
+ for (i = 3; i < NI; i++)
+ *q++ = *p--;
+ return;
}
+#endif
+ for (i = 2; i < NI; i++)
+ *q++ = 0;
+ return;
+ }
#endif
/* clear high guard word */
-*q++ = 0;
+ *q++ = 0;
/* move in the significand */
-for( i=0; i<NE-1; i++ )
- *q++ = *p--;
+ for (i = 0; i < NE - 1; i++)
+ *q++ = *p--;
/* clear low guard word */
-*q = 0;
+ *q = 0;
}
/* Move internal format number out,
* converting it to external format.
*/
-static void emovo(short unsigned int *a, short unsigned int *b, LDPARMS *ldp)
+static void
+emovo (short unsigned int *a, short unsigned int *b, LDPARMS * ldp)
{
-register unsigned short *p, *q;
-unsigned short i;
+ register unsigned short *p, *q;
+ unsigned short i;
-p = a;
-q = b + (NE-1); /* point to output exponent */
+ p = a;
+ q = b + (NE - 1); /* point to output exponent */
/* combine sign and exponent */
-i = *p++;
-if( i )
- *q-- = *p++ | 0x8000;
-else
- *q-- = *p++;
+ i = *p++;
+ if (i)
+ *q-- = *p++ | 0x8000;
+ else
+ *q-- = *p++;
#ifdef USE_INFINITY
-if( *(p-1) == 0x7fff )
- {
+ if (*(p - 1) == 0x7fff)
+ {
#ifdef NANS
- if( eiisnan(a) )
- {
- enan( b, NBITS );
- return;
- }
-#endif
- einfin(b, ldp);
- return;
+ if (eiisnan (a))
+ {
+ enan (b, NBITS);
+ return;
}
+#endif
+ einfin (b, ldp);
+ return;
+ }
#endif
/* skip over guard word */
-++p;
+ ++p;
/* move the significand */
-for( i=0; i<NE-1; i++ )
- *q-- = *p++;
+ for (i = 0; i < NE - 1; i++)
+ *q-- = *p++;
}
/* Clear out internal format number.
*/
-static void ecleaz(register short unsigned int *xi)
+static void
+ecleaz (register short unsigned int *xi)
{
-register int i;
+ register int i;
-for( i=0; i<NI; i++ )
- *xi++ = 0;
+ for (i = 0; i < NI; i++)
+ *xi++ = 0;
}
/* same, but don't touch the sign. */
-static void ecleazs(register short unsigned int *xi)
+static void
+ecleazs (register short unsigned int *xi)
{
-register int i;
+ register int i;
-++xi;
-for(i=0; i<NI-1; i++)
- *xi++ = 0;
+ ++xi;
+ for (i = 0; i < NI - 1; i++)
+ *xi++ = 0;
}
/* Move internal format number from a to b.
*/
-static void emovz(register short unsigned int *a, register short unsigned int *b)
+static void
+emovz (register short unsigned int *a, register short unsigned int *b)
{
-register int i;
+ register int i;
-for( i=0; i<NI-1; i++ )
- *b++ = *a++;
+ for (i = 0; i < NI - 1; i++)
+ *b++ = *a++;
/* clear low guard word */
-*b = 0;
+ *b = 0;
}
/* Return nonzero if internal format number is a NaN.
*/
-static int eiisnan (short unsigned int *x)
+static int
+eiisnan (short unsigned int *x)
{
-int i;
+ int i;
-if( (x[E] & 0x7fff) == 0x7fff )
+ if ((x[E] & 0x7fff) == 0x7fff)
+ {
+ for (i = M + 1; i < NI; i++)
{
- for( i=M+1; i<NI; i++ )
- {
- if( x[i] != 0 )
- return(1);
- }
+ if (x[i] != 0)
+ return (1);
}
-return(0);
+ }
+ return (0);
}
#if LDBL_MANT_DIG == 64
/* Return nonzero if internal format number is infinite. */
-static int
+static int
eiisinf (unsigned short x[])
{
; 0 if a == b
; -1 if a < b
*/
-static int ecmpm(register short unsigned int *a, register short unsigned int *b)
+static int
+ecmpm (register short unsigned int *a, register short unsigned int *b)
{
-int i;
-
-a += M; /* skip up to significand area */
-b += M;
-for( i=M; i<NI; i++ )
- {
- if( *a++ != *b++ )
- goto difrnt;
- }
-return(0);
+ int i;
+
+ a += M; /* skip up to significand area */
+ b += M;
+ for (i = M; i < NI; i++)
+ {
+ if (*a++ != *b++)
+ goto difrnt;
+ }
+ return (0);
difrnt:
-if( *(--a) > *(--b) )
- return(1);
-else
- return(-1);
+ if (*(--a) > *(--b))
+ return (1);
+ else
+ return (-1);
}
; 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;
-
-x += M; /* point to significand area */
-
-bits = 0;
-for( i=M; i<NI; i++ )
- {
- if( *x & 1 )
- bits |= 1;
- *x >>= 1;
- if( bits & 2 )
- *x |= 0x8000;
- bits <<= 1;
- ++x;
- }
+ register unsigned short bits;
+ int i;
+
+ x += M; /* point to significand area */
+
+ bits = 0;
+ for (i = M; i < NI; i++)
+ {
+ if (*x & 1)
+ bits |= 1;
+ *x >>= 1;
+ if (bits & 2)
+ *x |= 0x8000;
+ bits <<= 1;
+ ++x;
+ }
}
; Shift significand up by 1 bit
*/
-static void eshup1(register short unsigned int *x)
+static void
+eshup1 (register short unsigned int *x)
{
-register unsigned short bits;
-int i;
-
-x += NI-1;
-bits = 0;
-
-for( i=M; i<NI; i++ )
- {
- if( *x & 0x8000 )
- bits |= 1;
- *x <<= 1;
- if( bits & 2 )
- *x |= 1;
- bits <<= 1;
- --x;
- }
+ register unsigned short bits;
+ int i;
+
+ x += NI - 1;
+ bits = 0;
+
+ for (i = M; i < NI; i++)
+ {
+ if (*x & 0x8000)
+ bits |= 1;
+ *x <<= 1;
+ if (bits & 2)
+ *x |= 1;
+ bits <<= 1;
+ --x;
+ }
}
; Shift significand down by 8 bits
*/
-static void eshdn8(register short unsigned int *x)
+static void
+eshdn8 (register short unsigned int *x)
{
-register unsigned short newbyt, oldbyt;
-int i;
-
-x += M;
-oldbyt = 0;
-for( i=M; i<NI; i++ )
- {
- newbyt = *x << 8;
- *x >>= 8;
- *x |= oldbyt;
- oldbyt = newbyt;
- ++x;
- }
+ register unsigned short newbyt, oldbyt;
+ int i;
+
+ 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;
-
-x += NI-1;
-oldbyt = 0;
-
-for( i=M; i<NI; i++ )
- {
- newbyt = *x >> 8;
- *x <<= 8;
- *x |= oldbyt;
- oldbyt = newbyt;
- --x;
- }
+ int i;
+ register unsigned short newbyt, oldbyt;
+
+ x += NI - 1;
+ oldbyt = 0;
+
+ 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<NI-1; i++ )
- *p++ = *x++;
+ for (i = M; i < NI - 1; i++)
+ *p++ = *x++;
-*p = 0;
+ *p = 0;
}
/*
; Shift significand down by 16 bits
*/
-static void eshdn6(register short unsigned int *x)
+static void
+eshdn6 (register short unsigned int *x)
{
-int i;
-register unsigned short *p;
+ int i;
+ register unsigned short *p;
-x += NI-1;
-p = x + 1;
+ x += NI - 1;
+ p = x + 1;
-for( i=M; i<NI-1; i++ )
- *(--p) = *(--x);
+ for (i = M; i < NI - 1; i++)
+ *(--p) = *(--x);
-*(--p) = 0;
+ *(--p) = 0;
}
\f
/*
; x + y replaces y
*/
-static void eaddm(short unsigned int *x, short unsigned int *y)
+static void
+eaddm (short unsigned int *x, short unsigned int *y)
{
-register unsigned long a;
-int i;
-unsigned int carry;
-
-x += NI-1;
-y += NI-1;
-carry = 0;
-for( i=M; i<NI; i++ )
- {
- a = (unsigned long )(*x) + (unsigned long )(*y) + carry;
- if( a & 0x10000 )
- carry = 1;
- else
- carry = 0;
- *y = (unsigned short )a;
- --x;
- --y;
- }
+ register unsigned long a;
+ int i;
+ unsigned int carry;
+
+ x += NI - 1;
+ y += NI - 1;
+ carry = 0;
+ for (i = M; i < NI; i++)
+ {
+ a = (unsigned long) (*x) + (unsigned long) (*y) + carry;
+ if (a & 0x10000)
+ carry = 1;
+ else
+ carry = 0;
+ *y = (unsigned short) a;
+ --x;
+ --y;
+ }
}
/*
; y - x replaces y
*/
-static void esubm(short unsigned int *x, short unsigned int *y)
+static void
+esubm (short unsigned int *x, short unsigned int *y)
{
-unsigned long a;
-int i;
-unsigned int carry;
-
-x += NI-1;
-y += NI-1;
-carry = 0;
-for( i=M; i<NI; i++ )
- {
- a = (unsigned long )(*y) - (unsigned long )(*x) - carry;
- if( a & 0x10000 )
- carry = 1;
- else
- carry = 0;
- *y = (unsigned short )a;
- --x;
- --y;
- }
+ unsigned long a;
+ int i;
+ unsigned int carry;
+
+ x += NI - 1;
+ y += NI - 1;
+ carry = 0;
+ for (i = M; i < NI; i++)
+ {
+ a = (unsigned long) (*y) - (unsigned long) (*x) - carry;
+ if (a & 0x10000)
+ carry = 1;
+ else
+ carry = 0;
+ *y = (unsigned short) a;
+ --x;
+ --y;
+ }
}
/* Multiply significand of e-type number b
by 16-bit quantity a, e-type result to c. */
-static void m16m(short unsigned int a, short unsigned int *b, short unsigned int *c)
+static void
+m16m (short unsigned int a, short unsigned int *b, short unsigned int *c)
{
-register unsigned short *pp;
-register unsigned long carry;
-unsigned short *ps;
-unsigned short p[NI];
-unsigned long aa, m;
-int i;
-
-aa = a;
-pp = &p[NI-2];
-*pp++ = 0;
-*pp = 0;
-ps = &b[NI-1];
-
-for( i=M+1; i<NI; i++ )
- {
- if( *ps == 0 )
- {
- --ps;
- --pp;
- *(pp-1) = 0;
- }
- else
- {
- m = (unsigned long) aa * *ps--;
- carry = (m & 0xffff) + *pp;
- *pp-- = (unsigned short )carry;
- carry = (carry >> 16) + (m >> 16) + *pp;
- *pp = (unsigned short )carry;
- *(pp-1) = carry >> 16;
- }
- }
-for( i=M; i<NI; i++ )
- c[i] = p[i];
+ register unsigned short *pp;
+ register unsigned long carry;
+ unsigned short *ps;
+ unsigned short p[NI];
+ unsigned long aa, m;
+ int i;
+
+ aa = a;
+ pp = &p[NI - 2];
+ *pp++ = 0;
+ *pp = 0;
+ ps = &b[NI - 1];
+
+ for (i = M + 1; i < NI; i++)
+ {
+ if (*ps == 0)
+ {
+ --ps;
+ --pp;
+ *(pp - 1) = 0;
+ }
+ else
+ {
+ m = (unsigned long) aa **ps--;
+ carry = (m & 0xffff) + *pp;
+ *pp-- = (unsigned short) carry;
+ carry = (carry >> 16) + (m >> 16) + *pp;
+ *pp = (unsigned short) carry;
+ *(pp - 1) = carry >> 16;
+ }
+ }
+ for (i = M; i < NI; i++)
+ c[i] = p[i];
}
is permitted to have its high guard word nonzero. */
-static int edivm(short unsigned int *den, short unsigned int *num, LDPARMS *ldp)
+static int
+edivm (short unsigned int *den, short unsigned int *num, LDPARMS * ldp)
{
-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];
-
-for( i=M; i<NI; i++ )
- {
- *p++ = 0;
- }
-eshdn1( num );
-tdenm = den[M+1];
-for( i=M; i<NI; i++ )
- {
- /* Find trial quotient digit (the radix is 65536). */
- tnum = (((unsigned long) num[M]) << 16) + num[M+1];
-
- /* Do not execute the divide instruction if it will overflow. */
- if( (tdenm * 0xffffUL) < tnum )
- tquot = 0xffff;
- else
- tquot = tnum / tdenm;
-
- /* Prove that the divide worked. */
+ 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];
+
+ for (i = M; i < NI; i++)
+ {
+ *p++ = 0;
+ }
+ eshdn1 (num);
+ tdenm = den[M + 1];
+ for (i = M; i < NI; i++)
+ {
+ /* Find trial quotient digit (the radix is 65536). */
+ tnum = (((unsigned long) num[M]) << 16) + num[M + 1];
+
+ /* Do not execute the divide instruction if it will overflow. */
+ if ((tdenm * 0xffffUL) < tnum)
+ tquot = 0xffff;
+ else
+ tquot = tnum / tdenm;
+
+ /* Prove that the divide worked. */
/*
tcheck = (unsigned long )tquot * tdenm;
if( tnum - tcheck > 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 )
{
tnum, den[M+1], tquot );
}
*/
- esubm( tprod, num );
+ esubm (tprod, num);
/*
if( ecmpm( num, den ) >= 0 )
{
tnum, den[M+1], tquot );
}
*/
- equot[i] = tquot;
- eshup6(num);
- }
+ equot[i] = tquot;
+ eshup6 (num);
+ }
/* test for nonzero remainder after roundoff bit */
-p = &num[M];
-j = 0;
-for( i=M; i<NI; i++ )
- {
- j |= *p++;
- }
-if( j )
- j = 1;
-
-for( i=0; i<NI; i++ )
- num[i] = equot[i];
-
-return( (int )j );
+ p = &num[M];
+ j = 0;
+ for (i = M; i < NI; i++)
+ {
+ j |= *p++;
+ }
+ if (j)
+ j = 1;
+
+ for (i = 0; i < NI; i++)
+ num[i] = equot[i];
+
+ return ((int) j);
}
/* Multiply significands */
-static int emulm(short unsigned int *a, short unsigned int *b, LDPARMS *ldp)
+static int
+emulm (short unsigned int *a, short unsigned int *b, LDPARMS * ldp)
{
-unsigned short *p, *q;
-unsigned short pprod[NI];
-unsigned short j;
-int i;
-unsigned short *equot = ldp->equot;
+ 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<NI; i++ )
- equot[i] = 0;
+ equot[0] = b[0];
+ equot[1] = b[1];
+ for (i = M; i < NI; i++)
+ equot[i] = 0;
-j = 0;
-p = &a[NI-1];
-q = &equot[NI-1];
-for( i=M+1; i<NI; i++ )
+ j = 0;
+ p = &a[NI - 1];
+ q = &equot[NI - 1];
+ for (i = M + 1; i < NI; i++)
+ {
+ if (*p == 0)
{
- if( *p == 0 )
- {
- --p;
- }
- else
- {
- m16m( *p--, b, pprod );
- eaddm(pprod, equot);
- }
- j |= *q;
- eshdn6(equot);
+ --p;
}
+ else
+ {
+ m16m (*p--, b, pprod);
+ eaddm (pprod, equot);
+ }
+ j |= *q;
+ eshdn6 (equot);
+ }
-for( i=0; i<NI; i++ )
- b[i] = equot[i];
+ for (i = 0; i < NI; i++)
+ b[i] = equot[i];
/* return flag for lost nonzero bits */
-return( (int)j );
+ return ((int) j);
}
*/
-static void emdnorm(short unsigned int *s, int lost, int subflg, long int exp, int rcntrl, LDPARMS *ldp)
+static void
+emdnorm (short unsigned int *s, int lost, int subflg, long int exp,
+ int rcntrl, LDPARMS * ldp)
{
-int i, j;
-unsigned short r;
+ int i, j;
+ unsigned short r;
/* Normalize */
-j = enormlz( s );
+ j = enormlz (s);
/* a blank significand could mean either zero or infinity. */
#ifndef USE_INFINITY
-if( j > 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) )
+ if ((j > NBITS) && (exp < 32767L))
+ {
+ ecleazs (s);
+ return;
+ }
+#endif
+ if (exp < 0L)
+ {
+ if (exp > (long) (-NBITS - 1))
{
- ecleazs( s );
- return;
+ j = (int) exp;
+ i = eshift (s, j);
+ if (i)
+ lost = 1;
}
-#endif
-if( exp < 0L )
+ else
{
- if( exp > (long )(-NBITS-1) )
- {
- j = (int )exp;
- i = eshift( s, j );
- if( i )
- lost = 1;
- }
- else
- {
- ecleazs( s );
- return;
- }
+ 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.
* 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 )
- {
- i = ldp->rw + 1;
- while( i < NI )
- {
- if( s[i] )
- r |= 1;
- s[i] = 0;
- ++i;
- }
- }
-s[ldp->rw] &= ~ldp->rmsk;
-if( (r & ldp->rmbit) != 0 )
- {
- 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 );
- }
+ r = s[ldp->rw] & ldp->rmsk;
+ if (ldp->rndprc < NBITS)
+ {
+ i = ldp->rw + 1;
+ while (i < NI)
+ {
+ if (s[i])
+ r |= 1;
+ s[i] = 0;
+ ++i;
+ }
+ }
+ s[ldp->rw] &= ~ldp->rmsk;
+ if ((r & ldp->rmbit) != 0)
+ {
+ 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);
+ }
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) )
-#endif
- {
- eshup1(s);
- }
-if( s[2] != 0 )
- { /* overflow on roundoff */
- eshdn1(s);
- exp += 1;
- }
+ if ((exp <= 0) && (ldp->rndprc != 64) && (ldp->rndprc != NBITS))
+#endif
+ {
+ 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; i<NI-1; i++ )
- s[i] = 0;
+ s[1] = 32767;
+ for (i = 2; i < NI - 1; i++)
+ s[i] = 0;
#else
- 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;
- }
- }
-#endif
- return;
- }
-if( exp < 0 )
- s[1] = 0;
-else
- s[1] = (unsigned short )exp;
+ 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;
+ }
+ }
+#endif
+ return;
+ }
+ if (exp < 0)
+ s[1] = 0;
+ else
+ s[1] = (unsigned short) exp;
}
; 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;
- }
-#endif
-eadd1( a, b, c, 1, ldp );
+ if (eisinf (a) && eisinf (b) && ((eisneg (a) ^ eisneg (b)) == 0))
+ {
+ mtherr ("esub", DOMAIN);
+ enan (c, NBITS);
+ return;
+ }
+#endif
+ 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;
- }
-#endif
-emovi( a, ai );
-emovi( b, bi );
-if( subflg )
- ai[0] = ~ai[0];
+ 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];
/* 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<NI-1; j++ )
- {
- if( bi[j] != 0 )
- {
+ 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 < NI - 1; j++)
+ {
+ if (bi[j] != 0)
+ {
/* This could overflow, but let emovo take care of that. */
- ltb += 1;
- break;
- }
- }
- bi[E] = (unsigned short )ltb;
- goto done;
+ ltb += 1;
+ break;
}
- if( i > 0 )
- { /* put the larger number in bi */
- emovz( bi, ci );
- emovz( ai, bi );
- emovz( ci, ai );
- }
- }
-if( ai[0] == bi[0] )
- {
- eaddm( ai, bi );
- subflg = 0;
- }
-else
- {
- esubm( ai, bi );
- subflg = 1;
- }
-emdnorm( bi, lost, subflg, ltb, 64, ldp );
+ }
+ bi[E] = (unsigned short) ltb;
+ goto done;
+ }
+ if (i > 0)
+ { /* put the larger number in bi */
+ emovz (bi, ci);
+ emovz (ai, bi);
+ emovz (ci, ai);
+ }
+ }
+ 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);
}
; 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;
- }
-#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<NI-1; i++ )
- {
- if( bi[i] != 0 )
- {
- ltb -= enormlz( bi );
- goto dnzro1;
- }
- }
- 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 < NI - 1; i++)
+ {
+ if (bi[i] != 0)
+ {
+ ltb -= enormlz (bi);
+ goto dnzro1;
+ }
+ }
+ eclear (c);
+ return;
+ }
dnzro1:
-if( ai[E] == 0 )
- { /* possible divide by zero */
- for( i=1; i<NI-1; i++ )
- {
- if( ai[i] != 0 )
- {
- lta -= enormlz( ai );
- goto dnzro2;
- }
- }
- if( ai[0] == bi[0] )
- *(c+(NE-1)) = 0;
- else
- *(c+(NE-1)) = 0x8000;
- einfin(c, ldp);
- mtherr( "ediv", SING );
- return;
- }
+ if (ai[E] == 0)
+ { /* possible divide by zero */
+ for (i = 1; i < NI - 1; i++)
+ {
+ if (ai[i] != 0)
+ {
+ lta -= enormlz (ai);
+ goto dnzro2;
+ }
+ }
+ if (ai[0] == bi[0])
+ *(c + (NE - 1)) = 0;
+ else
+ *(c + (NE - 1)) = 0x8000;
+ einfin (c, ldp);
+ mtherr ("ediv", SING);
+ return;
+ }
dnzro2:
-i = edivm( ai, bi, ldp );
+ i = edivm (ai, bi, ldp);
/* calculate exponent */
-lt = ltb - lta + EXONE;
-emdnorm( bi, i, 0, lt, 64, ldp );
+ lt = ltb - lta + EXONE;
+ emdnorm (bi, i, 0, lt, 64, ldp);
/* set the sign */
-if( ai[0] == bi[0] )
- bi[0] = 0;
-else
- bi[0] = 0Xffff;
-emovo( bi, c, ldp );
+ if (ai[0] == bi[0])
+ bi[0] = 0;
+ else
+ bi[0] = 0Xffff;
+ emovo (bi, c, ldp);
}
; LDPARMS *ldp
; emul( a, b, c, ldp ); c = b * a
*/
-static void emul(_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)
{
-unsigned short ai[NI], bi[NI];
-int i, j;
-long lt, lta, ltb;
+ unsigned short ai[NI], bi[NI];
+ int i, j;
+ long lt, lta, ltb;
#ifdef NANS
/* NaN times anything is the same NaN. */
-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 times infinity is a NaN. */
-if( (eisinf(a) && (ecmp(b,ezero) == 0))
- || (eisinf(b) && (ecmp(a,ezero) == 0)) )
- {
- mtherr( "emul", DOMAIN );
- enan( c, NBITS );
- return;
- }
+ if ((eisinf (a) && (ecmp (b, ezero) == 0))
+ || (eisinf (b) && (ecmp (a, ezero) == 0)))
+ {
+ mtherr ("emul", DOMAIN);
+ enan (c, NBITS);
+ return;
+ }
#endif
/* Infinity times anything else is infinity. */
#ifdef USE_INFINITY
-if( eisinf(a) || eisinf(b) )
- {
- if( eisneg(a) ^ eisneg(b) )
- *(c+(NE-1)) = 0x8000;
- else
- *(c+(NE-1)) = 0;
- einfin(c, ldp);
- return;
- }
-#endif
-emovi( a, ai );
-emovi( b, bi );
-lta = ai[E];
-ltb = bi[E];
-if( ai[E] == 0 )
- {
- for( i=1; i<NI-1; i++ )
- {
- if( ai[i] != 0 )
- {
- lta -= enormlz( ai );
- goto mnzer1;
- }
- }
- eclear(c);
- return;
- }
+ if (eisinf (a) || eisinf (b))
+ {
+ if (eisneg (a) ^ eisneg (b))
+ *(c + (NE - 1)) = 0x8000;
+ else
+ *(c + (NE - 1)) = 0;
+ einfin (c, ldp);
+ return;
+ }
+#endif
+ emovi (a, ai);
+ emovi (b, bi);
+ lta = ai[E];
+ ltb = bi[E];
+ if (ai[E] == 0)
+ {
+ for (i = 1; i < NI - 1; i++)
+ {
+ if (ai[i] != 0)
+ {
+ lta -= enormlz (ai);
+ goto mnzer1;
+ }
+ }
+ eclear (c);
+ return;
+ }
mnzer1:
-if( bi[E] == 0 )
+ if (bi[E] == 0)
+ {
+ for (i = 1; i < NI - 1; i++)
{
- for( i=1; i<NI-1; i++ )
- {
- if( bi[i] != 0 )
- {
- ltb -= enormlz( bi );
- goto mnzer2;
- }
- }
- eclear(c);
- return;
+ if (bi[i] != 0)
+ {
+ ltb -= enormlz (bi);
+ goto mnzer2;
+ }
}
+ eclear (c);
+ return;
+ }
mnzer2:
/* Multiply significands */
-j = emulm( ai, bi, ldp );
+ j = emulm (ai, bi, ldp);
/* calculate exponent */
-lt = lta + ltb - (EXONE - 1);
-emdnorm( bi, j, 0, lt, 64, ldp );
+ lt = lta + ltb - (EXONE - 1);
+ emdnorm (bi, j, 0, lt, 64, ldp);
/* calculate sign of product */
-if( ai[0] == bi[0] )
- bi[0] = 0;
-else
- bi[0] = 0xffff;
-emovo( bi, c, ldp );
+ if (ai[0] == bi[0])
+ bi[0] = 0;
+ else
+ bi[0] = 0xffff;
+ emovo (bi, c, ldp);
}
#if LDBL_MANT_DIG > 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;
-
-e = pe;
-denorm = 0;
-ecleaz(yy);
+ register unsigned short r;
+ unsigned short *e, *p;
+ unsigned short yy[NI];
+ int denorm, i;
+
+ 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;
- }
- }
-#endif /* !IBMPC */
-#endif /* NANS */
- 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 */
-/* If denormal, remove the implied bit; else shift down 1. */
-if( r == 0 )
+ for (i = 0; i < 7; i++)
{
- yy[M] = 0;
+ if (pe[i] != 0)
+ {
+ enan (y, NBITS);
+ return;
+ }
}
-else
+#else /* !IBMPC */
+ for (i = 1; i < 8; i++)
{
- yy[M] = 1;
- eshift( yy, -1 );
+ if (pe[i] != 0)
+ {
+ enan (y, NBITS);
+ return;
+ }
}
-emovo(yy,y,ldp);
+#endif /* !IBMPC */
+#endif /* NANS */
+ 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 */
+/* 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);
}
/* 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<NE-5; i++ )
- *p++ = 0;
+ for (i = 0; i < NE - 5; i++)
+ *p++ = 0;
#ifdef IBMPC
-for( i=0; i<5; i++ )
- *p++ = *e++;
+ for (i = 0; i < 5; i++)
+ *p++ = *e++;
#endif
#ifdef DEC
-for( i=0; i<5; i++ )
- *p++ = *e++;
+ for (i = 0; i < 5; i++)
+ *p++ = *e++;
#endif
#ifdef MIEEE
-p = &yy[0] + (NE-1);
-*p-- = *e++;
-++e; /* MIEEE skips over 2nd short */
-for( i=0; i<4; i++ )
- *p-- = *e++;
+ p = &yy[0] + (NE - 1);
+ *p-- = *e++;
+ ++e; /* MIEEE skips over 2nd short */
+ for (i = 0; i < 4; i++)
+ *p-- = *e++;
#endif
#ifdef IBMPC
/* For Intel long double, shift denormal significand up 1
-- but only if the top significand bit is zero. */
-if((yy[NE-1] & 0x7fff) == 0 && (yy[NE-2] & 0x8000) == 0)
- {
- unsigned short temp[NI+1];
- emovi(yy, temp);
- eshup1(temp);
- emovo(temp,y,ldp);
- return;
- }
+ if ((yy[NE - 1] & 0x7fff) == 0 && (yy[NE - 2] & 0x8000) == 0)
+ {
+ unsigned short temp[NI + 1];
+ emovi (yy, temp);
+ eshup1 (temp);
+ emovo (temp, y, ldp);
+ return;
+ }
#endif
#ifdef USE_INFINITY
/* Point to the exponent field. */
-p = &yy[NE-1];
-if( (*p & 0x7fff) == 0x7fff )
- {
+ p = &yy[NE - 1];
+ if ((*p & 0x7fff) == 0x7fff)
+ {
#ifdef NANS
#ifdef IBMPC
- for( i=0; i<4; i++ )
- {
- if((i != 3 && pe[i] != 0)
- /* Check for Intel long double infinity pattern. */
- || (i == 3 && pe[i] != 0x8000))
- {
- enan( y, NBITS );
- return;
- }
- }
+ for (i = 0; i < 4; i++)
+ {
+ if ((i != 3 && pe[i] != 0)
+ /* Check for Intel long double infinity pattern. */
+ || (i == 3 && pe[i] != 0x8000))
+ {
+ enan (y, NBITS);
+ return;
+ }
+ }
#endif
#ifdef MIEEE
- for( i=2; i<=5; i++ )
- {
- if( pe[i] != 0 )
- {
- enan( y, NBITS );
- return;
- }
- }
+ for (i = 2; i <= 5; i++)
+ {
+ if (pe[i] != 0)
+ {
+ enan (y, NBITS);
+ return;
+ }
+ }
#endif
#endif /* NANS */
- eclear( y );
- einfin( y, ldp );
- if( *p & 0x8000 )
- eneg(y);
- return;
- }
+ eclear (y);
+ einfin (y, ldp);
+ if (*p & 0x8000)
+ eneg (y);
+ return;
+ }
#endif /* USE_INFINITY */
-p = yy;
-q = y;
-for( i=0; i<NE; i++ )
- *q++ = *p++;
+ p = yy;
+ q = y;
+ for (i = 0; i < NE; i++)
+ *q++ = *p++;
}
/* move out internal format to ieee long double */
-static void toe64(short unsigned int *a, short unsigned int *b)
+static void
+toe64 (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, 64 );
- return;
- }
+ if (eiisnan (a))
+ {
+ enan (b, 64);
+ return;
+ }
#endif
#ifdef IBMPC
/* Shift Intel denormal significand down 1. */
-if( a[E] == 0 )
- eshdn1(a);
+ if (a[E] == 0)
+ eshdn1 (a);
#endif
-p = a;
+ p = a;
#ifdef MIEEE
-q = b;
+ q = b;
#else
-q = b + 4; /* point to output exponent */
+ q = b + 4; /* point to output exponent */
/* NOTE: Intel data type is 96 bits wide, clear the last word here. */
-*(q+1)= 0;
+ *(q + 1) = 0;
#endif
/* combine sign and exponent */
-i = *p++;
+ i = *p++;
#ifdef MIEEE
-if( i )
- *q++ = *p++ | 0x8000;
-else
- *q++ = *p++;
-*q++ = 0; /* leave 2nd short blank */
+ if (i)
+ *q++ = *p++ | 0x8000;
+ else
+ *q++ = *p++;
+ *q++ = 0; /* leave 2nd short blank */
#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<4; i++ )
- *q++ = *p++;
+ for (i = 0; i < 4; i++)
+ *q++ = *p++;
#else
#ifdef USE_INFINITY
#ifdef IBMPC
-if (eiisinf (a))
- {
- /* Intel long double infinity. */
- *q-- = 0x8000;
- *q-- = 0;
- *q-- = 0;
- *q = 0;
- return;
- }
+ if (eiisinf (a))
+ {
+ /* Intel long double infinity. */
+ *q-- = 0x8000;
+ *q-- = 0;
+ *q-- = 0;
+ *q = 0;
+ return;
+ }
#endif /* IBMPC */
#endif /* USE_INFINITY */
-for( i=0; i<4; i++ )
- *q-- = *p++;
+ for (i = 0; i < 4; i++)
+ *q-- = *p++;
#endif
}
; unsigned short x[N+2];
; e53toe( &d, x );
*/
-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)
{
#ifdef DEC
-dectoe( pe, y ); /* see etodec.c */
+ dectoe (pe, y); /* see etodec.c */
#else
-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 += 3;
+ e += 3;
#endif
#ifdef DEC
-e += 3;
-#endif
-r = *e;
-yy[0] = 0;
-if( r & 0x8000 )
- yy[0] = 0xffff;
-yy[M] = (r & 0x0f) | 0x10;
-r &= ~0x800f; /* strip sign and 4 significand bits */
+ e += 3;
+#endif
+ r = *e;
+ yy[0] = 0;
+ if (r & 0x8000)
+ yy[0] = 0xffff;
+ yy[M] = (r & 0x0f) | 0x10;
+ r &= ~0x800f; /* strip sign and 4 significand bits */
#ifdef USE_INFINITY
-if( r == 0x7ff0 )
- {
+ if (r == 0x7ff0)
+ {
#ifdef NANS
#ifdef IBMPC
- if( ((pe[3] & 0xf) != 0) || (pe[2] != 0)
- || (pe[1] != 0) || (pe[0] != 0) )
- {
- enan( y, NBITS );
- return;
- }
-#else /* !IBMPC */
- if( ((pe[0] & 0xf) != 0) || (pe[1] != 0)
- || (pe[2] != 0) || (pe[3] != 0) )
- {
- enan( y, NBITS );
- return;
- }
-#endif /* !IBMPC */
-#endif /* NANS */
- eclear( y );
- einfin( y, ldp );
- if( yy[0] )
- eneg(y);
- return;
+ if (((pe[3] & 0xf) != 0) || (pe[2] != 0)
+ || (pe[1] != 0) || (pe[0] != 0))
+ {
+ enan (y, NBITS);
+ return;
}
-#endif
-r >>= 4;
-/* If zero exponent, then the significand is denormalized.
- * So, take back the understood high significand bit. */
-if( r == 0 )
+#else /* !IBMPC */
+ if (((pe[0] & 0xf) != 0) || (pe[1] != 0)
+ || (pe[2] != 0) || (pe[3] != 0))
{
- denorm = 1;
- yy[M] &= ~0x10;
+ enan (y, NBITS);
+ return;
}
-r += EXONE - 01777;
-yy[E] = r;
-p = &yy[M+1];
+#endif /* !IBMPC */
+#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++;
+ *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 );
+ (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 */
}
#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 */
}
; 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;
-
-e = pe;
-denorm = 0; /* flag if denormalized number */
-ecleaz(yy);
+ 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);
#ifdef IBMPC
-e += 1;
+ e += 1;
#endif
#ifdef DEC
-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 */
+ 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 */
#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;
+ if (((pe[0] & 0x7f) != 0) || (pe[1] != 0))
+ {
+ enan (y, NBITS);
+ return;
}
-#endif
-r >>= 7;
-/* If zero exponent, then the significand is denormalized.
- * So, take back the understood high significand bit. */
-if( r == 0 )
+#else /* !MIEEE */
+ if (((pe[1] & 0x7f) != 0) || (pe[0] != 0))
{
- denorm = 1;
- yy[M] &= ~0200;
+ enan (y, NBITS);
+ return;
}
-r += EXONE - 0177;
-yy[E] = r;
-p = &yy[M+1];
+#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++;
-#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 );
+ ++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);
}
-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 */
* -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<NI-1; i++ )
- {
- if( ai[i] != 0 )
- goto nzro;
- if( bi[i] != 0 )
- goto nzro;
- }
- return(0);
-nzro:
- if( *p == 0 )
- return( 1 );
- else
- return( -1 );
- }
+ for (i = 1; i < NI - 1; i++)
+ {
+ if (ai[i] != 0)
+ goto nzro;
+ if (bi[i] != 0)
+ goto nzro;
+ }
+ 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 == 0)
+ msign = 1;
+ else
+ msign = -1;
+ i = NI - 1;
+ do
+ {
+ if (*p++ != *q++)
{
- if( *p++ != *q++ )
- {
- goto diff;
- }
+ goto diff;
}
-while( --i > 0 );
+ }
+ 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 */
}
; 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;
- }
+ lost |= *p; /* remember lost bits */
+ eshdn6 (x);
+ sc -= 16;
+ }
- while( sc >= 8 )
- {
- lost |= *p & 0xff;
- eshdn8(x);
- sc -= 8;
- }
+ while (sc >= 8)
+ {
+ lost |= *p & 0xff;
+ eshdn8 (x);
+ sc -= 8;
+ }
- while( sc > 0 )
- {
- lost |= *p & 1;
- eshdn1(x);
- sc -= 1;
- }
+ while (sc > 0)
+ {
+ lost |= *p & 1;
+ eshdn1 (x);
+ sc -= 1;
}
-else
+ }
+ else
+ {
+ while (sc >= 16)
{
- while( sc >= 16 )
- {
- eshup6(x);
- sc -= 16;
- }
+ eshup6 (x);
+ sc -= 16;
+ }
- while( sc >= 8 )
- {
- eshup8(x);
- sc -= 8;
- }
+ while (sc >= 8)
+ {
+ eshup8 (x);
+ sc -= 8;
+ }
- while( sc > 0 )
- {
- eshup1(x);
- sc -= 1;
- }
+ while (sc > 0)
+ {
+ eshup1 (x);
+ sc -= 1;
}
-if( lost )
- lost = 1;
-return( (int )lost );
+ }
+ if (lost)
+ lost = 1;
+ 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;
-
-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;
+ 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;
/* 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);
}
#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,
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,
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
#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;
-
-rnd.rlast = -1;
-rnd.rndprc = NBITS;
+ unsigned short w[NI];
+ char *t, *u;
+ LDPARMS rnd;
+ LDPARMS *ldp = &rnd;
-if (sizeof(long double) == 16)
- e113toe( (unsigned short *)x, w, ldp );
-else
- e64toe( (unsigned short *)x, w, ldp );
+ rnd.rlast = -1;
+ rnd.rndprc = NBITS;
-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';
- }
+ 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';
+ }
}
#endif
/* 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;
-
-orig_ndigits = ndigits;
-rnd.rlast = -1;
-rnd.rndprc = NBITS;
-
- _REENT_CHECK_MP(ptr);
+ 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;
+
+ _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;
-
-etoasc( e, outbuf, ndigits, mode, ldp );
-s = outbuf;
-if( eisinf(e) || eisnan(e) )
- {
- *decpt = 9999;
- goto stripspaces;
- }
-*decpt = ldp->outexpon + 1;
+ 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;
/* 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.
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;
-
-ndigs = ndigits;
-rndsav = ldp->rndprc;
+ 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;
#ifdef NANS
-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 );
+ 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);
/* 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<NE-1; k++ )
- {
- if( y[k] != 0 )
- goto tnzro; /* denormalized number */
- }
- goto isone; /* legal all zeros */
+ if (y[k] != 0)
+ goto tnzro; /* denormalized number */
}
+ goto isone; /* legal all zeros */
+ }
tnzro:
/* Test for infinity.
*/
-if( y[NE-1] == 0x7fff )
- {
- if( sign )
- sprintf( string, " -Infinity " );
- else
- sprintf( string, " Infinity " );
- expon = 9999;
- goto bxit;
- }
+ if (y[NE - 1] == 0x7fff)
+ {
+ if (sign)
+ sprintf (string, " -Infinity ");
+ else
+ sprintf (string, " Infinity ");
+ expon = 9999;
+ goto bxit;
+ }
/* Test for exponent nonzero but significand denormalized.
* This is an error condition.
*/
-if( (y[NE-1] != 0) && ((y[NE-2] & 0x8000) == 0) )
- {
- mtherr( "etoasc", DOMAIN );
- sprintf( string, "NaN" );
- expon = 9999;
- goto bxit;
- }
+ if ((y[NE - 1] != 0) && ((y[NE - 2] & 0x8000) == 0))
+ {
+ mtherr ("etoasc", DOMAIN);
+ sprintf (string, "NaN");
+ expon = 9999;
+ goto bxit;
+ }
/* Compare to 1.0 */
-i = ecmp( eone, y );
-if( i == 0 )
- goto isone;
+ i = ecmp (eone, y);
+ if (i == 0)
+ goto isone;
-if( i < 0 )
- { /* Number is greater than 1 */
+ if (i < 0)
+ { /* Number is greater than 1 */
/* Convert significand to an integer and strip trailing decimal zeros. */
- emov( y, u );
- u[NE-1] = EXONE + NBITS - 1;
-
- p = &etens[NTEN-4][0];
- m = 16;
-do
- {
- 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 );
+ emov (y, u);
+ u[NE - 1] = EXONE + NBITS - 1;
+
+ p = &etens[NTEN - 4][0];
+ m = 16;
+ do
+ {
+ 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);
/* 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;
- }
- }
-else
- { /* Number is less than 1.0 */
+ 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 */
/* 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<NDEC+1; i++ )
- {
- if( (w[NI-1] & 0x7) != 0 )
- break;
+ 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 )
+ emovz (w, u);
+ eshdn1 (u);
+ eshdn1 (u);
+ eaddm (w, u);
+ u[1] += 3;
+ while (u[2] != 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;
+ eshdn1 (u);
+ u[1] += 1;
}
- ediv( t, eone, t, ldp );
- }
+ 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 )
- {
- *s++ = '1';
- *s++ = '.';
- if( ndigs > 0 )
- {
- *s++ = '0';
- ndigs -= 1;
- }
- expon += 1;
- if( ndigs < 0 )
- {
- ss = s;
- goto doexp;
- }
- }
-else
- {
- *s++ = (char )digit + '0';
- *s++ = '.';
- }
+ if (ndigs > NDEC)
+ ndigs = NDEC;
+ if (digit == 10)
+ {
+ *s++ = '1';
+ *s++ = '.';
+ if (ndigs > 0)
+ {
+ *s++ = '0';
+ ndigs -= 1;
+ }
+ expon += 1;
+ if (ndigs < 0)
+ {
+ 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 */
- }
+ 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;
+ 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;
+ 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;
- }
+ 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;
- }
+ 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;
}
; asctoq( string, q );
*/
-long double _strtold (char *s, char **se)
+long double
+_strtold (char *s, char **se)
{
union uconv x;
LDPARMS rnd;
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;
#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; k<c; k++ )
- {
- if( (*sp++ = *s++) == '\0' )
- break;
- }
-*sp = '\0';
-s = lstr;
-
-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;
+ 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; k < c; k++)
+ {
+ if ((*sp++ = *s++) == '\0')
+ break;
+ }
+ *sp = '\0';
+ s = lstr;
+
+ 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 )
- {
- 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:
+ 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)
+ {
+ 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 );
+ enan (yy, NI * 16);
#else
- mtherr( "asctoe", DOMAIN );
- ecleaz(yy);
+ mtherr ("asctoe", DOMAIN);
+ ecleaz (yy);
#endif
- goto aexit;
- }
+ 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 == '-' )
- {
- 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 (*s == '-')
+ {
+ 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;
+ }
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 */
* 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;
- }
-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 );
-
-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;
- }
+ 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;
+ }
+ }
+ 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;
+ }
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;
-#endif
- }
-lenldstr += s - lstr;
-if (mflag)
- free (lstr);
-return lenldstr;
+ case NBITS:
+ emovo (yy, y, ldp);
+ break;
+#endif
+ }
+ lenldstr += s - lstr;
+ if (mflag)
+ free (lstr);
+ return lenldstr;
}
-
+
/* y = largest integer not greater than x
* (truncated toward minus infinity)
*
* 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];
-
-emov( x, f ); /* leave in external format */
-expon = (int )f[NE-1];
-e = (expon & 0x7fff) - (EXONE - 1);
-if( e <= 0 )
- {
- eclear(y);
- goto isitneg;
- }
+ 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;
+ }
/* 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; i<NE-1; i++ )
- {
- if( f[i] != y[i] )
- {
- esub( eone, y, y, ldp );
- break;
- }
- }
+ if (f[i] != y[i])
+ {
+ esub (eone, y, y, ldp);
+ break;
+ }
}
+ }
}
-static void eiremain(short unsigned int *den, short unsigned int *num, LDPARMS *ldp)
+static void
+eiremain (short unsigned int *den, short unsigned int *num, LDPARMS * ldp)
{
-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 )
- {
- if( ecmpm(den,num) <= 0 )
- {
- esubm(den, num);
- j = 1;
- }
- else
- {
- j = 0;
- }
- eshup1(equot);
- equot[NI-1] |= j;
- eshup1(num);
- ln -= 1;
- }
-emdnorm( num, 0, 0, ln, 0, ldp );
+ 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)
+ {
+ if (ecmpm (den, num) <= 0)
+ {
+ esubm (den, num);
+ j = 1;
+ }
+ else
+ {
+ j = 0;
+ }
+ eshup1 (equot);
+ equot[NI - 1] |= j;
+ eshup1 (num);
+ ln -= 1;
+ }
+ emdnorm (num, 0, 0, ln, 0, ldp);
}
/* NaN bit patterns
#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 64:
- n = 6;
- p = nan64;
- break;
-
- case 53:
- n = 4;
- p = nan53;
- break;
-
- case 24:
- n = 2;
- p = nan24;
- break;
-
- case NBITS:
+ case 113:
+ n = 8;
+ p = nan113;
+ break;
+
+ case 64:
+ n = 6;
+ p = nan64;
+ break;
+
+ case 53:
+ n = 4;
+ p = nan53;
+ break;
+
+ case 24:
+ n = 2;
+ p = nan24;
+ break;
+
+ case NBITS:
#if !defined(__mips) || defined(__mips_nan2008)
- for( i=0; i<NE-2; i++ )
- *nan++ = 0;
- *nan++ = 0xc000;
+ for (i = 0; i < NE - 2; i++)
+ *nan++ = 0;
+ *nan++ = 0xc000;
#else /* __mips && !__mips_nan2008 */
- for( i=0; i<NE-2; i++ )
- *nan++ = 0xffff;
- *nan++ = 0xbfff;
+ for (i = 0; i < NE - 2; i++)
+ *nan++ = 0xffff;
+ *nan++ = 0xbfff;
#endif /* __mips && !__mips_nan2008 */
- *nan++ = 0x7fff;
- return;
+ *nan++ = 0x7fff;
+ return;
- case NI*16:
- *nan++ = 0;
- *nan++ = 0x7fff;
- *nan++ = 0;
+ case NI * 16:
+ *nan++ = 0;
+ *nan++ = 0x7fff;
+ *nan++ = 0;
#if !defined(__mips) || defined(__mips_nan2008)
- *nan++ = 0xc000;
- for( i=4; i<NI-1; i++ )
- *nan++ = 0;
+ *nan++ = 0xc000;
+ for (i = 4; i < NI - 1; i++)
+ *nan++ = 0;
#else /* __mips && !__mips_nan2008 */
- *nan++ = 0xbfff;
- for( i=4; i<NI-1; i++ )
- *nan++ = 0xffff;
+ *nan++ = 0xbfff;
+ for (i = 4; i < NI - 1; i++)
+ *nan++ = 0xffff;
#endif /* __mips && !__mips_nan2008 */
- *nan++ = 0;
- return;
-#endif
- default:
- mtherr( "enan", DOMAIN );
- return;
- }
-for (i=0; i < n; i++)
- *nan++ = *p++;
+ *nan++ = 0;
+ return;
+#endif
+ default:
+ mtherr ("enan", DOMAIN);
+ return;
+ }
+ for (i = 0; i < n; i++)
+ *nan++ = *p++;
}
git://sourceware.org / newlib-cygwin.git / commitdiff