--- /dev/null
+/* 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
projects / thirdparty / gcc.git / blobdiff