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