gas/atof-generic.c

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