projects/linux·blob v2.6.26-rc2 · refs

1108 lines · 26.0 KiB

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
12/*
13 * Fri Jul 13 2001 Crutcher Dunnavant <[email protected]>
14 * - changed to provide snprintf and vsnprintf functions
15 * So Feb 1 16:51:32 CET 2004 Juergen Quade <[email protected]>
16 * - scnprintf and vscnprintf
17 */
18
19#include <stdarg.h>
20#include <linux/module.h>
21#include <linux/types.h>
22#include <linux/string.h>
23#include <linux/ctype.h>
24#include <linux/kernel.h>
25
26#include <asm/page.h> /* for PAGE_SIZE */
27#include <asm/div64.h>
28
29/* Works only for digits and letters, but small and fast */
30#define TOLOWER(x) ((x) | 0x20)
31
32/**
33 * simple_strtoul - convert a string to an unsigned long
34 * @cp: The start of the string
35 * @endp: A pointer to the end of the parsed string will be placed here
36 * @base: The number base to use
37 */
38unsigned long simple_strtoul(const char *cp,char **endp,unsigned int base)
39{
40 unsigned long result = 0,value;
41
42 if (!base) {
43 base = 10;
44 if (*cp == '0') {
45 base = 8;
46 cp++;
47 if ((TOLOWER(*cp) == 'x') && isxdigit(cp[1])) {
48 cp++;
49 base = 16;
50 }
51 }
52 } else if (base == 16) {
53 if (cp[0] == '0' && TOLOWER(cp[1]) == 'x')
54 cp += 2;
55 }
56 while (isxdigit(*cp) &&
57 (value = isdigit(*cp) ? *cp-'0' : TOLOWER(*cp)-'a'+10) < base) {
58 result = result*base + value;
59 cp++;
60 }
61 if (endp)
62 *endp = (char *)cp;
63 return result;
64}
65
66EXPORT_SYMBOL(simple_strtoul);
67
68/**
69 * simple_strtol - convert a string to a signed long
70 * @cp: The start of the string
71 * @endp: A pointer to the end of the parsed string will be placed here
72 * @base: The number base to use
73 */
74long simple_strtol(const char *cp,char **endp,unsigned int base)
75{
76 if(*cp=='-')
77 return -simple_strtoul(cp+1,endp,base);
78 return simple_strtoul(cp,endp,base);
79}
80
81EXPORT_SYMBOL(simple_strtol);
82
83/**
84 * simple_strtoull - convert a string to an unsigned long long
85 * @cp: The start of the string
86 * @endp: A pointer to the end of the parsed string will be placed here
87 * @base: The number base to use
88 */
89unsigned long long simple_strtoull(const char *cp,char **endp,unsigned int base)
90{
91 unsigned long long result = 0,value;
92
93 if (!base) {
94 base = 10;
95 if (*cp == '0') {
96 base = 8;
97 cp++;
98 if ((TOLOWER(*cp) == 'x') && isxdigit(cp[1])) {
99 cp++;
100 base = 16;
101 }
102 }
103 } else if (base == 16) {
104 if (cp[0] == '0' && TOLOWER(cp[1]) == 'x')
105 cp += 2;
106 }
107 while (isxdigit(*cp)
108 && (value = isdigit(*cp) ? *cp-'0' : TOLOWER(*cp)-'a'+10) < base) {
109 result = result*base + value;
110 cp++;
111 }
112 if (endp)
113 *endp = (char *)cp;
114 return result;
115}
116
117EXPORT_SYMBOL(simple_strtoull);
118
119/**
120 * simple_strtoll - convert a string to a signed long long
121 * @cp: The start of the string
122 * @endp: A pointer to the end of the parsed string will be placed here
123 * @base: The number base to use
124 */
125long long simple_strtoll(const char *cp,char **endp,unsigned int base)
126{
127 if(*cp=='-')
128 return -simple_strtoull(cp+1,endp,base);
129 return simple_strtoull(cp,endp,base);
130}
131
132
133/**
134 * strict_strtoul - convert a string to an unsigned long strictly
135 * @cp: The string to be converted
136 * @base: The number base to use
137 * @res: The converted result value
138 *
139 * strict_strtoul converts a string to an unsigned long only if the
140 * string is really an unsigned long string, any string containing
141 * any invalid char at the tail will be rejected and -EINVAL is returned,
142 * only a newline char at the tail is acceptible because people generally
143 * change a module parameter in the following way:
144 *
145 * echo 1024 > /sys/module/e1000/parameters/copybreak
146 *
147 * echo will append a newline to the tail.
148 *
149 * It returns 0 if conversion is successful and *res is set to the converted
150 * value, otherwise it returns -EINVAL and *res is set to 0.
151 *
152 * simple_strtoul just ignores the successive invalid characters and
153 * return the converted value of prefix part of the string.
154 */
155int strict_strtoul(const char *cp, unsigned int base, unsigned long *res);
156
157/**
158 * strict_strtol - convert a string to a long strictly
159 * @cp: The string to be converted
160 * @base: The number base to use
161 * @res: The converted result value
162 *
163 * strict_strtol is similiar to strict_strtoul, but it allows the first
164 * character of a string is '-'.
165 *
166 * It returns 0 if conversion is successful and *res is set to the converted
167 * value, otherwise it returns -EINVAL and *res is set to 0.
168 */
169int strict_strtol(const char *cp, unsigned int base, long *res);
170
171/**
172 * strict_strtoull - convert a string to an unsigned long long strictly
173 * @cp: The string to be converted
174 * @base: The number base to use
175 * @res: The converted result value
176 *
177 * strict_strtoull converts a string to an unsigned long long only if the
178 * string is really an unsigned long long string, any string containing
179 * any invalid char at the tail will be rejected and -EINVAL is returned,
180 * only a newline char at the tail is acceptible because people generally
181 * change a module parameter in the following way:
182 *
183 * echo 1024 > /sys/module/e1000/parameters/copybreak
184 *
185 * echo will append a newline to the tail of the string.
186 *
187 * It returns 0 if conversion is successful and *res is set to the converted
188 * value, otherwise it returns -EINVAL and *res is set to 0.
189 *
190 * simple_strtoull just ignores the successive invalid characters and
191 * return the converted value of prefix part of the string.
192 */
193int strict_strtoull(const char *cp, unsigned int base, unsigned long long *res);
194
195/**
196 * strict_strtoll - convert a string to a long long strictly
197 * @cp: The string to be converted
198 * @base: The number base to use
199 * @res: The converted result value
200 *
201 * strict_strtoll is similiar to strict_strtoull, but it allows the first
202 * character of a string is '-'.
203 *
204 * It returns 0 if conversion is successful and *res is set to the converted
205 * value, otherwise it returns -EINVAL and *res is set to 0.
206 */
207int strict_strtoll(const char *cp, unsigned int base, long long *res);
208
209#define define_strict_strtoux(type, valtype) \
210int strict_strtou##type(const char *cp, unsigned int base, valtype *res)\
211{ \
212 char *tail; \
213 valtype val; \
214 size_t len; \
215 \
216 *res = 0; \
217 len = strlen(cp); \
218 if (len == 0) \
219 return -EINVAL; \
220 \
221 val = simple_strtoul(cp, &tail, base); \
222 if ((*tail == '\0') || \
223 ((len == (size_t)(tail - cp) + 1) && (*tail == '\n'))) {\
224 *res = val; \
225 return 0; \
226 } \
227 \
228 return -EINVAL; \
229} \
230
231#define define_strict_strtox(type, valtype) \
232int strict_strto##type(const char *cp, unsigned int base, valtype *res) \
233{ \
234 int ret; \
235 if (*cp == '-') { \
236 ret = strict_strtou##type(cp+1, base, res); \
237 if (!ret) \
238 *res = -(*res); \
239 } else \
240 ret = strict_strtou##type(cp, base, res); \
241 \
242 return ret; \
243} \
244
245define_strict_strtoux(l, unsigned long)
246define_strict_strtox(l, long)
247define_strict_strtoux(ll, unsigned long long)
248define_strict_strtox(ll, long long)
249
250EXPORT_SYMBOL(strict_strtoul);
251EXPORT_SYMBOL(strict_strtol);
252EXPORT_SYMBOL(strict_strtoll);
253EXPORT_SYMBOL(strict_strtoull);
254
255static int skip_atoi(const char **s)
256{
257 int i=0;
258
259 while (isdigit(**s))
260 i = i*10 + *((*s)++) - '0';
261 return i;
262}
263
264/* Decimal conversion is by far the most typical, and is used
265 * for /proc and /sys data. This directly impacts e.g. top performance
266 * with many processes running. We optimize it for speed
267 * using code from
268 * http://www.cs.uiowa.edu/~jones/bcd/decimal.html
269 * (with permission from the author, Douglas W. Jones). */
270
271/* Formats correctly any integer in [0,99999].
272 * Outputs from one to five digits depending on input.
273 * On i386 gcc 4.1.2 -O2: ~250 bytes of code. */
274static char* put_dec_trunc(char *buf, unsigned q)
275{
276 unsigned d3, d2, d1, d0;
277 d1 = (q>>4) & 0xf;
278 d2 = (q>>8) & 0xf;
279 d3 = (q>>12);
280
281 d0 = 6*(d3 + d2 + d1) + (q & 0xf);
282 q = (d0 * 0xcd) >> 11;
283 d0 = d0 - 10*q;
284 *buf++ = d0 + '0'; /* least significant digit */
285 d1 = q + 9*d3 + 5*d2 + d1;
286 if (d1 != 0) {
287 q = (d1 * 0xcd) >> 11;
288 d1 = d1 - 10*q;
289 *buf++ = d1 + '0'; /* next digit */
290
291 d2 = q + 2*d2;
292 if ((d2 != 0) || (d3 != 0)) {
293 q = (d2 * 0xd) >> 7;
294 d2 = d2 - 10*q;
295 *buf++ = d2 + '0'; /* next digit */
296
297 d3 = q + 4*d3;
298 if (d3 != 0) {
299 q = (d3 * 0xcd) >> 11;
300 d3 = d3 - 10*q;
301 *buf++ = d3 + '0'; /* next digit */
302 if (q != 0)
303 *buf++ = q + '0'; /* most sign. digit */
304 }
305 }
306 }
307 return buf;
308}
309/* Same with if's removed. Always emits five digits */
310static char* put_dec_full(char *buf, unsigned q)
311{
312 /* BTW, if q is in [0,9999], 8-bit ints will be enough, */
313 /* but anyway, gcc produces better code with full-sized ints */
314 unsigned d3, d2, d1, d0;
315 d1 = (q>>4) & 0xf;
316 d2 = (q>>8) & 0xf;
317 d3 = (q>>12);
318
319 /* Possible ways to approx. divide by 10 */
320 /* gcc -O2 replaces multiply with shifts and adds */
321 // (x * 0xcd) >> 11: 11001101 - shorter code than * 0x67 (on i386)
322 // (x * 0x67) >> 10: 1100111
323 // (x * 0x34) >> 9: 110100 - same
324 // (x * 0x1a) >> 8: 11010 - same
325 // (x * 0x0d) >> 7: 1101 - same, shortest code (on i386)
326
327 d0 = 6*(d3 + d2 + d1) + (q & 0xf);
328 q = (d0 * 0xcd) >> 11;
329 d0 = d0 - 10*q;
330 *buf++ = d0 + '0';
331 d1 = q + 9*d3 + 5*d2 + d1;
332 q = (d1 * 0xcd) >> 11;
333 d1 = d1 - 10*q;
334 *buf++ = d1 + '0';
335
336 d2 = q + 2*d2;
337 q = (d2 * 0xd) >> 7;
338 d2 = d2 - 10*q;
339 *buf++ = d2 + '0';
340
341 d3 = q + 4*d3;
342 q = (d3 * 0xcd) >> 11; /* - shorter code */
343 /* q = (d3 * 0x67) >> 10; - would also work */
344 d3 = d3 - 10*q;
345 *buf++ = d3 + '0';
346 *buf++ = q + '0';
347 return buf;
348}
349/* No inlining helps gcc to use registers better */
350static noinline char* put_dec(char *buf, unsigned long long num)
351{
352 while (1) {
353 unsigned rem;
354 if (num < 100000)
355 return put_dec_trunc(buf, num);
356 rem = do_div(num, 100000);
357 buf = put_dec_full(buf, rem);
358 }
359}
360
361#define ZEROPAD 1 /* pad with zero */
362#define SIGN 2 /* unsigned/signed long */
363#define PLUS 4 /* show plus */
364#define SPACE 8 /* space if plus */
365#define LEFT 16 /* left justified */
366#define SMALL 32 /* Must be 32 == 0x20 */
367#define SPECIAL 64 /* 0x */
368
369static char *number(char *buf, char *end, unsigned long long num, int base, int size, int precision, int type)
370{
371 /* we are called with base 8, 10 or 16, only, thus don't need "G..." */
372 static const char digits[16] = "0123456789ABCDEF"; /* "GHIJKLMNOPQRSTUVWXYZ"; */
373
374 char tmp[66];
375 char sign;
376 char locase;
377 int need_pfx = ((type & SPECIAL) && base != 10);
378 int i;
379
380 /* locase = 0 or 0x20. ORing digits or letters with 'locase'
381 * produces same digits or (maybe lowercased) letters */
382 locase = (type & SMALL);
383 if (type & LEFT)
384 type &= ~ZEROPAD;
385 sign = 0;
386 if (type & SIGN) {
387 if ((signed long long) num < 0) {
388 sign = '-';
389 num = - (signed long long) num;
390 size--;
391 } else if (type & PLUS) {
392 sign = '+';
393 size--;
394 } else if (type & SPACE) {
395 sign = ' ';
396 size--;
397 }
398 }
399 if (need_pfx) {
400 size--;
401 if (base == 16)
402 size--;
403 }
404
405 /* generate full string in tmp[], in reverse order */
406 i = 0;
407 if (num == 0)
408 tmp[i++] = '0';
409 /* Generic code, for any base:
410 else do {
411 tmp[i++] = (digits[do_div(num,base)] | locase);
412 } while (num != 0);
413 */
414 else if (base != 10) { /* 8 or 16 */
415 int mask = base - 1;
416 int shift = 3;
417 if (base == 16) shift = 4;
418 do {
419 tmp[i++] = (digits[((unsigned char)num) & mask] | locase);
420 num >>= shift;
421 } while (num);
422 } else { /* base 10 */
423 i = put_dec(tmp, num) - tmp;
424 }
425
426 /* printing 100 using %2d gives "100", not "00" */
427 if (i > precision)
428 precision = i;
429 /* leading space padding */
430 size -= precision;
431 if (!(type & (ZEROPAD+LEFT))) {
432 while(--size >= 0) {
433 if (buf < end)
434 *buf = ' ';
435 ++buf;
436 }
437 }
438 /* sign */
439 if (sign) {
440 if (buf < end)
441 *buf = sign;
442 ++buf;
443 }
444 /* "0x" / "0" prefix */
445 if (need_pfx) {
446 if (buf < end)
447 *buf = '0';
448 ++buf;
449 if (base == 16) {
450 if (buf < end)
451 *buf = ('X' | locase);
452 ++buf;
453 }
454 }
455 /* zero or space padding */
456 if (!(type & LEFT)) {
457 char c = (type & ZEROPAD) ? '0' : ' ';
458 while (--size >= 0) {
459 if (buf < end)
460 *buf = c;
461 ++buf;
462 }
463 }
464 /* hmm even more zero padding? */
465 while (i <= --precision) {
466 if (buf < end)
467 *buf = '0';
468 ++buf;
469 }
470 /* actual digits of result */
471 while (--i >= 0) {
472 if (buf < end)
473 *buf = tmp[i];
474 ++buf;
475 }
476 /* trailing space padding */
477 while (--size >= 0) {
478 if (buf < end)
479 *buf = ' ';
480 ++buf;
481 }
482 return buf;
483}
484
485/**
486 * vsnprintf - Format a string and place it in a buffer
487 * @buf: The buffer to place the result into
488 * @size: The size of the buffer, including the trailing null space
489 * @fmt: The format string to use
490 * @args: Arguments for the format string
491 *
492 * The return value is the number of characters which would
493 * be generated for the given input, excluding the trailing
494 * '\0', as per ISO C99. If you want to have the exact
495 * number of characters written into @buf as return value
496 * (not including the trailing '\0'), use vscnprintf(). If the
497 * return is greater than or equal to @size, the resulting
498 * string is truncated.
499 *
500 * Call this function if you are already dealing with a va_list.
501 * You probably want snprintf() instead.
502 */
503int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
504{
505 int len;
506 unsigned long long num;
507 int i, base;
508 char *str, *end, c;
509 const char *s;
510
511 int flags; /* flags to number() */
512
513 int field_width; /* width of output field */
514 int precision; /* min. # of digits for integers; max
515 number of chars for from string */
516 int qualifier; /* 'h', 'l', or 'L' for integer fields */
517 /* 'z' support added 23/7/1999 S.H. */
518 /* 'z' changed to 'Z' --davidm 1/25/99 */
519 /* 't' added for ptrdiff_t */
520
521 /* Reject out-of-range values early. Large positive sizes are
522 used for unknown buffer sizes. */
523 if (unlikely((int) size < 0)) {
524 /* There can be only one.. */
525 static char warn = 1;
526 WARN_ON(warn);
527 warn = 0;
528 return 0;
529 }
530
531 str = buf;
532 end = buf + size;
533
534 /* Make sure end is always >= buf */
535 if (end < buf) {
536 end = ((void *)-1);
537 size = end - buf;
538 }
539
540 for (; *fmt ; ++fmt) {
541 if (*fmt != '%') {
542 if (str < end)
543 *str = *fmt;
544 ++str;
545 continue;
546 }
547
548 /* process flags */
549 flags = 0;
550 repeat:
551 ++fmt; /* this also skips first '%' */
552 switch (*fmt) {
553 case '-': flags |= LEFT; goto repeat;
554 case '+': flags |= PLUS; goto repeat;
555 case ' ': flags |= SPACE; goto repeat;
556 case '#': flags |= SPECIAL; goto repeat;
557 case '0': flags |= ZEROPAD; goto repeat;
558 }
559
560 /* get field width */
561 field_width = -1;
562 if (isdigit(*fmt))
563 field_width = skip_atoi(&fmt);
564 else if (*fmt == '*') {
565 ++fmt;
566 /* it's the next argument */
567 field_width = va_arg(args, int);
568 if (field_width < 0) {
569 field_width = -field_width;
570 flags |= LEFT;
571 }
572 }
573
574 /* get the precision */
575 precision = -1;
576 if (*fmt == '.') {
577 ++fmt;
578 if (isdigit(*fmt))
579 precision = skip_atoi(&fmt);
580 else if (*fmt == '*') {
581 ++fmt;
582 /* it's the next argument */
583 precision = va_arg(args, int);
584 }
585 if (precision < 0)
586 precision = 0;
587 }
588
589 /* get the conversion qualifier */
590 qualifier = -1;
591 if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' ||
592 *fmt =='Z' || *fmt == 'z' || *fmt == 't') {
593 qualifier = *fmt;
594 ++fmt;
595 if (qualifier == 'l' && *fmt == 'l') {
596 qualifier = 'L';
597 ++fmt;
598 }
599 }
600
601 /* default base */
602 base = 10;
603
604 switch (*fmt) {
605 case 'c':
606 if (!(flags & LEFT)) {
607 while (--field_width > 0) {
608 if (str < end)
609 *str = ' ';
610 ++str;
611 }
612 }
613 c = (unsigned char) va_arg(args, int);
614 if (str < end)
615 *str = c;
616 ++str;
617 while (--field_width > 0) {
618 if (str < end)
619 *str = ' ';
620 ++str;
621 }
622 continue;
623
624 case 's':
625 s = va_arg(args, char *);
626 if ((unsigned long)s < PAGE_SIZE)
627 s = "<NULL>";
628
629 len = strnlen(s, precision);
630
631 if (!(flags & LEFT)) {
632 while (len < field_width--) {
633 if (str < end)
634 *str = ' ';
635 ++str;
636 }
637 }
638 for (i = 0; i < len; ++i) {
639 if (str < end)
640 *str = *s;
641 ++str; ++s;
642 }
643 while (len < field_width--) {
644 if (str < end)
645 *str = ' ';
646 ++str;
647 }
648 continue;
649
650 case 'p':
651 flags |= SMALL;
652 if (field_width == -1) {
653 field_width = 2*sizeof(void *);
654 flags |= ZEROPAD;
655 }
656 str = number(str, end,
657 (unsigned long) va_arg(args, void *),
658 16, field_width, precision, flags);
659 continue;
660
661
662 case 'n':
663 /* FIXME:
664 * What does C99 say about the overflow case here? */
665 if (qualifier == 'l') {
666 long * ip = va_arg(args, long *);
667 *ip = (str - buf);
668 } else if (qualifier == 'Z' || qualifier == 'z') {
669 size_t * ip = va_arg(args, size_t *);
670 *ip = (str - buf);
671 } else {
672 int * ip = va_arg(args, int *);
673 *ip = (str - buf);
674 }
675 continue;
676
677 case '%':
678 if (str < end)
679 *str = '%';
680 ++str;
681 continue;
682
683 /* integer number formats - set up the flags and "break" */
684 case 'o':
685 base = 8;
686 break;
687
688 case 'x':
689 flags |= SMALL;
690 case 'X':
691 base = 16;
692 break;
693
694 case 'd':
695 case 'i':
696 flags |= SIGN;
697 case 'u':
698 break;
699
700 default:
701 if (str < end)
702 *str = '%';
703 ++str;
704 if (*fmt) {
705 if (str < end)
706 *str = *fmt;
707 ++str;
708 } else {
709 --fmt;
710 }
711 continue;
712 }
713 if (qualifier == 'L')
714 num = va_arg(args, long long);
715 else if (qualifier == 'l') {
716 num = va_arg(args, unsigned long);
717 if (flags & SIGN)
718 num = (signed long) num;
719 } else if (qualifier == 'Z' || qualifier == 'z') {
720 num = va_arg(args, size_t);
721 } else if (qualifier == 't') {
722 num = va_arg(args, ptrdiff_t);
723 } else if (qualifier == 'h') {
724 num = (unsigned short) va_arg(args, int);
725 if (flags & SIGN)
726 num = (signed short) num;
727 } else {
728 num = va_arg(args, unsigned int);
729 if (flags & SIGN)
730 num = (signed int) num;
731 }
732 str = number(str, end, num, base,
733 field_width, precision, flags);
734 }
735 if (size > 0) {
736 if (str < end)
737 *str = '\0';
738 else
739 end[-1] = '\0';
740 }
741 /* the trailing null byte doesn't count towards the total */
742 return str-buf;
743}
744
745EXPORT_SYMBOL(vsnprintf);
746
747/**
748 * vscnprintf - Format a string and place it in a buffer
749 * @buf: The buffer to place the result into
750 * @size: The size of the buffer, including the trailing null space
751 * @fmt: The format string to use
752 * @args: Arguments for the format string
753 *
754 * The return value is the number of characters which have been written into
755 * the @buf not including the trailing '\0'. If @size is <= 0 the function
756 * returns 0.
757 *
758 * Call this function if you are already dealing with a va_list.
759 * You probably want scnprintf() instead.
760 */
761int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
762{
763 int i;
764
765 i=vsnprintf(buf,size,fmt,args);
766 return (i >= size) ? (size - 1) : i;
767}
768
769EXPORT_SYMBOL(vscnprintf);
770
771/**
772 * snprintf - Format a string and place it in a buffer
773 * @buf: The buffer to place the result into
774 * @size: The size of the buffer, including the trailing null space
775 * @fmt: The format string to use
776 * @...: Arguments for the format string
777 *
778 * The return value is the number of characters which would be
779 * generated for the given input, excluding the trailing null,
780 * as per ISO C99. If the return is greater than or equal to
781 * @size, the resulting string is truncated.
782 */
783int snprintf(char * buf, size_t size, const char *fmt, ...)
784{
785 va_list args;
786 int i;
787
788 va_start(args, fmt);
789 i=vsnprintf(buf,size,fmt,args);
790 va_end(args);
791 return i;
792}
793
794EXPORT_SYMBOL(snprintf);
795
796/**
797 * scnprintf - Format a string and place it in a buffer
798 * @buf: The buffer to place the result into
799 * @size: The size of the buffer, including the trailing null space
800 * @fmt: The format string to use
801 * @...: Arguments for the format string
802 *
803 * The return value is the number of characters written into @buf not including
804 * the trailing '\0'. If @size is <= 0 the function returns 0.
805 */
806
807int scnprintf(char * buf, size_t size, const char *fmt, ...)
808{
809 va_list args;
810 int i;
811
812 va_start(args, fmt);
813 i = vsnprintf(buf, size, fmt, args);
814 va_end(args);
815 return (i >= size) ? (size - 1) : i;
816}
817EXPORT_SYMBOL(scnprintf);
818
819/**
820 * vsprintf - Format a string and place it in a buffer
821 * @buf: The buffer to place the result into
822 * @fmt: The format string to use
823 * @args: Arguments for the format string
824 *
825 * The function returns the number of characters written
826 * into @buf. Use vsnprintf() or vscnprintf() in order to avoid
827 * buffer overflows.
828 *
829 * Call this function if you are already dealing with a va_list.
830 * You probably want sprintf() instead.
831 */
832int vsprintf(char *buf, const char *fmt, va_list args)
833{
834 return vsnprintf(buf, INT_MAX, fmt, args);
835}
836
837EXPORT_SYMBOL(vsprintf);
838
839/**
840 * sprintf - Format a string and place it in a buffer
841 * @buf: The buffer to place the result into
842 * @fmt: The format string to use
843 * @...: Arguments for the format string
844 *
845 * The function returns the number of characters written
846 * into @buf. Use snprintf() or scnprintf() in order to avoid
847 * buffer overflows.
848 */
849int sprintf(char * buf, const char *fmt, ...)
850{
851 va_list args;
852 int i;
853
854 va_start(args, fmt);
855 i=vsnprintf(buf, INT_MAX, fmt, args);
856 va_end(args);
857 return i;
858}
859
860EXPORT_SYMBOL(sprintf);
861
862/**
863 * vsscanf - Unformat a buffer into a list of arguments
864 * @buf: input buffer
865 * @fmt: format of buffer
866 * @args: arguments
867 */
868int vsscanf(const char * buf, const char * fmt, va_list args)
869{
870 const char *str = buf;
871 char *next;
872 char digit;
873 int num = 0;
874 int qualifier;
875 int base;
876 int field_width;
877 int is_sign = 0;
878
879 while(*fmt && *str) {
880 /* skip any white space in format */
881 /* white space in format matchs any amount of
882 * white space, including none, in the input.
883 */
884 if (isspace(*fmt)) {
885 while (isspace(*fmt))
886 ++fmt;
887 while (isspace(*str))
888 ++str;
889 }
890
891 /* anything that is not a conversion must match exactly */
892 if (*fmt != '%' && *fmt) {
893 if (*fmt++ != *str++)
894 break;
895 continue;
896 }
897
898 if (!*fmt)
899 break;
900 ++fmt;
901
902 /* skip this conversion.
903 * advance both strings to next white space
904 */
905 if (*fmt == '*') {
906 while (!isspace(*fmt) && *fmt)
907 fmt++;
908 while (!isspace(*str) && *str)
909 str++;
910 continue;
911 }
912
913 /* get field width */
914 field_width = -1;
915 if (isdigit(*fmt))
916 field_width = skip_atoi(&fmt);
917
918 /* get conversion qualifier */
919 qualifier = -1;
920 if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' ||
921 *fmt == 'Z' || *fmt == 'z') {
922 qualifier = *fmt++;
923 if (unlikely(qualifier == *fmt)) {
924 if (qualifier == 'h') {
925 qualifier = 'H';
926 fmt++;
927 } else if (qualifier == 'l') {
928 qualifier = 'L';
929 fmt++;
930 }
931 }
932 }
933 base = 10;
934 is_sign = 0;
935
936 if (!*fmt || !*str)
937 break;
938
939 switch(*fmt++) {
940 case 'c':
941 {
942 char *s = (char *) va_arg(args,char*);
943 if (field_width == -1)
944 field_width = 1;
945 do {
946 *s++ = *str++;
947 } while (--field_width > 0 && *str);
948 num++;
949 }
950 continue;
951 case 's':
952 {
953 char *s = (char *) va_arg(args, char *);
954 if(field_width == -1)
955 field_width = INT_MAX;
956 /* first, skip leading white space in buffer */
957 while (isspace(*str))
958 str++;
959
960 /* now copy until next white space */
961 while (*str && !isspace(*str) && field_width--) {
962 *s++ = *str++;
963 }
964 *s = '\0';
965 num++;
966 }
967 continue;
968 case 'n':
969 /* return number of characters read so far */
970 {
971 int *i = (int *)va_arg(args,int*);
972 *i = str - buf;
973 }
974 continue;
975 case 'o':
976 base = 8;
977 break;
978 case 'x':
979 case 'X':
980 base = 16;
981 break;
982 case 'i':
983 base = 0;
984 case 'd':
985 is_sign = 1;
986 case 'u':
987 break;
988 case '%':
989 /* looking for '%' in str */
990 if (*str++ != '%')
991 return num;
992 continue;
993 default:
994 /* invalid format; stop here */
995 return num;
996 }
997
998 /* have some sort of integer conversion.
999 * first, skip white space in buffer.
1000 */
1001 while (isspace(*str))
1002 str++;
1003
1004 digit = *str;
1005 if (is_sign && digit == '-')
1006 digit = *(str + 1);
1007
1008 if (!digit
1009 || (base == 16 && !isxdigit(digit))
1010 || (base == 10 && !isdigit(digit))
1011 || (base == 8 && (!isdigit(digit) || digit > '7'))
1012 || (base == 0 && !isdigit(digit)))
1013 break;
1014
1015 switch(qualifier) {
1016 case 'H': /* that's 'hh' in format */
1017 if (is_sign) {
1018 signed char *s = (signed char *) va_arg(args,signed char *);
1019 *s = (signed char) simple_strtol(str,&next,base);
1020 } else {
1021 unsigned char *s = (unsigned char *) va_arg(args, unsigned char *);
1022 *s = (unsigned char) simple_strtoul(str, &next, base);
1023 }
1024 break;
1025 case 'h':
1026 if (is_sign) {
1027 short *s = (short *) va_arg(args,short *);
1028 *s = (short) simple_strtol(str,&next,base);
1029 } else {
1030 unsigned short *s = (unsigned short *) va_arg(args, unsigned short *);
1031 *s = (unsigned short) simple_strtoul(str, &next, base);
1032 }
1033 break;
1034 case 'l':
1035 if (is_sign) {
1036 long *l = (long *) va_arg(args,long *);
1037 *l = simple_strtol(str,&next,base);
1038 } else {
1039 unsigned long *l = (unsigned long*) va_arg(args,unsigned long*);
1040 *l = simple_strtoul(str,&next,base);
1041 }
1042 break;
1043 case 'L':
1044 if (is_sign) {
1045 long long *l = (long long*) va_arg(args,long long *);
1046 *l = simple_strtoll(str,&next,base);
1047 } else {
1048 unsigned long long *l = (unsigned long long*) va_arg(args,unsigned long long*);
1049 *l = simple_strtoull(str,&next,base);
1050 }
1051 break;
1052 case 'Z':
1053 case 'z':
1054 {
1055 size_t *s = (size_t*) va_arg(args,size_t*);
1056 *s = (size_t) simple_strtoul(str,&next,base);
1057 }
1058 break;
1059 default:
1060 if (is_sign) {
1061 int *i = (int *) va_arg(args, int*);
1062 *i = (int) simple_strtol(str,&next,base);
1063 } else {
1064 unsigned int *i = (unsigned int*) va_arg(args, unsigned int*);
1065 *i = (unsigned int) simple_strtoul(str,&next,base);
1066 }
1067 break;
1068 }
1069 num++;
1070
1071 if (!next)
1072 break;
1073 str = next;
1074 }
1075
1076 /*
1077 * Now we've come all the way through so either the input string or the
1078 * format ended. In the former case, there can be a %n at the current
1079 * position in the format that needs to be filled.
1080 */
1081 if (*fmt == '%' && *(fmt + 1) == 'n') {
1082 int *p = (int *)va_arg(args, int *);
1083 *p = str - buf;
1084 }
1085
1086 return num;
1087}
1088
1089EXPORT_SYMBOL(vsscanf);
1090
1091/**
1092 * sscanf - Unformat a buffer into a list of arguments
1093 * @buf: input buffer
1094 * @fmt: formatting of buffer
1095 * @...: resulting arguments
1096 */
1097int sscanf(const char * buf, const char * fmt, ...)
1098{
1099 va_list args;
1100 int i;
1101
1102 va_start(args,fmt);
1103 i = vsscanf(buf,fmt,args);
1104 va_end(args);
1105 return i;
1106}
1107
1108EXPORT_SYMBOL(sscanf);