From 5362be5926f9b07cb8c61fc10e0ed4485fc8bf86 Mon Sep 17 00:00:00 2001 From: Danny Smith Date: Tue, 26 Nov 2002 00:11:06 +0000 Subject: [PATCH] Add strtold and wcstold to libmingwex.a * mingwex/strtold.c: New file. * mingwex/wcstold.c: New file. * mingwex/ldtoa.c: New file. * mingwex/math/cephes_emath.h: New file. * mingwex/math/cephes_emath.c: New file. * mingwex/Makefile.in (DISTFILES): Add new files. (MATH_DISTFILES): Ditto. (STDLIB_OBJS): New. Define as strtold.c wcstold.c. (MATH_OBJS): Add cephes_emath.o. (LIB_OBJS): Add $(STDLIB_OBJS). * include/stdlib.h (strtold, wcstold): Add prototypes. * include/wchar.h (wcstold): Add prototype. Add missing ChangeLog entry for 2002-11-09. --- winsup/mingw/ChangeLog | 26 +- winsup/mingw/include/stdlib.h | 2 + winsup/mingw/include/wchar.h | 1 + winsup/mingw/mingwex/Makefile.in | 22 +- winsup/mingw/mingwex/ldtoa.c | 614 ++++++++++ winsup/mingw/mingwex/math/cephes_emath.c | 1318 ++++++++++++++++++++++ winsup/mingw/mingwex/math/cephes_emath.h | 713 ++++++++++++ winsup/mingw/mingwex/strtold.c | 384 +++++++ winsup/mingw/mingwex/wcstold.c | 76 ++ 9 files changed, 3147 insertions(+), 9 deletions(-) create mode 100644 winsup/mingw/mingwex/ldtoa.c create mode 100644 winsup/mingw/mingwex/math/cephes_emath.c create mode 100644 winsup/mingw/mingwex/math/cephes_emath.h create mode 100644 winsup/mingw/mingwex/strtold.c create mode 100644 winsup/mingw/mingwex/wcstold.c diff --git a/winsup/mingw/ChangeLog b/winsup/mingw/ChangeLog index 0e187ada1..108f939ca 100644 --- a/winsup/mingw/ChangeLog +++ b/winsup/mingw/ChangeLog @@ -1,6 +1,30 @@ +2002-11-26 Danny Smith + + * mingwex/strtold.c: New file. + * mingwex/wcstold.c: New file. + * mingwex/ldtoa.c: New file. + * mingwex/math/cephes_emath.h: New file. + * mingwex/math/cephes_emath.c: New file. + * mingwex/Makefile.in (DISTFILES): Add new files. + (MATH_DISTFILES): Ditto. + (STDLIB_OBJS): New. Define as strtold.c wcstold.c. + (MATH_OBJS): Add cephes_emath.o. + (LIB_OBJS): Add $(STDLIB_OBJS). + * include/stdlib.h (strtold, wcstold): Add prototypes. + * include/wchar.h (wcstold): Add prototype. + +2002-11-09 Danny Smith + + * include/math.h (sqrt): Remove inline definition. + (sqrtf): Replace inline definition with prototype. + (sqrtl): Likewise. + * mingwex/math/sqrtf.c (sqrtf): Set domain error if + argument less than zero. + * mingwex/math/sqrtf.c (sqrtl): Likewise. + 2002-10-30 Guido Serassio - * include/stdio.h (_getnaxstdio): Add prototype. + * include/stdio.h (_getmaxstdio): Add prototype. (_setmaxstdio): Likewise. 2002-10-19 Kang Li diff --git a/winsup/mingw/include/stdlib.h b/winsup/mingw/include/stdlib.h index 30ff29c63..349249e8c 100644 --- a/winsup/mingw/include/stdlib.h +++ b/winsup/mingw/include/stdlib.h @@ -324,6 +324,7 @@ double strtod (const char*, char**); #if !defined __NO_ISOCEXT /* extern stubs in static libmingwex.a */ extern __inline__ float strtof (const char *nptr, char **endptr) { return (strtod (nptr, endptr));} +long double strtold (const char * __restrict__, char ** __restrict__); #endif /* __NO_ISOCEXT */ long strtol (const char*, char**, int); @@ -335,6 +336,7 @@ double wcstod (const wchar_t*, wchar_t**); #if !defined __NO_ISOCEXT /* extern stub in static libmingwex.a */ extern __inline__ float wcstof( const wchar_t *nptr, wchar_t **endptr) { return (wcstod(nptr, endptr)); } +long double wcstold (const wchar_t * __restrict__, wchar_t ** __restrict__); #endif /* __NO_ISOCEXT */ long wcstol (const wchar_t*, wchar_t**, int); diff --git a/winsup/mingw/include/wchar.h b/winsup/mingw/include/wchar.h index e33df6152..3c3fa2931 100644 --- a/winsup/mingw/include/wchar.h +++ b/winsup/mingw/include/wchar.h @@ -250,6 +250,7 @@ double wcstod (const wchar_t*, wchar_t**); #if !defined __NO_ISOCEXT /* extern stub in static libmingwex.a */ extern __inline__ float wcstof( const wchar_t *nptr, wchar_t **endptr) { return (wcstod(nptr, endptr)); } +long double wcstold (const wchar_t * __restrict__, wchar_t ** __restrict__); #endif /* __NO_ISOCEXT */ #define _WSTDLIB_DEFINED #endif diff --git a/winsup/mingw/mingwex/Makefile.in b/winsup/mingw/mingwex/Makefile.in index 8ede9f9e9..318613728 100644 --- a/winsup/mingw/mingwex/Makefile.in +++ b/winsup/mingw/mingwex/Makefile.in @@ -29,15 +29,16 @@ DISTFILES = Makefile.in configure configure.in \ _Exit.c atoll.c dirent.c feclearexcept.c fegetenv.c \ fegetexceptflag.c fegetround.c feholdexcept.c feraiseexcept.c \ fesetenv.c fesetexceptflag.c fesetround.c fetestexcept.c \ - feupdateenv.c fwide.c imaxabs.c imaxdiv.c lltoa.c lltow.c \ + feupdateenv.c fwide.c imaxabs.c imaxdiv.c ldtoa.c lltoa.c lltow.c \ mbsinit.c mingw-fseek.c sitest.c snprintf.c snwprintf.c \ - strtof.c strtoimax.c strtoumax.c testwmem.c ulltoa.c ulltow.c \ - vsnprintf.c vsnwprintf.c wcstof.c wcstoimax.c wcstoumax.c \ - wdirent.c wmemchr.c wmemcmp.c wmemcpy.c wmemmove.c wmemset.c \ - wtoll.c + strtof.c strtoimax.c strtold.c strtoumax.c testwmem.c \ + ulltoa.c ulltow.c vsnprintf.c vsnwprintf.c wcstof.c \ + wcstoimax.c wcstold.c wcstoumax.c wdirent.c wmemchr.c \ + wmemcmp.c wmemcpy.c wmemmove.c wmemset.c wtoll.c MATH_DISTFILES = \ acosf.c acosl.c asinf.c asinl.c atan2f.c atan2l.c \ - atanf.c atanl.c cbrt.c cbrtf.c cbrtl.c ceilf.S ceill.S cephes_mconf.h \ + atanf.c atanl.c cbrt.c cbrtf.c cbrtl.c ceilf.S ceill.S \ + cephes_emath.h cephes_emath.c cephes_mconf.h \ copysign.S copysignf.S copysignl.S cosf.S coshf.c coshl.c cosl.S \ exp2.S exp2f.S exp2l.S expf.c expl.c fabs.c fabsf.c fabsl.c \ fdim.c fdimf.c fdiml.c floorf.S floorl.S fma.S fmaf.S fmal.c \ @@ -93,6 +94,8 @@ Q8_OBJS = \ fwide.o imaxabs.o imaxdiv.o mbsinit.o \ strtoimax.o strtoumax.o wcstoimax.o wcstoumax.o \ wmemchr.o wmemcmp.o wmemcpy.o wmemmove.o wmemset.o +STDLIB_OBJS = \ + strtold.o wcstold.o STDLIB_STUB_OBJS = \ lltoa.o ulltoa.o \ lltow.o ulltow.o \ @@ -104,6 +107,7 @@ STDIO_STUB_OBJS = \ MATH_OBJS = \ acosf.o acosl.o asinf.o asinl.o atan2f.o atan2l.o \ atanf.o atanl.o cbrt.o cbrtf.o cbrtl.o ceilf.o ceill.o \ + cephes_emath.o \ copysign.o copysignf.o copysignl.o cosf.o coshf.o coshl.o cosl.o \ exp2.o exp2f.o exp2l.o expf.o expl.o fabs.o fabsf.o fabsl.o \ fdim.o fdimf.o fdiml.o floorf.o floorl.o fma.o fmaf.o fmal.o \ @@ -132,8 +136,8 @@ POSIX_OBJS = \ REPLACE_OBJS = \ mingw-fseek.o -LIB_OBJS = $(Q8_OBJS) $(STDLIB_STUB_OBJS) $(STDIO_STUB_OBJS) \ - $(MATH_OBJS) $(FENV_OBJS) $(POSIX_OBJS) \ +LIB_OBJS = $(Q8_OBJS) $(STDLIB_OBJS) $(STDLIB_STUB_OBJS) \ + $(STDIO_STUB_OBJS) $(MATH_OBJS) $(FENV_OBJS) $(POSIX_OBJS) \ $(REPLACE_OBJS) LIBS = $(LIBMINGWEX_A) @@ -184,6 +188,8 @@ distclean: # Dependancies # wdirent.o: $(srcdir)/dirent.c $(srcdir)/wdirent.c +strtold.o: $(srcdir)/strtold.c $(srcdir)/math/cephes_emath.h +wcstold.o: $(srcdir)/wcstold.c $(srcdir)/math/cephes_emath.h dist: diff --git a/winsup/mingw/mingwex/ldtoa.c b/winsup/mingw/mingwex/ldtoa.c new file mode 100644 index 000000000..09dc7911b --- /dev/null +++ b/winsup/mingw/mingwex/ldtoa.c @@ -0,0 +1,614 @@ +/* This file is extracted from S L Moshier's ioldoubl.c, + * modified for use in MinGW + * + * Extended precision arithmetic functions for long double I/O. + * This program has been placed in the public domain. + */ + + +/* + * Revision history: + * + * 5 Jan 84 PDP-11 assembly language version + * 6 Dec 86 C language version + * 30 Aug 88 100 digit version, improved rounding + * 15 May 92 80-bit long double support + * + * Author: S. L. Moshier. + * + * 6 Oct 02 Modified for MinGW by inlining utility routines, + * removing global variables and splitting out strtold + * from _IO_ldtoa and _IO_ldtostr. + * + * Danny Smith + * + */ + + +#ifdef USE_LDTOA + +#include "math/cephes_emath.h" + +#if NE == 10 + +/* 1.0E0 */ +static const unsigned short __eone[NE] = + {0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x8000, 0x3fff,}; + +#else + +static const unsigned short __eone[NE] = { +0, 0000000,0000000,0000000,0100000,0x3fff,}; +#endif + + +#if NE == 10 +static const unsigned short __etens[NTEN + 1][NE] = +{ + {0x6576, 0x4a92, 0x804a, 0x153f, + 0xc94c, 0x979a, 0x8a20, 0x5202, 0xc460, 0x7525,}, /* 10**4096 */ + {0x6a32, 0xce52, 0x329a, 0x28ce, + 0xa74d, 0x5de4, 0xc53d, 0x3b5d, 0x9e8b, 0x5a92,}, /* 10**2048 */ + {0x526c, 0x50ce, 0xf18b, 0x3d28, + 0x650d, 0x0c17, 0x8175, 0x7586, 0xc976, 0x4d48,}, + {0x9c66, 0x58f8, 0xbc50, 0x5c54, + 0xcc65, 0x91c6, 0xa60e, 0xa0ae, 0xe319, 0x46a3,}, + {0x851e, 0xeab7, 0x98fe, 0x901b, + 0xddbb, 0xde8d, 0x9df9, 0xebfb, 0xaa7e, 0x4351,}, + {0x0235, 0x0137, 0x36b1, 0x336c, + 0xc66f, 0x8cdf, 0x80e9, 0x47c9, 0x93ba, 0x41a8,}, + {0x50f8, 0x25fb, 0xc76b, 0x6b71, + 0x3cbf, 0xa6d5, 0xffcf, 0x1f49, 0xc278, 0x40d3,}, + {0x0000, 0x0000, 0x0000, 0x0000, + 0xf020, 0xb59d, 0x2b70, 0xada8, 0x9dc5, 0x4069,}, + {0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0400, 0xc9bf, 0x8e1b, 0x4034,}, + {0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x2000, 0xbebc, 0x4019,}, + {0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x9c40, 0x400c,}, + {0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0xc800, 0x4005,}, + {0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0xa000, 0x4002,}, /* 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 */ +}; +#endif + +#if NE == 10 +static const unsigned short __emtens[NTEN + 1][NE] = +{ + {0x2030, 0xcffc, 0xa1c3, 0x8123, + 0x2de3, 0x9fde, 0xd2ce, 0x04c8, 0xa6dd, 0x0ad8,}, /* 10**-4096 */ + {0x8264, 0xd2cb, 0xf2ea, 0x12d4, + 0x4925, 0x2de4, 0x3436, 0x534f, 0xceae, 0x256b,}, /* 10**-2048 */ + {0xf53f, 0xf698, 0x6bd3, 0x0158, + 0x87a6, 0xc0bd, 0xda57, 0x82a5, 0xa2a6, 0x32b5,}, + {0xe731, 0x04d4, 0xe3f2, 0xd332, + 0x7132, 0xd21c, 0xdb23, 0xee32, 0x9049, 0x395a,}, + {0xa23e, 0x5308, 0xfefb, 0x1155, + 0xfa91, 0x1939, 0x637a, 0x4325, 0xc031, 0x3cac,}, + {0xe26d, 0xdbde, 0xd05d, 0xb3f6, + 0xac7c, 0xe4a0, 0x64bc, 0x467c, 0xddd0, 0x3e55,}, + {0x2a20, 0x6224, 0x47b3, 0x98d7, + 0x3f23, 0xe9a5, 0xa539, 0xea27, 0xa87f, 0x3f2a,}, + {0x0b5b, 0x4af2, 0xa581, 0x18ed, + 0x67de, 0x94ba, 0x4539, 0x1ead, 0xcfb1, 0x3f94,}, + {0xbf71, 0xa9b3, 0x7989, 0xbe68, + 0x4c2e, 0xe15b, 0xc44d, 0x94be, 0xe695, 0x3fc9,}, + {0x3d4d, 0x7c3d, 0x36ba, 0x0d2b, + 0xfdc2, 0xcefc, 0x8461, 0x7711, 0xabcc, 0x3fe4,}, + {0xc155, 0xa4a8, 0x404e, 0x6113, + 0xd3c3, 0x652b, 0xe219, 0x1758, 0xd1b7, 0x3ff1,}, + {0xd70a, 0x70a3, 0x0a3d, 0xa3d7, + 0x3d70, 0xd70a, 0x70a3, 0x0a3d, 0xa3d7, 0x3ff8,}, + {0xcccd, 0xcccc, 0xcccc, 0xcccc, + 0xcccc, 0xcccc, 0xcccc, 0xcccc, 0xcccc, 0x3ffb,}, /* 10**-1 */ +}; + +#else +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 + +/* This routine will not return more than NDEC+1 digits. */ +void __etoasc(short unsigned int * __restrict__ x, + char * __restrict__ string, + const int ndigits, const int outformat, + int* outexp) +{ +long digit; +unsigned short y[NI], t[NI], u[NI], w[NI], equot[NI]; +const unsigned short *r, *p; +const unsigned short *ten; +unsigned short sign; +int i, j, k, expon, ndigs; +char *s, *ss; +unsigned short m; + +ndigs = ndigits; +#ifdef NANS +if( __eisnan(x) ) + { + sprintf( string, " NaN " ); + expon = 9999; + goto bxit; + } +#endif +__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 ) + { + for( k=0; k>= 1; + } +while( m != 0 ); + +/* Rescale from integer significand */ + 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 ); + __emul( p, t, t ); + 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 ); + expon -= 1; + } + } + else + { + __emovi( y, w ); + for( i=0; i 0 ) + { + if( __ecmp( p, w ) >= 0 ) + { + __emul( r, w, w ); + __emul( r, t, t ); + expon += k; + } + k /= 2; + if( k == 0 ) + break; + p += NE; + r += NE; + } + __ediv( t, __eone, t ); + } +isone: +/* Find the first (leading) digit. */ +__emovi( t, w ); +__emovz( w, t ); +__emovi( y, w ); +__emovz( w, y ); +__eiremain( t, y, equot); +digit = equot[NI-1]; +while( (digit == 0) && (__eiszero(y) == 0) ) + { + __eshup1( y ); + __emovz( y, u ); + __eshup1( u ); + __eshup1( u ); + __eaddm( u, y ); + __eiremain( t, y, equot); + 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; +/* +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++ = '.'; + } +/* Generate digits after the decimal point. */ +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, equot); + *s++ = (char )equot[NI-1] + '0'; + } +digit = equot[NI-1]; +--s; +ss = s; +/* round off the ASCII string */ +if( digit > 4 ) + { +/* Test for critical rounding case in ASCII output. */ + if( digit == 5 ) + { + if( __eiiszero(y) == 0 ) + goto roun; /* round to nearest */ + if( (*(s-1) & 1) == 0 ) + goto doexp; /* round to even */ + } +/* Round up and propagate carry-outs */ +roun: + --s; + k = *s & 0x7f; +/* Carry out to most significant digit? */ + if( ndigs < 0 ) + { + /* This will print like "1E-6". */ + *s = '1'; + + expon += 1; + goto doexp; + } + else if( k == '.' ) + { + --s; + k = *s; + k += 1; + *s = (char )k; +/* Most significant digit carries to 10? */ + if( k > '9' ) + { + expon += 1; + *s = '1'; + } + goto doexp; + } +/* Round up and carry out from less significant digits */ + k += 1; + *s = (char )k; + if( k > '9' ) + { + *s = '0'; + goto roun; + } + } +doexp: +#if defined (__GO32__) || defined (__MINGW32__) +if( expon >= 0 ) + sprintf( ss, "e+%02d", expon ); +else + sprintf( ss, "e-%02d", -expon ); +#else + sprintf( ss, "E%d", expon ); +#endif +bxit: + +if (outexp) + *outexp = expon; +} + + +/* FIXME: Not thread safe */ +static char outstr[128]; + + char * +_IO_ldtoa(long double d, int mode, int ndigits, int *decpt, + int *sign, char **rve) +{ +unsigned short e[NI]; +char *s, *p; +int k; +int outexpon = 0; + +union + { + unsigned short int us[6]; + long double ld; + } xx; +xx.ld = d; +__e64toe(xx.us, e ); +if( __eisneg(e) ) + *sign = 1; +else + *sign = 0; +/* Mode 3 is "f" format. */ +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; +/* 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, outstr, ndigits, mode, &outexpon ); +s = outstr; +if( __eisinf(e) || __eisnan(e) ) + { + *decpt = 9999; + goto stripspaces; + } +*decpt = outexpon + 1; + +/* Transform the string returned by etoasc into what the caller wants. */ + +/* Look for decimal point and delete it from the string. */ +s = outstr; +while( *s != '\0' ) + { + if( *s == '.' ) + goto yesdecpt; + ++s; + } +goto nodecpt; + +yesdecpt: + +/* Delete the decimal point. */ +while( *s != '\0' ) + { + *s = *(s+1); + ++s; + } + +nodecpt: + +/* Back up over the exponent field. */ +while( *s != 'E' && *s != 'e' && s > outstr) + --s; +*s = '\0'; + +stripspaces: + +/* Strip leading spaces and sign. */ +p = outstr; +while( *p == ' ' || *p == '-') + ++p; + +/* Find new end of string. */ +s = outstr; +while( (*s++ = *p++) != '\0' ) + ; +--s; + +/* Strip trailing zeros. */ +if( mode == 2 ) + k = 1; +else if( ndigits > outexpon ) + k = ndigits; +else + k = outexpon; + +while( *(s-1) == '0' && ((s - outstr) > 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 + outexpon) < 0)) + { + s = outstr; + *s = '\0'; + *decpt = 0; + } + +if( rve ) + *rve = s; +return outstr; +} + +void +_IO_ldtostr(long double *x, char *string, int ndigs, int flags, char fmt) +{ +unsigned short w[NI]; +char *t, *u; +int outexpon = 0; +int outformat = -1; +char dec_sym = *(localeconv()->decimal_point); + +__e64toe( (unsigned short *)x, w ); +__etoasc( w, string, ndigs, outformat, &outexpon ); + +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 (dec_sym != '.') + { + t = string; + while (*t != '.') + ++t; + *t = dec_sym; + } +} + +#endif /* USE_LDTOA */ diff --git a/winsup/mingw/mingwex/math/cephes_emath.c b/winsup/mingw/mingwex/math/cephes_emath.c new file mode 100644 index 000000000..ab798a2d2 --- /dev/null +++ b/winsup/mingw/mingwex/math/cephes_emath.c @@ -0,0 +1,1318 @@ +/* This file is extracted from S L Moshier's ioldoubl.c, + * modified for use in MinGW + * + * Extended precision arithmetic functions for long double I/O. + * This program has been placed in the public domain. + */ + + + +/* + * Revision history: + * + * 5 Jan 84 PDP-11 assembly language version + * 6 Dec 86 C language version + * 30 Aug 88 100 digit version, improved rounding + * 15 May 92 80-bit long double support + * + * Author: S. L. Moshier. + * + * 6 Oct 02 Modified for MinGW by inlining utility routines, + * removing global variables and splitting out strtold + * from _IO_ldtoa and _IO_ldtostr. + * + * Danny Smith + * + */ + + +#include "cephes_emath.h" + +/* + * The constants are for 64 bit precision. + */ + + +/* Move in external format number, + * converting it to internal format. + */ +void __emovi(const short unsigned int * __restrict__ a, + short unsigned int * __restrict__ b) +{ +register const unsigned short *p; +register unsigned short *q; +int i; + +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; +/* get the exponent */ +*q = *p--; +*q++ &= 0x7fff; /* delete the sign bit */ +#ifdef INFINITY +if( (*(q-1) & 0x7fff) == 0x7fff ) + { +#ifdef NANS + if( __eisnan(a) ) + { + *q++ = 0; + for( i=3; i> 16) + (m >> 16) + *pp; + *pp = (unsigned short )carry; + *(pp-1) = carry >> 16; + } + } +for( i=M; i tdenm ) + tquot = 0xffff; +*/ + /* Multiply denominator by trial quotient digit. */ + __m16m( tquot, den, tprod ); + /* The quotient digit may have been overestimated. */ + if( __ecmpm( tprod, num ) > 0 ) + { + tquot -= 1; + __esubm( den, tprod ); + if( __ecmpm( tprod, num ) > 0 ) + { + tquot -= 1; + __esubm( den, tprod ); + } + } + __esubm( tprod, num ); + equot[i] = tquot; + __eshup6(num); + } +/* test for nonzero remainder after roundoff bit */ +p = &num[M]; +j = 0; +for( i=M; i NBITS ) + { + __ecleazs( s ); + return; + } +#endif +exp -= j; +#ifndef INFINITY +if( exp >= 32767L ) + goto overf; +#else +if( (j > NBITS) && (exp < 32767L) ) + { + __ecleazs( s ); + return; + } +#endif +if( exp < 0L ) + { + if( exp > (long )(-NBITS-1) ) + { + j = (int )exp; + i = __eshift( s, j ); + if( i ) + lost = 1; + } + else + { + __ecleazs( s ); + return; + } + } +/* Round off, unless told not to by rcntrl. */ +if( rcntrl == 0 ) + goto mdfin; +if (rndprc == 64) + { + rw = 7; + re = 6; + rbit[NI-2] = 0; + rbit[6] = 1; + } + +/* Shift down 1 temporarily if the data structure has an implied + * most significant bit and the number is denormal. + * For rndprc = 64 or NBITS, there is no implied bit. + * But Intel long double denormals lose one bit of significance even so. + */ +#if IBMPC +if( (exp <= 0) && (rndprc != NBITS) ) +#else +if( (exp <= 0) && (rndprc != 64) && (rndprc != NBITS) ) +#endif + { + lost |= s[NI-1] & 1; + __eshdn1(s); + } +/* Clear out all bits below the rounding bit, + * remembering in r if any were nonzero. + */ +r = s[rw] & rmsk; +if( rndprc < NBITS ) + { + i = rw + 1; + while( i < NI ) + { + if( s[i] ) + r |= 1; + s[i] = 0; + ++i; + } + } +s[rw] &= ~rmsk; +if( (r & rmbit) != 0 ) + { + if( r == rmbit ) + { + if( lost == 0 ) + { /* round to even */ + if( (s[re] & 1) == 0 ) + goto mddone; + } + else + { + if( subflg != 0 ) + goto mddone; + } + } + __eaddm( rbit, s ); + } +mddone: +#if IBMPC +if( (exp <= 0) && (rndprc != NBITS) ) +#else +if( (exp <= 0) && (rndprc != 64) && (rndprc != NBITS) ) +#endif + { + __eshup1(s); + } +if( s[2] != 0 ) + { /* overflow on roundoff */ + __eshdn1(s); + exp += 1; + } +mdfin: +s[NI-1] = 0; +if( exp >= 32767L ) + { +#ifndef INFINITY +overf: +#endif +#ifdef INFINITY + s[1] = 32767; + for( i=2; i b + * 0 if a == b + * -1 if a < b + * -2 if either a or b is a NaN. + */ +int __ecmp(const short unsigned int * __restrict__ a, + const short unsigned int * __restrict__ b) +{ +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 ); +#endif +__emovi( a, ai ); +p = ai; +__emovi( b, bi ); +q = bi; + +if( *p != *q ) + { /* the signs are different */ +/* -0 equals + 0 */ + for( i=1; i 0 ); + +return(0); /* equality */ + + + +diff: + +if( *(--p) > *(--q) ) + return( msign ); /* p is bigger */ +else + return( -msign ); /* p is littler */ +} + +/* +; Shift significand +; +; Shifts significand area up or down by the number of bits +; given by the variable sc. +*/ +int __eshift(short unsigned int *x, int sc) +{ +unsigned short lost; +unsigned short *p; + +if( sc == 0 ) + return( 0 ); + +lost = 0; +p = x + NI-1; + +if( sc < 0 ) + { + sc = -sc; + while( sc >= 16 ) + { + lost |= *p; /* remember lost bits */ + __eshdn6(x); + sc -= 16; + } + + while( sc >= 8 ) + { + lost |= *p & 0xff; + __eshdn8(x); + sc -= 8; + } + + while( sc > 0 ) + { + lost |= *p & 1; + __eshdn1(x); + sc -= 1; + } + } +else + { + while( sc >= 16 ) + { + __eshup6(x); + sc -= 16; + } + + while( sc >= 8 ) + { + __eshup8(x); + sc -= 8; + } + + while( sc > 0 ) + { + __eshup1(x); + sc -= 1; + } + } +if( lost ) + lost = 1; +return( (int )lost ); +} + + + +/* +; normalize +; +; Shift normalizes the significand area pointed to by argument +; shift count (up = positive) is returned. +*/ +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; +/* With guard word, there are NBITS+16 bits available. + * return true if all are zero. + */ + if( sc > NBITS ) + return( sc ); + } +/* see if high byte is zero */ +while( (*p & 0xff00) == 0 ) + { + __eshup8(x); + sc += 8; + } +/* now shift 1 bit at a time */ +while( (*p & 0x8000) == 0) + { + __eshup1(x); + sc += 1; + if( sc > (NBITS+16) ) + { + mtherr( "enormlz", UNDERFLOW ); + 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( sc < -NBITS ) + { + mtherr( "enormlz", OVERFLOW ); + return( sc ); + } + } +return( sc ); +} + + +/* Move internal format number out, + * converting it to external format. + */ +void __emovo(const short unsigned int * __restrict__ a, + short unsigned int * __restrict__ b) +{ +register const unsigned short *p; +register unsigned short *q; +unsigned short i; + +p = a; +q = b + (NE-1); /* point to output exponent */ +/* combine sign and exponent */ +i = *p++; +if( i ) + *q-- = *p++ | 0x8000; +else + *q-- = *p++; +#ifdef INFINITY +if( *(p-1) == 0x7fff ) + { +#ifdef NANS + if( __eiisnan(a) ) + { + __enan_NBITS( b ); + return; + } +#endif + __einfin(b); + return; + } +#endif +/* skip over guard word */ +++p; +/* move the significand */ +for( i=0; i= 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, NBITS ); +} + + +void __eadd1(const short unsigned int * __restrict__ a, + const short unsigned int * __restrict__ b, + short unsigned int * __restrict__ c, + int subflg) +{ +unsigned short ai[NI], bi[NI], ci[NI]; +int i, lost, j, k; +long lt, lta, ltb; + +#ifdef 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( sub ) + 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 + { +/* exponents were the same, so must compare significands */ + i = __ecmpm( ai, bi ); + if( i == 0 ) + { /* the numbers are identical in magnitude */ + /* if different signs, result is zero */ + if( ai[0] != bi[0] ) + { + __eclear(c); + return; + } + /* if same sign, result is double */ + /* double denomalized tiny number */ + if( (bi[E] == 0) && ((bi[3] & 0x8000) == 0) ) + { + __eshup1( bi ); + goto done; + } + /* add 1 to exponent unless both are zero! */ + for( j=1; j 0 ) + { /* put the larger number in bi */ + __emovz( bi, ci ); + __emovz( ai, bi ); + __emovz( ci, ai ); + } + } +if( ai[0] == bi[0] ) + { + __eaddm( ai, bi ); + subflg = 0; + } +else + { + __esubm( ai, bi ); + subflg = 1; + } +__emdnorm( bi, lost, subflg, ltb, 64, NBITS); + +done: +__emovo( bi, c ); +} + + +/* y = largest integer not greater than x + * (truncated toward minus infinity) + * + * unsigned short x[NE], y[NE] + * + * efloor( x, y ); + */ + + +void __efloor(short unsigned int *x, short unsigned int *y) +{ +register unsigned short *p; +int e, expon, i; +unsigned short f[NE]; +const unsigned short bmask[] = { +0xffff, +0xfffe, +0xfffc, +0xfff8, +0xfff0, +0xffe0, +0xffc0, +0xff80, +0xff00, +0xfe00, +0xfc00, +0xf800, +0xf000, +0xe000, +0xc000, +0x8000, +0x0000, +}; + +__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; + +p = &y[0]; +while( e >= 16 ) + { + *p++ = 0; + e -= 16; + } +/* clear the remaining bits */ +*p &= bmask[e]; +/* truncate negatives toward minus infinity */ +isitneg: + +if( (unsigned short )expon & (unsigned short )0x8000 ) + { + for( i=0; i + * + */ + + + +/* ieee.c + * + * Extended precision IEEE binary floating point arithmetic routines + * + * Numbers are stored in C language as arrays of 16-bit unsigned + * short integers. The arguments of the routines are pointers to + * the arrays. + * + * + * External e type data structure, simulates Intel 8087 chip + * temporary real format but possibly with a larger significand: + * + * NE-1 significand words (least significant word first, + * most significant bit is normally set) + * exponent (value = EXONE for 1.0, + * top bit is the sign) + * + * + * Internal data structure of a number (a "word" is 16 bits): + * + * ei[0] sign word (0 for positive, 0xffff for negative) + * ei[1] biased __exponent (value = EXONE for the number 1.0) + * ei[2] high guard word (always zero after normalization) + * ei[3] + * to ei[NI-2] significand (NI-4 significand words, + * most significant word first, + * most significant bit is set) + * ei[NI-1] low guard word (0x8000 bit is rounding place) + * + * + * + * Routines for external format numbers + * + * __asctoe64( string, &d ) ASCII string to long double + * __asctoeg( string, e, prec ) ASCII string to specified precision + * __e64toe( &d, e ) IEEE long double precision to e type + * __eadd( a, b, c ) c = b + a + * __eclear(e) e = 0 + * __ecmp (a, b) Returns 1 if a > b, 0 if a == b, + * -1 if a < b, -2 if either a or b is a NaN. + * __ediv( a, b, c ) c = b / a + * __efloor( a, b ) truncate to integer, toward -infinity + * __efrexp( a, exp, s ) extract exponent and significand + * __eifrac( e, &l, frac ) e to long integer and e type fraction + * __euifrac( e, &l, frac ) e to unsigned long integer and e type fraction + * __einfin( e ) set e to infinity, leaving its sign alone + * __eldexp( a, n, b ) multiply by 2**n + * __emov( a, b ) b = a + * __emul( a, b, c ) c = b * a + * __eneg(e) e = -e + * __eround( a, b ) b = nearest integer value to a + * __esub( a, b, c ) c = b - a + * __e24toasc( &f, str, n ) single to ASCII string, n digits after decimal + * __e53toasc( &d, str, n ) double to ASCII string, n digits after decimal + * __e64toasc( &d, str, n ) long double to ASCII string + * __etoasc( e, str, n ) e to ASCII string, n digits after decimal + * __etoe24( e, &f ) convert e type to IEEE single precision + * __etoe53( e, &d ) convert e type to IEEE double precision + * __etoe64( e, &d ) convert e type to IEEE long double precision + * __eisneg( e ) 1 if sign bit of e != 0, else 0 + * __eisinf( e ) 1 if e has maximum exponent (non-IEEE) + * or is infinite (IEEE) + * __eisnan( e ) 1 if e is a NaN + * __esqrt( a, b ) b = square root of a + * + * + * Routines for internal format numbers + * + * __eaddm( ai, bi ) add significands, bi = bi + ai + * __ecleaz(ei) ei = 0 + * __ecleazs(ei) set ei = 0 but leave its sign alone + * __ecmpm( ai, bi ) compare significands, return 1, 0, or -1 + * __edivm( ai, bi ) divide significands, bi = bi / ai + * __emdnorm(ai,l,s,exp) normalize and round off + * __emovi( a, ai ) convert external a to internal ai + * __emovo( ai, a ) convert internal ai to external a + * __emovz( ai, bi ) bi = ai, low guard word of bi = 0 + * __emulm( ai, bi ) multiply significands, bi = bi * ai + * __enormlz(ei) left-justify the significand + * __eshdn1( ai ) shift significand and guards down 1 bit + * __eshdn8( ai ) shift down 8 bits + * __eshdn6( ai ) shift down 16 bits + * __eshift( ai, n ) shift ai n bits up (or down if n < 0) + * __eshup1( ai ) shift significand and guards up 1 bit + * __eshup8( ai ) shift up 8 bits + * __eshup6( ai ) shift up 16 bits + * __esubm( ai, bi ) subtract significands, bi = bi - ai + * + * + * The result is always normalized and rounded to NI-4 word precision + * after each arithmetic operation. + * + * Exception flags are NOT fully supported. + * + * Define INFINITY in mconf.h for support of infinity; otherwise a + * saturation arithmetic is implemented. + * + * Define NANS for support of Not-a-Number items; otherwise the + * arithmetic will never produce a NaN output, and might be confused + * by a NaN input. + * If NaN's are supported, the output of ecmp(a,b) is -2 if + * either a or b is a NaN. This means asking if(ecmp(a,b) < 0) + * may not be legitimate. Use if(ecmp(a,b) == -1) for less-than + * if in doubt. + * Signaling NaN's are NOT supported; they are treated the same + * as quiet NaN's. + * + * Denormals are always supported here where appropriate (e.g., not + * for conversion to DEC numbers). + */ + +#include +#include +#include +#include +#include +#include +#include + +#define alloca __builtin_alloca + +/* Don't build non-ANSI _IO_ldtoa. It is not thread safe. */ +#ifndef USE_LDTOA +#define USE_LDTOA 0 +#endif + + + /* Number of 16 bit words in external x type format */ +#define NE 6 + + /* Number of 16 bit words in internal format */ +#define NI (NE+3) + + /* Array offset to exponent */ +#define E 1 + + /* Array offset to high guard word */ +#define M 2 + + /* Number of bits of precision */ +#define NBITS ((NI-4)*16) + + /* Maximum number of decimal digits in ASCII conversion + * = NBITS*log10(2) + */ +#define NDEC (NBITS*8/27) + + /* The exponent of 1.0 */ +#define EXONE (0x3fff) + + +#define mtherr(x,y) + + +extern long double strtold (const char * __restrict__ s, char ** __restrict__ se); +extern int __asctoe64(const char * __restrict__ ss, + short unsigned int * __restrict__ y); +extern void __emul(const short unsigned int * a, + const short unsigned int * b, + short unsigned int * c); +extern int __ecmp(const short unsigned int * __restrict__ a, + const short unsigned int * __restrict__ b); +extern int __enormlz(short unsigned int *x); +extern int __eshift(short unsigned int *x, int sc); +extern void __eaddm(const short unsigned int * __restrict__ x, + short unsigned int * __restrict__ y); +extern void __esubm(const short unsigned int * __restrict__ x, + short unsigned int * __restrict__ y); +extern void __emdnorm(short unsigned int *s, int lost, int subflg, + long int exp, int rcntrl, const int rndprc); +extern void __toe64(short unsigned int * __restrict__ a, + short unsigned int * __restrict__ b); +extern int __edivm(short unsigned int * __restrict__ den, + short unsigned int * __restrict__ num); +extern int __emulm(const short unsigned int * __restrict__ a, + short unsigned int * __restrict__ b); +extern void __emovi(const short unsigned int * __restrict__ a, + short unsigned int * __restrict__ b); +extern void __emovo(const short unsigned int * __restrict__ a, + short unsigned int * __restrict__ b); + +#if USE_LDTOA + +extern char * _IO_ldtoa(long double, int, int, int *, int *, char **); +extern void _IO_ldtostr(long double *x, char *string, int ndigs, + int flags, char fmt); + +extern void __eiremain(short unsigned int * __restrict__ den, + short unsigned int *__restrict__ num, + short unsigned int *__restrict__ equot); +extern void __efloor(short unsigned int *x, short unsigned int *y); +extern void __eadd1(const short unsigned int * __restrict__ a, + const short unsigned int * __restrict__ b, + short unsigned int * __restrict__ c, + int subflg); +extern void __esub(const short unsigned int *a, const short unsigned int *b, + short unsigned int *c); +extern void __ediv(const short unsigned int *a, const short unsigned int *b, + short unsigned int *c); +extern void __e64toe(short unsigned int *pe, short unsigned int *y); + + +#endif + +static __inline__ int __eisneg(const short unsigned int *x); +static __inline__ int __eisinf(const short unsigned int *x); +static __inline__ int __eisnan(const short unsigned int *x); +static __inline__ int __eiszero(const short unsigned int *a); +static __inline__ void __emovz(register const short unsigned int * __restrict__ a, + register short unsigned int * __restrict__ b); +static __inline__ void __eclear(register short unsigned int *x); +static __inline__ void __ecleaz(register short unsigned int *xi); +static __inline__ void __ecleazs(register short unsigned int *xi); +static __inline__ int __eiisinf(const short unsigned int *x); +static __inline__ int __eiisnan(const short unsigned int *x); +static __inline__ int __eiiszero(const short unsigned int *x); +static __inline__ void __enan_64(short unsigned int *nan); +static __inline__ void __enan_NBITS (short unsigned int *nan); +static __inline__ void __enan_NI16 (short unsigned int *nan); +static __inline__ void __einfin(register short unsigned int *x); +static __inline__ void __eneg(short unsigned int *x); +static __inline__ void __eshup1(register short unsigned int *x); +static __inline__ void __eshup8(register short unsigned int *x); +static __inline__ void __eshup6(register short unsigned int *x); +static __inline__ void __eshdn1(register short unsigned int *x); +static __inline__ void __eshdn8(register short unsigned int *x); +static __inline__ void __eshdn6(register short unsigned int *x); + + + +/* Intel IEEE, low order words come first: + */ +#define IBMPC 1 + +/* Define 1 for ANSI C atan2() function + * See atan.c and clog.c. + */ +#define ANSIC 1 + +/*define VOLATILE volatile*/ +#define VOLATILE + +/* For 12-byte long doubles on an i386, pad a 16-bit short 0 + * to the end of real constants initialized by integer arrays. + * + * #define XPD 0, + * + * Otherwise, the type is 10 bytes long and XPD should be + * defined blank. + * + * #define XPD + */ +#define XPD 0, +/* #define XPD */ +#define NANS +#define INFINITY + +/* NaN's require infinity support. */ +#ifdef NANS +#ifndef INFINITY +#define INFINITY +#endif +#endif + +/* This handles 64-bit long ints. */ +#define LONGBITS (8 * sizeof(long)) + + +#define NTEN 12 +#define MAXP 4096 + +extern const unsigned short __etens[NTEN + 1][NE]; + +/* +; Clear out entire external format number. +; +; unsigned short x[]; +; eclear( x ); +*/ + +static __inline__ void __eclear(register short unsigned int *x) +{ + memset(x, 0, NE * sizeof(unsigned short)); +} + + +/* Move external format number from a to b. + * + * emov( a, b ); + */ + +static __inline__ void __emov(register const short unsigned int * __restrict__ a, + register short unsigned int * __restrict__ b) +{ + memcpy(b, a, NE * sizeof(unsigned short)); +} + + +/* +; Negate external format number +; +; unsigned short x[NE]; +; eneg( x ); +*/ + +static __inline__ void __eneg(short unsigned int *x) +{ + +#ifdef NANS +if( __eisnan(x) ) + return; +#endif +x[NE-1] ^= 0x8000; /* Toggle the sign bit */ +} + + +/* Return 1 if external format number is negative, + * else return zero. + */ +static __inline__ int __eisneg(const short unsigned int *x) +{ + +#ifdef NANS +if( __eisnan(x) ) + return( 0 ); +#endif +if( x[NE-1] & 0x8000 ) + return( 1 ); +else + return( 0 ); +} + + +/* Return 1 if external format number has maximum possible exponent, + * else return zero. + */ +static __inline__ int __eisinf(const short unsigned int *x) +{ + +if( (x[NE-1] & 0x7fff) == 0x7fff ) + { +#ifdef NANS + if( __eisnan(x) ) + return( 0 ); +#endif + return( 1 ); + } +else + return( 0 ); +} + +/* Check if e-type number is not a number. + */ +static __inline__ int __eisnan(const short unsigned int *x) +{ +#ifdef NANS +int i; +/* NaN has maximum __exponent */ +if( (x[NE-1] & 0x7fff) == 0x7fff ) +/* ... and non-zero significand field. */ + for( i=0; i b +; 0 if a == b +; -1 if a < b +*/ +static __inline__ int __ecmpm(register const short unsigned int * __restrict__ a, + register const short unsigned int * __restrict__ b) +{ +int i; + +a += M; /* skip up to significand area */ +b += M; +for( i=M; i *(--b) ) + return(1); +else + return(-1); +} + + +/* +; Shift significand down by 1 bit +*/ + +static __inline__ 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>= 1; + if( bits & 2 ) + *x |= 0x8000; + bits <<= 1; + ++x; + } +} + +/* +; Shift significand up by 1 bit +*/ + +static __inline__ void __eshup1(register short unsigned int *x) +{ +register unsigned short bits; +int i; + +x += NI-1; +bits = 0; + +for( i=M; i>= 8; + *x |= oldbyt; + oldbyt = newbyt; + ++x; + } +} + +/* +; Shift significand up by 8 bits +*/ + +static __inline__ void __eshup8(register short unsigned int *x) +{ +int i; +register unsigned short newbyt, oldbyt; + +x += NI-1; +oldbyt = 0; + +for( i=M; i> 8; + *x <<= 8; + *x |= oldbyt; + oldbyt = newbyt; + --x; + } +} + +/* +; Shift significand up by 16 bits +*/ + +static __inline__ void __eshup6(register short unsigned int *x) +{ +int i; +register unsigned short *p; + +p = x + M; +x += M + 1; + +for( i=M; i + */ + + +#include "math/cephes_emath.h" + +#if NE == 10 + +/* 1.0E0 */ +static const unsigned short __eone[NE] = + {0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x8000, 0x3fff,}; +#else +static const unsigned short __eone[NE] = { +0, 0000000,0000000,0000000,0100000,0x3fff,}; +#endif + +#if NE == 10 +static const unsigned short __etens[NTEN + 1][NE] = +{ + {0x6576, 0x4a92, 0x804a, 0x153f, + 0xc94c, 0x979a, 0x8a20, 0x5202, 0xc460, 0x7525,}, /* 10**4096 */ + {0x6a32, 0xce52, 0x329a, 0x28ce, + 0xa74d, 0x5de4, 0xc53d, 0x3b5d, 0x9e8b, 0x5a92,}, /* 10**2048 */ + {0x526c, 0x50ce, 0xf18b, 0x3d28, + 0x650d, 0x0c17, 0x8175, 0x7586, 0xc976, 0x4d48,}, + {0x9c66, 0x58f8, 0xbc50, 0x5c54, + 0xcc65, 0x91c6, 0xa60e, 0xa0ae, 0xe319, 0x46a3,}, + {0x851e, 0xeab7, 0x98fe, 0x901b, + 0xddbb, 0xde8d, 0x9df9, 0xebfb, 0xaa7e, 0x4351,}, + {0x0235, 0x0137, 0x36b1, 0x336c, + 0xc66f, 0x8cdf, 0x80e9, 0x47c9, 0x93ba, 0x41a8,}, + {0x50f8, 0x25fb, 0xc76b, 0x6b71, + 0x3cbf, 0xa6d5, 0xffcf, 0x1f49, 0xc278, 0x40d3,}, + {0x0000, 0x0000, 0x0000, 0x0000, + 0xf020, 0xb59d, 0x2b70, 0xada8, 0x9dc5, 0x4069,}, + {0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0400, 0xc9bf, 0x8e1b, 0x4034,}, + {0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x2000, 0xbebc, 0x4019,}, + {0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x9c40, 0x400c,}, + {0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0xc800, 0x4005,}, + {0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0xa000, 0x4002,}, /* 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 */ +}; +#endif + +int __asctoe64(const char * __restrict__ ss, short unsigned int * __restrict__ y) +{ +unsigned short yy[NI], xt[NI], tt[NI]; +int esign, decflg, sgnflg, nexp, exp, prec, lost; +int k, trail, c; +long lexp; +unsigned short nsign; +const unsigned short *p; +char *sp, *lstr; +char *s; + +char dec_sym = *(localeconv ()->decimal_point); + +int lenldstr = 0; + +/* Copy the input string. */ +c = strlen (ss) + 2; +lstr = (char *) alloca (c); +s = (char *) ss; +while( isspace ((int)(unsigned char)*s)) /* skip leading spaces */ + { + ++s; + ++lenldstr; + } +sp = lstr; +for( k=0; k= 0) && (k <= 9) ) + { +/* Ignore leading zeros */ + 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; + --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; + } +if (*s == dec_sym) + { + if( decflg ) + goto daldone; + ++decflg; + } +else + switch( *s ) + { + case 'z': + break; + case 'E': + case 'e': + goto expnt; + case '-': + nsign = 0xffff; + if( sgnflg ) + goto daldone; + ++sgnflg; + break; + case '+': + if( sgnflg ) + goto daldone; + ++sgnflg; + break; + case 'i': + case 'I': + { + s++; + if (*s != 'n' && *s != 'N') + goto zero; + s++; + if (*s != 'f' && *s != 'F') + goto zero; + s++; + if ((*s == 'i' || *s == 'I') && (s[1] == 'n' || s[1] == 'N') + && (s[2] == 'i' || s[2] == 'I') + && (s[3] == 't' || s[3] == 'T') + && (s[4] == 'y' || s[4] == 'Y')) + s += 5; + goto infinite; + } + case 'n': + case 'N': + { + s++; + if (*s != 'a' && *s != 'A') + goto zero; + s++; + if (*s != 'n' && *s != 'N') + goto zero; + s++; + __enan_NI16( yy ); + goto aexit; + } + default: + goto daldone; + } +donchr: +++s; +goto nxtcom; + +/* Exponent interpretation */ +expnt: + +esign = 1; +exp = 0; +++s; +/* check for + or - */ +if( *s == '-' ) + { + esign = -1; + ++s; + } +if( *s == '+' ) + ++s; +while( (*s >= '0') && (*s <= '9') && exp < 4978) + { + exp *= 10; + exp += *s++ - '0'; + } +if( esign < 0 ) + exp = -exp; +if( exp > 4932 ) + { + errno = ERANGE; +infinite: + __ecleaz(yy); + yy[E] = 0x7fff; /* infinity */ + goto aexit; + } +if( exp < -4977 ) + { + errno = ERANGE; +zero: + __ecleaz(yy); + goto aexit; + } + +daldone: +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, NBITS ); +/* convert to external format */ + + +/* Multiply by 10**nexp. If precision is 64 bits, + * the maximum relative error incurred in forming 10**n + * for 0 <= n <= 324 is 8.2e-20, at 10**180. + * 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 ); + lexp += EXONE; + nexp -= 4096; + } + } +p = &__etens[NTEN][0]; +__emov( __eone, xt ); +exp = 1; +do + { + if( exp & nexp ) + __emul( p, xt, xt ); + p -= NE; + exp = exp + exp; + } +while( exp <= MAXP ); + +__emovi( xt, tt ); +if( esign < 0 ) + { + lexp -= tt[E]; + k = __edivm( tt, yy ); + lexp += EXONE; + } +else + { + lexp += tt[E]; + k = __emulm( tt, yy ); + lexp -= EXONE - 1; + } + +expdon: + +/* Round and convert directly to the destination type */ + +__emdnorm( yy, k, 0, lexp, 64, 64 ); + +aexit: + +yy[0] = nsign; +__toe64( yy, y ); +return (lenldstr + s - lstr); +} + + +long double strtold (const char * __restrict__ s, char ** __restrict__ se) +{ + int lenldstr; + union + { + unsigned short int us[6]; + long double ld; + } xx = {{0}}; + + lenldstr = __asctoe64( s, xx.us); + if (se) + *se = (char*)s + lenldstr; + return xx.ld; +} diff --git a/winsup/mingw/mingwex/wcstold.c b/winsup/mingw/mingwex/wcstold.c new file mode 100644 index 000000000..85298807c --- /dev/null +++ b/winsup/mingw/mingwex/wcstold.c @@ -0,0 +1,76 @@ +/* Wide char wrapper for strtold + * Revision history: + * 6 Nov 2002 Initial version. + * + * Contributor: Danny Smith + */ + + /* This routine has been placed in the public domain.*/ + +#define WIN32_LEAN_AND_MEAN +#include +#include +#include +#include +#include + +extern int __asctoe64(const char * __restrict__ ss, + short unsigned int * __restrict__ y); + + +static __inline__ unsigned int get_codepage (void) +{ + char* cp; + + /* + locale :: "lang[_country[.code_page]]" + | ".code_page" + */ + if ((cp = strchr(setlocale(LC_CTYPE, NULL), '.'))) + return atoi( cp + 1); + else + return 0; +} + +long double wcstold (const wchar_t * __restrict__ wcs, wchar_t ** __restrict__ wcse) +{ + char * cs; + int i; + int lenldstr; + union + { + unsigned short int us[6]; + long double ld; + } xx; + + unsigned int cp = get_codepage (); + + /* Allocate enough room for (possibly) mb chars */ + cs = (char *) malloc ((wcslen(wcs)+1) * MB_CUR_MAX); + + if (cp == 0) /* C locale */ + { + for (i = 0; (wcs[i] != 0) && wcs[i] <= 255; i++) + cs[i] = (char) wcs[i]; + cs[i] = '\0'; + } + else + { + int nbytes = -1; + int mb_len = 0; + /* loop through till we hit null or invalid character */ + for (i = 0; (wcs[i] != 0) && (nbytes != 0); i++) + { + nbytes = WideCharToMultiByte(cp, WC_COMPOSITECHECK | WC_SEPCHARS, + wcs + i, 1, cs + mb_len, MB_CUR_MAX, + NULL, NULL); + mb_len += nbytes; + } + cs[mb_len] = '\0'; + } + lenldstr = __asctoe64( cs, xx.us); + free (cs); + if (wcse) + *wcse = (wchar_t*) wcs + lenldstr; + return xx.ld; +}