git
/
gcc
mirror of git://gcc.gnu.org/git/gcc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Makefile.in (libdecnumber_a_OBJS): Remove decUtility.o 

2007-09-10  Janis Johnson  <janis187@us.ibm.com>
	    Ben Elliston  <bje@au.ibm.com>

libdecnumber/
	* Makefile.in (libdecnumber_a_OBJS): Remove decUtility.o
	(dependencies): Add Symbols headers.
	* decContext.c: Upgrade to decNumber 3.53.
	* decContext.h: Ditto.
	* decDPD.h: Ditto.
	* decNumber.c: Ditto.
	* decNumber.h: Ditto.
	* decNumberLocal.h: Ditto.
	* decBasic.c: New file from decNumber 3.53.
	* decCommon.c: Ditto.
	* decDouble.c: Ditto.
	* decDouble.h: Ditto.
	* decQuad.c: Ditto.
	* decQuad.h: Ditto.
	* decSingle.c: Ditto.
	* decSingle.h: Ditto.
	* decPacked.c: Ditto.
	* decPacked.h: Ditto.
	* dpd/decimal128.c: Upgrade to decNumber 3.53.
	* dpd/decimal128.h: Ditto.
	* dpd/decimal32.c: Ditto.
	* dpd/decimal32.h: Ditto.
	* dpd/decimal64.c: Ditto.
	* dpd/decimal64.h: Ditto.
	* decLibrary.c (__dec_byte_swap): Remove.
	* decContextSymbols.h: New file.
	* decDoubleSymbols.h: New file.
	* decNumberSymbols.h: New file.
	* decPackedSymbols.h: New file.
	* decQuadSymbols.h: New file.
	* decSingleSymbols.h: New file.
	* decUtility.c: Delete file.
	* decUtility.h: Delete file.
	* bid/decimal128Symbols.h: New file.
	* bid/decimal128Local.h: New file.
	* bid/decimal32Symbols.h: New file.
	* bid/decimal64Symbols.h: New file.
	* bid/host-ieee128.c (__swap128): Remove.
	(__host_to_ieee_128, __ieee_to_host_128): Don't handle endianness.
	* bid/host-ieee32.c (__dec_type_swap): Remove.
	(__host_to_ieee_32, __ieee_to_host_32): Don't handle endianness.
	* bid/host-ieee64.c (__swap64): Remove.
	(__host_to_ieee_64, __ieee_to_host_64): Don't handle endianness.
	* dpd/decimal32Symbols.h: New file.
	* dpd/decimal64Symbols.h: New file.
	* dpd/decimal128Symbols.h: New file.
	* dpd/decimal128Local.h: New file.

libgcc/
	* Makefile.in (dfp-filenames): Remove decUtility, add
	decDouble, decPacked, decQuad, decSingle.

gcc/
	* dfp.c: Include decimal128Local.h; 
	(dfp_byte_swap): Remove.
	(encode_decimal32, decode_decimal32): Don't handle endianness.
	(encode_decimal64, decode_decimal64): Ditto.
	(encode_decimal128, decode_decimal128): Ditto.
	* config/dfp-bit.c (host_to_ieee32, ieee_to_host_32): Ditto.
	(__swap64): Remove.
	(host_to_ieee_64, ieee_to_host_64): Don't handle endianness.
         (__swap128): Remove
	(host_to_ieee_128, ieee_to_host_128): Don't handle endianness.
	* Makefile.in (DECNUM_H): Add decimal128Local.h.

Co-Authored-By: Ben Elliston <bje@au.ibm.com>

From-SVN: r128350
This commit is contained in:
Janis Johnson 2007-09-10 20:44:08 +00:00 committed by Janis Johnson
parent bfd9cff5c5
commit 2533577ff6
49 changed files with 18815 additions and 7841 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
gcc/ChangeLog
View File

@ -1,3 +1,18 @@
2007-09-10 Janis Johnson <janis187@us.ibm.com>
Ben Elliston <bje@au.ibm.com>
* dfp.c: Include decimal128Local.h;
(dfp_byte_swap): Remove.
(encode_decimal32, decode_decimal32): Don't handle endianness.
(encode_decimal64, decode_decimal64): Ditto.
(encode_decimal128, decode_decimal128): Ditto.
* config/dfp-bit.c (host_to_ieee32, ieee_to_host_32): Ditto.
(__swap64): Remove.
(host_to_ieee_64, ieee_to_host_64): Don't handle endianness.
(__swap128): Remove
(host_to_ieee_128, ieee_to_host_128): Don't handle endianness.
* Makefile.in (DECNUM_H): Add decimal128Local.h.
2007-09-10 David Daney <ddaney@avtrex.com> 2007-09-10 David Daney <ddaney@avtrex.com>
* config/mips/mips.md (UNSPEC_MEMORY_BARRIER): New entry in * config/mips/mips.md (UNSPEC_MEMORY_BARRIER): New entry in

3
gcc/Makefile.in
View File

@ -815,7 +815,8 @@ PREDICT_H = predict.h predict.def
CPPLIB_H = $(srcdir)/../libcpp/include/line-map.h \ CPPLIB_H = $(srcdir)/../libcpp/include/line-map.h \
$(srcdir)/../libcpp/include/cpplib.h $(srcdir)/../libcpp/include/cpplib.h
DECNUM_H = $(DECNUM)/decContext.h $(DECNUM)/decDPD.h $(DECNUM)/decNumber.h \ DECNUM_H = $(DECNUM)/decContext.h $(DECNUM)/decDPD.h $(DECNUM)/decNumber.h \
$(DECNUMFMT)/decimal32.h $(DECNUMFMT)/decimal64.h $(DECNUMFMT)/decimal128.h $(DECNUMFMT)/decimal32.h $(DECNUMFMT)/decimal64.h \
$(DECNUMFMT)/decimal128.h $(DECNUMFMT)/decimal128Local.h
MKDEPS_H = $(srcdir)/../libcpp/include/mkdeps.h MKDEPS_H = $(srcdir)/../libcpp/include/mkdeps.h
SYMTAB_H = $(srcdir)/../libcpp/include/symtab.h SYMTAB_H = $(srcdir)/../libcpp/include/symtab.h
CPP_ID_DATA_H = $(CPPLIB_H) $(srcdir)/../libcpp/include/cpp-id-data.h CPP_ID_DATA_H = $(CPPLIB_H) $(srcdir)/../libcpp/include/cpp-id-data.h

74
gcc/config/dfp-bit.c
View File

@ -70,8 +70,6 @@ typedef decNumber* (*dfp_unary_func)
/* A pointer to a binary decNumber operation. */ /* A pointer to a binary decNumber operation. */
typedef decNumber* (*dfp_binary_func) typedef decNumber* (*dfp_binary_func)
(decNumber *, const decNumber *, const decNumber *, decContext *); (decNumber *, const decNumber *, const decNumber *, decContext *);
extern uint32_t __dec_byte_swap (uint32_t);
/* Unary operations. */ /* Unary operations. */
@ -190,101 +188,41 @@ dfp_compare_op (dfp_binary_func op, DFP_C_TYPE arg_a, DFP_C_TYPE arg_b)
void void
__host_to_ieee_32 (_Decimal32 in, decimal32 *out) __host_to_ieee_32 (_Decimal32 in, decimal32 *out)
{ {
uint32_t t; memcpy (out, &in, 4);
if (!LIBGCC2_FLOAT_WORDS_BIG_ENDIAN)
{
memcpy (&t, &in, 4);
t = __dec_byte_swap (t);
memcpy (out, &t, 4);
}
else
memcpy (out, &in, 4);
} }
void void
__ieee_to_host_32 (decimal32 in, _Decimal32 *out) __ieee_to_host_32 (decimal32 in, _Decimal32 *out)
{ {
uint32_t t; memcpy (out, &in, 4);
if (!LIBGCC2_FLOAT_WORDS_BIG_ENDIAN)
{
memcpy (&t, &in, 4);
t = __dec_byte_swap (t);
memcpy (out, &t, 4);
}
else
memcpy (out, &in, 4);
} }
#endif /* L_conv_sd */ #endif /* L_conv_sd */
#if defined(L_conv_dd) #if defined(L_conv_dd)
static void
__swap64 (char *src, char *dst)
{
uint32_t t1, t2;
if (!LIBGCC2_FLOAT_WORDS_BIG_ENDIAN)
{
memcpy (&t1, src, 4);
memcpy (&t2, src + 4, 4);
t1 = __dec_byte_swap (t1);
t2 = __dec_byte_swap (t2);
memcpy (dst, &t2, 4);
memcpy (dst + 4, &t1, 4);
}
else
memcpy (dst, src, 8);
}
void void
__host_to_ieee_64 (_Decimal64 in, decimal64 *out) __host_to_ieee_64 (_Decimal64 in, decimal64 *out)
{ {
__swap64 ((char *) &in, (char *) out); memcpy (out, &in, 8);
} }
void void
__ieee_to_host_64 (decimal64 in, _Decimal64 *out) __ieee_to_host_64 (decimal64 in, _Decimal64 *out)
{ {
__swap64 ((char *) &in, (char *) out); memcpy (out, &in, 8);
} }
#endif /* L_conv_dd */ #endif /* L_conv_dd */
#if defined(L_conv_td) #if defined(L_conv_td)
static void
__swap128 (char *src, char *dst)
{
uint32_t t1, t2, t3, t4;
if (!LIBGCC2_FLOAT_WORDS_BIG_ENDIAN)
{
memcpy (&t1, src, 4);
memcpy (&t2, src + 4, 4);
memcpy (&t3, src + 8, 4);
memcpy (&t4, src + 12, 4);
t1 = __dec_byte_swap (t1);
t2 = __dec_byte_swap (t2);
t3 = __dec_byte_swap (t3);
t4 = __dec_byte_swap (t4);
memcpy (dst, &t4, 4);
memcpy (dst + 4, &t3, 4);
memcpy (dst + 8, &t2, 4);
memcpy (dst + 12, &t1, 4);
}
else
memcpy (dst, src, 16);
}
void void
__host_to_ieee_128 (_Decimal128 in, decimal128 *out) __host_to_ieee_128 (_Decimal128 in, decimal128 *out)
{ {
__swap128 ((char *) &in, (char *) out); memcpy (out, &in, 16);
} }
void void
__ieee_to_host_128 (decimal128 in, _Decimal128 *out) __ieee_to_host_128 (decimal128 in, _Decimal128 *out)
{ {
__swap128 ((char *) &in, (char *) out); memcpy (out, &in, 16);
} }
#endif /* L_conv_td */ #endif /* L_conv_td */

90
gcc/dfp.c
View File

@ -31,29 +31,11 @@ along with GCC; see the file COPYING3. If not see
decNumber structure is large enough to hold decimal128 digits. */ decNumber structure is large enough to hold decimal128 digits. */
#include "decimal128.h" #include "decimal128.h"
#include "decimal128Local.h"
#include "decimal64.h" #include "decimal64.h"
#include "decimal32.h" #include "decimal32.h"
#include "decNumber.h" #include "decNumber.h"
static uint32_t
dfp_byte_swap (uint32_t in)
{
uint32_t out = 0;
unsigned char *p = (unsigned char *) &out;
union {
uint32_t i;
unsigned char b[4];
} u;
u.i = in;
p[0] = u.b[3];
p[1] = u.b[2];
p[2] = u.b[1];
p[3] = u.b[0];
return out;
}
/* Initialize R (a real with the decimal flag set) from DN. Can /* Initialize R (a real with the decimal flag set) from DN. Can
utilize status passed in via CONTEXT, if a previous operation had utilize status passed in via CONTEXT, if a previous operation had
interesting status. */ interesting status. */
@ -155,10 +137,7 @@ encode_decimal32 (const struct real_format *fmt ATTRIBUTE_UNUSED,
decimal_to_decnumber (r, &dn); decimal_to_decnumber (r, &dn);
decimal32FromNumber (&d32, &dn, &set); decimal32FromNumber (&d32, &dn, &set);
if (FLOAT_WORDS_BIG_ENDIAN) buf[0] = *(uint32_t *) d32.bytes;
buf[0] = *(uint32_t *) d32.bytes;
else
buf[0] = dfp_byte_swap (*(uint32_t *) d32.bytes);
} }
/* Decode an IEEE 754R decimal32 type into a real. */ /* Decode an IEEE 754R decimal32 type into a real. */
@ -174,10 +153,7 @@ decode_decimal32 (const struct real_format *fmt ATTRIBUTE_UNUSED,
decContextDefault (&set, DEC_INIT_DECIMAL128); decContextDefault (&set, DEC_INIT_DECIMAL128);
set.traps = 0; set.traps = 0;
if (FLOAT_WORDS_BIG_ENDIAN) *((uint32_t *) d32.bytes) = (uint32_t) buf[0];
*((uint32_t *) d32.bytes) = (uint32_t) buf[0];
else
*((uint32_t *) d32.bytes) = dfp_byte_swap ((uint32_t) buf[0]);
decimal32ToNumber (&d32, &dn); decimal32ToNumber (&d32, &dn);
decimal_from_decnumber (r, &dn, &set); decimal_from_decnumber (r, &dn, &set);
@ -199,16 +175,8 @@ encode_decimal64 (const struct real_format *fmt ATTRIBUTE_UNUSED,
decimal_to_decnumber (r, &dn); decimal_to_decnumber (r, &dn);
decimal64FromNumber (&d64, &dn, &set); decimal64FromNumber (&d64, &dn, &set);
if (FLOAT_WORDS_BIG_ENDIAN) buf[0] = *(uint32_t *) &d64.bytes[0];
{ buf[1] = *(uint32_t *) &d64.bytes[4];
buf[0] = *(uint32_t *) &d64.bytes[0];
buf[1] = *(uint32_t *) &d64.bytes[4];
}
else
{
buf[1] = dfp_byte_swap (*(uint32_t *) &d64.bytes[0]);
buf[0] = dfp_byte_swap (*(uint32_t *) &d64.bytes[4]);
}
} }
/* Decode an IEEE 754R decimal64 type into a real. */ /* Decode an IEEE 754R decimal64 type into a real. */
@ -224,16 +192,8 @@ decode_decimal64 (const struct real_format *fmt ATTRIBUTE_UNUSED,
decContextDefault (&set, DEC_INIT_DECIMAL128); decContextDefault (&set, DEC_INIT_DECIMAL128);
set.traps = 0; set.traps = 0;
if (FLOAT_WORDS_BIG_ENDIAN) *((uint32_t *) &d64.bytes[0]) = (uint32_t) buf[0];
{ *((uint32_t *) &d64.bytes[4]) = (uint32_t) buf[1];
*((uint32_t *) &d64.bytes[0]) = (uint32_t) buf[0];
*((uint32_t *) &d64.bytes[4]) = (uint32_t) buf[1];
}
else
{
*((uint32_t *) &d64.bytes[0]) = dfp_byte_swap ((uint32_t) buf[1]);
*((uint32_t *) &d64.bytes[4]) = dfp_byte_swap ((uint32_t) buf[0]);
}
decimal64ToNumber (&d64, &dn); decimal64ToNumber (&d64, &dn);
decimal_from_decnumber (r, &dn, &set); decimal_from_decnumber (r, &dn, &set);
@ -255,20 +215,10 @@ encode_decimal128 (const struct real_format *fmt ATTRIBUTE_UNUSED,
decimal_to_decnumber (r, &dn); decimal_to_decnumber (r, &dn);
decimal128FromNumber (&d128, &dn, &set); decimal128FromNumber (&d128, &dn, &set);
if (FLOAT_WORDS_BIG_ENDIAN) buf[0] = *(uint32_t *) &d128.bytes[0];
{ buf[1] = *(uint32_t *) &d128.bytes[4];
buf[0] = *(uint32_t *) &d128.bytes[0]; buf[2] = *(uint32_t *) &d128.bytes[8];
buf[1] = *(uint32_t *) &d128.bytes[4]; buf[3] = *(uint32_t *) &d128.bytes[12];
buf[2] = *(uint32_t *) &d128.bytes[8];
buf[3] = *(uint32_t *) &d128.bytes[12];
}
else
{
buf[0] = dfp_byte_swap (*(uint32_t *) &d128.bytes[12]);
buf[1] = dfp_byte_swap (*(uint32_t *) &d128.bytes[8]);
buf[2] = dfp_byte_swap (*(uint32_t *) &d128.bytes[4]);
buf[3] = dfp_byte_swap (*(uint32_t *) &d128.bytes[0]);
}
} }
/* Decode an IEEE 754R decimal128 type into a real. */ /* Decode an IEEE 754R decimal128 type into a real. */
@ -284,20 +234,10 @@ decode_decimal128 (const struct real_format *fmt ATTRIBUTE_UNUSED,
decContextDefault (&set, DEC_INIT_DECIMAL128); decContextDefault (&set, DEC_INIT_DECIMAL128);
set.traps = 0; set.traps = 0;
if (FLOAT_WORDS_BIG_ENDIAN) *((uint32_t *) &d128.bytes[0]) = (uint32_t) buf[0];
{ *((uint32_t *) &d128.bytes[4]) = (uint32_t) buf[1];
*((uint32_t *) &d128.bytes[0]) = (uint32_t) buf[0]; *((uint32_t *) &d128.bytes[8]) = (uint32_t) buf[2];
*((uint32_t *) &d128.bytes[4]) = (uint32_t) buf[1]; *((uint32_t *) &d128.bytes[12]) = (uint32_t) buf[3];
*((uint32_t *) &d128.bytes[8]) = (uint32_t) buf[2];
*((uint32_t *) &d128.bytes[12]) = (uint32_t) buf[3];
}
else
{
*((uint32_t *) &d128.bytes[0]) = dfp_byte_swap ((uint32_t) buf[3]);
*((uint32_t *) &d128.bytes[4]) = dfp_byte_swap ((uint32_t) buf[2]);
*((uint32_t *) &d128.bytes[8]) = dfp_byte_swap ((uint32_t) buf[1]);
*((uint32_t *) &d128.bytes[12]) = dfp_byte_swap ((uint32_t) buf[0]);
}
decimal128ToNumber (&d128, &dn); decimal128ToNumber (&d128, &dn);
decimal_from_decnumber (r, &dn, &set); decimal_from_decnumber (r, &dn, &set);

51
libdecnumber/ChangeLog
View File

@ -1,3 +1,54 @@
2007-09-10 Janis Johnson <janis187@us.ibm.com>
Ben Elliston <bje@au.ibm.com>
* Makefile.in (libdecnumber_a_OBJS): Remove decUtility.o
(dependencies): Add Symbols headers.
* decContext.c: Upgrade to decNumber 3.53.
* decContext.h: Ditto.
* decDPD.h: Ditto.
* decNumber.c: Ditto.
* decNumber.h: Ditto.
* decNumberLocal.h: Ditto.
* decBasic.c: New file from decNumber 3.53.
* decCommon.c: Ditto.
* decDouble.c: Ditto.
* decDouble.h: Ditto.
* decQuad.c: Ditto.
* decQuad.h: Ditto.
* decSingle.c: Ditto.
* decSingle.h: Ditto.
* decPacked.c: Ditto.
* decPacked.h: Ditto.
* dpd/decimal128.c: Upgrade to decNumber 3.53.
* dpd/decimal128.h: Ditto.
* dpd/decimal32.c: Ditto.
* dpd/decimal32.h: Ditto.
* dpd/decimal64.c: Ditto.
* dpd/decimal64.h: Ditto.
* decLibrary.c (__dec_byte_swap): Remove.
* decContextSymbols.h: New file.
* decDoubleSymbols.h: New file.
* decNumberSymbols.h: New file.
* decPackedSymbols.h: New file.
* decQuadSymbols.h: New file.
* decSingleSymbols.h: New file.
* decUtility.c: Delete file.
* decUtility.h: Delete file.
* bid/decimal128Symbols.h: New file.
* bid/decimal128Local.h: New file.
* bid/decimal32Symbols.h: New file.
* bid/decimal64Symbols.h: New file.
* bid/host-ieee128.c (__swap128): Remove.
(__host_to_ieee_128, __ieee_to_host_128): Don't handle endianness.
* bid/host-ieee32.c (__dec_type_swap): Remove.
(__host_to_ieee_32, __ieee_to_host_32): Don't handle endianness.
* bid/host-ieee64.c (__swap64): Remove.
(__host_to_ieee_64, __ieee_to_host_64): Don't handle endianness.
* dpd/decimal32Symbols.h: New file.
* dpd/decimal64Symbols.h: New file.
* dpd/decimal128Symbols.h: New file.
* dpd/decimal128Local.h: New file.
2007-06-18 Martin Michlmayr <tbm@cyrius.com> 2007-06-18 Martin Michlmayr <tbm@cyrius.com>
H.J. Lu <hongjiu.lu@intel.com> H.J. Lu <hongjiu.lu@intel.com>

19
libdecnumber/Makefile.in
View File

@ -56,7 +56,7 @@ INCLUDES = -I$(srcdir) -I.
ALL_CFLAGS = $(CFLAGS) $(WARN_CFLAGS) $(INCLUDES) $(CPPFLAGS) ALL_CFLAGS = $(CFLAGS) $(WARN_CFLAGS) $(INCLUDES) $(CPPFLAGS)
libdecnumber_a_OBJS = decNumber.o decContext.o decUtility.o \ libdecnumber_a_OBJS = decNumber.o decContext.o \
decimal32.o decimal64.o decimal128.o decimal32.o decimal64.o decimal128.o
ifeq ($(enable_decimal_float),bid) ifeq ($(enable_decimal_float),bid)
@ -66,7 +66,6 @@ endif
libdecnumber_a_SOURCES = decContext.c decContext.h decDPD.h \ libdecnumber_a_SOURCES = decContext.c decContext.h decDPD.h \
decNumber.c decNumber.h decNumberLocal.h \ decNumber.c decNumber.h decNumberLocal.h \
decUtility.c decUtility.h \
dpd/decimal128.c dpd/decimal128.h \ dpd/decimal128.c dpd/decimal128.h \
dpd/decimal32.c dpd/decimal32.h \ dpd/decimal32.c dpd/decimal32.h \
dpd/decimal64.c dpd/decimal64.h \ dpd/decimal64.c dpd/decimal64.h \
@ -113,19 +112,25 @@ $(srcdir)/config.in: @MAINT@ $(srcdir)/configure
# Dependencies. # Dependencies.
decContext.o: decContext.c decContext.h decNumberLocal.h decContext.o: decContext.c decContext.h decNumberLocal.h \
decNumber.o: decNumber.c decNumber.h decContext.h decNumberLocal.h decContextSymbols.h
decNumber.o: decNumber.c decNumber.h decContext.h decNumberLocal.h \
decNumberSymbols.h
decimal32.o: $(enable_decimal_float)/decimal32.c \ decimal32.o: $(enable_decimal_float)/decimal32.c \
$(enable_decimal_float)/decimal32.h \ $(enable_decimal_float)/decimal32.h \
decNumber.h decContext.h decNumberLocal.h decUtility.h $(enable_decimal_float)/decimal32Symbols.h \
decNumber.h decContext.h decNumberLocal.h
$(COMPILE) $< $(COMPILE) $<
decimal64.o: $(enable_decimal_float)/decimal64.c \ decimal64.o: $(enable_decimal_float)/decimal64.c \
$(enable_decimal_float)/decimal64.h \ $(enable_decimal_float)/decimal64.h \
decNumber.h decContext.h decNumberLocal.h decUtility.h $(enable_decimal_float)/decimal64Symbols.h \
decNumber.h decContext.h decNumberLocal.h
$(COMPILE) $< $(COMPILE) $<
decimal128.o: $(enable_decimal_float)/decimal128.c \ decimal128.o: $(enable_decimal_float)/decimal128.c \
$(enable_decimal_float)/decimal128.h \ $(enable_decimal_float)/decimal128.h \
decNumber.h decContext.h decNumberLocal.h decUtility.h $(enable_decimal_float)/decimal128Symbols.h\
$(enable_decimal_float)/decimal128Local.h\
decNumber.h decContext.h decNumberLocal.h
$(COMPILE) $< $(COMPILE) $<
bid2dpd_dpd2bid.o : bid/bid2dpd_dpd2bid.c bid/bid2dpd_dpd2bid.h bid2dpd_dpd2bid.o : bid/bid2dpd_dpd2bid.c bid/bid2dpd_dpd2bid.h
$(COMPILE) $< $(COMPILE) $<

1
libdecnumber/bid/decimal128Local.h Normal file
View File

@ -0,0 +1 @@
#include "dpd/decimal128Local.h"

1
libdecnumber/bid/decimal128Symbols.h Normal file
View File

@ -0,0 +1 @@
#include "dpd/decimal128Symbols.h"

1
libdecnumber/bid/decimal32Symbols.h Normal file
View File

@ -0,0 +1 @@
#include "dpd/decimal32Symbols.h"

1
libdecnumber/bid/decimal64Symbols.h Normal file
View File

@ -0,0 +1 @@
#include "dpd/decimal64Symbols.h"

38
libdecnumber/bid/host-ieee128.c
View File

@ -27,56 +27,22 @@ along with GCC; see the file COPYING. If not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA. */ 02110-1301, USA. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h> #include <string.h>
#include <limits.h>
#include "config.h"
#include "gstdint.h"
#include "bid-dpd.h" #include "bid-dpd.h"
#include "decimal128.h" #include "decimal128.h"
extern uint32_t __dec_byte_swap (uint32_t);
void __host_to_ieee_128 (_Decimal128 in, decimal128 *out); void __host_to_ieee_128 (_Decimal128 in, decimal128 *out);
void __ieee_to_host_128 (decimal128 in, _Decimal128 *out); void __ieee_to_host_128 (decimal128 in, _Decimal128 *out);
#ifndef WORDS_BIGENDIAN
#define WORDS_BIGENDIAN 0
#endif
static void
__swap128 (char *src, char *dst)
{
uint32_t t1, t2, t3, t4;
if (!WORDS_BIGENDIAN)
{
memcpy (&t1, src, 4);
memcpy (&t2, src + 4, 4);
memcpy (&t3, src + 8, 4);
memcpy (&t4, src + 12, 4);
t1 = __dec_byte_swap (t1);
t2 = __dec_byte_swap (t2);
t3 = __dec_byte_swap (t3);
t4 = __dec_byte_swap (t4);
memcpy (dst, &t4, 4);
memcpy (dst + 4, &t3, 4);
memcpy (dst + 8, &t2, 4);
memcpy (dst + 12, &t1, 4);
}
else
memcpy (dst, src, 16);
}
void void
__host_to_ieee_128 (_Decimal128 in, decimal128 *out) __host_to_ieee_128 (_Decimal128 in, decimal128 *out)
{ {
__swap128 ((char *) &in, (char *) out); memcpy ((char *) out, (char *) &in, 16);
} }
void void
__ieee_to_host_128 (decimal128 in, _Decimal128 *out) __ieee_to_host_128 (decimal128 in, _Decimal128 *out)
{ {
__swap128 ((char *) &in, (char *) out); memcpy ((char *) out, (char *) &in, 16);
} }

52
libdecnumber/bid/host-ieee32.c
View File

@ -37,69 +37,21 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
/* The intended way to use this file is to make two copies, add `#define ' /* The intended way to use this file is to make two copies, add `#define '
to one copy, then compile both copies and add them to libgcc.a. */ to one copy, then compile both copies and add them to libgcc.a. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h> #include <string.h>
#include <limits.h>
#include "config.h"
#include "gstdint.h"
#include "bid-dpd.h" #include "bid-dpd.h"
#include "decimal32.h" #include "decimal32.h"
uint32_t __dec_byte_swap (uint32_t);
void __host_to_ieee_32 (_Decimal32 in, decimal32 *out); void __host_to_ieee_32 (_Decimal32 in, decimal32 *out);
void __ieee_to_host_32 (decimal32 in, _Decimal32 *out); void __ieee_to_host_32 (decimal32 in, _Decimal32 *out);
#ifndef WORDS_BIGENDIAN
#define WORDS_BIGENDIAN 0
#endif
uint32_t
__dec_byte_swap (uint32_t in)
{
uint32_t out = 0;
unsigned char *p = (unsigned char *) &out;
union {
uint32_t i;
unsigned char b[4];
} u;
u.i = in;
p[0] = u.b[3];
p[1] = u.b[2];
p[2] = u.b[1];
p[3] = u.b[0];
return out;
}
void void
__host_to_ieee_32 (_Decimal32 in, decimal32 *out) __host_to_ieee_32 (_Decimal32 in, decimal32 *out)
{ {
uint32_t t; memcpy ((char *) out, (char *) &in, 4);
if (!WORDS_BIGENDIAN)
{
memcpy (&t, &in, 4);
t = __dec_byte_swap (t);
memcpy (out, &t, 4);
}
else
memcpy (out, &in, 4);
} }
void void
__ieee_to_host_32 (decimal32 in, _Decimal32 *out) __ieee_to_host_32 (decimal32 in, _Decimal32 *out)
{ {
uint32_t t; memcpy ((char *) out, (char *) &in, 4);
if (!WORDS_BIGENDIAN)
{
memcpy (&t, &in, 4);
t = __dec_byte_swap (t);
memcpy (out, &t, 4);
}
else
memcpy (out, &in, 4);
} }

33
libdecnumber/bid/host-ieee64.c
View File

@ -37,50 +37,21 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
/* The intended way to use this file is to make two copies, add `#define ' /* The intended way to use this file is to make two copies, add `#define '
to one copy, then compile both copies and add them to libgcc.a. */ to one copy, then compile both copies and add them to libgcc.a. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h> #include <string.h>
#include <limits.h>
#include "config.h"
#include "gstdint.h"
#include "bid-dpd.h" #include "bid-dpd.h"
#include "decimal64.h" #include "decimal64.h"
uint32_t __dec_byte_swap (uint32_t);
void __host_to_ieee_64 (_Decimal64 in, decimal64 *out); void __host_to_ieee_64 (_Decimal64 in, decimal64 *out);
void __ieee_to_host_64 (decimal64 in, _Decimal64 *out); void __ieee_to_host_64 (decimal64 in, _Decimal64 *out);
#ifndef WORDS_BIGENDIAN
#define WORDS_BIGENDIAN 0
#endif
static void
__swap64 (char *src, char *dst)
{
uint32_t t1, t2;
if (!WORDS_BIGENDIAN)
{
memcpy (&t1, src, 4);
memcpy (&t2, src + 4, 4);
t1 = __dec_byte_swap (t1);
t2 = __dec_byte_swap (t2);
memcpy (dst, &t2, 4);
memcpy (dst + 4, &t1, 4);
}
else
memcpy (dst, src, 8);
}
void void
__host_to_ieee_64 (_Decimal64 in, decimal64 *out) __host_to_ieee_64 (_Decimal64 in, decimal64 *out)
{ {
__swap64 ((char *) &in, (char *) out); memcpy ((char *) out, (char *) &in, 8);
} }
void void
__ieee_to_host_64 (decimal64 in, _Decimal64 *out) __ieee_to_host_64 (decimal64 in, _Decimal64 *out)
{ {
__swap64 ((char *) &in, (char *) out); memcpy ((char *) out, (char *) &in, 8);
} }

3769
libdecnumber/decBasic.c Normal file
View File

File diff suppressed because it is too large Load Diff

1771
libdecnumber/decCommon.c Normal file
View File

File diff suppressed because it is too large Load Diff

540
libdecnumber/decContext.c
View File

@ -1,5 +1,5 @@
/* Decimal context module for the decNumber C Library. /* Decimal context module for the decNumber C Library.
Copyright (C) 2005 Free Software Foundation, Inc. Copyright (C) 2005, 2007 Free Software Foundation, Inc.
Contributed by IBM Corporation. Author Mike Cowlishaw. Contributed by IBM Corporation. Author Mike Cowlishaw.
This file is part of GCC. This file is part of GCC.
@ -28,201 +28,405 @@
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA. */ 02110-1301, USA. */
/* This module compirises the routines for handling the arithmetic /* ------------------------------------------------------------------ */
context structures. */ /* Decimal Context module */
/* ------------------------------------------------------------------ */
/* This module comprises the routines for handling arithmetic */
/* context structures. */
/* ------------------------------------------------------------------ */
#include <string.h> /* for strcmp */ #include <string.h> /* for strcmp */
#include "config.h" #include <stdio.h> /* for printf if DECCHECK */
#include "decContext.h" /* context and base types */ #include "config.h" /* for GCC definitions */
#include "decNumberLocal.h" /* decNumber local types, etc. */ #include "decContext.h" /* context and base types */
#include "decNumberLocal.h" /* decNumber local types, etc. */
#if DECCHECK
/* compile-time endian tester [assumes sizeof(Int)>1] */
static const Int mfcone=1; /* constant 1 */
static const Flag *mfctop=(Flag *)&mfcone; /* -> top byte */
#define LITEND *mfctop /* named flag; 1=little-endian */
#endif
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
/* decContextDefault -- initialize a context structure */ /* round-for-reround digits */
/* */ /* ------------------------------------------------------------------ */
/* context is the structure to be initialized */ const uByte DECSTICKYTAB[10]={1,1,2,3,4,6,6,7,8,9}; /* used if sticky */
/* kind selects the required set of default values, one of: */
/* DEC_INIT_BASE -- select ANSI X3-274 defaults */ /* ------------------------------------------------------------------ */
/* DEC_INIT_DECIMAL32 -- select IEEE 754r defaults, 32-bit */ /* Powers of ten (powers[n]==10**n, 0<=n<=9) */
/* DEC_INIT_DECIMAL64 -- select IEEE 754r defaults, 64-bit */ /* ------------------------------------------------------------------ */
/* DEC_INIT_DECIMAL128 -- select IEEE 754r defaults, 128-bit */ const uInt DECPOWERS[10]={1, 10, 100, 1000, 10000, 100000, 1000000,
/* For any other value a valid context is returned, but with */ 10000000, 100000000, 1000000000};
/* Invalid_operation set in the status field. */
/* ------------------------------------------------------------------ */
/* decContextClearStatus -- clear bits in current status */
/* */
/* context is the context structure to be queried */
/* mask indicates the bits to be cleared (the status bit that */
/* corresponds to each 1 bit in the mask is cleared) */
/* returns context */
/* */
/* No error is possible. */
/* ------------------------------------------------------------------ */
decContext *decContextClearStatus(decContext *context, uInt mask) {
context->status&=~mask;
return context;
} /* decContextClearStatus */
/* ------------------------------------------------------------------ */
/* decContextDefault -- initialize a context structure */
/* */
/* context is the structure to be initialized */
/* kind selects the required set of default values, one of: */
/* DEC_INIT_BASE -- select ANSI X3-274 defaults */
/* DEC_INIT_DECIMAL32 -- select IEEE 754r defaults, 32-bit */
/* DEC_INIT_DECIMAL64 -- select IEEE 754r defaults, 64-bit */
/* DEC_INIT_DECIMAL128 -- select IEEE 754r defaults, 128-bit */
/* For any other value a valid context is returned, but with */
/* Invalid_operation set in the status field. */
/* returns a context structure with the appropriate initial values. */ /* returns a context structure with the appropriate initial values. */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
decContext * decContext * decContextDefault(decContext *context, Int kind) {
decContextDefault (decContext * context, Int kind)
{
/* set defaults... */ /* set defaults... */
context->digits = 9; /* 9 digits */ context->digits=9; /* 9 digits */
context->emax = DEC_MAX_EMAX; /* 9-digit exponents */ context->emax=DEC_MAX_EMAX; /* 9-digit exponents */
context->emin = DEC_MIN_EMIN; /* .. balanced */ context->emin=DEC_MIN_EMIN; /* .. balanced */
context->round = DEC_ROUND_HALF_UP; /* 0.5 rises */ context->round=DEC_ROUND_HALF_UP; /* 0.5 rises */
context->traps = DEC_Errors; /* all but informational */ context->traps=DEC_Errors; /* all but informational */
context->status = 0; /* cleared */ context->status=0; /* cleared */
context->clamp = 0; /* no clamping */ context->clamp=0; /* no clamping */
#if DECSUBSET #if DECSUBSET
context->extended = 0; /* cleared */ context->extended=0; /* cleared */
#endif #endif
switch (kind) switch (kind) {
{
case DEC_INIT_BASE: case DEC_INIT_BASE:
/* [use defaults] */ /* [use defaults] */
break; break;
case DEC_INIT_DECIMAL32: case DEC_INIT_DECIMAL32:
context->digits = 7; /* digits */ context->digits=7; /* digits */
context->emax = 96; /* Emax */ context->emax=96; /* Emax */
context->emin = -95; /* Emin */ context->emin=-95; /* Emin */
context->round = DEC_ROUND_HALF_EVEN; /* 0.5 to nearest even */ context->round=DEC_ROUND_HALF_EVEN; /* 0.5 to nearest even */
context->traps = 0; /* no traps set */ context->traps=0; /* no traps set */
context->clamp = 1; /* clamp exponents */ context->clamp=1; /* clamp exponents */
#if DECSUBSET #if DECSUBSET
context->extended = 1; /* set */ context->extended=1; /* set */
#endif #endif
break; break;
case DEC_INIT_DECIMAL64: case DEC_INIT_DECIMAL64:
context->digits = 16; /* digits */ context->digits=16; /* digits */
context->emax = 384; /* Emax */ context->emax=384; /* Emax */
context->emin = -383; /* Emin */ context->emin=-383; /* Emin */
context->round = DEC_ROUND_HALF_EVEN; /* 0.5 to nearest even */ context->round=DEC_ROUND_HALF_EVEN; /* 0.5 to nearest even */
context->traps = 0; /* no traps set */ context->traps=0; /* no traps set */
context->clamp = 1; /* clamp exponents */ context->clamp=1; /* clamp exponents */
#if DECSUBSET #if DECSUBSET
context->extended = 1; /* set */ context->extended=1; /* set */
#endif #endif
break; break;
case DEC_INIT_DECIMAL128: case DEC_INIT_DECIMAL128:
context->digits = 34; /* digits */ context->digits=34; /* digits */
context->emax = 6144; /* Emax */ context->emax=6144; /* Emax */
context->emin = -6143; /* Emin */ context->emin=-6143; /* Emin */
context->round = DEC_ROUND_HALF_EVEN; /* 0.5 to nearest even */ context->round=DEC_ROUND_HALF_EVEN; /* 0.5 to nearest even */
context->traps = 0; /* no traps set */ context->traps=0; /* no traps set */
context->clamp = 1; /* clamp exponents */ context->clamp=1; /* clamp exponents */
#if DECSUBSET #if DECSUBSET
context->extended = 1; /* set */ context->extended=1; /* set */
#endif #endif
break; break;
default: /* invalid Kind */ default: /* invalid Kind */
/* use defaults, and .. */ /* use defaults, and .. */
decContextSetStatus (context, DEC_Invalid_operation); /* trap */ decContextSetStatus(context, DEC_Invalid_operation); /* trap */
} }
#if DECCHECK
if (LITEND!=DECLITEND) {
const char *adj;
if (LITEND) adj="little";
else adj="big";
printf("Warning: DECLITEND is set to %d, but this computer appears to be %s-endian\n",
DECLITEND, adj);
}
#endif
return context;} /* decContextDefault */
/* ------------------------------------------------------------------ */
/* decContextGetRounding -- return current rounding mode */
/* */
/* context is the context structure to be queried */
/* returns the rounding mode */
/* */
/* No error is possible. */
/* ------------------------------------------------------------------ */
enum rounding decContextGetRounding(decContext *context) {
return context->round;
} /* decContextGetRounding */
/* ------------------------------------------------------------------ */
/* decContextGetStatus -- return current status */
/* */
/* context is the context structure to be queried */
/* returns status */
/* */
/* No error is possible. */
/* ------------------------------------------------------------------ */
uInt decContextGetStatus(decContext *context) {
return context->status;
} /* decContextGetStatus */
/* ------------------------------------------------------------------ */
/* decContextRestoreStatus -- restore bits in current status */
/* */
/* context is the context structure to be updated */
/* newstatus is the source for the bits to be restored */
/* mask indicates the bits to be restored (the status bit that */
/* corresponds to each 1 bit in the mask is set to the value of */
/* the correspnding bit in newstatus) */
/* returns context */
/* */
/* No error is possible. */
/* ------------------------------------------------------------------ */
decContext *decContextRestoreStatus(decContext *context,
uInt newstatus, uInt mask) {
context->status&=~mask; /* clear the selected bits */
context->status|=(mask&newstatus); /* or in the new bits */
return context; return context;
} /* decContextDefault */ } /* decContextRestoreStatus */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
/* decContextStatusToString -- convert status flags to a string */ /* decContextSaveStatus -- save bits in current status */
/* */ /* */
/* context is a context with valid status field */ /* context is the context structure to be queried */
/* */ /* mask indicates the bits to be saved (the status bits that */
/* returns a constant string describing the condition. If multiple */ /* correspond to each 1 bit in the mask are saved) */
/* (or no) flags are set, a generic constant message is returned. */ /* returns the AND of the mask and the current status */
/* */
/* No error is possible. */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
const char * uInt decContextSaveStatus(decContext *context, uInt mask) {
decContextStatusToString (const decContext * context) return context->status&mask;
{ } /* decContextSaveStatus */
Int status = context->status;
if (status == DEC_Conversion_syntax)
return DEC_Condition_CS;
if (status == DEC_Division_by_zero)
return DEC_Condition_DZ;
if (status == DEC_Division_impossible)
return DEC_Condition_DI;
if (status == DEC_Division_undefined)
return DEC_Condition_DU;
if (status == DEC_Inexact)
return DEC_Condition_IE;
if (status == DEC_Insufficient_storage)
return DEC_Condition_IS;
if (status == DEC_Invalid_context)
return DEC_Condition_IC;
if (status == DEC_Invalid_operation)
return DEC_Condition_IO;
#if DECSUBSET
if (status == DEC_Lost_digits)
return DEC_Condition_LD;
#endif
if (status == DEC_Overflow)
return DEC_Condition_OV;
if (status == DEC_Clamped)
return DEC_Condition_PA;
if (status == DEC_Rounded)
return DEC_Condition_RO;
if (status == DEC_Subnormal)
return DEC_Condition_SU;
if (status == DEC_Underflow)
return DEC_Condition_UN;
if (status == 0)
return DEC_Condition_ZE;
return DEC_Condition_MU; /* Multiple errors */
} /* decContextStatusToString */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
/* decContextSetStatusFromString -- set status from a string */ /* decContextSetRounding -- set current rounding mode */
/* */ /* */
/* context is the controlling context */ /* context is the context structure to be updated */
/* string is a string exactly equal to one that might be returned */ /* newround is the value which will replace the current mode */
/* by decContextStatusToString */ /* returns context */
/* */ /* */
/* The status bit corresponding to the string is set, and a trap */ /* No error is possible. */
/* is raised if appropriate. */
/* */
/* returns the context structure, unless the string is equal to */
/* DEC_Condition_MU or is not recognized. In these cases NULL is */
/* returned. */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
decContext * decContext *decContextSetRounding(decContext *context,
decContextSetStatusFromString (decContext * context, const char *string) enum rounding newround) {
{ context->round=newround;
if (strcmp (string, DEC_Condition_CS) == 0) return context;
return decContextSetStatus (context, DEC_Conversion_syntax); } /* decContextSetRounding */
if (strcmp (string, DEC_Condition_DZ) == 0)
return decContextSetStatus (context, DEC_Division_by_zero);
if (strcmp (string, DEC_Condition_DI) == 0)
return decContextSetStatus (context, DEC_Division_impossible);
if (strcmp (string, DEC_Condition_DU) == 0)
return decContextSetStatus (context, DEC_Division_undefined);
if (strcmp (string, DEC_Condition_IE) == 0)
return decContextSetStatus (context, DEC_Inexact);
if (strcmp (string, DEC_Condition_IS) == 0)
return decContextSetStatus (context, DEC_Insufficient_storage);
if (strcmp (string, DEC_Condition_IC) == 0)
return decContextSetStatus (context, DEC_Invalid_context);
if (strcmp (string, DEC_Condition_IO) == 0)
return decContextSetStatus (context, DEC_Invalid_operation);
#if DECSUBSET
if (strcmp (string, DEC_Condition_LD) == 0)
return decContextSetStatus (context, DEC_Lost_digits);
#endif
if (strcmp (string, DEC_Condition_OV) == 0)
return decContextSetStatus (context, DEC_Overflow);
if (strcmp (string, DEC_Condition_PA) == 0)
return decContextSetStatus (context, DEC_Clamped);
if (strcmp (string, DEC_Condition_RO) == 0)
return decContextSetStatus (context, DEC_Rounded);
if (strcmp (string, DEC_Condition_SU) == 0)
return decContextSetStatus (context, DEC_Subnormal);
if (strcmp (string, DEC_Condition_UN) == 0)
return decContextSetStatus (context, DEC_Underflow);
if (strcmp (string, DEC_Condition_ZE) == 0)
return context;
return NULL; /* Multiple status, or unknown */
} /* decContextSetStatusFromString */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
/* decContextSetStatus -- set status and raise trap if appropriate */ /* decContextSetStatus -- set status and raise trap if appropriate */
/* */ /* */
/* context is the controlling context */ /* context is the context structure to be updated */
/* status is the DEC_ exception code */ /* status is the DEC_ exception code */
/* returns the context structure */ /* returns the context structure */
/* */ /* */
/* Control may never return from this routine, if there is a signal */ /* Control may never return from this routine, if there is a signal */
/* handler and it takes a long jump. */ /* handler and it takes a long jump. */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
decContext * decContext * decContextSetStatus(decContext *context, uInt status) {
decContextSetStatus (decContext * context, uInt status) context->status|=status;
{ if (status & context->traps) raise(SIGFPE);
context->status |= status; return context;} /* decContextSetStatus */
if (status & context->traps)
raise (SIGFPE); /* ------------------------------------------------------------------ */
/* decContextSetStatusFromString -- set status from a string + trap */
/* */
/* context is the context structure to be updated */
/* string is a string exactly equal to one that might be returned */
/* by decContextStatusToString */
/* */
/* The status bit corresponding to the string is set, and a trap */
/* is raised if appropriate. */
/* */
/* returns the context structure, unless the string is equal to */
/* DEC_Condition_MU or is not recognized. In these cases NULL is */
/* returned. */
/* ------------------------------------------------------------------ */
decContext * decContextSetStatusFromString(decContext *context,
const char *string) {
if (strcmp(string, DEC_Condition_CS)==0)
return decContextSetStatus(context, DEC_Conversion_syntax);
if (strcmp(string, DEC_Condition_DZ)==0)
return decContextSetStatus(context, DEC_Division_by_zero);
if (strcmp(string, DEC_Condition_DI)==0)
return decContextSetStatus(context, DEC_Division_impossible);
if (strcmp(string, DEC_Condition_DU)==0)
return decContextSetStatus(context, DEC_Division_undefined);
if (strcmp(string, DEC_Condition_IE)==0)
return decContextSetStatus(context, DEC_Inexact);
if (strcmp(string, DEC_Condition_IS)==0)
return decContextSetStatus(context, DEC_Insufficient_storage);
if (strcmp(string, DEC_Condition_IC)==0)
return decContextSetStatus(context, DEC_Invalid_context);
if (strcmp(string, DEC_Condition_IO)==0)
return decContextSetStatus(context, DEC_Invalid_operation);
#if DECSUBSET
if (strcmp(string, DEC_Condition_LD)==0)
return decContextSetStatus(context, DEC_Lost_digits);
#endif
if (strcmp(string, DEC_Condition_OV)==0)
return decContextSetStatus(context, DEC_Overflow);
if (strcmp(string, DEC_Condition_PA)==0)
return decContextSetStatus(context, DEC_Clamped);
if (strcmp(string, DEC_Condition_RO)==0)
return decContextSetStatus(context, DEC_Rounded);
if (strcmp(string, DEC_Condition_SU)==0)
return decContextSetStatus(context, DEC_Subnormal);
if (strcmp(string, DEC_Condition_UN)==0)
return decContextSetStatus(context, DEC_Underflow);
if (strcmp(string, DEC_Condition_ZE)==0)
return context;
return NULL; /* Multiple status, or unknown */
} /* decContextSetStatusFromString */
/* ------------------------------------------------------------------ */
/* decContextSetStatusFromStringQuiet -- set status from a string */
/* */
/* context is the context structure to be updated */
/* string is a string exactly equal to one that might be returned */
/* by decContextStatusToString */
/* */
/* The status bit corresponding to the string is set; no trap is */
/* raised. */
/* */
/* returns the context structure, unless the string is equal to */
/* DEC_Condition_MU or is not recognized. In these cases NULL is */
/* returned. */
/* ------------------------------------------------------------------ */
decContext * decContextSetStatusFromStringQuiet(decContext *context,
const char *string) {
if (strcmp(string, DEC_Condition_CS)==0)
return decContextSetStatusQuiet(context, DEC_Conversion_syntax);
if (strcmp(string, DEC_Condition_DZ)==0)
return decContextSetStatusQuiet(context, DEC_Division_by_zero);
if (strcmp(string, DEC_Condition_DI)==0)
return decContextSetStatusQuiet(context, DEC_Division_impossible);
if (strcmp(string, DEC_Condition_DU)==0)
return decContextSetStatusQuiet(context, DEC_Division_undefined);
if (strcmp(string, DEC_Condition_IE)==0)
return decContextSetStatusQuiet(context, DEC_Inexact);
if (strcmp(string, DEC_Condition_IS)==0)
return decContextSetStatusQuiet(context, DEC_Insufficient_storage);
if (strcmp(string, DEC_Condition_IC)==0)
return decContextSetStatusQuiet(context, DEC_Invalid_context);
if (strcmp(string, DEC_Condition_IO)==0)
return decContextSetStatusQuiet(context, DEC_Invalid_operation);
#if DECSUBSET
if (strcmp(string, DEC_Condition_LD)==0)
return decContextSetStatusQuiet(context, DEC_Lost_digits);
#endif
if (strcmp(string, DEC_Condition_OV)==0)
return decContextSetStatusQuiet(context, DEC_Overflow);
if (strcmp(string, DEC_Condition_PA)==0)
return decContextSetStatusQuiet(context, DEC_Clamped);
if (strcmp(string, DEC_Condition_RO)==0)
return decContextSetStatusQuiet(context, DEC_Rounded);
if (strcmp(string, DEC_Condition_SU)==0)
return decContextSetStatusQuiet(context, DEC_Subnormal);
if (strcmp(string, DEC_Condition_UN)==0)
return decContextSetStatusQuiet(context, DEC_Underflow);
if (strcmp(string, DEC_Condition_ZE)==0)
return context;
return NULL; /* Multiple status, or unknown */
} /* decContextSetStatusFromStringQuiet */
/* ------------------------------------------------------------------ */
/* decContextSetStatusQuiet -- set status without trap */
/* */
/* context is the context structure to be updated */
/* status is the DEC_ exception code */
/* returns the context structure */
/* */
/* No error is possible. */
/* ------------------------------------------------------------------ */
decContext * decContextSetStatusQuiet(decContext *context, uInt status) {
context->status|=status;
return context;} /* decContextSetStatusQuiet */
/* ------------------------------------------------------------------ */
/* decContextStatusToString -- convert status flags to a string */
/* */
/* context is a context with valid status field */
/* */
/* returns a constant string describing the condition. If multiple */
/* (or no) flags are set, a generic constant message is returned. */
/* ------------------------------------------------------------------ */
const char *decContextStatusToString(const decContext *context) {
Int status=context->status;
/* test the five IEEE first, as some of the others are ambiguous when */
/* DECEXTFLAG=0 */
if (status==DEC_Invalid_operation ) return DEC_Condition_IO;
if (status==DEC_Division_by_zero ) return DEC_Condition_DZ;
if (status==DEC_Overflow ) return DEC_Condition_OV;
if (status==DEC_Underflow ) return DEC_Condition_UN;
if (status==DEC_Inexact ) return DEC_Condition_IE;
if (status==DEC_Division_impossible ) return DEC_Condition_DI;
if (status==DEC_Division_undefined ) return DEC_Condition_DU;
if (status==DEC_Rounded ) return DEC_Condition_RO;
if (status==DEC_Clamped ) return DEC_Condition_PA;
if (status==DEC_Subnormal ) return DEC_Condition_SU;
if (status==DEC_Conversion_syntax ) return DEC_Condition_CS;
if (status==DEC_Insufficient_storage ) return DEC_Condition_IS;
if (status==DEC_Invalid_context ) return DEC_Condition_IC;
#if DECSUBSET
if (status==DEC_Lost_digits ) return DEC_Condition_LD;
#endif
if (status==0 ) return DEC_Condition_ZE;
return DEC_Condition_MU; /* Multiple errors */
} /* decContextStatusToString */
/* ------------------------------------------------------------------ */
/* decContextTestSavedStatus -- test bits in saved status */
/* */
/* oldstatus is the status word to be tested */
/* mask indicates the bits to be tested (the oldstatus bits that */
/* correspond to each 1 bit in the mask are tested) */
/* returns 1 if any of the tested bits are 1, or 0 otherwise */
/* */
/* No error is possible. */
/* ------------------------------------------------------------------ */
uInt decContextTestSavedStatus(uInt oldstatus, uInt mask) {
return (oldstatus&mask)!=0;
} /* decContextTestSavedStatus */
/* ------------------------------------------------------------------ */
/* decContextTestStatus -- test bits in current status */
/* */
/* context is the context structure to be updated */
/* mask indicates the bits to be tested (the status bits that */
/* correspond to each 1 bit in the mask are tested) */
/* returns 1 if any of the tested bits are 1, or 0 otherwise */
/* */
/* No error is possible. */
/* ------------------------------------------------------------------ */
uInt decContextTestStatus(decContext *context, uInt mask) {
return (context->status&mask)!=0;
} /* decContextTestStatus */
/* ------------------------------------------------------------------ */
/* decContextZeroStatus -- clear all status bits */
/* */
/* context is the context structure to be updated */
/* returns context */
/* */
/* No error is possible. */
/* ------------------------------------------------------------------ */
decContext *decContextZeroStatus(decContext *context) {
context->status=0;
return context; return context;
} /* decContextSetStatus */ } /* decContextZeroStatus */

347
libdecnumber/decContext.h
View File

@ -1,5 +1,5 @@
/* Decimal Context module header for the decNumber C Library /* Decimal context header module for the decNumber C Library.
Copyright (C) 2005, 2006 Free Software Foundation, Inc. Copyright (C) 2005, 2007 Free Software Foundation, Inc.
Contributed by IBM Corporation. Author Mike Cowlishaw. Contributed by IBM Corporation. Author Mike Cowlishaw.
This file is part of GCC. This file is part of GCC.
@ -29,159 +29,230 @@
02110-1301, USA. */ 02110-1301, USA. */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
/* */ /* Decimal Context module header */
/* Context must always be set correctly: */ /* ------------------------------------------------------------------ */
/* */ /* */
/* digits -- must be in the range 1 through 999999999 */ /* Context variables must always have valid values: */
/* emax -- must be in the range 0 through 999999999 */ /* */
/* emin -- must be in the range 0 through -999999999 */ /* status -- [any bits may be cleared, but not set, by user] */
/* round -- must be one of the enumerated rounding modes */ /* round -- must be one of the enumerated rounding modes */
/* traps -- only defined bits may be set */ /* */
/* status -- [any bits may be cleared, but not set, by user] */ /* The following variables are implied for fixed size formats (i.e., */
/* clamp -- must be either 0 or 1 */ /* they are ignored) but should still be set correctly in case used */
/* with decNumber functions: */
/* */
/* clamp -- must be either 0 or 1 */
/* digits -- must be in the range 1 through 999999999 */
/* emax -- must be in the range 0 through 999999999 */
/* emin -- must be in the range 0 through -999999999 */
/* extended -- must be either 0 or 1 [present only if DECSUBSET] */ /* extended -- must be either 0 or 1 [present only if DECSUBSET] */
/* */ /* traps -- only defined bits may be set */
/* */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
#if !defined(DECCONTEXT) #if !defined(DECCONTEXT)
#define DECCONTEXT #define DECCONTEXT
#define DECCNAME "decContext" /* Short name */ #define DECCNAME "decContext" /* Short name */
#define DECCFULLNAME "Decimal Context Descriptor" /* Verbose name */ #define DECCFULLNAME "Decimal Context Descriptor" /* Verbose name */
#define DECCAUTHOR "Mike Cowlishaw" /* Who to blame */ #define DECCAUTHOR "Mike Cowlishaw" /* Who to blame */
#include "gstdint.h" /* C99 standard integers */ #include "gstdint.h" /* C99 standard integers */
#include <signal.h> /* for traps */ #include <stdio.h> /* for printf, etc. */
#include <signal.h> /* for traps */
/* Extended flags setting -- set this to 0 to use only IEEE flags */
#define DECEXTFLAG 1 /* 1=enable extended flags */
/* Conditional code flag -- set this to 0 for best performance */ /* Conditional code flag -- set this to 0 for best performance */
#define DECSUBSET 0 /* 1 to enable subset arithmetic */ #define DECSUBSET 0 /* 1=enable subset arithmetic */
/* Context for operations, with associated constants */ /* Context for operations, with associated constants */
enum rounding enum rounding {
{ DEC_ROUND_CEILING, /* round towards +infinity */
DEC_ROUND_CEILING, /* round towards +infinity */ DEC_ROUND_UP, /* round away from 0 */
DEC_ROUND_UP, /* round away from 0 */ DEC_ROUND_HALF_UP, /* 0.5 rounds up */
DEC_ROUND_HALF_UP, /* 0.5 rounds up */ DEC_ROUND_HALF_EVEN, /* 0.5 rounds to nearest even */
DEC_ROUND_HALF_EVEN, /* 0.5 rounds to nearest even */ DEC_ROUND_HALF_DOWN, /* 0.5 rounds down */
DEC_ROUND_HALF_DOWN, /* 0.5 rounds down */ DEC_ROUND_DOWN, /* round towards 0 (truncate) */
DEC_ROUND_DOWN, /* round towards 0 (truncate) */ DEC_ROUND_FLOOR, /* round towards -infinity */
DEC_ROUND_FLOOR, /* round towards -infinity */ DEC_ROUND_05UP, /* round for reround */
DEC_ROUND_MAX /* enum must be less than this */ DEC_ROUND_MAX /* enum must be less than this */
}; };
#define DEC_ROUND_DEFAULT DEC_ROUND_HALF_EVEN;
typedef struct typedef struct {
{ int32_t digits; /* working precision */
int32_t digits; /* working precision */ int32_t emax; /* maximum positive exponent */
int32_t emax; /* maximum positive exponent */ int32_t emin; /* minimum negative exponent */
int32_t emin; /* minimum negative exponent */ enum rounding round; /* rounding mode */
enum rounding round; /* rounding mode */ uint32_t traps; /* trap-enabler flags */
uint32_t traps; /* trap-enabler flags */ uint32_t status; /* status flags */
uint32_t status; /* status flags */ uint8_t clamp; /* flag: apply IEEE exponent clamp */
uint8_t clamp; /* flag: apply IEEE exponent clamp */ #if DECSUBSET
#if DECSUBSET uint8_t extended; /* flag: special-values allowed */
uint8_t extended; /* flag: special-values allowed */ #endif
#endif } decContext;
} decContext;
/* Maxima and Minima */ /* Maxima and Minima for context settings */
#define DEC_MAX_DIGITS 999999999 #define DEC_MAX_DIGITS 999999999
#define DEC_MIN_DIGITS 1 #define DEC_MIN_DIGITS 1
#define DEC_MAX_EMAX 999999999 #define DEC_MAX_EMAX 999999999
#define DEC_MIN_EMAX 0 #define DEC_MIN_EMAX 0
#define DEC_MAX_EMIN 0 #define DEC_MAX_EMIN 0
#define DEC_MIN_EMIN -999999999 #define DEC_MIN_EMIN -999999999
#define DEC_MAX_MATH 999999 /* max emax, etc., for math funcs. */
/* Trap-enabler and Status flags (exceptional conditions), and their names */ /* Classifications for decimal numbers, aligned with 754r (note */
/* Top byte is reserved for internal use */ /* that 'normal' and 'subnormal' are meaningful only with a */
#define DEC_Conversion_syntax 0x00000001 /* decContext or a fixed size format). */
#define DEC_Division_by_zero 0x00000002 enum decClass {
#define DEC_Division_impossible 0x00000004 DEC_CLASS_SNAN,
#define DEC_Division_undefined 0x00000008 DEC_CLASS_QNAN,
#define DEC_Insufficient_storage 0x00000010 /* [used if malloc fails] */ DEC_CLASS_NEG_INF,
#define DEC_Inexact 0x00000020 DEC_CLASS_NEG_NORMAL,
#define DEC_Invalid_context 0x00000040 DEC_CLASS_NEG_SUBNORMAL,
#define DEC_Invalid_operation 0x00000080 DEC_CLASS_NEG_ZERO,
#if DECSUBSET DEC_CLASS_POS_ZERO,
#define DEC_Lost_digits 0x00000100 DEC_CLASS_POS_SUBNORMAL,
#endif DEC_CLASS_POS_NORMAL,
#define DEC_Overflow 0x00000200 DEC_CLASS_POS_INF
#define DEC_Clamped 0x00000400 };
#define DEC_Rounded 0x00000800 /* Strings for the decClasses */
#define DEC_Subnormal 0x00001000 #define DEC_ClassString_SN "sNaN"
#define DEC_Underflow 0x00002000 #define DEC_ClassString_QN "NaN"
#define DEC_ClassString_NI "-Infinity"
#define DEC_ClassString_NN "-Normal"
#define DEC_ClassString_NS "-Subnormal"
#define DEC_ClassString_NZ "-Zero"
#define DEC_ClassString_PZ "+Zero"
#define DEC_ClassString_PS "+Subnormal"
#define DEC_ClassString_PN "+Normal"
#define DEC_ClassString_PI "+Infinity"
#define DEC_ClassString_UN "Invalid"
/* IEEE 854 groupings for the flags */ /* Trap-enabler and Status flags (exceptional conditions), and */
/* [DEC_Clamped, DEC_Lost_digits, DEC_Rounded, and DEC_Subnormal are */ /* their names. The top byte is reserved for internal use */
/* not in IEEE 854] */ #if DECEXTFLAG
#define DEC_IEEE_854_Division_by_zero (DEC_Division_by_zero) /* Extended flags */
#if DECSUBSET #define DEC_Conversion_syntax 0x00000001
#define DEC_IEEE_854_Inexact (DEC_Inexact | DEC_Lost_digits) #define DEC_Division_by_zero 0x00000002
#else #define DEC_Division_impossible 0x00000004
#define DEC_IEEE_854_Inexact (DEC_Inexact) #define DEC_Division_undefined 0x00000008
#endif #define DEC_Insufficient_storage 0x00000010 /* [when malloc fails] */
#define DEC_IEEE_854_Invalid_operation (DEC_Conversion_syntax | \ #define DEC_Inexact 0x00000020
DEC_Division_impossible | \ #define DEC_Invalid_context 0x00000040
DEC_Division_undefined | \ #define DEC_Invalid_operation 0x00000080
DEC_Insufficient_storage | \ #if DECSUBSET
DEC_Invalid_context | \ #define DEC_Lost_digits 0x00000100
DEC_Invalid_operation) #endif
#define DEC_IEEE_854_Overflow (DEC_Overflow) #define DEC_Overflow 0x00000200
#define DEC_IEEE_854_Underflow (DEC_Underflow) #define DEC_Clamped 0x00000400
#define DEC_Rounded 0x00000800
#define DEC_Subnormal 0x00001000
#define DEC_Underflow 0x00002000
#else
/* IEEE flags only */
#define DEC_Conversion_syntax 0x00000010
#define DEC_Division_by_zero 0x00000002
#define DEC_Division_impossible 0x00000010
#define DEC_Division_undefined 0x00000010
#define DEC_Insufficient_storage 0x00000010 /* [when malloc fails] */
#define DEC_Inexact 0x00000001
#define DEC_Invalid_context 0x00000010
#define DEC_Invalid_operation 0x00000010
#if DECSUBSET
#define DEC_Lost_digits 0x00000000
#endif
#define DEC_Overflow 0x00000008
#define DEC_Clamped 0x00000000
#define DEC_Rounded 0x00000000
#define DEC_Subnormal 0x00000000
#define DEC_Underflow 0x00000004
#endif
/* flags which are normally errors (results are qNaN, infinite, or 0) */ /* IEEE 854 groupings for the flags */
#define DEC_Errors (DEC_IEEE_854_Division_by_zero | \ /* [DEC_Clamped, DEC_Lost_digits, DEC_Rounded, and DEC_Subnormal */
DEC_IEEE_854_Invalid_operation | \ /* are not in IEEE 854] */
DEC_IEEE_854_Overflow | DEC_IEEE_854_Underflow) #define DEC_IEEE_854_Division_by_zero (DEC_Division_by_zero)
/* flags which cause a result to become qNaN */ #if DECSUBSET
#define DEC_NaNs DEC_IEEE_854_Invalid_operation #define DEC_IEEE_854_Inexact (DEC_Inexact | DEC_Lost_digits)
#else
#define DEC_IEEE_854_Inexact (DEC_Inexact)
#endif
#define DEC_IEEE_854_Invalid_operation (DEC_Conversion_syntax | \
DEC_Division_impossible | \
DEC_Division_undefined | \
DEC_Insufficient_storage | \
DEC_Invalid_context | \
DEC_Invalid_operation)
#define DEC_IEEE_854_Overflow (DEC_Overflow)
#define DEC_IEEE_854_Underflow (DEC_Underflow)
/* flags which are normally for information only (have finite results) */ /* flags which are normally errors (result is qNaN, infinite, or 0) */
#if DECSUBSET #define DEC_Errors (DEC_IEEE_854_Division_by_zero | \
#define DEC_Information (DEC_Clamped | DEC_Rounded | DEC_Inexact \ DEC_IEEE_854_Invalid_operation | \
| DEC_Lost_digits) DEC_IEEE_854_Overflow | DEC_IEEE_854_Underflow)
#else /* flags which cause a result to become qNaN */
#define DEC_Information (DEC_Clamped | DEC_Rounded | DEC_Inexact) #define DEC_NaNs DEC_IEEE_854_Invalid_operation
#endif
/* name strings for the exceptional conditions */ /* flags which are normally for information only (finite results) */
#if DECSUBSET
#define DEC_Information (DEC_Clamped | DEC_Rounded | DEC_Inexact \
| DEC_Lost_digits)
#else
#define DEC_Information (DEC_Clamped | DEC_Rounded | DEC_Inexact)
#endif
#define DEC_Condition_CS "Conversion syntax" /* Name strings for the exceptional conditions */
#define DEC_Condition_DZ "Division by zero" #define DEC_Condition_CS "Conversion syntax"
#define DEC_Condition_DI "Division impossible" #define DEC_Condition_DZ "Division by zero"
#define DEC_Condition_DU "Division undefined" #define DEC_Condition_DI "Division impossible"
#define DEC_Condition_IE "Inexact" #define DEC_Condition_DU "Division undefined"
#define DEC_Condition_IS "Insufficient storage" #define DEC_Condition_IE "Inexact"
#define DEC_Condition_IC "Invalid context" #define DEC_Condition_IS "Insufficient storage"
#define DEC_Condition_IO "Invalid operation" #define DEC_Condition_IC "Invalid context"
#if DECSUBSET #define DEC_Condition_IO "Invalid operation"
#define DEC_Condition_LD "Lost digits" #if DECSUBSET
#endif #define DEC_Condition_LD "Lost digits"
#define DEC_Condition_OV "Overflow" #endif
#define DEC_Condition_PA "Clamped" #define DEC_Condition_OV "Overflow"
#define DEC_Condition_RO "Rounded" #define DEC_Condition_PA "Clamped"
#define DEC_Condition_SU "Subnormal" #define DEC_Condition_RO "Rounded"
#define DEC_Condition_UN "Underflow" #define DEC_Condition_SU "Subnormal"
#define DEC_Condition_ZE "No status" #define DEC_Condition_UN "Underflow"
#define DEC_Condition_MU "Multiple status" #define DEC_Condition_ZE "No status"
#define DEC_Condition_Length 21 /* length of the longest string, */ #define DEC_Condition_MU "Multiple status"
/* including terminator */ #define DEC_Condition_Length 21 /* length of the longest string, */
/* including terminator */
/* Initialization descriptors, used by decContextDefault */ /* Initialization descriptors, used by decContextDefault */
#define DEC_INIT_BASE 0 #define DEC_INIT_BASE 0
#define DEC_INIT_DECIMAL32 32 #define DEC_INIT_DECIMAL32 32
#define DEC_INIT_DECIMAL64 64 #define DEC_INIT_DECIMAL64 64
#define DEC_INIT_DECIMAL128 128 #define DEC_INIT_DECIMAL128 128
/* Synonyms */
#define DEC_INIT_DECSINGLE DEC_INIT_DECIMAL32
#define DEC_INIT_DECDOUBLE DEC_INIT_DECIMAL64
#define DEC_INIT_DECQUAD DEC_INIT_DECIMAL128
/* decContext routines */ /* decContext routines */
#ifdef IN_LIBGCC2
#define decContextDefault __decContextDefault #include "decContextSymbols.h"
#define decContextSetStatus __decContextSetStatus
#define decContextStatusToString __decContextStatusToString extern decContext * decContextClearStatus(decContext *, uint32_t);
#define decContextSetStatusFromString __decContextSetStatusFromString extern decContext * decContextDefault(decContext *, int32_t);
#endif extern enum rounding decContextGetRounding(decContext *);
decContext *decContextDefault (decContext *, int32_t); extern uint32_t decContextGetStatus(decContext *);
decContext *decContextSetStatus (decContext *, uint32_t); extern decContext * decContextRestoreStatus(decContext *, uint32_t, uint32_t);
const char *decContextStatusToString (const decContext *); extern uint32_t decContextSaveStatus(decContext *, uint32_t);
decContext *decContextSetStatusFromString (decContext *, const char *); extern decContext * decContextSetRounding(decContext *, enum rounding);
extern decContext * decContextSetStatus(decContext *, uint32_t);
extern decContext * decContextSetStatusFromString(decContext *, const char *);
extern decContext * decContextSetStatusFromStringQuiet(decContext *, const char *);
extern decContext * decContextSetStatusQuiet(decContext *, uint32_t);
extern const char * decContextStatusToString(const decContext *);
extern uint32_t decContextTestSavedStatus(uint32_t, uint32_t);
extern uint32_t decContextTestStatus(decContext *, uint32_t);
extern decContext * decContextZeroStatus(decContext *);
#endif #endif

22
libdecnumber/decContextSymbols.h Normal file
View File

@ -0,0 +1,22 @@
#if !defined(DECCONTEXTSYMBOLS)
#define DECCONTEXTSYMBOLS
#ifdef IN_LIBGCC2
#define decContextClearStatus __decContextClearStatus
#define decContextDefault __decContextDefault
#define decContextGetRounding __decContextGetRounding
#define decContextGetStatus __decContextGetStatus
#define decContextRestoreStatus __decContextRestoreStatus
#define decContextSaveStatus __decContextSaveStatus
#define decContextSetRounding __decContextSetRounding
#define decContextSetStatus __decContextSetStatus
#define decContextSetStatusFromString __decContextSetStatusFromString
#define decContextSetStatusFromStringQuiet __decContextSetStatusFromStringQuiet
#define decContextSetStatusQuiet __decContextSetStatusQuiet
#define decContextStatusToString __decContextStatusToString
#define decContextTestSavedStatus __decContextTestSavedStatus
#define decContextTestStatus __decContextTestStatus
#define decContextZeroStatus __decContextZeroStatus
#endif
#endif

1662
libdecnumber/decDPD.h
View File

File diff suppressed because it is too large Load Diff

154
libdecnumber/decDouble.c Normal file
View File

@ -0,0 +1,154 @@
/* decDouble module for the decNumber C Library.
Copyright (C) 2007 Free Software Foundation, Inc.
Contributed by IBM Corporation. Author Mike Cowlishaw.
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2, or (at your option) any later
version.
In addition to the permissions in the GNU General Public License,
the Free Software Foundation gives you unlimited permission to link
the compiled version of this file into combinations with other
programs, and to distribute those combinations without any
restriction coming from the use of this file. (The General Public
License restrictions do apply in other respects; for example, they
cover modification of the file, and distribution when not linked
into a combine executable.)
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA. */
/* ------------------------------------------------------------------ */
/* decDouble.c -- decDouble operations module */
/* ------------------------------------------------------------------ */
/* This module comprises decDouble operations (including conversions) */
/* ------------------------------------------------------------------ */
#include "decContext.h" /* public includes */
#include "decDouble.h" /* .. */
/* Constant mappings for shared code */
#define DECPMAX DECDOUBLE_Pmax
#define DECEMIN DECDOUBLE_Emin
#define DECEMAX DECDOUBLE_Emax
#define DECEMAXD DECDOUBLE_EmaxD
#define DECBYTES DECDOUBLE_Bytes
#define DECSTRING DECDOUBLE_String
#define DECECONL DECDOUBLE_EconL
#define DECBIAS DECDOUBLE_Bias
#define DECLETS DECDOUBLE_Declets
#define DECQTINY (-DECDOUBLE_Bias)
/* parameters of next-wider format */
#define DECWBYTES DECQUAD_Bytes
#define DECWPMAX DECQUAD_Pmax
#define DECWECONL DECQUAD_EconL
#define DECWBIAS DECQUAD_Bias
/* Type and function mappings for shared code */
#define decFloat decDouble /* Type name */
#define decFloatWider decQuad /* Type name */
/* Utilities and conversions (binary results, extractors, etc.) */
#define decFloatFromBCD decDoubleFromBCD
#define decFloatFromInt32 decDoubleFromInt32
#define decFloatFromPacked decDoubleFromPacked
#define decFloatFromString decDoubleFromString
#define decFloatFromUInt32 decDoubleFromUInt32
#define decFloatFromWider decDoubleFromWider
#define decFloatGetCoefficient decDoubleGetCoefficient
#define decFloatGetExponent decDoubleGetExponent
#define decFloatSetCoefficient decDoubleSetCoefficient
#define decFloatSetExponent decDoubleSetExponent
#define decFloatShow decDoubleShow
#define decFloatToBCD decDoubleToBCD
#define decFloatToEngString decDoubleToEngString
#define decFloatToInt32 decDoubleToInt32
#define decFloatToInt32Exact decDoubleToInt32Exact
#define decFloatToPacked decDoubleToPacked
#define decFloatToString decDoubleToString
#define decFloatToUInt32 decDoubleToUInt32
#define decFloatToUInt32Exact decDoubleToUInt32Exact
#define decFloatToWider decDoubleToWider
#define decFloatZero decDoubleZero
/* Computational (result is a decFloat) */
#define decFloatAbs decDoubleAbs
#define decFloatAdd decDoubleAdd
#define decFloatAnd decDoubleAnd
#define decFloatDivide decDoubleDivide
#define decFloatDivideInteger decDoubleDivideInteger
#define decFloatFMA decDoubleFMA
#define decFloatInvert decDoubleInvert
#define decFloatLogB decDoubleLogB
#define decFloatMax decDoubleMax
#define decFloatMaxMag decDoubleMaxMag
#define decFloatMin decDoubleMin
#define decFloatMinMag decDoubleMinMag
#define decFloatMinus decDoubleMinus
#define decFloatMultiply decDoubleMultiply
#define decFloatNextMinus decDoubleNextMinus
#define decFloatNextPlus decDoubleNextPlus
#define decFloatNextToward decDoubleNextToward
#define decFloatOr decDoubleOr
#define decFloatPlus decDoublePlus
#define decFloatQuantize decDoubleQuantize
#define decFloatReduce decDoubleReduce
#define decFloatRemainder decDoubleRemainder
#define decFloatRemainderNear decDoubleRemainderNear
#define decFloatRotate decDoubleRotate
#define decFloatScaleB decDoubleScaleB
#define decFloatShift decDoubleShift
#define decFloatSubtract decDoubleSubtract
#define decFloatToIntegralValue decDoubleToIntegralValue
#define decFloatToIntegralExact decDoubleToIntegralExact
#define decFloatXor decDoubleXor
/* Comparisons */
#define decFloatCompare decDoubleCompare
#define decFloatCompareSignal decDoubleCompareSignal
#define decFloatCompareTotal decDoubleCompareTotal
#define decFloatCompareTotalMag decDoubleCompareTotalMag
/* Copies */
#define decFloatCanonical decDoubleCanonical
#define decFloatCopy decDoubleCopy
#define decFloatCopyAbs decDoubleCopyAbs
#define decFloatCopyNegate decDoubleCopyNegate
#define decFloatCopySign decDoubleCopySign
/* Non-computational */
#define decFloatClass decDoubleClass
#define decFloatClassString decDoubleClassString
#define decFloatDigits decDoubleDigits
#define decFloatIsCanonical decDoubleIsCanonical
#define decFloatIsFinite decDoubleIsFinite
#define decFloatIsInfinite decDoubleIsInfinite
#define decFloatIsInteger decDoubleIsInteger
#define decFloatIsNaN decDoubleIsNaN
#define decFloatIsNormal decDoubleIsNormal
#define decFloatIsSignaling decDoubleIsSignaling
#define decFloatIsSignalling decDoubleIsSignalling
#define decFloatIsSigned decDoubleIsSigned
#define decFloatIsSubnormal decDoubleIsSubnormal
#define decFloatIsZero decDoubleIsZero
#define decFloatRadix decDoubleRadix
#define decFloatSameQuantum decDoubleSameQuantum
#define decFloatVersion decDoubleVersion
#include "decNumberLocal.h" /* local includes (need DECPMAX) */
#include "decCommon.c" /* non-arithmetic decFloat routines */
#include "decBasic.c" /* basic formats routines */
/* Below here will move to shared file as completed */

164
libdecnumber/decDouble.h Normal file
View File

@ -0,0 +1,164 @@
/* decDouble module header for the decNumber C Library.
Copyright (C) 2007 Free Software Foundation, Inc.
Contributed by IBM Corporation. Author Mike Cowlishaw.
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2, or (at your option) any later
version.
In addition to the permissions in the GNU General Public License,
the Free Software Foundation gives you unlimited permission to link
the compiled version of this file into combinations with other
programs, and to distribute those combinations without any
restriction coming from the use of this file. (The General Public
License restrictions do apply in other respects; for example, they
cover modification of the file, and distribution when not linked
into a combine executable.)
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA. */
/* ------------------------------------------------------------------ */
/* decDouble.h -- Decimal 64-bit format module header */
/* ------------------------------------------------------------------ */
/* Please see decFloats.h for an overview and documentation details. */
/* ------------------------------------------------------------------ */
#if !defined(DECDOUBLE)
#define DECDOUBLE
#define DECDOUBLENAME "decimalDouble" /* Short name */
#define DECDOUBLETITLE "Decimal 64-bit datum" /* Verbose name */
#define DECDOUBLEAUTHOR "Mike Cowlishaw" /* Who to blame */
/* parameters for decDoubles */
#define DECDOUBLE_Bytes 8 /* length */
#define DECDOUBLE_Pmax 16 /* maximum precision (digits) */
#define DECDOUBLE_Emin -383 /* minimum adjusted exponent */
#define DECDOUBLE_Emax 384 /* maximum adjusted exponent */
#define DECDOUBLE_EmaxD 3 /* maximum exponent digits */
#define DECDOUBLE_Bias 398 /* bias for the exponent */
#define DECDOUBLE_String 25 /* maximum string length, +1 */
#define DECDOUBLE_EconL 8 /* exponent continuation length */
#define DECDOUBLE_Declets 5 /* count of declets */
/* highest biased exponent (Elimit-1) */
#define DECDOUBLE_Ehigh (DECDOUBLE_Emax + DECDOUBLE_Bias - (DECDOUBLE_Pmax-1))
/* Required includes */
#include "decContext.h"
#include "decQuad.h"
/* The decDouble decimal 64-bit type, accessible by bytes */
typedef struct {
uint8_t bytes[DECDOUBLE_Bytes]; /* fields: 1, 5, 8, 50 bits */
} decDouble;
/* ---------------------------------------------------------------- */
/* Routines -- implemented as decFloat routines in common files */
/* ---------------------------------------------------------------- */
#include "decDoubleSymbols.h"
/* Utilities and conversions, extractors, etc.) */
extern decDouble * decDoubleFromBCD(decDouble *, int32_t, const uint8_t *, int32_t);
extern decDouble * decDoubleFromInt32(decDouble *, int32_t);
extern decDouble * decDoubleFromPacked(decDouble *, int32_t, const uint8_t *);
extern decDouble * decDoubleFromString(decDouble *, const char *, decContext *);
extern decDouble * decDoubleFromUInt32(decDouble *, uint32_t);
extern decDouble * decDoubleFromWider(decDouble *, const decQuad *, decContext *);
extern int32_t decDoubleGetCoefficient(const decDouble *, uint8_t *);
extern int32_t decDoubleGetExponent(const decDouble *);
extern decDouble * decDoubleSetCoefficient(decDouble *, const uint8_t *, int32_t);
extern decDouble * decDoubleSetExponent(decDouble *, decContext *, int32_t);
extern void decDoubleShow(const decDouble *, const char *);
extern int32_t decDoubleToBCD(const decDouble *, int32_t *, uint8_t *);
extern char * decDoubleToEngString(const decDouble *, char *);
extern int32_t decDoubleToInt32(const decDouble *, decContext *, enum rounding);
extern int32_t decDoubleToInt32Exact(const decDouble *, decContext *, enum rounding);
extern int32_t decDoubleToPacked(const decDouble *, int32_t *, uint8_t *);
extern char * decDoubleToString(const decDouble *, char *);
extern uint32_t decDoubleToUInt32(const decDouble *, decContext *, enum rounding);
extern uint32_t decDoubleToUInt32Exact(const decDouble *, decContext *, enum rounding);
extern decQuad * decDoubleToWider(const decDouble *, decQuad *);
extern decDouble * decDoubleZero(decDouble *);
/* Computational (result is a decDouble) */
extern decDouble * decDoubleAbs(decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleAdd(decDouble *, const decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleAnd(decDouble *, const decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleDivide(decDouble *, const decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleDivideInteger(decDouble *, const decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleFMA(decDouble *, const decDouble *, const decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleInvert(decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleLogB(decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleMax(decDouble *, const decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleMaxMag(decDouble *, const decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleMin(decDouble *, const decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleMinMag(decDouble *, const decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleMinus(decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleMultiply(decDouble *, const decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleNextMinus(decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleNextPlus(decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleNextToward(decDouble *, const decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleOr(decDouble *, const decDouble *, const decDouble *, decContext *);
extern decDouble * decDoublePlus(decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleQuantize(decDouble *, const decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleReduce(decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleRemainder(decDouble *, const decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleRemainderNear(decDouble *, const decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleRotate(decDouble *, const decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleScaleB(decDouble *, const decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleShift(decDouble *, const decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleSubtract(decDouble *, const decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleToIntegralValue(decDouble *, const decDouble *, decContext *, enum rounding);
extern decDouble * decDoubleToIntegralExact(decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleXor(decDouble *, const decDouble *, const decDouble *, decContext *);
/* Comparisons */
extern decDouble * decDoubleCompare(decDouble *, const decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleCompareSignal(decDouble *, const decDouble *, const decDouble *, decContext *);
extern decDouble * decDoubleCompareTotal(decDouble *, const decDouble *, const decDouble *);
extern decDouble * decDoubleCompareTotalMag(decDouble *, const decDouble *, const decDouble *);
/* Copies */
extern decDouble * decDoubleCanonical(decDouble *, const decDouble *);
extern decDouble * decDoubleCopy(decDouble *, const decDouble *);
extern decDouble * decDoubleCopyAbs(decDouble *, const decDouble *);
extern decDouble * decDoubleCopyNegate(decDouble *, const decDouble *);
extern decDouble * decDoubleCopySign(decDouble *, const decDouble *, const decDouble *);
/* Non-computational */
extern enum decClass decDoubleClass(const decDouble *);
extern const char * decDoubleClassString(const decDouble *);
extern uint32_t decDoubleDigits(const decDouble *);
extern uint32_t decDoubleIsCanonical(const decDouble *);
extern uint32_t decDoubleIsFinite(const decDouble *);
extern uint32_t decDoubleIsInfinite(const decDouble *);
extern uint32_t decDoubleIsInteger(const decDouble *);
extern uint32_t decDoubleIsNaN(const decDouble *);
extern uint32_t decDoubleIsNormal(const decDouble *);
extern uint32_t decDoubleIsSignaling(const decDouble *);
extern uint32_t decDoubleIsSignalling(const decDouble *);
extern uint32_t decDoubleIsSigned(const decDouble *);
extern uint32_t decDoubleIsSubnormal(const decDouble *);
extern uint32_t decDoubleIsZero(const decDouble *);
extern uint32_t decDoubleRadix(const decDouble *);
extern uint32_t decDoubleSameQuantum(const decDouble *, const decDouble *);
extern const char * decDoubleVersion(void);
/* decNumber conversions; these are implemented as macros so as not */
/* to force a dependency on decimal64 and decNumber in decDouble. */
#define decDoubleToNumber(dq, dn) decimal64ToNumber((decimal64 *)(dq), dn)
#define decDoubleFromNumber(dq, dn, set) (decDouble *)decimal64FromNumber((decimal64 *)(dq), dn, set)
#endif

84
libdecnumber/decDoubleSymbols.h Normal file
View File

@ -0,0 +1,84 @@
#if !defined(DECDOUBLESYMBOLS)
#define DECDOUBLESYMBOLS
#ifdef IN_LIBGCC2
#define decDoubleAbs __decDoubleAbs
#define decDoubleAdd __decDoubleAdd
#define decDoubleAnd __decDoubleAnd
#define decDoubleCanonical __decDoubleCanonical
#define decDoubleClass __decDoubleClass
#define decDoubleClassString __decDoubleClassString
#define decDoubleCompare __decDoubleCompare
#define decDoubleCompareSignal __decDoubleCompareSignal
#define decDoubleCompareTotal __decDoubleCompareTotal
#define decDoubleCompareTotalMag __decDoubleCompareTotalMag
#define decDoubleCopy __decDoubleCopy
#define decDoubleCopyAbs __decDoubleCopyAbs
#define decDoubleCopyNegate __decDoubleCopyNegate
#define decDoubleCopySign __decDoubleCopySign
#define decDoubleDigits __decDoubleDigits
#define decDoubleDivide __decDoubleDivide
#define decDoubleDivideInteger __decDoubleDivideInteger
#define decDoubleFMA __decDoubleFMA
#define decDoubleFromBCD __decDoubleFromBCD
#define decDoubleFromInt32 __decDoubleFromInt32
#define decDoubleFromPacked __decDoubleFromPacked
#define decDoubleFromString __decDoubleFromString
#define decDoubleFromUInt32 __decDoubleFromUInt32
#define decDoubleFromWider __decDoubleFromWider
#define decDoubleGetCoefficient __decDoubleGetCoefficient
#define decDoubleGetExponent __decDoubleGetExponent
#define decDoubleInvert __decDoubleInvert
#define decDoubleIsCanonical __decDoubleIsCanonical
#define decDoubleIsFinite __decDoubleIsFinite
#define decDoubleIsInfinite __decDoubleIsInfinite
#define decDoubleIsInteger __decDoubleIsInteger
#define decDoubleIsNaN __decDoubleIsNaN
#define decDoubleIsNormal __decDoubleIsNormal
#define decDoubleIsSignaling __decDoubleIsSignaling
#define decDoubleIsSignalling __decDoubleIsSignalling
#define decDoubleIsSigned __decDoubleIsSigned
#define decDoubleIsSubnormal __decDoubleIsSubnormal
#define decDoubleIsZero __decDoubleIsZero
#define decDoubleLogB __decDoubleLogB
#define decDoubleMax __decDoubleMax
#define decDoubleMaxMag __decDoubleMaxMag
#define decDoubleMin __decDoubleMin
#define decDoubleMinMag __decDoubleMinMag
#define decDoubleMinus __decDoubleMinus
#define decDoubleMultiply __decDoubleMultiply
#define decDoubleNextMinus __decDoubleNextMinus
#define decDoubleNextPlus __decDoubleNextPlus
#define decDoubleNextToward __decDoubleNextToward
#define decDoubleOr __decDoubleOr
#define decDoublePlus __decDoublePlus
#define decDoubleQuantize __decDoubleQuantize
#define decDoubleRadix __decDoubleRadix
#define decDoubleReduce __decDoubleReduce
#define decDoubleRemainder __decDoubleRemainder
#define decDoubleRemainderNear __decDoubleRemainderNear
#define decDoubleRotate __decDoubleRotate
#define decDoubleSameQuantum __decDoubleSameQuantum
#define decDoubleScaleB __decDoubleScaleB
#define decDoubleSetCoefficient __decDoubleSetCoefficient
#define decDoubleSetExponent __decDoubleSetExponent
#define decDoubleShift __decDoubleShift
#define decDoubleShow __decDoubleShow
#define decDoubleSubtract __decDoubleSubtract
#define decDoubleToBCD __decDoubleToBCD
#define decDoubleToEngString __decDoubleToEngString
#define decDoubleToInt32 __decDoubleToInt32
#define decDoubleToInt32Exact __decDoubleToInt32Exact
#define decDoubleToIntegralExact __decDoubleToIntegralExact
#define decDoubleToIntegralValue __decDoubleToIntegralValue
#define decDoubleToPacked __decDoubleToPacked
#define decDoubleToString __decDoubleToString
#define decDoubleToUInt32 __decDoubleToUInt32
#define decDoubleToUInt32Exact __decDoubleToUInt32Exact
#define decDoubleToWider __decDoubleToWider
#define decDoubleVersion __decDoubleVersion
#define decDoubleXor __decDoubleXor
#define decDoubleZero __decDoubleZero
#endif
#endif

19
libdecnumber/decLibrary.c
View File

@ -74,22 +74,3 @@ isinfd128 (_Decimal128 arg)
decimal128ToNumber (&d128, &dn); decimal128ToNumber (&d128, &dn);
return (decNumberIsInfinite (&dn)); return (decNumberIsInfinite (&dn));
} }
uint32_t
__dec_byte_swap (uint32_t in)
{
uint32_t out = 0;
unsigned char *p = (unsigned char *) &out;
union {
uint32_t i;
unsigned char b[4];
} u;
u.i = in;
p[0] = u.b[3];
p[1] = u.b[2];
p[2] = u.b[1];
p[3] = u.b[0];
return out;
}

12495
libdecnumber/decNumber.c
View File

File diff suppressed because it is too large Load Diff

304
libdecnumber/decNumber.h
View File

@ -1,5 +1,5 @@
/* Decimal Number module header for the decNumber C Library /* Decimal number arithmetic module header for the decNumber C Library.
Copyright (C) 2005 Free Software Foundation, Inc. Copyright (C) 2005, 2007 Free Software Foundation, Inc.
Contributed by IBM Corporation. Author Mike Cowlishaw. Contributed by IBM Corporation. Author Mike Cowlishaw.
This file is part of GCC. This file is part of GCC.
@ -28,167 +28,173 @@
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA. */ 02110-1301, USA. */
/* ------------------------------------------------------------------ */
/* Decimal Number arithmetic module header */
/* ------------------------------------------------------------------ */
#if !defined(DECNUMBER) #if !defined(DECNUMBER)
#define DECNUMBER #define DECNUMBER
#define DECNAME "decNumber" /* Short name */ #define DECNAME "decNumber" /* Short name */
#define DECVERSION "decNumber 3.24" /* Version [16 max.] */ #define DECFULLNAME "Decimal Number Module" /* Verbose name */
#define DECFULLNAME "Decimal Number Module" /* Verbose name */ #define DECAUTHOR "Mike Cowlishaw" /* Who to blame */
#define DECAUTHOR "Mike Cowlishaw" /* Who to blame */
#if !defined(DECCONTEXT) #if !defined(DECCONTEXT)
#include "decContext.h" #include "decContext.h"
#endif #endif
/* Bit settings for decNumber.bits */
#define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */
#define DECINF 0x40 /* 1=Infinity */
#define DECNAN 0x20 /* 1=NaN */
#define DECSNAN 0x10 /* 1=sNaN */
/* The remaining bits are reserved; they must be 0 */
#define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */
/* Bit settings for decNumber.bits */ /* Define the decNumber data structure. The size and shape of the */
#define DECNEG 0x80 /* Sign; 1=negative, 0=positive or zero */ /* units array in the structure is determined by the following */
#define DECINF 0x40 /* 1=Infinity */ /* constant. This must not be changed without recompiling the */
#define DECNAN 0x20 /* 1=NaN */
#define DECSNAN 0x10 /* 1=sNaN */
/* The remaining bits are reserved; they must be 0 */
#define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value */
/* DECNUMDIGITS is the default number of digits we can hold in the */
/* structure. If undefined, 1 is assumed and it is assumed that the */
/* structure will be immediately followed by extra space (if */
/* required). DECNUMDIGITS is always >0. */
#if !defined(DECNUMDIGITS)
#define DECNUMDIGITS 1
#endif
/* Define the decNumber data structure. The size and shape of the */
/* units array in the structure is determined by the following */
/* constant. This must not be changed without recompiling the */
/* decNumber library modules. */ /* decNumber library modules. */
#define DECDPUN 4 /* Decimal Digits Per UNit [must be in */
/* range 1-9; power of 2 recommended]. */ #define DECDPUN 3 /* DECimal Digits Per UNit [must be >0 */
/* The size (integer data type) of each unit is determined by the */ /* and <10; 3 or powers of 2 are best]. */
/* number of digits it will hold. */
#if DECDPUN<=2 /* DECNUMDIGITS is the default number of digits that can be held in */
#define decNumberUnit uint8_t /* the structure. If undefined, 1 is assumed and it is assumed */
#elif DECDPUN<=4 /* that the structure will be immediately followed by extra space, */
#define decNumberUnit uint16_t /* as required. DECNUMDIGITS is always >0. */
#else #if !defined(DECNUMDIGITS)
#define decNumberUnit uint32_t #define DECNUMDIGITS 1
#endif #endif
/* The number of decNumberUnits we need is ceiling of DECNUMDIGITS/DECDPUN */
#define DECNUMUNITS ((DECNUMDIGITS+DECDPUN-1)/DECDPUN) /* The size (integer data type) of each unit is determined by the */
/* number of digits it will hold. */
#if DECDPUN<=2
#define decNumberUnit uint8_t
#elif DECDPUN<=4
#define decNumberUnit uint16_t
#else
#define decNumberUnit uint32_t
#endif
/* The number of units needed is ceil(DECNUMDIGITS/DECDPUN) */
#define DECNUMUNITS ((DECNUMDIGITS+DECDPUN-1)/DECDPUN)
/* The data structure... */ /* The data structure... */
typedef struct typedef struct {
{ int32_t digits; /* Count of digits in the coefficient; >0 */
int32_t digits; /* Count of digits in the coefficient; >0 */ int32_t exponent; /* Unadjusted exponent, unbiased, in */
int32_t exponent; /* Unadjusted exponent, unbiased, in */ /* range: -1999999997 through 999999999 */
/* range: -1999999997 through 999999999 */ uint8_t bits; /* Indicator bits (see above) */
uint8_t bits; /* Indicator bits (see above) */ /* Coefficient, from least significant unit */
decNumberUnit lsu[DECNUMUNITS]; /* Coefficient, from least significant unit */ decNumberUnit lsu[DECNUMUNITS];
} decNumber; } decNumber;
/* Notes: */ /* Notes: */
/* 1. If digits is > DECDPUN then there will be more than one */ /* 1. If digits is > DECDPUN then there will one or more */
/* decNumberUnits immediately following the first element of lsu. */ /* decNumberUnits immediately following the first element of lsu.*/
/* These contain the remaining (more significant) digits of the */ /* These contain the remaining (more significant) digits of the */
/* number, and may be in the lsu array, or may be guaranteed by */ /* number, and may be in the lsu array, or may be guaranteed by */
/* some other mechanism (such as being contained in another */ /* some other mechanism (such as being contained in another */
/* structure, or being overlaid on dynamically allocated storage). */ /* structure, or being overlaid on dynamically allocated */
/* */ /* storage). */
/* Each integer of the coefficient (except the possibly the last) */ /* */
/* contains DECDPUN digits (e.g., a value in the range 0 through */ /* Each integer of the coefficient (except potentially the last) */
/* 99999999 if DECDPUN is 8, or 0 through 9999 if DECDPUN is 4). */ /* contains DECDPUN digits (e.g., a value in the range 0 through */
/* */ /* 99999999 if DECDPUN is 8, or 0 through 999 if DECDPUN is 3). */
/* 2. A decNumber converted to a string may need up to digits+14 */ /* */
/* characters. The worst cases (non-exponential and exponential */ /* 2. A decNumber converted to a string may need up to digits+14 */
/* formats) are: -0.00000{9...}# */ /* characters. The worst cases (non-exponential and exponential */
/* and: -9.{9...}E+999999999# (where # is '\0') */ /* formats) are -0.00000{9...}# and -9.{9...}E+999999999# */
/* (where # is '\0') */
/* ------------------------------------------------------------------ */ /* ---------------------------------------------------------------- */
/* decNumber public functions and macros */ /* decNumber public functions and macros */
/* ------------------------------------------------------------------ */ /* ---------------------------------------------------------------- */
#ifdef IN_LIBGCC2 #include "decNumberSymbols.h"
#define decNumberFromString __decNumberFromString
#define decNumberToString __decNumberToString
#define decNumberToEngString __decNumberToEngString
#define decNumberAbs __decNumberAbs
#define decNumberAdd __decNumberAdd
#define decNumberCompare __decNumberCompare
#define decNumberDivide __decNumberDivide
#define decNumberDivideInteger __decNumberDivideInteger
#define decNumberMax __decNumberMax
#define decNumberMin __decNumberMin
#define decNumberMinus __decNumberMinus
#define decNumberMultiply __decNumberMultiply
#define decNumberNormalize __decNumberNormalize
#define decNumberPlus __decNumberPlus
#define decNumberPower __decNumberPower
#define decNumberQuantize __decNumberQuantize
#define decNumberRemainder __decNumberRemainder
#define decNumberRemainderNear __decNumberRemainderNear
#define decNumberRescale __decNumberRescale
#define decNumberSameQuantum __decNumberSameQuantum
#define decNumberSquareRoot __decNumberSquareRoot
#define decNumberSubtract __decNumberSubtract
#define decNumberToIntegralValue __decNumberToIntegralValue
#define decNumberCopy __decNumberCopy
#define decNumberTrim __decNumberTrim
#define decNumberVersion __decNumberVersion
#define decNumberZero __decNumberZero
#endif
/* Conversions */ /* Conversions */
decNumber *decNumberFromString (decNumber *, const char *, decContext *); decNumber * decNumberFromInt32(decNumber *, int32_t);
char *decNumberToString (const decNumber *, char *); decNumber * decNumberFromUInt32(decNumber *, uint32_t);
char *decNumberToEngString (const decNumber *, char *); decNumber * decNumberFromString(decNumber *, const char *, decContext *);
char * decNumberToString(const decNumber *, char *);
char * decNumberToEngString(const decNumber *, char *);
uint32_t decNumberToUInt32(const decNumber *, decContext *);
int32_t decNumberToInt32(const decNumber *, decContext *);
uint8_t * decNumberGetBCD(const decNumber *, uint8_t *);
decNumber * decNumberSetBCD(decNumber *, const uint8_t *, uint32_t);
/* Operators */ /* Operators and elementary functions */
decNumber *decNumberAbs (decNumber *, const decNumber *, decContext *); decNumber * decNumberAbs(decNumber *, const decNumber *, decContext *);
decNumber *decNumberAdd (decNumber *, const decNumber *, decNumber * decNumberAdd(decNumber *, const decNumber *, const decNumber *, decContext *);
const decNumber *, decContext *); decNumber * decNumberAnd(decNumber *, const decNumber *, const decNumber *, decContext *);
decNumber *decNumberCompare (decNumber *, const decNumber *, decNumber * decNumberCompare(decNumber *, const decNumber *, const decNumber *, decContext *);
const decNumber *, decContext *); decNumber * decNumberCompareSignal(decNumber *, const decNumber *, const decNumber *, decContext *);
decNumber *decNumberDivide (decNumber *, const decNumber *, decNumber * decNumberCompareTotal(decNumber *, const decNumber *, const decNumber *, decContext *);
const decNumber *, decContext *); decNumber * decNumberCompareTotalMag(decNumber *, const decNumber *, const decNumber *, decContext *);
decNumber *decNumberDivideInteger (decNumber *, const decNumber *, decNumber * decNumberDivide(decNumber *, const decNumber *, const decNumber *, decContext *);
const decNumber *, decContext *); decNumber * decNumberDivideInteger(decNumber *, const decNumber *, const decNumber *, decContext *);
decNumber *decNumberMax (decNumber *, const decNumber *, decNumber * decNumberExp(decNumber *, const decNumber *, decContext *);
const decNumber *, decContext *); decNumber * decNumberFMA(decNumber *, const decNumber *, const decNumber *, const decNumber *, decContext *);
decNumber *decNumberMin (decNumber *, const decNumber *, decNumber * decNumberInvert(decNumber *, const decNumber *, decContext *);
const decNumber *, decContext *); decNumber * decNumberLn(decNumber *, const decNumber *, decContext *);
decNumber *decNumberMinus (decNumber *, const decNumber *, decContext *); decNumber * decNumberLogB(decNumber *, const decNumber *, decContext *);
decNumber *decNumberMultiply (decNumber *, const decNumber *, decNumber * decNumberLog10(decNumber *, const decNumber *, decContext *);
const decNumber *, decContext *); decNumber * decNumberMax(decNumber *, const decNumber *, const decNumber *, decContext *);
decNumber *decNumberNormalize (decNumber *, const decNumber *, decContext *); decNumber * decNumberMaxMag(decNumber *, const decNumber *, const decNumber *, decContext *);
decNumber *decNumberPlus (decNumber *, const decNumber *, decContext *); decNumber * decNumberMin(decNumber *, const decNumber *, const decNumber *, decContext *);
decNumber *decNumberPower (decNumber *, const decNumber *, decNumber * decNumberMinMag(decNumber *, const decNumber *, const decNumber *, decContext *);
const decNumber *, decContext *); decNumber * decNumberMinus(decNumber *, const decNumber *, decContext *);
decNumber *decNumberQuantize (decNumber *, const decNumber *, decNumber * decNumberMultiply(decNumber *, const decNumber *, const decNumber *, decContext *);
const decNumber *, decContext *); decNumber * decNumberNormalize(decNumber *, const decNumber *, decContext *);
decNumber *decNumberRemainder (decNumber *, const decNumber *, decNumber * decNumberOr(decNumber *, const decNumber *, const decNumber *, decContext *);
const decNumber *, decContext *); decNumber * decNumberPlus(decNumber *, const decNumber *, decContext *);
decNumber *decNumberRemainderNear (decNumber *, const decNumber *, decNumber * decNumberPower(decNumber *, const decNumber *, const decNumber *, decContext *);
const decNumber *, decContext *); decNumber * decNumberQuantize(decNumber *, const decNumber *, const decNumber *, decContext *);
decNumber *decNumberRescale (decNumber *, const decNumber *, decNumber * decNumberReduce(decNumber *, const decNumber *, decContext *);
const decNumber *, decContext *); decNumber * decNumberRemainder(decNumber *, const decNumber *, const decNumber *, decContext *);
decNumber *decNumberSameQuantum (decNumber *, const decNumber *, const decNumber *); decNumber * decNumberRemainderNear(decNumber *, const decNumber *, const decNumber *, decContext *);
decNumber *decNumberSquareRoot (decNumber *, const decNumber *, decContext *); decNumber * decNumberRescale(decNumber *, const decNumber *, const decNumber *, decContext *);
decNumber *decNumberSubtract (decNumber *, const decNumber *, decNumber * decNumberRotate(decNumber *, const decNumber *, const decNumber *, decContext *);
const decNumber *, decContext *); decNumber * decNumberSameQuantum(decNumber *, const decNumber *, const decNumber *);
decNumber *decNumberToIntegralValue (decNumber *, const decNumber *, decContext *); decNumber * decNumberScaleB(decNumber *, const decNumber *, const decNumber *, decContext *);
decNumber * decNumberShift(decNumber *, const decNumber *, const decNumber *, decContext *);
decNumber * decNumberSquareRoot(decNumber *, const decNumber *, decContext *);
decNumber * decNumberSubtract(decNumber *, const decNumber *, const decNumber *, decContext *);
decNumber * decNumberToIntegralExact(decNumber *, const decNumber *, decContext *);
decNumber * decNumberToIntegralValue(decNumber *, const decNumber *, decContext *);
decNumber * decNumberXor(decNumber *, const decNumber *, const decNumber *, decContext *);
/* Utilities */ /* Utilities */
decNumber *decNumberCopy (decNumber *, const decNumber *); enum decClass decNumberClass(const decNumber *, decContext *);
decNumber *decNumberTrim (decNumber *); const char * decNumberClassToString(enum decClass);
const char *decNumberVersion (void); decNumber * decNumberCopy(decNumber *, const decNumber *);
decNumber *decNumberZero (decNumber *); decNumber * decNumberCopyAbs(decNumber *, const decNumber *);
decNumber * decNumberCopyNegate(decNumber *, const decNumber *);
decNumber * decNumberCopySign(decNumber *, const decNumber *, const decNumber *);
decNumber * decNumberNextMinus(decNumber *, const decNumber *, decContext *);
decNumber * decNumberNextPlus(decNumber *, const decNumber *, decContext *);
decNumber * decNumberNextToward(decNumber *, const decNumber *, const decNumber *, decContext *);
decNumber * decNumberTrim(decNumber *);
const char * decNumberVersion(void);
decNumber * decNumberZero(decNumber *);
/* Macros */ /* Functions for testing decNumbers (normality depends on context) */
#define decNumberIsZero(dn) (*(dn)->lsu==0 \ int32_t decNumberIsNormal(const decNumber *, decContext *);
&& (dn)->digits==1 \ int32_t decNumberIsSubnormal(const decNumber *, decContext *);
&& (((dn)->bits&DECSPECIAL)==0))
#define decNumberIsNegative(dn) (((dn)->bits&DECNEG)!=0) /* Macros for testing decNumber *dn */
#define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0) #define decNumberIsCanonical(dn) (1) /* All decNumbers are saintly */
#define decNumberIsInfinite(dn) (((dn)->bits&DECINF)!=0) #define decNumberIsFinite(dn) (((dn)->bits&DECSPECIAL)==0)
#define decNumberIsInfinite(dn) (((dn)->bits&DECINF)!=0)
#define decNumberIsNaN(dn) (((dn)->bits&(DECNAN|DECSNAN))!=0)
#define decNumberIsNegative(dn) (((dn)->bits&DECNEG)!=0)
#define decNumberIsQNaN(dn) (((dn)->bits&(DECNAN))!=0)
#define decNumberIsSNaN(dn) (((dn)->bits&(DECSNAN))!=0)
#define decNumberIsSpecial(dn) (((dn)->bits&DECSPECIAL)!=0)
#define decNumberIsZero(dn) (*(dn)->lsu==0 \
&& (dn)->digits==1 \
&& (((dn)->bits&DECSPECIAL)==0))
#define decNumberRadix(dn) (10)
#endif #endif

709
libdecnumber/decNumberLocal.h
View File

@ -1,5 +1,5 @@
/* decNumber package local type, tuning, and macro definitions. /* Local definitions for the decNumber C Library.
Copyright (C) 2005 Free Software Foundation, Inc. Copyright (C) 2007 Free Software Foundation, Inc.
Contributed by IBM Corporation. Author Mike Cowlishaw. Contributed by IBM Corporation. Author Mike Cowlishaw.
This file is part of GCC. This file is part of GCC.
@ -29,108 +29,637 @@
02110-1301, USA. */ 02110-1301, USA. */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
/* This header file is included by all modules in the decNumber */ /* decNumber package local type, tuning, and macro definitions */
/* ------------------------------------------------------------------ */
/* This header file is included by all modules in the decNumber */
/* library, and contains local type definitions, tuning parameters, */ /* library, and contains local type definitions, tuning parameters, */
/* etc. It must only be included once, and should not need to be */ /* etc. It should not need to be used by application programs. */
/* used by application programs. decNumber.h must be included first. */ /* decNumber.h or one of decDouble (etc.) must be included first. */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
#if !defined(DECNUMBERLOC) #if !defined(DECNUMBERLOC)
#define DECNUMBERLOC #define DECNUMBERLOC
#define DECNLAUTHOR "Mike Cowlishaw" /* Who to blame */ #define DECVERSION "decNumber 3.53" /* Package Version [16 max.] */
#define DECNLAUTHOR "Mike Cowlishaw" /* Who to blame */
/* Local names for common types -- decNumber modules do not use int or #include <stdlib.h> /* for abs */
long directly */ #include <string.h> /* for memset, strcpy */
#define Flag uint8_t #include "config.h" /* for WORDS_BIGENDIAN */
#define Byte int8_t
#define uByte uint8_t /* Conditional code flag -- set this to match hardware platform */
#define Short int16_t /* 1=little-endian, 0=big-endian */
#define uShort uint16_t #if WORDS_BIGENDIAN
#define Int int32_t #define DECLITEND 0
#define uInt uint32_t #else
#define Unit decNumberUnit #define DECLITEND 1
#endif
/* Conditional code flag -- set this to 1 for best performance */
#define DECUSE64 1 /* 1=use int64s, 0=int32 & smaller only */
/* Conditional check flags -- set these to 0 for best performance */
#define DECCHECK 0 /* 1 to enable robust checking */
#define DECALLOC 0 /* 1 to enable memory accounting */
#define DECTRACE 0 /* 1 to trace certain internals, etc. */
/* Tuning parameter for decNumber (arbitrary precision) module */
#define DECBUFFER 36 /* Size basis for local buffers. This */
/* should be a common maximum precision */
/* rounded up to a multiple of 4; must */
/* be zero or positive. */
/* ---------------------------------------------------------------- */
/* Definitions for all modules (general-purpose) */
/* ---------------------------------------------------------------- */
/* Local names for common types -- for safety, decNumber modules do */
/* not use int or long directly. */
#define Flag uint8_t
#define Byte int8_t
#define uByte uint8_t
#define Short int16_t
#define uShort uint16_t
#define Int int32_t
#define uInt uint32_t
#define Unit decNumberUnit
#if DECUSE64
#define Long int64_t
#define uLong uint64_t
#endif
/* Development-use definitions */
typedef long int LI; /* for printf arguments only */
#define DECNOINT 0 /* 1 to check no internal use of 'int' */
#if DECNOINT
/* if these interfere with your C includes, do not set DECNOINT */
#define int ? /* enable to ensure that plain C 'int' */
#define long ?? /* .. or 'long' types are not used */
#endif
/* Shared lookup tables */
extern const uByte DECSTICKYTAB[10]; /* re-round digits if sticky */
extern const uInt DECPOWERS[10]; /* powers of ten table */
/* The following are included from decDPD.h */
extern const uShort DPD2BIN[1024]; /* DPD -> 0-999 */
extern const uShort BIN2DPD[1000]; /* 0-999 -> DPD */
extern const uInt DPD2BINK[1024]; /* DPD -> 0-999000 */
extern const uInt DPD2BINM[1024]; /* DPD -> 0-999000000 */
extern const uByte DPD2BCD8[4096]; /* DPD -> ddd + len */
extern const uByte BIN2BCD8[4000]; /* 0-999 -> ddd + len */
extern const uShort BCD2DPD[2458]; /* 0-0x999 -> DPD (0x999=2457)*/
/* LONGMUL32HI -- set w=(u*v)>>32, where w, u, and v are uInts */
/* (that is, sets w to be the high-order word of the 64-bit result; */
/* the low-order word is simply u*v.) */
/* This version is derived from Knuth via Hacker's Delight; */
/* it seems to optimize better than some others tried */
#define LONGMUL32HI(w, u, v) { \
uInt u0, u1, v0, v1, w0, w1, w2, t; \
u0=u & 0xffff; u1=u>>16; \
v0=v & 0xffff; v1=v>>16; \
w0=u0*v0; \
t=u1*v0 + (w0>>16); \
w1=t & 0xffff; w2=t>>16; \
w1=u0*v1 + w1; \
(w)=u1*v1 + w2 + (w1>>16);}
/* ROUNDUP -- round an integer up to a multiple of n */
#define ROUNDUP(i, n) ((((i)+(n)-1)/n)*n)
/* ROUNDDOWN -- round an integer down to a multiple of n */
#define ROUNDDOWN(i, n) (((i)/n)*n)
#define ROUNDDOWN4(i) ((i)&~3) /* special for n=4 */
/* References to multi-byte sequences under different sizes */
/* Refer to a uInt from four bytes starting at a char* or uByte*, */
/* etc. */
#define UINTAT(b) (*((uInt *)(b)))
#define USHORTAT(b) (*((uShort *)(b)))
#define UBYTEAT(b) (*((uByte *)(b)))
/* X10 and X100 -- multiply integer i by 10 or 100 */
/* [shifts are usually faster than multiply; could be conditional] */
#define X10(i) (((i)<<1)+((i)<<3))
#define X100(i) (((i)<<2)+((i)<<5)+((i)<<6))
/* MAXI and MINI -- general max & min (not in ANSI) for integers */
#define MAXI(x,y) ((x)<(y)?(y):(x))
#define MINI(x,y) ((x)>(y)?(y):(x))
/* Useful constants */
#define BILLION 1000000000 /* 10**9 */
/* CHARMASK: 0x30303030 for ASCII/UTF8; 0xF0F0F0F0 for EBCDIC */
#define CHARMASK ((((((((uInt)'0')<<8)+'0')<<8)+'0')<<8)+'0')
/* Tuning parameter */ /* ---------------------------------------------------------------- */
#define DECBUFFER 36 /* Maximum size basis for local buffers. */ /* Definitions for arbitary-precision modules (only valid after */
/* Should be a common maximum precision */ /* decNumber.h has been included) */
/* rounded up to a multiple of 4; must */ /* ---------------------------------------------------------------- */
/* be non-negative. */
/* Conditional code flags -- set these to 0 for best performance */ /* Limits and constants */
#define DECCHECK 0 /* 1 to enable robust checking */ #define DECNUMMAXP 999999999 /* maximum precision code can handle */
#define DECALLOC 0 /* 1 to enable memory allocation accounting */ #define DECNUMMAXE 999999999 /* maximum adjusted exponent ditto */
#define DECTRACE 0 /* 1 to trace critical intermediates, etc. */ #define DECNUMMINE -999999999 /* minimum adjusted exponent ditto */
#if (DECNUMMAXP != DEC_MAX_DIGITS)
#error Maximum digits mismatch
#endif
#if (DECNUMMAXE != DEC_MAX_EMAX)
#error Maximum exponent mismatch
#endif
#if (DECNUMMINE != DEC_MIN_EMIN)
#error Minimum exponent mismatch
#endif
/* Set DECDPUNMAX -- the maximum integer that fits in DECDPUN */
/* digits, and D2UTABLE -- the initializer for the D2U table */
#if DECDPUN==1
#define DECDPUNMAX 9
#define D2UTABLE {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17, \
18,19,20,21,22,23,24,25,26,27,28,29,30,31,32, \
33,34,35,36,37,38,39,40,41,42,43,44,45,46,47, \
48,49}
#elif DECDPUN==2
#define DECDPUNMAX 99
#define D2UTABLE {0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10, \
11,11,12,12,13,13,14,14,15,15,16,16,17,17,18, \
18,19,19,20,20,21,21,22,22,23,23,24,24,25}
#elif DECDPUN==3
#define DECDPUNMAX 999
#define D2UTABLE {0,1,1,1,2,2,2,3,3,3,4,4,4,5,5,5,6,6,6,7,7,7, \
8,8,8,9,9,9,10,10,10,11,11,11,12,12,12,13,13, \
13,14,14,14,15,15,15,16,16,16,17}
#elif DECDPUN==4
#define DECDPUNMAX 9999
#define D2UTABLE {0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,6, \
6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,10,10,10,10,11, \
11,11,11,12,12,12,12,13}
#elif DECDPUN==5
#define DECDPUNMAX 99999
#define D2UTABLE {0,1,1,1,1,1,2,2,2,2,2,3,3,3,3,3,4,4,4,4,4,5, \
5,5,5,5,6,6,6,6,6,7,7,7,7,7,8,8,8,8,8,9,9,9, \
9,9,10,10,10,10}
#elif DECDPUN==6
#define DECDPUNMAX 999999
#define D2UTABLE {0,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,3,3,4,4,4, \
4,4,4,5,5,5,5,5,5,6,6,6,6,6,6,7,7,7,7,7,7,8, \
8,8,8,8,8,9}
#elif DECDPUN==7
#define DECDPUNMAX 9999999
#define D2UTABLE {0,1,1,1,1,1,1,1,2,2,2,2,2,2,2,3,3,3,3,3,3,3, \
4,4,4,4,4,4,4,5,5,5,5,5,5,5,6,6,6,6,6,6,6,7, \
7,7,7,7,7,7}
#elif DECDPUN==8
#define DECDPUNMAX 99999999
#define D2UTABLE {0,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,3,3,3,3,3, \
3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,6,6,6, \
6,6,6,6,6,7}
#elif DECDPUN==9
#define DECDPUNMAX 999999999
#define D2UTABLE {0,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,3,3,3, \
3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5, \
5,5,6,6,6,6}
#elif defined(DECDPUN)
#error DECDPUN must be in the range 1-9
#endif
/* Development use defines */ /* ----- Shared data (in decNumber.c) ----- */
#if DECALLOC /* Public lookup table used by the D2U macro (see below) */
/* if these interfere with your C includes, just comment them out */ #define DECMAXD2U 49
#define int ? /* enable to ensure we do not use plain C */ extern const uByte d2utable[DECMAXD2U+1];
#define long ?? /* .. 'int' or 'long' types from here on */
#endif
/* Limits and constants */
#define DECNUMMAXP 999999999 /* maximum precision we can handle (9 digits) */
#define DECNUMMAXE 999999999 /* maximum adjusted exponent ditto (9 digits) */
#define DECNUMMINE -999999999 /* minimum adjusted exponent ditto (9 digits) */
#if (DECNUMMAXP != DEC_MAX_DIGITS)
#error Maximum digits mismatch
#endif
#if (DECNUMMAXE != DEC_MAX_EMAX)
#error Maximum exponent mismatch
#endif
#if (DECNUMMINE != DEC_MIN_EMIN)
#error Minimum exponent mismatch
#endif
/* Set DECDPUNMAX -- the maximum integer that fits in DECDPUN digits */
#if DECDPUN==1
#define DECDPUNMAX 9
#elif DECDPUN==2
#define DECDPUNMAX 99
#elif DECDPUN==3
#define DECDPUNMAX 999
#elif DECDPUN==4
#define DECDPUNMAX 9999
#elif DECDPUN==5
#define DECDPUNMAX 99999
#elif DECDPUN==6
#define DECDPUNMAX 999999
#elif DECDPUN==7
#define DECDPUNMAX 9999999
#elif DECDPUN==8
#define DECDPUNMAX 99999999
#elif DECDPUN==9
#define DECDPUNMAX 999999999
#elif defined(DECDPUN)
#error DECDPUN must be in the range 1-9
#endif
/* ----- Shared data ----- */
/* The powers of of ten array (powers[n]==10**n, 0<=n<=10) */
extern const uInt powers[];
/* ----- Macros ----- */ /* ----- Macros ----- */
/* ISZERO -- return true if decNumber dn is a zero */ /* ISZERO -- return true if decNumber dn is a zero */
/* [performance-critical in some situations] */ /* [performance-critical in some situations] */
#define ISZERO(dn) decNumberIsZero(dn) /* now just a local name */ #define ISZERO(dn) decNumberIsZero(dn) /* now just a local name */
/* X10 and X100 -- multiply integer i by 10 or 100 */ /* D2U -- return the number of Units needed to hold d digits */
/* [shifts are usually faster than multiply; could be conditional] */ /* (runtime version, with table lookaside for small d) */
#define X10(i) (((i)<<1)+((i)<<3)) #if DECDPUN==8
#define X100(i) (((i)<<2)+((i)<<5)+((i)<<6)) #define D2U(d) ((unsigned)((d)<=DECMAXD2U?d2utable[d]:((d)+7)>>3))
#elif DECDPUN==4
#define D2U(d) ((unsigned)((d)<=DECMAXD2U?d2utable[d]:((d)+3)>>2))
#else
#define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN)
#endif
/* SD2U -- static D2U macro (for compile-time calculation) */
#define SD2U(d) (((d)+DECDPUN-1)/DECDPUN)
/* D2U -- return the number of Units needed to hold d digits */ /* MSUDIGITS -- returns digits in msu, from digits, calculated */
#if DECDPUN==8 /* using D2U */
#define D2U(d) ((unsigned)((d)+7)>>3) #define MSUDIGITS(d) ((d)-(D2U(d)-1)*DECDPUN)
#elif DECDPUN==4
#define D2U(d) ((unsigned)((d)+3)>>2) /* D2N -- return the number of decNumber structs that would be */
#else /* needed to contain that number of digits (and the initial */
#define D2U(d) (((d)+DECDPUN-1)/DECDPUN) /* decNumber struct) safely. Note that one Unit is included in the */
#endif /* initial structure. Used for allocating space that is aligned on */
/* a decNumber struct boundary. */
#define D2N(d) \
((((SD2U(d)-1)*sizeof(Unit))+sizeof(decNumber)*2-1)/sizeof(decNumber))
/* TODIGIT -- macro to remove the leading digit from the unsigned */
/* integer u at column cut (counting from the right, LSD=0) and */
/* place it as an ASCII character into the character pointed to by */
/* c. Note that cut must be <= 9, and the maximum value for u is */
/* 2,000,000,000 (as is needed for negative exponents of */
/* subnormals). The unsigned integer pow is used as a temporary */
/* variable. */
#define TODIGIT(u, cut, c, pow) { \
*(c)='0'; \
pow=DECPOWERS[cut]*2; \
if ((u)>pow) { \
pow*=4; \
if ((u)>=pow) {(u)-=pow; *(c)+=8;} \
pow/=2; \
if ((u)>=pow) {(u)-=pow; *(c)+=4;} \
pow/=2; \
} \
if ((u)>=pow) {(u)-=pow; *(c)+=2;} \
pow/=2; \
if ((u)>=pow) {(u)-=pow; *(c)+=1;} \
}
/* ---------------------------------------------------------------- */
/* Definitions for fixed-precision modules (only valid after */
/* decSingle.h, decDouble.h, or decQuad.h has been included) */
/* ---------------------------------------------------------------- */
/* bcdnum -- a structure describing a format-independent finite */
/* number, whose coefficient is a string of bcd8 uBytes */
typedef struct {
uByte *msd; /* -> most significant digit */
uByte *lsd; /* -> least ditto */
uInt sign; /* 0=positive, DECFLOAT_Sign=negative */
Int exponent; /* Unadjusted signed exponent (q), or */
/* DECFLOAT_NaN etc. for a special */
} bcdnum;
/* Test if exponent or bcdnum exponent must be a special, etc. */
#define EXPISSPECIAL(exp) ((exp)>=DECFLOAT_MinSp)
#define EXPISINF(exp) (exp==DECFLOAT_Inf)
#define EXPISNAN(exp) (exp==DECFLOAT_qNaN || exp==DECFLOAT_sNaN)
#define NUMISSPECIAL(num) (EXPISSPECIAL((num)->exponent))
/* Refer to a 32-bit word or byte in a decFloat (df) by big-endian */
/* (array) notation (the 0 word or byte contains the sign bit), */
/* automatically adjusting for endianness; similarly address a word */
/* in the next-wider format (decFloatWider, or dfw) */
#define DECWORDS (DECBYTES/4)
#define DECWWORDS (DECWBYTES/4)
#if DECLITEND
#define DFWORD(df, off) UINTAT((df)->bytes+(DECWORDS-1-(off))*4)
#define DFBYTE(df, off) UBYTEAT((df)->bytes+(DECBYTES-1-(off)))
#define DFWWORD(dfw, off) UINTAT((dfw)->bytes+(DECWWORDS-1-(off))*4)
#else
#define DFWORD(df, off) UINTAT((df)->bytes+(off)*4)
#define DFBYTE(df, off) UBYTEAT((df)->bytes+(off))
#define DFWWORD(dfw, off) UINTAT((dfw)->bytes+(off)*4)
#endif
/* Tests for sign or specials, directly on DECFLOATs */
#define DFISSIGNED(df) (DFWORD(df, 0)&0x80000000)
#define DFISSPECIAL(df) ((DFWORD(df, 0)&0x78000000)==0x78000000)
#define DFISINF(df) ((DFWORD(df, 0)&0x7c000000)==0x78000000)
#define DFISNAN(df) ((DFWORD(df, 0)&0x7c000000)==0x7c000000)
#define DFISQNAN(df) ((DFWORD(df, 0)&0x7e000000)==0x7c000000)
#define DFISSNAN(df) ((DFWORD(df, 0)&0x7e000000)==0x7e000000)
/* Shared lookup tables */
extern const uInt DECCOMBMSD[64]; /* Combination field -> MSD */
extern const uInt DECCOMBFROM[48]; /* exp+msd -> Combination */
/* Private generic (utility) routine */
#if DECCHECK || DECTRACE
extern void decShowNum(const bcdnum *, const char *);
#endif
/* Format-dependent macros and constants */
#if defined(DECPMAX)
/* Useful constants */
#define DECPMAX9 (ROUNDUP(DECPMAX, 9)/9) /* 'Pmax' in 10**9s */
/* Top words for a zero */
#define SINGLEZERO 0x22500000
#define DOUBLEZERO 0x22380000
#define QUADZERO 0x22080000
/* [ZEROWORD is defined to be one of these in the DFISZERO macro] */
/* Format-dependent common tests: */
/* DFISZERO -- test for (any) zero */
/* DFISCCZERO -- test for coefficient continuation being zero */
/* DFISCC01 -- test for coefficient contains only 0s and 1s */
/* DFISINT -- test for finite and exponent q=0 */
/* DFISUINT01 -- test for sign=0, finite, exponent q=0, and */
/* MSD=0 or 1 */
/* ZEROWORD is also defined here. */
/* In DFISZERO the first test checks the least-significant word */
/* (most likely to be non-zero); the penultimate tests MSD and */
/* DPDs in the signword, and the final test excludes specials and */
/* MSD>7. DFISINT similarly has to allow for the two forms of */
/* MSD codes. DFISUINT01 only has to allow for one form of MSD */
/* code. */
#if DECPMAX==7
#define ZEROWORD SINGLEZERO
/* [test macros not needed except for Zero] */
#define DFISZERO(df) ((DFWORD(df, 0)&0x1c0fffff)==0 \
&& (DFWORD(df, 0)&0x60000000)!=0x60000000)
#elif DECPMAX==16
#define ZEROWORD DOUBLEZERO
#define DFISZERO(df) ((DFWORD(df, 1)==0 \
&& (DFWORD(df, 0)&0x1c03ffff)==0 \
&& (DFWORD(df, 0)&0x60000000)!=0x60000000))
#define DFISINT(df) ((DFWORD(df, 0)&0x63fc0000)==0x22380000 \
||(DFWORD(df, 0)&0x7bfc0000)==0x6a380000)
#define DFISUINT01(df) ((DFWORD(df, 0)&0xfbfc0000)==0x22380000)
#define DFISCCZERO(df) (DFWORD(df, 1)==0 \
&& (DFWORD(df, 0)&0x0003ffff)==0)
#define DFISCC01(df) ((DFWORD(df, 0)&~0xfffc9124)==0 \
&& (DFWORD(df, 1)&~0x49124491)==0)
#elif DECPMAX==34
#define ZEROWORD QUADZERO
#define DFISZERO(df) ((DFWORD(df, 3)==0 \
&& DFWORD(df, 2)==0 \
&& DFWORD(df, 1)==0 \
&& (DFWORD(df, 0)&0x1c003fff)==0 \
&& (DFWORD(df, 0)&0x60000000)!=0x60000000))
#define DFISINT(df) ((DFWORD(df, 0)&0x63ffc000)==0x22080000 \
||(DFWORD(df, 0)&0x7bffc000)==0x6a080000)
#define DFISUINT01(df) ((DFWORD(df, 0)&0xfbffc000)==0x22080000)
#define DFISCCZERO(df) (DFWORD(df, 3)==0 \
&& DFWORD(df, 2)==0 \
&& DFWORD(df, 1)==0 \
&& (DFWORD(df, 0)&0x00003fff)==0)
#define DFISCC01(df) ((DFWORD(df, 0)&~0xffffc912)==0 \
&& (DFWORD(df, 1)&~0x44912449)==0 \
&& (DFWORD(df, 2)&~0x12449124)==0 \
&& (DFWORD(df, 3)&~0x49124491)==0)
#endif
/* Macros to test if a certain 10 bits of a uInt or pair of uInts */
/* are a canonical declet [higher or lower bits are ignored]. */
/* declet is at offset 0 (from the right) in a uInt: */
#define CANONDPD(dpd) (((dpd)&0x300)==0 || ((dpd)&0x6e)!=0x6e)
/* declet is at offset k (a multiple of 2) in a uInt: */
#define CANONDPDOFF(dpd, k) (((dpd)&(0x300<<(k)))==0 \
|| ((dpd)&(((uInt)0x6e)<<(k)))!=(((uInt)0x6e)<<(k)))
/* declet is at offset k (a multiple of 2) in a pair of uInts: */
/* [the top 2 bits will always be in the more-significant uInt] */
#define CANONDPDTWO(hi, lo, k) (((hi)&(0x300>>(32-(k))))==0 \
|| ((hi)&(0x6e>>(32-(k))))!=(0x6e>>(32-(k))) \
|| ((lo)&(((uInt)0x6e)<<(k)))!=(((uInt)0x6e)<<(k)))
/* Macro to test whether a full-length (length DECPMAX) BCD8 */
/* coefficient is zero */
/* test just the LSWord first, then the remainder */
#if DECPMAX==7
#define ISCOEFFZERO(u) (UINTAT((u)+DECPMAX-4)==0 \
&& UINTAT((u)+DECPMAX-7)==0)
#elif DECPMAX==16
#define ISCOEFFZERO(u) (UINTAT((u)+DECPMAX-4)==0 \
&& (UINTAT((u)+DECPMAX-8)+UINTAT((u)+DECPMAX-12) \
+UINTAT((u)+DECPMAX-16))==0)
#elif DECPMAX==34
#define ISCOEFFZERO(u) (UINTAT((u)+DECPMAX-4)==0 \
&& (UINTAT((u)+DECPMAX-8) +UINTAT((u)+DECPMAX-12) \
+UINTAT((u)+DECPMAX-16)+UINTAT((u)+DECPMAX-20) \
+UINTAT((u)+DECPMAX-24)+UINTAT((u)+DECPMAX-28) \
+UINTAT((u)+DECPMAX-32)+USHORTAT((u)+DECPMAX-34))==0)
#endif
/* Macros and masks for the exponent continuation field and MSD */
/* Get the exponent continuation from a decFloat *df as an Int */
#define GETECON(df) ((Int)((DFWORD((df), 0)&0x03ffffff)>>(32-6-DECECONL)))
/* Ditto, from the next-wider format */
#define GETWECON(df) ((Int)((DFWWORD((df), 0)&0x03ffffff)>>(32-6-DECWECONL)))
/* Get the biased exponent similarly */
#define GETEXP(df) ((Int)(DECCOMBEXP[DFWORD((df), 0)>>26]+GETECON(df)))
/* Get the unbiased exponent similarly */
#define GETEXPUN(df) ((Int)GETEXP(df)-DECBIAS)
/* Get the MSD similarly (as uInt) */
#define GETMSD(df) (DECCOMBMSD[DFWORD((df), 0)>>26])
/* Compile-time computes of the exponent continuation field masks */
/* full exponent continuation field: */
#define ECONMASK ((0x03ffffff>>(32-6-DECECONL))<<(32-6-DECECONL))
/* same, not including its first digit (the qNaN/sNaN selector): */
#define ECONNANMASK ((0x01ffffff>>(32-6-DECECONL))<<(32-6-DECECONL))
/* Macros to decode the coefficient in a finite decFloat *df into */
/* a BCD string (uByte *bcdin) of length DECPMAX uBytes */
/* In-line sequence to convert 10 bits at right end of uInt dpd */
/* to three BCD8 digits starting at uByte u. Note that an extra */
/* byte is written to the right of the three digits because this */
/* moves four at a time for speed; the alternative macro moves */
/* exactly three bytes */
#define dpd2bcd8(u, dpd) { \
UINTAT(u)=UINTAT(&DPD2BCD8[((dpd)&0x3ff)*4]);}
#define dpd2bcd83(u, dpd) { \
*(u)=DPD2BCD8[((dpd)&0x3ff)*4]; \
*(u+1)=DPD2BCD8[((dpd)&0x3ff)*4+1]; \
*(u+2)=DPD2BCD8[((dpd)&0x3ff)*4+2];}
/* Decode the declets. After extracting each one, it is decoded */
/* to BCD8 using a table lookup (also used for variable-length */
/* decode). Each DPD decode is 3 bytes BCD8 plus a one-byte */
/* length which is not used, here). Fixed-length 4-byte moves */
/* are fast, however, almost everywhere, and so are used except */
/* for the final three bytes (to avoid overrun). The code below */
/* is 36 instructions for Doubles and about 70 for Quads, even */
/* on IA32. */
/* Two macros are defined for each format: */
/* GETCOEFF extracts the coefficient of the current format */
/* GETWCOEFF extracts the coefficient of the next-wider format. */
/* The latter is a copy of the next-wider GETCOEFF using DFWWORD. */
#if DECPMAX==7
#define GETCOEFF(df, bcd) { \
uInt sourhi=DFWORD(df, 0); \
*(bcd)=(uByte)DECCOMBMSD[sourhi>>26]; \
dpd2bcd8(bcd+1, sourhi>>10); \
dpd2bcd83(bcd+4, sourhi);}
#define GETWCOEFF(df, bcd) { \
uInt sourhi=DFWWORD(df, 0); \
uInt sourlo=DFWWORD(df, 1); \
*(bcd)=(uByte)DECCOMBMSD[sourhi>>26]; \
dpd2bcd8(bcd+1, sourhi>>8); \
dpd2bcd8(bcd+4, (sourhi<<2) | (sourlo>>30)); \
dpd2bcd8(bcd+7, sourlo>>20); \
dpd2bcd8(bcd+10, sourlo>>10); \
dpd2bcd83(bcd+13, sourlo);}
#elif DECPMAX==16
#define GETCOEFF(df, bcd) { \
uInt sourhi=DFWORD(df, 0); \
uInt sourlo=DFWORD(df, 1); \
*(bcd)=(uByte)DECCOMBMSD[sourhi>>26]; \
dpd2bcd8(bcd+1, sourhi>>8); \
dpd2bcd8(bcd+4, (sourhi<<2) | (sourlo>>30)); \
dpd2bcd8(bcd+7, sourlo>>20); \
dpd2bcd8(bcd+10, sourlo>>10); \
dpd2bcd83(bcd+13, sourlo);}
#define GETWCOEFF(df, bcd) { \
uInt sourhi=DFWWORD(df, 0); \
uInt sourmh=DFWWORD(df, 1); \
uInt sourml=DFWWORD(df, 2); \
uInt sourlo=DFWWORD(df, 3); \
*(bcd)=(uByte)DECCOMBMSD[sourhi>>26]; \
dpd2bcd8(bcd+1, sourhi>>4); \
dpd2bcd8(bcd+4, ((sourhi)<<6) | (sourmh>>26)); \
dpd2bcd8(bcd+7, sourmh>>16); \
dpd2bcd8(bcd+10, sourmh>>6); \
dpd2bcd8(bcd+13, ((sourmh)<<4) | (sourml>>28)); \
dpd2bcd8(bcd+16, sourml>>18); \
dpd2bcd8(bcd+19, sourml>>8); \
dpd2bcd8(bcd+22, ((sourml)<<2) | (sourlo>>30)); \
dpd2bcd8(bcd+25, sourlo>>20); \
dpd2bcd8(bcd+28, sourlo>>10); \
dpd2bcd83(bcd+31, sourlo);}
#elif DECPMAX==34
#define GETCOEFF(df, bcd) { \
uInt sourhi=DFWORD(df, 0); \
uInt sourmh=DFWORD(df, 1); \
uInt sourml=DFWORD(df, 2); \
uInt sourlo=DFWORD(df, 3); \
*(bcd)=(uByte)DECCOMBMSD[sourhi>>26]; \
dpd2bcd8(bcd+1, sourhi>>4); \
dpd2bcd8(bcd+4, ((sourhi)<<6) | (sourmh>>26)); \
dpd2bcd8(bcd+7, sourmh>>16); \
dpd2bcd8(bcd+10, sourmh>>6); \
dpd2bcd8(bcd+13, ((sourmh)<<4) | (sourml>>28)); \
dpd2bcd8(bcd+16, sourml>>18); \
dpd2bcd8(bcd+19, sourml>>8); \
dpd2bcd8(bcd+22, ((sourml)<<2) | (sourlo>>30)); \
dpd2bcd8(bcd+25, sourlo>>20); \
dpd2bcd8(bcd+28, sourlo>>10); \
dpd2bcd83(bcd+31, sourlo);}
#define GETWCOEFF(df, bcd) {??} /* [should never be used] */
#endif
/* Macros to decode the coefficient in a finite decFloat *df into */
/* a base-billion uInt array, with the least-significant */
/* 0-999999999 'digit' at offset 0. */
/* Decode the declets. After extracting each one, it is decoded */
/* to binary using a table lookup. Three tables are used; one */
/* the usual DPD to binary, the other two pre-multiplied by 1000 */
/* and 1000000 to avoid multiplication during decode. These */
/* tables can also be used for multiplying up the MSD as the DPD */
/* code for 0 through 9 is the identity. */
#define DPD2BIN0 DPD2BIN /* for prettier code */
#if DECPMAX==7
#define GETCOEFFBILL(df, buf) { \
uInt sourhi=DFWORD(df, 0); \
(buf)[0]=DPD2BIN0[sourhi&0x3ff] \
+DPD2BINK[(sourhi>>10)&0x3ff] \
+DPD2BINM[DECCOMBMSD[sourhi>>26]];}
#elif DECPMAX==16
#define GETCOEFFBILL(df, buf) { \
uInt sourhi, sourlo; \
sourlo=DFWORD(df, 1); \
(buf)[0]=DPD2BIN0[sourlo&0x3ff] \
+DPD2BINK[(sourlo>>10)&0x3ff] \
+DPD2BINM[(sourlo>>20)&0x3ff]; \
sourhi=DFWORD(df, 0); \
(buf)[1]=DPD2BIN0[((sourhi<<2) | (sourlo>>30))&0x3ff] \
+DPD2BINK[(sourhi>>8)&0x3ff] \
+DPD2BINM[DECCOMBMSD[sourhi>>26]];}
#elif DECPMAX==34
#define GETCOEFFBILL(df, buf) { \
uInt sourhi, sourmh, sourml, sourlo; \
sourlo=DFWORD(df, 3); \
(buf)[0]=DPD2BIN0[sourlo&0x3ff] \
+DPD2BINK[(sourlo>>10)&0x3ff] \
+DPD2BINM[(sourlo>>20)&0x3ff]; \
sourml=DFWORD(df, 2); \
(buf)[1]=DPD2BIN0[((sourml<<2) | (sourlo>>30))&0x3ff] \
+DPD2BINK[(sourml>>8)&0x3ff] \
+DPD2BINM[(sourml>>18)&0x3ff]; \
sourmh=DFWORD(df, 1); \
(buf)[2]=DPD2BIN0[((sourmh<<4) | (sourml>>28))&0x3ff] \
+DPD2BINK[(sourmh>>6)&0x3ff] \
+DPD2BINM[(sourmh>>16)&0x3ff]; \
sourhi=DFWORD(df, 0); \
(buf)[3]=DPD2BIN0[((sourhi<<6) | (sourmh>>26))&0x3ff] \
+DPD2BINK[(sourhi>>4)&0x3ff] \
+DPD2BINM[DECCOMBMSD[sourhi>>26]];}
#endif
/* Macros to decode the coefficient in a finite decFloat *df into */
/* a base-thousand uInt array, with the least-significant 0-999 */
/* 'digit' at offset 0. */
/* Decode the declets. After extracting each one, it is decoded */
/* to binary using a table lookup. */
#if DECPMAX==7
#define GETCOEFFTHOU(df, buf) { \
uInt sourhi=DFWORD(df, 0); \
(buf)[0]=DPD2BIN[sourhi&0x3ff]; \
(buf)[1]=DPD2BIN[(sourhi>>10)&0x3ff]; \
(buf)[2]=DECCOMBMSD[sourhi>>26];}
#elif DECPMAX==16
#define GETCOEFFTHOU(df, buf) { \
uInt sourhi, sourlo; \
sourlo=DFWORD(df, 1); \
(buf)[0]=DPD2BIN[sourlo&0x3ff]; \
(buf)[1]=DPD2BIN[(sourlo>>10)&0x3ff]; \
(buf)[2]=DPD2BIN[(sourlo>>20)&0x3ff]; \
sourhi=DFWORD(df, 0); \
(buf)[3]=DPD2BIN[((sourhi<<2) | (sourlo>>30))&0x3ff]; \
(buf)[4]=DPD2BIN[(sourhi>>8)&0x3ff]; \
(buf)[5]=DECCOMBMSD[sourhi>>26];}
#elif DECPMAX==34
#define GETCOEFFTHOU(df, buf) { \
uInt sourhi, sourmh, sourml, sourlo; \
sourlo=DFWORD(df, 3); \
(buf)[0]=DPD2BIN[sourlo&0x3ff]; \
(buf)[1]=DPD2BIN[(sourlo>>10)&0x3ff]; \
(buf)[2]=DPD2BIN[(sourlo>>20)&0x3ff]; \
sourml=DFWORD(df, 2); \
(buf)[3]=DPD2BIN[((sourml<<2) | (sourlo>>30))&0x3ff]; \
(buf)[4]=DPD2BIN[(sourml>>8)&0x3ff]; \
(buf)[5]=DPD2BIN[(sourml>>18)&0x3ff]; \
sourmh=DFWORD(df, 1); \
(buf)[6]=DPD2BIN[((sourmh<<4) | (sourml>>28))&0x3ff]; \
(buf)[7]=DPD2BIN[(sourmh>>6)&0x3ff]; \
(buf)[8]=DPD2BIN[(sourmh>>16)&0x3ff]; \
sourhi=DFWORD(df, 0); \
(buf)[9]=DPD2BIN[((sourhi<<6) | (sourmh>>26))&0x3ff]; \
(buf)[10]=DPD2BIN[(sourhi>>4)&0x3ff]; \
(buf)[11]=DECCOMBMSD[sourhi>>26];}
#endif
/* Set a decFloat to the maximum positive finite number (Nmax) */
#if DECPMAX==7
#define DFSETNMAX(df) \
{DFWORD(df, 0)=0x77f3fcff;}
#elif DECPMAX==16
#define DFSETNMAX(df) \
{DFWORD(df, 0)=0x77fcff3f; \
DFWORD(df, 1)=0xcff3fcff;}
#elif DECPMAX==34
#define DFSETNMAX(df) \
{DFWORD(df, 0)=0x77ffcff3; \
DFWORD(df, 1)=0xfcff3fcf; \
DFWORD(df, 2)=0xf3fcff3f; \
DFWORD(df, 3)=0xcff3fcff;}
#endif
/* [end of format-dependent macros and constants] */
#endif
#else #else
#error decNumberLocal included more than once #error decNumberLocal included more than once
#endif #endif

69
libdecnumber/decNumberSymbols.h Normal file
View File

@ -0,0 +1,69 @@
#if !defined(DECNUMBERSYMBOLS)
#define DECNUMBERSYMBOLS
#ifdef IN_LIBGCC2
#define decNumberAbs __decNumberAbs
#define decNumberAdd __decNumberAdd
#define decNumberAnd __decNumberAnd
#define decNumberClass __decNumberClass
#define decNumberClassToString __decNumberClassToString
#define decNumberCompare __decNumberCompare
#define decNumberCompareSignal __decNumberCompareSignal
#define decNumberCompareTotal __decNumberCompareTotal
#define decNumberCompareTotalMag __decNumberCompareTotalMag
#define decNumberCopy __decNumberCopy
#define decNumberCopyAbs __decNumberCopyAbs
#define decNumberCopyNegate __decNumberCopyNegate
#define decNumberCopySign __decNumberCopySign
#define decNumberDivide __decNumberDivide
#define decNumberDivideInteger __decNumberDivideInteger
#define decNumberExp __decNumberExp
#define decNumberFMA __decNumberFMA
#define decNumberFromInt32 __decNumberFromInt32
#define decNumberFromString __decNumberFromString
#define decNumberFromUInt32 __decNumberFromUInt32
#define decNumberGetBCD __decNumberGetBCD
#define decNumberInvert __decNumberInvert
#define decNumberIsNormal __decNumberIsNormal
#define decNumberIsSubnormal __decNumberIsSubnormal
#define decNumberLn __decNumberLn
#define decNumberLog10 __decNumberLog10
#define decNumberLogB __decNumberLogB
#define decNumberMax __decNumberMax
#define decNumberMaxMag __decNumberMaxMag
#define decNumberMin __decNumberMin
#define decNumberMinMag __decNumberMinMag
#define decNumberMinus __decNumberMinus
#define decNumberMultiply __decNumberMultiply
#define decNumberNextMinus __decNumberNextMinus
#define decNumberNextPlus __decNumberNextPlus
#define decNumberNextToward __decNumberNextToward
#define decNumberNormalize __decNumberNormalize
#define decNumberOr __decNumberOr
#define decNumberPlus __decNumberPlus
#define decNumberPower __decNumberPower
#define decNumberQuantize __decNumberQuantize
#define decNumberReduce __decNumberReduce
#define decNumberRemainder __decNumberRemainder
#define decNumberRemainderNear __decNumberRemainderNear
#define decNumberRescale __decNumberRescale
#define decNumberRotate __decNumberRotate
#define decNumberSameQuantum __decNumberSameQuantum
#define decNumberScaleB __decNumberScaleB
#define decNumberSetBCD __decNumberSetBCD
#define decNumberShift __decNumberShift
#define decNumberSquareRoot __decNumberSquareRoot
#define decNumberSubtract __decNumberSubtract
#define decNumberToEngString __decNumberToEngString
#define decNumberToInt32 __decNumberToInt32
#define decNumberToIntegralExact __decNumberToIntegralExact
#define decNumberToIntegralValue __decNumberToIntegralValue
#define decNumberToString __decNumberToString
#define decNumberToUInt32 __decNumberToUInt32
#define decNumberTrim __decNumberTrim
#define decNumberVersion __decNumberVersion
#define decNumberXor __decNumberXor
#define decNumberZero __decNumberZero
#endif
#endif

235
libdecnumber/decPacked.c Normal file
View File

@ -0,0 +1,235 @@
/* Packed decimal conversion module for the decNumber C Library.
Copyright (C) 2007 Free Software Foundation, Inc.
Contributed by IBM Corporation. Author Mike Cowlishaw.
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2, or (at your option) any later
version.
In addition to the permissions in the GNU General Public License,
the Free Software Foundation gives you unlimited permission to link
the compiled version of this file into combinations with other
programs, and to distribute those combinations without any
restriction coming from the use of this file. (The General Public
License restrictions do apply in other respects; for example, they
cover modification of the file, and distribution when not linked
into a combine executable.)
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA. */
/* ------------------------------------------------------------------ */
/* Packed Decimal conversion module */
/* ------------------------------------------------------------------ */
/* This module comprises the routines for Packed Decimal format */
/* numbers. Conversions are supplied to and from decNumber, which in */
/* turn supports: */
/* conversions to and from string */
/* arithmetic routines */
/* utilities. */
/* Conversions from decNumber to and from densely packed decimal */
/* formats are provided by the decimal32 through decimal128 modules. */
/* ------------------------------------------------------------------ */
#include <string.h> /* for NULL */
#include "decNumber.h" /* base number library */
#include "decPacked.h" /* packed decimal */
#include "decNumberLocal.h" /* decNumber local types, etc. */
/* ------------------------------------------------------------------ */
/* decPackedFromNumber -- convert decNumber to BCD Packed Decimal */
/* */
/* bcd is the BCD bytes */
/* length is the length of the BCD array */
/* scale is the scale result */
/* dn is the decNumber */
/* returns bcd, or NULL if error */
/* */
/* The number is converted to a BCD packed decimal byte array, */
/* right aligned in the bcd array, whose length is indicated by the */
/* second parameter. The final 4-bit nibble in the array will be a */
/* sign nibble, C (1100) for + and D (1101) for -. Unused bytes and */
/* nibbles to the left of the number are set to 0. */
/* */
/* scale is set to the scale of the number (this is the exponent, */
/* negated). To force the number to a specified scale, first use the */
/* decNumberRescale routine, which will round and change the exponent */
/* as necessary. */
/* */
/* If there is an error (that is, the decNumber has too many digits */
/* to fit in length bytes, or it is a NaN or Infinity), NULL is */
/* returned and the bcd and scale results are unchanged. Otherwise */
/* bcd is returned. */
/* ------------------------------------------------------------------ */
uByte * decPackedFromNumber(uByte *bcd, Int length, Int *scale,
const decNumber *dn) {
const Unit *up=dn->lsu; /* Unit array pointer */
uByte obyte, *out; /* current output byte, and where it goes */
Int indigs=dn->digits; /* digits processed */
uInt cut=DECDPUN; /* downcounter per Unit */
uInt u=*up; /* work */
uInt nib; /* .. */
#if DECDPUN<=4
uInt temp; /* .. */
#endif
if (dn->digits>length*2-1 /* too long .. */
||(dn->bits & DECSPECIAL)) return NULL; /* .. or special -- hopeless */
if (dn->bits&DECNEG) obyte=DECPMINUS; /* set the sign .. */
else obyte=DECPPLUS;
*scale=-dn->exponent; /* .. and scale */
/* loop from lowest (rightmost) byte */
out=bcd+length-1; /* -> final byte */
for (; out>=bcd; out--) {
if (indigs>0) {
if (cut==0) {
up++;
u=*up;
cut=DECDPUN;
}
#if DECDPUN<=4
temp=(u*6554)>>16; /* fast /10 */
nib=u-X10(temp);
u=temp;
#else
nib=u%10; /* cannot use *6554 trick :-( */
u=u/10;
#endif
obyte|=(nib<<4);
indigs--;
cut--;
}
*out=obyte;
obyte=0; /* assume 0 */
if (indigs>0) {
if (cut==0) {
up++;
u=*up;
cut=DECDPUN;
}
#if DECDPUN<=4
temp=(u*6554)>>16; /* as above */
obyte=(uByte)(u-X10(temp));
u=temp;
#else
obyte=(uByte)(u%10);
u=u/10;
#endif
indigs--;
cut--;
}
} /* loop */
return bcd;
} /* decPackedFromNumber */
/* ------------------------------------------------------------------ */
/* decPackedToNumber -- convert BCD Packed Decimal to a decNumber */
/* */
/* bcd is the BCD bytes */
/* length is the length of the BCD array */
/* scale is the scale associated with the BCD integer */
/* dn is the decNumber [with space for length*2 digits] */
/* returns dn, or NULL if error */
/* */
/* The BCD packed decimal byte array, together with an associated */
/* scale, is converted to a decNumber. The BCD array is assumed full */
/* of digits, and must be ended by a 4-bit sign nibble in the least */
/* significant four bits of the final byte. */
/* */
/* The scale is used (negated) as the exponent of the decNumber. */
/* Note that zeros may have a sign and/or a scale. */
/* */
/* The decNumber structure is assumed to have sufficient space to */
/* hold the converted number (that is, up to length*2-1 digits), so */
/* no error is possible unless the adjusted exponent is out of range, */
/* no sign nibble was found, or a sign nibble was found before the */
/* final nibble. In these error cases, NULL is returned and the */
/* decNumber will be 0. */
/* ------------------------------------------------------------------ */
decNumber * decPackedToNumber(const uByte *bcd, Int length,
const Int *scale, decNumber *dn) {
const uByte *last=bcd+length-1; /* -> last byte */
const uByte *first; /* -> first non-zero byte */
uInt nib; /* work nibble */
Unit *up=dn->lsu; /* output pointer */
Int digits; /* digits count */
Int cut=0; /* phase of output */
decNumberZero(dn); /* default result */
last=&bcd[length-1];
nib=*last & 0x0f; /* get the sign */
if (nib==DECPMINUS || nib==DECPMINUSALT) dn->bits=DECNEG;
else if (nib<=9) return NULL; /* not a sign nibble */
/* skip leading zero bytes [final byte is always non-zero, due to sign] */
for (first=bcd; *first==0;) first++;
digits=(last-first)*2+1; /* calculate digits .. */
if ((*first & 0xf0)==0) digits--; /* adjust for leading zero nibble */
if (digits!=0) dn->digits=digits; /* count of actual digits [if 0, */
/* leave as 1] */
/* check the adjusted exponent; note that scale could be unbounded */
dn->exponent=-*scale; /* set the exponent */
if (*scale>=0) { /* usual case */
if ((dn->digits-*scale-1)<-DECNUMMAXE) { /* underflow */
decNumberZero(dn);
return NULL;}
}
else { /* -ve scale; +ve exponent */
/* need to be careful to avoid wrap, here, also BADINT case */
if ((*scale<-DECNUMMAXE) /* overflow even without digits */
|| ((dn->digits-*scale-1)>DECNUMMAXE)) { /* overflow */
decNumberZero(dn);
return NULL;}
}
if (digits==0) return dn; /* result was zero */
/* copy the digits to the number's units, starting at the lsu */
/* [unrolled] */
for (;;) { /* forever */
/* left nibble first */
nib=(unsigned)(*last & 0xf0)>>4;
/* got a digit, in nib */
if (nib>9) {decNumberZero(dn); return NULL;}
if (cut==0) *up=(Unit)nib;
else *up=(Unit)(*up+nib*DECPOWERS[cut]);
digits--;
if (digits==0) break; /* got them all */
cut++;
if (cut==DECDPUN) {
up++;
cut=0;
}
last--; /* ready for next */
nib=*last & 0x0f; /* get right nibble */
if (nib>9) {decNumberZero(dn); return NULL;}
/* got a digit, in nib */
if (cut==0) *up=(Unit)nib;
else *up=(Unit)(*up+nib*DECPOWERS[cut]);
digits--;
if (digits==0) break; /* got them all */
cut++;
if (cut==DECDPUN) {
up++;
cut=0;
}
} /* forever */
return dn;
} /* decPackedToNumber */

70
libdecnumber/decPacked.h Normal file
View File

@ -0,0 +1,70 @@
/* Packed decimal conversion module header for the decNumber C Library.
Copyright (C) 2007 Free Software Foundation, Inc.
Contributed by IBM Corporation. Author Mike Cowlishaw.
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2, or (at your option) any later
version.
In addition to the permissions in the GNU General Public License,
the Free Software Foundation gives you unlimited permission to link
the compiled version of this file into combinations with other
programs, and to distribute those combinations without any
restriction coming from the use of this file. (The General Public
License restrictions do apply in other respects; for example, they
cover modification of the file, and distribution when not linked
into a combine executable.)
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA. */
/* ------------------------------------------------------------------ */
/* Packed Decimal conversion module header */
/* ------------------------------------------------------------------ */
#if !defined(DECPACKED)
#define DECPACKED
#define DECPNAME "decPacked" /* Short name */
#define DECPFULLNAME "Packed Decimal conversions" /* Verbose name */
#define DECPAUTHOR "Mike Cowlishaw" /* Who to blame */
#define DECPACKED_DefP 32 /* default precision */
#ifndef DECNUMDIGITS
#define DECNUMDIGITS DECPACKED_DefP /* size if not already defined*/
#endif
#include "decNumber.h" /* context and number library */
/* Sign nibble constants */
#if !defined(DECPPLUSALT)
#define DECPPLUSALT 0x0A /* alternate plus nibble */
#define DECPMINUSALT 0x0B /* alternate minus nibble */
#define DECPPLUS 0x0C /* preferred plus nibble */
#define DECPMINUS 0x0D /* preferred minus nibble */
#define DECPPLUSALT2 0x0E /* alternate plus nibble */
#define DECPUNSIGNED 0x0F /* alternate plus nibble (unsigned) */
#endif
/* ---------------------------------------------------------------- */
/* decPacked public routines */
/* ---------------------------------------------------------------- */
#include "decPackedSymbols.h"
/* Conversions */
uint8_t * decPackedFromNumber(uint8_t *, int32_t, int32_t *,
const decNumber *);
decNumber * decPackedToNumber(const uint8_t *, int32_t, const int32_t *,
decNumber *);
#endif

9
libdecnumber/decPackedSymbols.h Normal file
View File

@ -0,0 +1,9 @@
#if !defined(DECPACKEDSYMBOLS)
#define DECPACKEDSYMBOLS
#ifdef IN_LIBGCC2
#define decPackedFromNumber __decPackedFromNumber
#define decPackedToNumber __decPackedToNumber
#endif
#endif

146
libdecnumber/decQuad.c Normal file
View File

@ -0,0 +1,146 @@
/* decQuad module for the decNumber C Library.
Copyright (C) 2007 Free Software Foundation, Inc.
Contributed by IBM Corporation. Author Mike Cowlishaw.
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2, or (at your option) any later
version.
In addition to the permissions in the GNU General Public License,
the Free Software Foundation gives you unlimited permission to link
the compiled version of this file into combinations with other
programs, and to distribute those combinations without any
restriction coming from the use of this file. (The General Public
License restrictions do apply in other respects; for example, they
cover modification of the file, and distribution when not linked
into a combine executable.)
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA. */
/* ------------------------------------------------------------------ */
/* decQuad.c -- decQuad operations module */
/* ------------------------------------------------------------------ */
/* This module comprises decQuad operations (including conversions) */
/* ------------------------------------------------------------------ */
#include "decContext.h" /* public includes */
#include "decQuad.h" /* .. */
/* Constant mappings for shared code */
#define DECPMAX DECQUAD_Pmax
#define DECEMIN DECQUAD_Emin
#define DECEMAX DECQUAD_Emax
#define DECEMAXD DECQUAD_EmaxD
#define DECBYTES DECQUAD_Bytes
#define DECSTRING DECQUAD_String
#define DECECONL DECQUAD_EconL
#define DECBIAS DECQUAD_Bias
#define DECLETS DECQUAD_Declets
#define DECQTINY (-DECQUAD_Bias)
/* Type and function mappings for shared code */
#define decFloat decQuad /* Type name */
/* Utilities and conversions (binary results, extractors, etc.) */
#define decFloatFromBCD decQuadFromBCD
#define decFloatFromInt32 decQuadFromInt32
#define decFloatFromPacked decQuadFromPacked
#define decFloatFromString decQuadFromString
#define decFloatFromUInt32 decQuadFromUInt32
#define decFloatFromWider decQuadFromWider
#define decFloatGetCoefficient decQuadGetCoefficient
#define decFloatGetExponent decQuadGetExponent
#define decFloatSetCoefficient decQuadSetCoefficient
#define decFloatSetExponent decQuadSetExponent
#define decFloatShow decQuadShow
#define decFloatToBCD decQuadToBCD
#define decFloatToEngString decQuadToEngString
#define decFloatToInt32 decQuadToInt32
#define decFloatToInt32Exact decQuadToInt32Exact
#define decFloatToPacked decQuadToPacked
#define decFloatToString decQuadToString
#define decFloatToUInt32 decQuadToUInt32
#define decFloatToUInt32Exact decQuadToUInt32Exact
#define decFloatToWider decQuadToWider
#define decFloatZero decQuadZero
/* Computational (result is a decFloat) */
#define decFloatAbs decQuadAbs
#define decFloatAdd decQuadAdd
#define decFloatAnd decQuadAnd
#define decFloatDivide decQuadDivide
#define decFloatDivideInteger decQuadDivideInteger
#define decFloatFMA decQuadFMA
#define decFloatInvert decQuadInvert
#define decFloatLogB decQuadLogB
#define decFloatMax decQuadMax
#define decFloatMaxMag decQuadMaxMag
#define decFloatMin decQuadMin
#define decFloatMinMag decQuadMinMag
#define decFloatMinus decQuadMinus
#define decFloatMultiply decQuadMultiply
#define decFloatNextMinus decQuadNextMinus
#define decFloatNextPlus decQuadNextPlus
#define decFloatNextToward decQuadNextToward
#define decFloatOr decQuadOr
#define decFloatPlus decQuadPlus
#define decFloatQuantize decQuadQuantize
#define decFloatReduce decQuadReduce
#define decFloatRemainder decQuadRemainder
#define decFloatRemainderNear decQuadRemainderNear
#define decFloatRotate decQuadRotate
#define decFloatScaleB decQuadScaleB
#define decFloatShift decQuadShift
#define decFloatSubtract decQuadSubtract
#define decFloatToIntegralValue decQuadToIntegralValue
#define decFloatToIntegralExact decQuadToIntegralExact
#define decFloatXor decQuadXor
/* Comparisons */
#define decFloatCompare decQuadCompare
#define decFloatCompareSignal decQuadCompareSignal
#define decFloatCompareTotal decQuadCompareTotal
#define decFloatCompareTotalMag decQuadCompareTotalMag
/* Copies */
#define decFloatCanonical decQuadCanonical
#define decFloatCopy decQuadCopy
#define decFloatCopyAbs decQuadCopyAbs
#define decFloatCopyNegate decQuadCopyNegate
#define decFloatCopySign decQuadCopySign
/* Non-computational */
#define decFloatClass decQuadClass
#define decFloatClassString decQuadClassString
#define decFloatDigits decQuadDigits
#define decFloatIsCanonical decQuadIsCanonical
#define decFloatIsFinite decQuadIsFinite
#define decFloatIsInfinite decQuadIsInfinite
#define decFloatIsInteger decQuadIsInteger
#define decFloatIsNaN decQuadIsNaN
#define decFloatIsNormal decQuadIsNormal
#define decFloatIsSignaling decQuadIsSignaling
#define decFloatIsSignalling decQuadIsSignalling
#define decFloatIsSigned decQuadIsSigned
#define decFloatIsSubnormal decQuadIsSubnormal
#define decFloatIsZero decQuadIsZero
#define decFloatRadix decQuadRadix
#define decFloatSameQuantum decQuadSameQuantum
#define decFloatVersion decQuadVersion
#include "decNumberLocal.h" /* local includes (need DECPMAX) */
#include "decCommon.c" /* non-arithmetic decFloat routines */
#include "decBasic.c" /* basic formats routines */

186
libdecnumber/decQuad.h Normal file
View File

@ -0,0 +1,186 @@
/* decQuad module header for the decNumber C Library.
Copyright (C) 2007 Free Software Foundation, Inc.
Contributed by IBM Corporation. Author Mike Cowlishaw.
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2, or (at your option) any later
version.
In addition to the permissions in the GNU General Public License,
the Free Software Foundation gives you unlimited permission to link
the compiled version of this file into combinations with other
programs, and to distribute those combinations without any
restriction coming from the use of this file. (The General Public
License restrictions do apply in other respects; for example, they
cover modification of the file, and distribution when not linked
into a combine executable.)
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA. */
/* ------------------------------------------------------------------ */
/* decQuad.h -- Decimal 128-bit format module header */
/* ------------------------------------------------------------------ */
/* Please see decFloats.h for an overview and documentation details. */
/* ------------------------------------------------------------------ */
/* This include file is always included by decSingle and decDouble, */
/* and therefore also holds useful constants used by all three. */
#if !defined(DECQUAD)
#define DECQUAD
#define DECQUADNAME "decimalQuad" /* Short name */
#define DECQUADTITLE "Decimal 128-bit datum" /* Verbose name */
#define DECQUADAUTHOR "Mike Cowlishaw" /* Who to blame */
/* parameters for decQuads */
#define DECQUAD_Bytes 16 /* length */
#define DECQUAD_Pmax 34 /* maximum precision (digits) */
#define DECQUAD_Emin -6143 /* minimum adjusted exponent */
#define DECQUAD_Emax 6144 /* maximum adjusted exponent */
#define DECQUAD_EmaxD 4 /* maximum exponent digits */
#define DECQUAD_Bias 6176 /* bias for the exponent */
#define DECQUAD_String 43 /* maximum string length, +1 */
#define DECQUAD_EconL 12 /* exponent continuation length */
#define DECQUAD_Declets 11 /* count of declets */
/* highest biased exponent (Elimit-1) */
#define DECQUAD_Ehigh (DECQUAD_Emax + DECQUAD_Bias - (DECQUAD_Pmax-1))
/* Required include */
#include "decContext.h"
/* The decQuad decimal 128-bit type, accessible by bytes */
typedef struct {
uint8_t bytes[DECQUAD_Bytes]; /* fields: 1, 5, 12, 110 bits */
} decQuad;
/* ---------------------------------------------------------------- */
/* Shared constants */
/* ---------------------------------------------------------------- */
/* sign and special values [top 32-bits; last two bits are don't-care
for Infinity on input, last bit don't-care for NaNs] */
#define DECFLOAT_Sign 0x80000000 /* 1 00000 00 Sign */
#define DECFLOAT_NaN 0x7c000000 /* 0 11111 00 NaN generic */
#define DECFLOAT_qNaN 0x7c000000 /* 0 11111 00 qNaN */
#define DECFLOAT_sNaN 0x7e000000 /* 0 11111 10 sNaN */
#define DECFLOAT_Inf 0x78000000 /* 0 11110 00 Infinity */
#define DECFLOAT_MinSp 0x78000000 /* minimum special value */
/* [specials are all >=MinSp] */
/* Sign nibble constants */
#if !defined(DECPPLUSALT)
#define DECPPLUSALT 0x0A /* alternate plus nibble */
#define DECPMINUSALT 0x0B /* alternate minus nibble */
#define DECPPLUS 0x0C /* preferred plus nibble */
#define DECPMINUS 0x0D /* preferred minus nibble */
#define DECPPLUSALT2 0x0E /* alternate plus nibble */
#define DECPUNSIGNED 0x0F /* alternate plus nibble (unsigned) */
#endif
/* ---------------------------------------------------------------- */
/* Routines -- implemented as decFloat routines in common files */
/* ---------------------------------------------------------------- */
#include "decQuadSymbols.h"
/* Utilities and conversions, extractors, etc.) */
extern decQuad * decQuadFromBCD(decQuad *, int32_t, const uint8_t *, int32_t);
extern decQuad * decQuadFromInt32(decQuad *, int32_t);
extern decQuad * decQuadFromPacked(decQuad *, int32_t, const uint8_t *);
extern decQuad * decQuadFromString(decQuad *, const char *, decContext *);
extern decQuad * decQuadFromUInt32(decQuad *, uint32_t);
extern int32_t decQuadGetCoefficient(const decQuad *, uint8_t *);
extern int32_t decQuadGetExponent(const decQuad *);
extern decQuad * decQuadSetCoefficient(decQuad *, const uint8_t *, int32_t);
extern decQuad * decQuadSetExponent(decQuad *, decContext *, int32_t);
extern void decQuadShow(const decQuad *, const char *);
extern int32_t decQuadToBCD(const decQuad *, int32_t *, uint8_t *);
extern char * decQuadToEngString(const decQuad *, char *);
extern int32_t decQuadToInt32(const decQuad *, decContext *, enum rounding);
extern int32_t decQuadToInt32Exact(const decQuad *, decContext *, enum rounding);
extern int32_t decQuadToPacked(const decQuad *, int32_t *, uint8_t *);
extern char * decQuadToString(const decQuad *, char *);
extern uint32_t decQuadToUInt32(const decQuad *, decContext *, enum rounding);
extern uint32_t decQuadToUInt32Exact(const decQuad *, decContext *, enum rounding);
extern decQuad * decQuadZero(decQuad *);
/* Computational (result is a decQuad) */
extern decQuad * decQuadAbs(decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadAdd(decQuad *, const decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadAnd(decQuad *, const decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadDivide(decQuad *, const decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadDivideInteger(decQuad *, const decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadFMA(decQuad *, const decQuad *, const decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadInvert(decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadLogB(decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadMax(decQuad *, const decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadMaxMag(decQuad *, const decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadMin(decQuad *, const decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadMinMag(decQuad *, const decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadMinus(decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadMultiply(decQuad *, const decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadNextMinus(decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadNextPlus(decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadNextToward(decQuad *, const decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadOr(decQuad *, const decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadPlus(decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadQuantize(decQuad *, const decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadReduce(decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadRemainder(decQuad *, const decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadRemainderNear(decQuad *, const decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadRotate(decQuad *, const decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadScaleB(decQuad *, const decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadShift(decQuad *, const decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadSubtract(decQuad *, const decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadToIntegralValue(decQuad *, const decQuad *, decContext *, enum rounding);
extern decQuad * decQuadToIntegralExact(decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadXor(decQuad *, const decQuad *, const decQuad *, decContext *);
/* Comparisons */
extern decQuad * decQuadCompare(decQuad *, const decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadCompareSignal(decQuad *, const decQuad *, const decQuad *, decContext *);
extern decQuad * decQuadCompareTotal(decQuad *, const decQuad *, const decQuad *);
extern decQuad * decQuadCompareTotalMag(decQuad *, const decQuad *, const decQuad *);
/* Copies */
extern decQuad * decQuadCanonical(decQuad *, const decQuad *);
extern decQuad * decQuadCopy(decQuad *, const decQuad *);
extern decQuad * decQuadCopyAbs(decQuad *, const decQuad *);
extern decQuad * decQuadCopyNegate(decQuad *, const decQuad *);
extern decQuad * decQuadCopySign(decQuad *, const decQuad *, const decQuad *);
/* Non-computational */
extern enum decClass decQuadClass(const decQuad *);
extern const char * decQuadClassString(const decQuad *);
extern uint32_t decQuadDigits(const decQuad *);
extern uint32_t decQuadIsCanonical(const decQuad *);
extern uint32_t decQuadIsFinite(const decQuad *);
extern uint32_t decQuadIsInteger(const decQuad *);
extern uint32_t decQuadIsInfinite(const decQuad *);
extern uint32_t decQuadIsNaN(const decQuad *);
extern uint32_t decQuadIsNormal(const decQuad *);
extern uint32_t decQuadIsSignaling(const decQuad *);
extern uint32_t decQuadIsSignalling(const decQuad *);
extern uint32_t decQuadIsSigned(const decQuad *);
extern uint32_t decQuadIsSubnormal(const decQuad *);
extern uint32_t decQuadIsZero(const decQuad *);
extern uint32_t decQuadRadix(const decQuad *);
extern uint32_t decQuadSameQuantum(const decQuad *, const decQuad *);
extern const char * decQuadVersion(void);
/* decNumber conversions; these are implemented as macros so as not */
/* to force a dependency on decimal128 and decNumber in decQuad. */
#define decQuadToNumber(dq, dn) decimal128ToNumber((decimal128 *)(dq), dn)
#define decQuadFromNumber(dq, dn, set) (decQuad *)decimal128FromNumber((decimal128 *)(dq), dn, set)
#endif

82
libdecnumber/decQuadSymbols.h Normal file
View File

@ -0,0 +1,82 @@
#if !defined(DECQUADSYMBOLS)
#define DECQUADSYMBOLS
#ifdef IN_LIBGCC2
#define decQuadAbs __decQuadAbs
#define decQuadAdd __decQuadAdd
#define decQuadAnd __decQuadAnd
#define decQuadCanonical __decQuadCanonical
#define decQuadClass __decQuadClass
#define decQuadClassString __decQuadClassString
#define decQuadCompare __decQuadCompare
#define decQuadCompareSignal __decQuadCompareSignal
#define decQuadCompareTotal __decQuadCompareTotal
#define decQuadCompareTotalMag __decQuadCompareTotalMag
#define decQuadCopy __decQuadCopy
#define decQuadCopyAbs __decQuadCopyAbs
#define decQuadCopyNegate __decQuadCopyNegate
#define decQuadCopySign __decQuadCopySign
#define decQuadDigits __decQuadDigits
#define decQuadDivide __decQuadDivide
#define decQuadDivideInteger __decQuadDivideInteger
#define decQuadFMA __decQuadFMA
#define decQuadFromBCD __decQuadFromBCD
#define decQuadFromInt32 __decQuadFromInt32
#define decQuadFromPacked __decQuadFromPacked
#define decQuadFromString __decQuadFromString
#define decQuadFromUInt32 __decQuadFromUInt32
#define decQuadGetCoefficient __decQuadGetCoefficient
#define decQuadGetExponent __decQuadGetExponent
#define decQuadInvert __decQuadInvert
#define decQuadIsCanonical __decQuadIsCanonical
#define decQuadIsFinite __decQuadIsFinite
#define decQuadIsInfinite __decQuadIsInfinite
#define decQuadIsInteger __decQuadIsInteger
#define decQuadIsNaN __decQuadIsNaN
#define decQuadIsNormal __decQuadIsNormal
#define decQuadIsSignaling __decQuadIsSignaling
#define decQuadIsSignalling __decQuadIsSignalling
#define decQuadIsSigned __decQuadIsSigned
#define decQuadIsSubnormal __decQuadIsSubnormal
#define decQuadIsZero __decQuadIsZero
#define decQuadLogB __decQuadLogB
#define decQuadMax __decQuadMax
#define decQuadMaxMag __decQuadMaxMag
#define decQuadMin __decQuadMin
#define decQuadMinMag __decQuadMinMag
#define decQuadMinus __decQuadMinus
#define decQuadMultiply __decQuadMultiply
#define decQuadNextMinus __decQuadNextMinus
#define decQuadNextPlus __decQuadNextPlus
#define decQuadNextToward __decQuadNextToward
#define decQuadOr __decQuadOr
#define decQuadPlus __decQuadPlus
#define decQuadQuantize __decQuadQuantize
#define decQuadRadix __decQuadRadix
#define decQuadReduce __decQuadReduce
#define decQuadRemainder __decQuadRemainder
#define decQuadRemainderNear __decQuadRemainderNear
#define decQuadRotate __decQuadRotate
#define decQuadSameQuantum __decQuadSameQuantum
#define decQuadScaleB __decQuadScaleB
#define decQuadSetCoefficient __decQuadSetCoefficient
#define decQuadSetExponent __decQuadSetExponent
#define decQuadShift __decQuadShift
#define decQuadShow __decQuadShow
#define decQuadSubtract __decQuadSubtract
#define decQuadToBCD __decQuadToBCD
#define decQuadToEngString __decQuadToEngString
#define decQuadToInt32 __decQuadToInt32
#define decQuadToInt32Exact __decQuadToInt32Exact
#define decQuadToIntegralExact __decQuadToIntegralExact
#define decQuadToIntegralValue __decQuadToIntegralValue
#define decQuadToPacked __decQuadToPacked
#define decQuadToString __decQuadToString
#define decQuadToUInt32 __decQuadToUInt32
#define decQuadToUInt32Exact __decQuadToUInt32Exact
#define decQuadVersion __decQuadVersion
#define decQuadXor __decQuadXor
#define decQuadZero __decQuadZero
#endif
#endif

85
libdecnumber/decSingle.c Normal file
View File

@ -0,0 +1,85 @@
/* decSingle module for the decNumber C Library.
Copyright (C) 2007 Free Software Foundation, Inc.
Contributed by IBM Corporation. Author Mike Cowlishaw.
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2, or (at your option) any later
version.
In addition to the permissions in the GNU General Public License,
the Free Software Foundation gives you unlimited permission to link
the compiled version of this file into combinations with other
programs, and to distribute those combinations without any
restriction coming from the use of this file. (The General Public
License restrictions do apply in other respects; for example, they
cover modification of the file, and distribution when not linked
into a combine executable.)
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA. */
/* ------------------------------------------------------------------ */
/* decSingle.c -- decSingle operations module */
/* ------------------------------------------------------------------ */
/* This module comprises decSingle operations (including conversions) */
/* ------------------------------------------------------------------ */
#include "decContext.h" /* public includes */
#include "decSingle.h" /* public includes */
/* Constant mappings for shared code */
#define DECPMAX DECSINGLE_Pmax
#define DECEMIN DECSINGLE_Emin
#define DECEMAX DECSINGLE_Emax
#define DECEMAXD DECSINGLE_EmaxD
#define DECBYTES DECSINGLE_Bytes
#define DECSTRING DECSINGLE_String
#define DECECONL DECSINGLE_EconL
#define DECBIAS DECSINGLE_Bias
#define DECLETS DECSINGLE_Declets
#define DECQTINY (-DECSINGLE_Bias)
/* parameters of next-wider format */
#define DECWBYTES DECDOUBLE_Bytes
#define DECWPMAX DECDOUBLE_Pmax
#define DECWECONL DECDOUBLE_EconL
#define DECWBIAS DECDOUBLE_Bias
/* Type and function mappings for shared code */
#define decFloat decSingle /* Type name */
#define decFloatWider decDouble /* Type name */
/* Utility (binary results, extractors, etc.) */
#define decFloatFromBCD decSingleFromBCD
#define decFloatFromPacked decSingleFromPacked
#define decFloatFromString decSingleFromString
#define decFloatFromWider decSingleFromWider
#define decFloatGetCoefficient decSingleGetCoefficient
#define decFloatGetExponent decSingleGetExponent
#define decFloatSetCoefficient decSingleSetCoefficient
#define decFloatSetExponent decSingleSetExponent
#define decFloatShow decSingleShow
#define decFloatToBCD decSingleToBCD
#define decFloatToEngString decSingleToEngString
#define decFloatToPacked decSingleToPacked
#define decFloatToString decSingleToString
#define decFloatToWider decSingleToWider
#define decFloatZero decSingleZero
/* Non-computational */
#define decFloatRadix decSingleRadix
#define decFloatVersion decSingleVersion
#include "decNumberLocal.h" /* local includes (need DECPMAX) */
#include "decCommon.c" /* non-basic decFloat routines */
/* [Do not include decBasic.c for decimal32] */

101
libdecnumber/decSingle.h Normal file
View File

@ -0,0 +1,101 @@
/* decSingle module header for the decNumber C Library.
Copyright (C) 2005 Free Software Foundation, Inc.
Contributed by IBM Corporation. Author Mike Cowlishaw.
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2, or (at your option) any later
version.
In addition to the permissions in the GNU General Public License,
the Free Software Foundation gives you unlimited permission to link
the compiled version of this file into combinations with other
programs, and to distribute those combinations without any
restriction coming from the use of this file. (The General Public
License restrictions do apply in other respects; for example, they
cover modification of the file, and distribution when not linked
into a combine executable.)
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA. */
/* ------------------------------------------------------------------ */
/* decSingle.h -- Decimal 32-bit format module header */
/* ------------------------------------------------------------------ */
/* Please see decFloats.h for an overview and documentation details. */
/* ------------------------------------------------------------------ */
#if !defined(DECSINGLE)
#define DECSINGLE
#define DECSINGLENAME "decSingle" /* Short name */
#define DECSINGLETITLE "Decimal 32-bit datum" /* Verbose name */
#define DECSINGLEAUTHOR "Mike Cowlishaw" /* Who to blame */
/* parameters for decSingles */
#define DECSINGLE_Bytes 4 /* length */
#define DECSINGLE_Pmax 7 /* maximum precision (digits) */
#define DECSINGLE_Emin -95 /* minimum adjusted exponent */
#define DECSINGLE_Emax 96 /* maximum adjusted exponent */
#define DECSINGLE_EmaxD 3 /* maximum exponent digits */
#define DECSINGLE_Bias 101 /* bias for the exponent */
#define DECSINGLE_String 16 /* maximum string length, +1 */
#define DECSINGLE_EconL 6 /* exponent continuation length */
#define DECSINGLE_Declets 2 /* count of declets */
/* highest biased exponent (Elimit-1) */
#define DECSINGLE_Ehigh (DECSINGLE_Emax + DECSINGLE_Bias - (DECSINGLE_Pmax-1))
/* Required includes */
#include "decContext.h"
#include "decQuad.h"
#include "decDouble.h"
/* The decSingle decimal 32-bit type, accessible by bytes */
typedef struct {
uint8_t bytes[DECSINGLE_Bytes]; /* fields: 1, 5, 6, 20 bits */
} decSingle;
/* ---------------------------------------------------------------- */
/* Routines -- implemented as decFloat routines in common files */
/* ---------------------------------------------------------------- */
#include "decSingleSymbols.h"
/* Utilities (binary argument(s) or result, extractors, etc.) */
extern decSingle * decSingleFromBCD(decSingle *, int32_t, const uint8_t *, int32_t);
extern decSingle * decSingleFromPacked(decSingle *, int32_t, const uint8_t *);
extern decSingle * decSingleFromString(decSingle *, const char *, decContext *);
extern decSingle * decSingleFromWider(decSingle *, const decDouble *, decContext *);
extern int32_t decSingleGetCoefficient(const decSingle *, uint8_t *);
extern int32_t decSingleGetExponent(const decSingle *);
extern decSingle * decSingleSetCoefficient(decSingle *, const uint8_t *, int32_t);
extern decSingle * decSingleSetExponent(decSingle *, decContext *, int32_t);
extern void decSingleShow(const decSingle *, const char *);
extern int32_t decSingleToBCD(const decSingle *, int32_t *, uint8_t *);
extern char * decSingleToEngString(const decSingle *, char *);
extern int32_t decSingleToPacked(const decSingle *, int32_t *, uint8_t *);
extern char * decSingleToString(const decSingle *, char *);
extern decDouble * decSingleToWider(const decSingle *, decDouble *);
extern decSingle * decSingleZero(decSingle *);
/* (No Arithmetic routines for decSingle) */
/* Non-computational */
extern uint32_t decSingleRadix(const decSingle *);
extern const char * decSingleVersion(void);
/* decNumber conversions; these are implemented as macros so as not */
/* to force a dependency on decimal32 and decNumber in decSingle. */
#define decSingleToNumber(dq, dn) decimal32ToNumber((decimal32 *)(dq), dn)
#define decSingleFromNumber(dq, dn, set) (decSingle *)decimal32FromNumber((decimal32 *)(dq), dn, set)
#endif

24
libdecnumber/decSingleSymbols.h Normal file
View File

@ -0,0 +1,24 @@
#if !defined(DECSINGLESYMBOLS)
#define DECSINGLESYMBOLS
#ifdef IN_LIBGCC2
#define decSingleFromBCD __decSingleFromBCD
#define decSingleFromPacked __decSingleFromPacked
#define decSingleFromString __decSingleFromString
#define decSingleFromWider __decSingleFromWider
#define decSingleGetCoefficient __decSingleGetCoefficient
#define decSingleGetExponent __decSingleGetExponent
#define decSingleRadix __decSingleRadix
#define decSingleSetCoefficient __decSingleSetCoefficient
#define decSingleSetExponent __decSingleSetExponent
#define decSingleShow __decSingleShow
#define decSingleToBCD __decSingleToBCD
#define decSingleToEngString __decSingleToEngString
#define decSingleToPacked __decSingleToPacked
#define decSingleToString __decSingleToString
#define decSingleToWider __decSingleToWider
#define decSingleVersion __decSingleVersion
#define decSingleZero __decSingleZero
#endif
#endif

360
libdecnumber/decUtility.c
View File

@ -1,360 +0,0 @@
/* Utility functions for decimal floating point support via decNumber.
Copyright (C) 2005 Free Software Foundation, Inc.
Contributed by IBM Corporation. Author Mike Cowlishaw.
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2, or (at your option) any later
version.
In addition to the permissions in the GNU General Public License,
the Free Software Foundation gives you unlimited permission to link
the compiled version of this file into combinations with other
programs, and to distribute those combinations without any
restriction coming from the use of this file. (The General Public
License restrictions do apply in other respects; for example, they
cover modification of the file, and distribution when not linked
into a combine executable.)
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA. */
#include "config.h"
#include "decNumber.h" /* base number library */
#include "decNumberLocal.h" /* decNumber local types, etc. */
#include "decUtility.h" /* utility routines */
/* ================================================================== */
/* Shared utility routines */
/* ================================================================== */
/* define and include the conversion tables to use */
#define DEC_BIN2DPD 1 /* used for all sizes */
#if DECDPUN==3
#define DEC_DPD2BIN 1
#else
#define DEC_DPD2BCD 1
#endif
#include "decDPD.h" /* lookup tables */
/* The maximum number of decNumberUnits we need for a working copy of */
/* the units array is the ceiling of digits/DECDPUN, where digits is */
/* the maximum number of digits in any of the formats for which this */
/* is used. We do not want to include decimal128.h, so, as a very */
/* special case, that number is defined here. */
#define DECMAX754 34
#define DECMAXUNITS ((DECMAX754+DECDPUN-1)/DECDPUN)
/* ------------------------------------------------------------------ */
/* decDensePackCoeff -- densely pack coefficient into DPD form */
/* */
/* dn is the source number (assumed valid, max DECMAX754 digits) */
/* bytes is the target's byte array */
/* len is length of target format's byte array */
/* shift is the number of 0 digits to add on the right (normally 0) */
/* */
/* The coefficient must be known small enough to fit, and is filled */
/* in from the right (least significant first). Note that the full */
/* coefficient is copied, including the leading 'odd' digit. This */
/* digit is retrieved and packed into the combination field by the */
/* caller. */
/* */
/* shift is used for 'fold-down' padding. */
/* */
/* No error is possible. */
/* ------------------------------------------------------------------ */
void
decDensePackCoeff (const decNumber * dn, uByte * bytes, Int len, Int shift)
{
Int cut; /* work */
Int n; /* output bunch counter */
Int digits = dn->digits; /* digit countdown */
uInt dpd; /* densely packed decimal value */
uInt bin; /* binary value 0-999 */
uByte *bout; /* -> current output byte */
const Unit *inu = dn->lsu; /* -> current input unit */
Unit uar[DECMAXUNITS]; /* working copy of units, iff shifted */
#if DECDPUN!=3 /* not fast path */
Unit in; /* current input unit */
#endif
if (shift != 0)
{ /* shift towards most significant required */
/* shift the units array to the left by pad digits and copy */
/* [this code is a special case of decShiftToMost, which could */
/* be used instead if exposed and the array were copied first] */
Unit *target, *first; /* work */
const Unit *source; /* work */
uInt next = 0; /* work */
source = dn->lsu + D2U (digits) - 1; /* where msu comes from */
first = uar + D2U (digits + shift) - 1; /* where msu will end up */
target = uar + D2U (digits) - 1 + D2U (shift); /* where upper part of first cut goes */
cut = (DECDPUN - shift % DECDPUN) % DECDPUN;
for (; source >= dn->lsu; source--, target--)
{
/* split the source Unit and accumulate remainder for next */
uInt rem = *source % powers[cut];
next += *source / powers[cut];
if (target <= first)
*target = (Unit) next; /* write to target iff valid */
next = rem * powers[DECDPUN - cut]; /* save remainder for next Unit */
}
/* propagate remainder to one below and clear the rest */
for (; target >= uar; target--)
{
*target = (Unit) next;
next = 0;
}
digits += shift; /* add count (shift) of zeros added */
inu = uar; /* use units in working array */
}
/* densely pack the coefficient into the byte array, starting from
the right (optionally padded) */
bout = &bytes[len - 1]; /* rightmost result byte for phase */
#if DECDPUN!=3 /* not fast path */
in = *inu; /* prime */
cut = 0; /* at lowest digit */
bin = 0; /* [keep compiler quiet] */
#endif
for (n = 0; digits > 0; n++)
{ /* each output bunch */
#if DECDPUN==3 /* fast path, 3-at-a-time */
bin = *inu; /* 3 ready for convert */
digits -= 3; /* [may go negative] */
inu++; /* may need another */
#else /* must collect digit-by-digit */
Unit dig; /* current digit */
Int j; /* digit-in-bunch count */
for (j = 0; j < 3; j++)
{
#if DECDPUN<=4
Unit temp = (Unit) ((uInt) (in * 6554) >> 16);
dig = (Unit) (in - X10 (temp));
in = temp;
#else
dig = in % 10;
in = in / 10;
#endif
if (j == 0)
bin = dig;
else if (j == 1)
bin += X10 (dig);
else /* j==2 */
bin += X100 (dig);
digits--;
if (digits == 0)
break; /* [also protects *inu below] */
cut++;
if (cut == DECDPUN)
{
inu++;
in = *inu;
cut = 0;
}
}
#endif
/* here we have 3 digits in bin, or have used all input digits */
dpd = BIN2DPD[bin];
/* write bunch (bcd) to byte array */
switch (n & 0x03)
{ /* phase 0-3 */
case 0:
*bout = (uByte) dpd; /* [top 2 bits truncated] */
bout--;
*bout = (uByte) (dpd >> 8);
break;
case 1:
*bout |= (uByte) (dpd << 2);
bout--;
*bout = (uByte) (dpd >> 6);
break;
case 2:
*bout |= (uByte) (dpd << 4);
bout--;
*bout = (uByte) (dpd >> 4);
break;
case 3:
*bout |= (uByte) (dpd << 6);
bout--;
*bout = (uByte) (dpd >> 2);
bout--;
break;
} /* switch */
} /* n bunches */
return;
}
/* ------------------------------------------------------------------ */
/* decDenseUnpackCoeff -- unpack a format's coefficient */
/* */
/* byte is the source's byte array */
/* len is length of the source's byte array */
/* dn is the target number, with 7, 16, or 34-digit space. */
/* bunches is the count of DPD groups in the decNumber (2, 5, or 11)*/
/* odd is 1 if there is a non-zero leading 10-bit group containing */
/* a single digit, 0 otherwise */
/* */
/* (This routine works on a copy of the number, if necessary, where */
/* an extra 10-bit group is prefixed to the coefficient continuation */
/* to hold the most significant digit if the latter is non-0.) */
/* */
/* dn->digits is set, but not the sign or exponent. */
/* No error is possible [the redundant 888 codes are allowed]. */
/* ------------------------------------------------------------------ */
void
decDenseUnpackCoeff (const uByte * bytes, Int len, decNumber * dn,
Int bunches, Int odd)
{
uInt dpd = 0; /* collector for 10 bits */
Int n; /* counter */
const uByte *bin; /* -> current input byte */
Unit *uout = dn->lsu; /* -> current output unit */
Unit out = 0; /* accumulator */
Int cut = 0; /* power of ten in current unit */
Unit *last = uout; /* will be unit containing msd */
#if DECDPUN!=3
uInt bcd; /* BCD result */
uInt nibble; /* work */
#endif
/* Expand the densely-packed integer, right to left */
bin = &bytes[len - 1]; /* next input byte to use */
for (n = 0; n < bunches + odd; n++)
{ /* N bunches of 10 bits */
/* assemble the 10 bits */
switch (n & 0x03)
{ /* phase 0-3 */
case 0:
dpd = *bin;
bin--;
dpd |= (*bin & 0x03) << 8;
break;
case 1:
dpd = (unsigned) *bin >> 2;
bin--;
dpd |= (*bin & 0x0F) << 6;
break;
case 2:
dpd = (unsigned) *bin >> 4;
bin--;
dpd |= (*bin & 0x3F) << 4;
break;
case 3:
dpd = (unsigned) *bin >> 6;
bin--;
dpd |= (*bin) << 2;
bin--;
break;
} /*switch */
#if DECDPUN==3
if (dpd == 0)
*uout = 0;
else
{
*uout = DPD2BIN[dpd]; /* convert 10 bits to binary 0-999 */
last = uout; /* record most significant unit */
}
uout++;
#else /* DECDPUN!=3 */
if (dpd == 0)
{ /* fastpath [e.g., leading zeros] */
cut += 3;
for (; cut >= DECDPUN;)
{
cut -= DECDPUN;
*uout = out;
uout++;
out = 0;
}
continue;
}
bcd = DPD2BCD[dpd]; /* convert 10 bits to 12 bits BCD */
/* now split the 3 BCD nibbles into bytes, and accumulate into units */
/* If this is the last bunch and it is an odd one, we only have one */
/* nibble to handle [extras could overflow a Unit] */
nibble = bcd & 0x000f;
if (nibble)
{
last = uout;
out = (Unit) (out + nibble * powers[cut]);
}
cut++;
if (cut == DECDPUN)
{
*uout = out;
uout++;
cut = 0;
out = 0;
}
if (n < bunches)
{
nibble = bcd & 0x00f0;
if (nibble)
{
nibble >>= 4;
last = uout;
out = (Unit) (out + nibble * powers[cut]);
}
cut++;
if (cut == DECDPUN)
{
*uout = out;
uout++;
cut = 0;
out = 0;
}
nibble = bcd & 0x0f00;
if (nibble)
{
nibble >>= 8;
last = uout;
out = (Unit) (out + nibble * powers[cut]);
}
cut++;
if (cut == DECDPUN)
{
*uout = out;
uout++;
cut = 0;
out = 0;
}
}
#endif
} /* n */
if (cut != 0)
*uout = out; /* write out final unit */
/* here, last points to the most significant unit with digits */
/* we need to inspect it to get final digits count */
dn->digits = (last - dn->lsu) * DECDPUN; /* floor of digits */
for (cut = 0; cut < DECDPUN; cut++)
{
if (*last < powers[cut])
break;
dn->digits++;
}
if (dn->digits == 0)
dn->digits++; /* zero has one digit */
return;
}

719
libdecnumber/dpd/decimal128.c
View File

@ -1,5 +1,5 @@
/* Decimal 128-bit format module from the decNumber C Library. /* Decimal 128-bit format module for the decNumber C Library.
Copyright (C) 2005 Free Software Foundation, Inc. Copyright (C) 2005, 2007 Free Software Foundation, Inc.
Contributed by IBM Corporation. Author Mike Cowlishaw. Contributed by IBM Corporation. Author Mike Cowlishaw.
This file is part of GCC. This file is part of GCC.
@ -29,26 +29,41 @@
02110-1301, USA. */ 02110-1301, USA. */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
/* This module comprises the routines for decimal128 format numbers. */ /* Decimal 128-bit format module */
/* Conversions are supplied to and from decNumber and String. */
/* */
/* No arithmetic routines are included; decNumber provides these. */
/* */
/* Error handling is the same as decNumber (qv.). */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
#include <string.h> /* [for memset/memcpy] */ /* This module comprises the routines for decimal128 format numbers. */
#include <stdio.h> /* [for printf] */ /* Conversions are supplied to and from decNumber and String. */
/* */
/* This is used when decNumber provides operations, either for all */
/* operations or as a proxy between decNumber and decSingle. */
/* */
/* Error handling is the same as decNumber (qv.). */
/* ------------------------------------------------------------------ */
#include <string.h> /* [for memset/memcpy] */
#include <stdio.h> /* [for printf] */
#define DECNUMDIGITS 34 /* we need decNumbers with space for 34 */ #include "config.h" /* GCC definitions */
#include "config.h" #define DECNUMDIGITS 34 /* make decNumbers with space for 34 */
#include "decNumber.h" /* base number library */ #include "decNumber.h" /* base number library */
#include "decNumberLocal.h" /* decNumber local types, etc. */ #include "decNumberLocal.h" /* decNumber local types, etc. */
#include "decimal128.h" /* our primary include */ #include "decimal128.h" /* our primary include */
#include "decUtility.h" /* utility routines */
/* Utility routines and tables [in decimal64.c] */
/* DPD2BIN and the reverse are renamed to prevent link-time conflict */
/* if decQuad is also built in the same executable */
#define DPD2BIN DPD2BINx
#define BIN2DPD BIN2DPDx
extern const uInt COMBEXP[32], COMBMSD[32];
extern const uShort DPD2BIN[1024];
extern const uShort BIN2DPD[1000]; /* [not used] */
extern const uByte BIN2CHAR[4001];
extern void decDigitsFromDPD(decNumber *, const uInt *, Int);
extern void decDigitsToDPD(const decNumber *, uInt *, Int);
#if DECTRACE || DECCHECK #if DECTRACE || DECCHECK
void decimal128Show (const decimal128 *); /* for debug */ void decimal128Show(const decimal128 *); /* for debug */
void decNumberShow (const decNumber *); /* .. */ extern void decNumberShow(const decNumber *); /* .. */
#endif #endif
/* Useful macro */ /* Useful macro */
@ -56,292 +71,500 @@ void decNumberShow (const decNumber *); /* .. */
#define DEC_clear(d) memset(d, 0, sizeof(*d)) #define DEC_clear(d) memset(d, 0, sizeof(*d))
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
/* decimal128FromNumber -- convert decNumber to decimal128 */ /* decimal128FromNumber -- convert decNumber to decimal128 */
/* */ /* */
/* ds is the target decimal128 */ /* ds is the target decimal128 */
/* dn is the source number (assumed valid) */ /* dn is the source number (assumed valid) */
/* set is the context, used only for reporting errors */ /* set is the context, used only for reporting errors */
/* */ /* */
/* The set argument is used only for status reporting and for the */ /* The set argument is used only for status reporting and for the */
/* rounding mode (used if the coefficient is more than DECIMAL128_Pmax*/ /* rounding mode (used if the coefficient is more than DECIMAL128_Pmax*/
/* digits or an overflow is detected). If the exponent is out of the */ /* digits or an overflow is detected). If the exponent is out of the */
/* valid range then Overflow or Underflow will be raised. */ /* valid range then Overflow or Underflow will be raised. */
/* After Underflow a subnormal result is possible. */ /* After Underflow a subnormal result is possible. */
/* */ /* */
/* DEC_Clamped is set if the number has to be 'folded down' to fit, */ /* DEC_Clamped is set if the number has to be 'folded down' to fit, */
/* by reducing its exponent and multiplying the coefficient by a */ /* by reducing its exponent and multiplying the coefficient by a */
/* power of ten, or if the exponent on a zero had to be clamped. */ /* power of ten, or if the exponent on a zero had to be clamped. */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
decimal128 * decimal128 * decimal128FromNumber(decimal128 *d128, const decNumber *dn,
decimal128FromNumber (decimal128 * d128, const decNumber * dn, decContext * set) decContext *set) {
{ uInt status=0; /* status accumulator */
uInt status = 0; /* status accumulator */ Int ae; /* adjusted exponent */
Int pad = 0; /* coefficient pad digits */ decNumber dw; /* work */
decNumber dw; /* work */ decContext dc; /* .. */
decContext dc; /* .. */ uInt *pu; /* .. */
uByte isneg = dn->bits & DECNEG; /* non-0 if original sign set */ uInt comb, exp; /* .. */
uInt comb, exp; /* work */ uInt targar[4]={0,0,0,0}; /* target 128-bit */
#define targhi targar[3] /* name the word with the sign */
#define targmh targar[2] /* name the words */
#define targml targar[1] /* .. */
#define targlo targar[0] /* .. */
/* If the number is finite, and has too many digits, or the exponent */ /* If the number has too many digits, or the exponent could be */
/* could be out of range then we reduce the number under the */ /* out of range then reduce the number under the appropriate */
/* appropriate constraints */ /* constraints. This could push the number to Infinity or zero, */
if (!(dn->bits & DECSPECIAL)) /* so this check and rounding must be done before generating the */
{ /* not a special value */ /* decimal128] */
Int ae = dn->exponent + dn->digits - 1; /* adjusted exponent */ ae=dn->exponent+dn->digits-1; /* [0 if special] */
if (dn->digits > DECIMAL128_Pmax /* too many digits */ if (dn->digits>DECIMAL128_Pmax /* too many digits */
|| ae > DECIMAL128_Emax /* likely overflow */ || ae>DECIMAL128_Emax /* likely overflow */
|| ae < DECIMAL128_Emin) || ae<DECIMAL128_Emin) { /* likely underflow */
{ /* likely underflow */ decContextDefault(&dc, DEC_INIT_DECIMAL128); /* [no traps] */
decContextDefault (&dc, DEC_INIT_DECIMAL128); /* [no traps] */ dc.round=set->round; /* use supplied rounding */
dc.round = set->round; /* use supplied rounding */ decNumberPlus(&dw, dn, &dc); /* (round and check) */
decNumberPlus (&dw, dn, &dc); /* (round and check) */ /* [this changes -0 to 0, so enforce the sign...] */
/* [this changes -0 to 0, but it will be restored below] */ dw.bits|=dn->bits&DECNEG;
status |= dc.status; /* save status */ status=dc.status; /* save status */
dn = &dw; /* use the work number */ dn=&dw; /* use the work number */
} } /* maybe out of range */
/* [this could have pushed number to Infinity or zero, so this */
/* rounding must be done before we generate the decimal128] */
}
DEC_clear (d128); /* clean the target */ if (dn->bits&DECSPECIAL) { /* a special value */
if (dn->bits & DECSPECIAL) if (dn->bits&DECINF) targhi=DECIMAL_Inf<<24;
{ /* a special value */ else { /* sNaN or qNaN */
uByte top; /* work */ if ((*dn->lsu!=0 || dn->digits>1) /* non-zero coefficient */
if (dn->bits & DECINF) && (dn->digits<DECIMAL128_Pmax)) { /* coefficient fits */
top = DECIMAL_Inf; decDigitsToDPD(dn, targar, 0);
else
{ /* sNaN or qNaN */
if ((*dn->lsu != 0 || dn->digits > 1) /* non-zero coefficient */
&& (dn->digits < DECIMAL128_Pmax))
{ /* coefficient fits */
decDensePackCoeff (dn, d128->bytes, sizeof (d128->bytes), 0);
}
if (dn->bits & DECNAN)
top = DECIMAL_NaN;
else
top = DECIMAL_sNaN;
} }
d128->bytes[0] = top; if (dn->bits&DECNAN) targhi|=DECIMAL_NaN<<24;
} else targhi|=DECIMAL_sNaN<<24;
else if (decNumberIsZero (dn)) } /* a NaN */
{ /* a zero */ } /* special */
else { /* is finite */
if (decNumberIsZero(dn)) { /* is a zero */
/* set and clamp exponent */ /* set and clamp exponent */
if (dn->exponent < -DECIMAL128_Bias) if (dn->exponent<-DECIMAL128_Bias) {
{ exp=0; /* low clamp */
exp = 0; status|=DEC_Clamped;
status |= DEC_Clamped;
} }
else else {
{ exp=dn->exponent+DECIMAL128_Bias; /* bias exponent */
exp = dn->exponent + DECIMAL128_Bias; /* bias exponent */ if (exp>DECIMAL128_Ehigh) { /* top clamp */
if (exp > DECIMAL128_Ehigh) exp=DECIMAL128_Ehigh;
{ /* top clamp */ status|=DEC_Clamped;
exp = DECIMAL128_Ehigh; }
status |= DEC_Clamped;
}
} }
comb = (exp >> 9) & 0x18; /* combination field */ comb=(exp>>9) & 0x18; /* msd=0, exp top 2 bits .. */
d128->bytes[0] = (uByte) (comb << 2); }
exp &= 0xfff; /* remaining exponent bits */ else { /* non-zero finite number */
decimal128SetExpCon (d128, exp); uInt msd; /* work */
} Int pad=0; /* coefficient pad digits */
else
{ /* non-zero finite number */
uInt msd; /* work */
/* we have a dn that fits, but it may need to be padded */ /* the dn is known to fit, but it may need to be padded */
exp = (uInt) (dn->exponent + DECIMAL128_Bias); /* bias exponent */ exp=(uInt)(dn->exponent+DECIMAL128_Bias); /* bias exponent */
if (exp>DECIMAL128_Ehigh) { /* fold-down case */
if (exp > DECIMAL128_Ehigh) pad=exp-DECIMAL128_Ehigh;
{ /* fold-down case */ exp=DECIMAL128_Ehigh; /* [to maximum] */
pad = exp - DECIMAL128_Ehigh; status|=DEC_Clamped;
exp = DECIMAL128_Ehigh; /* [to maximum] */
status |= DEC_Clamped;
} }
decDensePackCoeff (dn, d128->bytes, sizeof (d128->bytes), pad); /* [fastpath for common case is not a win, here] */
decDigitsToDPD(dn, targar, pad);
/* save and clear the top digit */ /* save and clear the top digit */
msd = ((unsigned) d128->bytes[1] << 2) & 0x0c; /* top 2 bits */ msd=targhi>>14;
msd |= ((unsigned) d128->bytes[2] >> 6); /* low 2 bits */ targhi&=0x00003fff;
d128->bytes[1] &= 0xfc;
d128->bytes[2] &= 0x3f;
/* create the combination field */ /* create the combination field */
if (msd >= 8) if (msd>=8) comb=0x18 | ((exp>>11) & 0x06) | (msd & 0x01);
comb = 0x18 | (msd & 0x01) | ((exp >> 11) & 0x06); else comb=((exp>>9) & 0x18) | msd;
else }
comb = (msd & 0x07) | ((exp >> 9) & 0x18); targhi|=comb<<26; /* add combination field .. */
d128->bytes[0] = (uByte) (comb << 2); targhi|=(exp&0xfff)<<14; /* .. and exponent continuation */
exp &= 0xfff; /* remaining exponent bits */ } /* finite */
decimal128SetExpCon (d128, exp);
if (dn->bits&DECNEG) targhi|=0x80000000; /* add sign bit */
/* now write to storage; this is endian */
pu=(uInt *)d128->bytes; /* overlay */
if (DECLITEND) {
pu[0]=targlo; /* directly store the low int */
pu[1]=targml; /* then the mid-low */
pu[2]=targmh; /* then the mid-high */
pu[3]=targhi; /* then the high int */
}
else {
pu[0]=targhi; /* directly store the high int */
pu[1]=targmh; /* then the mid-high */
pu[2]=targml; /* then the mid-low */
pu[3]=targlo; /* then the low int */
} }
if (isneg) if (status!=0) decContextSetStatus(set, status); /* pass on status */
decimal128SetSign (d128, 1);
if (status != 0)
decContextSetStatus (set, status); /* pass on status */
/* decimal128Show(d128); */ /* decimal128Show(d128); */
return d128; return d128;
} } /* decimal128FromNumber */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
/* decimal128ToNumber -- convert decimal128 to decNumber */ /* decimal128ToNumber -- convert decimal128 to decNumber */
/* d128 is the source decimal128 */ /* d128 is the source decimal128 */
/* dn is the target number, with appropriate space */ /* dn is the target number, with appropriate space */
/* No error is possible. */ /* No error is possible. */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
decNumber * decNumber * decimal128ToNumber(const decimal128 *d128, decNumber *dn) {
decimal128ToNumber (const decimal128 * d128, decNumber * dn) uInt msd; /* coefficient MSD */
{ uInt exp; /* exponent top two bits */
uInt msd; /* coefficient MSD */ uInt comb; /* combination field */
decimal128 wk; /* working copy, if needed */ const uInt *pu; /* work */
uInt top = d128->bytes[0] & 0x7f; /* top byte, less sign bit */ Int need; /* .. */
decNumberZero (dn); /* clean target */ uInt sourar[4]; /* source 128-bit */
/* set the sign if negative */ #define sourhi sourar[3] /* name the word with the sign */
if (decimal128Sign (d128)) #define sourmh sourar[2] /* and the mid-high word */
dn->bits = DECNEG; #define sourml sourar[1] /* and the mod-low word */
#define sourlo sourar[0] /* and the lowest word */
if (top >= 0x78) /* load source from storage; this is endian */
{ /* is a special */ pu=(const uInt *)d128->bytes; /* overlay */
if ((top & 0x7c) == (DECIMAL_Inf & 0x7c)) if (DECLITEND) {
dn->bits |= DECINF; sourlo=pu[0]; /* directly load the low int */
else if ((top & 0x7e) == (DECIMAL_NaN & 0x7e)) sourml=pu[1]; /* then the mid-low */
dn->bits |= DECNAN; sourmh=pu[2]; /* then the mid-high */
else sourhi=pu[3]; /* then the high int */
dn->bits |= DECSNAN;
msd = 0; /* no top digit */
} }
else else {
{ /* have a finite number */ sourhi=pu[0]; /* directly load the high int */
uInt comb = top >> 2; /* combination field */ sourmh=pu[1]; /* then the mid-high */
uInt exp; /* exponent */ sourml=pu[2]; /* then the mid-low */
sourlo=pu[3]; /* then the low int */
if (comb >= 0x18)
{
msd = 8 + (comb & 0x01);
exp = (comb & 0x06) << 11; /* MSBs */
}
else
{
msd = comb & 0x07;
exp = (comb & 0x18) << 9;
}
dn->exponent = exp + decimal128ExpCon (d128) - DECIMAL128_Bias; /* remove bias */
} }
/* get the coefficient, unless infinite */ comb=(sourhi>>26)&0x1f; /* combination field */
if (!(dn->bits & DECINF))
{ decNumberZero(dn); /* clean number */
Int bunches = DECIMAL128_Pmax / 3; /* coefficient full bunches to convert */ if (sourhi&0x80000000) dn->bits=DECNEG; /* set sign if negative */
Int odd = 0; /* assume MSD is 0 (no odd bunch) */
if (msd != 0) msd=COMBMSD[comb]; /* decode the combination field */
{ /* coefficient has leading non-0 digit */ exp=COMBEXP[comb]; /* .. */
/* make a copy of the decimal128, with an extra bunch which has */
/* the top digit ready for conversion */ if (exp==3) { /* is a special */
wk = *d128; /* take a copy */ if (msd==0) {
wk.bytes[0] = 0; /* clear all but coecon */ dn->bits|=DECINF;
wk.bytes[1] = 0; /* .. */ return dn; /* no coefficient needed */
wk.bytes[2] &= 0x3f; /* .. */ }
wk.bytes[1] |= (msd >> 2); /* and prefix MSD */ else if (sourhi&0x02000000) dn->bits|=DECSNAN;
wk.bytes[2] |= (msd << 6); /* .. */ else dn->bits|=DECNAN;
odd++; /* indicate the extra */ msd=0; /* no top digit */
d128 = &wk; /* use the work copy */ }
} else { /* is a finite number */
decDenseUnpackCoeff (d128->bytes, sizeof (d128->bytes), dn, bunches, dn->exponent=(exp<<12)+((sourhi>>14)&0xfff)-DECIMAL128_Bias; /* unbiased */
odd);
} }
/* get the coefficient */
sourhi&=0x00003fff; /* clean coefficient continuation */
if (msd) { /* non-zero msd */
sourhi|=msd<<14; /* prefix to coefficient */
need=12; /* process 12 declets */
}
else { /* msd=0 */
if (sourhi) need=11; /* declets to process */
else if (sourmh) need=10;
else if (sourml) need=7;
else if (sourlo) need=4;
else return dn; /* easy: coefficient is 0 */
} /*msd=0 */
decDigitsFromDPD(dn, sourar, need); /* process declets */
/* decNumberShow(dn); */ /* decNumberShow(dn); */
return dn; return dn;
} } /* decimal128ToNumber */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
/* to-scientific-string -- conversion to numeric string */ /* to-scientific-string -- conversion to numeric string */
/* to-engineering-string -- conversion to numeric string */ /* to-engineering-string -- conversion to numeric string */
/* */ /* */
/* decimal128ToString(d128, string); */ /* decimal128ToString(d128, string); */
/* decimal128ToEngString(d128, string); */ /* decimal128ToEngString(d128, string); */
/* */ /* */
/* d128 is the decimal128 format number to convert */ /* d128 is the decimal128 format number to convert */
/* string is the string where the result will be laid out */ /* string is the string where the result will be laid out */
/* */ /* */
/* string must be at least 24 characters */ /* string must be at least 24 characters */
/* */ /* */
/* No error is possible, and no status can be set. */ /* No error is possible, and no status can be set. */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
char * char * decimal128ToEngString(const decimal128 *d128, char *string){
decimal128ToString (const decimal128 * d128, char *string) decNumber dn; /* work */
{ decimal128ToNumber(d128, &dn);
decNumber dn; /* work */ decNumberToEngString(&dn, string);
decimal128ToNumber (d128, &dn);
decNumberToString (&dn, string);
return string; return string;
} } /* decimal128ToEngString */
char * char * decimal128ToString(const decimal128 *d128, char *string){
decimal128ToEngString (const decimal128 * d128, char *string) uInt msd; /* coefficient MSD */
{ Int exp; /* exponent top two bits or full */
decNumber dn; /* work */ uInt comb; /* combination field */
decimal128ToNumber (d128, &dn); char *cstart; /* coefficient start */
decNumberToEngString (&dn, string); char *c; /* output pointer in string */
const uInt *pu; /* work */
char *s, *t; /* .. (source, target) */
Int dpd; /* .. */
Int pre, e; /* .. */
const uByte *u; /* .. */
uInt sourar[4]; /* source 128-bit */
#define sourhi sourar[3] /* name the word with the sign */
#define sourmh sourar[2] /* and the mid-high word */
#define sourml sourar[1] /* and the mod-low word */
#define sourlo sourar[0] /* and the lowest word */
/* load source from storage; this is endian */
pu=(const uInt *)d128->bytes; /* overlay */
if (DECLITEND) {
sourlo=pu[0]; /* directly load the low int */
sourml=pu[1]; /* then the mid-low */
sourmh=pu[2]; /* then the mid-high */
sourhi=pu[3]; /* then the high int */
}
else {
sourhi=pu[0]; /* directly load the high int */
sourmh=pu[1]; /* then the mid-high */
sourml=pu[2]; /* then the mid-low */
sourlo=pu[3]; /* then the low int */
}
c=string; /* where result will go */
if (((Int)sourhi)<0) *c++='-'; /* handle sign */
comb=(sourhi>>26)&0x1f; /* combination field */
msd=COMBMSD[comb]; /* decode the combination field */
exp=COMBEXP[comb]; /* .. */
if (exp==3) {
if (msd==0) { /* infinity */
strcpy(c, "Inf");
strcpy(c+3, "inity");
return string; /* easy */
}
if (sourhi&0x02000000) *c++='s'; /* sNaN */
strcpy(c, "NaN"); /* complete word */
c+=3; /* step past */
if (sourlo==0 && sourml==0 && sourmh==0
&& (sourhi&0x0003ffff)==0) return string; /* zero payload */
/* otherwise drop through to add integer; set correct exp */
exp=0; msd=0; /* setup for following code */
}
else exp=(exp<<12)+((sourhi>>14)&0xfff)-DECIMAL128_Bias; /* unbiased */
/* convert 34 digits of significand to characters */
cstart=c; /* save start of coefficient */
if (msd) *c++='0'+(char)msd; /* non-zero most significant digit */
/* Now decode the declets. After extracting each one, it is */
/* decoded to binary and then to a 4-char sequence by table lookup; */
/* the 4-chars are a 1-char length (significant digits, except 000 */
/* has length 0). This allows us to left-align the first declet */
/* with non-zero content, then remaining ones are full 3-char */
/* length. We use fixed-length memcpys because variable-length */
/* causes a subroutine call in GCC. (These are length 4 for speed */
/* and are safe because the array has an extra terminator byte.) */
#define dpd2char u=&BIN2CHAR[DPD2BIN[dpd]*4]; \
if (c!=cstart) {memcpy(c, u+1, 4); c+=3;} \
else if (*u) {memcpy(c, u+4-*u, 4); c+=*u;}
dpd=(sourhi>>4)&0x3ff; /* declet 1 */
dpd2char;
dpd=((sourhi&0xf)<<6) | (sourmh>>26); /* declet 2 */
dpd2char;
dpd=(sourmh>>16)&0x3ff; /* declet 3 */
dpd2char;
dpd=(sourmh>>6)&0x3ff; /* declet 4 */
dpd2char;
dpd=((sourmh&0x3f)<<4) | (sourml>>28); /* declet 5 */
dpd2char;
dpd=(sourml>>18)&0x3ff; /* declet 6 */
dpd2char;
dpd=(sourml>>8)&0x3ff; /* declet 7 */
dpd2char;
dpd=((sourml&0xff)<<2) | (sourlo>>30); /* declet 8 */
dpd2char;
dpd=(sourlo>>20)&0x3ff; /* declet 9 */
dpd2char;
dpd=(sourlo>>10)&0x3ff; /* declet 10 */
dpd2char;
dpd=(sourlo)&0x3ff; /* declet 11 */
dpd2char;
if (c==cstart) *c++='0'; /* all zeros -- make 0 */
if (exp==0) { /* integer or NaN case -- easy */
*c='\0'; /* terminate */
return string;
}
/* non-0 exponent */
e=0; /* assume no E */
pre=c-cstart+exp;
/* [here, pre-exp is the digits count (==1 for zero)] */
if (exp>0 || pre<-5) { /* need exponential form */
e=pre-1; /* calculate E value */
pre=1; /* assume one digit before '.' */
} /* exponential form */
/* modify the coefficient, adding 0s, '.', and E+nn as needed */
s=c-1; /* source (LSD) */
if (pre>0) { /* ddd.ddd (plain), perhaps with E */
char *dotat=cstart+pre;
if (dotat<c) { /* if embedded dot needed... */
t=c; /* target */
for (; s>=dotat; s--, t--) *t=*s; /* open the gap; leave t at gap */
*t='.'; /* insert the dot */
c++; /* length increased by one */
}
/* finally add the E-part, if needed; it will never be 0, and has */
/* a maximum length of 4 digits */
if (e!=0) {
*c++='E'; /* starts with E */
*c++='+'; /* assume positive */
if (e<0) {
*(c-1)='-'; /* oops, need '-' */
e=-e; /* uInt, please */
}
if (e<1000) { /* 3 (or fewer) digits case */
u=&BIN2CHAR[e*4]; /* -> length byte */
memcpy(c, u+4-*u, 4); /* copy fixed 4 characters [is safe] */
c+=*u; /* bump pointer appropriately */
}
else { /* 4-digits */
Int thou=((e>>3)*1049)>>17; /* e/1000 */
Int rem=e-(1000*thou); /* e%1000 */
*c++='0'+(char)thou;
u=&BIN2CHAR[rem*4]; /* -> length byte */
memcpy(c, u+1, 4); /* copy fixed 3+1 characters [is safe] */
c+=3; /* bump pointer, always 3 digits */
}
}
*c='\0'; /* add terminator */
/*printf("res %s\n", string); */
return string;
} /* pre>0 */
/* -5<=pre<=0: here for plain 0.ddd or 0.000ddd forms (can never have E) */
t=c+1-pre;
*(t+1)='\0'; /* can add terminator now */
for (; s>=cstart; s--, t--) *t=*s; /* shift whole coefficient right */
c=cstart;
*c++='0'; /* always starts with 0. */
*c++='.';
for (; pre<0; pre++) *c++='0'; /* add any 0's after '.' */
/*printf("res %s\n", string); */
return string; return string;
} } /* decimal128ToString */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
/* to-number -- conversion from numeric string */ /* to-number -- conversion from numeric string */
/* */ /* */
/* decimal128FromString(result, string, set); */ /* decimal128FromString(result, string, set); */
/* */ /* */
/* result is the decimal128 format number which gets the result of */ /* result is the decimal128 format number which gets the result of */
/* the conversion */ /* the conversion */
/* *string is the character string which should contain a valid */ /* *string is the character string which should contain a valid */
/* number (which may be a special value) */ /* number (which may be a special value) */
/* set is the context */ /* set is the context */
/* */ /* */
/* The context is supplied to this routine is used for error handling */ /* The context is supplied to this routine is used for error handling */
/* (setting of status and traps) and for the rounding mode, only. */ /* (setting of status and traps) and for the rounding mode, only. */
/* If an error occurs, the result will be a valid decimal128 NaN. */ /* If an error occurs, the result will be a valid decimal128 NaN. */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
decimal128 * decimal128 * decimal128FromString(decimal128 *result, const char *string,
decimal128FromString (decimal128 * result, const char *string, decContext * set) decContext *set) {
{ decContext dc; /* work */
decContext dc; /* work */ decNumber dn; /* .. */
decNumber dn; /* .. */
decContextDefault (&dc, DEC_INIT_DECIMAL128); /* no traps, please */ decContextDefault(&dc, DEC_INIT_DECIMAL128); /* no traps, please */
dc.round = set->round; /* use supplied rounding */ dc.round=set->round; /* use supplied rounding */
decNumberFromString (&dn, string, &dc); /* will round if needed */ decNumberFromString(&dn, string, &dc); /* will round if needed */
decimal128FromNumber (result, &dn, &dc); decimal128FromNumber(result, &dn, &dc);
if (dc.status != 0) if (dc.status!=0) { /* something happened */
{ /* something happened */ decContextSetStatus(set, dc.status); /* .. pass it on */
decContextSetStatus (set, dc.status); /* .. pass it on */
} }
return result; return result;
} } /* decimal128FromString */
/* ------------------------------------------------------------------ */
/* decimal128IsCanonical -- test whether encoding is canonical */
/* d128 is the source decimal128 */
/* returns 1 if the encoding of d128 is canonical, 0 otherwise */
/* No error is possible. */
/* ------------------------------------------------------------------ */
uint32_t decimal128IsCanonical(const decimal128 *d128) {
decNumber dn; /* work */
decimal128 canon; /* .. */
decContext dc; /* .. */
decContextDefault(&dc, DEC_INIT_DECIMAL128);
decimal128ToNumber(d128, &dn);
decimal128FromNumber(&canon, &dn, &dc);/* canon will now be canonical */
return memcmp(d128, &canon, DECIMAL128_Bytes)==0;
} /* decimal128IsCanonical */
/* ------------------------------------------------------------------ */
/* decimal128Canonical -- copy an encoding, ensuring it is canonical */
/* d128 is the source decimal128 */
/* result is the target (may be the same decimal128) */
/* returns result */
/* No error is possible. */
/* ------------------------------------------------------------------ */
decimal128 * decimal128Canonical(decimal128 *result, const decimal128 *d128) {
decNumber dn; /* work */
decContext dc; /* .. */
decContextDefault(&dc, DEC_INIT_DECIMAL128);
decimal128ToNumber(d128, &dn);
decimal128FromNumber(result, &dn, &dc);/* result will now be canonical */
return result;
} /* decimal128Canonical */
#if DECTRACE || DECCHECK #if DECTRACE || DECCHECK
/* Macros for accessing decimal128 fields. These assume the argument
is a reference (pointer) to the decimal128 structure, and the
decimal128 is in network byte order (big-endian) */
/* Get sign */
#define decimal128Sign(d) ((unsigned)(d)->bytes[0]>>7)
/* Get combination field */
#define decimal128Comb(d) (((d)->bytes[0] & 0x7c)>>2)
/* Get exponent continuation [does not remove bias] */
#define decimal128ExpCon(d) ((((d)->bytes[0] & 0x03)<<10) \
| ((unsigned)(d)->bytes[1]<<2) \
| ((unsigned)(d)->bytes[2]>>6))
/* Set sign [this assumes sign previously 0] */
#define decimal128SetSign(d, b) { \
(d)->bytes[0]|=((unsigned)(b)<<7);}
/* Set exponent continuation [does not apply bias] */
/* This assumes range has been checked and exponent previously 0; */
/* type of exponent must be unsigned */
#define decimal128SetExpCon(d, e) { \
(d)->bytes[0]|=(uint8_t)((e)>>10); \
(d)->bytes[1] =(uint8_t)(((e)&0x3fc)>>2); \
(d)->bytes[2]|=(uint8_t)(((e)&0x03)<<6);}
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
/* decimal128Show -- display a single in hexadecimal [debug aid] */ /* decimal128Show -- display a decimal128 in hexadecimal [debug aid] */
/* d128 -- the number to show */ /* d128 -- the number to show */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
/* Also shows sign/cob/expconfields extracted */ /* Also shows sign/cob/expconfields extracted */
void void decimal128Show(const decimal128 *d128) {
decimal128Show (const decimal128 * d128) char buf[DECIMAL128_Bytes*2+1];
{ Int i, j=0;
char buf[DECIMAL128_Bytes * 2 + 1];
Int i, j; if (DECLITEND) {
j = 0; for (i=0; i<DECIMAL128_Bytes; i++, j+=2) {
for (i = 0; i < DECIMAL128_Bytes; i++) sprintf(&buf[j], "%02x", d128->bytes[15-i]);
{ }
sprintf (&buf[j], "%02x", d128->bytes[i]); printf(" D128> %s [S:%d Cb:%02x Ec:%02x] LittleEndian\n", buf,
j = j + 2; d128->bytes[15]>>7, (d128->bytes[15]>>2)&0x1f,
((d128->bytes[15]&0x3)<<10)|(d128->bytes[14]<<2)|
(d128->bytes[13]>>6));
} }
printf (" D128> %s [S:%d Cb:%02x E:%d]\n", buf, else {
decimal128Sign (d128), decimal128Comb (d128), for (i=0; i<DECIMAL128_Bytes; i++, j+=2) {
decimal128ExpCon (d128)); sprintf(&buf[j], "%02x", d128->bytes[i]);
} }
printf(" D128> %s [S:%d Cb:%02x Ec:%02x] BigEndian\n", buf,
decimal128Sign(d128), decimal128Comb(d128),
decimal128ExpCon(d128));
}
} /* decimal128Show */
#endif #endif

145
libdecnumber/dpd/decimal128.h
View File

@ -1,5 +1,5 @@
/* Decimal 128-bit format module header for the decNumber C Library /* Decimal 128-bit format module header for the decNumber C Library.
Copyright (C) 2005 Free Software Foundation, Inc. Copyright (C) 2005, 2007 Free Software Foundation, Inc.
Contributed by IBM Corporation. Author Mike Cowlishaw. Contributed by IBM Corporation. Author Mike Cowlishaw.
This file is part of GCC. This file is part of GCC.
@ -28,103 +28,74 @@
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA. */ 02110-1301, USA. */
#if !defined(DECIMAL128) /* ------------------------------------------------------------------ */
#define DECIMAL128 /* Decimal 128-bit format module header */
#define DEC128NAME "decimal128" /* Short name */ /* ------------------------------------------------------------------ */
#define DEC128FULLNAME "Decimal 128-bit Number" /* Verbose name */
#define DEC128AUTHOR "Mike Cowlishaw" /* Who to blame */
#if defined(DECIMAL32) #if !defined(DECIMAL128)
#error decimal128.h must precede decimal32.h for correct DECNUMDIGITS #define DECIMAL128
#else #define DEC128NAME "decimal128" /* Short name */
#if defined(DECIMAL64) #define DEC128FULLNAME "Decimal 128-bit Number" /* Verbose name */
#error decimal128.h must precede decimal64.h for correct DECNUMDIGITS #define DEC128AUTHOR "Mike Cowlishaw" /* Who to blame */
#endif
#endif
/* parameters for decimal128s */ /* parameters for decimal128s */
#define DECIMAL128_Bytes 16 /* length */ #define DECIMAL128_Bytes 16 /* length */
#define DECIMAL128_Pmax 34 /* maximum precision (digits) */ #define DECIMAL128_Pmax 34 /* maximum precision (digits) */
#define DECIMAL128_Emax 6144 /* maximum adjusted exponent */ #define DECIMAL128_Emax 6144 /* maximum adjusted exponent */
#define DECIMAL128_Emin -6143 /* minimum adjusted exponent */ #define DECIMAL128_Emin -6143 /* minimum adjusted exponent */
#define DECIMAL128_Bias 6176 /* bias for the exponent */ #define DECIMAL128_Bias 6176 /* bias for the exponent */
#define DECIMAL128_String 43 /* maximum string length, +1 */ #define DECIMAL128_String 43 /* maximum string length, +1 */
/* highest biased exponent (Elimit-1) */ #define DECIMAL128_EconL 12 /* exp. continuation length */
#define DECIMAL128_Ehigh (DECIMAL128_Emax+DECIMAL128_Bias-DECIMAL128_Pmax+1) /* highest biased exponent (Elimit-1) */
#define DECIMAL128_Ehigh (DECIMAL128_Emax+DECIMAL128_Bias-DECIMAL128_Pmax+1)
#ifndef DECNUMDIGITS /* check enough digits, if pre-defined */
#define DECNUMDIGITS DECIMAL128_Pmax /* size if not already defined */ #if defined(DECNUMDIGITS)
#endif #if (DECNUMDIGITS<DECIMAL128_Pmax)
#ifndef DECNUMBER #error decimal128.h needs pre-defined DECNUMDIGITS>=34 for safe use
#include "decNumber.h" /* context and number library */ #endif
#endif #endif
/* Decimal 128-bit type, accessible by bytes */ #ifndef DECNUMDIGITS
typedef struct #define DECNUMDIGITS DECIMAL128_Pmax /* size if not already defined*/
{ #endif
uint8_t bytes[DECIMAL128_Bytes]; /* decimal128: 1, 5, 12, 110 bits */ #ifndef DECNUMBER
} decimal128; #include "decNumber.h" /* context and number library */
#endif
/* special values [top byte excluding sign bit; last two bits are /* Decimal 128-bit type, accessible by bytes */
don't-care for Infinity on input, last bit don't-care for NaN] */ typedef struct {
#if !defined(DECIMAL_NaN) uint8_t bytes[DECIMAL128_Bytes]; /* decimal128: 1, 5, 12, 110 bits*/
#define DECIMAL_NaN 0x7c /* 0 11111 00 NaN */ } decimal128;
#define DECIMAL_sNaN 0x7e /* 0 11111 10 sNaN */
#define DECIMAL_Inf 0x78 /* 0 11110 00 Infinity */
#endif
/* Macros for accessing decimal128 fields. These assume the argument /* special values [top byte excluding sign bit; last two bits are */
is a reference (pointer) to the decimal128 structure */ /* don't-care for Infinity on input, last bit don't-care for NaN] */
/* Get sign */ #if !defined(DECIMAL_NaN)
#define decimal128Sign(d) ((unsigned)(d)->bytes[0]>>7) #define DECIMAL_NaN 0x7c /* 0 11111 00 NaN */
#define DECIMAL_sNaN 0x7e /* 0 11111 10 sNaN */
#define DECIMAL_Inf 0x78 /* 0 11110 00 Infinity */
#endif
/* Get combination field */ #include "decimal128Local.h"
#define decimal128Comb(d) (((d)->bytes[0] & 0x7c)>>2)
/* Get exponent continuation [does not remove bias] */ /* ---------------------------------------------------------------- */
#define decimal128ExpCon(d) ((((d)->bytes[0] & 0x03)<<10) \ /* Routines */
| ((unsigned)(d)->bytes[1]<<2) \ /* ---------------------------------------------------------------- */
| ((unsigned)(d)->bytes[2]>>6))
/* Set sign [this assumes sign previously 0] */ #include "decimal128Symbols.h"
#define decimal128SetSign(d, b) { \
(d)->bytes[0]|=((unsigned)(b)<<7);}
/* Clear sign */ /* String conversions */
#define decimal128ClearSign(d) {(d)->bytes[0]&=~0x80;} decimal128 * decimal128FromString(decimal128 *, const char *, decContext *);
char * decimal128ToString(const decimal128 *, char *);
char * decimal128ToEngString(const decimal128 *, char *);
/* Flip sign */ /* decNumber conversions */
#define decimal128FlipSign(d) {(d)->bytes[0]^=0x80;} decimal128 * decimal128FromNumber(decimal128 *, const decNumber *,
decContext *);
decNumber * decimal128ToNumber(const decimal128 *, decNumber *);
/* Set exponent continuation [does not apply bias] */ /* Format-dependent utilities */
/* This assumes range has been checked and exponent previously 0; */ uint32_t decimal128IsCanonical(const decimal128 *);
/* type of exponent must be unsigned */ decimal128 * decimal128Canonical(decimal128 *, const decimal128 *);
#define decimal128SetExpCon(d, e) { \
(d)->bytes[0]|=(uint8_t)((e)>>10); \
(d)->bytes[1] =(uint8_t)(((e)&0x3fc)>>2); \
(d)->bytes[2]|=(uint8_t)(((e)&0x03)<<6);}
/* ------------------------------------------------------------------ */
/* Routines */
/* ------------------------------------------------------------------ */
#ifdef IN_LIBGCC2
#ifndef decimal128FromString
#define decimal128FromString __decimal128FromString
#define decimal128ToString __decimal128ToString
#define decimal128ToEngString __decimal128ToEngString
#define decimal128FromNumber __decimal128FromNumber
#define decimal128ToNumber __decimal128ToNumber
#endif
#endif
/* String conversions */
decimal128 *decimal128FromString (decimal128 *, const char *, decContext *);
char *decimal128ToString (const decimal128 *, char *);
char *decimal128ToEngString (const decimal128 *, char *);
/* decNumber conversions */
decimal128 *decimal128FromNumber (decimal128 *, const decNumber *, decContext *);
decNumber *decimal128ToNumber (const decimal128 *, decNumber *);
#endif #endif

28
libdecnumber/decUtility.h → libdecnumber/dpd/decimal128Local.h
View File

@ -1,6 +1,5 @@
/* Utility functions for decimal floating point support via decNumber. /* Local definitions for use with the decNumber C Library.
Copyright (C) 2005 Free Software Foundation, Inc. Copyright (C) 2007 Free Software Foundation, Inc.
Contributed by IBM Corporation. Author Mike Cowlishaw.
This file is part of GCC. This file is part of GCC.
@ -28,10 +27,21 @@
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA. */ 02110-1301, USA. */
#ifdef IN_LIBGCC2 #if !defined(DECIMAL128LOCAL)
#define decDensePackCoeff __decDensePackCoeff
#define decDenseUnpackCoeff __decDenseUnpackCoeff
#endif
extern void decDensePackCoeff (const decNumber *, uByte *, Int, Int); /* The compiler needs sign manipulation functions for decimal128 which
extern void decDenseUnpackCoeff (const uByte *, Int, decNumber *, Int, Int); are not part of the decNumber package. */
/* Set sign; this assumes the sign was previously zero. */
#define decimal128SetSign(d,b) \
{ (d)->bytes[FLOAT_WORDS_BIG_ENDIAN ? 0 : 15] |= ((unsigned) (b) << 7); }
/* Clear sign. */
#define decimal128ClearSign(d) \
{ (d)->bytes[FLOAT_WORDS_BIG_ENDIAN ? 0 : 15] &= ~0x80; }
/* Flip sign. */
#define decimal128FlipSign(d) \
{ (d)->bytes[FLOAT_WORDS_BIG_ENDIAN ? 0 : 15] ^= 0x80; }
#endif

16
libdecnumber/dpd/decimal128Symbols.h Normal file
View File

@ -0,0 +1,16 @@
#if !defined(DECIMAL128SYMBOLS)
#define DECIMAL128SYMBOLS
#ifdef IN_LIBGCC2
#define decDigitsFromDPD __decDigitsFromDPD
#define decDigitsToDPD __decDigitsToDPD
#define decimal128Canonical __decimal128Canonical
#define decimal128FromNumber __decimal128FromNumber
#define decimal128FromString __decimal128FromString
#define decimal128IsCanonical __decimal128IsCanonical
#define decimal128ToEngString __decimal128ToEngString
#define decimal128ToNumber __decimal128ToNumber
#define decimal128ToString __decimal128ToString
#endif
#endif

646
libdecnumber/dpd/decimal32.c
View File

@ -1,5 +1,5 @@
/* Decimal 32-bit format module for the decNumber C Library /* Decimal 32-bit format module for the decNumber C Library.
Copyright (C) 2005 Free Software Foundation, Inc. Copyright (C) 2005, 2007 Free Software Foundation, Inc.
Contributed by IBM Corporation. Author Mike Cowlishaw. Contributed by IBM Corporation. Author Mike Cowlishaw.
This file is part of GCC. This file is part of GCC.
@ -29,26 +29,41 @@
02110-1301, USA. */ 02110-1301, USA. */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
/* This module comprises the routines for decimal32 format numbers. */ /* Decimal 32-bit format module */
/* Conversions are supplied to and from decNumber and String. */
/* */
/* No arithmetic routines are included; decNumber provides these. */
/* */
/* Error handling is the same as decNumber (qv.). */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
#include <string.h> /* [for memset/memcpy] */ /* This module comprises the routines for decimal32 format numbers. */
#include <stdio.h> /* [for printf] */ /* Conversions are supplied to and from decNumber and String. */
/* */
/* This is used when decNumber provides operations, either for all */
/* operations or as a proxy between decNumber and decSingle. */
/* */
/* Error handling is the same as decNumber (qv.). */
/* ------------------------------------------------------------------ */
#include <string.h> /* [for memset/memcpy] */
#include <stdio.h> /* [for printf] */
#define DECNUMDIGITS 7 /* we need decNumbers with space for 7 */ #include "config.h" /* GCC definitions */
#include "config.h" #define DECNUMDIGITS 7 /* make decNumbers with space for 7 */
#include "decNumber.h" /* base number library */ #include "decNumber.h" /* base number library */
#include "decNumberLocal.h" /* decNumber local types, etc. */ #include "decNumberLocal.h" /* decNumber local types, etc. */
#include "decimal32.h" /* our primary include */ #include "decimal32.h" /* our primary include */
#include "decUtility.h" /* utility routines */
/* Utility tables and routines [in decimal64.c] */
/* DPD2BIN and the reverse are renamed to prevent link-time conflict */
/* if decQuad is also built in the same executable */
#define DPD2BIN DPD2BINx
#define BIN2DPD BIN2DPDx
extern const uInt COMBEXP[32], COMBMSD[32];
extern const uShort DPD2BIN[1024];
extern const uShort BIN2DPD[1000];
extern const uByte BIN2CHAR[4001];
extern void decDigitsToDPD(const decNumber *, uInt *, Int);
extern void decDigitsFromDPD(decNumber *, const uInt *, Int);
#if DECTRACE || DECCHECK #if DECTRACE || DECCHECK
void decimal32Show (const decimal32 *); /* for debug */ void decimal32Show(const decimal32 *); /* for debug */
void decNumberShow (const decNumber *); /* .. */ extern void decNumberShow(const decNumber *); /* .. */
#endif #endif
/* Useful macro */ /* Useful macro */
@ -56,282 +71,425 @@ void decNumberShow (const decNumber *); /* .. */
#define DEC_clear(d) memset(d, 0, sizeof(*d)) #define DEC_clear(d) memset(d, 0, sizeof(*d))
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
/* decimal32FromNumber -- convert decNumber to decimal32 */ /* decimal32FromNumber -- convert decNumber to decimal32 */
/* */ /* */
/* ds is the target decimal32 */ /* ds is the target decimal32 */
/* dn is the source number (assumed valid) */ /* dn is the source number (assumed valid) */
/* set is the context, used only for reporting errors */ /* set is the context, used only for reporting errors */
/* */ /* */
/* The set argument is used only for status reporting and for the */ /* The set argument is used only for status reporting and for the */
/* rounding mode (used if the coefficient is more than DECIMAL32_Pmax */ /* rounding mode (used if the coefficient is more than DECIMAL32_Pmax */
/* digits or an overflow is detected). If the exponent is out of the */ /* digits or an overflow is detected). If the exponent is out of the */
/* valid range then Overflow or Underflow will be raised. */ /* valid range then Overflow or Underflow will be raised. */
/* After Underflow a subnormal result is possible. */ /* After Underflow a subnormal result is possible. */
/* */ /* */
/* DEC_Clamped is set if the number has to be 'folded down' to fit, */ /* DEC_Clamped is set if the number has to be 'folded down' to fit, */
/* by reducing its exponent and multiplying the coefficient by a */ /* by reducing its exponent and multiplying the coefficient by a */
/* power of ten, or if the exponent on a zero had to be clamped. */ /* power of ten, or if the exponent on a zero had to be clamped. */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
decimal32 * decimal32 * decimal32FromNumber(decimal32 *d32, const decNumber *dn,
decimal32FromNumber (decimal32 * d32, const decNumber * dn, decContext * set) decContext *set) {
{ uInt status=0; /* status accumulator */
uInt status = 0; /* status accumulator */ Int ae; /* adjusted exponent */
Int pad = 0; /* coefficient pad digits */ decNumber dw; /* work */
decNumber dw; /* work */ decContext dc; /* .. */
decContext dc; /* .. */ uInt *pu; /* .. */
uByte isneg = dn->bits & DECNEG; /* non-0 if original sign set */ uInt comb, exp; /* .. */
uInt comb, exp; /* work */ uInt targ=0; /* target 32-bit */
/* If the number is finite, and has too many digits, or the exponent */ /* If the number has too many digits, or the exponent could be */
/* could be out of range then we reduce the number under the */ /* out of range then reduce the number under the appropriate */
/* appropriate constraints */ /* constraints. This could push the number to Infinity or zero, */
if (!(dn->bits & DECSPECIAL)) /* so this check and rounding must be done before generating the */
{ /* not a special value */ /* decimal32] */
Int ae = dn->exponent + dn->digits - 1; /* adjusted exponent */ ae=dn->exponent+dn->digits-1; /* [0 if special] */
if (dn->digits > DECIMAL32_Pmax /* too many digits */ if (dn->digits>DECIMAL32_Pmax /* too many digits */
|| ae > DECIMAL32_Emax /* likely overflow */ || ae>DECIMAL32_Emax /* likely overflow */
|| ae < DECIMAL32_Emin) || ae<DECIMAL32_Emin) { /* likely underflow */
{ /* likely underflow */ decContextDefault(&dc, DEC_INIT_DECIMAL32); /* [no traps] */
decContextDefault (&dc, DEC_INIT_DECIMAL32); /* [no traps] */ dc.round=set->round; /* use supplied rounding */
dc.round = set->round; /* use supplied rounding */ decNumberPlus(&dw, dn, &dc); /* (round and check) */
decNumberPlus (&dw, dn, &dc); /* (round and check) */ /* [this changes -0 to 0, so enforce the sign...] */
/* [this changes -0 to 0, but it will be restored below] */ dw.bits|=dn->bits&DECNEG;
status |= dc.status; /* save status */ status=dc.status; /* save status */
dn = &dw; /* use the work number */ dn=&dw; /* use the work number */
} } /* maybe out of range */
/* [this could have pushed number to Infinity or zero, so this */
/* rounding must be done before we generate the decimal32] */
}
DEC_clear (d32); /* clean the target */ if (dn->bits&DECSPECIAL) { /* a special value */
if (dn->bits & DECSPECIAL) if (dn->bits&DECINF) targ=DECIMAL_Inf<<24;
{ /* a special value */ else { /* sNaN or qNaN */
uByte top; /* work */ if ((*dn->lsu!=0 || dn->digits>1) /* non-zero coefficient */
if (dn->bits & DECINF) && (dn->digits<DECIMAL32_Pmax)) { /* coefficient fits */
top = DECIMAL_Inf; decDigitsToDPD(dn, &targ, 0);
else
{ /* sNaN or qNaN */
if ((*dn->lsu != 0 || dn->digits > 1) /* non-zero coefficient */
&& (dn->digits < DECIMAL32_Pmax))
{ /* coefficient fits */
decDensePackCoeff (dn, d32->bytes, sizeof (d32->bytes), 0);
}
if (dn->bits & DECNAN)
top = DECIMAL_NaN;
else
top = DECIMAL_sNaN;
} }
d32->bytes[0] = top; if (dn->bits&DECNAN) targ|=DECIMAL_NaN<<24;
} else targ|=DECIMAL_sNaN<<24;
else if (decNumberIsZero (dn)) } /* a NaN */
{ /* a zero */ } /* special */
else { /* is finite */
if (decNumberIsZero(dn)) { /* is a zero */
/* set and clamp exponent */ /* set and clamp exponent */
if (dn->exponent < -DECIMAL32_Bias) if (dn->exponent<-DECIMAL32_Bias) {
{ exp=0; /* low clamp */
exp = 0; status|=DEC_Clamped;
status |= DEC_Clamped;
} }
else else {
{ exp=dn->exponent+DECIMAL32_Bias; /* bias exponent */
exp = dn->exponent + DECIMAL32_Bias; /* bias exponent */ if (exp>DECIMAL32_Ehigh) { /* top clamp */
if (exp > DECIMAL32_Ehigh) exp=DECIMAL32_Ehigh;
{ /* top clamp */ status|=DEC_Clamped;
exp = DECIMAL32_Ehigh; }
status |= DEC_Clamped;
}
} }
comb = (exp >> 3) & 0x18; /* combination field */ comb=(exp>>3) & 0x18; /* msd=0, exp top 2 bits .. */
d32->bytes[0] = (uByte) (comb << 2); }
exp &= 0x3f; /* remaining exponent bits */ else { /* non-zero finite number */
decimal32SetExpCon (d32, exp); uInt msd; /* work */
} Int pad=0; /* coefficient pad digits */
else
{ /* non-zero finite number */
uInt msd; /* work */
/* we have a dn that fits, but it may need to be padded */ /* the dn is known to fit, but it may need to be padded */
exp = (uInt) (dn->exponent + DECIMAL32_Bias); /* bias exponent */ exp=(uInt)(dn->exponent+DECIMAL32_Bias); /* bias exponent */
if (exp>DECIMAL32_Ehigh) { /* fold-down case */
if (exp > DECIMAL32_Ehigh) pad=exp-DECIMAL32_Ehigh;
{ /* fold-down case */ exp=DECIMAL32_Ehigh; /* [to maximum] */
pad = exp - DECIMAL32_Ehigh; status|=DEC_Clamped;
exp = DECIMAL32_Ehigh; /* [to maximum] */
status |= DEC_Clamped;
} }
decDensePackCoeff (dn, d32->bytes, sizeof (d32->bytes), pad); /* fastpath common case */
if (DECDPUN==3 && pad==0) {
targ=BIN2DPD[dn->lsu[0]];
if (dn->digits>3) targ|=(uInt)(BIN2DPD[dn->lsu[1]])<<10;
msd=(dn->digits==7 ? dn->lsu[2] : 0);
}
else { /* general case */
decDigitsToDPD(dn, &targ, pad);
/* save and clear the top digit */
msd=targ>>20;
targ&=0x000fffff;
}
/* save and clear the top digit */
msd = ((unsigned) d32->bytes[1] >> 4);
d32->bytes[1] &= 0x0f;
/* create the combination field */ /* create the combination field */
if (msd >= 8) if (msd>=8) comb=0x18 | ((exp>>5) & 0x06) | (msd & 0x01);
comb = 0x18 | (msd & 0x01) | ((exp >> 5) & 0x06); else comb=((exp>>3) & 0x18) | msd;
else }
comb = (msd & 0x07) | ((exp >> 3) & 0x18); targ|=comb<<26; /* add combination field .. */
d32->bytes[0] = (uByte) (comb << 2); targ|=(exp&0x3f)<<20; /* .. and exponent continuation */
exp &= 0x3f; /* remaining exponent bits */ } /* finite */
decimal32SetExpCon (d32, exp);
}
if (isneg) if (dn->bits&DECNEG) targ|=0x80000000; /* add sign bit */
decimal32SetSign (d32, 1);
if (status != 0)
decContextSetStatus (set, status); /* pass on status */
/*decimal32Show(d32); */ /* now write to storage; this is endian */
pu=(uInt *)d32->bytes; /* overlay */
*pu=targ; /* directly store the int */
if (status!=0) decContextSetStatus(set, status); /* pass on status */
/* decimal32Show(d32); */
return d32; return d32;
} } /* decimal32FromNumber */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
/* decimal32ToNumber -- convert decimal32 to decNumber */ /* decimal32ToNumber -- convert decimal32 to decNumber */
/* d32 is the source decimal32 */ /* d32 is the source decimal32 */
/* dn is the target number, with appropriate space */ /* dn is the target number, with appropriate space */
/* No error is possible. */ /* No error is possible. */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
decNumber * decNumber * decimal32ToNumber(const decimal32 *d32, decNumber *dn) {
decimal32ToNumber (const decimal32 * d32, decNumber * dn) uInt msd; /* coefficient MSD */
{ uInt exp; /* exponent top two bits */
uInt msd; /* coefficient MSD */ uInt comb; /* combination field */
decimal32 wk; /* working copy, if needed */ uInt sour; /* source 32-bit */
uInt top = d32->bytes[0] & 0x7f; /* top byte, less sign bit */ const uInt *pu; /* work */
decNumberZero (dn); /* clean target */
/* set the sign if negative */
if (decimal32Sign (d32))
dn->bits = DECNEG;
if (top >= 0x78) /* load source from storage; this is endian */
{ /* is a special */ pu=(const uInt *)d32->bytes; /* overlay */
if ((top & 0x7c) == (DECIMAL_Inf & 0x7c)) sour=*pu; /* directly load the int */
dn->bits |= DECINF;
else if ((top & 0x7e) == (DECIMAL_NaN & 0x7e)) comb=(sour>>26)&0x1f; /* combination field */
dn->bits |= DECNAN;
else decNumberZero(dn); /* clean number */
dn->bits |= DECSNAN; if (sour&0x80000000) dn->bits=DECNEG; /* set sign if negative */
msd = 0; /* no top digit */
msd=COMBMSD[comb]; /* decode the combination field */
exp=COMBEXP[comb]; /* .. */
if (exp==3) { /* is a special */
if (msd==0) {
dn->bits|=DECINF;
return dn; /* no coefficient needed */
}
else if (sour&0x02000000) dn->bits|=DECSNAN;
else dn->bits|=DECNAN;
msd=0; /* no top digit */
} }
else else { /* is a finite number */
{ /* have a finite number */ dn->exponent=(exp<<6)+((sour>>20)&0x3f)-DECIMAL32_Bias; /* unbiased */
uInt comb = top >> 2; /* combination field */
uInt exp; /* working exponent */
if (comb >= 0x18)
{
msd = 8 + (comb & 0x01);
exp = (comb & 0x06) << 5; /* MSBs */
}
else
{
msd = comb & 0x07;
exp = (comb & 0x18) << 3;
}
dn->exponent = exp + decimal32ExpCon (d32) - DECIMAL32_Bias; /* remove bias */
} }
/* get the coefficient, unless infinite */ /* get the coefficient */
if (!(dn->bits & DECINF)) sour&=0x000fffff; /* clean coefficient continuation */
{ if (msd) { /* non-zero msd */
Int bunches = DECIMAL32_Pmax / 3; /* coefficient full bunches to convert */ sour|=msd<<20; /* prefix to coefficient */
Int odd = 0; /* assume MSD is 0 (no odd bunch) */ decDigitsFromDPD(dn, &sour, 3); /* process 3 declets */
if (msd != 0) return dn;
{ /* coefficient has leading non-0 digit */
/* make a copy of the decimal32, with an extra bunch which has */
/* the top digit ready for conversion */
wk = *d32; /* take a copy */
wk.bytes[0] = 0; /* clear all but coecon */
wk.bytes[1] &= 0x0f; /* .. */
wk.bytes[1] |= (msd << 4); /* and prefix MSD */
odd++; /* indicate the extra */
d32 = &wk; /* use the work copy */
}
decDenseUnpackCoeff (d32->bytes, sizeof (d32->bytes), dn, bunches, odd);
} }
/* msd=0 */
if (!sour) return dn; /* easy: coefficient is 0 */
if (sour&0x000ffc00) /* need 2 declets? */
decDigitsFromDPD(dn, &sour, 2); /* process 2 declets */
else
decDigitsFromDPD(dn, &sour, 1); /* process 1 declet */
return dn; return dn;
} } /* decimal32ToNumber */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
/* to-scientific-string -- conversion to numeric string */ /* to-scientific-string -- conversion to numeric string */
/* to-engineering-string -- conversion to numeric string */ /* to-engineering-string -- conversion to numeric string */
/* */ /* */
/* decimal32ToString(d32, string); */ /* decimal32ToString(d32, string); */
/* decimal32ToEngString(d32, string); */ /* decimal32ToEngString(d32, string); */
/* */ /* */
/* d32 is the decimal32 format number to convert */ /* d32 is the decimal32 format number to convert */
/* string is the string where the result will be laid out */ /* string is the string where the result will be laid out */
/* */ /* */
/* string must be at least 24 characters */ /* string must be at least 24 characters */
/* */ /* */
/* No error is possible, and no status can be set. */ /* No error is possible, and no status can be set. */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
char * char * decimal32ToEngString(const decimal32 *d32, char *string){
decimal32ToString (const decimal32 * d32, char *string) decNumber dn; /* work */
{ decimal32ToNumber(d32, &dn);
decNumber dn; /* work */ decNumberToEngString(&dn, string);
decimal32ToNumber (d32, &dn);
decNumberToString (&dn, string);
return string; return string;
} } /* decimal32ToEngString */
char * char * decimal32ToString(const decimal32 *d32, char *string){
decimal32ToEngString (const decimal32 * d32, char *string) uInt msd; /* coefficient MSD */
{ Int exp; /* exponent top two bits or full */
decNumber dn; /* work */ uInt comb; /* combination field */
decimal32ToNumber (d32, &dn); char *cstart; /* coefficient start */
decNumberToEngString (&dn, string); char *c; /* output pointer in string */
const uInt *pu; /* work */
const uByte *u; /* .. */
char *s, *t; /* .. (source, target) */
Int dpd; /* .. */
Int pre, e; /* .. */
uInt sour; /* source 32-bit */
/* load source from storage; this is endian */
pu=(const uInt *)d32->bytes; /* overlay */
sour=*pu; /* directly load the int */
c=string; /* where result will go */
if (((Int)sour)<0) *c++='-'; /* handle sign */
comb=(sour>>26)&0x1f; /* combination field */
msd=COMBMSD[comb]; /* decode the combination field */
exp=COMBEXP[comb]; /* .. */
if (exp==3) {
if (msd==0) { /* infinity */
strcpy(c, "Inf");
strcpy(c+3, "inity");
return string; /* easy */
}
if (sour&0x02000000) *c++='s'; /* sNaN */
strcpy(c, "NaN"); /* complete word */
c+=3; /* step past */
if ((sour&0x000fffff)==0) return string; /* zero payload */
/* otherwise drop through to add integer; set correct exp */
exp=0; msd=0; /* setup for following code */
}
else exp=(exp<<6)+((sour>>20)&0x3f)-DECIMAL32_Bias; /* unbiased */
/* convert 7 digits of significand to characters */
cstart=c; /* save start of coefficient */
if (msd) *c++='0'+(char)msd; /* non-zero most significant digit */
/* Now decode the declets. After extracting each one, it is */
/* decoded to binary and then to a 4-char sequence by table lookup; */
/* the 4-chars are a 1-char length (significant digits, except 000 */
/* has length 0). This allows us to left-align the first declet */
/* with non-zero content, then remaining ones are full 3-char */
/* length. We use fixed-length memcpys because variable-length */
/* causes a subroutine call in GCC. (These are length 4 for speed */
/* and are safe because the array has an extra terminator byte.) */
#define dpd2char u=&BIN2CHAR[DPD2BIN[dpd]*4]; \
if (c!=cstart) {memcpy(c, u+1, 4); c+=3;} \
else if (*u) {memcpy(c, u+4-*u, 4); c+=*u;}
dpd=(sour>>10)&0x3ff; /* declet 1 */
dpd2char;
dpd=(sour)&0x3ff; /* declet 2 */
dpd2char;
if (c==cstart) *c++='0'; /* all zeros -- make 0 */
if (exp==0) { /* integer or NaN case -- easy */
*c='\0'; /* terminate */
return string;
}
/* non-0 exponent */
e=0; /* assume no E */
pre=c-cstart+exp;
/* [here, pre-exp is the digits count (==1 for zero)] */
if (exp>0 || pre<-5) { /* need exponential form */
e=pre-1; /* calculate E value */
pre=1; /* assume one digit before '.' */
} /* exponential form */
/* modify the coefficient, adding 0s, '.', and E+nn as needed */
s=c-1; /* source (LSD) */
if (pre>0) { /* ddd.ddd (plain), perhaps with E */
char *dotat=cstart+pre;
if (dotat<c) { /* if embedded dot needed... */
t=c; /* target */
for (; s>=dotat; s--, t--) *t=*s; /* open the gap; leave t at gap */
*t='.'; /* insert the dot */
c++; /* length increased by one */
}
/* finally add the E-part, if needed; it will never be 0, and has */
/* a maximum length of 3 digits (E-101 case) */
if (e!=0) {
*c++='E'; /* starts with E */
*c++='+'; /* assume positive */
if (e<0) {
*(c-1)='-'; /* oops, need '-' */
e=-e; /* uInt, please */
}
u=&BIN2CHAR[e*4]; /* -> length byte */
memcpy(c, u+4-*u, 4); /* copy fixed 4 characters [is safe] */
c+=*u; /* bump pointer appropriately */
}
*c='\0'; /* add terminator */
/*printf("res %s\n", string); */
return string;
} /* pre>0 */
/* -5<=pre<=0: here for plain 0.ddd or 0.000ddd forms (can never have E) */
t=c+1-pre;
*(t+1)='\0'; /* can add terminator now */
for (; s>=cstart; s--, t--) *t=*s; /* shift whole coefficient right */
c=cstart;
*c++='0'; /* always starts with 0. */
*c++='.';
for (; pre<0; pre++) *c++='0'; /* add any 0's after '.' */
/*printf("res %s\n", string); */
return string; return string;
} } /* decimal32ToString */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
/* to-number -- conversion from numeric string */ /* to-number -- conversion from numeric string */
/* */ /* */
/* decimal32FromString(result, string, set); */ /* decimal32FromString(result, string, set); */
/* */ /* */
/* result is the decimal32 format number which gets the result of */ /* result is the decimal32 format number which gets the result of */
/* the conversion */ /* the conversion */
/* *string is the character string which should contain a valid */ /* *string is the character string which should contain a valid */
/* number (which may be a special value) */ /* number (which may be a special value) */
/* set is the context */ /* set is the context */
/* */ /* */
/* The context is supplied to this routine is used for error handling */ /* The context is supplied to this routine is used for error handling */
/* (setting of status and traps) and for the rounding mode, only. */ /* (setting of status and traps) and for the rounding mode, only. */
/* If an error occurs, the result will be a valid decimal32 NaN. */ /* If an error occurs, the result will be a valid decimal32 NaN. */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
decimal32 * decimal32 * decimal32FromString(decimal32 *result, const char *string,
decimal32FromString (decimal32 * result, const char *string, decContext * set) decContext *set) {
{ decContext dc; /* work */
decContext dc; /* work */ decNumber dn; /* .. */
decNumber dn; /* .. */
decContextDefault (&dc, DEC_INIT_DECIMAL32); /* no traps, please */ decContextDefault(&dc, DEC_INIT_DECIMAL32); /* no traps, please */
dc.round = set->round; /* use supplied rounding */ dc.round=set->round; /* use supplied rounding */
decNumberFromString (&dn, string, &dc); /* will round if needed */ decNumberFromString(&dn, string, &dc); /* will round if needed */
decimal32FromNumber (result, &dn, &dc); decimal32FromNumber(result, &dn, &dc);
if (dc.status != 0) if (dc.status!=0) { /* something happened */
{ /* something happened */ decContextSetStatus(set, dc.status); /* .. pass it on */
decContextSetStatus (set, dc.status); /* .. pass it on */
} }
return result; return result;
} } /* decimal32FromString */
/* ------------------------------------------------------------------ */
/* decimal32IsCanonical -- test whether encoding is canonical */
/* d32 is the source decimal32 */
/* returns 1 if the encoding of d32 is canonical, 0 otherwise */
/* No error is possible. */
/* ------------------------------------------------------------------ */
uint32_t decimal32IsCanonical(const decimal32 *d32) {
decNumber dn; /* work */
decimal32 canon; /* .. */
decContext dc; /* .. */
decContextDefault(&dc, DEC_INIT_DECIMAL32);
decimal32ToNumber(d32, &dn);
decimal32FromNumber(&canon, &dn, &dc);/* canon will now be canonical */
return memcmp(d32, &canon, DECIMAL32_Bytes)==0;
} /* decimal32IsCanonical */
/* ------------------------------------------------------------------ */
/* decimal32Canonical -- copy an encoding, ensuring it is canonical */
/* d32 is the source decimal32 */
/* result is the target (may be the same decimal32) */
/* returns result */
/* No error is possible. */
/* ------------------------------------------------------------------ */
decimal32 * decimal32Canonical(decimal32 *result, const decimal32 *d32) {
decNumber dn; /* work */
decContext dc; /* .. */
decContextDefault(&dc, DEC_INIT_DECIMAL32);
decimal32ToNumber(d32, &dn);
decimal32FromNumber(result, &dn, &dc);/* result will now be canonical */
return result;
} /* decimal32Canonical */
#if DECTRACE || DECCHECK #if DECTRACE || DECCHECK
/* Macros for accessing decimal32 fields. These assume the argument
is a reference (pointer) to the decimal32 structure, and the
decimal32 is in network byte order (big-endian) */
/* Get sign */
#define decimal32Sign(d) ((unsigned)(d)->bytes[0]>>7)
/* Get combination field */
#define decimal32Comb(d) (((d)->bytes[0] & 0x7c)>>2)
/* Get exponent continuation [does not remove bias] */
#define decimal32ExpCon(d) ((((d)->bytes[0] & 0x03)<<4) \
| ((unsigned)(d)->bytes[1]>>4))
/* Set sign [this assumes sign previously 0] */
#define decimal32SetSign(d, b) { \
(d)->bytes[0]|=((unsigned)(b)<<7);}
/* Set exponent continuation [does not apply bias] */
/* This assumes range has been checked and exponent previously 0; */
/* type of exponent must be unsigned */
#define decimal32SetExpCon(d, e) { \
(d)->bytes[0]|=(uint8_t)((e)>>4); \
(d)->bytes[1]|=(uint8_t)(((e)&0x0F)<<4);}
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
/* decimal32Show -- display a single in hexadecimal [debug aid] */ /* decimal32Show -- display a decimal32 in hexadecimal [debug aid] */
/* d32 -- the number to show */ /* d32 -- the number to show */
/* ------------------------------------------------------------------ */ /* ------------------------------------------------------------------ */
/* Also shows sign/cob/expconfields extracted */ /* Also shows sign/cob/expconfields extracted - valid bigendian only */
void void decimal32Show(const decimal32 *d32) {
decimal32Show (const decimal32 * d32) char buf[DECIMAL32_Bytes*2+1];
{ Int i, j=0;
char buf[DECIMAL32_Bytes * 2 + 1];
Int i, j; if (DECLITEND) {
j = 0; for (i=0; i<DECIMAL32_Bytes; i++, j+=2) {
for (i = 0; i < DECIMAL32_Bytes; i++) sprintf(&buf[j], "%02x", d32->bytes[3-i]);
{ }
sprintf (&buf[j], "%02x", d32->bytes[i]); printf(" D32> %s [S:%d Cb:%02x Ec:%02x] LittleEndian\n", buf,
j = j + 2; d32->bytes[3]>>7, (d32->bytes[3]>>2)&0x1f,
((d32->bytes[3]&0x3)<<4)| (d32->bytes[2]>>4));
} }
printf (" D32> %s [S:%d Cb:%02x E:%d]\n", buf, else {
decimal32Sign (d32), decimal32Comb (d32), decimal32ExpCon (d32)); for (i=0; i<DECIMAL32_Bytes; i++, j+=2) {
} sprintf(&buf[j], "%02x", d32->bytes[i]);
}
printf(" D32> %s [S:%d Cb:%02x Ec:%02x] BigEndian\n", buf,
decimal32Sign(d32), decimal32Comb(d32), decimal32ExpCon(d32));
}
} /* decimal32Show */
#endif #endif

135
libdecnumber/dpd/decimal32.h
View File

@ -1,5 +1,5 @@
/* Decimal 32-bit format module header for the decNumber C Library /* Decimal 32-bit format module header for the decNumber C Library.
Copyright (C) 2005 Free Software Foundation, Inc. Copyright (C) 2005, 2007 Free Software Foundation, Inc.
Contributed by IBM Corporation. Author Mike Cowlishaw. Contributed by IBM Corporation. Author Mike Cowlishaw.
This file is part of GCC. This file is part of GCC.
@ -28,93 +28,72 @@
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA. */ 02110-1301, USA. */
/* ------------------------------------------------------------------ */
/* Decimal 32-bit format module header */
/* ------------------------------------------------------------------ */
#if !defined(DECIMAL32) #if !defined(DECIMAL32)
#define DECIMAL32 #define DECIMAL32
#define DEC32NAME "decimal32" /* Short name */ #define DEC32NAME "decimal32" /* Short name */
#define DEC32FULLNAME "Decimal 32-bit Number" /* Verbose name */ #define DEC32FULLNAME "Decimal 32-bit Number" /* Verbose name */
#define DEC32AUTHOR "Mike Cowlishaw" /* Who to blame */ #define DEC32AUTHOR "Mike Cowlishaw" /* Who to blame */
/* parameters for decimal32s */ /* parameters for decimal32s */
#define DECIMAL32_Bytes 4 /* length */ #define DECIMAL32_Bytes 4 /* length */
#define DECIMAL32_Pmax 7 /* maximum precision (digits) */ #define DECIMAL32_Pmax 7 /* maximum precision (digits) */
#define DECIMAL32_Emax 96 /* maximum adjusted exponent */ #define DECIMAL32_Emax 96 /* maximum adjusted exponent */
#define DECIMAL32_Emin -95 /* minimum adjusted exponent */ #define DECIMAL32_Emin -95 /* minimum adjusted exponent */
#define DECIMAL32_Bias 101 /* bias for the exponent */ #define DECIMAL32_Bias 101 /* bias for the exponent */
#define DECIMAL32_String 15 /* maximum string length, +1 */ #define DECIMAL32_String 15 /* maximum string length, +1 */
/* highest biased exponent (Elimit-1) */ #define DECIMAL32_EconL 6 /* exp. continuation length */
#define DECIMAL32_Ehigh (DECIMAL32_Emax+DECIMAL32_Bias-DECIMAL32_Pmax+1) /* highest biased exponent (Elimit-1) */
#define DECIMAL32_Ehigh (DECIMAL32_Emax+DECIMAL32_Bias-DECIMAL32_Pmax+1)
#ifndef DECNUMDIGITS /* check enough digits, if pre-defined */
#define DECNUMDIGITS DECIMAL32_Pmax /* size if not already defined */ #if defined(DECNUMDIGITS)
#endif #if (DECNUMDIGITS<DECIMAL32_Pmax)
#ifndef DECNUMBER #error decimal32.h needs pre-defined DECNUMDIGITS>=7 for safe use
#include "decNumber.h" /* context and number library */ #endif
#endif #endif
#ifndef DECNUMDIGITS
#define DECNUMDIGITS DECIMAL32_Pmax /* size if not already defined*/
#endif
#ifndef DECNUMBER
#include "decNumber.h" /* context and number library */
#endif
/* Decimal 32-bit type, accessible by bytes */ /* Decimal 32-bit type, accessible by bytes */
typedef struct typedef struct {
{ uint8_t bytes[DECIMAL32_Bytes]; /* decimal32: 1, 5, 6, 20 bits*/
uint8_t bytes[DECIMAL32_Bytes]; /* decimal32: 1, 5, 6, 20 bits */ } decimal32;
} decimal32;
/* special values [top byte excluding sign bit; last two bits are /* special values [top byte excluding sign bit; last two bits are */
don't-care for Infinity on input, last bit don't-care for NaN] */ /* don't-care for Infinity on input, last bit don't-care for NaN] */
#if !defined(DECIMAL_NaN) #if !defined(DECIMAL_NaN)
#define DECIMAL_NaN 0x7c /* 0 11111 00 NaN */ #define DECIMAL_NaN 0x7c /* 0 11111 00 NaN */
#define DECIMAL_sNaN 0x7e /* 0 11111 10 sNaN */ #define DECIMAL_sNaN 0x7e /* 0 11111 10 sNaN */
#define DECIMAL_Inf 0x78 /* 0 11110 00 Infinity */ #define DECIMAL_Inf 0x78 /* 0 11110 00 Infinity */
#endif #endif
/* Macros for accessing decimal32 fields. These assume the argument /* ---------------------------------------------------------------- */
is a reference (pointer) to the decimal32 structure */ /* Routines */
/* Get sign */ /* ---------------------------------------------------------------- */
#define decimal32Sign(d) ((unsigned)(d)->bytes[0]>>7)
/* Get combination field */ #include "decimal32Symbols.h"
#define decimal32Comb(d) (((d)->bytes[0] & 0x7c)>>2)
/* Get exponent continuation [does not remove bias] */ /* String conversions */
#define decimal32ExpCon(d) ((((d)->bytes[0] & 0x03)<<4) \ decimal32 * decimal32FromString(decimal32 *, const char *, decContext *);
| ((unsigned)(d)->bytes[1]>>4)) char * decimal32ToString(const decimal32 *, char *);
char * decimal32ToEngString(const decimal32 *, char *);
/* Set sign [this assumes sign previously 0] */ /* decNumber conversions */
#define decimal32SetSign(d, b) { \ decimal32 * decimal32FromNumber(decimal32 *, const decNumber *,
(d)->bytes[0]|=((unsigned)(b)<<7);} decContext *);
decNumber * decimal32ToNumber(const decimal32 *, decNumber *);
/* Clear sign */ /* Format-dependent utilities */
#define decimal32ClearSign(d) {(d)->bytes[0]&=~0x80;} uint32_t decimal32IsCanonical(const decimal32 *);
decimal32 * decimal32Canonical(decimal32 *, const decimal32 *);
/* Flip sign */
#define decimal32FlipSign(d) {(d)->bytes[0]^=0x80;}
/* Set exponent continuation [does not apply bias] */
/* This assumes range has been checked and exponent previously 0; */
/* type of exponent must be unsigned */
#define decimal32SetExpCon(d, e) { \
(d)->bytes[0]|=(uint8_t)((e)>>4); \
(d)->bytes[1]|=(uint8_t)(((e)&0x0F)<<4);}
/* ------------------------------------------------------------------ */
/* Routines */
/* ------------------------------------------------------------------ */
#ifdef IN_LIBGCC2
#ifndef decimal32FromString
#define decimal32FromString __decimal32FromString
#define decimal32ToString __decimal32ToString
#define decimal32ToEngString __decimal32ToEngString
#define decimal32FromNumber __decimal32FromNumber
#define decimal32ToNumber __decimal32ToNumber
#endif
#endif
/* String conversions. */
decimal32 *decimal32FromString (decimal32 *, const char *, decContext *);
char *decimal32ToString (const decimal32 *, char *);
char *decimal32ToEngString (const decimal32 *, char *);
/* decNumber conversions. */
decimal32 *decimal32FromNumber (decimal32 *, const decNumber *, decContext *);
decNumber *decimal32ToNumber (const decimal32 *, decNumber *);
#endif #endif

16
libdecnumber/dpd/decimal32Symbols.h Normal file
View File

@ -0,0 +1,16 @@
#if !defined(DECIMAL32SYMBOLS)
#define DECIMAL32SYMBOLS
#ifdef IN_LIBGCC2
#define decDigitsFromDPD __decDigitsFromDPD
#define decDigitsToDPD __decDigitsToDPD
#define decimal32Canonical __decimal32Canonical
#define decimal32FromNumber __decimal32FromNumber
#define decimal32FromString __decimal32FromString
#define decimal32IsCanonical __decimal32IsCanonical
#define decimal32ToEngString __decimal32ToEngString
#define decimal32ToNumber __decimal32ToNumber
#define decimal32ToString __decimal32ToString
#endif
#endif

1003
libdecnumber/dpd/decimal64.c
View File

File diff suppressed because it is too large Load Diff

139
libdecnumber/dpd/decimal64.h
View File

@ -1,5 +1,5 @@
/* Decimal 64-bit format module header for the decNumber C Library /* Decimal 64-bit format module header for the decNumber C Library.
Copyright (C) 2005 Free Software Foundation, Inc. Copyright (C) 2005, 2007 Free Software Foundation, Inc.
Contributed by IBM Corporation. Author Mike Cowlishaw. Contributed by IBM Corporation. Author Mike Cowlishaw.
This file is part of GCC. This file is part of GCC.
@ -28,97 +28,74 @@
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA. */ 02110-1301, USA. */
/* ------------------------------------------------------------------ */
/* Decimal 64-bit format module header */
/* ------------------------------------------------------------------ */
#if !defined(DECIMAL64) #if !defined(DECIMAL64)
#define DECIMAL64 #define DECIMAL64
#define DEC64NAME "decimal64" /* Short name */ #define DEC64NAME "decimal64" /* Short name */
#define DEC64FULLNAME "Decimal 64-bit Number" /* Verbose name */ #define DEC64FULLNAME "Decimal 64-bit Number" /* Verbose name */
#define DEC64AUTHOR "Mike Cowlishaw" /* Who to blame */ #define DEC64AUTHOR "Mike Cowlishaw" /* Who to blame */
#if defined(DECIMAL32)
#error decimal64.h must precede decimal32.h for correct DECNUMDIGITS
#endif
/* parameters for decimal64s */ /* parameters for decimal64s */
#define DECIMAL64_Bytes 8 /* length */ #define DECIMAL64_Bytes 8 /* length */
#define DECIMAL64_Pmax 16 /* maximum precision (digits) */ #define DECIMAL64_Pmax 16 /* maximum precision (digits) */
#define DECIMAL64_Emax 384 /* maximum adjusted exponent */ #define DECIMAL64_Emax 384 /* maximum adjusted exponent */
#define DECIMAL64_Emin -383 /* minimum adjusted exponent */ #define DECIMAL64_Emin -383 /* minimum adjusted exponent */
#define DECIMAL64_Bias 398 /* bias for the exponent */ #define DECIMAL64_Bias 398 /* bias for the exponent */
#define DECIMAL64_String 24 /* maximum string length, +1 */ #define DECIMAL64_String 24 /* maximum string length, +1 */
/* highest biased exponent (Elimit-1) */ #define DECIMAL64_EconL 8 /* exp. continuation length */
#define DECIMAL64_Ehigh (DECIMAL64_Emax+DECIMAL64_Bias-DECIMAL64_Pmax+1) /* highest biased exponent (Elimit-1) */
#define DECIMAL64_Ehigh (DECIMAL64_Emax+DECIMAL64_Bias-DECIMAL64_Pmax+1)
#ifndef DECNUMDIGITS /* check enough digits, if pre-defined */
#define DECNUMDIGITS DECIMAL64_Pmax /* size if not already defined */ #if defined(DECNUMDIGITS)
#endif #if (DECNUMDIGITS<DECIMAL64_Pmax)
#ifndef DECNUMBER #error decimal64.h needs pre-defined DECNUMDIGITS>=16 for safe use
#include "decNumber.h" /* context and number library */ #endif
#endif #endif
/* Decimal 64-bit type, accessible by bytes */
typedef struct
{
uint8_t bytes[DECIMAL64_Bytes]; /* decimal64: 1, 5, 8, 50 bits */
} decimal64;
/* special values [top byte excluding sign bit; last two bits are #ifndef DECNUMDIGITS
don't-care for Infinity on input, last bit don't-care for NaN] */ #define DECNUMDIGITS DECIMAL64_Pmax /* size if not already defined*/
#if !defined(DECIMAL_NaN) #endif
#define DECIMAL_NaN 0x7c /* 0 11111 00 NaN */ #ifndef DECNUMBER
#define DECIMAL_sNaN 0x7e /* 0 11111 10 sNaN */ #include "decNumber.h" /* context and number library */
#define DECIMAL_Inf 0x78 /* 0 11110 00 Infinity */ #endif
#endif
/* Macros for accessing decimal64 fields. These assume the argument /* Decimal 64-bit type, accessible by bytes */
is a reference (pointer) to the decimal64 structure */ typedef struct {
/* Get sign */ uint8_t bytes[DECIMAL64_Bytes]; /* decimal64: 1, 5, 8, 50 bits*/
#define decimal64Sign(d) ((unsigned)(d)->bytes[0]>>7) } decimal64;
/* Get combination field */ /* special values [top byte excluding sign bit; last two bits are */
#define decimal64Comb(d) (((d)->bytes[0] & 0x7c)>>2) /* don't-care for Infinity on input, last bit don't-care for NaN] */
#if !defined(DECIMAL_NaN)
#define DECIMAL_NaN 0x7c /* 0 11111 00 NaN */
#define DECIMAL_sNaN 0x7e /* 0 11111 10 sNaN */
#define DECIMAL_Inf 0x78 /* 0 11110 00 Infinity */
#endif
/* Get exponent continuation [does not remove bias] */ /* ---------------------------------------------------------------- */
#define decimal64ExpCon(d) ((((d)->bytes[0] & 0x03)<<6) \ /* Routines */
| ((unsigned)(d)->bytes[1]>>2)) /* ---------------------------------------------------------------- */
/* Set sign [this assumes sign previously 0] */ #include "decimal64Symbols.h"
#define decimal64SetSign(d, b) { \
(d)->bytes[0]|=((unsigned)(b)<<7);}
/* Clear sign */ /* String conversions */
#define decimal64ClearSign(d) {(d)->bytes[0]&=~0x80;} decimal64 * decimal64FromString(decimal64 *, const char *, decContext *);
char * decimal64ToString(const decimal64 *, char *);
char * decimal64ToEngString(const decimal64 *, char *);
/* Flip sign */ /* decNumber conversions */
#define decimal64FlipSign(d) {(d)->bytes[0]^=0x80;} decimal64 * decimal64FromNumber(decimal64 *, const decNumber *,
decContext *);
decNumber * decimal64ToNumber(const decimal64 *, decNumber *);
/* Set exponent continuation [does not apply bias] */ /* Format-dependent utilities */
/* This assumes range has been checked and exponent previously 0; type */ uint32_t decimal64IsCanonical(const decimal64 *);
/* of exponent must be unsigned */ decimal64 * decimal64Canonical(decimal64 *, const decimal64 *);
#define decimal64SetExpCon(d, e) { \
(d)->bytes[0]|=(uint8_t)((e)>>6); \
(d)->bytes[1]|=(uint8_t)(((e)&0x3F)<<2);}
/* ------------------------------------------------------------------ */
/* Routines */
/* ------------------------------------------------------------------ */
#ifdef IN_LIBGCC2
#ifndef decimal64FromString
#define decimal64FromString __decimal64FromString
#define decimal64ToString __decimal64ToString
#define decimal64ToEngString __decimal64ToEngString
#define decimal64FromNumber __decimal64FromNumber
#define decimal64ToNumber __decimal64ToNumber
#endif
#endif
/* String conversions */
decimal64 *decimal64FromString (decimal64 *, const char *, decContext *);
char *decimal64ToString (const decimal64 *, char *);
char *decimal64ToEngString (const decimal64 *, char *);
/* decNumber conversions */
decimal64 *decimal64FromNumber (decimal64 *, const decNumber *, decContext *);
decNumber *decimal64ToNumber (const decimal64 *, decNumber *);
#endif #endif

16
libdecnumber/dpd/decimal64Symbols.h Normal file
View File

@ -0,0 +1,16 @@
#if !defined(DECIMAL64SYMBOLS)
#define DECIMAL64SYMBOLS
#ifdef IN_LIBGCC2
#define decDigitsFromDPD __decDigitsFromDPD
#define decDigitsToDPD __decDigitsToDPD
#define decimal64Canonical __decimal64Canonical
#define decimal64FromNumber __decimal64FromNumber
#define decimal64FromString __decimal64FromString
#define decimal64IsCanonical __decimal64IsCanonical
#define decimal64ToEngString __decimal64ToEngString
#define decimal64ToNumber __decimal64ToNumber
#define decimal64ToString __decimal64ToString
#endif
#endif

5
libgcc/ChangeLog
View File

@ -1,3 +1,8 @@
2007-09-10 Janis Johnson <janis187@us.ibm.com>
* Makefile.in (dfp-filenames): Remove decUtility, add
decDouble, decPacked, decQuad, decSingle.
2007-08-27 Hans Kester <hans.kester@ellips.nl> 2007-08-27 Hans Kester <hans.kester@ellips.nl>
* config.host : Add x86_64-elf target. * config.host : Add x86_64-elf target.

2
libgcc/Makefile.in
View File

@ -488,7 +488,7 @@ dfp-filenames += decimal_globals decimal_data binarydecimal \
bid128_to_int32 bid128_to_int64 \ bid128_to_int32 bid128_to_int64 \
bid128_to_uint32 bid128_to_uint64 bid128_to_uint32 bid128_to_uint64
else else
dfp-filenames += decContext decNumber decExcept decRound decLibrary decUtility dfp-filenames += decContext decNumber decExcept decRound decLibrary decDouble decPacked decQuad decSingle
endif endif
endif endif