![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to _fconv.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / libc / stdio|
Return to _fconv.c CVS log | Up to [Research Unix] / researchv10no / libc / stdio |
1.1 root 1: /* Common routines for _dtoa and strtod */
2:
3: #include "fconv.h"
4:
5: #ifdef DEBUG
6: #include <stdio.h>
7: #define Bug(x) {fprintf(stderr, "%s\n", x); exit(1);}
8: #endif
9:
10: double
11: _tens[] = {
12: 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
13: 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
14: 1e20, 1e21, 1e22
15: #ifdef VAX
16: , 1e23, 1e24
17: #endif
18: };
19:
20:
21: #ifdef IEEE_Arith
22: double _bigtens[] = { 1e16, 1e32, 1e64, 1e128, 1e256 };
23: double _tinytens[] = { 1e-16, 1e-32, 1e-64, 1e-128, 1e-256 };
24: #else
25: #ifdef IBM
26: double _bigtens[] = { 1e16, 1e32, 1e64 };
27: double _tinytens[] = { 1e-16, 1e-32, 1e-64 };
28: #else
29: double _bigtens[] = { 1e16, 1e32 };
30: double _tinytens[] = { 1e-16, 1e-32 };
31: #endif
32: #endif
33:
34: static Bigint *freelist[Kmax+1];
35:
36: Bigint *
37: _Balloc(int k)
38: {
39: int x;
40: Bigint *rv;
41:
42: if (rv = freelist[k]) {
43: freelist[k] = rv->next;
44: }
45: else {
46: x = 1 << k;
47: rv = (Bigint *)malloc(sizeof(Bigint) + (x-1)*sizeof(long));
48: rv->k = k;
49: rv->maxwds = x;
50: }
51: rv->sign = rv->wds = 0;
52: return rv;
53: }
54:
55: void
56: _Bfree(Bigint *v)
57: {
58: if (v) {
59: v->next = freelist[v->k];
60: freelist[v->k] = v;
61: }
62: }
63:
64:
65: Bigint *
66: _multadd(Bigint *b, int m, int a) /* multiply by m and add a */
67: {
68: int i, wds;
69: unsigned long *x, y;
70: #ifdef Pack_32
71: unsigned long xi, z;
72: #endif
73: Bigint *b1;
74:
75: wds = b->wds;
76: x = b->x;
77: i = 0;
78: do {
79: #ifdef Pack_32
80: xi = *x;
81: y = (xi & 0xffff) * m + a;
82: z = (xi >> 16) * m + (y >> 16);
83: a = (int)(z >> 16);
84: *x++ = (z << 16) + (y & 0xffff);
85: #else
86: y = *x * m + a;
87: a = (int)(y >> 16);
88: *x++ = y & 0xffff;
89: #endif
90: }
91: while(++i < wds);
92: if (a) {
93: if (wds >= b->maxwds) {
94: b1 = Balloc(b->k+1);
95: Bcopy(b1, b);
96: Bfree(b);
97: b = b1;
98: }
99: b->x[wds++] = a;
100: b->wds = wds;
101: }
102: return b;
103: }
104:
105: int
106: _hi0bits(register unsigned long x)
107: {
108: register int k = 0;
109:
110: if (!(x & 0xffff0000)) {
111: k = 16;
112: x <<= 16;
113: }
114: if (!(x & 0xff000000)) {
115: k += 8;
116: x <<= 8;
117: }
118: if (!(x & 0xf0000000)) {
119: k += 4;
120: x <<= 4;
121: }
122: if (!(x & 0xc0000000)) {
123: k += 2;
124: x <<= 2;
125: }
126: if (!(x & 0x80000000)) {
127: k++;
128: if (!(x & 0x40000000))
129: return 32;
130: }
131: return k;
132: }
133:
134: static int
135: lo0bits(unsigned long *y)
136: {
137: register int k;
138: register unsigned long x = *y;
139:
140: if (x & 7) {
141: if (x & 1)
142: return 0;
143: if (x & 2) {
144: *y = x >> 1;
145: return 1;
146: }
147: *y = x >> 2;
148: return 2;
149: }
150: k = 0;
151: if (!(x & 0xffff)) {
152: k = 16;
153: x >>= 16;
154: }
155: if (!(x & 0xff)) {
156: k += 8;
157: x >>= 8;
158: }
159: if (!(x & 0xf)) {
160: k += 4;
161: x >>= 4;
162: }
163: if (!(x & 0x3)) {
164: k += 2;
165: x >>= 2;
166: }
167: if (!(x & 1)) {
168: k++;
169: x >>= 1;
170: if (!x & 1)
171: return 32;
172: }
173: *y = x;
174: return k;
175: }
176:
177: Bigint *
178: _i2b(int i)
179: {
180: Bigint *b;
181:
182: b = Balloc(1);
183: b->x[0] = i;
184: b->wds = 1;
185: return b;
186: }
187:
188: Bigint *
189: _mult(Bigint *a, Bigint *b)
190: {
191: Bigint *c;
192: int k, wa, wb, wc;
193: unsigned long carry, y, z;
194: unsigned long *x, *xa, *xae, *xb, *xbe, *xc, *xc0;
195: #ifdef Pack_32
196: unsigned long z2;
197: #endif
198:
199: if (a->wds < b->wds) {
200: c = a;
201: a = b;
202: b = c;
203: }
204: k = a->k;
205: wa = a->wds;
206: wb = b->wds;
207: wc = wa + wb;
208: if (wc > a->maxwds)
209: k++;
210: c = Balloc(k);
211: for(x = c->x, xa = x + wc; x < xa; x++)
212: *x = 0;
213: xa = a->x;
214: xae = xa + wa;
215: xb = b->x;
216: xbe = xb + wb;
217: xc0 = c->x;
218: #ifdef Pack_32
219: for(; xb < xbe; xb++, xc0++) {
220: if (y = *xb & 0xffff) {
221: x = xa;
222: xc = xc0;
223: carry = 0;
224: do {
225: z = (*x & 0xffff) * y + (*xc & 0xffff) + carry;
226: carry = z >> 16;
227: z2 = (*x++ >> 16) * y + (*xc >> 16) + carry;
228: carry = z2 >> 16;
229: Storeinc(xc, z2, z);
230: }
231: while(x < xae);
232: *xc = carry;
233: }
234: if (y = *xb >> 16) {
235: x = xa;
236: xc = xc0;
237: carry = 0;
238: z2 = *xc;
239: do {
240: z = (*x & 0xffff) * y + (*xc >> 16) + carry;
241: carry = z >> 16;
242: Storeinc(xc, z, z2);
243: z2 = (*x++ >> 16) * y + (*xc & 0xffff) + carry;
244: carry = z2 >> 16;
245: }
246: while(x < xae);
247: *xc = z2;
248: }
249: }
250: #else
251: for(; xb < xbe; xc0++) {
252: if (y = *xb++) {
253: x = xa;
254: xc = xc0;
255: carry = 0;
256: do {
257: z = *x++ * y + *xc + carry;
258: carry = z >> 16;
259: *xc++ = z & 0xffff;
260: }
261: while(x < xae);
262: *xc = carry;
263: }
264: }
265: #endif
266: for(xc0 = c->x, xc = xc0 + wc; wc > 0 && !*--xc; --wc) ;
267: c->wds = wc;
268: return c;
269: }
270:
271: static Bigint *p5s;
272:
273: Bigint *
274: _pow5mult(Bigint *b, int k)
275: {
276: Bigint *b1, *p5, *p51;
277: int i;
278: static int p05[3] = { 5, 25, 125 };
279:
280: if (i = k & 3)
281: b = multadd(b, p05[i-1], 0);
282:
283: if (!(k >>= 2))
284: return b;
285: if (!(p5 = p5s)) {
286: /* first time */
287: p5 = p5s = i2b(625);
288: p5->next = 0;
289: }
290: for(;;) {
291: if (k & 1) {
292: b1 = mult(b, p5);
293: Bfree(b);
294: b = b1;
295: }
296: if (!(k >>= 1))
297: break;
298: if (!(p51 = p5->next)) {
299: p51 = p5->next = mult(p5,p5);
300: p51->next = 0;
301: }
302: p5 = p51;
303: }
304: return b;
305: }
306:
307: Bigint *
308: _lshift(Bigint *b, int k)
309: {
310: int i, k1, n, n1;
311: Bigint *b1;
312: unsigned long *x, *x1, *xe, z;
313:
314: #ifdef Pack_32
315: n = k >> 5;
316: #else
317: n = k >> 4;
318: #endif
319: k1 = b->k;
320: n1 = n + b->wds + 1;
321: for(i = b->maxwds; n1 > i; i <<= 1)
322: k1++;
323: b1 = Balloc(k1);
324: x1 = b1->x;
325: for(i = 0; i < n; i++)
326: *x1++ = 0;
327: x = b->x;
328: xe = x + b->wds;
329: #ifdef Pack_32
330: if (k &= 0x1f) {
331: k1 = 32 - k;
332: z = 0;
333: do {
334: *x1++ = *x << k | z;
335: z = *x++ >> k1;
336: }
337: while(x < xe);
338: if (*x1 = z)
339: ++n1;
340: }
341: #else
342: if (k &= 0xf) {
343: k1 = 16 - k;
344: z = 0;
345: do {
346: *x1++ = *x << k & 0xffff | z;
347: z = *x++ >> k1;
348: }
349: while(x < xe);
350: if (*x1 = z)
351: ++n1;
352: }
353: #endif
354: else do
355: *x1++ = *x++;
356: while(x < xe);
357: b1->wds = n1 - 1;
358: Bfree(b);
359: return b1;
360: }
361:
362: int
363: _cmp(Bigint *a, Bigint *b)
364: {
365: unsigned long *xa, *xa0, *xb, *xb0;
366: int i, j;
367:
368: i = a->wds;
369: j = b->wds;
370: #ifdef DEBUG
371: if (i > 1 && !a->x[i-1])
372: Bug("cmp called with a->x[a->wds-1] == 0");
373: if (j > 1 && !b->x[j-1])
374: Bug("cmp called with b->x[b->wds-1] == 0");
375: #endif
376: if (i -= j)
377: return i;
378: xa0 = a->x;
379: xa = xa0 + j;
380: xb0 = b->x;
381: xb = xb0 + j;
382: for(;;) {
383: if (*--xa != *--xb)
384: return *xa < *xb ? -1 : 1;
385: if (xa <= xa0)
386: break;
387: }
388: return 0;
389: }
390:
391: Bigint *
392: _diff(Bigint *a, Bigint *b)
393: {
394: Bigint *c;
395: int i, wa, wb;
396: long borrow, y; /* We need signed shifts here. */
397: unsigned long *xa, *xae, *xb, *xbe, *xc;
398: #ifdef Pack_32
399: long z;
400: #endif
401:
402: i = cmp(a,b);
403: if (!i) {
404: c = Balloc(0);
405: c->wds = 1;
406: c->x[0] = 0;
407: return c;
408: }
409: if (i < 0) {
410: c = a;
411: a = b;
412: b = c;
413: i = 1;
414: }
415: else
416: i = 0;
417: c = Balloc(a->k);
418: c->sign = i;
419: wa = a->wds;
420: xa = a->x;
421: xae = xa + wa;
422: wb = b->wds;
423: xb = b->x;
424: xbe = xb + wb;
425: xc = c->x;
426: borrow = 0;
427: #ifdef Pack_32
428: do {
429: y = (*xa & 0xffff) - (*xb & 0xffff) + borrow;
430: borrow = y >> 16;
431: Sign_Extend(borrow, y);
432: z = (*xa++ >> 16) - (*xb++ >> 16) + borrow;
433: borrow = z >> 16;
434: Sign_Extend(borrow, z);
435: Storeinc(xc, z, y);
436: }
437: while(xb < xbe);
438: while(xa < xae) {
439: y = (*xa & 0xffff) + borrow;
440: borrow = y >> 16;
441: Sign_Extend(borrow, y);
442: z = (*xa++ >> 16) + borrow;
443: borrow = z >> 16;
444: Sign_Extend(borrow, z);
445: Storeinc(xc, z, y);
446: }
447: #else
448: do {
449: y = *xa++ - *xb++ + borrow;
450: borrow = y >> 16;
451: Sign_Extend(borrow, y);
452: *xc++ = y & 0xffff;
453: }
454: while(xb < xbe);
455: while(xa < xae) {
456: y = *xa++ + borrow;
457: borrow = y >> 16;
458: Sign_Extend(borrow, y);
459: *xc++ = y & 0xffff;
460: }
461: #endif
462: while(!*--xc)
463: wa--;
464: c->wds = wa;
465: return c;
466: }
467:
468: Bigint *
469: _d2b(double darg, int *e, int *bits)
470: {
471: Bigint *b;
472: int de, i, k;
473: unsigned long *x, y, z;
474: Dul d;
475: #ifdef VAX
476: unsigned long d0, d1;
477: d.d = darg;
478: d0 = word0(d) >> 16 | word0(d) << 16;
479: d1 = word1(d) >> 16 | word1(d) << 16;
480: #else
481: d.d = darg;
482: #define d0 word0(d)
483: #define d1 word1(d)
484: #endif
485:
486: #ifdef Pack_32
487: b = Balloc(1);
488: #else
489: b = Balloc(2);
490: #endif
491: x = b->x;
492:
493: z = d0 & Frac_mask;
494: d0 &= 0x7fffffff; /* clear sign bit, which we ignore */
495: #ifdef Sudden_Underflow
496: de = (int)(d0 >> Exp_shift);
497: #ifndef IBM
498: z |= Exp_msk11;
499: #endif
500: #else
501: if (de = (int)(d0 >> Exp_shift))
502: z |= Exp_msk1;
503: #endif
504: #ifdef Pack_32
505: if (y = d1) {
506: if (k = lo0bits(&y)) {
507: x[0] = y | z << 32 - k;
508: z >>= k;
509: }
510: else
511: x[0] = y;
512: i = b->wds = (x[1] = z) ? 2 : 1;
513: }
514: else {
515: #ifdef DEBUG
516: if (!z)
517: Bug("Zero passed to d2b");
518: #endif
519: k = lo0bits(&z);
520: x[0] = z;
521: i = b->wds = 1;
522: k += 32;
523: }
524: #else
525: if (y = d1) {
526: if (k = lo0bits(&y))
527: if (k >= 16) {
528: x[0] = y | z << 32 - k & 0xffff;
529: x[1] = z >> k - 16 & 0xffff;
530: x[2] = z >> k;
531: i = 2;
532: }
533: else {
534: x[0] = y & 0xffff;
535: x[1] = y >> 16 | z << 16 - k & 0xffff;
536: x[2] = z >> k & 0xffff;
537: x[3] = z >> k+16;
538: i = 3;
539: }
540: else {
541: x[0] = y & 0xffff;
542: x[1] = y >> 16;
543: x[2] = z & 0xffff;
544: x[3] = z >> 16;
545: i = 3;
546: }
547: }
548: else {
549: #ifdef DEBUG
550: if (!z)
551: Bug("Zero passed to d2b");
552: #endif
553: k = lo0bits(&z);
554: if (k >= 16) {
555: x[0] = z;
556: i = 0;
557: }
558: else {
559: x[0] = z & 0xffff;
560: x[1] = z >> 16;
561: i = 1;
562: }
563: k += 32;
564: }
565: while(!x[i])
566: --i;
567: b->wds = i + 1;
568: #endif
569: #ifndef Sudden_Underflow
570: if (de) {
571: #endif
572: #ifdef IBM
573: *e = (de - Bias - (P-1) << 2) + k;
574: *bits = 4*P + 8 - k - hi0bits(word0(d) & Frac_mask);
575: #else
576: *e = de - Bias - (P-1) + k;
577: *bits = P - k;
578: #endif
579: #ifndef Sudden_Underflow
580: }
581: else {
582: *e = de - Bias - (P-1) + 1 + k;
583: #ifdef Pack_32
584: *bits = 32*i - hi0bits(x[i-1]);
585: #else
586: *bits = (i+2)*16 - hi0bits(x[i]);
587: #endif
588: }
589: #endif
590: return b;
591: }
592: #undef d0
593: #undef d1
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.