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