diff options
Diffstat (limited to 'gcc-4.2.1-5666.3/libdecnumber/decimal128.c')
| -rw-r--r-- | gcc-4.2.1-5666.3/libdecnumber/decimal128.c | 347 |
1 files changed, 0 insertions, 347 deletions
diff --git a/gcc-4.2.1-5666.3/libdecnumber/decimal128.c b/gcc-4.2.1-5666.3/libdecnumber/decimal128.c deleted file mode 100644 index 92b4f618e..000000000 --- a/gcc-4.2.1-5666.3/libdecnumber/decimal128.c +++ /dev/null @@ -1,347 +0,0 @@ -/* Decimal 128-bit format module from 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. */ - -/* ------------------------------------------------------------------ */ -/* This module comprises the routines for decimal128 format numbers. */ -/* 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] */ -#include <stdio.h> /* [for printf] */ - -#define DECNUMDIGITS 34 /* we need decNumbers with space for 34 */ -#include "config.h" -#include "decNumber.h" /* base number library */ -#include "decNumberLocal.h" /* decNumber local types, etc. */ -#include "decimal128.h" /* our primary include */ -#include "decUtility.h" /* utility routines */ - -#if DECTRACE || DECCHECK -void decimal128Show (const decimal128 *); /* for debug */ -void decNumberShow (const decNumber *); /* .. */ -#endif - -/* Useful macro */ -/* Clear a structure (e.g., a decNumber) */ -#define DEC_clear(d) memset(d, 0, sizeof(*d)) - -/* ------------------------------------------------------------------ */ -/* decimal128FromNumber -- convert decNumber to decimal128 */ -/* */ -/* ds is the target decimal128 */ -/* dn is the source number (assumed valid) */ -/* set is the context, used only for reporting errors */ -/* */ -/* The set argument is used only for status reporting and for the */ -/* rounding mode (used if the coefficient is more than DECIMAL128_Pmax*/ -/* digits or an overflow is detected). If the exponent is out of the */ -/* valid range then Overflow or Underflow will be raised. */ -/* After Underflow a subnormal result is possible. */ -/* */ -/* DEC_Clamped is set if the number has to be 'folded down' to fit, */ -/* by reducing its exponent and multiplying the coefficient by a */ -/* power of ten, or if the exponent on a zero had to be clamped. */ -/* ------------------------------------------------------------------ */ -decimal128 * -decimal128FromNumber (decimal128 * d128, const decNumber * dn, decContext * set) -{ - uInt status = 0; /* status accumulator */ - Int pad = 0; /* coefficient pad digits */ - decNumber dw; /* work */ - decContext dc; /* .. */ - uByte isneg = dn->bits & DECNEG; /* non-0 if original sign set */ - uInt comb, exp; /* work */ - - /* If the number is finite, and has too many digits, or the exponent */ - /* could be out of range then we reduce the number under the */ - /* appropriate constraints */ - if (!(dn->bits & DECSPECIAL)) - { /* not a special value */ - Int ae = dn->exponent + dn->digits - 1; /* adjusted exponent */ - if (dn->digits > DECIMAL128_Pmax /* too many digits */ - || ae > DECIMAL128_Emax /* likely overflow */ - || ae < DECIMAL128_Emin) - { /* likely underflow */ - decContextDefault (&dc, DEC_INIT_DECIMAL128); /* [no traps] */ - dc.round = set->round; /* use supplied rounding */ - decNumberPlus (&dw, dn, &dc); /* (round and check) */ - /* [this changes -0 to 0, but it will be restored below] */ - status |= dc.status; /* save status */ - dn = &dw; /* use the work number */ - } - /* [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 */ - uByte top; /* work */ - if (dn->bits & DECINF) - top = DECIMAL_Inf; - 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; - } - else if (decNumberIsZero (dn)) - { /* a zero */ - /* set and clamp exponent */ - if (dn->exponent < -DECIMAL128_Bias) - { - exp = 0; - status |= DEC_Clamped; - } - else - { - exp = dn->exponent + DECIMAL128_Bias; /* bias exponent */ - if (exp > DECIMAL128_Ehigh) - { /* top clamp */ - exp = DECIMAL128_Ehigh; - status |= DEC_Clamped; - } - } - comb = (exp >> 9) & 0x18; /* combination field */ - d128->bytes[0] = (uByte) (comb << 2); - exp &= 0xfff; /* remaining exponent bits */ - decimal128SetExpCon (d128, exp); - } - else - { /* non-zero finite number */ - uInt msd; /* work */ - - /* we have a dn that fits, but it may need to be padded */ - exp = (uInt) (dn->exponent + DECIMAL128_Bias); /* bias exponent */ - - if (exp > DECIMAL128_Ehigh) - { /* fold-down case */ - pad = exp - DECIMAL128_Ehigh; - exp = DECIMAL128_Ehigh; /* [to maximum] */ - status |= DEC_Clamped; - } - - decDensePackCoeff (dn, d128->bytes, sizeof (d128->bytes), pad); - - /* save and clear the top digit */ - msd = ((unsigned) d128->bytes[1] << 2) & 0x0c; /* top 2 bits */ - msd |= ((unsigned) d128->bytes[2] >> 6); /* low 2 bits */ - d128->bytes[1] &= 0xfc; - d128->bytes[2] &= 0x3f; - - /* create the combination field */ - if (msd >= 8) - comb = 0x18 | (msd & 0x01) | ((exp >> 11) & 0x06); - else - comb = (msd & 0x07) | ((exp >> 9) & 0x18); - d128->bytes[0] = (uByte) (comb << 2); - exp &= 0xfff; /* remaining exponent bits */ - decimal128SetExpCon (d128, exp); - } - - if (isneg) - decimal128SetSign (d128, 1); - if (status != 0) - decContextSetStatus (set, status); /* pass on status */ - - /* decimal128Show(d128); */ - return d128; -} - -/* ------------------------------------------------------------------ */ -/* decimal128ToNumber -- convert decimal128 to decNumber */ -/* d128 is the source decimal128 */ -/* dn is the target number, with appropriate space */ -/* No error is possible. */ -/* ------------------------------------------------------------------ */ -decNumber * -decimal128ToNumber (const decimal128 * d128, decNumber * dn) -{ - uInt msd; /* coefficient MSD */ - decimal128 wk; /* working copy, if needed */ - uInt top = d128->bytes[0] & 0x7f; /* top byte, less sign bit */ - decNumberZero (dn); /* clean target */ - /* set the sign if negative */ - if (decimal128Sign (d128)) - dn->bits = DECNEG; - - if (top >= 0x78) - { /* is a special */ - if ((top & 0x7c) == (DECIMAL_Inf & 0x7c)) - dn->bits |= DECINF; - else if ((top & 0x7e) == (DECIMAL_NaN & 0x7e)) - dn->bits |= DECNAN; - else - dn->bits |= DECSNAN; - msd = 0; /* no top digit */ - } - else - { /* have a finite number */ - uInt comb = top >> 2; /* combination field */ - uInt exp; /* exponent */ - - 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 */ - if (!(dn->bits & DECINF)) - { - Int bunches = DECIMAL128_Pmax / 3; /* coefficient full bunches to convert */ - Int odd = 0; /* assume MSD is 0 (no odd bunch) */ - if (msd != 0) - { /* coefficient has leading non-0 digit */ - /* make a copy of the decimal128, with an extra bunch which has */ - /* the top digit ready for conversion */ - wk = *d128; /* take a copy */ - wk.bytes[0] = 0; /* clear all but coecon */ - wk.bytes[1] = 0; /* .. */ - wk.bytes[2] &= 0x3f; /* .. */ - wk.bytes[1] |= (msd >> 2); /* and prefix MSD */ - wk.bytes[2] |= (msd << 6); /* .. */ - odd++; /* indicate the extra */ - d128 = &wk; /* use the work copy */ - } - decDenseUnpackCoeff (d128->bytes, sizeof (d128->bytes), dn, bunches, - odd); - } - - /* decNumberShow(dn); */ - return dn; -} - -/* ------------------------------------------------------------------ */ -/* to-scientific-string -- conversion to numeric string */ -/* to-engineering-string -- conversion to numeric string */ -/* */ -/* decimal128ToString(d128, string); */ -/* decimal128ToEngString(d128, string); */ -/* */ -/* d128 is the decimal128 format number to convert */ -/* string is the string where the result will be laid out */ -/* */ -/* string must be at least 24 characters */ -/* */ -/* No error is possible, and no status can be set. */ -/* ------------------------------------------------------------------ */ -char * -decimal128ToString (const decimal128 * d128, char *string) -{ - decNumber dn; /* work */ - decimal128ToNumber (d128, &dn); - decNumberToString (&dn, string); - return string; -} - -char * -decimal128ToEngString (const decimal128 * d128, char *string) -{ - decNumber dn; /* work */ - decimal128ToNumber (d128, &dn); - decNumberToEngString (&dn, string); - return string; -} - -/* ------------------------------------------------------------------ */ -/* to-number -- conversion from numeric string */ -/* */ -/* decimal128FromString(result, string, set); */ -/* */ -/* result is the decimal128 format number which gets the result of */ -/* the conversion */ -/* *string is the character string which should contain a valid */ -/* number (which may be a special value) */ -/* set is the context */ -/* */ -/* The context is supplied to this routine is used for error handling */ -/* (setting of status and traps) and for the rounding mode, only. */ -/* If an error occurs, the result will be a valid decimal128 NaN. */ -/* ------------------------------------------------------------------ */ -decimal128 * -decimal128FromString (decimal128 * result, const char *string, decContext * set) -{ - decContext dc; /* work */ - decNumber dn; /* .. */ - - decContextDefault (&dc, DEC_INIT_DECIMAL128); /* no traps, please */ - dc.round = set->round; /* use supplied rounding */ - - decNumberFromString (&dn, string, &dc); /* will round if needed */ - decimal128FromNumber (result, &dn, &dc); - if (dc.status != 0) - { /* something happened */ - decContextSetStatus (set, dc.status); /* .. pass it on */ - } - return result; -} - - -#if DECTRACE || DECCHECK -/* ------------------------------------------------------------------ */ -/* decimal128Show -- display a single in hexadecimal [debug aid] */ -/* d128 -- the number to show */ -/* ------------------------------------------------------------------ */ -/* Also shows sign/cob/expconfields extracted */ -void -decimal128Show (const decimal128 * d128) -{ - char buf[DECIMAL128_Bytes * 2 + 1]; - Int i, j; - j = 0; - for (i = 0; i < DECIMAL128_Bytes; i++) - { - sprintf (&buf[j], "%02x", d128->bytes[i]); - j = j + 2; - } - printf (" D128> %s [S:%d Cb:%02x E:%d]\n", buf, - decimal128Sign (d128), decimal128Comb (d128), - decimal128ExpCon (d128)); -} -#endif |