![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to natof.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / bin / as|
Return to natof.c CVS log | Up to [CSRG BSD Unix] / 42BSD / bin / as |
1.1 root 1: /*
2: * Copyright (c) 1982 Regents of the University of California
3: */
4: #ifndef lint
5: static char sccsid[] = "@(#)natof.c 4.3 2/14/82";
6: #endif not lint
7:
8: #include <stdio.h>
9: #include <ctype.h>
10: #include <errno.h>
11:
12: #include "as.h"
13:
14: Bignum bigatof(str, radix)
15: reg char *str; /* r11 */
16: int radix; /* TYPF ... TYPH */
17: {
18: int msign;
19: int esign;
20: int decpt;
21: reg chptr temp; /* r10 */
22: reg u_int quotient; /* r9 */ /* must be here */
23: reg u_int remainder; /* r8 */ /* must be here */
24: reg chptr acc;
25: reg int dividend; /* for doing division */
26: reg u_int i;
27: short *sptr; /* for doing division */
28: int ch;
29: int dexponent; /* decimal exponent */
30: int bexponent; /* binary exponent */
31: Bignum Acc;
32: Bignum Temp;
33: static Bignum znumber;
34: Ovf ovf;
35: u_int j;
36: extern int errno;
37: u_int ediv();
38:
39: #ifdef lint
40: quotient = 0;
41: remainder = 0;
42: #endif lint
43: msign = 0;
44: esign = 0;
45: decpt = 0;
46: dexponent = 0;
47: Acc = znumber;
48: Acc.num_tag = radix;
49: acc = CH_FIELD(Acc);
50: temp = CH_FIELD(Temp);
51:
52: do{
53: ch = *str++;
54: } while(isspace(ch));
55:
56: switch(ch){
57: case '-':
58: msign = -1;
59: /* FALLTHROUGH */
60: case '+':
61: ch = *str++;
62: break;
63: }
64: dofract:
65: for(; isdigit(ch); ch = *str++){
66: assert(((acc[HOC] & SIGNBIT) == 0), "Negative HOC");
67: if (acc[HOC] < MAXINT_10){
68: ovf = numshift(3, temp, acc);
69: ovf |= numshift(1, acc, acc);
70: ovf |= numaddv(acc, temp, acc);
71: ovf |= numaddd(acc, acc, ch - '0');
72: assert(ovf == 0, "Overflow building mantissa");
73: } else {
74: /*
75: * Then, the number is too large anyway
76: */
77: dexponent++;
78: }
79: if (decpt)
80: dexponent--;
81: }
82: switch(ch){
83: case '.':
84: if (decpt == 0){
85: decpt++;
86: ch = *str++;
87: goto dofract;
88: }
89: break;
90: /*
91: * only 'e' and 'E' are recognized by atof()
92: */
93: case 'e':
94: case 'E':
95: /*
96: * we include the remainder for compatability with as formats
97: * in as, the radix actual paramater agrees with the character
98: * we expect; consequently, no checking is done.
99: */
100: case 'd':
101: case 'D':
102: case 'g':
103: case 'G':
104: case 'h':
105: case 'H':
106: j = 0;
107: ch = *str++;
108: esign = 0;
109: switch(ch){
110: case '-':
111: esign = 1;
112: /* FALLTHROUGH */
113: case '+':
114: ch = *str++;
115: }
116: for(; isdigit(ch); ch = *str++){
117: if (j < MAXINT_10){
118: j *= 10;
119: j += ch - '0';
120: } else {
121: /*
122: * outrageously large exponent
123: */
124: /*VOID*/
125: }
126: }
127: if (esign)
128: dexponent -= j;
129: else
130: dexponent += j;
131: /*
132: * There should be a range check on dexponent here
133: */
134: }
135: /*
136: * The number has now been reduced to a mantissa
137: * and an exponent.
138: * The mantissa is an n bit number (to the precision
139: * of the extended words) in the acc.
140: * The exponent is a signed power of 10 in dexponent.
141: * msign is on if the resulting number will eventually
142: * be negative.
143: *
144: * We now must convert the number to standard format floating
145: * number, which will be done by accumulating
146: * a binary exponent in bexponent, as we gradually
147: * drive dexponent towards zero, one count at a time.
148: */
149: if (isclear(acc)){
150: return(Acc);
151: }
152: bexponent = 0;
153:
154: /*
155: * Scale the number down.
156: * We must divide acc by 10 as many times as needed.
157: */
158: for (; dexponent < 0; dexponent++){
159: /*
160: * Align the number so that the most significant
161: * bits are aligned in the most significant
162: * bits of the accumulator, adjusting the
163: * binary exponent as we shift.
164: * The goal is to get the high order bit (NOT the
165: * sign bit) set.
166: */
167: assert(((acc[HOC] & SIGNBIT) == 0), "Negative HOC");
168: ovf = 0;
169:
170: for (j = 5; j >= 1; --j){
171: i = 1 << (j - 1); /* 16, 8, 4, 2, 1 */
172: quotient = ONES(i);
173: quotient <<= (CH_BITS - 1) - i;
174: while((acc[HOC] & quotient) == 0){
175: ovf |= numshift((int)i, acc, acc);
176: bexponent -= i;
177: }
178: }
179: /*
180: * Add 2 to the accumulator to effect rounding,
181: * and get set up to divide by 5.
182: */
183: ovf = numaddd(acc, acc, 2);
184: assert(ovf == 0, "Carry out of left rounding up by 2");
185: /*
186: * Divide the high order chunks by 5;
187: * The last chunk will be divided by 10,
188: * (to see what the remainder is, also to effect rounding)
189: * and then multipiled by 2 to effect division by 5.
190: */
191: remainder = 0;
192: #if DEBUGNATOF
193: printf("Dividing: ");
194: bignumprint(Acc);
195: printf("\n");
196: #endif DEBUGNATOF
197: sptr = (short *)acc;
198: for (i = (CH_N * 2 - 1); i >= 1; --i){
199: /*
200: * Divide (remainder:16).(acc[i]:16)
201: * by 5, putting the quotient back
202: * into acc[i]:16, and save the remainder
203: * for the next iteration.
204: */
205: dividend = (remainder << 16) | (sptr[i] & ONES(16));
206: assert(dividend >= 0, "dividend < 0");
207: quotient = dividend / 5;
208: remainder = dividend - (quotient * 5);
209: sptr[i] = quotient;
210: remainder = remainder;
211: }
212: /*
213: * Divide the lowest order chunk by 10,
214: * saving the remainder to decide how to round.
215: * Then, multiply by 2, making it look as
216: * if we divided by 10.
217: * This multiply fills in a 0 on the least sig bit.
218: */
219: dividend = (remainder << 16) | (sptr[0] & ONES(16));
220: assert(dividend >= 0, "dividend < 0");
221: quotient = dividend / 10;
222: remainder = dividend - (quotient * 10);
223: sptr[0] = quotient + quotient;
224:
225: if (remainder >= 5)
226: ovf = numaddd(acc, acc, 1);
227: /*
228: * Now, divide by 2, effecting division by 10,
229: * merely by adjusting the binary exponent.
230: */
231: bexponent--;
232: }
233: /*
234: * Scale the number up by multiplying by 10 as
235: * many times as necessary
236: */
237: for (; dexponent > 0; dexponent--){
238: /*
239: * Compare high word to (2**31)/5,
240: * and scale accordingly
241: */
242: while ( ((unsigned)acc[HOC]) > MAXINT_5){
243: (void)numshift(-1, acc, acc);
244: bexponent++;
245: }
246: /*
247: * multiply the mantissa by 5,
248: * and scale the binary exponent by 2
249: */
250: ovf = numshift(2, temp, acc);
251: ovf |= numaddv(acc, acc, temp);
252: assert(ovf == 0, "Scaling * 10 of manitissa");
253: bexponent++;
254: }
255: /*
256: * We now have:
257: * a CH_N chunk length binary integer, right
258: * justified (in native format).
259: * a binary exponent.
260: *
261: * Now, we treat this large integer as an octa word
262: * number, and unpack it into standard unpacked
263: * format. That unpacking will give us yet
264: * another binary exponent, which we adjust with
265: * the accumulated binary exponent.
266: */
267: Acc.num_tag = TYPO;
268: #if DEBUGNATOF
269: printf("Octal number: ");
270: bignumprint(Acc);
271: printf("\n");
272: #endif DEBUGNATOF
273: Acc = bignumunpack(Acc, &ovf);
274:
275: if (ovf)
276: errno = ERANGE;
277: #if DEBUGNATOF
278: printf("Unpacked octal number: ");
279: bignumprint(Acc);
280: printf("bexponent == %d\n", bexponent);
281: #endif DEBUGNATOF
282: Acc.num_exponent += bexponent;
283: assert(Acc.num_sign == 0, "unpacked integer is < 0");
284: Acc.num_sign = msign;
285: /*
286: * We now pack the number back into a radix format number.
287: * This checks for overflow, underflow,
288: * and rounds by 1/2 ulp.
289: */
290: ovf = 0;
291: Acc = bignumpack(Acc, radix, &ovf);
292: if (ovf)
293: errno = ERANGE;
294: #if DEBUGNATOF
295: printf("packed number: ");
296: bignumprint(Acc);
297: printf("\n");
298: #endif DEBUGNATOF
299: return(Acc);
300: }
301: #if 0
302: /*
303: * Unfortunately, one can't use the ediv instruction to do
304: * division on numbers with > 64 bits.
305: * This is because ediv returns signed quantities;
306: * if the quotient is an unsigned number > 2^31,
307: * ediv sets integer overflow.
308: */
309: unsigned int ediv(high, low, divisor, qp, i)
310: register unsigned int high; /* r11 */
311: register unsigned int low; /* r10 */
312: register unsigned int divisor; /* r9 */
313: unsigned int *qp;
314: {
315: register unsigned int remainder; /* r8 */
316: register unsigned int quotient; /* r7 */
317:
318: asm("ediv r9, r10, r7, r8 # Divide. q->r7, r->r8 (discarded)");
319: *qp = quotient;
320: return(remainder);
321: }
322: #endif 0
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.