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