gas/atof-generic.c

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