gas/atof-generic.c

   1 /* atof_generic.c - turn a string of digits into a Flonum
   2    Copyright (C) 1987-2019 Free Software Foundation, Inc.
   3
   4    This file is part of GAS, the GNU Assembler.
   5
   6    GAS is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3, or (at your option)
   9    any later version.
  10
  11    GAS is distributed in the hope that it will be useful, but WITHOUT
  12    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  14    License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with GAS; see the file COPYING.  If not, write to the Free
  18    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
  19    02110-1301, USA.  */
  20
  21 #include "as.h"
  22 #include "safe-ctype.h"
  23
  24 #ifndef FALSE
  25 #define FALSE (0)
  26 #endif
  27 #ifndef TRUE
  28 #define TRUE  (1)
  29 #endif
  30
  31 #ifdef TRACE
  32 static void flonum_print (const FLONUM_TYPE *);
  33 #endif
  34
  35 #define ASSUME_DECIMAL_MARK_IS_DOT
  36
  37 /***********************************************************************\
  38  *                                                                      *
  39  *      Given a string of decimal digits , with optional decimal        *
  40  *      mark and optional decimal exponent (place value) of the         *
  41  *      lowest_order decimal digit: produce a floating point            *
  42  *      number. The number is 'generic' floating point: our             *
  43  *      caller will encode it for a specific machine architecture.      *
  44  *                                                                      *
  45  *      Assumptions                                                     *
  46  *              uses base (radix) 2                                     *
  47  *              this machine uses 2's complement binary integers        *
  48  *              target flonums use "      "         "       "           *
  49  *              target flonums exponents fit in a long                  *
  50  *                                                                      *
  51  \***********************************************************************/
  52
  53 /*
  54
  55   Syntax:
  56
  57   <flonum> ::= <optional-sign> <decimal-number> <optional-exponent>
  58   <optional-sign> ::= '+' | '-' | {empty}
  59   <decimal-number> ::= <integer>
  60   | <integer> <radix-character>
  61   | <integer> <radix-character> <integer>
  62   | <radix-character> <integer>
  63
  64   <optional-exponent> ::= {empty}
  65   | <exponent-character> <optional-sign> <integer>
  66
  67   <integer> ::= <digit> | <digit> <integer>
  68   <digit> ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
  69   <exponent-character> ::= {one character from "string_of_decimal_exponent_marks"}
  70   <radix-character> ::= {one character from "string_of_decimal_marks"}
  71
  72   */
  73
  74 int
  75 atof_generic (/* return pointer to just AFTER number we read.  */
  76               char **address_of_string_pointer,
  77               /* At most one per number.  */
  78               const char *string_of_decimal_marks,
  79               const char *string_of_decimal_exponent_marks,
  80               FLONUM_TYPE *address_of_generic_floating_point_number)
  81 {
  82   int return_value;             /* 0 means OK.  */
  83   char *first_digit;
  84   unsigned int number_of_digits_before_decimal;
  85   unsigned int number_of_digits_after_decimal;
  86   long decimal_exponent;
  87   unsigned int number_of_digits_available;
  88   char digits_sign_char;
  89
  90   /*
  91    * Scan the input string, abstracting (1)digits (2)decimal mark (3) exponent.
  92    * It would be simpler to modify the string, but we don't; just to be nice
  93    * to caller.
  94    * We need to know how many digits we have, so we can allocate space for
  95    * the digits' value.
  96    */
  97
  98   char *p;
  99   char c;
 100   int seen_significant_digit;
 101
 102 #ifdef ASSUME_DECIMAL_MARK_IS_DOT
 103   gas_assert (string_of_decimal_marks[0] == '.'
 104           && string_of_decimal_marks[1] == 0);
 105 #define IS_DECIMAL_MARK(c)      ((c) == '.')
 106 #else
 107 #define IS_DECIMAL_MARK(c)      (0 != strchr (string_of_decimal_marks, (c)))
 108 #endif
 109
 110   first_digit = *address_of_string_pointer;
 111   c = *first_digit;
 112
 113   if (c == '-' || c == '+')
 114     {
 115       digits_sign_char = c;
 116       first_digit++;
 117     }
 118   else
 119     digits_sign_char = '+';
 120
 121   switch (first_digit[0])
 122     {
 123     case 'n':
 124     case 'N':
 125       if (!strncasecmp ("nan", first_digit, 3))
 126         {
 127           address_of_generic_floating_point_number->sign = 0;
 128           address_of_generic_floating_point_number->exponent = 0;
 129           address_of_generic_floating_point_number->leader =
 130             address_of_generic_floating_point_number->low;
 131           *address_of_string_pointer = first_digit + 3;
 132           return 0;
 133         }
 134       break;
 135
 136     case 'i':
 137     case 'I':
 138       if (!strncasecmp ("inf", first_digit, 3))
 139         {
 140           address_of_generic_floating_point_number->sign =
 141             digits_sign_char == '+' ? 'P' : 'N';
 142           address_of_generic_floating_point_number->exponent = 0;
 143           address_of_generic_floating_point_number->leader =
 144             address_of_generic_floating_point_number->low;
 145
 146           first_digit += 3;
 147           if (!strncasecmp ("inity", first_digit, 5))
 148             first_digit += 5;
 149
 150           *address_of_string_pointer = first_digit;
 151
 152           return 0;
 153         }
 154       break;
 155     }
 156
 157   number_of_digits_before_decimal = 0;
 158   number_of_digits_after_decimal = 0;
 159   decimal_exponent = 0;
 160   seen_significant_digit = 0;
 161   for (p = first_digit;
 162        (((c = *p) != '\0')
 163         && (!c || !IS_DECIMAL_MARK (c))
 164         && (!c || !strchr (string_of_decimal_exponent_marks, c)));
 165        p++)
 166     {
 167       if (ISDIGIT (c))
 168         {
 169           if (seen_significant_digit || c > '0')
 170             {
 171               ++number_of_digits_before_decimal;
 172               seen_significant_digit = 1;
 173             }
 174           else
 175             {
 176               first_digit++;
 177             }
 178         }
 179       else
 180         {
 181           break;                /* p -> char after pre-decimal digits.  */
 182         }
 183     }                           /* For each digit before decimal mark.  */
 184
 185 #ifndef OLD_FLOAT_READS
 186   /* Ignore trailing 0's after the decimal point.  The original code here
 187      (ifdef'd out) does not do this, and numbers like
 188         4.29496729600000000000e+09      (2**31)
 189      come out inexact for some reason related to length of the digit
 190      string.  */
 191
 192   /* The case number_of_digits_before_decimal = 0 is handled for
 193      deleting zeros after decimal.  In this case the decimal mark and
 194      the first zero digits after decimal mark are skipped.  */
 195   seen_significant_digit = 0;
 196   signed long subtract_decimal_exponent = 0;
 197
 198   if (c && IS_DECIMAL_MARK (c))
 199     {
 200       unsigned int zeros = 0;   /* Length of current string of zeros.  */
 201
 202       if (number_of_digits_before_decimal == 0)
 203         /* Skip decimal mark.  */
 204         first_digit++;
 205
 206       for (p++; (c = *p) && ISDIGIT (c); p++)
 207         {
 208           if (c == '0')
 209             {
 210               if (number_of_digits_before_decimal == 0
 211                   && !seen_significant_digit)
 212                 {
 213                   /* Skip '0' and the decimal mark.  */
 214                   first_digit++;
 215                   subtract_decimal_exponent--;
 216                 }
 217               else
 218                 zeros++;
 219             }
 220           else
 221             {
 222               seen_significant_digit = 1;
 223               number_of_digits_after_decimal += 1 + zeros;
 224               zeros = 0;
 225             }
 226         }
 227     }
 228 #else
 229   if (c && IS_DECIMAL_MARK (c))
 230     {
 231       for (p++;
 232            (((c = *p) != '\0')
 233             && (!c || !strchr (string_of_decimal_exponent_marks, c)));
 234            p++)
 235         {
 236           if (ISDIGIT (c))
 237             {
 238               /* This may be retracted below.  */
 239               number_of_digits_after_decimal++;
 240
 241               if ( /* seen_significant_digit || */ c > '0')
 242                 {
 243                   seen_significant_digit = TRUE;
 244                 }
 245             }
 246           else
 247             {
 248               if (!seen_significant_digit)
 249                 {
 250                   number_of_digits_after_decimal = 0;
 251                 }
 252               break;
 253             }
 254         }                       /* For each digit after decimal mark.  */
 255     }
 256
 257   while (number_of_digits_after_decimal
 258          && first_digit[number_of_digits_before_decimal
 259                         + number_of_digits_after_decimal] == '0')
 260     --number_of_digits_after_decimal;
 261 #endif
 262
 263   if (flag_m68k_mri)
 264     {
 265       while (c == '_')
 266         c = *++p;
 267     }
 268   if (c && strchr (string_of_decimal_exponent_marks, c))
 269     {
 270       char digits_exponent_sign_char;
 271
 272       c = *++p;
 273       if (flag_m68k_mri)
 274         {
 275           while (c == '_')
 276             c = *++p;
 277         }
 278       if (c && strchr ("+-", c))
 279         {
 280           digits_exponent_sign_char = c;
 281           c = *++p;
 282         }
 283       else
 284         {
 285           digits_exponent_sign_char = '+';
 286         }
 287
 288       for (; (c); c = *++p)
 289         {
 290           if (ISDIGIT (c))
 291             {
 292               decimal_exponent = decimal_exponent * 10 + c - '0';
 293               /*
 294                * BUG! If we overflow here, we lose!
 295                */
 296             }
 297           else
 298             {
 299               break;
 300             }
 301         }
 302
 303       if (digits_exponent_sign_char == '-')
 304         {
 305           decimal_exponent = -decimal_exponent;
 306         }
 307     }
 308
 309 #ifndef OLD_FLOAT_READS
 310   /* Subtract_decimal_exponent != 0 when number_of_digits_before_decimal = 0
 311      and first digit after decimal is '0'.  */
 312   decimal_exponent += subtract_decimal_exponent;
 313 #endif
 314
 315   *address_of_string_pointer = p;
 316
 317   number_of_digits_available =
 318     number_of_digits_before_decimal + number_of_digits_after_decimal;
 319   return_value = 0;
 320   if (number_of_digits_available == 0)
 321     {
 322       address_of_generic_floating_point_number->exponent = 0;   /* Not strictly necessary */
 323       address_of_generic_floating_point_number->leader
 324         = -1 + address_of_generic_floating_point_number->low;
 325       address_of_generic_floating_point_number->sign = digits_sign_char;
 326       /* We have just concocted (+/-)0.0E0 */
 327
 328     }
 329   else
 330     {
 331       int count;                /* Number of useful digits left to scan.  */
 332
 333       LITTLENUM_TYPE *temporary_binary_low = NULL;
 334       LITTLENUM_TYPE *power_binary_low = NULL;
 335       LITTLENUM_TYPE *digits_binary_low;
 336       unsigned int precision;
 337       unsigned int maximum_useful_digits;
 338       unsigned int number_of_digits_to_use;
 339       unsigned int more_than_enough_bits_for_digits;
 340       unsigned int more_than_enough_littlenums_for_digits;
 341       unsigned int size_of_digits_in_littlenums;
 342       unsigned int size_of_digits_in_chars;
 343       FLONUM_TYPE power_of_10_flonum;
 344       FLONUM_TYPE digits_flonum;
 345
 346       precision = (address_of_generic_floating_point_number->high
 347                    - address_of_generic_floating_point_number->low
 348                    + 1);        /* Number of destination littlenums.  */
 349
 350       /* Includes guard bits (two littlenums worth) */
 351       maximum_useful_digits = (((precision - 2))
 352                                * ( (LITTLENUM_NUMBER_OF_BITS))
 353                                * 1000000 / 3321928)
 354         + 2;                    /* 2 :: guard digits.  */
 355
 356       if (number_of_digits_available > maximum_useful_digits)
 357         {
 358           number_of_digits_to_use = maximum_useful_digits;
 359         }
 360       else
 361         {
 362           number_of_digits_to_use = number_of_digits_available;
 363         }
 364
 365       /* Cast these to SIGNED LONG first, otherwise, on systems with
 366          LONG wider than INT (such as Alpha OSF/1), unsignedness may
 367          cause unexpected results.  */
 368       decimal_exponent += ((long) number_of_digits_before_decimal
 369                            - (long) number_of_digits_to_use);
 370
 371       more_than_enough_bits_for_digits
 372         = (number_of_digits_to_use * 3321928 / 1000000 + 1);
 373
 374       more_than_enough_littlenums_for_digits
 375         = (more_than_enough_bits_for_digits
 376            / LITTLENUM_NUMBER_OF_BITS)
 377         + 2;
 378
 379       /* Compute (digits) part. In "12.34E56" this is the "1234" part.
 380          Arithmetic is exact here. If no digits are supplied then this
 381          part is a 0 valued binary integer.  Allocate room to build up
 382          the binary number as littlenums.  We want this memory to
 383          disappear when we leave this function.  Assume no alignment
 384          problems => (room for n objects) == n * (room for 1
 385          object).  */
 386
 387       size_of_digits_in_littlenums = more_than_enough_littlenums_for_digits;
 388       size_of_digits_in_chars = size_of_digits_in_littlenums
 389         * sizeof (LITTLENUM_TYPE);
 390
 391       digits_binary_low = (LITTLENUM_TYPE *)
 392         xmalloc (size_of_digits_in_chars);
 393
 394       memset ((char *) digits_binary_low, '\0', size_of_digits_in_chars);
 395
 396       /* Digits_binary_low[] is allocated and zeroed.  */
 397
 398       /*
 399        * Parse the decimal digits as if * digits_low was in the units position.
 400        * Emit a binary number into digits_binary_low[].
 401        *
 402        * Use a large-precision version of:
 403        * (((1st-digit) * 10 + 2nd-digit) * 10 + 3rd-digit ...) * 10 + last-digit
 404        */
 405
 406       for (p = first_digit, count = number_of_digits_to_use; count; p++, --count)
 407         {
 408           c = *p;
 409           if (ISDIGIT (c))
 410             {
 411               /*
 412                * Multiply by 10. Assume can never overflow.
 413                * Add this digit to digits_binary_low[].
 414                */
 415
 416               long carry;
 417               LITTLENUM_TYPE *littlenum_pointer;
 418               LITTLENUM_TYPE *littlenum_limit;
 419
 420               littlenum_limit = digits_binary_low
 421                 + more_than_enough_littlenums_for_digits
 422                 - 1;
 423
 424               carry = c - '0';  /* char -> binary */
 425
 426               for (littlenum_pointer = digits_binary_low;
 427                    littlenum_pointer <= littlenum_limit;
 428                    littlenum_pointer++)
 429                 {
 430                   long work;
 431
 432                   work = carry + 10 * (long) (*littlenum_pointer);
 433                   *littlenum_pointer = work & LITTLENUM_MASK;
 434                   carry = work >> LITTLENUM_NUMBER_OF_BITS;
 435                 }
 436
 437               if (carry != 0)
 438                 {
 439                   /*
 440                    * We have a GROSS internal error.
 441                    * This should never happen.
 442                    */
 443                   as_fatal (_("failed sanity check"));
 444                 }
 445             }
 446           else
 447             {
 448               ++count;          /* '.' doesn't alter digits used count.  */
 449             }
 450         }
 451
 452       /*
 453        * Digits_binary_low[] properly encodes the value of the digits.
 454        * Forget about any high-order littlenums that are 0.
 455        */
 456       while (digits_binary_low[size_of_digits_in_littlenums - 1] == 0
 457              && size_of_digits_in_littlenums >= 2)
 458         size_of_digits_in_littlenums--;
 459
 460       digits_flonum.low = digits_binary_low;
 461       digits_flonum.high = digits_binary_low + size_of_digits_in_littlenums - 1;
 462       digits_flonum.leader = digits_flonum.high;
 463       digits_flonum.exponent = 0;
 464       /*
 465        * The value of digits_flonum . sign should not be important.
 466        * We have already decided the output's sign.
 467        * We trust that the sign won't influence the other parts of the number!
 468        * So we give it a value for these reasons:
 469        * (1) courtesy to humans reading/debugging
 470        *     these numbers so they don't get excited about strange values
 471        * (2) in future there may be more meaning attached to sign,
 472        *     and what was
 473        *     harmless noise may become disruptive, ill-conditioned (or worse)
 474        *     input.
 475        */
 476       digits_flonum.sign = '+';
 477
 478       {
 479         /*
 480          * Compute the mantissa (& exponent) of the power of 10.
 481          * If successful, then multiply the power of 10 by the digits
 482          * giving return_binary_mantissa and return_binary_exponent.
 483          */
 484
 485         int decimal_exponent_is_negative;
 486         /* This refers to the "-56" in "12.34E-56".  */
 487         /* FALSE: decimal_exponent is positive (or 0) */
 488         /* TRUE:  decimal_exponent is negative */
 489         FLONUM_TYPE temporary_flonum;
 490         unsigned int size_of_power_in_littlenums;
 491         unsigned int size_of_power_in_chars;
 492
 493         size_of_power_in_littlenums = precision;
 494         /* Precision has a built-in fudge factor so we get a few guard bits.  */
 495
 496         decimal_exponent_is_negative = decimal_exponent < 0;
 497         if (decimal_exponent_is_negative)
 498           {
 499             decimal_exponent = -decimal_exponent;
 500           }
 501
 502         /* From now on: the decimal exponent is > 0. Its sign is separate.  */
 503
 504         size_of_power_in_chars = size_of_power_in_littlenums
 505           * sizeof (LITTLENUM_TYPE) + 2;
 506
 507         power_binary_low = (LITTLENUM_TYPE *) xmalloc (size_of_power_in_chars);
 508         temporary_binary_low = (LITTLENUM_TYPE *) xmalloc (size_of_power_in_chars);
 509
 510         memset ((char *) power_binary_low, '\0', size_of_power_in_chars);
 511         *power_binary_low = 1;
 512         power_of_10_flonum.exponent = 0;
 513         power_of_10_flonum.low = power_binary_low;
 514         power_of_10_flonum.leader = power_binary_low;
 515         power_of_10_flonum.high = power_binary_low + size_of_power_in_littlenums - 1;
 516         power_of_10_flonum.sign = '+';
 517         temporary_flonum.low = temporary_binary_low;
 518         temporary_flonum.high = temporary_binary_low + size_of_power_in_littlenums - 1;
 519         /*
 520          * (power) == 1.
 521          * Space for temporary_flonum allocated.
 522          */
 523
 524         /*
 525          * ...
 526          *
 527          * WHILE        more bits
 528          * DO   find next bit (with place value)
 529          *      multiply into power mantissa
 530          * OD
 531          */
 532         {
 533           int place_number_limit;
 534           /* Any 10^(2^n) whose "n" exceeds this */
 535           /* value will fall off the end of */
 536           /* flonum_XXXX_powers_of_ten[].  */
 537           int place_number;
 538           const FLONUM_TYPE *multiplicand;      /* -> 10^(2^n) */
 539
 540           place_number_limit = table_size_of_flonum_powers_of_ten;
 541
 542           multiplicand = (decimal_exponent_is_negative
 543                           ? flonum_negative_powers_of_ten
 544                           : flonum_positive_powers_of_ten);
 545
 546           for (place_number = 1;/* Place value of this bit of exponent.  */
 547                decimal_exponent;/* Quit when no more 1 bits in exponent.  */
 548                decimal_exponent >>= 1, place_number++)
 549             {
 550               if (decimal_exponent & 1)
 551                 {
 552                   if (place_number > place_number_limit)
 553                     {
 554                       /* The decimal exponent has a magnitude so great
 555                          that our tables can't help us fragment it.
 556                          Although this routine is in error because it
 557                          can't imagine a number that big, signal an
 558                          error as if it is the user's fault for
 559                          presenting such a big number.  */
 560                       return_value = ERROR_EXPONENT_OVERFLOW;
 561                       /* quit out of loop gracefully */
 562                       decimal_exponent = 0;
 563                     }
 564                   else
 565                     {
 566 #ifdef TRACE
 567                       printf ("before multiply, place_number = %d., power_of_10_flonum:\n",
 568                               place_number);
 569
 570                       flonum_print (&power_of_10_flonum);
 571                       (void) putchar ('\n');
 572 #endif
 573 #ifdef TRACE
 574                       printf ("multiplier:\n");
 575                       flonum_print (multiplicand + place_number);
 576                       (void) putchar ('\n');
 577 #endif
 578                       flonum_multip (multiplicand + place_number,
 579                                      &power_of_10_flonum, &temporary_flonum);
 580 #ifdef TRACE
 581                       printf ("after multiply:\n");
 582                       flonum_print (&temporary_flonum);
 583                       (void) putchar ('\n');
 584 #endif
 585                       flonum_copy (&temporary_flonum, &power_of_10_flonum);
 586 #ifdef TRACE
 587                       printf ("after copy:\n");
 588                       flonum_print (&power_of_10_flonum);
 589                       (void) putchar ('\n');
 590 #endif
 591                     } /* If this bit of decimal_exponent was computable.*/
 592                 } /* If this bit of decimal_exponent was set.  */
 593             } /* For each bit of binary representation of exponent */
 594 #ifdef TRACE
 595           printf ("after computing power_of_10_flonum:\n");
 596           flonum_print (&power_of_10_flonum);
 597           (void) putchar ('\n');
 598 #endif
 599         }
 600       }
 601
 602       /*
 603        * power_of_10_flonum is power of ten in binary (mantissa) , (exponent).
 604        * It may be the number 1, in which case we don't NEED to multiply.
 605        *
 606        * Multiply (decimal digits) by power_of_10_flonum.
 607        */
 608
 609       flonum_multip (&power_of_10_flonum, &digits_flonum, address_of_generic_floating_point_number);
 610       /* Assert sign of the number we made is '+'.  */
 611       address_of_generic_floating_point_number->sign = digits_sign_char;
 612
 613       if (temporary_binary_low)
 614         free (temporary_binary_low);
 615       if (power_binary_low)
 616         free (power_binary_low);
 617       free (digits_binary_low);
 618     }
 619   return return_value;
 620 }
 621
 622 #ifdef TRACE
 623 static void
 624 flonum_print (f)
 625      const FLONUM_TYPE *f;
 626 {
 627   LITTLENUM_TYPE *lp;
 628   char littlenum_format[10];
 629   sprintf (littlenum_format, " %%0%dx", sizeof (LITTLENUM_TYPE) * 2);
 630 #define print_littlenum(LP)     (printf (littlenum_format, LP))
 631   printf ("flonum @%p %c e%ld", f, f->sign, f->exponent);
 632   if (f->low < f->high)
 633     for (lp = f->high; lp >= f->low; lp--)
 634       print_littlenum (*lp);
 635   else
 636     for (lp = f->low; lp <= f->high; lp++)
 637       print_littlenum (*lp);
 638   printf ("\n");
 639   fflush (stdout);
 640 }
 641 #endif
 642
 643 /* end of atof_generic.c */