![[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 [Research Unix] / researchv10no / libc / stdio / ostdio|
Return to atof.s CVS log | Up to [Research Unix] / researchv10no / libc / stdio / ostdio |
1.1 ! root 1: # ! 2: # atof, strtod: convert ascii to floating ! 3: # ! 4: # C usage: ! 5: # ! 6: # double atof (s) ! 7: # char *s; ! 8: # ! 9: # double strtod (s, p) ! 10: # char *s, **p; ! 11: # ! 12: # For strtod, if p is non-null, *p gets set to point at the ! 13: # character after the input string. ! 14: # ! 15: # Register usage: ! 16: # ! 17: # r0-1: value being developed ! 18: # r2: first section: pointer to the next character ! 19: # second section: binary exponent ! 20: # r3: flags ! 21: # r4: first section: the current character ! 22: # second section: scratch ! 23: # r5: the decimal exponent ! 24: # r6-7: scratch ! 25: # r8: a copy of p (strtod) or zero (atof) ! 26: # ! 27: # Flag definitions ! 28: # ! 29: .set msign,0 # mantissa has negative sign ! 30: .set esign,1 # exponent has negative sign ! 31: .set decpt,2 # decimal point encountered ! 32: ! 33: .align 2 ! 34: two31: .word 0x5000 # 2 ** 31 ! 35: .word 0 # (=2147483648) ! 36: .word 0 # in floating-point ! 37: .word 0 # (so atof doesn't have to convert it) ! 38: # ! 39: # Entry points ! 40: # ! 41: .text ! 42: .align 2 ! 43: .globl _strtod ! 44: _strtod:.word 0x01c0 # Save r8 through r6 (we use r0-r8) ! 45: movl 8(ap),r8 # Pick up value of p ! 46: jbr init ! 47: ! 48: .align 2 ! 49: .globl _atof ! 50: _atof: .word 0x01c0 # Save r8 through r6 (we use r0-r8) ! 51: clrl r8 # This is atof, not strtod ! 52: # ! 53: # Initialization ! 54: # ! 55: init: ! 56: clrl r3 # All flags start out false ! 57: movl 4(ap),r2 # Address the first character ! 58: clrl r5 # Clear starting exponent ! 59: # ! 60: # Skip leading white space ! 61: # ! 62: sk0: movzbl (r2)+,r4 # Fetch the next (first) character ! 63: cmpb $' ,r4 # Is it blank? ! 64: jeql sk0 # ...yes ! 65: cmpb r4,$8 # 8 is lowest of white-space group ! 66: jlss sk1 # Jump if char too low to be white space ! 67: cmpb r4,$13 # 13 is highest of white-space group ! 68: jleq sk0 # Jump if character is white space ! 69: sk1: ! 70: # ! 71: # Check for a sign ! 72: # ! 73: cmpb $'+,r4 # Positive sign? ! 74: jeql cs1 # ... yes ! 75: cmpb $'-,r4 # Negative sign? ! 76: jneq cs2 # ... no ! 77: bisb2 $1<msign,r3 # Indicate a negative mantissa ! 78: cs1: movzbl (r2)+,r4 # Skip the character ! 79: cs2: ! 80: # ! 81: # Accumulate digits, keeping track of the exponent ! 82: # ! 83: clrq r0 # Clear the accumulator ! 84: ad0: cmpb r4,$'0 # Do we have a digit? ! 85: jlss ad4 # ... no, too small ! 86: cmpb r4,$'9 ! 87: jgtr ad4 # ... no, too large ! 88: # ! 89: # We got a digit. Accumulate it ! 90: # ! 91: cmpl r1,$214748364 # Would this digit cause overflow? ! 92: jgeq 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: ashq $1,r0,r6 # (r6,r7)=(r0,r1)*2 ! 99: ashq $3,r0,r0 # (r0,r1)=(r0,r1)*8 ! 100: addl2 r6,r0 # Add low halves ! 101: adwc r7,r1 # Add high halves ! 102: # ! 103: # Add in the digit ! 104: # ! 105: subl2 $'0,r4 # Get the digit value ! 106: addl2 r4,r0 # Add it into the accumulator ! 107: adwc $0,r1 # Possible carry into high half ! 108: jbr 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: jbc $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: jbr ad0 # Try again ! 124: # ! 125: # Not a digit. Could it be a decimal point? ! 126: # ! 127: ad4: cmpb r4,$'. # If it's not a decimal point, either it's ! 128: jneq ad5 # the end of the number or the start of ! 129: # the exponent. ! 130: jbcs $decpt,r3,ad3 # If it IS a decimal point, we record that ! 131: # we've seen one, and keep collecting ! 132: # digits if it is the first one. ! 133: # ! 134: # Check for an exponent ! 135: # ! 136: ad5: clrl r6 # Initialize the exponent accumulator ! 137: ! 138: cmpb r4,$'e # We allow both lower case e ! 139: jeql ex1 # ... and ... ! 140: cmpb r4,$'E # upper-case E ! 141: jneq ex7 ! 142: # ! 143: # Does the exponent have a sign? ! 144: # ! 145: ex1: movzbl (r2)+,r4 # Get next character ! 146: cmpb r4,$'+ # Positive sign? ! 147: jeql ex2 # ... yes ... ! 148: cmpb r4,$'- # Negative sign? ! 149: jneq ex3 # ... no ... ! 150: bisb2 $1<esign,r3 # Indicate exponent is negative ! 151: ex2: movzbl (r2)+,r4 # Grab the next character ! 152: # ! 153: # Accumulate exponent digits in r6 ! 154: # ! 155: ex3: cmpb r4,$'0 # A digit is within the range ! 156: jlss ex4 # '0' through ! 157: cmpb r4,$'9 # '9', ! 158: jgtr ex4 # inclusive. ! 159: cmpl r6,$214748364 # Exponent outrageously large already? ! 160: jgeq ex2 # ... yes ! 161: moval (r6)[r6],r6 # r6 *= 5 ! 162: movaw -'0(r4)[r6],r6 # r6 = r6 * 2 + r4 - '0' ! 163: jbr ex2 # Go 'round again ! 164: ex4: ! 165: # ! 166: # Now get the final exponent and force it within a reasonable ! 167: # range so our scaling loops don't take forever for values ! 168: # that will ultimately cause overflow or underflow anyway. ! 169: # A tight check on over/underflow will be done by ldexp. ! 170: # ! 171: jbc $esign,r3,ex5 # Jump if exponent not negative ! 172: mnegl r6,r6 # If sign, negate exponent ! 173: ex5: addl2 r6,r5 # Add given exponent to calculated exponent ! 174: cmpl r5,$-100 # Absurdly small? ! 175: jgtr ex6 # ... no ! 176: movl $-100,r5 # ... yes, force within limit ! 177: ex6: cmpl r5,$100 # Absurdly large? ! 178: jlss ex7 # ... no ! 179: movl $100,r5 # ... yes, force within bounds ! 180: ex7: ! 181: # ! 182: # If this is strtod and p is non-null, store a value in *p ! 183: # ! 184: tstl r8 # Is there a place to store it? ! 185: jeql ex8 # ... no, skip store ! 186: decl r2 ! 187: movl r2,(r8) # ... yes, store value in *p ! 188: ex8: ! 189: # ! 190: # Our number has now been reduced to a mantissa and an exponent. ! 191: # The mantissa is a 63-bit positive binary integer in r0,r1, ! 192: # and the exponent is a signed power of 10 in r5. The msign ! 193: # bit in r3 will be on if the mantissa should ultimately be ! 194: # considered negative. ! 195: # ! 196: # We now have to convert it to a standard format floating point ! 197: # number. This will be done by accumulating a binary exponent ! 198: # in r2, as we progressively get r5 closer to zero. ! 199: # ! 200: # Don't bother scaling if the mantissa is zero ! 201: # ! 202: movq r0,r0 # Mantissa zero? ! 203: jeql exit # ... yes ! 204: ! 205: clrl r2 # Initialize binary exponent ! 206: tstl r5 # Which way to scale? ! 207: jleq sd0 # Scale down if decimal exponent <= 0 ! 208: # ! 209: # Scale up by "multiplying" r0,r1 by 10 as many times as necessary, ! 210: # as follows: ! 211: # ! 212: # Step 1: Shift r0,r1 right as necessary to ensure that no ! 213: # overflow can occur when multiplying. ! 214: # ! 215: su0: cmpl r1,$429496729 # Compare high word to (2**31)/5 ! 216: jlss su1 # Jump out if guaranteed safe ! 217: ashq $-1,r0,r0 # Else shift right one bit ! 218: incl r2 # bump exponent to compensate ! 219: jbr su0 # and go back to test again. ! 220: # ! 221: # Step 2: Multiply r0,r1 by 5, by appropriate shifting and ! 222: # double-precision addition ! 223: # ! 224: su1: ashq $2,r0,r6 # (r6,r7) := (r0,r1) * 4 ! 225: addl2 r6,r0 # Add low-order halves ! 226: adwc r7,r1 # and high-order halves ! 227: # ! 228: # Step 3: Increment the binary exponent to take care of the final ! 229: # factor of 2, and go back if we still need to scale more. ! 230: # ! 231: incl r2 # Increment the exponent ! 232: sobgtr r5,su0 # and back for more (maybe) ! 233: ! 234: jbr 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: jeql 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 r1 # Is the entire high-order half zero? ! 250: jneq sd2 # ...no, go shift one bit at a time ! 251: ashq $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: ashq $1,r0,r0 # Shift (r0,r1) left one, and ! 256: decl r2 # decrement the exponent to compensate ! 257: sd2: jbc $30,r1,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 r1,r6 # Copy the high-order part ! 263: clrl r7 # Zero-extend to 64 bits ! 264: ediv $5,r6,r1,r7 # 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,r0,r6 # Dividend is low part of (r0,r1) plus ! 275: adwc $0,r7 # 2 for rounding plus ! 276: # (2**32) * previous remainder ! 277: ediv $10,r6,r0,r6 # r0 := quotient, r6 := remainder. ! 278: addl2 r0,r0 # Make r0 result of dividing by 5 ! 279: cmpl r6,$5 # If remainder is 5 or greater, ! 280: jlss sd4 # increment the adjustted quotient. ! 281: incl r0 ! 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: low-order half of a 64-bit integer ! 293: # r1: high-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 (r1) 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: jbc $30,r1,cm1 # jump if no adjustment needed ! 309: ashq $-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: ashq $1,r0,r0 # put the high-order bits in r1 ! 316: # and a 0 in the bottom of r0 ! 317: rotl $-1,r0,r0 # right-justify the bits in r0 ! 318: # moving the 0 from the ashq ! 319: # into the sign bit. ! 320: # ! 321: # Step 3: convert both halves to floating point ! 322: # ! 323: cvtld r0,r6 # low-order part in r6-r7 ! 324: cvtld r1,r0 # high-order part in r0-r1 ! 325: # ! 326: # Step 4: multiply the high order part by 2**31 and combine them ! 327: # ! 328: muld2 two31,r0 # multiply ! 329: addd2 r6,r0 # combine ! 330: # ! 331: # Step 5: if appropriate, negate the floating value ! 332: # ! 333: jbc $msign,r3,cm2 # Jump if mantissa not signed ! 334: mnegd r0,r0 # If negative, make it so ! 335: # ! 336: # Step 6: call ldexp to complete the job ! 337: # ! 338: cm2: pushl r2 # Put exponent in parameter list ! 339: movd r0,-(sp) # and also mantissa ! 340: calls $3,_ldexp # go combine them ! 341: ! 342: exit: ret
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.