libdecnumber/decimal128.c

   1 /* Decimal 128-bit format module from the decNumber C Library.
   2    Copyright (C) 2005 Free Software Foundation, Inc.
   3    Contributed by IBM Corporation.  Author Mike Cowlishaw.
   4
   5    This file is part of GCC.
   6
   7    GCC is free software; you can redistribute it and/or modify it under
   8    the terms of the GNU General Public License as published by the Free
   9    Software Foundation; either version 2, or (at your option) any later
  10    version.
  11
  12    GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13    WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15    for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GCC; see the file COPYING.  If not, write to the Free
  19    Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  20    02110-1301, USA.  */
  21
  22 /* ------------------------------------------------------------------ */
  23 /* This module comprises the routines for decimal128 format numbers.  */
  24 /* Conversions are supplied to and from decNumber and String.         */
  25 /*                                                                    */
  26 /* No arithmetic routines are included; decNumber provides these.     */
  27 /*                                                                    */
  28 /* Error handling is the same as decNumber (qv.).                     */
  29 /* ------------------------------------------------------------------ */
  30 #include <string.h>             /* [for memset/memcpy] */
  31 #include <stdio.h>              /* [for printf] */
  32
  33 #define  DECNUMDIGITS 34        /* we need decNumbers with space for 34 */
  34 #include "config.h"
  35 #include "decNumber.h"          /* base number library */
  36 #include "decNumberLocal.h"     /* decNumber local types, etc. */
  37 #include "decimal128.h"         /* our primary include */
  38 #include "decUtility.h"         /* utility routines */
  39
  40 #if DECTRACE || DECCHECK
  41 void decimal128Show (const decimal128 *);       /* for debug */
  42 void decNumberShow (const decNumber *); /* .. */
  43 #endif
  44
  45 /* Useful macro */
  46 /* Clear a structure (e.g., a decNumber) */
  47 #define DEC_clear(d) memset(d, 0, sizeof(*d))
  48
  49 /* ------------------------------------------------------------------ */
  50 /* decimal128FromNumber -- convert decNumber to decimal128            */
  51 /*                                                                    */
  52 /*   ds is the target decimal128                                      */
  53 /*   dn is the source number (assumed valid)                          */
  54 /*   set is the context, used only for reporting errors               */
  55 /*                                                                    */
  56 /* The set argument is used only for status reporting and for the     */
  57 /* rounding mode (used if the coefficient is more than DECIMAL128_Pmax*/
  58 /* digits or an overflow is detected).  If the exponent is out of the */
  59 /* valid range then Overflow or Underflow will be raised.             */
  60 /* After Underflow a subnormal result is possible.                    */
  61 /*                                                                    */
  62 /* DEC_Clamped is set if the number has to be 'folded down' to fit,   */
  63 /* by reducing its exponent and multiplying the coefficient by a      */
  64 /* power of ten, or if the exponent on a zero had to be clamped.      */
  65 /* ------------------------------------------------------------------ */
  66 decimal128 *
  67 decimal128FromNumber (decimal128 * d128, const decNumber * dn, decContext * set)
  68 {
  69   uInt status = 0;              /* status accumulator */
  70   Int pad = 0;                  /* coefficient pad digits */
  71   decNumber dw;                 /* work */
  72   decContext dc;                /* .. */
  73   uByte isneg = dn->bits & DECNEG;      /* non-0 if original sign set */
  74   uInt comb, exp;               /* work */
  75
  76   /* If the number is finite, and has too many digits, or the exponent */
  77   /* could be out of range then we reduce the number under the */
  78   /* appropriate constraints */
  79   if (!(dn->bits & DECSPECIAL))
  80     {                           /* not a special value */
  81       Int ae = dn->exponent + dn->digits - 1;   /* adjusted exponent */
  82       if (dn->digits > DECIMAL128_Pmax  /* too many digits */
  83           || ae > DECIMAL128_Emax       /* likely overflow */
  84           || ae < DECIMAL128_Emin)
  85         {                       /* likely underflow */
  86           decContextDefault (&dc, DEC_INIT_DECIMAL128); /* [no traps] */
  87           dc.round = set->round;        /* use supplied rounding */
  88           decNumberPlus (&dw, dn, &dc); /* (round and check) */
  89           /* [this changes -0 to 0, but it will be restored below] */
  90           status |= dc.status;  /* save status */
  91           dn = &dw;             /* use the work number */
  92         }
  93       /* [this could have pushed number to Infinity or zero, so this */
  94       /* rounding must be done before we generate the decimal128] */
  95     }
  96
  97   DEC_clear (d128);             /* clean the target */
  98   if (dn->bits & DECSPECIAL)
  99     {                           /* a special value */
 100       uByte top;                /* work */
 101       if (dn->bits & DECINF)
 102         top = DECIMAL_Inf;
 103       else
 104         {                       /* sNaN or qNaN */
 105           if ((*dn->lsu != 0 || dn->digits > 1) /* non-zero coefficient */
 106               && (dn->digits < DECIMAL128_Pmax))
 107             {                   /* coefficient fits */
 108               decDensePackCoeff (dn, d128->bytes, sizeof (d128->bytes), 0);
 109             }
 110           if (dn->bits & DECNAN)
 111             top = DECIMAL_NaN;
 112           else
 113             top = DECIMAL_sNaN;
 114         }
 115       d128->bytes[0] = top;
 116     }
 117   else if (decNumberIsZero (dn))
 118     {                           /* a zero */
 119       /* set and clamp exponent */
 120       if (dn->exponent < -DECIMAL128_Bias)
 121         {
 122           exp = 0;
 123           status |= DEC_Clamped;
 124         }
 125       else
 126         {
 127           exp = dn->exponent + DECIMAL128_Bias; /* bias exponent */
 128           if (exp > DECIMAL128_Ehigh)
 129             {                   /* top clamp */
 130               exp = DECIMAL128_Ehigh;
 131               status |= DEC_Clamped;
 132             }
 133         }
 134       comb = (exp >> 9) & 0x18; /* combination field */
 135       d128->bytes[0] = (uByte) (comb << 2);
 136       exp &= 0xfff;             /* remaining exponent bits */
 137       decimal128SetExpCon (d128, exp);
 138     }
 139   else
 140     {                           /* non-zero finite number */
 141       uInt msd;                 /* work */
 142
 143       /* we have a dn that fits, but it may need to be padded */
 144       exp = (uInt) (dn->exponent + DECIMAL128_Bias);    /* bias exponent */
 145
 146       if (exp > DECIMAL128_Ehigh)
 147         {                       /* fold-down case */
 148           pad = exp - DECIMAL128_Ehigh;
 149           exp = DECIMAL128_Ehigh;       /* [to maximum] */
 150           status |= DEC_Clamped;
 151         }
 152
 153       decDensePackCoeff (dn, d128->bytes, sizeof (d128->bytes), pad);
 154
 155       /* save and clear the top digit */
 156       msd = ((unsigned) d128->bytes[1] << 2) & 0x0c;    /* top 2 bits */
 157       msd |= ((unsigned) d128->bytes[2] >> 6);  /* low 2 bits */
 158       d128->bytes[1] &= 0xfc;
 159       d128->bytes[2] &= 0x3f;
 160
 161       /* create the combination field */
 162       if (msd >= 8)
 163         comb = 0x18 | (msd & 0x01) | ((exp >> 11) & 0x06);
 164       else
 165         comb = (msd & 0x07) | ((exp >> 9) & 0x18);
 166       d128->bytes[0] = (uByte) (comb << 2);
 167       exp &= 0xfff;             /* remaining exponent bits */
 168       decimal128SetExpCon (d128, exp);
 169     }
 170
 171   if (isneg)
 172     decimal128SetSign (d128, 1);
 173   if (status != 0)
 174     decContextSetStatus (set, status);  /* pass on status */
 175
 176   /* decimal128Show(d128); */
 177   return d128;
 178 }
 179
 180 /* ------------------------------------------------------------------ */
 181 /* decimal128ToNumber -- convert decimal128 to decNumber              */
 182 /*   d128 is the source decimal128                                    */
 183 /*   dn is the target number, with appropriate space                  */
 184 /* No error is possible.                                              */
 185 /* ------------------------------------------------------------------ */
 186 decNumber *
 187 decimal128ToNumber (const decimal128 * d128, decNumber * dn)
 188 {
 189   uInt msd;                     /* coefficient MSD */
 190   decimal128 wk;                /* working copy, if needed */
 191   uInt top = d128->bytes[0] & 0x7f;     /* top byte, less sign bit */
 192   decNumberZero (dn);           /* clean target */
 193   /* set the sign if negative */
 194   if (decimal128Sign (d128))
 195     dn->bits = DECNEG;
 196
 197   if (top >= 0x78)
 198     {                           /* is a special */
 199       if ((top & 0x7c) == (DECIMAL_Inf & 0x7c))
 200         dn->bits |= DECINF;
 201       else if ((top & 0x7e) == (DECIMAL_NaN & 0x7e))
 202         dn->bits |= DECNAN;
 203       else
 204         dn->bits |= DECSNAN;
 205       msd = 0;                  /* no top digit */
 206     }
 207   else
 208     {                           /* have a finite number */
 209       uInt comb = top >> 2;     /* combination field */
 210       uInt exp;                 /* exponent */
 211
 212       if (comb >= 0x18)
 213         {
 214           msd = 8 + (comb & 0x01);
 215           exp = (comb & 0x06) << 11;    /* MSBs */
 216         }
 217       else
 218         {
 219           msd = comb & 0x07;
 220           exp = (comb & 0x18) << 9;
 221         }
 222       dn->exponent = exp + decimal128ExpCon (d128) - DECIMAL128_Bias;   /* remove bias */
 223     }
 224
 225   /* get the coefficient, unless infinite */
 226   if (!(dn->bits & DECINF))
 227     {
 228       Int bunches = DECIMAL128_Pmax / 3;        /* coefficient full bunches to convert */
 229       Int odd = 0;              /* assume MSD is 0 (no odd bunch) */
 230       if (msd != 0)
 231         {                       /* coefficient has leading non-0 digit */
 232           /* make a copy of the decimal128, with an extra bunch which has */
 233           /* the top digit ready for conversion */
 234           wk = *d128;           /* take a copy */
 235           wk.bytes[0] = 0;      /* clear all but coecon */
 236           wk.bytes[1] = 0;      /* .. */
 237           wk.bytes[2] &= 0x3f;  /* .. */
 238           wk.bytes[1] |= (msd >> 2);    /* and prefix MSD */
 239           wk.bytes[2] |= (msd << 6);    /* .. */
 240           odd++;                /* indicate the extra */
 241           d128 = &wk;           /* use the work copy */
 242         }
 243       decDenseUnpackCoeff (d128->bytes, sizeof (d128->bytes), dn, bunches,
 244                            odd);
 245     }
 246
 247   /* decNumberShow(dn); */
 248   return dn;
 249 }
 250
 251 /* ------------------------------------------------------------------ */
 252 /* to-scientific-string -- conversion to numeric string               */
 253 /* to-engineering-string -- conversion to numeric string              */
 254 /*                                                                    */
 255 /*   decimal128ToString(d128, string);                                */
 256 /*   decimal128ToEngString(d128, string);                             */
 257 /*                                                                    */
 258 /*  d128 is the decimal128 format number to convert                   */
 259 /*  string is the string where the result will be laid out            */
 260 /*                                                                    */
 261 /*  string must be at least 24 characters                             */
 262 /*                                                                    */
 263 /*  No error is possible, and no status can be set.                   */
 264 /* ------------------------------------------------------------------ */
 265 char *
 266 decimal128ToString (const decimal128 * d128, char *string)
 267 {
 268   decNumber dn;                 /* work */
 269   decimal128ToNumber (d128, &dn);
 270   decNumberToString (&dn, string);
 271   return string;
 272 }
 273
 274 char *
 275 decimal128ToEngString (const decimal128 * d128, char *string)
 276 {
 277   decNumber dn;                 /* work */
 278   decimal128ToNumber (d128, &dn);
 279   decNumberToEngString (&dn, string);
 280   return string;
 281 }
 282
 283 /* ------------------------------------------------------------------ */
 284 /* to-number -- conversion from numeric string                        */
 285 /*                                                                    */
 286 /*   decimal128FromString(result, string, set);                       */
 287 /*                                                                    */
 288 /*  result  is the decimal128 format number which gets the result of  */
 289 /*          the conversion                                            */
 290 /*  *string is the character string which should contain a valid      */
 291 /*          number (which may be a special value)                     */
 292 /*  set     is the context                                            */
 293 /*                                                                    */
 294 /* The context is supplied to this routine is used for error handling */
 295 /* (setting of status and traps) and for the rounding mode, only.     */
 296 /* If an error occurs, the result will be a valid decimal128 NaN.     */
 297 /* ------------------------------------------------------------------ */
 298 decimal128 *
 299 decimal128FromString (decimal128 * result, const char *string, decContext * set)
 300 {
 301   decContext dc;                /* work */
 302   decNumber dn;                 /* .. */
 303
 304   decContextDefault (&dc, DEC_INIT_DECIMAL128); /* no traps, please */
 305   dc.round = set->round;        /* use supplied rounding */
 306
 307   decNumberFromString (&dn, string, &dc);       /* will round if needed */
 308   decimal128FromNumber (result, &dn, &dc);
 309   if (dc.status != 0)
 310     {                           /* something happened */
 311       decContextSetStatus (set, dc.status);     /* .. pass it on */
 312     }
 313   return result;
 314 }
 315
 316
 317 #if DECTRACE || DECCHECK
 318 /* ------------------------------------------------------------------ */
 319 /* decimal128Show -- display a single in hexadecimal [debug aid]      */
 320 /*   d128 -- the number to show                                       */
 321 /* ------------------------------------------------------------------ */
 322 /* Also shows sign/cob/expconfields extracted */
 323 void
 324 decimal128Show (const decimal128 * d128)
 325 {
 326   char buf[DECIMAL128_Bytes * 2 + 1];
 327   Int i, j;
 328   j = 0;
 329   for (i = 0; i < DECIMAL128_Bytes; i++)
 330     {
 331       sprintf (&buf[j], "%02x", d128->bytes[i]);
 332       j = j + 2;
 333     }
 334   printf (" D128> %s [S:%d Cb:%02x E:%d]\n", buf,
 335           decimal128Sign (d128), decimal128Comb (d128),
 336           decimal128ExpCon (d128));
 337 }
 338 #endif