xref: /openbmc/u-boot/lib/vsprintf.c (revision 365475e6)
1 /*
2  *  linux/lib/vsprintf.c
3  *
4  *  Copyright (C) 1991, 1992  Linus Torvalds
5  */
6 
7 /* vsprintf.c -- Lars Wirzenius & Linus Torvalds. */
8 /*
9  * Wirzenius wrote this portably, Torvalds fucked it up :-)
10  *
11  * from hush: simple_itoa() was lifted from boa-0.93.15
12  */
13 
14 #include <stdarg.h>
15 #include <linux/types.h>
16 #include <linux/string.h>
17 #include <linux/ctype.h>
18 #include <errno.h>
19 
20 #include <common.h>
21 #if !defined(CONFIG_PANIC_HANG)
22 #include <command.h>
23 #endif
24 
25 #include <div64.h>
26 #define noinline __attribute__((noinline))
27 
28 /* some reluctance to put this into a new limits.h, so it is here */
29 #define INT_MAX		((int)(~0U>>1))
30 
31 static const char hex_asc[] = "0123456789abcdef";
32 #define hex_asc_lo(x)   hex_asc[((x) & 0x0f)]
33 #define hex_asc_hi(x)   hex_asc[((x) & 0xf0) >> 4]
34 
35 static inline char *pack_hex_byte(char *buf, u8 byte)
36 {
37 	*buf++ = hex_asc_hi(byte);
38 	*buf++ = hex_asc_lo(byte);
39 	return buf;
40 }
41 
42 unsigned long simple_strtoul(const char *cp, char **endp,
43 				unsigned int base)
44 {
45 	unsigned long result = 0;
46 	unsigned long value;
47 
48 	if (*cp == '0') {
49 		cp++;
50 		if ((*cp == 'x') && isxdigit(cp[1])) {
51 			base = 16;
52 			cp++;
53 		}
54 
55 		if (!base)
56 			base = 8;
57 	}
58 
59 	if (!base)
60 		base = 10;
61 
62 	while (isxdigit(*cp) && (value = isdigit(*cp) ? *cp-'0' : (islower(*cp)
63 	    ? toupper(*cp) : *cp)-'A'+10) < base) {
64 		result = result*base + value;
65 		cp++;
66 	}
67 
68 	if (endp)
69 		*endp = (char *)cp;
70 
71 	return result;
72 }
73 
74 int strict_strtoul(const char *cp, unsigned int base, unsigned long *res)
75 {
76 	char *tail;
77 	unsigned long val;
78 	size_t len;
79 
80 	*res = 0;
81 	len = strlen(cp);
82 	if (len == 0)
83 		return -EINVAL;
84 
85 	val = simple_strtoul(cp, &tail, base);
86 	if (tail == cp)
87 		return -EINVAL;
88 
89 	if ((*tail == '\0') ||
90 		((len == (size_t)(tail - cp) + 1) && (*tail == '\n'))) {
91 		*res = val;
92 		return 0;
93 	}
94 
95 	return -EINVAL;
96 }
97 
98 long simple_strtol(const char *cp, char **endp, unsigned int base)
99 {
100 	if (*cp == '-')
101 		return -simple_strtoul(cp + 1, endp, base);
102 
103 	return simple_strtoul(cp, endp, base);
104 }
105 
106 unsigned long ustrtoul(const char *cp, char **endp, unsigned int base)
107 {
108 	unsigned long result = simple_strtoul(cp, endp, base);
109 	switch (**endp) {
110 	case 'G':
111 		result *= 1024;
112 		/* fall through */
113 	case 'M':
114 		result *= 1024;
115 		/* fall through */
116 	case 'K':
117 	case 'k':
118 		result *= 1024;
119 		if ((*endp)[1] == 'i') {
120 			if ((*endp)[2] == 'B')
121 				(*endp) += 3;
122 			else
123 				(*endp) += 2;
124 		}
125 	}
126 	return result;
127 }
128 
129 unsigned long long ustrtoull(const char *cp, char **endp, unsigned int base)
130 {
131 	unsigned long long result = simple_strtoull(cp, endp, base);
132 	switch (**endp) {
133 	case 'G':
134 		result *= 1024;
135 		/* fall through */
136 	case 'M':
137 		result *= 1024;
138 		/* fall through */
139 	case 'K':
140 	case 'k':
141 		result *= 1024;
142 		if ((*endp)[1] == 'i') {
143 			if ((*endp)[2] == 'B')
144 				(*endp) += 3;
145 			else
146 				(*endp) += 2;
147 		}
148 	}
149 	return result;
150 }
151 
152 unsigned long long simple_strtoull(const char *cp, char **endp,
153 					unsigned int base)
154 {
155 	unsigned long long result = 0, value;
156 
157 	if (*cp == '0') {
158 		cp++;
159 		if ((*cp == 'x') && isxdigit(cp[1])) {
160 			base = 16;
161 			cp++;
162 		}
163 
164 		if (!base)
165 			base = 8;
166 	}
167 
168 	if (!base)
169 		base = 10;
170 
171 	while (isxdigit(*cp) && (value = isdigit(*cp) ? *cp - '0'
172 		: (islower(*cp) ? toupper(*cp) : *cp) - 'A' + 10) < base) {
173 		result = result * base + value;
174 		cp++;
175 	}
176 
177 	if (endp)
178 		*endp = (char *) cp;
179 
180 	return result;
181 }
182 
183 /* we use this so that we can do without the ctype library */
184 #define is_digit(c)	((c) >= '0' && (c) <= '9')
185 
186 static int skip_atoi(const char **s)
187 {
188 	int i = 0;
189 
190 	while (is_digit(**s))
191 		i = i * 10 + *((*s)++) - '0';
192 
193 	return i;
194 }
195 
196 /* Decimal conversion is by far the most typical, and is used
197  * for /proc and /sys data. This directly impacts e.g. top performance
198  * with many processes running. We optimize it for speed
199  * using code from
200  * http://www.cs.uiowa.edu/~jones/bcd/decimal.html
201  * (with permission from the author, Douglas W. Jones). */
202 
203 /* Formats correctly any integer in [0,99999].
204  * Outputs from one to five digits depending on input.
205  * On i386 gcc 4.1.2 -O2: ~250 bytes of code. */
206 static char *put_dec_trunc(char *buf, unsigned q)
207 {
208 	unsigned d3, d2, d1, d0;
209 	d1 = (q>>4) & 0xf;
210 	d2 = (q>>8) & 0xf;
211 	d3 = (q>>12);
212 
213 	d0 = 6*(d3 + d2 + d1) + (q & 0xf);
214 	q = (d0 * 0xcd) >> 11;
215 	d0 = d0 - 10*q;
216 	*buf++ = d0 + '0'; /* least significant digit */
217 	d1 = q + 9*d3 + 5*d2 + d1;
218 	if (d1 != 0) {
219 		q = (d1 * 0xcd) >> 11;
220 		d1 = d1 - 10*q;
221 		*buf++ = d1 + '0'; /* next digit */
222 
223 		d2 = q + 2*d2;
224 		if ((d2 != 0) || (d3 != 0)) {
225 			q = (d2 * 0xd) >> 7;
226 			d2 = d2 - 10*q;
227 			*buf++ = d2 + '0'; /* next digit */
228 
229 			d3 = q + 4*d3;
230 			if (d3 != 0) {
231 				q = (d3 * 0xcd) >> 11;
232 				d3 = d3 - 10*q;
233 				*buf++ = d3 + '0';  /* next digit */
234 				if (q != 0)
235 					*buf++ = q + '0'; /* most sign. digit */
236 			}
237 		}
238 	}
239 	return buf;
240 }
241 /* Same with if's removed. Always emits five digits */
242 static char *put_dec_full(char *buf, unsigned q)
243 {
244 	/* BTW, if q is in [0,9999], 8-bit ints will be enough, */
245 	/* but anyway, gcc produces better code with full-sized ints */
246 	unsigned d3, d2, d1, d0;
247 	d1 = (q>>4) & 0xf;
248 	d2 = (q>>8) & 0xf;
249 	d3 = (q>>12);
250 
251 	/*
252 	 * Possible ways to approx. divide by 10
253 	 * gcc -O2 replaces multiply with shifts and adds
254 	 * (x * 0xcd) >> 11: 11001101 - shorter code than * 0x67 (on i386)
255 	 * (x * 0x67) >> 10:  1100111
256 	 * (x * 0x34) >> 9:    110100 - same
257 	 * (x * 0x1a) >> 8:     11010 - same
258 	 * (x * 0x0d) >> 7:      1101 - same, shortest code (on i386)
259 	 */
260 
261 	d0 = 6*(d3 + d2 + d1) + (q & 0xf);
262 	q = (d0 * 0xcd) >> 11;
263 	d0 = d0 - 10*q;
264 	*buf++ = d0 + '0';
265 	d1 = q + 9*d3 + 5*d2 + d1;
266 		q = (d1 * 0xcd) >> 11;
267 		d1 = d1 - 10*q;
268 		*buf++ = d1 + '0';
269 
270 		d2 = q + 2*d2;
271 			q = (d2 * 0xd) >> 7;
272 			d2 = d2 - 10*q;
273 			*buf++ = d2 + '0';
274 
275 			d3 = q + 4*d3;
276 				q = (d3 * 0xcd) >> 11; /* - shorter code */
277 				/* q = (d3 * 0x67) >> 10; - would also work */
278 				d3 = d3 - 10*q;
279 				*buf++ = d3 + '0';
280 					*buf++ = q + '0';
281 	return buf;
282 }
283 /* No inlining helps gcc to use registers better */
284 static noinline char *put_dec(char *buf, u64 num)
285 {
286 	while (1) {
287 		unsigned rem;
288 		if (num < 100000)
289 			return put_dec_trunc(buf, num);
290 		rem = do_div(num, 100000);
291 		buf = put_dec_full(buf, rem);
292 	}
293 }
294 
295 #define ZEROPAD	1		/* pad with zero */
296 #define SIGN	2		/* unsigned/signed long */
297 #define PLUS	4		/* show plus */
298 #define SPACE	8		/* space if plus */
299 #define LEFT	16		/* left justified */
300 #define SMALL	32		/* Must be 32 == 0x20 */
301 #define SPECIAL	64		/* 0x */
302 
303 #ifdef CONFIG_SYS_VSNPRINTF
304 /*
305  * Macro to add a new character to our output string, but only if it will
306  * fit. The macro moves to the next character position in the output string.
307  */
308 #define ADDCH(str, ch) do { \
309 	if ((str) < end) \
310 		*(str) = (ch); \
311 	++str; \
312 	} while (0)
313 #else
314 #define ADDCH(str, ch)	(*(str)++ = (ch))
315 #endif
316 
317 static char *number(char *buf, char *end, u64 num,
318 		int base, int size, int precision, int type)
319 {
320 	/* we are called with base 8, 10 or 16, only, thus don't need "G..."  */
321 	static const char digits[16] = "0123456789ABCDEF";
322 
323 	char tmp[66];
324 	char sign;
325 	char locase;
326 	int need_pfx = ((type & SPECIAL) && base != 10);
327 	int i;
328 
329 	/* locase = 0 or 0x20. ORing digits or letters with 'locase'
330 	 * produces same digits or (maybe lowercased) letters */
331 	locase = (type & SMALL);
332 	if (type & LEFT)
333 		type &= ~ZEROPAD;
334 	sign = 0;
335 	if (type & SIGN) {
336 		if ((s64) num < 0) {
337 			sign = '-';
338 			num = -(s64) num;
339 			size--;
340 		} else if (type & PLUS) {
341 			sign = '+';
342 			size--;
343 		} else if (type & SPACE) {
344 			sign = ' ';
345 			size--;
346 		}
347 	}
348 	if (need_pfx) {
349 		size--;
350 		if (base == 16)
351 			size--;
352 	}
353 
354 	/* generate full string in tmp[], in reverse order */
355 	i = 0;
356 	if (num == 0)
357 		tmp[i++] = '0';
358 	/* Generic code, for any base:
359 	else do {
360 		tmp[i++] = (digits[do_div(num,base)] | locase);
361 	} while (num != 0);
362 	*/
363 	else if (base != 10) { /* 8 or 16 */
364 		int mask = base - 1;
365 		int shift = 3;
366 
367 		if (base == 16)
368 			shift = 4;
369 
370 		do {
371 			tmp[i++] = (digits[((unsigned char)num) & mask]
372 					| locase);
373 			num >>= shift;
374 		} while (num);
375 	} else { /* base 10 */
376 		i = put_dec(tmp, num) - tmp;
377 	}
378 
379 	/* printing 100 using %2d gives "100", not "00" */
380 	if (i > precision)
381 		precision = i;
382 	/* leading space padding */
383 	size -= precision;
384 	if (!(type & (ZEROPAD + LEFT))) {
385 		while (--size >= 0)
386 			ADDCH(buf, ' ');
387 	}
388 	/* sign */
389 	if (sign)
390 		ADDCH(buf, sign);
391 	/* "0x" / "0" prefix */
392 	if (need_pfx) {
393 		ADDCH(buf, '0');
394 		if (base == 16)
395 			ADDCH(buf, 'X' | locase);
396 	}
397 	/* zero or space padding */
398 	if (!(type & LEFT)) {
399 		char c = (type & ZEROPAD) ? '0' : ' ';
400 
401 		while (--size >= 0)
402 			ADDCH(buf, c);
403 	}
404 	/* hmm even more zero padding? */
405 	while (i <= --precision)
406 		ADDCH(buf, '0');
407 	/* actual digits of result */
408 	while (--i >= 0)
409 		ADDCH(buf, tmp[i]);
410 	/* trailing space padding */
411 	while (--size >= 0)
412 		ADDCH(buf, ' ');
413 	return buf;
414 }
415 
416 static char *string(char *buf, char *end, char *s, int field_width,
417 		int precision, int flags)
418 {
419 	int len, i;
420 
421 	if (s == NULL)
422 		s = "<NULL>";
423 
424 	len = strnlen(s, precision);
425 
426 	if (!(flags & LEFT))
427 		while (len < field_width--)
428 			ADDCH(buf, ' ');
429 	for (i = 0; i < len; ++i)
430 		ADDCH(buf, *s++);
431 	while (len < field_width--)
432 		ADDCH(buf, ' ');
433 	return buf;
434 }
435 
436 #ifdef CONFIG_CMD_NET
437 static char *mac_address_string(char *buf, char *end, u8 *addr, int field_width,
438 				int precision, int flags)
439 {
440 	/* (6 * 2 hex digits), 5 colons and trailing zero */
441 	char mac_addr[6 * 3];
442 	char *p = mac_addr;
443 	int i;
444 
445 	for (i = 0; i < 6; i++) {
446 		p = pack_hex_byte(p, addr[i]);
447 		if (!(flags & SPECIAL) && i != 5)
448 			*p++ = ':';
449 	}
450 	*p = '\0';
451 
452 	return string(buf, end, mac_addr, field_width, precision,
453 		      flags & ~SPECIAL);
454 }
455 
456 static char *ip6_addr_string(char *buf, char *end, u8 *addr, int field_width,
457 			 int precision, int flags)
458 {
459 	/* (8 * 4 hex digits), 7 colons and trailing zero */
460 	char ip6_addr[8 * 5];
461 	char *p = ip6_addr;
462 	int i;
463 
464 	for (i = 0; i < 8; i++) {
465 		p = pack_hex_byte(p, addr[2 * i]);
466 		p = pack_hex_byte(p, addr[2 * i + 1]);
467 		if (!(flags & SPECIAL) && i != 7)
468 			*p++ = ':';
469 	}
470 	*p = '\0';
471 
472 	return string(buf, end, ip6_addr, field_width, precision,
473 		      flags & ~SPECIAL);
474 }
475 
476 static char *ip4_addr_string(char *buf, char *end, u8 *addr, int field_width,
477 			 int precision, int flags)
478 {
479 	/* (4 * 3 decimal digits), 3 dots and trailing zero */
480 	char ip4_addr[4 * 4];
481 	char temp[3];	/* hold each IP quad in reverse order */
482 	char *p = ip4_addr;
483 	int i, digits;
484 
485 	for (i = 0; i < 4; i++) {
486 		digits = put_dec_trunc(temp, addr[i]) - temp;
487 		/* reverse the digits in the quad */
488 		while (digits--)
489 			*p++ = temp[digits];
490 		if (i != 3)
491 			*p++ = '.';
492 	}
493 	*p = '\0';
494 
495 	return string(buf, end, ip4_addr, field_width, precision,
496 		      flags & ~SPECIAL);
497 }
498 #endif
499 
500 /*
501  * Show a '%p' thing.  A kernel extension is that the '%p' is followed
502  * by an extra set of alphanumeric characters that are extended format
503  * specifiers.
504  *
505  * Right now we handle:
506  *
507  * - 'M' For a 6-byte MAC address, it prints the address in the
508  *       usual colon-separated hex notation
509  * - 'I' [46] for IPv4/IPv6 addresses printed in the usual way (dot-separated
510  *       decimal for v4 and colon separated network-order 16 bit hex for v6)
511  * - 'i' [46] for 'raw' IPv4/IPv6 addresses, IPv6 omits the colons, IPv4 is
512  *       currently the same
513  *
514  * Note: The difference between 'S' and 'F' is that on ia64 and ppc64
515  * function pointers are really function descriptors, which contain a
516  * pointer to the real address.
517  */
518 static char *pointer(const char *fmt, char *buf, char *end, void *ptr,
519 		int field_width, int precision, int flags)
520 {
521 	/*
522 	 * Being a boot loader, we explicitly allow pointers to
523 	 * (physical) address null.
524 	 */
525 #if 0
526 	if (!ptr)
527 		return string(buf, end, "(null)", field_width, precision,
528 			      flags);
529 #endif
530 
531 #ifdef CONFIG_CMD_NET
532 	switch (*fmt) {
533 	case 'm':
534 		flags |= SPECIAL;
535 		/* Fallthrough */
536 	case 'M':
537 		return mac_address_string(buf, end, ptr, field_width,
538 					  precision, flags);
539 	case 'i':
540 		flags |= SPECIAL;
541 		/* Fallthrough */
542 	case 'I':
543 		if (fmt[1] == '6')
544 			return ip6_addr_string(buf, end, ptr, field_width,
545 					       precision, flags);
546 		if (fmt[1] == '4')
547 			return ip4_addr_string(buf, end, ptr, field_width,
548 					       precision, flags);
549 		flags &= ~SPECIAL;
550 		break;
551 	}
552 #endif
553 	flags |= SMALL;
554 	if (field_width == -1) {
555 		field_width = 2*sizeof(void *);
556 		flags |= ZEROPAD;
557 	}
558 	return number(buf, end, (unsigned long)ptr, 16, field_width,
559 		      precision, flags);
560 }
561 
562 static int vsnprintf_internal(char *buf, size_t size, const char *fmt,
563 			      va_list args)
564 {
565 	u64 num;
566 	int base;
567 	char *str;
568 
569 	int flags;		/* flags to number() */
570 
571 	int field_width;	/* width of output field */
572 	int precision;		/* min. # of digits for integers; max
573 				   number of chars for from string */
574 	int qualifier;		/* 'h', 'l', or 'L' for integer fields */
575 				/* 'z' support added 23/7/1999 S.H.    */
576 				/* 'z' changed to 'Z' --davidm 1/25/99 */
577 				/* 't' added for ptrdiff_t */
578 	char *end = buf + size;
579 
580 #ifdef CONFIG_SYS_VSNPRINTF
581 	/* Make sure end is always >= buf - do we want this in U-Boot? */
582 	if (end < buf) {
583 		end = ((void *)-1);
584 		size = end - buf;
585 	}
586 #endif
587 	str = buf;
588 
589 	for (; *fmt ; ++fmt) {
590 		if (*fmt != '%') {
591 			ADDCH(str, *fmt);
592 			continue;
593 		}
594 
595 		/* process flags */
596 		flags = 0;
597 repeat:
598 			++fmt;		/* this also skips first '%' */
599 			switch (*fmt) {
600 			case '-':
601 				flags |= LEFT;
602 				goto repeat;
603 			case '+':
604 				flags |= PLUS;
605 				goto repeat;
606 			case ' ':
607 				flags |= SPACE;
608 				goto repeat;
609 			case '#':
610 				flags |= SPECIAL;
611 				goto repeat;
612 			case '0':
613 				flags |= ZEROPAD;
614 				goto repeat;
615 			}
616 
617 		/* get field width */
618 		field_width = -1;
619 		if (is_digit(*fmt))
620 			field_width = skip_atoi(&fmt);
621 		else if (*fmt == '*') {
622 			++fmt;
623 			/* it's the next argument */
624 			field_width = va_arg(args, int);
625 			if (field_width < 0) {
626 				field_width = -field_width;
627 				flags |= LEFT;
628 			}
629 		}
630 
631 		/* get the precision */
632 		precision = -1;
633 		if (*fmt == '.') {
634 			++fmt;
635 			if (is_digit(*fmt))
636 				precision = skip_atoi(&fmt);
637 			else if (*fmt == '*') {
638 				++fmt;
639 				/* it's the next argument */
640 				precision = va_arg(args, int);
641 			}
642 			if (precision < 0)
643 				precision = 0;
644 		}
645 
646 		/* get the conversion qualifier */
647 		qualifier = -1;
648 		if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' ||
649 		    *fmt == 'Z' || *fmt == 'z' || *fmt == 't') {
650 			qualifier = *fmt;
651 			++fmt;
652 			if (qualifier == 'l' && *fmt == 'l') {
653 				qualifier = 'L';
654 				++fmt;
655 			}
656 		}
657 
658 		/* default base */
659 		base = 10;
660 
661 		switch (*fmt) {
662 		case 'c':
663 			if (!(flags & LEFT)) {
664 				while (--field_width > 0)
665 					ADDCH(str, ' ');
666 			}
667 			ADDCH(str, (unsigned char) va_arg(args, int));
668 			while (--field_width > 0)
669 				ADDCH(str, ' ');
670 			continue;
671 
672 		case 's':
673 			str = string(str, end, va_arg(args, char *),
674 				     field_width, precision, flags);
675 			continue;
676 
677 		case 'p':
678 			str = pointer(fmt + 1, str, end,
679 					va_arg(args, void *),
680 					field_width, precision, flags);
681 			/* Skip all alphanumeric pointer suffixes */
682 			while (isalnum(fmt[1]))
683 				fmt++;
684 			continue;
685 
686 		case 'n':
687 			if (qualifier == 'l') {
688 				long *ip = va_arg(args, long *);
689 				*ip = (str - buf);
690 			} else {
691 				int *ip = va_arg(args, int *);
692 				*ip = (str - buf);
693 			}
694 			continue;
695 
696 		case '%':
697 			ADDCH(str, '%');
698 			continue;
699 
700 		/* integer number formats - set up the flags and "break" */
701 		case 'o':
702 			base = 8;
703 			break;
704 
705 		case 'x':
706 			flags |= SMALL;
707 		case 'X':
708 			base = 16;
709 			break;
710 
711 		case 'd':
712 		case 'i':
713 			flags |= SIGN;
714 		case 'u':
715 			break;
716 
717 		default:
718 			ADDCH(str, '%');
719 			if (*fmt)
720 				ADDCH(str, *fmt);
721 			else
722 				--fmt;
723 			continue;
724 		}
725 		if (qualifier == 'L')  /* "quad" for 64 bit variables */
726 			num = va_arg(args, unsigned long long);
727 		else if (qualifier == 'l') {
728 			num = va_arg(args, unsigned long);
729 			if (flags & SIGN)
730 				num = (signed long) num;
731 		} else if (qualifier == 'Z' || qualifier == 'z') {
732 			num = va_arg(args, size_t);
733 		} else if (qualifier == 't') {
734 			num = va_arg(args, ptrdiff_t);
735 		} else if (qualifier == 'h') {
736 			num = (unsigned short) va_arg(args, int);
737 			if (flags & SIGN)
738 				num = (signed short) num;
739 		} else {
740 			num = va_arg(args, unsigned int);
741 			if (flags & SIGN)
742 				num = (signed int) num;
743 		}
744 		str = number(str, end, num, base, field_width, precision,
745 			     flags);
746 	}
747 
748 #ifdef CONFIG_SYS_VSNPRINTF
749 	if (size > 0) {
750 		ADDCH(str, '\0');
751 		if (str > end)
752 			end[-1] = '\0';
753 		--str;
754 	}
755 #else
756 	*str = '\0';
757 #endif
758 	/* the trailing null byte doesn't count towards the total */
759 	return str - buf;
760 }
761 
762 #ifdef CONFIG_SYS_VSNPRINTF
763 int vsnprintf(char *buf, size_t size, const char *fmt,
764 			      va_list args)
765 {
766 	return vsnprintf_internal(buf, size, fmt, args);
767 }
768 
769 int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
770 {
771 	int i;
772 
773 	i = vsnprintf(buf, size, fmt, args);
774 
775 	if (likely(i < size))
776 		return i;
777 	if (size != 0)
778 		return size - 1;
779 	return 0;
780 }
781 
782 int snprintf(char *buf, size_t size, const char *fmt, ...)
783 {
784 	va_list args;
785 	int i;
786 
787 	va_start(args, fmt);
788 	i = vsnprintf(buf, size, fmt, args);
789 	va_end(args);
790 
791 	return i;
792 }
793 
794 int scnprintf(char *buf, size_t size, const char *fmt, ...)
795 {
796 	va_list args;
797 	int i;
798 
799 	va_start(args, fmt);
800 	i = vscnprintf(buf, size, fmt, args);
801 	va_end(args);
802 
803 	return i;
804 }
805 #endif /* CONFIG_SYS_VSNPRINT */
806 
807 /**
808  * Format a string and place it in a buffer (va_list version)
809  *
810  * @param buf	The buffer to place the result into
811  * @param fmt	The format string to use
812  * @param args	Arguments for the format string
813  *
814  * The function returns the number of characters written
815  * into @buf. Use vsnprintf() or vscnprintf() in order to avoid
816  * buffer overflows.
817  *
818  * If you're not already dealing with a va_list consider using sprintf().
819  */
820 int vsprintf(char *buf, const char *fmt, va_list args)
821 {
822 	return vsnprintf_internal(buf, INT_MAX, fmt, args);
823 }
824 
825 int sprintf(char *buf, const char *fmt, ...)
826 {
827 	va_list args;
828 	int i;
829 
830 	va_start(args, fmt);
831 	i = vsprintf(buf, fmt, args);
832 	va_end(args);
833 	return i;
834 }
835 
836 void panic(const char *fmt, ...)
837 {
838 	va_list args;
839 	va_start(args, fmt);
840 	vprintf(fmt, args);
841 	putc('\n');
842 	va_end(args);
843 #if defined(CONFIG_PANIC_HANG)
844 	hang();
845 #else
846 	udelay(100000);	/* allow messages to go out */
847 	do_reset(NULL, 0, 0, NULL);
848 #endif
849 	while (1)
850 		;
851 }
852 
853 void __assert_fail(const char *assertion, const char *file, unsigned line,
854 		   const char *function)
855 {
856 	/* This will not return */
857 	panic("%s:%u: %s: Assertion `%s' failed.", file, line, function,
858 	      assertion);
859 }
860 
861 char *simple_itoa(ulong i)
862 {
863 	/* 21 digits plus null terminator, good for 64-bit or smaller ints */
864 	static char local[22];
865 	char *p = &local[21];
866 
867 	*p-- = '\0';
868 	do {
869 		*p-- = '0' + i % 10;
870 		i /= 10;
871 	} while (i > 0);
872 	return p + 1;
873 }
874 
875 /* We don't seem to have %'d in U-Boot */
876 void print_grouped_ull(unsigned long long int_val, int digits)
877 {
878 	char str[21], *s;
879 	int grab = 3;
880 
881 	digits = (digits + 2) / 3;
882 	sprintf(str, "%*llu", digits * 3, int_val);
883 	for (s = str; *s; s += grab) {
884 		if (s != str)
885 			putc(s[-1] != ' ' ? ',' : ' ');
886 		printf("%.*s", grab, s);
887 		grab = 3;
888 	}
889 }
890