xref: /freebsd/contrib/gdtoa/misc.c (revision 59c8e88e72633afbc47a4ace0d2170d00d51f7dc)
1 /****************************************************************
2 
3 The author of this software is David M. Gay.
4 
5 Copyright (C) 1998, 1999 by Lucent Technologies
6 All Rights Reserved
7 
8 Permission to use, copy, modify, and distribute this software and
9 its documentation for any purpose and without fee is hereby
10 granted, provided that the above copyright notice appear in all
11 copies and that both that the copyright notice and this
12 permission notice and warranty disclaimer appear in supporting
13 documentation, and that the name of Lucent or any of its entities
14 not be used in advertising or publicity pertaining to
15 distribution of the software without specific, written prior
16 permission.
17 
18 LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
19 INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
20 IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR ANY
21 SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
22 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
23 IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
24 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
25 THIS SOFTWARE.
26 
27 ****************************************************************/
28 
29 /* Please send bug reports to David M. Gay (dmg at acm dot org,
30  * with " at " changed at "@" and " dot " changed to ".").	*/
31 
32 #include "gdtoaimp.h"
33 
34  static Bigint *freelist[Kmax+1];
35 #ifndef Omit_Private_Memory
36 #ifndef PRIVATE_MEM
37 #define PRIVATE_MEM 2304
38 #endif
39 #define PRIVATE_mem ((PRIVATE_MEM+sizeof(double)-1)/sizeof(double))
40 static double private_mem[PRIVATE_mem], *pmem_next = private_mem;
41 #endif
42 
43  Bigint *
44 Balloc
45 #ifdef KR_headers
46 	(k) int k;
47 #else
48 	(int k)
49 #endif
50 {
51 	int x;
52 	Bigint *rv;
53 #ifndef Omit_Private_Memory
54 	unsigned int len;
55 #endif
56 
57 	ACQUIRE_DTOA_LOCK(0);
58 	/* The k > Kmax case does not need ACQUIRE_DTOA_LOCK(0), */
59 	/* but this case seems very unlikely. */
60 	if (k <= Kmax && (rv = freelist[k]) !=0) {
61 		freelist[k] = rv->next;
62 		}
63 	else {
64 		x = 1 << k;
65 #ifdef Omit_Private_Memory
66 		rv = (Bigint *)MALLOC(sizeof(Bigint) + (x-1)*sizeof(ULong));
67 #else
68 		len = (sizeof(Bigint) + (x-1)*sizeof(ULong) + sizeof(double) - 1)
69 			/sizeof(double);
70 		if (k <= Kmax && pmem_next - private_mem + len <= PRIVATE_mem) {
71 			rv = (Bigint*)pmem_next;
72 			pmem_next += len;
73 			}
74 		else
75 			rv = (Bigint*)MALLOC(len*sizeof(double));
76 #endif
77 		rv->k = k;
78 		rv->maxwds = x;
79 		}
80 	FREE_DTOA_LOCK(0);
81 	rv->sign = rv->wds = 0;
82 	return rv;
83 	}
84 
85  void
86 Bfree
87 #ifdef KR_headers
88 	(v) Bigint *v;
89 #else
90 	(Bigint *v)
91 #endif
92 {
93 	if (v) {
94 		if (v->k > Kmax)
95 #ifdef FREE
96 			FREE((void*)v);
97 #else
98 			free((void*)v);
99 #endif
100 		else {
101 			ACQUIRE_DTOA_LOCK(0);
102 			v->next = freelist[v->k];
103 			freelist[v->k] = v;
104 			FREE_DTOA_LOCK(0);
105 			}
106 		}
107 	}
108 
109  int
110 lo0bits
111 #ifdef KR_headers
112 	(y) ULong *y;
113 #else
114 	(ULong *y)
115 #endif
116 {
117 	int k;
118 	ULong x = *y;
119 
120 	if (x & 7) {
121 		if (x & 1)
122 			return 0;
123 		if (x & 2) {
124 			*y = x >> 1;
125 			return 1;
126 			}
127 		*y = x >> 2;
128 		return 2;
129 		}
130 	k = 0;
131 	if (!(x & 0xffff)) {
132 		k = 16;
133 		x >>= 16;
134 		}
135 	if (!(x & 0xff)) {
136 		k += 8;
137 		x >>= 8;
138 		}
139 	if (!(x & 0xf)) {
140 		k += 4;
141 		x >>= 4;
142 		}
143 	if (!(x & 0x3)) {
144 		k += 2;
145 		x >>= 2;
146 		}
147 	if (!(x & 1)) {
148 		k++;
149 		x >>= 1;
150 		if (!x)
151 			return 32;
152 		}
153 	*y = x;
154 	return k;
155 	}
156 
157  Bigint *
158 multadd
159 #ifdef KR_headers
160 	(b, m, a) Bigint *b; int m, a;
161 #else
162 	(Bigint *b, int m, int a)	/* multiply by m and add a */
163 #endif
164 {
165 	int i, wds;
166 #ifdef ULLong
167 	ULong *x;
168 	ULLong carry, y;
169 #else
170 	ULong carry, *x, y;
171 #ifdef Pack_32
172 	ULong xi, z;
173 #endif
174 #endif
175 	Bigint *b1;
176 
177 	wds = b->wds;
178 	x = b->x;
179 	i = 0;
180 	carry = a;
181 	do {
182 #ifdef ULLong
183 		y = *x * (ULLong)m + carry;
184 		carry = y >> 32;
185 		*x++ = y & 0xffffffffUL;
186 #else
187 #ifdef Pack_32
188 		xi = *x;
189 		y = (xi & 0xffff) * m + carry;
190 		z = (xi >> 16) * m + (y >> 16);
191 		carry = z >> 16;
192 		*x++ = (z << 16) + (y & 0xffff);
193 #else
194 		y = *x * m + carry;
195 		carry = y >> 16;
196 		*x++ = y & 0xffff;
197 #endif
198 #endif
199 		}
200 		while(++i < wds);
201 	if (carry) {
202 		if (wds >= b->maxwds) {
203 			b1 = Balloc(b->k+1);
204 			Bcopy(b1, b);
205 			Bfree(b);
206 			b = b1;
207 			}
208 		b->x[wds++] = carry;
209 		b->wds = wds;
210 		}
211 	return b;
212 	}
213 
214  int
215 hi0bits_D2A
216 #ifdef KR_headers
217 	(x) ULong x;
218 #else
219 	(ULong x)
220 #endif
221 {
222 	int k = 0;
223 
224 	if (!(x & 0xffff0000)) {
225 		k = 16;
226 		x <<= 16;
227 		}
228 	if (!(x & 0xff000000)) {
229 		k += 8;
230 		x <<= 8;
231 		}
232 	if (!(x & 0xf0000000)) {
233 		k += 4;
234 		x <<= 4;
235 		}
236 	if (!(x & 0xc0000000)) {
237 		k += 2;
238 		x <<= 2;
239 		}
240 	if (!(x & 0x80000000)) {
241 		k++;
242 		if (!(x & 0x40000000))
243 			return 32;
244 		}
245 	return k;
246 	}
247 
248  Bigint *
249 i2b
250 #ifdef KR_headers
251 	(i) int i;
252 #else
253 	(int i)
254 #endif
255 {
256 	Bigint *b;
257 
258 	b = Balloc(1);
259 	b->x[0] = i;
260 	b->wds = 1;
261 	return b;
262 	}
263 
264  Bigint *
265 mult
266 #ifdef KR_headers
267 	(a, b) Bigint *a, *b;
268 #else
269 	(Bigint *a, Bigint *b)
270 #endif
271 {
272 	Bigint *c;
273 	int k, wa, wb, wc;
274 	ULong *x, *xa, *xae, *xb, *xbe, *xc, *xc0;
275 	ULong y;
276 #ifdef ULLong
277 	ULLong carry, z;
278 #else
279 	ULong carry, z;
280 #ifdef Pack_32
281 	ULong z2;
282 #endif
283 #endif
284 
285 	if (a->wds < b->wds) {
286 		c = a;
287 		a = b;
288 		b = c;
289 		}
290 	k = a->k;
291 	wa = a->wds;
292 	wb = b->wds;
293 	wc = wa + wb;
294 	if (wc > a->maxwds)
295 		k++;
296 	c = Balloc(k);
297 	for(x = c->x, xa = x + wc; x < xa; x++)
298 		*x = 0;
299 	xa = a->x;
300 	xae = xa + wa;
301 	xb = b->x;
302 	xbe = xb + wb;
303 	xc0 = c->x;
304 #ifdef ULLong
305 	for(; xb < xbe; xc0++) {
306 		if ( (y = *xb++) !=0) {
307 			x = xa;
308 			xc = xc0;
309 			carry = 0;
310 			do {
311 				z = *x++ * (ULLong)y + *xc + carry;
312 				carry = z >> 32;
313 				*xc++ = z & 0xffffffffUL;
314 				}
315 				while(x < xae);
316 			*xc = carry;
317 			}
318 		}
319 #else
320 #ifdef Pack_32
321 	for(; xb < xbe; xb++, xc0++) {
322 		if ( (y = *xb & 0xffff) !=0) {
323 			x = xa;
324 			xc = xc0;
325 			carry = 0;
326 			do {
327 				z = (*x & 0xffff) * y + (*xc & 0xffff) + carry;
328 				carry = z >> 16;
329 				z2 = (*x++ >> 16) * y + (*xc >> 16) + carry;
330 				carry = z2 >> 16;
331 				Storeinc(xc, z2, z);
332 				}
333 				while(x < xae);
334 			*xc = carry;
335 			}
336 		if ( (y = *xb >> 16) !=0) {
337 			x = xa;
338 			xc = xc0;
339 			carry = 0;
340 			z2 = *xc;
341 			do {
342 				z = (*x & 0xffff) * y + (*xc >> 16) + carry;
343 				carry = z >> 16;
344 				Storeinc(xc, z, z2);
345 				z2 = (*x++ >> 16) * y + (*xc & 0xffff) + carry;
346 				carry = z2 >> 16;
347 				}
348 				while(x < xae);
349 			*xc = z2;
350 			}
351 		}
352 #else
353 	for(; xb < xbe; xc0++) {
354 		if ( (y = *xb++) !=0) {
355 			x = xa;
356 			xc = xc0;
357 			carry = 0;
358 			do {
359 				z = *x++ * y + *xc + carry;
360 				carry = z >> 16;
361 				*xc++ = z & 0xffff;
362 				}
363 				while(x < xae);
364 			*xc = carry;
365 			}
366 		}
367 #endif
368 #endif
369 	for(xc0 = c->x, xc = xc0 + wc; wc > 0 && !*--xc; --wc) ;
370 	c->wds = wc;
371 	return c;
372 	}
373 
374  static Bigint *p5s;
375 
376  Bigint *
377 pow5mult
378 #ifdef KR_headers
379 	(b, k) Bigint *b; int k;
380 #else
381 	(Bigint *b, int k)
382 #endif
383 {
384 	Bigint *b1, *p5, *p51;
385 	int i;
386 	static int p05[3] = { 5, 25, 125 };
387 
388 	if ( (i = k & 3) !=0)
389 		b = multadd(b, p05[i-1], 0);
390 
391 	if (!(k >>= 2))
392 		return b;
393 	if ((p5 = p5s) == 0) {
394 		/* first time */
395 #ifdef MULTIPLE_THREADS
396 		ACQUIRE_DTOA_LOCK(1);
397 		if (!(p5 = p5s)) {
398 			p5 = p5s = i2b(625);
399 			p5->next = 0;
400 			}
401 		FREE_DTOA_LOCK(1);
402 #else
403 		p5 = p5s = i2b(625);
404 		p5->next = 0;
405 #endif
406 		}
407 	for(;;) {
408 		if (k & 1) {
409 			b1 = mult(b, p5);
410 			Bfree(b);
411 			b = b1;
412 			}
413 		if (!(k >>= 1))
414 			break;
415 		if ((p51 = p5->next) == 0) {
416 #ifdef MULTIPLE_THREADS
417 			ACQUIRE_DTOA_LOCK(1);
418 			if (!(p51 = p5->next)) {
419 				p51 = p5->next = mult(p5,p5);
420 				p51->next = 0;
421 				}
422 			FREE_DTOA_LOCK(1);
423 #else
424 			p51 = p5->next = mult(p5,p5);
425 			p51->next = 0;
426 #endif
427 			}
428 		p5 = p51;
429 		}
430 	return b;
431 	}
432 
433  Bigint *
434 lshift
435 #ifdef KR_headers
436 	(b, k) Bigint *b; int k;
437 #else
438 	(Bigint *b, int k)
439 #endif
440 {
441 	int i, k1, n, n1;
442 	Bigint *b1;
443 	ULong *x, *x1, *xe, z;
444 
445 	n = k >> kshift;
446 	k1 = b->k;
447 	n1 = n + b->wds + 1;
448 	for(i = b->maxwds; n1 > i; i <<= 1)
449 		k1++;
450 	b1 = Balloc(k1);
451 	x1 = b1->x;
452 	for(i = 0; i < n; i++)
453 		*x1++ = 0;
454 	x = b->x;
455 	xe = x + b->wds;
456 	if (k &= kmask) {
457 #ifdef Pack_32
458 		k1 = 32 - k;
459 		z = 0;
460 		do {
461 			*x1++ = *x << k | z;
462 			z = *x++ >> k1;
463 			}
464 			while(x < xe);
465 		if ((*x1 = z) !=0)
466 			++n1;
467 #else
468 		k1 = 16 - k;
469 		z = 0;
470 		do {
471 			*x1++ = *x << k  & 0xffff | z;
472 			z = *x++ >> k1;
473 			}
474 			while(x < xe);
475 		if (*x1 = z)
476 			++n1;
477 #endif
478 		}
479 	else do
480 		*x1++ = *x++;
481 		while(x < xe);
482 	b1->wds = n1 - 1;
483 	Bfree(b);
484 	return b1;
485 	}
486 
487  int
488 cmp
489 #ifdef KR_headers
490 	(a, b) Bigint *a, *b;
491 #else
492 	(Bigint *a, Bigint *b)
493 #endif
494 {
495 	ULong *xa, *xa0, *xb, *xb0;
496 	int i, j;
497 
498 	i = a->wds;
499 	j = b->wds;
500 #ifdef DEBUG
501 	if (i > 1 && !a->x[i-1])
502 		Bug("cmp called with a->x[a->wds-1] == 0");
503 	if (j > 1 && !b->x[j-1])
504 		Bug("cmp called with b->x[b->wds-1] == 0");
505 #endif
506 	if (i -= j)
507 		return i;
508 	xa0 = a->x;
509 	xa = xa0 + j;
510 	xb0 = b->x;
511 	xb = xb0 + j;
512 	for(;;) {
513 		if (*--xa != *--xb)
514 			return *xa < *xb ? -1 : 1;
515 		if (xa <= xa0)
516 			break;
517 		}
518 	return 0;
519 	}
520 
521  Bigint *
522 diff
523 #ifdef KR_headers
524 	(a, b) Bigint *a, *b;
525 #else
526 	(Bigint *a, Bigint *b)
527 #endif
528 {
529 	Bigint *c;
530 	int i, wa, wb;
531 	ULong *xa, *xae, *xb, *xbe, *xc;
532 #ifdef ULLong
533 	ULLong borrow, y;
534 #else
535 	ULong borrow, y;
536 #ifdef Pack_32
537 	ULong z;
538 #endif
539 #endif
540 
541 	i = cmp(a,b);
542 	if (!i) {
543 		c = Balloc(0);
544 		c->wds = 1;
545 		c->x[0] = 0;
546 		return c;
547 		}
548 	if (i < 0) {
549 		c = a;
550 		a = b;
551 		b = c;
552 		i = 1;
553 		}
554 	else
555 		i = 0;
556 	c = Balloc(a->k);
557 	c->sign = i;
558 	wa = a->wds;
559 	xa = a->x;
560 	xae = xa + wa;
561 	wb = b->wds;
562 	xb = b->x;
563 	xbe = xb + wb;
564 	xc = c->x;
565 	borrow = 0;
566 #ifdef ULLong
567 	do {
568 		y = (ULLong)*xa++ - *xb++ - borrow;
569 		borrow = y >> 32 & 1UL;
570 		*xc++ = y & 0xffffffffUL;
571 		}
572 		while(xb < xbe);
573 	while(xa < xae) {
574 		y = *xa++ - borrow;
575 		borrow = y >> 32 & 1UL;
576 		*xc++ = y & 0xffffffffUL;
577 		}
578 #else
579 #ifdef Pack_32
580 	do {
581 		y = (*xa & 0xffff) - (*xb & 0xffff) - borrow;
582 		borrow = (y & 0x10000) >> 16;
583 		z = (*xa++ >> 16) - (*xb++ >> 16) - borrow;
584 		borrow = (z & 0x10000) >> 16;
585 		Storeinc(xc, z, y);
586 		}
587 		while(xb < xbe);
588 	while(xa < xae) {
589 		y = (*xa & 0xffff) - borrow;
590 		borrow = (y & 0x10000) >> 16;
591 		z = (*xa++ >> 16) - borrow;
592 		borrow = (z & 0x10000) >> 16;
593 		Storeinc(xc, z, y);
594 		}
595 #else
596 	do {
597 		y = *xa++ - *xb++ - borrow;
598 		borrow = (y & 0x10000) >> 16;
599 		*xc++ = y & 0xffff;
600 		}
601 		while(xb < xbe);
602 	while(xa < xae) {
603 		y = *xa++ - borrow;
604 		borrow = (y & 0x10000) >> 16;
605 		*xc++ = y & 0xffff;
606 		}
607 #endif
608 #endif
609 	while(!*--xc)
610 		wa--;
611 	c->wds = wa;
612 	return c;
613 	}
614 
615  double
616 b2d
617 #ifdef KR_headers
618 	(a, e) Bigint *a; int *e;
619 #else
620 	(Bigint *a, int *e)
621 #endif
622 {
623 	ULong *xa, *xa0, w, y, z;
624 	int k;
625 	U d;
626 #ifdef VAX
627 	ULong d0, d1;
628 #else
629 #define d0 word0(&d)
630 #define d1 word1(&d)
631 #endif
632 
633 	xa0 = a->x;
634 	xa = xa0 + a->wds;
635 	y = *--xa;
636 #ifdef DEBUG
637 	if (!y) Bug("zero y in b2d");
638 #endif
639 	k = hi0bits(y);
640 	*e = 32 - k;
641 #ifdef Pack_32
642 	if (k < Ebits) {
643 		d0 = Exp_1 | y >> (Ebits - k);
644 		w = xa > xa0 ? *--xa : 0;
645 		d1 = y << ((32-Ebits) + k) | w >> (Ebits - k);
646 		goto ret_d;
647 		}
648 	z = xa > xa0 ? *--xa : 0;
649 	if (k -= Ebits) {
650 		d0 = Exp_1 | y << k | z >> (32 - k);
651 		y = xa > xa0 ? *--xa : 0;
652 		d1 = z << k | y >> (32 - k);
653 		}
654 	else {
655 		d0 = Exp_1 | y;
656 		d1 = z;
657 		}
658 #else
659 	if (k < Ebits + 16) {
660 		z = xa > xa0 ? *--xa : 0;
661 		d0 = Exp_1 | y << k - Ebits | z >> Ebits + 16 - k;
662 		w = xa > xa0 ? *--xa : 0;
663 		y = xa > xa0 ? *--xa : 0;
664 		d1 = z << k + 16 - Ebits | w << k - Ebits | y >> 16 + Ebits - k;
665 		goto ret_d;
666 		}
667 	z = xa > xa0 ? *--xa : 0;
668 	w = xa > xa0 ? *--xa : 0;
669 	k -= Ebits + 16;
670 	d0 = Exp_1 | y << k + 16 | z << k | w >> 16 - k;
671 	y = xa > xa0 ? *--xa : 0;
672 	d1 = w << k + 16 | y << k;
673 #endif
674  ret_d:
675 #ifdef VAX
676 	word0(&d) = d0 >> 16 | d0 << 16;
677 	word1(&d) = d1 >> 16 | d1 << 16;
678 #endif
679 	return dval(&d);
680 	}
681 #undef d0
682 #undef d1
683 
684  Bigint *
685 d2b
686 #ifdef KR_headers
687 	(dd, e, bits) double dd; int *e, *bits;
688 #else
689 	(double dd, int *e, int *bits)
690 #endif
691 {
692 	Bigint *b;
693 	U d;
694 #ifndef Sudden_Underflow
695 	int i;
696 #endif
697 	int de, k;
698 	ULong *x, y, z;
699 #ifdef VAX
700 	ULong d0, d1;
701 #else
702 #define d0 word0(&d)
703 #define d1 word1(&d)
704 #endif
705 	d.d = dd;
706 #ifdef VAX
707 	d0 = word0(&d) >> 16 | word0(&d) << 16;
708 	d1 = word1(&d) >> 16 | word1(&d) << 16;
709 #endif
710 
711 #ifdef Pack_32
712 	b = Balloc(1);
713 #else
714 	b = Balloc(2);
715 #endif
716 	x = b->x;
717 
718 	z = d0 & Frac_mask;
719 	d0 &= 0x7fffffff;	/* clear sign bit, which we ignore */
720 #ifdef Sudden_Underflow
721 	de = (int)(d0 >> Exp_shift);
722 #ifndef IBM
723 	z |= Exp_msk11;
724 #endif
725 #else
726 	if ( (de = (int)(d0 >> Exp_shift)) !=0)
727 		z |= Exp_msk1;
728 #endif
729 #ifdef Pack_32
730 	if ( (y = d1) !=0) {
731 		if ( (k = lo0bits(&y)) !=0) {
732 			x[0] = y | z << (32 - k);
733 			z >>= k;
734 			}
735 		else
736 			x[0] = y;
737 #ifndef Sudden_Underflow
738 		i =
739 #endif
740 		     b->wds = (x[1] = z) !=0 ? 2 : 1;
741 		}
742 	else {
743 		k = lo0bits(&z);
744 		x[0] = z;
745 #ifndef Sudden_Underflow
746 		i =
747 #endif
748 		    b->wds = 1;
749 		k += 32;
750 		}
751 #else
752 	if ( (y = d1) !=0) {
753 		if ( (k = lo0bits(&y)) !=0)
754 			if (k >= 16) {
755 				x[0] = y | z << 32 - k & 0xffff;
756 				x[1] = z >> k - 16 & 0xffff;
757 				x[2] = z >> k;
758 				i = 2;
759 				}
760 			else {
761 				x[0] = y & 0xffff;
762 				x[1] = y >> 16 | z << 16 - k & 0xffff;
763 				x[2] = z >> k & 0xffff;
764 				x[3] = z >> k+16;
765 				i = 3;
766 				}
767 		else {
768 			x[0] = y & 0xffff;
769 			x[1] = y >> 16;
770 			x[2] = z & 0xffff;
771 			x[3] = z >> 16;
772 			i = 3;
773 			}
774 		}
775 	else {
776 #ifdef DEBUG
777 		if (!z)
778 			Bug("Zero passed to d2b");
779 #endif
780 		k = lo0bits(&z);
781 		if (k >= 16) {
782 			x[0] = z;
783 			i = 0;
784 			}
785 		else {
786 			x[0] = z & 0xffff;
787 			x[1] = z >> 16;
788 			i = 1;
789 			}
790 		k += 32;
791 		}
792 	while(!x[i])
793 		--i;
794 	b->wds = i + 1;
795 #endif
796 #ifndef Sudden_Underflow
797 	if (de) {
798 #endif
799 #ifdef IBM
800 		*e = (de - Bias - (P-1) << 2) + k;
801 		*bits = 4*P + 8 - k - hi0bits(word0(&d) & Frac_mask);
802 #else
803 		*e = de - Bias - (P-1) + k;
804 		*bits = P - k;
805 #endif
806 #ifndef Sudden_Underflow
807 		}
808 	else {
809 		*e = de - Bias - (P-1) + 1 + k;
810 #ifdef Pack_32
811 		*bits = 32*i - hi0bits(x[i-1]);
812 #else
813 		*bits = (i+2)*16 - hi0bits(x[i]);
814 #endif
815 		}
816 #endif
817 	return b;
818 	}
819 #undef d0
820 #undef d1
821 
822  CONST double
823 #ifdef IEEE_Arith
824 bigtens[] = { 1e16, 1e32, 1e64, 1e128, 1e256 };
825 CONST double tinytens[] = { 1e-16, 1e-32, 1e-64, 1e-128, 1e-256
826 		};
827 #else
828 #ifdef IBM
829 bigtens[] = { 1e16, 1e32, 1e64 };
830 CONST double tinytens[] = { 1e-16, 1e-32, 1e-64 };
831 #else
832 bigtens[] = { 1e16, 1e32 };
833 CONST double tinytens[] = { 1e-16, 1e-32 };
834 #endif
835 #endif
836 
837  CONST double
838 tens[] = {
839 		1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
840 		1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
841 		1e20, 1e21, 1e22
842 #ifdef VAX
843 		, 1e23, 1e24
844 #endif
845 		};
846 
847  char *
848 #ifdef KR_headers
849 strcp_D2A(a, b) char *a; char *b;
850 #else
851 strcp_D2A(char *a, CONST char *b)
852 #endif
853 {
854 	while((*a = *b++))
855 		a++;
856 	return a;
857 	}
858 
859 #ifdef NO_STRING_H
860 
861  Char *
862 #ifdef KR_headers
863 memcpy_D2A(a, b, len) Char *a; Char *b; size_t len;
864 #else
865 memcpy_D2A(void *a1, void *b1, size_t len)
866 #endif
867 {
868 	char *a = (char*)a1, *ae = a + len;
869 	char *b = (char*)b1, *a0 = a;
870 	while(a < ae)
871 		*a++ = *b++;
872 	return a0;
873 	}
874 
875 #endif /* NO_STRING_H */
876