op public repos

Blob

Date:: Sun Feb 29 22:11:15 2004 UTC
Message:: Move utf, fmt. Small header file changes.
Actions:: History | Blame | Raw File
1 /*
2  * The authors of this software are Rob Pike and Ken Thompson.
3  *              Copyright (c) 2002 by Lucent Technologies.
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose without fee is hereby granted, provided that this entire notice
6  * is included in all copies of any software which is or includes a copy
7  * or modification of this software and in all copies of the supporting
8  * documentation for such software.
9  * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
10  * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
11  * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
12  * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
13  */
14 #include <stdio.h>
15 #include <math.h>
16 #include <float.h>
17 #include <string.h>
18 #include <stdlib.h>
19 #include <errno.h>
20 #include <stdarg.h>
21 #include "fmt.h"
22 #include "fmtdef.h"
23 #include "nan.h"
24 
25 enum
26 {
27 	FDEFLT	= 6,
28 	NSIGNIF	= 17
29 };
30 
31 /*
32  * first few powers of 10, enough for about 1/2 of the
33  * total space for doubles.
34  */
35 static double pows10[] =
36 {
37 	  1e0,   1e1,   1e2,   1e3,   1e4,   1e5,   1e6,   1e7,   1e8,   1e9,  
38 	 1e10,  1e11,  1e12,  1e13,  1e14,  1e15,  1e16,  1e17,  1e18,  1e19,  
39 	 1e20,  1e21,  1e22,  1e23,  1e24,  1e25,  1e26,  1e27,  1e28,  1e29,  
40 	 1e30,  1e31,  1e32,  1e33,  1e34,  1e35,  1e36,  1e37,  1e38,  1e39,  
41 	 1e40,  1e41,  1e42,  1e43,  1e44,  1e45,  1e46,  1e47,  1e48,  1e49,  
42 	 1e50,  1e51,  1e52,  1e53,  1e54,  1e55,  1e56,  1e57,  1e58,  1e59,  
43 	 1e60,  1e61,  1e62,  1e63,  1e64,  1e65,  1e66,  1e67,  1e68,  1e69,  
44 	 1e70,  1e71,  1e72,  1e73,  1e74,  1e75,  1e76,  1e77,  1e78,  1e79,  
45 	 1e80,  1e81,  1e82,  1e83,  1e84,  1e85,  1e86,  1e87,  1e88,  1e89,  
46 	 1e90,  1e91,  1e92,  1e93,  1e94,  1e95,  1e96,  1e97,  1e98,  1e99,  
47 	1e100, 1e101, 1e102, 1e103, 1e104, 1e105, 1e106, 1e107, 1e108, 1e109, 
48 	1e110, 1e111, 1e112, 1e113, 1e114, 1e115, 1e116, 1e117, 1e118, 1e119, 
49 	1e120, 1e121, 1e122, 1e123, 1e124, 1e125, 1e126, 1e127, 1e128, 1e129, 
50 	1e130, 1e131, 1e132, 1e133, 1e134, 1e135, 1e136, 1e137, 1e138, 1e139, 
51 	1e140, 1e141, 1e142, 1e143, 1e144, 1e145, 1e146, 1e147, 1e148, 1e149, 
52 	1e150, 1e151, 1e152, 1e153, 1e154, 1e155, 1e156, 1e157, 1e158, 1e159, 
53 };
54 
55 static double
56 pow10(int n)
57 {
58 	double d;
59 	int neg;
60 
61 	neg = 0;
62 	if(n < 0){
63 		if(n < DBL_MIN_10_EXP){
64 			return 0.;
65 		}
66 		neg = 1;
67 		n = -n;
68 	}else if(n > DBL_MAX_10_EXP){
69 		return HUGE_VAL;
70 	}
71 	if(n < (int)(sizeof(pows10)/sizeof(pows10[0])))
72 		d = pows10[n];
73 	else{
74 		d = pows10[sizeof(pows10)/sizeof(pows10[0]) - 1];
75 		for(;;){
76 			n -= sizeof(pows10)/sizeof(pows10[0]) - 1;
77 			if(n < (int)(sizeof(pows10)/sizeof(pows10[0]))){
78 				d *= pows10[n];
79 				break;
80 			}
81 			d *= pows10[sizeof(pows10)/sizeof(pows10[0]) - 1];
82 		}
83 	}
84 	if(neg){
85 		return 1./d;
86 	}
87 	return d;
88 }
89 
90 static int
91 xadd(char *a, int n, int v)
92 {
93 	char *b;
94 	int c;
95 
96 	if(n < 0 || n >= NSIGNIF)
97 		return 0;
98 	for(b = a+n; b >= a; b--) {
99 		c = *b + v;
100 		if(c <= '9') {
101 			*b = c;
102 			return 0;
103 		}
104 		*b = '0';
105 		v = 1;
106 	}
107 	*a = '1';	/* overflow adding */
108 	return 1;
109 }
110 
111 static int
112 xsub(char *a, int n, int v)
113 {
114 	char *b;
115 	int c;
116 
117 	for(b = a+n; b >= a; b--) {
118 		c = *b - v;
119 		if(c >= '0') {
120 			*b = c;
121 			return 0;
122 		}
123 		*b = '9';
124 		v = 1;
125 	}
126 	*a = '9';	/* underflow subtracting */
127 	return 1;
128 }
129 
130 static void
131 xaddexp(char *p, int e)
132 {
133 	char se[9];
134 	int i;
135 
136 	*p++ = 'e';
137 	if(e < 0) {
138 		*p++ = '-';
139 		e = -e;
140 	}
141 	i = 0;
142 	while(e) {
143 		se[i++] = e % 10 + '0';
144 		e /= 10;
145 	}
146 	if(i == 0) {
147 		*p++ = '0';
148 	} else {
149 		while(i > 0)
150 			*p++ = se[--i];
151 	}
152 	*p++ = '\0';
153 }
154 
155 static char*
156 xdodtoa(char *s1, double f, int chr, int prec, int *decpt, int *rsign)
157 {
158 	char s2[NSIGNIF+10];
159 	double g, h;
160 	int e, d, i;
161 	int c2, sign, oerr;
162 
163 	if(chr == 'F')
164 		chr = 'f';
165 	if(prec > NSIGNIF)
166 		prec = NSIGNIF;
167 	if(prec < 0)
168 		prec = 0;
169 	if(__isNaN(f)) {
170 		*decpt = 9999;
171 		*rsign = 0;
172 		strcpy(s1, "nan");
173 		return &s1[3];
174 	}
175 	sign = 0;
176 	if(f < 0) {
177 		f = -f;
178 		sign++;
179 	}
180 	*rsign = sign;
181 	if(__isInf(f, 1) || __isInf(f, -1)) {
182 		*decpt = 9999;
183 		strcpy(s1, "inf");
184 		return &s1[3];
185 	}
186 
187 	e = 0;
188 	g = f;
189 	if(g != 0) {
190 		frexp(f, &e);
191 		e = (int)(e * .301029995664);
192 		if(e >= -150 && e <= +150) {
193 			d = 0;
194 			h = f;
195 		} else {
196 			d = e/2;
197 			h = f * pow10(-d);
198 		}
199 		g = h * pow10(d-e);
200 		while(g < 1) {
201 			e--;
202 			g = h * pow10(d-e);
203 		}
204 		while(g >= 10) {
205 			e++;
206 			g = h * pow10(d-e);
207 		}
208 	}
209 
210 	/*
211 	 * convert NSIGNIF digits and convert
212 	 * back to get accuracy.
213 	 */
214 	for(i=0; i<NSIGNIF; i++) {
215 		d = (int)g;
216 		s1[i] = d + '0';
217 		g = (g - d) * 10;
218 	}
219 	s1[i] = 0;
220 
221 	/*
222 	 * try decimal rounding to eliminate 9s
223 	 */
224 	c2 = prec + 1;
225 	if(chr == 'f')
226 		c2 += e;
227 	oerr = errno;
228 	if(c2 >= NSIGNIF-2) {
229 		strcpy(s2, s1);
230 		d = e;
231 		s1[NSIGNIF-2] = '0';
232 		s1[NSIGNIF-1] = '0';
233 		xaddexp(s1+NSIGNIF, e-NSIGNIF+1);
234 		g = fmtstrtod(s1, nil);
235 		if(g == f)
236 			goto found;
237 		if(xadd(s1, NSIGNIF-3, 1)) {
238 			e++;
239 			xaddexp(s1+NSIGNIF, e-NSIGNIF+1);
240 		}
241 		g = fmtstrtod(s1, nil);
242 		if(g == f)
243 			goto found;
244 		strcpy(s1, s2);
245 		e = d;
246 	}
247 
248 	/*
249 	 * convert back so s1 gets exact answer
250 	 */
251 	for(d = 0; d < 10; d++) {
252 		xaddexp(s1+NSIGNIF, e-NSIGNIF+1);
253 		g = fmtstrtod(s1, nil);
254 		if(f > g) {
255 			if(xadd(s1, NSIGNIF-1, 1))
256 				e--;
257 			continue;
258 		}
259 		if(f < g) {
260 			if(xsub(s1, NSIGNIF-1, 1))
261 				e++;
262 			continue;
263 		}
264 		break;
265 	}
266 
267 found:
268 	errno = oerr;
269 
270 	/*
271 	 * sign
272 	 */
273 	d = 0;
274 	i = 0;
275 
276 	/*
277 	 * round & adjust 'f' digits
278 	 */
279 	c2 = prec + 1;
280 	if(chr == 'f'){
281 		if(xadd(s1, c2+e, 5))
282 			e++;
283 		c2 += e;
284 		if(c2 < 0){
285 			c2 = 0;
286 			e = -prec - 1;
287 		}
288 	}else{
289 		if(xadd(s1, c2, 5))
290 			e++;
291 	}
292 	if(c2 > NSIGNIF){
293 		c2 = NSIGNIF;
294 	}
295 
296 	*decpt = e + 1;
297 
298 	/*
299 	 * terminate the converted digits
300 	 */
301 	s1[c2] = '\0';
302 	return &s1[c2];
303 }
304 
305 /*
306  * this function works like the standard dtoa, if you want it.
307  */
308 #if 0
309 static char*
310 __dtoa(double f, int mode, int ndigits, int *decpt, int *rsign, char **rve)
311 {
312 	static char s2[NSIGNIF + 10];
313 	char *es;
314 	int chr, prec;
315 
316 	switch(mode) {
317 	/* like 'e' */
318 	case 2:
319 	case 4:
320 	case 6:
321 	case 8:
322 		chr = 'e';
323 		break;
324 	/* like 'g' */
325 	case 0:
326 	case 1:
327 	default:
328 		chr = 'g';
329 		break;
330 	/* like 'f' */
331 	case 3:
332 	case 5:
333 	case 7:
334 	case 9:
335 		chr = 'f';
336 		break;
337 	}
338 
339 	if(chr != 'f' && ndigits){
340 		ndigits--;
341 	}
342 	prec = ndigits;
343 	if(prec > NSIGNIF)
344 		prec = NSIGNIF;
345 	if(ndigits == 0)
346 		prec = NSIGNIF;
347 	es = xdodtoa(s2, f, chr, prec, decpt, rsign);
348 
349 	/*
350 	 * strip trailing 0
351 	 */
352 	for(; es > s2 + 1; es--){
353 		if(es[-1] != '0'){
354 			break;
355 		}
356 	}
357 	*es = '\0';
358 	if(rve != NULL)
359 		*rve = es;
360 	return s2;
361 }
362 #endif
363 
364 static int
365 fmtzdotpad(Fmt *f, int n, int pt)
366 {
367 	char *t, *s;
368 	int i;
369 	Rune *rt, *rs;
370 
371 	if(f->runes){
372 		rt = (Rune*)f->to;
373 		rs = (Rune*)f->stop;
374 		for(i = 0; i < n; i++){
375 			if(i == pt){
376 				FMTRCHAR(f, rt, rs, '.');
377 			}
378 			FMTRCHAR(f, rt, rs, '0');
379 		}
380 		f->nfmt += rt - (Rune*)f->to;
381 		f->to = rt;
382 	}else{
383 		t = (char*)f->to;
384 		s = (char*)f->stop;
385 		for(i = 0; i < n; i++){
386 			if(i == pt){
387 				FMTCHAR(f, t, s, '.');
388 			}
389 			FMTCHAR(f, t, s, '0');
390 		}
391 		f->nfmt += t - (char *)f->to;
392 		f->to = t;
393 	}
394 	return 0;
395 }
396 
397 int
398 __efgfmt(Fmt *fmt)
399 {
400 	double f;
401 	char s1[NSIGNIF+10];
402 	int e, d, n;
403 	int c1, c2, c3, c4, ucase, sign, chr, prec, fl;
404 
405 	f = va_arg(fmt->args, double);
406 	prec = FDEFLT;
407 	fl = fmt->flags;
408 	fmt->flags = 0;
409 	if(fl & FmtPrec)
410 		prec = fmt->prec;
411 	chr = fmt->r;
412 	ucase = 0;
413 	if(chr == 'E'){
414 		chr = 'e';
415 		ucase = 1;
416 	}else if(chr == 'F'){
417 		chr = 'f';
418 		ucase = 1;
419 	}else if(chr == 'G'){
420 		chr = 'g';
421 		ucase = 1;
422 	}
423 	if(prec > 0 && chr == 'g')
424 		prec--;
425 	if(prec < 0)
426 		prec = 0;
427 
428 	xdodtoa(s1, f, chr, prec, &e, &sign);
429 	e--;
430 	if(*s1 == 'i' || *s1 == 'n'){
431 		if(ucase){
432 			if(*s1 == 'i'){
433 				strcpy(s1, "INF");
434 			}else{
435 				strcpy(s1, "NAN");
436 			}
437 		}
438 		fmt->flags = fl & (FmtWidth|FmtLeft);
439 		return __fmtcpy(fmt, (const void*)s1, 3, 3);
440 	}
441 
442 	/*
443 	 * copy into final place
444 	 * c1 digits of leading '0'
445 	 * c2 digits from conversion
446 	 * c3 digits of trailing '0'
447 	 * c4 digits after '.'
448 	 */
449 	c1 = 0;
450 	c2 = prec + 1;
451 	c3 = 0;
452 	c4 = prec;
453 	switch(chr) {
454 	default:
455 		chr = 'e';
456 		break;
457 	case 'g':
458 		/*
459 		 * decide on 'e' of 'f' style convers
460 		 */
461 		if(e >= -4 && e <= prec) {
462 			c1 = -e;
463 			c4 = prec - e;
464 			chr = 'h';	/* flag for 'f' style */
465 		}
466 		break;
467 	case 'f':
468 		c1 = -e;
469 		if(c1 > prec)
470 			c1 = prec + 1;
471 		c2 += e;
472 		break;
473 	}
474 
475 	/*
476 	 * clean up c1 c2 and c3
477 	 */
478 	if(c1 < 0)
479 		c1 = 0;
480 	if(c2 < 0)
481 		c2 = 0;
482 	if(c2 > NSIGNIF) {
483 		c3 = c2-NSIGNIF;
484 		c2 = NSIGNIF;
485 	}
486 
487 	/*
488 	 * trim trailing zeros for %g
489 	 */
490 	if(!(fl & FmtSharp)
491 	&& (chr == 'g' || chr == 'h')){
492 		if(c4 >= c3){
493 			c4 -= c3;
494 			c3 = 0;
495 		}else{
496 			c3 -= c4;
497 			c4 = 0;
498 		}
499 		while(c4 && c2 > 1 && s1[c2 - 1] == '0'){
500 			c4--;
501 			c2--;
502 		}
503 	}
504 
505 	/*
506 	 * calculate the total length
507 	 */
508 	n = c1 + c2 + c3;
509 	if(sign || (fl & (FmtSign|FmtSpace)))
510 		n++;
511 	if(c4 || (fl & FmtSharp)){
512 		n++;
513 	}
514 	if(chr == 'e' || chr == 'g'){
515 		n += 4;
516 		if(e >= 100)
517 			n++;
518 	}
519 
520 	/*
521 	 * pad to width if right justified
522 	 */
523 	if((fl & (FmtWidth|FmtLeft)) == FmtWidth && n < fmt->width){
524 		if(fl & FmtZero){
525 			c1 += fmt->width - n;
526 		}else{
527 			if(__fmtpad(fmt, fmt->width - n) < 0){
528 				return -1;
529 			}
530 		}
531 	}
532 
533 	/*
534 	 * sign
535 	 */
536 	d = 0;
537 	if(sign)
538 		d = '-';
539 	else if(fl & FmtSign)
540 		d = '+';
541 	else if(fl & FmtSpace)
542 		d = ' ';
543 	if(d && fmtrune(fmt, d) < 0){
544 		return -1;
545 	}
546 
547 	/*
548 	 * copy digits
549 	 */
550 	c4 = c1 + c2 + c3 - c4;
551 	if(c1 > 0){
552 		if(fmtzdotpad(fmt, c1, c4) < 0){
553 			return -1;
554 		}
555 		c4 -= c1;
556 	}
557 	d = 0;
558 	if(c4 >= 0 && c4 < c2){
559 		if(__fmtcpy(fmt, s1, c4, c4) < 0 || fmtrune(fmt, '.') < 0)
560 			return -1;
561 		d = c4;
562 		c2 -= c4;
563 		c4 = -1;
564 	}
565 	if(__fmtcpy(fmt, (const void*)(s1 + d), c2, c2) < 0){
566 		return -1;
567 	}
568 	c4 -= c2;
569 	if(c3 > 0){
570 		if(fmtzdotpad(fmt, c3, c4) < 0){
571 			return -1;
572 		}
573 		c4 -= c3;
574 	}
575 
576 	/*
577 	 * strip trailing '0' on g conv
578 	 */
579 	if((fl & FmtSharp) && c4 == 0 && fmtrune(fmt, '.') < 0){
580 		return -1;
581 	}
582 	if(chr == 'e' || chr == 'g') {
583 		d = 0;
584 		if(ucase)
585 			s1[d++] = 'E';
586 		else
587 			s1[d++] = 'e';
588 		c1 = e;
589 		if(c1 < 0) {
590 			s1[d++] = '-';
591 			c1 = -c1;
592 		} else
593 			s1[d++] = '+';
594 		if(c1 >= 100) {
595 			s1[d++] = c1/100 + '0';
596 			c1 = c1%100;
597 		}
598 		s1[d++] = c1/10 + '0';
599 		s1[d++] = c1%10 + '0';
600 		if(__fmtcpy(fmt, s1, d, d) < 0){
601 			return -1;
602 		}
603 	}
604 	if((fl & (FmtWidth|FmtLeft)) == (FmtWidth|FmtLeft) && n < fmt->width){
605 		if(__fmtpad(fmt, fmt->width - n) < 0){
606 			return -1;
607 		}
608 	}
609 	return 0;
610 }