libgcc/config/libbid/bid64_string.c

   1 /* Copyright (C) 2007, 2009  Free Software Foundation, Inc.
   2
   3 This file is part of GCC.
   4
   5 GCC is free software; you can redistribute it and/or modify it under
   6 the terms of the GNU General Public License as published by the Free
   7 Software Foundation; either version 3, or (at your option) any later
   8 version.
   9
  10 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  11 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13 for more details.
  14
  15 Under Section 7 of GPL version 3, you are granted additional
  16 permissions described in the GCC Runtime Library Exception, version
  17 3.1, as published by the Free Software Foundation.
  18
  19 You should have received a copy of the GNU General Public License and
  20 a copy of the GCC Runtime Library Exception along with this program;
  21 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  22 <http://www.gnu.org/licenses/>.  */
  23
  24 #include <ctype.h>
  25 #include "bid_internal.h"
  26 #include "bid128_2_str.h"
  27 #include "bid128_2_str_macros.h"
  28
  29 #define MAX_FORMAT_DIGITS     16
  30 #define DECIMAL_EXPONENT_BIAS 398
  31 #define MAX_DECIMAL_EXPONENT  767
  32
  33 #if DECIMAL_CALL_BY_REFERENCE
  34
  35 void
  36 bid64_to_string (char *ps, UINT64 * px
  37                  _EXC_FLAGS_PARAM _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
  38   UINT64 x;
  39 #else
  40
  41 void
  42 bid64_to_string (char *ps, UINT64 x
  43                  _EXC_FLAGS_PARAM _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
  44 #endif
  45 // the destination string (pointed to by ps) must be pre-allocated
  46   UINT64 sign_x, coefficient_x, D, ER10;
  47   int istart, exponent_x, j, digits_x, bin_expon_cx;
  48   int_float tempx;
  49   UINT32 MiDi[12], *ptr;
  50   UINT64 HI_18Dig, LO_18Dig, Tmp;
  51   char *c_ptr_start, *c_ptr;
  52   int midi_ind, k_lcv, len;
  53   unsigned int save_fpsf;
  54
  55 #if DECIMAL_CALL_BY_REFERENCE
  56   x = *px;
  57 #endif
  58
  59   save_fpsf = *pfpsf; // place holder only
  60   // unpack arguments, check for NaN or Infinity
  61   if (!unpack_BID64 (&sign_x, &exponent_x, &coefficient_x, x)) {
  62     // x is Inf. or NaN or 0
  63
  64     // Inf or NaN?
  65     if ((x & 0x7800000000000000ull) == 0x7800000000000000ull) {
  66       if ((x & 0x7c00000000000000ull) == 0x7c00000000000000ull) {
  67     ps[0] = (sign_x) ? '-' : '+';
  68     ps[1] = ((x & MASK_SNAN) == MASK_SNAN)? 'S':'Q';
  69         ps[2] = 'N';
  70         ps[3] = 'a';
  71         ps[4] = 'N';
  72         ps[5] = 0;
  73         return;
  74       }
  75       // x is Inf
  76       ps[0] = (sign_x) ? '-' : '+';
  77       ps[1] = 'I';
  78       ps[2] = 'n';
  79       ps[3] = 'f';
  80       ps[4] = 0;
  81       return;
  82     }
  83     // 0
  84     istart = 0;
  85     if (sign_x) {
  86       ps[istart++] = '-';
  87     }
  88
  89     ps[istart++] = '0';
  90     ps[istart++] = 'E';
  91
  92     exponent_x -= 398;
  93     if (exponent_x < 0) {
  94       ps[istart++] = '-';
  95       exponent_x = -exponent_x;
  96     } else
  97       ps[istart++] = '+';
  98
  99     if (exponent_x) {
 100       // get decimal digits in coefficient_x
 101       tempx.d = (float) exponent_x;
 102       bin_expon_cx = ((tempx.i >> 23) & 0xff) - 0x7f;
 103       digits_x = estimate_decimal_digits[bin_expon_cx];
 104       if ((UINT64)exponent_x >= power10_table_128[digits_x].w[0])
 105         digits_x++;
 106
 107       j = istart + digits_x - 1;
 108       istart = j + 1;
 109
 110       // 2^32/10
 111       ER10 = 0x1999999a;
 112
 113       while (exponent_x > 9) {
 114         D = (UINT64) exponent_x *ER10;
 115         D >>= 32;
 116         exponent_x = exponent_x - (D << 1) - (D << 3);
 117
 118         ps[j--] = '0' + (char) exponent_x;
 119         exponent_x = D;
 120       }
 121       ps[j] = '0' + (char) exponent_x;
 122     } else {
 123       ps[istart++] = '0';
 124     }
 125
 126     ps[istart] = 0;
 127
 128     return;
 129   }
 130   // convert expon, coeff to ASCII
 131   exponent_x -= DECIMAL_EXPONENT_BIAS;
 132
 133   ER10 = 0x1999999a;
 134
 135   istart = 0;
 136   if (sign_x) {
 137     ps[0] = '-';
 138     istart = 1;
 139   }
 140   // if zero or non-canonical, set coefficient to '0'
 141   if ((coefficient_x > 9999999999999999ull) ||  // non-canonical
 142       ((coefficient_x == 0))    // significand is zero
 143     ) {
 144     ps[istart++] = '0';
 145   } else {
 146     /* ****************************************************
 147        This takes a bid coefficient in C1.w[1],C1.w[0]
 148        and put the converted character sequence at location
 149        starting at &(str[k]). The function returns the number
 150        of MiDi returned. Note that the character sequence
 151        does not have leading zeros EXCEPT when the input is of
 152        zero value. It will then output 1 character '0'
 153        The algorithm essentailly tries first to get a sequence of
 154        Millenial Digits "MiDi" and then uses table lookup to get the
 155        character strings of these MiDis.
 156        **************************************************** */
 157     /* Algorithm first decompose possibly 34 digits in hi and lo
 158        18 digits. (The high can have at most 16 digits). It then
 159        uses macro that handle 18 digit portions.
 160        The first step is to get hi and lo such that
 161        2^(64) C1.w[1] + C1.w[0] = hi * 10^18  + lo,   0 <= lo < 10^18.
 162        We use a table lookup method to obtain the hi and lo 18 digits.
 163        [C1.w[1],C1.w[0]] = c_8 2^(107) + c_7 2^(101) + ... + c_0 2^(59) + d
 164        where 0 <= d < 2^59 and each c_j has 6 bits. Because d fits in
 165        18 digits,  we set hi = 0, and lo = d to begin with.
 166        We then retrieve from a table, for j = 0, 1, ..., 8
 167        that gives us A and B where c_j 2^(59+6j) = A * 10^18 + B.
 168        hi += A ; lo += B; After each accumulation into lo, we normalize
 169        immediately. So at the end, we have the decomposition as we need. */
 170
 171     Tmp = coefficient_x >> 59;
 172     LO_18Dig = (coefficient_x << 5) >> 5;
 173     HI_18Dig = 0;
 174     k_lcv = 0;
 175
 176     while (Tmp) {
 177       midi_ind = (int) (Tmp & 0x000000000000003FLL);
 178       midi_ind <<= 1;
 179       Tmp >>= 6;
 180       HI_18Dig += mod10_18_tbl[k_lcv][midi_ind++];
 181       LO_18Dig += mod10_18_tbl[k_lcv++][midi_ind];
 182       __L0_Normalize_10to18 (HI_18Dig, LO_18Dig);
 183     }
 184
 185     ptr = MiDi;
 186     __L1_Split_MiDi_6_Lead (LO_18Dig, ptr);
 187     len = ptr - MiDi;
 188     c_ptr_start = &(ps[istart]);
 189     c_ptr = c_ptr_start;
 190
 191     /* now convert the MiDi into character strings */
 192     __L0_MiDi2Str_Lead (MiDi[0], c_ptr);
 193     for (k_lcv = 1; k_lcv < len; k_lcv++) {
 194       __L0_MiDi2Str (MiDi[k_lcv], c_ptr);
 195     }
 196     istart = istart + (c_ptr - c_ptr_start);
 197   }
 198
 199   ps[istart++] = 'E';
 200
 201   if (exponent_x < 0) {
 202     ps[istart++] = '-';
 203     exponent_x = -exponent_x;
 204   } else
 205     ps[istart++] = '+';
 206
 207   if (exponent_x) {
 208     // get decimal digits in coefficient_x
 209     tempx.d = (float) exponent_x;
 210     bin_expon_cx = ((tempx.i >> 23) & 0xff) - 0x7f;
 211     digits_x = estimate_decimal_digits[bin_expon_cx];
 212     if ((UINT64)exponent_x >= power10_table_128[digits_x].w[0])
 213       digits_x++;
 214
 215     j = istart + digits_x - 1;
 216     istart = j + 1;
 217
 218     // 2^32/10
 219     ER10 = 0x1999999a;
 220
 221     while (exponent_x > 9) {
 222       D = (UINT64) exponent_x *ER10;
 223       D >>= 32;
 224       exponent_x = exponent_x - (D << 1) - (D << 3);
 225
 226       ps[j--] = '0' + (char) exponent_x;
 227       exponent_x = D;
 228     }
 229     ps[j] = '0' + (char) exponent_x;
 230   } else {
 231     ps[istart++] = '0';
 232   }
 233
 234   ps[istart] = 0;
 235
 236   return;
 237
 238 }
 239
 240
 241 #if DECIMAL_CALL_BY_REFERENCE
 242 void
 243 bid64_from_string (UINT64 * pres, char *ps
 244                    _RND_MODE_PARAM _EXC_FLAGS_PARAM
 245                    _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 246 #else
 247 UINT64
 248 bid64_from_string (char *ps
 249                    _RND_MODE_PARAM _EXC_FLAGS_PARAM
 250                    _EXC_MASKS_PARAM _EXC_INFO_PARAM) {
 251 #endif
 252   UINT64 sign_x, coefficient_x = 0, rounded = 0, res;
 253   int expon_x = 0, sgn_expon, ndigits, add_expon = 0, midpoint =
 254     0, rounded_up = 0;
 255   int dec_expon_scale = 0, right_radix_leading_zeros = 0, rdx_pt_enc =
 256     0;
 257   unsigned fpsc;
 258   char c;
 259   unsigned int save_fpsf;
 260
 261 #if DECIMAL_CALL_BY_REFERENCE
 262 #if !DECIMAL_GLOBAL_ROUNDING
 263   _IDEC_round rnd_mode = *prnd_mode;
 264 #endif
 265 #endif
 266
 267   save_fpsf = *pfpsf; // place holder only
 268   // eliminate leading whitespace
 269   while (((*ps == ' ') || (*ps == '\t')) && (*ps))
 270     ps++;
 271
 272   // get first non-whitespace character
 273   c = *ps;
 274
 275   // detect special cases (INF or NaN)
 276   if (!c || (c != '.' && c != '-' && c != '+' && (c < '0' || c > '9'))) {
 277     // Infinity?
 278     if ((tolower_macro (ps[0]) == 'i' && tolower_macro (ps[1]) == 'n' &&
 279         tolower_macro (ps[2]) == 'f') && (!ps[3] ||
 280         (tolower_macro (ps[3]) == 'i' &&
 281         tolower_macro (ps[4]) == 'n' && tolower_macro (ps[5]) == 'i' &&
 282         tolower_macro (ps[6]) == 't' && tolower_macro (ps[7]) == 'y' &&
 283         !ps[8]))) {
 284       res = 0x7800000000000000ull;
 285       BID_RETURN (res);
 286     }
 287     // return sNaN
 288     if (tolower_macro (ps[0]) == 's' && tolower_macro (ps[1]) == 'n' &&
 289         tolower_macro (ps[2]) == 'a' && tolower_macro (ps[3]) == 'n') {
 290         // case insensitive check for snan
 291       res = 0x7e00000000000000ull;
 292       BID_RETURN (res);
 293     } else {
 294       // return qNaN
 295       res = 0x7c00000000000000ull;
 296       BID_RETURN (res);
 297     }
 298   }
 299   // detect +INF or -INF
 300   if ((tolower_macro (ps[1]) == 'i' && tolower_macro (ps[2]) == 'n' &&
 301       tolower_macro (ps[3]) == 'f') && (!ps[4] ||
 302       (tolower_macro (ps[4]) == 'i' && tolower_macro (ps[5]) == 'n' &&
 303       tolower_macro (ps[6]) == 'i' && tolower_macro (ps[7]) == 't' &&
 304       tolower_macro (ps[8]) == 'y' && !ps[9]))) {
 305     if (c == '+')
 306       res = 0x7800000000000000ull;
 307     else if (c == '-')
 308       res = 0xf800000000000000ull;
 309     else
 310       res = 0x7c00000000000000ull;
 311     BID_RETURN (res);
 312   }
 313   // if +sNaN, +SNaN, -sNaN, or -SNaN
 314   if (tolower_macro (ps[1]) == 's' && tolower_macro (ps[2]) == 'n'
 315       && tolower_macro (ps[3]) == 'a' && tolower_macro (ps[4]) == 'n') {
 316     if (c == '-')
 317       res = 0xfe00000000000000ull;
 318     else
 319       res = 0x7e00000000000000ull;
 320     BID_RETURN (res);
 321   }
 322   // determine sign
 323   if (c == '-')
 324     sign_x = 0x8000000000000000ull;
 325   else
 326     sign_x = 0;
 327
 328   // get next character if leading +/- sign
 329   if (c == '-' || c == '+') {
 330     ps++;
 331     c = *ps;
 332   }
 333   // if c isn't a decimal point or a decimal digit, return NaN
 334   if (c != '.' && (c < '0' || c > '9')) {
 335     // return NaN
 336     res = 0x7c00000000000000ull | sign_x;
 337     BID_RETURN (res);
 338   }
 339
 340   rdx_pt_enc = 0;
 341
 342   // detect zero (and eliminate/ignore leading zeros)
 343   if (*(ps) == '0' || *(ps) == '.') {
 344
 345     if (*(ps) == '.') {
 346       rdx_pt_enc = 1;
 347       ps++;
 348     }
 349     // if all numbers are zeros (with possibly 1 radix point, the number is zero
 350     // should catch cases such as: 000.0
 351     while (*ps == '0') {
 352       ps++;
 353       // for numbers such as 0.0000000000000000000000000000000000001001,
 354       // we want to count the leading zeros
 355       if (rdx_pt_enc) {
 356         right_radix_leading_zeros++;
 357       }
 358       // if this character is a radix point, make sure we haven't already
 359       // encountered one
 360       if (*(ps) == '.') {
 361         if (rdx_pt_enc == 0) {
 362           rdx_pt_enc = 1;
 363           // if this is the first radix point, and the next character is NULL,
 364           // we have a zero
 365           if (!*(ps + 1)) {
 366             res =
 367               ((UINT64) (398 - right_radix_leading_zeros) << 53) |
 368               sign_x;
 369             BID_RETURN (res);
 370           }
 371           ps = ps + 1;
 372         } else {
 373           // if 2 radix points, return NaN
 374           res = 0x7c00000000000000ull | sign_x;
 375           BID_RETURN (res);
 376         }
 377       } else if (!*(ps)) {
 378         //pres->w[1] = 0x3040000000000000ull | sign_x;
 379         res =
 380           ((UINT64) (398 - right_radix_leading_zeros) << 53) | sign_x;
 381         BID_RETURN (res);
 382       }
 383     }
 384   }
 385
 386   c = *ps;
 387
 388   ndigits = 0;
 389   while ((c >= '0' && c <= '9') || c == '.') {
 390     if (c == '.') {
 391       if (rdx_pt_enc) {
 392         // return NaN
 393         res = 0x7c00000000000000ull | sign_x;
 394         BID_RETURN (res);
 395       }
 396       rdx_pt_enc = 1;
 397       ps++;
 398       c = *ps;
 399       continue;
 400     }
 401     dec_expon_scale += rdx_pt_enc;
 402
 403     ndigits++;
 404     if (ndigits <= 16) {
 405       coefficient_x = (coefficient_x << 1) + (coefficient_x << 3);
 406       coefficient_x += (UINT64) (c - '0');
 407     } else if (ndigits == 17) {
 408       // coefficient rounding
 409                 switch(rnd_mode){
 410         case ROUNDING_TO_NEAREST:
 411       midpoint = (c == '5' && !(coefficient_x & 1)) ? 1 : 0;
 412           // if coefficient is even and c is 5, prepare to round up if
 413           // subsequent digit is nonzero
 414       // if str[MAXDIG+1] > 5, we MUST round up
 415       // if str[MAXDIG+1] == 5 and coefficient is ODD, ROUND UP!
 416       if (c > '5' || (c == '5' && (coefficient_x & 1))) {
 417         coefficient_x++;
 418         rounded_up = 1;
 419         break;
 420
 421         case ROUNDING_DOWN:
 422                 if(sign_x) { coefficient_x++; rounded_up=1; }
 423                 break;
 424         case ROUNDING_UP:
 425                 if(!sign_x) { coefficient_x++; rounded_up=1; }
 426                 break;
 427         case ROUNDING_TIES_AWAY:
 428                 if(c>='5') { coefficient_x++; rounded_up=1; }
 429                 break;
 430           }
 431         if (coefficient_x == 10000000000000000ull) {
 432           coefficient_x = 1000000000000000ull;
 433           add_expon = 1;
 434         }
 435       }
 436       if (c > '0')
 437         rounded = 1;
 438       add_expon += 1;
 439     } else { // ndigits > 17
 440       add_expon++;
 441       if (midpoint && c > '0') {
 442         coefficient_x++;
 443         midpoint = 0;
 444         rounded_up = 1;
 445       }
 446       if (c > '0')
 447         rounded = 1;
 448     }
 449     ps++;
 450     c = *ps;
 451   }
 452
 453   add_expon -= (dec_expon_scale + right_radix_leading_zeros);
 454
 455   if (!c) {
 456     res =
 457       fast_get_BID64_check_OF (sign_x,
 458                                add_expon + DECIMAL_EXPONENT_BIAS,
 459                                coefficient_x, 0, &fpsc);
 460     BID_RETURN (res);
 461   }
 462
 463   if (c != 'E' && c != 'e') {
 464     // return NaN
 465     res = 0x7c00000000000000ull | sign_x;
 466     BID_RETURN (res);
 467   }
 468   ps++;
 469   c = *ps;
 470   sgn_expon = (c == '-') ? 1 : 0;
 471   if (c == '-' || c == '+') {
 472     ps++;
 473     c = *ps;
 474   }
 475   if (!c || c < '0' || c > '9') {
 476     // return NaN
 477     res = 0x7c00000000000000ull | sign_x;
 478     BID_RETURN (res);
 479   }
 480
 481   while (c >= '0' && c <= '9') {
 482     expon_x = (expon_x << 1) + (expon_x << 3);
 483     expon_x += (int) (c - '0');
 484
 485     ps++;
 486     c = *ps;
 487   }
 488
 489   if (c) {
 490     // return NaN
 491     res = 0x7c00000000000000ull | sign_x;
 492     BID_RETURN (res);
 493   }
 494
 495   if (sgn_expon)
 496     expon_x = -expon_x;
 497
 498   expon_x += add_expon + DECIMAL_EXPONENT_BIAS;
 499
 500   if (expon_x < 0) {
 501     if (rounded_up)
 502       coefficient_x--;
 503     rnd_mode = 0;
 504     res =
 505       get_BID64_UF (sign_x, expon_x, coefficient_x, rounded, rnd_mode,
 506                     &fpsc);
 507     BID_RETURN (res);
 508   }
 509   res = get_BID64 (sign_x, expon_x, coefficient_x, rnd_mode, &fpsc);
 510   BID_RETURN (res);
 511 }