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   if (c && IS_DECIMAL_MARK (c))
 193     {
 194       unsigned int zeros = 0;   /* Length of current string of zeros */
 195
 196       for (p++; (c = *p) && ISDIGIT (c); p++)
 197         {
 198           if (c == '0')
 199             {
 200               zeros++;
 201             }
 202           else
 203             {
 204               number_of_digits_after_decimal += 1 + zeros;
 205               zeros = 0;
 206             }
 207         }
 208     }
 209 #else
 210   if (c && IS_DECIMAL_MARK (c))
 211     {
 212       for (p++;
 213            (((c = *p) != '\0')
 214             && (!c || !strchr (string_of_decimal_exponent_marks, c)));
 215            p++)
 216         {
 217           if (ISDIGIT (c))
 218             {
 219               /* This may be retracted below.  */
 220               number_of_digits_after_decimal++;
 221
 222               if ( /* seen_significant_digit || */ c > '0')
 223                 {
 224                   seen_significant_digit = TRUE;
 225                 }
 226             }
 227           else
 228             {
 229               if (!seen_significant_digit)
 230                 {
 231                   number_of_digits_after_decimal = 0;
 232                 }
 233               break;
 234             }
 235         }                       /* For each digit after decimal mark.  */
 236     }
 237
 238   while (number_of_digits_after_decimal
 239          && first_digit[number_of_digits_before_decimal
 240                         + number_of_digits_after_decimal] == '0')
 241     --number_of_digits_after_decimal;
 242 #endif
 243
 244   if (flag_m68k_mri)
 245     {
 246       while (c == '_')
 247         c = *++p;
 248     }
 249   if (c && strchr (string_of_decimal_exponent_marks, c))
 250     {
 251       char digits_exponent_sign_char;
 252
 253       c = *++p;
 254       if (flag_m68k_mri)
 255         {
 256           while (c == '_')
 257             c = *++p;
 258         }
 259       if (c && strchr ("+-", c))
 260         {
 261           digits_exponent_sign_char = c;
 262           c = *++p;
 263         }
 264       else
 265         {
 266           digits_exponent_sign_char = '+';
 267         }
 268
 269       for (; (c); c = *++p)
 270         {
 271           if (ISDIGIT (c))
 272             {
 273               decimal_exponent = decimal_exponent * 10 + c - '0';
 274               /*
 275                * BUG! If we overflow here, we lose!
 276                */
 277             }
 278           else
 279             {
 280               break;
 281             }
 282         }
 283
 284       if (digits_exponent_sign_char == '-')
 285         {
 286           decimal_exponent = -decimal_exponent;
 287         }
 288     }
 289
 290   *address_of_string_pointer = p;
 291
 292   number_of_digits_available =
 293     number_of_digits_before_decimal + number_of_digits_after_decimal;
 294   return_value = 0;
 295   if (number_of_digits_available == 0)
 296     {
 297       address_of_generic_floating_point_number->exponent = 0;   /* Not strictly necessary */
 298       address_of_generic_floating_point_number->leader
 299         = -1 + address_of_generic_floating_point_number->low;
 300       address_of_generic_floating_point_number->sign = digits_sign_char;
 301       /* We have just concocted (+/-)0.0E0 */
 302
 303     }
 304   else
 305     {
 306       int count;                /* Number of useful digits left to scan.  */
 307
 308       LITTLENUM_TYPE *temporary_binary_low = NULL;
 309       LITTLENUM_TYPE *power_binary_low = NULL;
 310       LITTLENUM_TYPE *digits_binary_low;
 311       unsigned int precision;
 312       unsigned int maximum_useful_digits;
 313       unsigned int number_of_digits_to_use;
 314       unsigned int more_than_enough_bits_for_digits;
 315       unsigned int more_than_enough_littlenums_for_digits;
 316       unsigned int size_of_digits_in_littlenums;
 317       unsigned int size_of_digits_in_chars;
 318       FLONUM_TYPE power_of_10_flonum;
 319       FLONUM_TYPE digits_flonum;
 320
 321       precision = (address_of_generic_floating_point_number->high
 322                    - address_of_generic_floating_point_number->low
 323                    + 1);        /* Number of destination littlenums.  */
 324
 325       /* Includes guard bits (two littlenums worth) */
 326       maximum_useful_digits = (((precision - 2))
 327                                * ( (LITTLENUM_NUMBER_OF_BITS))
 328                                * 1000000 / 3321928)
 329         + 2;                    /* 2 :: guard digits.  */
 330
 331       if (number_of_digits_available > maximum_useful_digits)
 332         {
 333           number_of_digits_to_use = maximum_useful_digits;
 334         }
 335       else
 336         {
 337           number_of_digits_to_use = number_of_digits_available;
 338         }
 339
 340       /* Cast these to SIGNED LONG first, otherwise, on systems with
 341          LONG wider than INT (such as Alpha OSF/1), unsignedness may
 342          cause unexpected results.  */
 343       decimal_exponent += ((long) number_of_digits_before_decimal
 344                            - (long) number_of_digits_to_use);
 345
 346       more_than_enough_bits_for_digits
 347         = (number_of_digits_to_use * 3321928 / 1000000 + 1);
 348
 349       more_than_enough_littlenums_for_digits
 350         = (more_than_enough_bits_for_digits
 351            / LITTLENUM_NUMBER_OF_BITS)
 352         + 2;
 353
 354       /* Compute (digits) part. In "12.34E56" this is the "1234" part.
 355          Arithmetic is exact here. If no digits are supplied then this
 356          part is a 0 valued binary integer.  Allocate room to build up
 357          the binary number as littlenums.  We want this memory to
 358          disappear when we leave this function.  Assume no alignment
 359          problems => (room for n objects) == n * (room for 1
 360          object).  */
 361
 362       size_of_digits_in_littlenums = more_than_enough_littlenums_for_digits;
 363       size_of_digits_in_chars = size_of_digits_in_littlenums
 364         * sizeof (LITTLENUM_TYPE);
 365
 366       digits_binary_low = (LITTLENUM_TYPE *)
 367         xmalloc (size_of_digits_in_chars);
 368
 369       memset ((char *) digits_binary_low, '\0', size_of_digits_in_chars);
 370
 371       /* Digits_binary_low[] is allocated and zeroed.  */
 372
 373       /*
 374        * Parse the decimal digits as if * digits_low was in the units position.
 375        * Emit a binary number into digits_binary_low[].
 376        *
 377        * Use a large-precision version of:
 378        * (((1st-digit) * 10 + 2nd-digit) * 10 + 3rd-digit ...) * 10 + last-digit
 379        */
 380
 381       for (p = first_digit, count = number_of_digits_to_use; count; p++, --count)
 382         {
 383           c = *p;
 384           if (ISDIGIT (c))
 385             {
 386               /*
 387                * Multiply by 10. Assume can never overflow.
 388                * Add this digit to digits_binary_low[].
 389                */
 390
 391               long carry;
 392               LITTLENUM_TYPE *littlenum_pointer;
 393               LITTLENUM_TYPE *littlenum_limit;
 394
 395               littlenum_limit = digits_binary_low
 396                 + more_than_enough_littlenums_for_digits
 397                 - 1;
 398
 399               carry = c - '0';  /* char -> binary */
 400
 401               for (littlenum_pointer = digits_binary_low;
 402                    littlenum_pointer <= littlenum_limit;
 403                    littlenum_pointer++)
 404                 {
 405                   long work;
 406
 407                   work = carry + 10 * (long) (*littlenum_pointer);
 408                   *littlenum_pointer = work & LITTLENUM_MASK;
 409                   carry = work >> LITTLENUM_NUMBER_OF_BITS;
 410                 }
 411
 412               if (carry != 0)
 413                 {
 414                   /*
 415                    * We have a GROSS internal error.
 416                    * This should never happen.
 417                    */
 418                   as_fatal (_("failed sanity check"));
 419                 }
 420             }
 421           else
 422             {
 423               ++count;          /* '.' doesn't alter digits used count.  */
 424             }
 425         }
 426
 427       /*
 428        * Digits_binary_low[] properly encodes the value of the digits.
 429        * Forget about any high-order littlenums that are 0.
 430        */
 431       while (digits_binary_low[size_of_digits_in_littlenums - 1] == 0
 432              && size_of_digits_in_littlenums >= 2)
 433         size_of_digits_in_littlenums--;
 434
 435       digits_flonum.low = digits_binary_low;
 436       digits_flonum.high = digits_binary_low + size_of_digits_in_littlenums - 1;
 437       digits_flonum.leader = digits_flonum.high;
 438       digits_flonum.exponent = 0;
 439       /*
 440        * The value of digits_flonum . sign should not be important.
 441        * We have already decided the output's sign.
 442        * We trust that the sign won't influence the other parts of the number!
 443        * So we give it a value for these reasons:
 444        * (1) courtesy to humans reading/debugging
 445        *     these numbers so they don't get excited about strange values
 446        * (2) in future there may be more meaning attached to sign,
 447        *     and what was
 448        *     harmless noise may become disruptive, ill-conditioned (or worse)
 449        *     input.
 450        */
 451       digits_flonum.sign = '+';
 452
 453       {
 454         /*
 455          * Compute the mantissa (& exponent) of the power of 10.
 456          * If successful, then multiply the power of 10 by the digits
 457          * giving return_binary_mantissa and return_binary_exponent.
 458          */
 459
 460         int decimal_exponent_is_negative;
 461         /* This refers to the "-56" in "12.34E-56".  */
 462         /* FALSE: decimal_exponent is positive (or 0) */
 463         /* TRUE:  decimal_exponent is negative */
 464         FLONUM_TYPE temporary_flonum;
 465         unsigned int size_of_power_in_littlenums;
 466         unsigned int size_of_power_in_chars;
 467
 468         size_of_power_in_littlenums = precision;
 469         /* Precision has a built-in fudge factor so we get a few guard bits.  */
 470
 471         decimal_exponent_is_negative = decimal_exponent < 0;
 472         if (decimal_exponent_is_negative)
 473           {
 474             decimal_exponent = -decimal_exponent;
 475           }
 476
 477         /* From now on: the decimal exponent is > 0. Its sign is separate.  */
 478
 479         size_of_power_in_chars = size_of_power_in_littlenums
 480           * sizeof (LITTLENUM_TYPE) + 2;
 481
 482         power_binary_low = (LITTLENUM_TYPE *) xmalloc (size_of_power_in_chars);
 483         temporary_binary_low = (LITTLENUM_TYPE *) xmalloc (size_of_power_in_chars);
 484
 485         memset ((char *) power_binary_low, '\0', size_of_power_in_chars);
 486         *power_binary_low = 1;
 487         power_of_10_flonum.exponent = 0;
 488         power_of_10_flonum.low = power_binary_low;
 489         power_of_10_flonum.leader = power_binary_low;
 490         power_of_10_flonum.high = power_binary_low + size_of_power_in_littlenums - 1;
 491         power_of_10_flonum.sign = '+';
 492         temporary_flonum.low = temporary_binary_low;
 493         temporary_flonum.high = temporary_binary_low + size_of_power_in_littlenums - 1;
 494         /*
 495          * (power) == 1.
 496          * Space for temporary_flonum allocated.
 497          */
 498
 499         /*
 500          * ...
 501          *
 502          * WHILE        more bits
 503          * DO   find next bit (with place value)
 504          *      multiply into power mantissa
 505          * OD
 506          */
 507         {
 508           int place_number_limit;
 509           /* Any 10^(2^n) whose "n" exceeds this */
 510           /* value will fall off the end of */
 511           /* flonum_XXXX_powers_of_ten[].  */
 512           int place_number;
 513           const FLONUM_TYPE *multiplicand;      /* -> 10^(2^n) */
 514
 515           place_number_limit = table_size_of_flonum_powers_of_ten;
 516
 517           multiplicand = (decimal_exponent_is_negative
 518                           ? flonum_negative_powers_of_ten
 519                           : flonum_positive_powers_of_ten);
 520
 521           for (place_number = 1;/* Place value of this bit of exponent.  */
 522                decimal_exponent;/* Quit when no more 1 bits in exponent.  */
 523                decimal_exponent >>= 1, place_number++)
 524             {
 525               if (decimal_exponent & 1)
 526                 {
 527                   if (place_number > place_number_limit)
 528                     {
 529                       /* The decimal exponent has a magnitude so great
 530                          that our tables can't help us fragment it.
 531                          Although this routine is in error because it
 532                          can't imagine a number that big, signal an
 533                          error as if it is the user's fault for
 534                          presenting such a big number.  */
 535                       return_value = ERROR_EXPONENT_OVERFLOW;
 536                       /* quit out of loop gracefully */
 537                       decimal_exponent = 0;
 538                     }
 539                   else
 540                     {
 541 #ifdef TRACE
 542                       printf ("before multiply, place_number = %d., power_of_10_flonum:\n",
 543                               place_number);
 544
 545                       flonum_print (&power_of_10_flonum);
 546                       (void) putchar ('\n');
 547 #endif
 548 #ifdef TRACE
 549                       printf ("multiplier:\n");
 550                       flonum_print (multiplicand + place_number);
 551                       (void) putchar ('\n');
 552 #endif
 553                       flonum_multip (multiplicand + place_number,
 554                                      &power_of_10_flonum, &temporary_flonum);
 555 #ifdef TRACE
 556                       printf ("after multiply:\n");
 557                       flonum_print (&temporary_flonum);
 558                       (void) putchar ('\n');
 559 #endif
 560                       flonum_copy (&temporary_flonum, &power_of_10_flonum);
 561 #ifdef TRACE
 562                       printf ("after copy:\n");
 563                       flonum_print (&power_of_10_flonum);
 564                       (void) putchar ('\n');
 565 #endif
 566                     } /* If this bit of decimal_exponent was computable.*/
 567                 } /* If this bit of decimal_exponent was set.  */
 568             } /* For each bit of binary representation of exponent */
 569 #ifdef TRACE
 570           printf ("after computing power_of_10_flonum:\n");
 571           flonum_print (&power_of_10_flonum);
 572           (void) putchar ('\n');
 573 #endif
 574         }
 575       }
 576
 577       /*
 578        * power_of_10_flonum is power of ten in binary (mantissa) , (exponent).
 579        * It may be the number 1, in which case we don't NEED to multiply.
 580        *
 581        * Multiply (decimal digits) by power_of_10_flonum.
 582        */
 583
 584       flonum_multip (&power_of_10_flonum, &digits_flonum, address_of_generic_floating_point_number);
 585       /* Assert sign of the number we made is '+'.  */
 586       address_of_generic_floating_point_number->sign = digits_sign_char;
 587
 588       if (temporary_binary_low)
 589         free (temporary_binary_low);
 590       if (power_binary_low)
 591         free (power_binary_low);
 592       free (digits_binary_low);
 593     }
 594   return return_value;
 595 }
 596
 597 #ifdef TRACE
 598 static void
 599 flonum_print (f)
 600      const FLONUM_TYPE *f;
 601 {
 602   LITTLENUM_TYPE *lp;
 603   char littlenum_format[10];
 604   sprintf (littlenum_format, " %%0%dx", sizeof (LITTLENUM_TYPE) * 2);
 605 #define print_littlenum(LP)     (printf (littlenum_format, LP))
 606   printf ("flonum @%p %c e%ld", f, f->sign, f->exponent);
 607   if (f->low < f->high)
 608     for (lp = f->high; lp >= f->low; lp--)
 609       print_littlenum (*lp);
 610   else
 611     for (lp = f->low; lp <= f->high; lp++)
 612       print_littlenum (*lp);
 613   printf ("\n");
 614   fflush (stdout);
 615 }
 616 #endif
 617
 618 /* end of atof_generic.c */