From 2fea53baf42a973843f0bd1d370910ef8c847549 Mon Sep 17 00:00:00 2001 From: jjohnstn Date: Sat, 17 Aug 2002 05:57:19 +0000 Subject: [PATCH] 2002-08-17 Jeff Johnston * configure.host: Add powerpc*-*-eabispe* configuration. * libc/machine/powerpc/atosfix16.c: New fixed-point conversion file. * libc/machine/powerpc/atosfix32.c: Ditto. * libc/machine/powerpc/atosfix64.c: Ditto. * libc/machine/powerpc/atoufix16.c: Ditto. * libc/machine/powerpc/atoufix32.c: Ditto. * libc/machine/powerpc/atoufix64.c: Ditto. * libc/machine/powerpc/fix64.h: Ditto. * libc/machine/powerpc/simdldtoa.c: Ditto. * libc/machine/powerpc/strtosfix16.c: Ditto. * libc/machine/powerpc/strtosfix32.c: Ditto. * libc/machine/powerpc/strtosfix64.c: Ditto. * libc/machine/powerpc/strtoufix16.c: Ditto. * libc/machine/powerpc/strtoufix32.c: Ditto. * libc/machine/powerpc/strtoufix64.c: Ditto. * libc/machine/powerpc/ufix64toa.c: Ditto. * libc/machine/powerpc/configure.in: Add check for powerpc*-eabispe and add fixed-point conversion functions. * libc/machine/powerpc/configure: Regenerated. * libc/machine/powerpc/vfprintf.c[__SPE__]: Add support for %r and %R format specifiers which handle fixed-point data. * libc/machine/powerpc/vfscanf.c[__SPE__]: Ditto. * libc/machine/powerpc/machine/stdlib.h[__SPE__]: Add fixed-point function prototypes. --- newlib/ChangeLog | 27 + newlib/configure.host | 3 + newlib/libc/machine/powerpc/atosfix16.c | 102 + newlib/libc/machine/powerpc/atosfix32.c | 25 + newlib/libc/machine/powerpc/atosfix64.c | 25 + newlib/libc/machine/powerpc/atoufix16.c | 102 + newlib/libc/machine/powerpc/atoufix32.c | 25 + newlib/libc/machine/powerpc/atoufix64.c | 25 + newlib/libc/machine/powerpc/configure | 4 + newlib/libc/machine/powerpc/configure.in | 4 + newlib/libc/machine/powerpc/fix64.h | 80 + newlib/libc/machine/powerpc/machine/stdlib.h | 38 + newlib/libc/machine/powerpc/simdldtoa.c | 3715 ++++++++++++++++++++++++++ newlib/libc/machine/powerpc/strtosfix16.c | 206 ++ newlib/libc/machine/powerpc/strtosfix32.c | 100 + newlib/libc/machine/powerpc/strtosfix64.c | 113 + newlib/libc/machine/powerpc/strtoufix16.c | 197 ++ newlib/libc/machine/powerpc/strtoufix32.c | 97 + newlib/libc/machine/powerpc/strtoufix64.c | 115 + newlib/libc/machine/powerpc/ufix64toa.c | 88 + newlib/libc/machine/powerpc/vfprintf.c | 133 +- newlib/libc/machine/powerpc/vfscanf.c | 50 +- 22 files changed, 5272 insertions(+), 2 deletions(-) create mode 100644 newlib/libc/machine/powerpc/atosfix16.c create mode 100644 newlib/libc/machine/powerpc/atosfix32.c create mode 100644 newlib/libc/machine/powerpc/atosfix64.c create mode 100644 newlib/libc/machine/powerpc/atoufix16.c create mode 100644 newlib/libc/machine/powerpc/atoufix32.c create mode 100644 newlib/libc/machine/powerpc/atoufix64.c create mode 100644 newlib/libc/machine/powerpc/fix64.h create mode 100644 newlib/libc/machine/powerpc/simdldtoa.c create mode 100644 newlib/libc/machine/powerpc/strtosfix16.c create mode 100644 newlib/libc/machine/powerpc/strtosfix32.c create mode 100644 newlib/libc/machine/powerpc/strtosfix64.c create mode 100644 newlib/libc/machine/powerpc/strtoufix16.c create mode 100644 newlib/libc/machine/powerpc/strtoufix32.c create mode 100644 newlib/libc/machine/powerpc/strtoufix64.c create mode 100644 newlib/libc/machine/powerpc/ufix64toa.c diff --git a/newlib/ChangeLog b/newlib/ChangeLog index 48d7cc8d05..6034e7df18 100644 --- a/newlib/ChangeLog +++ b/newlib/ChangeLog @@ -1,5 +1,32 @@ 2002-08-17 Jeff Johnston + * configure.host: Add powerpc*-*-eabispe* configuration. + * libc/machine/powerpc/atosfix16.c: New fixed-point conversion file. + * libc/machine/powerpc/atosfix32.c: Ditto. + * libc/machine/powerpc/atosfix64.c: Ditto. + * libc/machine/powerpc/atoufix16.c: Ditto. + * libc/machine/powerpc/atoufix32.c: Ditto. + * libc/machine/powerpc/atoufix64.c: Ditto. + * libc/machine/powerpc/fix64.h: Ditto. + * libc/machine/powerpc/simdldtoa.c: Ditto. + * libc/machine/powerpc/strtosfix16.c: Ditto. + * libc/machine/powerpc/strtosfix32.c: Ditto. + * libc/machine/powerpc/strtosfix64.c: Ditto. + * libc/machine/powerpc/strtoufix16.c: Ditto. + * libc/machine/powerpc/strtoufix32.c: Ditto. + * libc/machine/powerpc/strtoufix64.c: Ditto. + * libc/machine/powerpc/ufix64toa.c: Ditto. + * libc/machine/powerpc/configure.in: Add check for + powerpc*-eabispe and add fixed-point conversion functions. + * libc/machine/powerpc/configure: Regenerated. + * libc/machine/powerpc/vfprintf.c[__SPE__]: Add support for + %r and %R format specifiers which handle fixed-point data. + * libc/machine/powerpc/vfscanf.c[__SPE__]: Ditto. + * libc/machine/powerpc/machine/stdlib.h[__SPE__]: Add fixed-point + function prototypes. + +2002-08-17 Jeff Johnston + * Makefile.am: Move cmath stuff into libc/sys/linux. * Makefile.in: Regenerated. * configure.host: Default -DMB_CAPABLE for x86-linux. diff --git a/newlib/configure.host b/newlib/configure.host index 63c636d6ba..8874026e96 100644 --- a/newlib/configure.host +++ b/newlib/configure.host @@ -518,6 +518,9 @@ case "${host}" in powerpc*-*-eabialtivec*) newlib_cflags="${newlib_cflags} -DMISSING_SYSCALL_NAMES -DWANT_PRINTF_LONG_LONG" ;; + powerpc*-*-eabispe*) + newlib_cflags="${newlib_cflags} -DMISSING_SYSCALL_NAMES -DWANT_PRINTF_LONG_LONG" + ;; powerpc*-*-eabi* | \ powerpc*-*-elf* | \ powerpc*-*-linux* | \ diff --git a/newlib/libc/machine/powerpc/atosfix16.c b/newlib/libc/machine/powerpc/atosfix16.c new file mode 100644 index 0000000000..819c2f0688 --- /dev/null +++ b/newlib/libc/machine/powerpc/atosfix16.c @@ -0,0 +1,102 @@ +/* +FUNCTION + <>, <>, <>---string to signed fixed-point + +INDEX + atosfix16 +INDEX + atosfix32 +INDEX + atosfix64 +INDEX + _atosfix16_r +INDEX + _atosfix32_r +INDEX + _atosfix64_r + +ANSI_SYNOPSIS + #include + __int16_t atosfix16(const char *<[s]>); + __int32_t atosfix32(const char *<[s]>); + __int64_t atosfix32(const char *<[s]>); + + __int16_t _atosfix16_r(struct __reent *, const char *<[s]>); + __int32_t _atosfix32_r(struct __reent *, const char *<[s]>); + __int64_t _atosfix32_r(struct __reent *, const char *<[s]>); + +TRAD_SYNOPSIS + #include + __int16_t atosfix16(<[s]>) + const char *<[s]>; + + __int32_t atosfix32(<[s]>) + const char *<[s]>; + + __int64_t atosfix64(<[s]>) + const char *<[s]>; + + __int16_t _atosfix16_r(, <[s]>) + struct _reent *<[reent]>; + const char *<[s]>; + + __int32_t _atosfix32_r(, <[s]>) + struct _reent *<[reent]>; + const char *<[s]>; + + __int64_t _atosfix64_r(, <[s]>) + struct _reent *<[reent]>; + const char *<[s]>; + +DESCRIPTION + <> converts the initial portion of a string to a sign + + 15-bit fraction fixed point value. + <> converts the initial portion of a string to a sign + + 31-bit fraction fixed point value. + <> converts the initial portion of a string to a sign + + 63-bit fraction fixed point value. + <> is implemented as <> + <> is implemented as <> + <> is implemented as <> + + The alternate functions <<_atosfix16_r>>, <<_atosfix32_r>>, + and <<_atosfix64_r>> are reentrant versions. + The extra argument <[reent]> is a pointer to a reentrancy structure. + +RETURNS + The functions return the converted value, if any. If no conversion was + made, <<0>> is returned. If saturation occurs, <> is stored + in errno. + +PORTABILITY + <>, <>, and <> are non-standard. + + No supporting OS subroutines are directly required. The + OS subroutines required by <> are used. +*/ + +/* + * Jeff Johnston - 02/13/2002 + */ + +#include +#include <_ansi.h> + +__int16_t +_DEFUN (_atosfix16_r, (reent, s), + struct _reent *reent _AND + _CONST char *s) +{ + return _strtosfix16_r (reent, s, NULL); +} + +#ifndef _REENT_ONLY +__int16_t +_DEFUN (atosfix16, (s), + _CONST char *s) +{ + return strtosfix16 (s, NULL); +} + +#endif /* !_REENT_ONLY */ + diff --git a/newlib/libc/machine/powerpc/atosfix32.c b/newlib/libc/machine/powerpc/atosfix32.c new file mode 100644 index 0000000000..5d55e45801 --- /dev/null +++ b/newlib/libc/machine/powerpc/atosfix32.c @@ -0,0 +1,25 @@ +/* + * Jeff Johnston - 02/13/2002 + */ + +#include +#include <_ansi.h> + +__int32_t +_DEFUN (_atosfix32_r, (reent, s), + struct _reent *reent _AND + _CONST char *s) +{ + return _strtosfix32_r (reent, s, NULL); +} + +#ifndef _REENT_ONLY +__int32_t +_DEFUN (atosfix32, (s), + _CONST char *s) +{ + return strtosfix32 (s, NULL); +} + +#endif /* !_REENT_ONLY */ + diff --git a/newlib/libc/machine/powerpc/atosfix64.c b/newlib/libc/machine/powerpc/atosfix64.c new file mode 100644 index 0000000000..b720d3824f --- /dev/null +++ b/newlib/libc/machine/powerpc/atosfix64.c @@ -0,0 +1,25 @@ +/* + * Jeff Johnston - 02/13/2002 + */ + +#include +#include <_ansi.h> + +__int64_t +_DEFUN (_atosfix64_r, (reent, s), + struct _reent *reent _AND + _CONST char *s) +{ + return _strtosfix64_r (reent, s, NULL); +} + +#ifndef _REENT_ONLY +__int64_t +_DEFUN (atosfix64, (s), + _CONST char *s) +{ + return strtosfix64 (s, NULL); +} + +#endif /* !_REENT_ONLY */ + diff --git a/newlib/libc/machine/powerpc/atoufix16.c b/newlib/libc/machine/powerpc/atoufix16.c new file mode 100644 index 0000000000..a84c4c7e17 --- /dev/null +++ b/newlib/libc/machine/powerpc/atoufix16.c @@ -0,0 +1,102 @@ +/* +FUNCTION + <>, <>, <>---string to unsigned fixed-point + +INDEX + atoufix16 +INDEX + atoufix32 +INDEX + atoufix64 +INDEX + _atoufix16_r +INDEX + _atoufix32_r +INDEX + _atoufix64_r + +ANSI_SYNOPSIS + #include + __uint16_t atoufix16(const char *<[s]>); + __uint32_t atoufix32(const char *<[s]>); + __uint64_t atoufix32(const char *<[s]>); + + __uint16_t _atoufix16_r(struct __reent *, const char *<[s]>); + __uint32_t _atoufix32_r(struct __reent *, const char *<[s]>); + __uint64_t _atoufix32_r(struct __reent *, const char *<[s]>); + +TRAD_SYNOPSIS + #include + __uint16_t atoufix16(<[s]>) + const char *<[s]>; + + __uint32_t atoufix32(<[s]>) + const char *<[s]>; + + __uint64_t atoufix64(<[s]>) + const char *<[s]>; + + __uint16_t _atoufix16_r(, <[s]>) + struct _reent *<[reent]>; + const char *<[s]>; + + __uint32_t _atoufix32_r(, <[s]>) + struct _reent *<[reent]>; + const char *<[s]>; + + __uint64_t _atoufix64_r(, <[s]>) + struct _reent *<[reent]>; + const char *<[s]>; + +DESCRIPTION + <> converts the initial portion of a string to a + 16-bit fraction unsigned fixed point value. + <> converts the initial portion of a string to a + 32-bit fraction unsigned fixed point value. + <> converts the initial portion of a string to a + 64-bit fraction unsigned fixed point value. + <> is implemented as <> + <> is implemented as <> + <> is implemented as <> + + The alternate functions <<_atoufix16_r>>, <<_atoufix32_r>>, + and <<_atoufix64_r>> are reentrant versions. + The extra argument <[reent]> is a pointer to a reentrancy structure. + +RETURNS + The functions return the converted value, if any. If no conversion was + made, <<0>> is returned. If saturation occurs, <> is stored + in errno. + +PORTABILITY + <>, <>, and <> are non-standard. + + No supporting OS subroutines are directly required. The + OS subroutines required by <> are used. +*/ + +/* + * Jeff Johnston - 02/13/2002 + */ + +#include +#include <_ansi.h> + +__uint16_t +_DEFUN (_atoufix16_r, (reent, s), + struct _reent *reent _AND + _CONST char *s) +{ + return _strtoufix16_r (reent, s, NULL); +} + +#ifndef _REENT_ONLY +__uint16_t +_DEFUN (atoufix16, (s), + _CONST char *s) +{ + return strtoufix16 (s, NULL); +} + +#endif /* !_REENT_ONLY */ + diff --git a/newlib/libc/machine/powerpc/atoufix32.c b/newlib/libc/machine/powerpc/atoufix32.c new file mode 100644 index 0000000000..f3ef1d43a0 --- /dev/null +++ b/newlib/libc/machine/powerpc/atoufix32.c @@ -0,0 +1,25 @@ +/* + * Jeff Johnston - 02/13/2002 + */ + +#include +#include <_ansi.h> + +__uint32_t +_DEFUN (_atoufix32_r, (reent, s), + struct _reent *reent _AND + _CONST char *s) +{ + return _strtoufix32_r (reent, s, NULL); +} + +#ifndef _REENT_ONLY +__uint32_t +_DEFUN (atoufix32, (s), + _CONST char *s) +{ + return strtoufix32 (s, NULL); +} + +#endif /* !_REENT_ONLY */ + diff --git a/newlib/libc/machine/powerpc/atoufix64.c b/newlib/libc/machine/powerpc/atoufix64.c new file mode 100644 index 0000000000..c2a7eded79 --- /dev/null +++ b/newlib/libc/machine/powerpc/atoufix64.c @@ -0,0 +1,25 @@ +/* + * Jeff Johnston - 02/13/2002 + */ + +#include +#include <_ansi.h> + +__uint64_t +_DEFUN (_atoufix64_r, (reent, s), + struct _reent *reent _AND + _CONST char *s) +{ + return _strtoufix64_r (reent, s, NULL); +} + +#ifndef _REENT_ONLY +__uint64_t +_DEFUN (atoufix64, (s), + _CONST char *s) +{ + return strtoufix64 (s, NULL); +} + +#endif /* !_REENT_ONLY */ + diff --git a/newlib/libc/machine/powerpc/configure b/newlib/libc/machine/powerpc/configure index 34275a3a06..99229f3d4b 100755 --- a/newlib/libc/machine/powerpc/configure +++ b/newlib/libc/machine/powerpc/configure @@ -1494,6 +1494,10 @@ case $host in extra_objs="vfprintf.o vfscanf.o vec_malloc.o vec_calloc.o vec_free.o vec_realloc.o vec_reallocr.o vec_callocr.o" extra_sources="vfprintf.c vfscanf.c vec_malloc.c vec_calloc.c vec_free.c vec_realloc.c vec_mallocr.c" ;; + powerpc*-*spe*) + extra_objs="atosfix16.o atosfix32.o atosfix64.o atoufix16.o atoufix32.o atoufix64.o simdldtoa.o strtosfix16.o strtosfix32.o strtosfix64.o strtoufix16.o strtoufix32.o strtoufix64.o ufix64toa.o vfprintf.o vfscanf.o" + extra_sources="atosfix16.c atosfix32.c atosfix64.c atoufix16.c atoufix32.c atoufix64.c simdldtoa.c strtosfix16.c strtosfix32.c strtosfix64.c strtoufix16.c strtoufix32.c strtoufix64.c ufix64toa.c vfprintf.c vfscanf.c" + ;; esac diff --git a/newlib/libc/machine/powerpc/configure.in b/newlib/libc/machine/powerpc/configure.in index 655c086672..b1c4734ca2 100644 --- a/newlib/libc/machine/powerpc/configure.in +++ b/newlib/libc/machine/powerpc/configure.in @@ -16,6 +16,10 @@ case $host in extra_objs="vfprintf.o vfscanf.o vec_malloc.o vec_calloc.o vec_free.o vec_realloc.o vec_reallocr.o vec_callocr.o" extra_sources="vfprintf.c vfscanf.c vec_malloc.c vec_calloc.c vec_free.c vec_realloc.c vec_mallocr.c" ;; + powerpc*-*spe*) + extra_objs="atosfix16.o atosfix32.o atosfix64.o atoufix16.o atoufix32.o atoufix64.o simdldtoa.o strtosfix16.o strtosfix32.o strtosfix64.o strtoufix16.o strtoufix32.o strtoufix64.o ufix64toa.o vfprintf.o vfscanf.o" + extra_sources="atosfix16.c atosfix32.c atosfix64.c atoufix16.c atoufix32.c atoufix64.c simdldtoa.c strtosfix16.c strtosfix32.c strtosfix64.c strtoufix16.c strtoufix32.c strtoufix64.c ufix64toa.c vfprintf.c vfscanf.c" + ;; esac AC_SUBST(extra_objs) AC_SUBST(extra_sources) diff --git a/newlib/libc/machine/powerpc/fix64.h b/newlib/libc/machine/powerpc/fix64.h new file mode 100644 index 0000000000..3423d3d563 --- /dev/null +++ b/newlib/libc/machine/powerpc/fix64.h @@ -0,0 +1,80 @@ +#ifndef _FIX64_H_ + +#define _FIX64_H_ + +#include +#include +#include +#include +#include + +#ifdef __IEEE_LITTLE_ENDIAN +#define IEEE_8087 +#endif + +#ifdef __IEEE_BIG_ENDIAN +#define IEEE_MC68k +#endif + +#ifdef __Z8000__ +#define Just_16 +#endif + +#if defined(IEEE_8087) + defined(IEEE_MC68k) + defined(VAX) + defined(IBM) != 1 +Exactly one of IEEE_8087, IEEE_MC68k, VAX, or IBM should be defined. +#endif + +union long_double_union +{ + long double ld; + __uint32_t i[4]; +}; + +typedef union long_double_union LONG_DOUBLE_UNION; + +extern void _simdstrtold (char *, char **, LONG_DOUBLE_UNION *); +extern int _simdldchk (LONG_DOUBLE_UNION *); + +#define SIMD_LDBL_MANT_DIG 113 + +#ifdef IEEE_8087 +# define word0(x) (x.i[3]) +# define word1(x) (x.i[2]) +# define word2(x) (x.i[1]) +# define word3(x) (x.i[0]) +#else /* !IEEE_8087 */ +# define word0(x) (x.i[0]) +# define word1(x) (x.i[1]) +# define word2(x) (x.i[2]) +# define word3(x) (x.i[3]) +#endif /* !IEEE_8087 */ + +#undef Exp_shift +#define Exp_shift 16 +#undef Exp_mask +#define Exp_mask ((__uint32_t)0x7fff0000L) +#undef Exp_msk1 +#define Exp_msk1 ((__uint32_t)0x00010000L) +#undef Bias +#define Bias 16383 +#undef Ebits +#define Ebits 15 +#undef Sign_bit +#define Sign_bit ((__uint32_t)0x80000000L) +#define init(x) {} + +union fix64_union +{ + __uint64_t ll; + __uint32_t j[2]; +}; + +#ifdef __LITTLE_ENDIAN__ +# define hiword(y) (y.j[1]) +# define loword(y) (y.j[0]) +#else /* __BIG_ENDIAN__ */ +# define hiword(y) (y.j[0]) +# define loword(y) (y.j[1]) +#endif /* __BIG_ENDIAN__ */ + +#endif /* _FIX64_H_ */ diff --git a/newlib/libc/machine/powerpc/machine/stdlib.h b/newlib/libc/machine/powerpc/machine/stdlib.h index 17e9dc32d2..45173dac55 100644 --- a/newlib/libc/machine/powerpc/machine/stdlib.h +++ b/newlib/libc/machine/powerpc/machine/stdlib.h @@ -16,6 +16,44 @@ _PTR _EXFUN(_vec_realloc_r,(struct _reent *, _PTR __r, size_t __size)); # endif /* __ALTIVEC__ */ +# if defined(__SPE__) + +__int16_t _EXFUN(atosfix16,(const char *__str)); +__int16_t _EXFUN(_atosfix16_r,(struct _reent *, const char *__str)); +__int32_t _EXFUN(atosfix32,(const char *__str)); +__int32_t _EXFUN(_atosfix32_r,(struct _reent *, const char *__str)); +__int64_t _EXFUN(atosfix64,(const char *__str)); +__int64_t _EXFUN(_atosfix64_r,(struct _reent *, const char *__str)); + +__uint16_t _EXFUN(atoufix16,(const char *__str)); +__uint16_t _EXFUN(_atoufix16_r,(struct _reent *, const char *__str)); +__uint32_t _EXFUN(atoufix32,(const char *__str)); +__uint32_t _EXFUN(_atoufix32_r,(struct _reent *, const char *__str)); +__uint64_t _EXFUN(atoufix64,(const char *__str)); +__uint64_t _EXFUN(_atoufix64_r,(struct _reent *, const char *__str)); + +__int16_t _EXFUN(strtosfix16,(const char *__str, char **__endptr)); +__int16_t _EXFUN(_strtosfix16_r,(struct _reent *, const char *__str, + char **__endptr)); +__int32_t _EXFUN(strtosfix32,(const char *__str, char **__endptr)); +__int32_t _EXFUN(_strtosfix32_r,(struct _reent *, const char *__str, + char **__endptr)); +__int64_t _EXFUN(strtosfix64,(const char *__str, char **__endptr)); +__int64_t _EXFUN(_strtosfix64_r,(struct _reent *, const char *__str, + char **__endptr)); + +__uint16_t _EXFUN(strtoufix16,(const char *__str, char **__endptr)); +__uint16_t _EXFUN(_strtoufix16_r,(struct _reent *, const char *__str, + char **__endptr)); +__uint32_t _EXFUN(strtoufix32,(const char *__str, char **__endptr)); +__uint32_t _EXFUN(_strtoufix32_r,(struct _reent *, const char *__str, + char **__endptr)); +__uint64_t _EXFUN(strtoufix64,(const char *__str, char **__endptr)); +__uint64_t _EXFUN(_strtoufix64_r,(struct _reent *, const char *__str, + char **__endptr)); + +# endif /* __SPE__ */ + #endif /* !__STRICT_ANSI__ */ diff --git a/newlib/libc/machine/powerpc/simdldtoa.c b/newlib/libc/machine/powerpc/simdldtoa.c new file mode 100644 index 0000000000..d4299186d2 --- /dev/null +++ b/newlib/libc/machine/powerpc/simdldtoa.c @@ -0,0 +1,3715 @@ + + /* Extended precision arithmetic functions for long double I/O. + * This program has been placed in the public domain. + */ + +#include <_ansi.h> +#include +#include +#include +#include "mprec.h" +#include "fix64.h" + +/* These are the externally visible entries. */ +/* linux name: long double _IO_strtold (char *, char **); */ +void _simdstrtold (char *, char **, LONG_DOUBLE_UNION *); +char * _simdldtoa_r (struct _reent *, LONG_DOUBLE_UNION *, int, int, int *, int *, char **); +int _simdldcheck (LONG_DOUBLE_UNION *); + + /* Number of 16 bit words in external x type format */ + #define NE 10 + + /* 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) + +/* Control structure for long doublue conversion including rounding precision values. + * rndprc can be set to 80 (if NE=6), 64, 56, 53, or 24 bits. + */ +typedef struct +{ + int rlast; + int rndprc; + int rw; + int re; + int outexpon; + unsigned short rmsk; + unsigned short rmbit; + unsigned short rebit; + unsigned short rbit[NI]; + unsigned short equot[NI]; +} LDPARMS; + +static void esub(short unsigned int *a, short unsigned int *b, short unsigned int *c, LDPARMS *ldp); +static void emul(short unsigned int *a, short unsigned int *b, short unsigned int *c, LDPARMS *ldp); +static void ediv(short unsigned int *a, short unsigned int *b, short unsigned int *c, LDPARMS *ldp); +static int ecmp(short unsigned int *a, 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 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); + +#if SIMD_LDBL_MANT_DIG == 24 +static void e24toe(short unsigned int *pe, short unsigned int *y, LDPARMS *ldp); +#elif SIMD_LDBL_MANT_DIG == 53 +static void e53toe(short unsigned int *pe, short unsigned int *y, LDPARMS *ldp); +#elif SIMD_LDBL_MANT_DIG == 64 +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); +#endif + +/* econst.c */ +/* e type constants used by high precision check routines */ + +#if NE == 10 +/* 0.0 */ +static unsigned short ezero[NE] = + {0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,}; + +/* 1.0E0 */ +static unsigned short eone[NE] = + {0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x8000, 0x3fff,}; + +#else + +/* 0.0 */ +static unsigned short ezero[NE] = { +0, 0000000,0000000,0000000,0000000,0000000,}; +/* 1.0E0 */ +static unsigned short eone[NE] = { +0, 0000000,0000000,0000000,0100000,0x3fff,}; + +#endif + +/* Debugging routine for displaying errors */ +#ifdef DEBUG +/* Notice: the order of appearance of the following + * messages is bound to the error codes defined + * in mconf.h. + */ +static char *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) +#endif + +/* 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 + * + * asctoe( string, e ) ASCII string to extended double e type + * asctoe64( string, &d ) ASCII string to long double + * asctoe53( string, &d ) ASCII string to double + * asctoe24( string, &f ) ASCII string to single + * asctoeg( string, e, prec, ldp ) ASCII string to specified precision + * e24toe( &f, e, ldp ) IEEE single precision to e type + * e53toe( &d, e, ldp ) IEEE double precision to e type + * e64toe( &d, e, ldp ) IEEE long double precision to e type + * e113toe( &d, e, ldp ) IEEE long double precision to e type + * eabs(e) absolute value + * 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, ldp ) c = b / a + * efloor( a, b, ldp ) 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, ldp ) 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, ldp ) c = b * a + * eneg(e) e = -e + * eround( a, b ) b = nearest integer value to a + * esub( a, b, c, ldp ) 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,fmt,ldp)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 + * ltoe( &l, e ) long (32 bit) integer to e type + * ultoe( &l, e ) unsigned long (32 bit) integer to e type + * 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, ldp ) divide significands, bi = bi / ai + * emdnorm(ai,l,s,exp,ldp) normalize and round off + * emovi( a, ai ) convert external a to internal ai + * emovo( ai, a, ldp ) convert internal ai to external a + * emovz( ai, bi ) bi = ai, low guard word of bi = 0 + * emulm( ai, bi, ldp ) 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). + */ + +/* + * 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 + * 22 Nov 00 Revised to fit into newlib by Jeff Johnston + * + * Author: S. L. Moshier. + * + * Copyright (c) 1984,2000 S.L. Moshier + * + * Permission to use, copy, modify, and distribute this software for any + * purpose without fee is hereby granted, provided that this entire notice + * is included in all copies of any software which is or includes a copy + * or modification of this software and in all copies of the supporting + * documentation for such software. + * + * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED + * WARRANTY. IN PARTICULAR, THE AUTHOR MAKES NO REPRESENTATION + * OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY OF THIS + * SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE. + * + */ + +#include +/* #include "\usr\include\stdio.h" */ +/*#include "ehead.h"*/ +/*#include "mconf.h"*/ +/* mconf.h + * + * Common include file for math routines + * + * + * + * SYNOPSIS: + * + * #include "mconf.h" + * + * + * + * DESCRIPTION: + * + * This file contains definitions for error codes that are + * passed to the common error handling routine mtherr() + * (which see). + * + * The file also includes a conditional assembly definition + * for the type of computer arithmetic (IEEE, DEC, Motorola + * IEEE, or UNKnown). + * + * For Digital Equipment PDP-11 and VAX computers, certain + * IBM systems, and others that use numbers with a 56-bit + * significand, the symbol DEC should be defined. In this + * mode, most floating point constants are given as arrays + * of octal integers to eliminate decimal to binary conversion + * errors that might be introduced by the compiler. + * + * For computers, such as IBM PC, that follow the IEEE + * Standard for Binary Floating Point Arithmetic (ANSI/IEEE + * Std 754-1985), the symbol IBMPC should be defined. These + * numbers have 53-bit significands. In this mode, constants + * are provided as arrays of hexadecimal 16 bit integers. + * + * To accommodate other types of computer arithmetic, all + * constants are also provided in a normal decimal radix + * which one can hope are correctly converted to a suitable + * format by the available C language compiler. To invoke + * this mode, the symbol UNK is defined. + * + * An important difference among these modes is a predefined + * set of machine arithmetic constants for each. The numbers + * MACHEP (the machine roundoff error), MAXNUM (largest number + * represented), and several other parameters are preset by + * the configuration symbol. Check the file const.c to + * ensure that these values are correct for your computer. + * + * For ANSI C compatibility, define ANSIC equal to 1. Currently + * this affects only the atan2() function and others that use it. + */ + +/* Constant definitions for math error conditions + */ + +#define DOMAIN 1 /* argument domain error */ +#define SING 2 /* argument singularity */ +#define OVERFLOW 3 /* overflow range error */ +#define UNDERFLOW 4 /* underflow range error */ +#define TLOSS 5 /* total loss of precision */ +#define PLOSS 6 /* partial loss of precision */ + +#define EDOM 33 +#define ERANGE 34 + +typedef struct + { + double r; + double i; + }cmplx; + +/* Type of computer arithmetic */ + +#ifndef DEC +#ifdef __IEEE_LITTLE_ENDIAN +#define IBMPC 1 +#else /* !__IEEE_LITTLE_ENDIAN */ +#define MIEEE 1 +#endif /* !__IEEE_LITTLE_ENDIAN */ +#endif /* !DEC */ + +/* Define 1 for ANSI C atan2() function + * See atan.c and clog.c. + */ +#define ANSIC 1 + +/*define VOLATILE volatile*/ +#define VOLATILE + +#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)) + + +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 SIMD_LDBL_MANT_DIG == 24 +static void toe24(short unsigned int *x, short unsigned int *y); +#elif SIMD_LDBL_MANT_DIG == 53 +static void toe53(short unsigned int *x, short unsigned int *y); +#elif SIMD_LDBL_MANT_DIG == 64 +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(short unsigned int *x); +static int eisinf(short unsigned int *x); +static void emovi(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(short unsigned int *a, short unsigned int *b, short unsigned int *c, int subflg, LDPARMS *ldp); +static int eisnan(short unsigned int *x); +static int eiisnan(short unsigned int *x); + +#ifdef DEC +static void etodec(), todec(), dectoe(); +#endif + +/* +; Clear out entire external format number. +; +; unsigned short x[]; +; eclear( x ); +*/ + +static void eclear(register short unsigned int *x) +{ +register int i; + +for( i=0; irndprc < NBITS ) + { + 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; + } + } +#endif +} + +/* Move in external format number, + * converting it to internal format. + */ +static void emovi(short unsigned int *a, short unsigned int *b) +{ +register unsigned short *p, *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 b +; 0 if a == b +; -1 if a < 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 *(--b) ) + return(1); +else + return(-1); +} + + +/* +; Shift significand down by 1 bit +*/ + +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>= 1; + if( bits & 2 ) + *x |= 0x8000; + bits <<= 1; + ++x; + } +} + + + +/* +; Shift significand up by 1 bit +*/ + +static 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 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 void eshup6(register short unsigned int *x) +{ +int i; +register unsigned short *p; + +p = x + M; +x += M + 1; + +for( i=M; i> 16) + (m >> 16) + *pp; + *pp = (unsigned short )carry; + *(pp-1) = carry >> 16; + } + } +for( i=M; iequot; + +p = &equot[0]; +*p++ = num[0]; +*p++ = num[1]; + +for( i=M; i tdenm ) + tquot = 0xffff; +*/ + /* Multiply denominator by trial quotient digit. */ + m16m( tquot, den, tprod ); + /* The quotient digit may have been overestimated. */ + if( ecmpm( tprod, num ) > 0 ) + { + tquot -= 1; + esubm( den, tprod ); + if( ecmpm( tprod, num ) > 0 ) + { + tquot -= 1; + esubm( den, tprod ); + } + } +/* + if( ecmpm( tprod, num ) > 0 ) + { + eshow( "tprod", tprod ); + eshow( "num ", num ); + printf( "tnum = %08lx, tden = %04x, tquot = %04x\n", + tnum, den[M+1], tquot ); + } +*/ + esubm( tprod, num ); +/* + if( ecmpm( num, den ) >= 0 ) + { + eshow( "num ", num ); + eshow( "den ", den ); + printf( "tnum = %08lx, tden = %04x, tquot = %04x\n", + tnum, den[M+1], tquot ); + } +*/ + equot[i] = tquot; + eshup6(num); + } +/* test for nonzero remainder after roundoff bit */ +p = &num[M]; +j = 0; +for( i=M; iequot; + +equot[0] = b[0]; +equot[1] = b[1]; +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; +/* Set up rounding parameters if the control register changed. */ +if( ldp->rndprc != ldp->rlast ) + { + 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; +/* 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; + } + +/* 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) && (ldp->rndprc != NBITS) ) +#else +if( (exp <= 0) && (ldp->rndprc != 64) && (ldp->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[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) ) +#else +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 ) + { +#ifndef INFINITY +overf: +#endif +#ifdef INFINITY + s[1] = 32767; + for( i=2; irndprc < 64) || (ldp->rndprc == 113) ) + { + s[ldp->rw] &= ~ldp->rmsk; + if( ldp->rndprc == 24 ) + { + s[5] = 0; + s[6] = 0; + } + } +#endif + return; + } +if( exp < 0 ) + s[1] = 0; +else + s[1] = (unsigned short )exp; +} + + + +/* +; Subtract external format numbers. +; +; unsigned short a[NE], b[NE], c[NE]; +; LDPARMS *ldp; +; esub( a, b, c, ldp ); c = b - a +*/ + +static void esub(short unsigned int *a, 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; + } +/* 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 ); +} + + + +static void eadd1(short unsigned int *a, 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; + +#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( 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 + { +/* 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, ldp ); + +done: +emovo( bi, c, ldp ); +} + + + +/* +; Divide. +; +; unsigned short a[NE], b[NE], c[NE]; +; LDPARMS *ldp; +; ediv( a, b, c, ldp ); c = b / a +*/ +static void ediv(short unsigned int *a, short unsigned int *b, short unsigned int *c, LDPARMS *ldp) +{ +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; + } +/* 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; + } +#endif +/* Infinity over anything else is infinity. */ +#ifdef 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 64 +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); +#ifdef IBMPC +e += 7; +#endif +r = *e; +yy[0] = 0; +if( r & 0x8000 ) + yy[0] = 0xffff; +r &= 0x7fff; +#ifdef INFINITY +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 ) + { + 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) +{ +register unsigned short *p, *q; +unsigned short i; + +#ifdef NANS +if( eiisnan(a) ) + { + enan( b, 113 ); + return; + } +#endif +p = a; +#ifdef MIEEE +q = b; +#else +q = b + 7; /* point to output exponent */ +#endif + +/* If not denormal, delete the implied bit. */ +if( a[E] != 0 ) + { + eshup1 (a); + } +/* combine sign and exponent */ +i = *p++; +#ifdef MIEEE +if( i ) + *q++ = *p++ | 0x8000; +else + *q++ = *p++; +#else +if( i ) + *q-- = *p++ | 0x8000; +else + *q-- = *p++; +#endif +/* skip over guard word */ +++p; +/* move the significand */ +#ifdef MIEEE +for (i = 0; i < 7; i++) + *q++ = *p++; +#else +for (i = 0; i < 7; i++) + *q-- = *p++; +#endif +} +#endif /* SIMD_LDBL_MANT_DIG > 64 */ + + +#if SIMD_LDBL_MANT_DIG == 64 +static void e64toe(short unsigned int *pe, short unsigned int *y, LDPARMS *ldp) +{ +unsigned short yy[NI]; +unsigned short *p, *q, *e; +int i; + +e = pe; +p = yy; + +for( i=0; i>= 4; +/* If zero exponent, then the significand is denormalized. + * So, take back the understood high significand bit. */ +if( r == 0 ) + { + denorm = 1; + yy[M] &= ~0x10; + } +r += EXONE - 01777; +yy[E] = r; +p = &yy[M+1]; +#ifdef IBMPC +*p++ = *(--e); +*p++ = *(--e); +*p++ = *(--e); +#else /* !IBMPC */ +++e; +*p++ = *e++; +*p++ = *e++; +*p++ = *e++; +#endif /* !IBMPC */ +(void )eshift( yy, -5 ); +if( denorm ) + { /* if zero exponent, then normalize the significand */ + if( (k = enormlz(yy)) > NBITS ) + ecleazs(yy); + else + yy[E] -= (unsigned short )(k-1); + } +emovo( yy, y, ldp ); +#endif /* !DEC */ +} + +/* +; e type to IEEE double precision +; double d; +; unsigned short x[NE]; +; etoe53( x, &d ); +*/ + +#ifdef DEC + +static void etoe53( x, e ) +unsigned short *x, *e; +{ +etodec( x, e ); /* see etodec.c */ +} + +static void toe53( x, y ) +unsigned short *x, *y; +{ +todec( x, y ); +} + +#else + +static void toe53(short unsigned int *x, short unsigned int *y) +{ +unsigned short i; +unsigned short *p; + + +#ifdef NANS +if( eiisnan(x) ) + { + enan( y, 53 ); + return; + } +#endif +p = &x[0]; +#ifdef IBMPC +y += 3; +#endif +#ifdef DEC +y += 3; +#endif +*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. */ +#ifdef INFINITY + *y |= 0x7ff0; +#ifdef IBMPC + *(--y) = 0; + *(--y) = 0; + *(--y) = 0; +#else /* !IBMPC */ + ++y; + *y++ = 0; + *y++ = 0; + *y++ = 0; +#endif /* IBMPC */ +#else /* !INFINITY */ + *y |= (unsigned short )0x7fef; +#ifdef IBMPC + *(--y) = 0xffff; + *(--y) = 0xffff; + *(--y) = 0xffff; +#else /* !IBMPC */ + ++y; + *y++ = 0xffff; + *y++ = 0xffff; + *y++ = 0xffff; +#endif +#endif /* !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 */ +#ifdef IBMPC +*(--y) = *p++; +*(--y) = *p++; +*(--y) = *p; +#else /* !IBMPC */ +++y; +*y++ = *p++; +*y++ = *p++; +*y++ = *p++; +#endif /* !IBMPC */ +} + +#endif /* not DEC */ +#endif /* SIMD_LDBL_MANT_DIG == 53 */ + +#if SIMD_LDBL_MANT_DIG == 24 +/* +; Convert IEEE single precision to e type +; float d; +; unsigned short x[N+2]; +; dtox( &d, x ); +*/ +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); +#ifdef IBMPC +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 */ +#ifdef INFINITY +if( r == 0x7f80 ) + { +#ifdef NANS +#ifdef MIEEE + if( ((pe[0] & 0x7f) != 0) || (pe[1] != 0) ) + { + enan( y, NBITS ); + return; + } +#else /* !MIEEE */ + if( ((pe[1] & 0x7f) != 0) || (pe[0] != 0) ) + { + enan( y, NBITS ); + return; + } +#endif /* !MIEEE */ +#endif /* NANS */ + eclear( y ); + einfin( y, ldp ); + if( yy[0] ) + eneg(y); + return; + } +#endif +r >>= 7; +/* If zero exponent, then the significand is denormalized. + * So, take back the understood high significand bit. */ +if( r == 0 ) + { + denorm = 1; + yy[M] &= ~0200; + } +r += EXONE - 0177; +yy[E] = r; +p = &yy[M+1]; +#ifdef IBMPC +*p++ = *(--e); +#endif +#ifdef DEC +*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 ); +} + +static void toe24(short unsigned int *x, short unsigned int *y) +{ +unsigned short i; +unsigned short *p; + +#ifdef NANS +if( eiisnan(x) ) + { + enan( y, 24 ); + return; + } +#endif +p = &x[0]; +#ifdef IBMPC +y += 1; +#endif +#ifdef DEC +y += 1; +#endif +*y = 0; /* output high order */ +if( *p++ ) + *y = 0x8000; /* output sign bit */ + +i = *p++; +if( i >= 255 ) + { /* Saturate at largest number less than infinity. */ +#ifdef INFINITY + *y |= (unsigned short )0x7f80; +#ifdef IBMPC + *(--y) = 0; +#endif +#ifdef DEC + *(--y) = 0; +#endif +#ifdef MIEEE + ++y; + *y = 0; +#endif +#else /* !INFINITY */ + *y |= (unsigned short )0x7f7f; +#ifdef IBMPC + *(--y) = 0xffff; +#endif +#ifdef DEC + *(--y) = 0xffff; +#endif +#ifdef MIEEE + ++y; + *y = 0xffff; +#endif +#endif /* !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 */ +#ifdef IBMPC +*(--y) = *p; +#endif +#ifdef DEC +*(--y) = *p; +#endif +#ifdef MIEEE +++y; +*y = *p; +#endif +} +#endif /* SIMD_LDBL_MANT_DIG == 24 */ + +/* Compare two e type numbers. + * + * unsigned short a[NE], b[NE]; + * 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. + */ +static int ecmp(short unsigned int *a, short unsigned int *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. +*/ +static 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. +*/ +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; +/* 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 ); +} + + + + +/* Convert e type number to decimal format ASCII string. + * The constants are for 64 bit precision. + */ + +#define NTEN 12 +#define MAXP 4096 + +#if NE == 10 +static 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 */ +}; + +static 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 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 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 + + + +/* ASCII string outputs for unix */ + + +#if 0 +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; + +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 * +_simdldtoa_r (struct _reent *ptr, LONG_DOUBLE_UNION *d, int mode, int ndigits, int *decpt, + int *sign, char **rve) +{ +unsigned short e[NI]; +char *s, *p; +int k; +LDPARMS rnd; +LDPARMS *ldp = &rnd; +char *outstr; + +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 SIMD_LDBL_MANT_DIG == 24 +e24toe( (unsigned short *)d, e, ldp ); +#elif SIMD_LDBL_MANT_DIG == 53 +e53toe( (unsigned short *)d, e, ldp ); +#elif SIMD_LDBL_MANT_DIG == 64 +e64toe( (unsigned short *)d, e, ldp ); +#else +e113toe( (unsigned short *)d, e, ldp ); +#endif + +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; + +/* reentrancy addition to use mprec storage pool */ +_REENT_MP_RESULT(ptr) = Balloc (ptr, 3); +_REENT_MP_RESULT_K(ptr) = 3; +outstr = (char *)_REENT_MP_RESULT(ptr); + +etoasc( e, outstr, ndigits, mode, ldp ); +s = outstr; +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 = 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 > 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 > ldp->outexpon ) + k = ndigits; +else + k = ldp->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 + ldp->outexpon) < 0)) + { + s = outstr; + *s = '\0'; + *decpt = 0; + } + +if( rve ) + *rve = s; +return outstr; +} + +/* Routine used to tell if long double is NaN or Infinity or regular number. + Returns: 0 = regular number + 1 = Nan + 2 = Infinity +*/ +int +_simdldcheck (LONG_DOUBLE_UNION *d) +{ +unsigned short e[NI]; +LDPARMS rnd; +LDPARMS *ldp = &rnd; + +rnd.rlast = -1; +rnd.rndprc = NBITS; + +#if SIMD_LDBL_MANT_DIG == 24 +e24toe( (unsigned short *)d, e, ldp ); +#elif SIMD_LDBL_MANT_DIG == 53 +e53toe( (unsigned short *)d, e, ldp ); +#elif SIMD_LDBL_MANT_DIG == 64 +e64toe( (unsigned short *)d, e, ldp ); +#else +e113toe( (unsigned short *)d, e, ldp ); +#endif + +if( (e[NE-1] & 0x7fff) == 0x7fff ) + { +#ifdef NANS + if( eisnan(e) ) + return( 1 ); +#endif + return( 2 ); + } +else + return( 0 ); +} /* _ldcheck */ + +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]; +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 ); +/* 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, 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 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++ = ' '; +/* 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, ldp ); + *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 ) + { + emovo( y, t, ldp ); + if( ecmp(t,ezero) != 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: +#ifdef __GO32__ +if( expon >= 0 ) + sprintf( ss, "e+%02d", expon ); +else + sprintf( ss, "e-%02d", -expon ); +#else + sprintf( ss, "E%d", expon ); +#endif +bxit: +ldp->rndprc = rndsav; +ldp->outexpon = expon; +} + + + + +/* +; ASCTOQ +; ASCTOQ.MAC LATEST REV: 11 JAN 84 +; SLM, 3 JAN 78 +; +; Convert ASCII string to quadruple precision floating point +; +; Numeric input is free field decimal number +; with max of 15 digits with or without +; decimal point entered as ASCII from teletype. +; Entering E after the number followed by a second +; number causes the second number to be interpreted +; as a power of 10 to be multiplied by the first number +; (i.e., "scientific" notation). +; +; Usage: +; asctoq( string, q ); +*/ + +void _simdstrtold (char *s, char **se, LONG_DOUBLE_UNION *x) +{ + LDPARMS rnd; + LDPARMS *ldp = &rnd; + int lenldstr; + + rnd.rlast = -1; + rnd.rndprc = NBITS; + + lenldstr = asctoeg( s, (unsigned short *)x, SIMD_LDBL_MANT_DIG, ldp ); + if (se) + *se = s + lenldstr; +} + +#define REASONABLE_LEN 200 + +static int +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, *p; +char *sp, *s, *lstr; +int lenldstr; +int mflag = 0; +char tmpstr[REASONABLE_LEN]; + +/* Copy the input string. */ +c = strlen (ss) + 2; +if (c <= REASONABLE_LEN) + lstr = tmpstr; +else + { + lstr = (char *) calloc (c, 1); + mflag = 1; + } +s = ss; +lenldstr = 0; +while( *s == ' ' ) /* skip leading spaces */ + { + ++s; + ++lenldstr; + } +sp = lstr; +for( k=0; krndprc; +ldp->rndprc = NBITS; /* Set to full precision */ +lost = 0; +nsign = 0; +decflg = 0; +sgnflg = 0; +nexp = 0; +exp = 0; +prec = 0; +ecleaz( yy ); +trail = 0; + +nxtcom: +k = *s - '0'; +if( (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; +/* 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; + } +/* 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: +#ifdef NANS + enan( yy, NI*16 ); +#else + mtherr( "asctoe", DOMAIN ); + ecleaz(yy); +#endif + goto aexit; + } +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 *= 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; +/* 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 ); +/* 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, 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; +#ifdef DEC +else if( oprec == 56 ) + lexp -= EXONE - 0201; +#endif +ldp->rndprc = oprec; +emdnorm( yy, k, 0, lexp, 64, ldp ); + +aexit: + +ldp->rndprc = rndsav; +yy[0] = nsign; +switch( oprec ) + { +#ifdef DEC + case 56: + todec( yy, y ); /* see etodec.c */ + break; +#endif +#if SIMD_LDBL_MANT_DIG == 53 + case 53: + toe53( yy, y ); + break; +#elif SIMD_LDBL_MANT_DIG == 24 + case 24: + toe24( yy, y ); + break; +#elif SIMD_LDBL_MANT_DIG == 64 + case 64: + toe64( yy, y ); + break; +#elif SIMD_LDBL_MANT_DIG == 113 + case 113: + toe113( yy, y ); + break; +#else + 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) + * + * unsigned short x[NE], y[NE] + * LDPARMS *ldp + * + * efloor( x, y, ldp ); + */ +static unsigned short bmask[] = { +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) +{ +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; + +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; iequot; + +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 +static unsigned short nan113[8] = { + 0x7fff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}; +static unsigned short nan64[6] = {0x7fff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}; +static unsigned short nan53[4] = {0x7fff, 0xffff, 0xffff, 0xffff}; +static unsigned short nan24[2] = {0x7fff, 0xffff}; +#else /* !MIEEE */ +static unsigned short nan113[8] = {0, 0, 0, 0, 0, 0, 0x8000, 0x7fff}; +static unsigned short nan64[6] = {0, 0, 0, 0, 0xc000, 0x7fff}; +static unsigned short nan53[4] = {0, 0, 0, 0x7ff8}; +static unsigned short nan24[2] = {0, 0x7fc0}; +#endif /* !MIEEE */ + + +static void enan (short unsigned int *nan, int size) +{ +int i, n; +unsigned short *p; + +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: + for( i=0; i>, <>, <>---string to signed fixed point + +INDEX + strtosfix16 +INDEX + strtosfix32 +INDEX + strtosfix64 +INDEX + _strtosfix16_r +INDEX + _strtosfix32_r +INDEX + _strtosfix64_r + +ANSI_SYNOPSIS + #include + __int16 strtosfix16 (const char *<[s]>, char **<[ptr]>); + + __int32 strtosfix32 (const char *<[s]>, char **<[ptr]>); + + __int64 strtosfix64 (const char *<[s]>, char **<[ptr]>); + + __int16 _strtosfix16_r (void *<[reent]>, + const char *<[s]>, char **<[ptr]>); + + __int32 _strtosfix32_r (void *<[reent]>, + const char *<[s]>, char **<[ptr]>); + + __int64 _strtosfix64_r (void *<[reent]>, + const char *<[s]>, char **<[ptr]>); + +TRAD_SYNOPSIS + #include + __int16 strtosfix16 (<[s]>, <[ptr]>) + char *<[s]>; + char **<[ptr]>; + + __int32 strtosfix32 (<[s]>, <[ptr]>) + char *<[s]>; + char **<[ptr]>; + + __int64 strtosfix64 (<[s]>, <[ptr]>) + char *<[s]>; + char **<[ptr]>; + + __int16 _strtosfix16_r (<[reent]>, <[s]>, <[ptr]>) + char *<[reent]>; + char *<[s]>; + char **<[ptr]>; + + __int32 _strtosfix32_r (<[reent]>, <[s]>, <[ptr]>) + char *<[reent]>; + char *<[s]>; + char **<[ptr]>; + + __int64 _strtosfix64_r (<[reent]>, <[s]>, <[ptr]>) + char *<[reent]>; + char *<[s]>; + char **<[ptr]>; + +DESCRIPTION + The function <> converts the string <<*<[s]>>> to + a fixed-point sign + 15-bits fraction representation. The function + follows the same rules as <>. + + The substring converted is the longest initial + subsequence of <[s]>, beginning with the first + non-whitespace character, that has the format: + .[+|-]<[digits]>[.][<[digits]>][(e|E)[+|-]<[digits]>] + The substring contains no characters if <[s]> is empty, consists + entirely of whitespace, or if the first non-whitespace + character is something other than <<+>>, <<->>, <<.>>, or a + digit. If the substring is empty, no conversion is done, and + the value of <[s]> is stored in <<*<[ptr]>>>. Otherwise, + the substring is converted, and a pointer to the final string + (which will contain at least the terminating null character of + <[s]>) is stored in <<*<[ptr]>>>. If you want no + assignment to <<*<[ptr]>>>, pass a null pointer as <[ptr]>. + + <> is identical to <> except that it + converts to fixed-point sign + 31-bits fraction representation. + <> is also similar, except that it converts + to fixed-point sign + 63-bit fraction format. + + The alternate functions <<_strtosfix16_r>>, <<_strtosfix32_r>>, + and <<_strtosfix64_r>> are reentrant versions. + The extra argument <[reent]> is a pointer to a reentrancy structure. + +RETURNS + The functions return the converted substring value, if any. If + no conversion can be performed, then 0 is returned. If the converted + value is a NaN, 0 is returned and errno is set to <>. + If the converted value exceeds the maximum positive fixed-point value, + the output value is saturated to the maximum value and <> is stored in + errno. If the converted value is less than the minimum fixed-point negative + value, then the output is saturated to the minimum value and <> is stored + in errno. Otherwise, the converted value is returned in the + specified fixed-point format. + +PORTABILITY + <>, <>, and <> are non-standard. + + The OS subroutines of <> are required. +*/ + +#include <_ansi.h> +#include +#include +#include +#include +#include "vfieeefp.h" + +/* + * Convert a string to a fixed-point (sign + 15-bits) value. + * + * Ignores `locale' stuff. + */ +__int16_t +_DEFUN (_strtosfix16_r, (rptr, nptr, endptr), + struct _reent *rptr _AND + _CONST char *nptr _AND + char **endptr) +{ + union double_union dbl; + unsigned long tmp, tmp2; + int exp, negexp, sign; + __int16_t result; + + dbl.d = _strtod_r (rptr, nptr, endptr); + + /* treat NAN as domain error, +/- infinity as saturation */ + if (!finite(dbl.d)) + { + if (isnan (dbl.d)) + { + rptr->_errno = EDOM; + return 0; + } + rptr->_errno = ERANGE; + if (word0(dbl) & Sign_bit) + return SHRT_MIN; + return SHRT_MAX; + } + + /* check for normal saturation */ + if (dbl.d >= 1.0) + { + rptr->_errno = ERANGE; + return SHRT_MAX; + } + else if (dbl.d < -1.0) + { + rptr->_errno = ERANGE; + return SHRT_MIN; + } + + /* otherwise we have normal number in range */ + + /* strip off sign and exponent */ + sign = word0(dbl) & Sign_bit; + exp = ((word0(dbl) & Exp_mask) >> Exp_shift) - Bias; + negexp = -exp; + if (negexp > 15) + return 0; + /* add in implicit normalized bit */ + tmp = word0(dbl) | Exp_msk1; + /* remove exponent and sign */ + tmp <<= Ebits; + if (negexp != 0) + { + /* perform rounding */ + tmp2 = tmp + (1 << (negexp - 1)); + result = (short)(tmp2 >> (negexp + 16)); + /* check if rounding caused carry bit which must be added into result */ + if (tmp2 < tmp) + result |= (1 << (16 - negexp)); + /* check if positive saturation has occurred because of rounding */ + if (!sign && result < 0) + { + rptr->_errno = ERANGE; + return SHRT_MAX; + } + } + else + { + /* we have -1.0, no rounding necessary */ + return SHRT_MIN; + } + + return sign ? -result : result; +} + +#ifndef _REENT_ONLY + +__int16_t +_DEFUN (strtosfix16, (s, ptr, base), + _CONST char *s _AND + char **ptr) +{ + return _strtosfix16_r (_REENT, s, ptr); +} + +#endif diff --git a/newlib/libc/machine/powerpc/strtosfix32.c b/newlib/libc/machine/powerpc/strtosfix32.c new file mode 100644 index 0000000000..0f2ded6f7f --- /dev/null +++ b/newlib/libc/machine/powerpc/strtosfix32.c @@ -0,0 +1,100 @@ +#include <_ansi.h> +#include +#include +#include +#include +#include "vfieeefp.h" + +/* + * Convert a string to a fixed-point (sign + 31-bits) value. + * + * Ignores `locale' stuff. + */ +__int32_t +_DEFUN (_strtosfix32_r, (rptr, nptr, endptr), + struct _reent *rptr _AND + _CONST char *nptr _AND + char **endptr) +{ + union double_union dbl; + int exp, negexp, sign; + unsigned long tmp, tmp2; + long result = 0; + + dbl.d = _strtod_r (rptr, nptr, endptr); + + /* treat NAN as domain error, +/- infinity as saturation */ + if (!finite(dbl.d)) + { + if (isnan (dbl.d)) + { + rptr->_errno = EDOM; + return 0; + } + rptr->_errno = ERANGE; + if (word0(dbl) & Sign_bit) + return LONG_MIN; + return LONG_MAX; + } + + /* check for normal saturation */ + if (dbl.d >= 1.0) + { + rptr->_errno = ERANGE; + return LONG_MAX; + } + else if (dbl.d < -1.0) + { + rptr->_errno = ERANGE; + return LONG_MIN; + } + + /* otherwise we have normal number in range */ + + /* strip off sign and exponent */ + sign = word0(dbl) & Sign_bit; + exp = ((word0(dbl) & Exp_mask) >> Exp_shift) - Bias; + negexp = -exp; + if (negexp > 31) + return 0; + word0(dbl) &= ~(Exp_mask | Sign_bit); + /* add in implicit normalized bit */ + word0(dbl) |= Exp_msk1; + /* shift so result is contained in single word */ + tmp = word0(dbl) << Ebits; + tmp |= ((unsigned long)word1(dbl) >> (32 - Ebits)); + if (negexp != 0) + { + /* perform rounding */ + tmp2 = tmp + (1 << (negexp - 1)); + result = (long)(tmp2 >> negexp); + /* check if rounding caused carry bit which must be added into result */ + if (tmp2 < tmp) + result |= (1 << (32 - negexp)); + /* check if positive saturation has occurred because of rounding */ + if (!sign && result < 0) + { + rptr->_errno = ERANGE; + return LONG_MAX; + } + } + else + { + /* we have -1.0, no rounding necessary */ + return LONG_MIN; + } + + return sign ? -result : result; +} + +#ifndef _REENT_ONLY + +__int32_t +_DEFUN (strtosfix32, (s, ptr, base), + _CONST char *s _AND + char **ptr) +{ + return _strtosfix32_r (_REENT, s, ptr); +} + +#endif diff --git a/newlib/libc/machine/powerpc/strtosfix64.c b/newlib/libc/machine/powerpc/strtosfix64.c new file mode 100644 index 0000000000..d0fa769d94 --- /dev/null +++ b/newlib/libc/machine/powerpc/strtosfix64.c @@ -0,0 +1,113 @@ +#include <_ansi.h> +#include +#include +#include +#include +#include "fix64.h" + +/* + * Convert a string to a fixed-point (sign + 63-bits) value. + * + * Ignores `locale' stuff. + */ +__int64_t +_DEFUN (_strtosfix64_r, (rptr, nptr, endptr), + struct _reent *rptr _AND + _CONST char *nptr _AND + char **endptr) +{ + union long_double_union ldbl; + int exp, negexp, sign, ld_type; + __uint64_t tmp, tmp2; + __int64_t result = 0; + + init(ldbl); + + _simdstrtold ((char *)nptr, endptr, &ldbl); + + /* treat NAN as domain error, +/- infinity as saturation */ + ld_type = _simdldcheck (&ldbl.ld); + if (ld_type != 0) + { + if (ld_type == 1) + { + rptr->_errno = EDOM; + return 0; + } + rptr->_errno = ERANGE; + if (word0(ldbl) & Sign_bit) + return LONG_LONG_MIN; + return LONG_LONG_MAX; + } + + /* strip off sign and exponent */ + sign = word0(ldbl) & Sign_bit; + exp = ((word0(ldbl) & Exp_mask) >> Exp_shift) - Bias; + negexp = -exp; + if (negexp > 63) + return 0; + word0(ldbl) &= ~(Exp_mask | Sign_bit); + /* add in implicit normalized bit */ + word0(ldbl) |= Exp_msk1; + /* shift so result is contained in single word */ + tmp = word0(ldbl) << Ebits; + tmp |= ((unsigned long)word1(ldbl) >> (32 - Ebits)); + tmp <<= 32; + if (Ebits < 32) + tmp |= ((unsigned long)word1(ldbl) << Ebits); + tmp |= ((unsigned long)word2(ldbl) >> (32 - Ebits)); + + /* check for saturation */ + if (sign) + { + if (exp > 0 || (exp == 0 && tmp != 0x8000000000000000LL)) + { + rptr->_errno = ERANGE; + return LONG_LONG_MIN; + } + } + else + { + if (exp >= 0) + { + rptr->_errno = ERANGE; + return LONG_LONG_MAX; + } + } + + /* otherwise we have normal number in range */ + if (negexp != 0) + { + /* perform rounding */ + tmp2 = tmp + (1 << (negexp - 1)); + result = (long long)(tmp2 >> negexp); + /* check if rounding caused carry bit which must be added into result */ + if (tmp2 < tmp) + result |= (1 << (64 - negexp)); + /* check if positive saturation has occurred because of rounding */ + if (!sign && result < 0) + { + rptr->_errno = ERANGE; + return LONG_LONG_MAX; + } + } + else + { + /* we have -1.0, no rounding necessary */ + return LONG_LONG_MIN; + } + + return sign ? -result : result; +} + +#ifndef _REENT_ONLY + +__int64_t +_DEFUN (strtosfix64, (s, ptr, base), + _CONST char *s _AND + char **ptr) +{ + return _strtosfix64_r (_REENT, s, ptr); +} + +#endif diff --git a/newlib/libc/machine/powerpc/strtoufix16.c b/newlib/libc/machine/powerpc/strtoufix16.c new file mode 100644 index 0000000000..0c1fad30f7 --- /dev/null +++ b/newlib/libc/machine/powerpc/strtoufix16.c @@ -0,0 +1,197 @@ +/* +FUNCTION + <>, <>, <>---string to signed fixed point + +INDEX + strtoufix16 +INDEX + strtoufix32 +INDEX + strtoufix64 +INDEX + _strtoufix16_r +INDEX + _strtoufix32_r +INDEX + _strtoufix64_r + +ANSI_SYNOPSIS + #include + __uint16_t strtoufix16 (const char *<[s]>, char **<[ptr]>); + + __uint32_t strtoufix32 (const char *<[s]>, char **<[ptr]>); + + __uint64_t strtoufix64 (const char *<[s]>, char **<[ptr]>); + + __uint16_t _strtoufix16_r (void *<[reent]>, + const char *<[s]>, char **<[ptr]>); + + __uint32_t _strtoufix32_r (void *<[reent]>, + const char *<[s]>, char **<[ptr]>); + + __uint64_t _strtoufix64_r (void *<[reent]>, + const char *<[s]>, char **<[ptr]>); + +TRAD_SYNOPSIS + #include + __uint16_t strtoufix16 (<[s]>, <[ptr]>) + char *<[s]>; + char **<[ptr]>; + + __uint32_t strtoufix32 (<[s]>, <[ptr]>) + char *<[s]>; + char **<[ptr]>; + + __uint64_t strtoufix64 (<[s]>, <[ptr]>) + char *<[s]>; + char **<[ptr]>; + + __uint16_t _strtoufix16_r (<[reent]>, <[s]>, <[ptr]>) + char *<[reent]>; + char *<[s]>; + char **<[ptr]>; + + __uint32_t _strtoufix32_r (<[reent]>, <[s]>, <[ptr]>) + char *<[reent]>; + char *<[s]>; + char **<[ptr]>; + + __uint64_t _strtoufix64_r (<[reent]>, <[s]>, <[ptr]>) + char *<[reent]>; + char *<[s]>; + char **<[ptr]>; + +DESCRIPTION + The function <> converts the string <<*<[s]>>> to + a fixed-point 16-bits fraction representation. The function + follows the same rules as <>. + + The substring converted is the longest initial + subsequence of <[s]>, beginning with the first + non-whitespace character, that has the format: + .[+|-]<[digits]>[.][<[digits]>][(e|E)[+|-]<[digits]>] + The substring contains no characters if <[s]> is empty, consists + entirely of whitespace, or if the first non-whitespace + character is something other than <<+>>, <<->>, <<.>>, or a + digit. If the substring is empty, no conversion is done, and + the value of <[s]> is stored in <<*<[ptr]>>>. Otherwise, + the substring is converted, and a pointer to the final string + (which will contain at least the terminating null character of + <[s]>) is stored in <<*<[ptr]>>>. If you want no + assignment to <<*<[ptr]>>>, pass a null pointer as <[ptr]>. + + <> is identical to <> except that it + converts to fixed-point 32-bit fraction representation. + <> is also similar, except that it converts + to fixed-point 64-bit fraction. + + The alternate functions <<_strtoufix16_r>>, <<_strtoufix32_r>>, + and <<_strtoufix64_r>> are reentrant versions. + The extra argument <[reent]> is a pointer to a reentrancy structure. + +RETURNS + The functions return the converted substring value, if any. If + no conversion can be performed, then 0 is returned. If the converted + value is a NaN, 0 is returned and errno is set to <>. + If the converted value exceeds the maximum positive unsigned fixed-point value, + the output value is saturated to the maximum value and <> is stored in + errno. If the converted value is less than 0, then the output is saturated to 0 + and <> is stored in errno. Otherwise, the converted value is returned in the + specified fixed-point format. + +PORTABILITY + <>, <>, and <> are non-standard. + + The OS subroutines of <> are required. +*/ + +#include <_ansi.h> +#include +#include +#include +#include +#include "vfieeefp.h" + +/* + * Convert a string to a fixed-point 16-bit value. + * + * Ignores `locale' stuff. + */ +__uint16_t +_DEFUN (_strtoufix16_r, (rptr, nptr, endptr), + struct _reent *rptr _AND + _CONST char *nptr _AND + char **endptr) +{ + union double_union dbl; + unsigned long tmp, tmp2, result; + int exp, negexp; + + dbl.d = _strtod_r (rptr, nptr, endptr); + + /* treat NAN as domain error, +/- infinity as saturation */ + if (!finite(dbl.d)) + { + if (isnan (dbl.d)) + { + rptr->_errno = EDOM; + return 0; + } + rptr->_errno = ERANGE; + if (word0(dbl) & Sign_bit) + return 0; + return USHRT_MAX; + } + + /* check for normal saturation */ + if (dbl.d >= 1.0) + { + rptr->_errno = ERANGE; + return USHRT_MAX; + } + else if (dbl.d < 0) + { + rptr->_errno = ERANGE; + return 0; + } + + /* otherwise we have normal postive number in range */ + + /* strip off exponent */ + exp = ((word0(dbl) & Exp_mask) >> Exp_shift) - Bias; + negexp = -exp; + if (negexp > 16) + return 0; + /* add in implicit normalized bit */ + tmp = word0(dbl) | Exp_msk1; + /* remove exponent and sign */ + tmp <<= Ebits; + /* perform rounding */ + tmp2 = tmp + (1 << (negexp + 14)); + result = tmp2 >> (negexp + 15); + /* if rounding causes carry, must add carry bit in */ + if (tmp2 < tmp) + { + if (negexp == 0) + { + /* we have overflow which means saturation */ + rptr->_errno = ERANGE; + return USHRT_MAX; + } + result |= (1 << (16 - negexp)); + } + + return (__uint16_t)result; +} + +#ifndef _REENT_ONLY + +__uint16_t +_DEFUN (strtoufix16, (s, ptr, base), + _CONST char *s _AND + char **ptr) +{ + return _strtoufix16_r (_REENT, s, ptr); +} + +#endif diff --git a/newlib/libc/machine/powerpc/strtoufix32.c b/newlib/libc/machine/powerpc/strtoufix32.c new file mode 100644 index 0000000000..141c6278f7 --- /dev/null +++ b/newlib/libc/machine/powerpc/strtoufix32.c @@ -0,0 +1,97 @@ +#include <_ansi.h> +#include +#include +#include +#include +#include "vfieeefp.h" + +/* + * Convert a string to a fixed-point 32-bit value. + * + * Ignores `locale' stuff. + */ +__uint32_t +_DEFUN (_strtoufix32_r, (rptr, nptr, endptr), + struct _reent *rptr _AND + _CONST char *nptr _AND + char **endptr) +{ + union double_union dbl; + int exp, negexp, sign; + __uint32_t tmp, tmp2, result = 0; + + dbl.d = _strtod_r (rptr, nptr, endptr); + + /* treat NAN as domain error, +/- infinity as saturation */ + if (!finite(dbl.d)) + { + if (isnan (dbl.d)) + { + rptr->_errno = EDOM; + return 0; + } + rptr->_errno = ERANGE; + if (word0(dbl) & Sign_bit) + return 0; + return ULONG_MAX; + } + + /* check for normal saturation */ + if (dbl.d >= 1.0) + { + rptr->_errno = ERANGE; + return ULONG_MAX; + } + else if (dbl.d < 0) + { + rptr->_errno = ERANGE; + return 0; + } + + /* otherwise we have normal positive number in range */ + + /* strip off exponent */ + exp = ((word0(dbl) & Exp_mask) >> Exp_shift) - Bias; + negexp = -exp; + if (negexp > 32) + return 0; + word0(dbl) &= ~(Exp_mask | Sign_bit); + /* add in implicit normalized bit */ + word0(dbl) |= Exp_msk1; + /* shift so result is contained left-justified in word */ + tmp = word0(dbl) << Ebits; + tmp |= ((unsigned long)word1(dbl) >> (32 - Ebits)); + /* perform rounding */ + if (negexp > 1) + { + tmp2 = tmp + (1 << (negexp - 2)); + result = (tmp2 >> (negexp - 1)); + /* if rounding causes carry, add carry bit in */ + if (tmp2 < tmp) + result += 1 << (32 - negexp); + } + else + { + result = tmp + ((word1(dbl) & (1 << (32 - Ebits - 1))) != 0); + /* if rounding causes carry, then saturation has occurred */ + if (result < tmp) + { + rptr->_errno = ERANGE; + return ULONG_MAX; + } + } + + return result; +} + +#ifndef _REENT_ONLY + +__uint32_t +_DEFUN (strtoufix32, (s, ptr, base), + _CONST char *s _AND + char **ptr) +{ + return _strtoufix32_r (_REENT, s, ptr); +} + +#endif diff --git a/newlib/libc/machine/powerpc/strtoufix64.c b/newlib/libc/machine/powerpc/strtoufix64.c new file mode 100644 index 0000000000..e06f4db6c3 --- /dev/null +++ b/newlib/libc/machine/powerpc/strtoufix64.c @@ -0,0 +1,115 @@ +#include <_ansi.h> +#include +#include +#include +#include +#include "fix64.h" + +/* + * Convert a string to a fixed-point 64-bit unsigned value. + * + * Ignores `locale' stuff. + */ +__uint64_t +_DEFUN (_strtoufix64_r, (rptr, nptr, endptr), + struct _reent *rptr _AND + _CONST char *nptr _AND + char **endptr) +{ + union long_double_union ldbl; + int exp, sign, negexp, ld_type; + __uint64_t tmp, tmp2, result = 0; + + init(ldbl); + + _simdstrtold ((char *)nptr, endptr, &ldbl); + + /* treat NAN as domain error, +/- infinity as saturation */ + ld_type = _simdldcheck (&ldbl.ld); + if (ld_type != 0) + { + if (ld_type == 1) + { + rptr->_errno = EDOM; + return 0; + } + rptr->_errno = ERANGE; + if (word0(ldbl) & Sign_bit) + return 0; + return ULONG_LONG_MAX; + } + + /* strip off sign and exponent */ + sign = word0(ldbl) & Sign_bit; + exp = ((word0(ldbl) & Exp_mask) >> Exp_shift) - Bias; + negexp = -exp; + if (negexp > 63) + return 0; + word0(ldbl) &= ~(Exp_mask | Sign_bit); + /* add in implicit normalized bit */ + word0(ldbl) |= Exp_msk1; + /* shift so result is contained in single word */ + tmp = word0(ldbl) << Ebits; + tmp |= ((unsigned long)word1(ldbl) >> (32 - Ebits)); + tmp <<= 32; + if (Ebits < 32) + tmp |= ((unsigned long)word1(ldbl) << Ebits); + tmp |= ((unsigned long)word2(ldbl) >> (32 - Ebits)); + + /* check for saturation */ + if (sign) + { + rptr->_errno = ERANGE; + return 0; + } + else + { + if (exp > 0 || (exp == 0 && tmp >= 0x8000000000000000LL)) + { + rptr->_errno = ERANGE; + return ULONG_LONG_MAX; + } + } + + /* otherwise we have normal number in range */ + if (negexp > 1) + { + tmp2 = tmp + (1 << (negexp - 2)); + result = (tmp2 >> (negexp - 1)); + /* if rounding causes carry, add carry bit in */ + if (tmp2 < tmp) + result += 1 << (64 - negexp); + } + else + { + if (Ebits < 32) + { + result = tmp + ((word2(ldbl) & (1 << (64 - Ebits - 1))) != 0); + /* if rounding causes carry, then saturation has occurred */ + if (result < tmp) + { + rptr->_errno = ERANGE; + return ULONG_LONG_MAX; + } + } + else + result = tmp; + } + + return result; +} + +#ifndef _REENT_ONLY + +__uint64_t +_DEFUN (strtoufix64, (s, ptr, base), + _CONST char *s _AND + char **ptr) +{ + return _strtoufix64_r (_REENT, s, ptr); +} + +#endif + + + diff --git a/newlib/libc/machine/powerpc/ufix64toa.c b/newlib/libc/machine/powerpc/ufix64toa.c new file mode 100644 index 0000000000..4d3d0a8851 --- /dev/null +++ b/newlib/libc/machine/powerpc/ufix64toa.c @@ -0,0 +1,88 @@ +/* _ufix64toa_r: convert unsigned 64-bit fixed point to ASCII string. + * + * This routine converts an unsigned fixed-point number to long double format and + * then calls _ldtoa_r to do the conversion. + * + * Written by Jeff Johnston. + */ + +#include <_ansi.h> +#include +#include +#include +#include +#include "fix64.h" + +extern char *_simdldtoa_r _PARAMS((struct _reent *, LONG_DOUBLE_UNION *, int, + int, int *, int *, char **)); + +/* + * Convert an unsigned fixed-point 64-bit value to string. + * + * Ignores `locale' stuff. + */ + +char * +_DEFUN (_ufix64toa_r, (rptr, value, mode, ndigits, decpt, sign, rve), + struct _reent *rptr _AND + __uint64_t value _AND + int mode _AND + int ndigits _AND + int *decpt _AND + int *sign _AND + char **rve) +{ + union long_double_union ldbl; + union fix64_union fix64; + unsigned long tmp; + int exp, negexp; + + /* if input is 0, no additional work is needed */ + if (value == 0) + { + ldbl.i[0] = ldbl.i[1] = ldbl.i[2] = ldbl.i[3] = 0; + } + else /* otherwise, we calculate long double equivalent of value */ + { + /* find exponent by locating most-significant one-bit */ + fix64.ll = value; + negexp = 1; + if (hiword(fix64) == 0) + { + tmp = loword(fix64); + negexp = 33; + } + else + { + tmp = hiword(fix64); + negexp = 1; + } + + while (negexp < 65) + { + if (tmp & 0x80000000) + break; + ++negexp; + tmp <<= 1; + } + + /* shift input appropriately */ + fix64.ll = value << (negexp - 1 + (Exp_msk1 != 0)); + + /* build long double */ + exp = -negexp + Bias; + word0(ldbl) = (exp << Exp_shift); + word1(ldbl) = hiword(fix64) << (32-Ebits); + word2(ldbl) = loword(fix64) << (32-Ebits); + word3(ldbl) = 0; + if (Ebits < 32) + { + word0(ldbl) |= hiword(fix64) >> Ebits; + word1(ldbl) |= loword(fix64) >> Ebits; + } + } + + /* convert long double to character */ + return _simdldtoa_r (rptr, &ldbl, mode, ndigits, decpt, sign, rve); +} + diff --git a/newlib/libc/machine/powerpc/vfprintf.c b/newlib/libc/machine/powerpc/vfprintf.c index 0bb9d9f13c..ff3a4f66b5 100644 --- a/newlib/libc/machine/powerpc/vfprintf.c +++ b/newlib/libc/machine/powerpc/vfprintf.c @@ -166,6 +166,8 @@ static char *rcsid = "$Id$"; #include #include #include +#include +#include #ifdef __ALTIVEC__ #include #endif @@ -275,6 +277,10 @@ extern int _ldcheck _PARAMS((_LONG_DOUBLE *)); static int exponent _PARAMS((char *, int, int)); +#ifdef __SPE__ +static char *cvt_ufix64 _PARAMS((struct _reent *, unsigned long long, int, int *, int *)); +#endif /* __SPE__ */ + #else /* no FLOATING_POINT */ #define BUF 40 @@ -308,6 +314,7 @@ static int exponent _PARAMS((char *, int, int)); #define ZEROPAD 0x080 /* zero (as opposed to blank) pad */ #define FPT 0x100 /* Floating point number */ #define VECTOR 0x200 /* vector */ +#define FIXEDPOINT 0x400 /* fixed-point */ int _DEFUN (VFPRINTF, (fp, fmt0, ap), @@ -382,7 +389,7 @@ _DEFUN (_VFPRINTF_R, (data, fp, fmt0, ap), int vec_print_count; /* number of vector chunks remaining */ vec_16_byte_union vec_tmp; #endif /* __ALTIVEC__ */ - int state = 0; /* mbtowc calls from library must not change state */ + mbstate_t state; /* mbtowc calls from library must not change state */ /* * Choose PADSIZE to trade efficiency vs. size. If larger printf @@ -480,6 +487,16 @@ _DEFUN (_VFPRINTF_R, (data, fp, fmt0, ap), flags&LONGINT ? GET_ULONG(ap) : \ flags&SHORTINT ? (u_long)GET_USHORT(ap) : \ (u_long)GET_UINT(ap)) +#ifdef __SPE__ +#define SFPARG() \ + (flags&LONGINT ? va_arg(ap, quad_t) : \ + flags&SHORTINT ? (long)GET_SHORT(ap) : \ + (long)va_arg(ap, int)) +#define UFPARG() \ + (flags&LONGINT ? va_arg(ap, u_quad_t) : \ + flags&SHORTINT ? (u_long)GET_USHORT(ap) : \ + (u_long)va_arg(ap, u_int)) +#endif /* __SPE__ */ #else #define SARG() \ (flags&LONGINT ? GET_LONG(ap) : \ @@ -489,8 +506,20 @@ _DEFUN (_VFPRINTF_R, (data, fp, fmt0, ap), (flags&LONGINT ? GET_ULONG(ap) : \ flags&SHORTINT ? (u_long)GET_USHORT(ap) : \ (u_long)GET_UINT(ap)) +#ifdef __SPE__ +#define SFPARG() \ + (flags&LONGINT ? (va_arg(ap, long) << 32) : \ + flags&SHORTINT ? (long)GET_SHORT(ap) : \ + (long)va_arg(ap, int)) +#define UFPARG() \ + (flags&LONGINT ? (va_arg(ap, u_long) <<32) : \ + flags&SHORTINT ? (u_long)GET_USHORT(ap) : \ + (u_long)va_arg(ap, u_int)) +#endif /* __SPE__ */ #endif + memset (&state, '\0', sizeof (state)); + /* sorry, fprintf(read_only_file, "") returns EOF, not 0 */ if (cantwrite(fp)) return (EOF); @@ -863,6 +892,51 @@ reswitch: switch (ch) { } break; #endif /* FLOATING_POINT */ +#ifdef __SPE__ + case 'r': + flags |= FIXEDPOINT; + _uquad = SFPARG(); + if ((quad_t)_uquad < 0) + { + sign = '-'; + _uquad = -(quad_t)_uquad; + } + if (flags & SHORTINT) + _uquad <<= 49; + else if (flags & LONGINT) + _uquad <<= 1; + else + _uquad <<= 33; + + if (_uquad == 0 && sign) + { + /* we have -1.0 which has to be handled special */ + cp = "100000"; + expt = 1; + ndig = 6; + break; + } + + goto fixed_nosign; + case 'R': + flags |= FIXEDPOINT; + _uquad = UFPARG(); + if (flags & SHORTINT) + _uquad <<= 48; + else if (!(flags & LONGINT)) + _uquad <<= 32; + +fixed_nosign: + if (prec == -1) + prec = DEFPREC; + + cp = cvt_ufix64 (data, _uquad, prec, &expt, &ndig); + + /* act like %f of format "0.X" */ + size = prec + 2; + + break; +#endif /* __SPE__ */ case 'n': #ifdef __ALTIVEC__ if (flags & VECTOR) @@ -1107,6 +1181,35 @@ number: if ((dprec = prec) >= 0) /* the string or number proper */ #ifdef FLOATING_POINT if ((flags & FPT) == 0) { +#ifdef __SPE__ + if (flags & FIXEDPOINT) { + if (_uquad == 0 && !sign) { + /* kludge for __dtoa irregularity */ + PRINT("0", 1); + if (expt < ndig || (flags & ALT) != 0) { + PRINT(decimal_point, 1); + PAD(ndig - 1, zeroes); + } + } else if (expt <= 0) { + PRINT("0", 1); + if(expt || ndig) { + PRINT(decimal_point, 1); + PAD(-expt, zeroes); + PRINT(cp, ndig); + } + } else if (expt >= ndig) { + PRINT(cp, ndig); + PAD(expt - ndig, zeroes); + if (flags & ALT) + PRINT(".", 1); + } else { + PRINT(cp, expt); + cp += expt; + PRINT(".", 1); + PRINT(cp, ndig-expt); + } + } else +#endif /* __SPE__ */ PRINT(cp, size); } else { /* glue together f_p fragments */ if (ch >= 'f') { /* 'f' or 'g' */ @@ -1297,3 +1400,31 @@ exponent(p0, exp, fmtch) } #endif /* FLOATING_POINT */ +#ifdef __SPE__ +extern char *_ufix64toa_r _PARAMS((struct _reent *, unsigned long long, int, + int, int *, int *, char **)); +static char * +cvt_ufix64 (data, value, ndigits, decpt, length) + struct _reent *data; + unsigned long long value; + int ndigits, *decpt, *length; +{ + int dsgn; + char *digits, *bp, *rve; + + /* treat the same as %f format and use mode=3 */ + digits = _ufix64toa_r (data, value, 3, ndigits, decpt, &dsgn, &rve); + + /* print trailing zeroes */ + bp = digits + ndigits; + if (*digits == '0' && value) + *decpt = -ndigits + 1; + bp += *decpt; + if (value == 0) /* kludge for __dtoa irregularity */ + rve = bp; + while (rve < bp) + *rve++ = '0'; + *length = rve - digits; + return (digits); +} +#endif /* __SPE__ */ diff --git a/newlib/libc/machine/powerpc/vfscanf.c b/newlib/libc/machine/powerpc/vfscanf.c index 919147c3ab..9cfb658ca1 100644 --- a/newlib/libc/machine/powerpc/vfscanf.c +++ b/newlib/libc/machine/powerpc/vfscanf.c @@ -107,6 +107,8 @@ Supporting OS subroutines required: #include #include #include +#include +#include #ifdef _HAVE_STDC #include #else @@ -130,6 +132,11 @@ Supporting OS subroutines required: extern _LONG_DOUBLE _strtold _PARAMS((char *s, char **sptr)); #endif +#ifdef __SPE__ +extern __int64_t _strtosfix64_r _PARAMS((struct _reent *, char *s, char **sptr)); +extern __uint64_t _strtoufix64_r _PARAMS((struct _reent *, char *s, char **sptr)); +#endif + #define _NO_LONGLONG #if defined WANT_PRINTF_LONG_LONG && defined __GNUC__ # undef _NO_LONGLONG @@ -171,6 +178,8 @@ extern _LONG_DOUBLE _strtold _PARAMS((char *s, char **sptr)); #define NZDIGITS 0x200 /* no zero digits detected */ #define VECTOR 0x400 /* v: vector */ +#define FIXEDPOINT 0x800 /* r/R: fixed-point */ +#define SIGNED 0x1000 /* r: signed fixed-point */ /* * Conversion types. @@ -275,7 +284,7 @@ __svfscanf_r (rptr, fp, fmt0, ap) vec_union vec_buf; char *lptr; /* literal pointer */ #ifdef MB_CAPABLE - int state = 0; /* value to keep track of multibyte state */ + mbstate_t state; /* value to keep track of multibyte state */ #endif char *ch_dest; @@ -302,6 +311,7 @@ __svfscanf_r (rptr, fp, fmt0, ap) #ifndef MB_CAPABLE wc = *fmt; #else + memset (&state, '\0', sizeof (state)); nbytes = _mbtowc_r (rptr, &wc, fmt, MB_CUR_MAX, &state); #endif fmt += nbytes; @@ -467,6 +477,16 @@ __svfscanf_r (rptr, fp, fmt0, ap) vec_read_count = 4; break; +# ifdef __SPE__ + /* treat fixed-point like %f floating point */ + case 'r': + flags |= SIGNED; + /* fallthrough */ + case 'R': + flags |= FIXEDPOINT; + type = CT_FLOAT; + break; +# endif #endif case 's': @@ -1138,6 +1158,34 @@ __svfscanf_r (rptr, fp, fmt0, ap) exp_start = buf + sizeof (buf) - MAX_LONG_LEN - 1; sprintf (exp_start, "e%ld", new_exp); } +#ifdef __SPE__ + if (flags & FIXEDPOINT) + { + __uint64_t ufix64; + if (flags & SIGNED) + ufix64 = (__uint64_t)_strtosfix64_r (rptr, buf, NULL); + else + ufix64 = _strtoufix64_r (rptr, buf, NULL); + if (flags & SHORT) + { + __uint16_t *sp = va_arg (ap, __uint16_t *); + *sp = (__uint16_t)(ufix64 >> 48); + } + else if (flags & LONG) + { + __uint64_t *llp = va_arg (ap, __uint64_t *); + *llp = ufix64; + } + else + { + __uint32_t *lp = va_arg (ap, __uint32_t *); + *lp = (__uint32_t)(ufix64 >> 32); + } + nassigned++; + break; + } + +#endif /* __SPE__ */ #ifdef _NO_LONGDBL res = _strtod_r (rptr, buf, NULL); #else /* !_NO_LONGDBL */ -- 2.11.0