Coverage Report

Created: 2024-05-21 06:29

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