![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to atof.s CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / lib / libc / tahoe / stdlib|
Return to atof.s CVS log | Up to [CSRG BSD Unix] / 43BSDReno / lib / libc / tahoe / stdlib |
1.1 root 1: /*
2: * Copyright (c) 1988 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted
6: * provided that: (1) source distributions retain this entire copyright
7: * notice and comment, and (2) distributions including binaries display
8: * the following acknowledgement: ``This product includes software
9: * developed by the University of California, Berkeley and its contributors''
10: * in the documentation or other materials provided with the distribution
11: * and in all advertising materials mentioning features or use of this
12: * software. Neither the name of the University nor the names of its
13: * contributors may be used to endorse or promote products derived
14: * from this software without specific prior written permission.
15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
16: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
17: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18: */
19:
20: #if defined(LIBC_SCCS) && !defined(lint)
21: .asciz "@(#)atof.s 5.3 (Berkeley) 6/1/90"
22: #endif /* LIBC_SCCS and not lint */
23:
24: #include "DEFS.h"
25:
26: /*
27: * atof: convert ascii to floating
28: *
29: * C usage:
30: *
31: * double atof (s)
32: * char *s;
33: *
34: * Register usage:
35: *
36: * r0-1: value being developed
37: * r2: first section: pointer to the next character
38: * second section: binary exponent
39: * r3: flags
40: * r4: first section: the current character
41: * second section: scratch
42: * r5: the decimal exponent
43: * r6-7: scratch
44: */
45: .set msign,0 # mantissa has negative sign
46: .set esign,1 # exponent has negative sign
47: .set decpt,2 # decimal point encountered
48:
49: ENTRY(atof, R6|R7)
50: /*
51: * Initialization
52: */
53: clrl r3 # All flags start out false
54: movl 4(fp),r2 # Address the first character
55: clrl r5 # Clear starting exponent
56: /*
57: * Skip leading white space
58: */
59: sk0: movzbl (r2),r4 # Fetch the next (first) character
60: incl r2
61: cmpb $' ,r4 # Is it blank?
62: beql sk0 # ...yes
63: cmpb r4,$8 # 8 is lowest of white-space group
64: blss sk1 # Jump if char too low to be white space
65: cmpb r4,$13 # 13 is highest of white-space group
66: bleq sk0 # Jump if character is white space
67: sk1:
68: /*
69: * Check for a sign
70: */
71: cmpb $'+,r4 # Positive sign?
72: beql cs1 # ... yes
73: cmpb $'-,r4 # Negative sign?
74: bneq cs2 # ... no
75: orb2 $1<msign,r3 # Indicate a negative mantissa
76: cs1: movzbl (r2),r4 # Skip the character
77: incl r2
78: cs2:
79: /*
80: * Accumulate digits, keeping track of the exponent
81: */
82: clrl r1
83: clrl r0 # Clear the accumulator
84: ad0: cmpb r4,$'0 # Do we have a digit?
85: blss ad4 # ... no, too small
86: cmpb r4,$'9
87: bgtr ad4 # ... no, too large
88: /*
89: * We got a digit. Accumulate it
90: */
91: cmpl r0,$214748364 # Would this digit cause overflow?
92: bgeq ad1 # ... yes
93: /*
94: * Multiply (r0,r1) by 10. This is done by developing
95: * (r0,r1)*2 in (r6,r7), shifting (r0,r1) left three bits,
96: * and adding the two quadwords.
97: */
98: shlq $1,r0,r6 # (r6,r7)=(r0,r1)*2
99: shlq $3,r0,r0 # (r0,r1)=(r0,r1)*8
100: addl2 r7,r1 # Add low halves
101: adwc r6,r0 # Add high halves
102: /*
103: * Add in the digit
104: */
105: subl2 $'0,r4 # Get the digit value
106: addl2 r4,r1 # Add it into the accumulator
107: adwc $0,r0 # Possible carry into high half
108: brb ad2 # Join common code
109: /*
110: * Here when the digit won't fit in the accumulator
111: */
112: ad1: incl r5 # Ignore the digit, bump exponent
113: /*
114: * If we have seen a decimal point, decrease the exponent by 1
115: */
116: ad2: bbc $decpt,r3,ad3 # Jump if decimal point not seen
117: decl r5 # Decrease exponent
118: ad3:
119: /*
120: * Fetch the next character, back for more
121: */
122: movzbl (r2),r4 # Fetch
123: incl r2
124: brb ad0 # Try again
125: /*
126: * Not a digit. Could it be a decimal point?
127: */
128: ad4: cmpb r4,$'. # If it's not a decimal point, either it's
129: bneq ad5 # the end of the number or the start of
130: # the exponent.
131: bbs $decpt,r3,ad5
132: orb2 $1<decpt,r3 # If it IS a decimal point, we record that
133: brb ad3 # we've seen one, and keep collecting
134: # digits if it is the first one.
135:
136: /*
137: * Check for an exponent
138: */
139: ad5: clrl r6 # Initialize the exponent accumulator
140:
141: cmpb r4,$'e # We allow both lower case e
142: beql ex1 # ... and ...
143: cmpb r4,$'E # upper-case E
144: bneq ex7
145: /*
146: * Does the exponent have a sign?
147: */
148: ex1: movzbl (r2),r4 # Get next character
149: incl r2
150: cmpb r4,$'+ # Positive sign?
151: beql ex2 # ... yes ...
152: cmpb r4,$'- # Negative sign?
153: bneq ex3 # ... no ...
154: orb2 $1<esign,r3 # Indicate exponent is negative
155: ex2: movzbl (r2),r4 # Grab the next character
156: incl r2
157: /*
158: * Accumulate exponent digits in r6
159: */
160: ex3: cmpb r4,$'0 # A digit is within the range
161: blss ex4 # '0' through
162: cmpb r4,$'9 # '9',
163: bgtr ex4 # inclusive.
164: cmpl r6,$214748364 # Exponent outrageously large already?
165: bgeq ex2 # ... yes
166: moval (r6)[r6],r6 # r6 *= 5
167: movaw -'0(r4)[r6],r6 # r6 = r6 * 2 + r4 - '0'
168: brb ex2 # Go 'round again
169: ex4:
170: /*
171: * Now get the final exponent and force it within a reasonable
172: * range so our scaling loops don't take forever for values
173: * that will ultimately cause overflow or underflow anyway.
174: * A tight check on over/underflow will be done by ldexp.
175: */
176: bbc $esign,r3,ex5 # Jump if exponent not negative
177: mnegl r6,r6 # If sign, negate exponent
178: ex5: addl2 r6,r5 # Add given exponent to calculated exponent
179: cmpl r5,$-100 # Absurdly small?
180: bgtr ex6 # ... no
181: movl $-100,r5 # ... yes, force within limit
182: ex6: cmpl r5,$100 # Absurdly large?
183: blss ex7 # ... no
184: movl $100,r5 # ... yes, force within bounds
185: ex7:
186: /*
187: * Our number has now been reduced to a mantissa and an exponent.
188: * The mantissa is a 63-bit positive binary integer in r0,r1,
189: * and the exponent is a signed power of 10 in r5. The msign
190: * bit in r3 will be on if the mantissa should ultimately be
191: * considered negative.
192: *
193: * We now have to convert it to a standard format floating point
194: * number. This will be done by accumulating a binary exponent
195: * in r2, as we progressively get r5 closer to zero.
196: *
197: * Don't bother scaling if the mantissa is zero
198: */
199: tstl r1
200: bneq 1f
201: tstl r0 # Mantissa zero?
202: jeql exit # ... yes
203:
204: 1: clrl r2 # Initialize binary exponent
205: tstl r5 # Which way to scale?
206: bleq sd0 # Scale down if decimal exponent <= 0
207: /*
208: * Scale up by "multiplying" r0,r1 by 10 as many times as necessary,
209: * as follows:
210: *
211: * Step 1: Shift r0,r1 right as necessary to ensure that no
212: * overflow can occur when multiplying.
213: */
214: su0: cmpl r0,$429496729 # Compare high word to (2**31)/5
215: blss su1 # Jump out if guaranteed safe
216: shrq $1,r0,r0 # Else shift right one bit
217: incl r2 # bump exponent to compensate
218: brb su0 # and go back to test again.
219: /*
220: * Step 2: Multiply r0,r1 by 5, by appropriate shifting and
221: * double-precision addition
222: */
223: su1: shlq $2,r0,r6 # (r6,r7) := (r0,r1) * 4
224: addl2 r7,r1 # Add low-order halves
225: adwc r6,r0 # and high-order halves
226: /*
227: * Step 3: Increment the binary exponent to take care of the final
228: * factor of 2, and go back if we still need to scale more.
229: */
230: incl r2 # Increment the exponent
231: decl r5 # ...sobgtr r5,su0
232: bgtr su0 # and back for more (maybe)
233:
234: brb cm0 # Merge to build final value
235:
236: /*
237: * Scale down. We must "divide" r0,r1 by 10 as many times
238: * as needed, as follows:
239: *
240: * Step 0: Right now, the condition codes reflect the state
241: * of r5. If it's zero, we are done.
242: */
243: sd0: beql cm0 # If finished, build final number
244: /*
245: * Step 1: Shift r0,r1 left until the high-order bit (not counting
246: * the sign bit) is nonzero, so that the division will preserve
247: * as much precision as possible.
248: */
249: tstl r0 # Is the entire high-order half zero?
250: bneq sd2 # ...no, go shift one bit at a time
251: shlq $30,r0,r0 # ...yes, shift left 30,
252: subl2 $30,r2 # decrement the exponent to compensate,
253: # and now it's known to be safe to shift
254: # at least once more.
255: sd1: shlq $1,r0,r0 # Shift (r0,r1) left one, and
256: decl r2 # decrement the exponent to compensate
257: sd2: bbc $30,r0,sd1 # If the high-order bit is off, go shift
258: /*
259: * Step 2: Divide the high-order part of (r0,r1) by 5,
260: * giving a quotient in r1 and a remainder in r7.
261: */
262: sd3: movl r0,r7 # Copy the high-order part
263: clrl r6 # Zero-extend to 64 bits
264: ediv $5,r6,r0,r6 # Divide (cannot overflow)
265: /*
266: * Step 3: Divide the low-order part of (r0,r1) by 5,
267: * using the remainder from step 2 for rounding.
268: * Note that the result of this computation is unsigned,
269: * so we have to allow for the fact that an ordinary division
270: * by 5 could overflow. We make allowance by dividing by 10,
271: * multiplying the quotient by 2, and using the remainder
272: * to adjust the modified quotient.
273: */
274: addl3 $2,r1,r7 # Dividend is low part of (r0,r1) plus
275: adwc $0,r6 # 2 for rounding plus
276: # (2**32) * previous remainder
277: ediv $10,r6,r1,r7 # r1 := quotient, r7 := remainder.
278: addl2 r1,r1 # Make r1 result of dividing by 5
279: cmpl r7,$5 # If remainder is 5 or greater,
280: blss sd4 # increment the adjustted quotient.
281: incl r1
282: /*
283: * Step 4: Increment the decimal exponent, decrement the binary
284: * exponent (to make the division by 5 into a division by 10),
285: * and back for another iteration.
286: */
287: sd4: decl r2 # Binary exponent
288: aoblss $0,r5,sd2
289: /*
290: * We now have the following:
291: *
292: * r0: high-order half of a 64-bit integer
293: * r1: load-order half of the same 64-bit integer
294: * r2: a binary exponent
295: *
296: * Our final result is the integer represented by (r0,r1)
297: * multiplied by 2 to the power contained in r2.
298: * We will transform (r0,r1) into a floating-point value,
299: * set the sign appropriately, and let ldexp do the
300: * rest of the work.
301: *
302: * Step 1: if the high-order bit (excluding the sign) of
303: * the high-order half (r0) is 1, then we have 63 bits of
304: * fraction, too many to convert easily. However, we also
305: * know we won't need them all, so we will just throw the
306: * low-order bit away (and adjust the exponent appropriately).
307: */
308: cm0: bbc $30,r0,cm1 # jump if no adjustment needed
309: shrq $1,r0,r0 # lose the low-order bit
310: incl r2 # increase the exponent to compensate
311: /*
312: * Step 2: split the 62-bit number in (r0,r1) into two
313: * 31-bit positive quantities
314: */
315: cm1: shlq $1,r0,r0 # put the high-order bits in r0
316: # and a 0 in the bottom of r1
317: shrl $1,r1,r1 # right-justify the bits in r1
318: # moving 0 into the sign bit.
319: /*
320: * Step 3: convert both halves to floating point
321: */
322: cvld r1
323: std r6 # low-order part in r6-r7
324: cvld r0
325: std r0 # high-order part in r0-r1
326: /*
327: * Step 4: multiply the high order part by 2**31 and combine them
328: */
329: ldd two31
330: muld r0 # multiply
331: addd r6 # combine
332: /*
333: * Step 5: if appropriate, negate the floating value
334: */
335: bbc $msign,r3,cm2 # Jump if mantissa not signed
336: negd # If negative, make it so
337: /*
338: * Step 6: call ldexp to complete the job
339: */
340: cm2: pushl r2 # Put exponent in parameter list
341: pushd # and also mantissa
342: calls $3,_ldexp # go combine them
343:
344: exit:
345: ret
346:
347: .align 2
348: two31: .long 0x50000000 # (=2147483648) 2 ** 31 in floating-point
349: .long 0 # so atof doesn't have to convert it
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.