1 /* Copyright (c) 2002-2006 Lucent Technologies; see LICENSE */
2 /* Copyright (c) 2004 Google Inc.; see LICENSE */
3 
4 #include <stdarg.h>
5 #include <string.h>
6 #include "plan9.h"
7 #include "fmt.h"
8 #include "fmtdef.h"
9 
10 /* format the output into f->to and return the number of characters fmted  */
11 int
12 dofmt(Fmt *f, char *fmt)
13 {
14 	Rune rune, *rt, *rs;
15 	int r;
16 	char *t, *s;
17 	int n, nfmt;
18 
19 	nfmt = f->nfmt;
20 	for(;;){
21 		if(f->runes){
22 			rt = (Rune*)f->to;
23 			rs = (Rune*)f->stop;
24 			while((r = *(uchar*)fmt) && r != '%'){
25 				if(r < Runeself)
26 					fmt++;
27 				else{
28 					fmt += chartorune(&rune, fmt);
29 					r = rune;
30 				}
31 				FMTRCHAR(f, rt, rs, r);
32 			}
33 			fmt++;
34 			f->nfmt += rt - (Rune *)f->to;
35 			f->to = rt;
36 			if(!r)
37 				return f->nfmt - nfmt;
38 			f->stop = rs;
39 		}else{
40 			t = (char*)f->to;
41 			s = (char*)f->stop;
42 			while((r = *(uchar*)fmt) && r != '%'){
43 				if(r < Runeself){
44 					FMTCHAR(f, t, s, r);
45 					fmt++;
46 				}else{
47 					n = chartorune(&rune, fmt);
48 					if(t + n > s){
49 						t = (char*)__fmtflush(f, t, n);
50 						if(t != nil)
51 							s = (char*)f->stop;
52 						else
53 							return -1;
54 					}
55 					while(n--)
56 						*t++ = *fmt++;
57 				}
58 			}
59 			fmt++;
60 			f->nfmt += t - (char *)f->to;
61 			f->to = t;
62 			if(!r)
63 				return f->nfmt - nfmt;
64 			f->stop = s;
65 		}
66 
67 		fmt = (char*)__fmtdispatch(f, fmt, 0);
68 		if(fmt == nil)
69 			return -1;
70 	}
71 }
72 
73 void *
74 __fmtflush(Fmt *f, void *t, int len)
75 {
76 	if(f->runes)
77 		f->nfmt += (Rune*)t - (Rune*)f->to;
78 	else
79 		f->nfmt += (char*)t - (char *)f->to;
80 	f->to = t;
81 	if(f->flush == 0 || (*f->flush)(f) == 0 || (char*)f->to + len > (char*)f->stop){
82 		f->stop = f->to;
83 		return nil;
84 	}
85 	return f->to;
86 }
87 
88 /*
89  * put a formatted block of memory sz bytes long of n runes into the output buffer,
90  * left/right justified in a field of at least f->width characters (if FmtWidth is set)
91  */
92 int
93 __fmtpad(Fmt *f, int n)
94 {
95 	char *t, *s;
96 	int i;
97 
98 	t = (char*)f->to;
99 	s = (char*)f->stop;
100 	for(i = 0; i < n; i++)
101 		FMTCHAR(f, t, s, ' ');
102 	f->nfmt += t - (char *)f->to;
103 	f->to = t;
104 	return 0;
105 }
106 
107 int
108 __rfmtpad(Fmt *f, int n)
109 {
110 	Rune *t, *s;
111 	int i;
112 
113 	t = (Rune*)f->to;
114 	s = (Rune*)f->stop;
115 	for(i = 0; i < n; i++)
116 		FMTRCHAR(f, t, s, ' ');
117 	f->nfmt += t - (Rune *)f->to;
118 	f->to = t;
119 	return 0;
120 }
121 
122 int
123 __fmtcpy(Fmt *f, const void *vm, int n, int sz)
124 {
125 	Rune *rt, *rs, r;
126 	char *t, *s, *m, *me;
127 	ulong fl;
128 	int nc, w;
129 
130 	m = (char*)vm;
131 	me = m + sz;
132 	fl = f->flags;
133 	w = 0;
134 	if(fl & FmtWidth)
135 		w = f->width;
136 	if((fl & FmtPrec) && n > f->prec)
137 		n = f->prec;
138 	if(f->runes){
139 		if(!(fl & FmtLeft) && __rfmtpad(f, w - n) < 0)
140 			return -1;
141 		rt = (Rune*)f->to;
142 		rs = (Rune*)f->stop;
143 		for(nc = n; nc > 0; nc--){
144 			r = *(uchar*)m;
145 			if(r < Runeself)
146 				m++;
147 			else if((me - m) >= UTFmax || fullrune(m, me-m))
148 				m += chartorune(&r, m);
149 			else
150 				break;
151 			FMTRCHAR(f, rt, rs, r);
152 		}
153 		f->nfmt += rt - (Rune *)f->to;
154 		f->to = rt;
155 		if(fl & FmtLeft && __rfmtpad(f, w - n) < 0)
156 			return -1;
157 	}else{
158 		if(!(fl & FmtLeft) && __fmtpad(f, w - n) < 0)
159 			return -1;
160 		t = (char*)f->to;
161 		s = (char*)f->stop;
162 		for(nc = n; nc > 0; nc--){
163 			r = *(uchar*)m;
164 			if(r < Runeself)
165 				m++;
166 			else if((me - m) >= UTFmax || fullrune(m, me-m))
167 				m += chartorune(&r, m);
168 			else
169 				break;
170 			FMTRUNE(f, t, s, r);
171 		}
172 		f->nfmt += t - (char *)f->to;
173 		f->to = t;
174 		if(fl & FmtLeft && __fmtpad(f, w - n) < 0)
175 			return -1;
176 	}
177 	return 0;
178 }
179 
180 int
181 __fmtrcpy(Fmt *f, const void *vm, int n)
182 {
183 	Rune r, *m, *me, *rt, *rs;
184 	char *t, *s;
185 	ulong fl;
186 	int w;
187 
188 	m = (Rune*)vm;
189 	fl = f->flags;
190 	w = 0;
191 	if(fl & FmtWidth)
192 		w = f->width;
193 	if((fl & FmtPrec) && n > f->prec)
194 		n = f->prec;
195 	if(f->runes){
196 		if(!(fl & FmtLeft) && __rfmtpad(f, w - n) < 0)
197 			return -1;
198 		rt = (Rune*)f->to;
199 		rs = (Rune*)f->stop;
200 		for(me = m + n; m < me; m++)
201 			FMTRCHAR(f, rt, rs, *m);
202 		f->nfmt += rt - (Rune *)f->to;
203 		f->to = rt;
204 		if(fl & FmtLeft && __rfmtpad(f, w - n) < 0)
205 			return -1;
206 	}else{
207 		if(!(fl & FmtLeft) && __fmtpad(f, w - n) < 0)
208 			return -1;
209 		t = (char*)f->to;
210 		s = (char*)f->stop;
211 		for(me = m + n; m < me; m++){
212 			r = *m;
213 			FMTRUNE(f, t, s, r);
214 		}
215 		f->nfmt += t - (char *)f->to;
216 		f->to = t;
217 		if(fl & FmtLeft && __fmtpad(f, w - n) < 0)
218 			return -1;
219 	}
220 	return 0;
221 }
222 
223 /* fmt out one character */
224 int
225 __charfmt(Fmt *f)
226 {
227 	char x[1];
228 
229 	x[0] = va_arg(f->args, int);
230 	f->prec = 1;
231 	return __fmtcpy(f, (const char*)x, 1, 1);
232 }
233 
234 /* fmt out one rune */
235 int
236 __runefmt(Fmt *f)
237 {
238 	Rune x[1];
239 
240 	x[0] = va_arg(f->args, int);
241 	return __fmtrcpy(f, (const void*)x, 1);
242 }
243 
244 /* public helper routine: fmt out a null terminated string already in hand */
245 int
246 fmtstrcpy(Fmt *f, char *s)
247 {
248 	int i, j;
249 
250 	if(!s)
251 		return __fmtcpy(f, "<nil>", 5, 5);
252 	/* if precision is specified, make sure we don't wander off the end */
253 	if(f->flags & FmtPrec){
254 #ifdef PLAN9PORT
255 		Rune r;
256 		i = 0;
257 		for(j=0; j<f->prec && s[i]; j++)
258 			i += chartorune(&r, s+i);
259 #else
260 		/* ANSI requires precision in bytes, not Runes */
261 		for(i=0; i<f->prec; i++)
262 			if(s[i] == 0)
263 				break;
264 		j = utfnlen(s, i);	/* won't print partial at end */
265 #endif
266 		return __fmtcpy(f, s, j, i);
267 	}
268 	return __fmtcpy(f, s, utflen(s), strlen(s));
269 }
270 
271 /* fmt out a null terminated utf string */
272 int
273 __strfmt(Fmt *f)
274 {
275 	char *s;
276 
277 	s = va_arg(f->args, char *);
278 	return fmtstrcpy(f, s);
279 }
280 
281 /* public helper routine: fmt out a null terminated rune string already in hand */
282 int
283 fmtrunestrcpy(Fmt *f, Rune *s)
284 {
285 	Rune *e;
286 	int n, p;
287 
288 	if(!s)
289 		return __fmtcpy(f, "<nil>", 5, 5);
290 	/* if precision is specified, make sure we don't wander off the end */
291 	if(f->flags & FmtPrec){
292 		p = f->prec;
293 		for(n = 0; n < p; n++)
294 			if(s[n] == 0)
295 				break;
296 	}else{
297 		for(e = s; *e; e++)
298 			;
299 		n = e - s;
300 	}
301 	return __fmtrcpy(f, s, n);
302 }
303 
304 /* fmt out a null terminated rune string */
305 int
306 __runesfmt(Fmt *f)
307 {
308 	Rune *s;
309 
310 	s = va_arg(f->args, Rune *);
311 	return fmtrunestrcpy(f, s);
312 }
313 
314 /* fmt a % */
315 int
316 __percentfmt(Fmt *f)
317 {
318 	Rune x[1];
319 
320 	x[0] = f->r;
321 	f->prec = 1;
322 	return __fmtrcpy(f, (const void*)x, 1);
323 }
324 
325 /* fmt an integer */
326 int
327 __ifmt(Fmt *f)
328 {
329 	char buf[140], *p, *conv;
330 	/* 140: for 64 bits of binary + 3-byte sep every 4 digits */
331 	uvlong vu;
332 	ulong u;
333 	int neg, base, i, n, fl, w, isv;
334 	int ndig, len, excess, bytelen;
335 	char *grouping;
336 	char *thousands;
337 
338 	neg = 0;
339 	fl = f->flags;
340 	isv = 0;
341 	vu = 0;
342 	u = 0;
343 #ifndef PLAN9PORT
344 	/*
345 	 * Unsigned verbs for ANSI C
346 	 */
347 	switch(f->r){
348 	case 'o':
349 	case 'p':
350 	case 'u':
351 	case 'x':
352 	case 'X':
353 		fl |= FmtUnsigned;
354 		fl &= ~(FmtSign|FmtSpace);
355 		break;
356 	}
357 #endif
358 	if(f->r == 'p'){
359 		u = (ulong)va_arg(f->args, void*);
360 		f->r = 'x';
361 		fl |= FmtUnsigned;
362 	}else if(fl & FmtVLong){
363 		isv = 1;
364 		if(fl & FmtUnsigned)
365 			vu = va_arg(f->args, uvlong);
366 		else
367 			vu = va_arg(f->args, vlong);
368 	}else if(fl & FmtLong){
369 		if(fl & FmtUnsigned)
370 			u = va_arg(f->args, ulong);
371 		else
372 			u = va_arg(f->args, long);
373 	}else if(fl & FmtByte){
374 		if(fl & FmtUnsigned)
375 			u = (uchar)va_arg(f->args, int);
376 		else
377 			u = (char)va_arg(f->args, int);
378 	}else if(fl & FmtShort){
379 		if(fl & FmtUnsigned)
380 			u = (ushort)va_arg(f->args, int);
381 		else
382 			u = (short)va_arg(f->args, int);
383 	}else{
384 		if(fl & FmtUnsigned)
385 			u = va_arg(f->args, uint);
386 		else
387 			u = va_arg(f->args, int);
388 	}
389 	conv = "0123456789abcdef";
390 	grouping = "\4";	/* for hex, octal etc. (undefined by spec but nice) */
391 	thousands = f->thousands;
392 	switch(f->r){
393 	case 'd':
394 	case 'i':
395 	case 'u':
396 		base = 10;
397 		grouping = f->grouping;
398 		break;
399 	case 'X':
400 		conv = "0123456789ABCDEF";
401 		/* fall through */
402 	case 'x':
403 		base = 16;
404 		thousands = ":";
405 		break;
406 	case 'b':
407 		base = 2;
408 		thousands = ":";
409 		break;
410 	case 'o':
411 		base = 8;
412 		break;
413 	default:
414 		return -1;
415 	}
416 	if(!(fl & FmtUnsigned)){
417 		if(isv && (vlong)vu < 0){
418 			vu = -(vlong)vu;
419 			neg = 1;
420 		}else if(!isv && (long)u < 0){
421 			u = -(long)u;
422 			neg = 1;
423 		}
424 	}
425 	p = buf + sizeof buf - 1;
426 	n = 0;	/* in runes */
427 	excess = 0;	/* number of bytes > number runes */
428 	ndig = 0;
429 	len = utflen(thousands);
430 	bytelen = strlen(thousands);
431 	if(isv){
432 		while(vu){
433 			i = vu % base;
434 			vu /= base;
435 			if((fl & FmtComma) && n % 4 == 3){
436 				*p-- = ',';
437 				n++;
438 			}
439 			if((fl & FmtApost) && __needsep(&ndig, &grouping)){
440 				n += len;
441 				excess += bytelen - len;
442 				p -= bytelen;
443 				memmove(p+1, thousands, bytelen);
444 			}
445 			*p-- = conv[i];
446 			n++;
447 		}
448 	}else{
449 		while(u){
450 			i = u % base;
451 			u /= base;
452 			if((fl & FmtComma) && n % 4 == 3){
453 				*p-- = ',';
454 				n++;
455 			}
456 			if((fl & FmtApost) && __needsep(&ndig, &grouping)){
457 				n += len;
458 				excess += bytelen - len;
459 				p -= bytelen;
460 				memmove(p+1, thousands, bytelen);
461 			}
462 			*p-- = conv[i];
463 			n++;
464 		}
465 	}
466 	if(n == 0){
467 		/*
468 		 * "The result of converting a zero value with
469 		 * a precision of zero is no characters."  - ANSI
470 		 *
471 		 * "For o conversion, # increases the precision, if and only if
472 		 * necessary, to force the first digit of the result to be a zero
473 		 * (if the value and precision are both 0, a single 0 is printed)." - ANSI
474 		 */
475 		if(!(fl & FmtPrec) || f->prec != 0 || (f->r == 'o' && (fl & FmtSharp))){
476 			*p-- = '0';
477 			n = 1;
478 			if(fl & FmtApost)
479 				__needsep(&ndig, &grouping);
480 		}
481 
482 		/*
483 		 * Zero values don't get 0x.
484 		 */
485 		if(f->r == 'x' || f->r == 'X')
486 			fl &= ~FmtSharp;
487 	}
488 	for(w = f->prec; n < w && p > buf+3; n++){
489 		if((fl & FmtApost) && __needsep(&ndig, &grouping)){
490 			n += len;
491 			excess += bytelen - len;
492 			p -= bytelen;
493 			memmove(p+1, thousands, bytelen);
494 		}
495 		*p-- = '0';
496 	}
497 	if(neg || (fl & (FmtSign|FmtSpace)))
498 		n++;
499 	if(fl & FmtSharp){
500 		if(base == 16)
501 			n += 2;
502 		else if(base == 8){
503 			if(p[1] == '0')
504 				fl &= ~FmtSharp;
505 			else
506 				n++;
507 		}
508 	}
509 	if((fl & FmtZero) && !(fl & (FmtLeft|FmtPrec))){
510 		w = 0;
511 		if(fl & FmtWidth)
512 			w = f->width;
513 		for(; n < w && p > buf+3; n++){
514 			if((fl & FmtApost) && __needsep(&ndig, &grouping)){
515 				n += len;
516 				excess += bytelen - len;
517 				p -= bytelen;
518 				memmove(p+1, thousands, bytelen);
519 			}
520 			*p-- = '0';
521 		}
522 		f->flags &= ~FmtWidth;
523 	}
524 	if(fl & FmtSharp){
525 		if(base == 16)
526 			*p-- = f->r;
527 		if(base == 16 || base == 8)
528 			*p-- = '0';
529 	}
530 	if(neg)
531 		*p-- = '-';
532 	else if(fl & FmtSign)
533 		*p-- = '+';
534 	else if(fl & FmtSpace)
535 		*p-- = ' ';
536 	f->flags &= ~FmtPrec;
537 	return __fmtcpy(f, p + 1, n, n + excess);
538 }
539 
540 int
541 __countfmt(Fmt *f)
542 {
543 	void *p;
544 	ulong fl;
545 
546 	fl = f->flags;
547 	p = va_arg(f->args, void*);
548 	if(fl & FmtVLong){
549 		*(vlong*)p = f->nfmt;
550 	}else if(fl & FmtLong){
551 		*(long*)p = f->nfmt;
552 	}else if(fl & FmtByte){
553 		*(char*)p = f->nfmt;
554 	}else if(fl & FmtShort){
555 		*(short*)p = f->nfmt;
556 	}else{
557 		*(int*)p = f->nfmt;
558 	}
559 	return 0;
560 }
561 
562 int
563 __flagfmt(Fmt *f)
564 {
565 	switch(f->r){
566 	case ',':
567 		f->flags |= FmtComma;
568 		break;
569 	case '-':
570 		f->flags |= FmtLeft;
571 		break;
572 	case '+':
573 		f->flags |= FmtSign;
574 		break;
575 	case '#':
576 		f->flags |= FmtSharp;
577 		break;
578 	case '\'':
579 		f->flags |= FmtApost;
580 		break;
581 	case ' ':
582 		f->flags |= FmtSpace;
583 		break;
584 	case 'u':
585 		f->flags |= FmtUnsigned;
586 		break;
587 	case 'h':
588 		if(f->flags & FmtShort)
589 			f->flags |= FmtByte;
590 		f->flags |= FmtShort;
591 		break;
592 	case 'L':
593 		f->flags |= FmtLDouble;
594 		break;
595 	case 'l':
596 		if(f->flags & FmtLong)
597 			f->flags |= FmtVLong;
598 		f->flags |= FmtLong;
599 		break;
600 	}
601 	return 1;
602 }
603 
604 /* default error format */
605 int
606 __badfmt(Fmt *f)
607 {
608 	char x[2+UTFmax];
609 	int n;
610 
611 	x[0] = '%';
612 	n = 1 + runetochar(x+1, &f->r);
613 	x[n++] = '%';
614 	f->prec = n;
615 	__fmtcpy(f, (const void*)x, n, n);
616 	return 0;
617 }