| /* |
| * Taken from Linux kernel's linux/lib/vsprintf.c |
| * and somewhat simplified. |
| * |
| * Copyright (C) 1991, 1992 Linus Torvalds |
| */ |
| /* vsprintf.c -- Lars Wirzenius & Linus Torvalds. */ |
| /* |
| * Wirzenius wrote this portably, Torvalds fucked it up :-) |
| */ |
| |
| #include "defs.h" |
| |
| #if USE_CUSTOM_PRINTF |
| |
| #include <stdarg.h> |
| #include <limits.h> |
| |
| #ifndef HAVE_FPUTS_UNLOCKED |
| # define fputs_unlocked fputs |
| #endif |
| |
| #define noinline_for_stack /*nothing*/ |
| #define likely(expr) (expr) |
| #define unlikely(expr) (expr) |
| |
| #define do_div(n, d) ({ __typeof(num) t = n % d; n /= d; t; }) |
| |
| #undef isdigit |
| #define isdigit(a) ((unsigned char)((a) - '0') <= 9) |
| |
| static inline |
| int skip_atoi(const char **s) |
| { |
| int i = 0; |
| const char *p = *s; |
| |
| while (isdigit(*p)) |
| i = i*10 + *p++ - '0'; |
| |
| *s = p; |
| return i; |
| } |
| |
| /* Decimal conversion is by far the most typical, and is used |
| * for /proc and /sys data. This directly impacts e.g. top performance |
| * with many processes running. We optimize it for speed |
| * using ideas described at <http://www.cs.uiowa.edu/~jones/bcd/divide.html> |
| * (with permission from the author, Douglas W. Jones). |
| */ |
| |
| #if LONG_MAX != 0x7fffffffUL || LLONG_MAX != 0x7fffffffffffffffULL |
| /* Formats correctly any integer in [0, 999999999] */ |
| static noinline_for_stack |
| char *put_dec_full9(char *buf, unsigned q) |
| { |
| unsigned r; |
| |
| /* Possible ways to approx. divide by 10 |
| * (x * 0x1999999a) >> 32 x < 1073741829 (multiply must be 64-bit) |
| * (x * 0xcccd) >> 19 x < 81920 (x < 262149 when 64-bit mul) |
| * (x * 0x6667) >> 18 x < 43699 |
| * (x * 0x3334) >> 17 x < 16389 |
| * (x * 0x199a) >> 16 x < 16389 |
| * (x * 0x0ccd) >> 15 x < 16389 |
| * (x * 0x0667) >> 14 x < 2739 |
| * (x * 0x0334) >> 13 x < 1029 |
| * (x * 0x019a) >> 12 x < 1029 |
| * (x * 0x00cd) >> 11 x < 1029 shorter code than * 0x67 (on i386) |
| * (x * 0x0067) >> 10 x < 179 |
| * (x * 0x0034) >> 9 x < 69 same |
| * (x * 0x001a) >> 8 x < 69 same |
| * (x * 0x000d) >> 7 x < 69 same, shortest code (on i386) |
| * (x * 0x0007) >> 6 x < 19 |
| * See <http://www.cs.uiowa.edu/~jones/bcd/divide.html> |
| */ |
| r = (q * (uint64_t)0x1999999a) >> 32; |
| *buf++ = (q - 10 * r) + '0'; /* 1 */ |
| q = (r * (uint64_t)0x1999999a) >> 32; |
| *buf++ = (r - 10 * q) + '0'; /* 2 */ |
| r = (q * (uint64_t)0x1999999a) >> 32; |
| *buf++ = (q - 10 * r) + '0'; /* 3 */ |
| q = (r * (uint64_t)0x1999999a) >> 32; |
| *buf++ = (r - 10 * q) + '0'; /* 4 */ |
| r = (q * (uint64_t)0x1999999a) >> 32; |
| *buf++ = (q - 10 * r) + '0'; /* 5 */ |
| /* Now value is under 10000, can avoid 64-bit multiply */ |
| q = (r * 0x199a) >> 16; |
| *buf++ = (r - 10 * q) + '0'; /* 6 */ |
| r = (q * 0xcd) >> 11; |
| *buf++ = (q - 10 * r) + '0'; /* 7 */ |
| q = (r * 0xcd) >> 11; |
| *buf++ = (r - 10 * q) + '0'; /* 8 */ |
| *buf++ = q + '0'; /* 9 */ |
| return buf; |
| } |
| #endif |
| |
| /* Similar to above but do not pad with zeros. |
| * Code can be easily arranged to print 9 digits too, but our callers |
| * always call put_dec_full9() instead when the number has 9 decimal digits. |
| */ |
| static noinline_for_stack |
| char *put_dec_trunc8(char *buf, unsigned r) |
| { |
| unsigned q; |
| |
| /* Copy of previous function's body with added early returns */ |
| q = (r * (uint64_t)0x1999999a) >> 32; |
| *buf++ = (r - 10 * q) + '0'; /* 2 */ |
| if (q == 0) return buf; |
| r = (q * (uint64_t)0x1999999a) >> 32; |
| *buf++ = (q - 10 * r) + '0'; /* 3 */ |
| if (r == 0) return buf; |
| q = (r * (uint64_t)0x1999999a) >> 32; |
| *buf++ = (r - 10 * q) + '0'; /* 4 */ |
| if (q == 0) return buf; |
| r = (q * (uint64_t)0x1999999a) >> 32; |
| *buf++ = (q - 10 * r) + '0'; /* 5 */ |
| if (r == 0) return buf; |
| q = (r * 0x199a) >> 16; |
| *buf++ = (r - 10 * q) + '0'; /* 6 */ |
| if (q == 0) return buf; |
| r = (q * 0xcd) >> 11; |
| *buf++ = (q - 10 * r) + '0'; /* 7 */ |
| if (r == 0) return buf; |
| q = (r * 0xcd) >> 11; |
| *buf++ = (r - 10 * q) + '0'; /* 8 */ |
| if (q == 0) return buf; |
| *buf++ = q + '0'; /* 9 */ |
| return buf; |
| } |
| |
| /* There are two algorithms to print larger numbers. |
| * One is generic: divide by 1000000000 and repeatedly print |
| * groups of (up to) 9 digits. It's conceptually simple, |
| * but requires a (unsigned long long) / 1000000000 division. |
| * |
| * Second algorithm splits 64-bit unsigned long long into 16-bit chunks, |
| * manipulates them cleverly and generates groups of 4 decimal digits. |
| * It so happens that it does NOT require long long division. |
| * |
| * If long is > 32 bits, division of 64-bit values is relatively easy, |
| * and we will use the first algorithm. |
| * If long long is > 64 bits (strange architecture with VERY large long long), |
| * second algorithm can't be used, and we again use the first one. |
| * |
| * Else (if long is 32 bits and long long is 64 bits) we use second one. |
| */ |
| |
| #if LONG_MAX != 0x7fffffffUL || LLONG_MAX != 0x7fffffffffffffffULL |
| |
| /* First algorithm: generic */ |
| |
| static |
| char *put_dec(char *buf, unsigned long long n) |
| { |
| if (n >= 100*1000*1000) { |
| while (n >= 1000*1000*1000) |
| buf = put_dec_full9(buf, do_div(n, 1000*1000*1000)); |
| if (n >= 100*1000*1000) |
| return put_dec_full9(buf, n); |
| } |
| return put_dec_trunc8(buf, n); |
| } |
| |
| #else |
| |
| /* Second algorithm: valid only for 64-bit long longs */ |
| |
| static noinline_for_stack |
| char *put_dec_full4(char *buf, unsigned q) |
| { |
| unsigned r; |
| r = (q * 0xcccd) >> 19; |
| *buf++ = (q - 10 * r) + '0'; |
| q = (r * 0x199a) >> 16; |
| *buf++ = (r - 10 * q) + '0'; |
| r = (q * 0xcd) >> 11; |
| *buf++ = (q - 10 * r) + '0'; |
| *buf++ = r + '0'; |
| return buf; |
| } |
| |
| /* Based on code by Douglas W. Jones found at |
| * <http://www.cs.uiowa.edu/~jones/bcd/decimal.html#sixtyfour> |
| * (with permission from the author). |
| * Performs no 64-bit division and hence should be fast on 32-bit machines. |
| */ |
| static |
| char *put_dec(char *buf, unsigned long long n) |
| { |
| uint32_t d3, d2, d1, q, h; |
| |
| if (n < 100*1000*1000) |
| return put_dec_trunc8(buf, n); |
| |
| d1 = ((uint32_t)n >> 16); /* implicit "& 0xffff" */ |
| h = (n >> 32); |
| d2 = (h ) & 0xffff; |
| d3 = (h >> 16); /* implicit "& 0xffff" */ |
| |
| q = 656 * d3 + 7296 * d2 + 5536 * d1 + ((uint32_t)n & 0xffff); |
| |
| buf = put_dec_full4(buf, q % 10000); |
| q = q / 10000; |
| |
| d1 = q + 7671 * d3 + 9496 * d2 + 6 * d1; |
| buf = put_dec_full4(buf, d1 % 10000); |
| q = d1 / 10000; |
| |
| d2 = q + 4749 * d3 + 42 * d2; |
| buf = put_dec_full4(buf, d2 % 10000); |
| q = d2 / 10000; |
| |
| d3 = q + 281 * d3; |
| if (!d3) |
| goto done; |
| buf = put_dec_full4(buf, d3 % 10000); |
| q = d3 / 10000; |
| if (!q) |
| goto done; |
| buf = put_dec_full4(buf, q); |
| done: |
| while (buf[-1] == '0') |
| --buf; |
| |
| return buf; |
| } |
| |
| #endif |
| |
| /* |
| * For strace, the following formats are not supported: |
| * %h[h]u, %zu, %tu - use [unsigned] int/long/long long fmt instead |
| * %8.4u - no precision field for integers allowed (ok for strings) |
| * %+d, % d - no forced sign or force "space positive" sign |
| * %-07u - use %-7u instead |
| * %X - works as %x |
| */ |
| |
| #define ZEROPAD 1 /* pad with zero */ |
| #define SIGN 2 /* unsigned/signed long */ |
| //#define PLUS 4 /* show plus */ |
| //#define SPACE 8 /* space if plus */ |
| #define LEFT 16 /* left justified */ |
| //#deefine SMALL 32 /* use lowercase in hex (must be 32 == 0x20) */ |
| #define SPECIAL 64 /* prefix hex with "0x", octal with "0" */ |
| |
| enum format_type { |
| FORMAT_TYPE_NONE, /* Just a string part */ |
| FORMAT_TYPE_WIDTH, |
| FORMAT_TYPE_PRECISION, |
| FORMAT_TYPE_CHAR, |
| FORMAT_TYPE_STR, |
| FORMAT_TYPE_PTR, |
| FORMAT_TYPE_PERCENT_CHAR, |
| FORMAT_TYPE_INVALID, |
| FORMAT_TYPE_LONG_LONG, |
| FORMAT_TYPE_ULONG, |
| FORMAT_TYPE_LONG, |
| FORMAT_TYPE_UINT, |
| FORMAT_TYPE_INT, |
| }; |
| |
| struct printf_spec { |
| uint8_t type; /* format_type enum */ |
| uint8_t flags; /* flags to number() */ |
| uint8_t base; /* number base, 8, 10 or 16 only */ |
| uint8_t qualifier; /* number qualifier, one of 'hHlLtzZ' */ |
| int field_width; /* width of output field */ |
| int precision; /* # of digits/chars */ |
| }; |
| |
| static noinline_for_stack |
| char *number(char *buf, char *end, unsigned long long num, |
| struct printf_spec spec) |
| { |
| /* we are called with base 8, 10 or 16, only, thus don't need "G..." */ |
| static const char digits[16] = "0123456789abcdef"; /* "GHIJKLMNOPQRSTUVWXYZ"; */ |
| |
| char tmp[sizeof(long long)*3 + 4]; |
| char sign; |
| int need_pfx = ((spec.flags & SPECIAL) && spec.base != 10); |
| int i; |
| |
| /* We may overflow the buf. Crudely check for it */ |
| i = sizeof(long long)*3 + 4; |
| if (i < spec.field_width) |
| i = spec.field_width; |
| if ((end - buf) <= i) |
| return buf + i; |
| |
| //we don't use formats like "%-07u" |
| // if (spec.flags & LEFT) |
| // spec.flags &= ~ZEROPAD; |
| sign = 0; |
| if (spec.flags & SIGN) { |
| if ((signed long long)num < 0) { |
| sign = '-'; |
| num = -(signed long long)num; |
| spec.field_width--; |
| // } else if (spec.flags & PLUS) { |
| // sign = '+'; |
| // spec.field_width--; |
| // } else if (spec.flags & SPACE) { |
| // sign = ' '; |
| // spec.field_width--; |
| } |
| } |
| if (need_pfx) { |
| spec.field_width--; |
| if (spec.base == 16) |
| spec.field_width--; |
| } |
| |
| /* generate full string in tmp[], in reverse order */ |
| i = 0; |
| if (num < spec.base) |
| tmp[i++] = digits[num]; |
| /* Generic code, for any base: |
| else do { |
| tmp[i++] = (digits[do_div(num,base)]); |
| } while (num != 0); |
| */ |
| else if (spec.base != 10) { /* 8 or 16 */ |
| int mask = spec.base - 1; |
| int shift = 3; |
| |
| if (spec.base == 16) |
| shift = 4; |
| do { |
| tmp[i++] = digits[((unsigned char)num) & mask]; |
| num >>= shift; |
| } while (num); |
| } else { /* base 10 */ |
| i = put_dec(tmp, num) - tmp; |
| } |
| |
| //spec.precision is assumed 0 ("not specified") |
| // /* printing 100 using %2d gives "100", not "00" */ |
| // if (i > spec.precision) |
| // spec.precision = i; |
| // /* leading space padding */ |
| // spec.field_width -= spec.precision; |
| spec.field_width -= i; |
| if (!(spec.flags & (ZEROPAD+LEFT))) { |
| while (--spec.field_width >= 0) { |
| ///if (buf < end) |
| *buf = ' '; |
| ++buf; |
| } |
| } |
| /* sign */ |
| if (sign) { |
| ///if (buf < end) |
| *buf = sign; |
| ++buf; |
| } |
| /* "0x" / "0" prefix */ |
| if (need_pfx) { |
| ///if (buf < end) |
| *buf = '0'; |
| ++buf; |
| if (spec.base == 16) { |
| ///if (buf < end) |
| *buf = 'x'; |
| ++buf; |
| } |
| } |
| /* zero or space padding */ |
| if (!(spec.flags & LEFT)) { |
| char c = (spec.flags & ZEROPAD) ? '0' : ' '; |
| while (--spec.field_width >= 0) { |
| ///if (buf < end) |
| *buf = c; |
| ++buf; |
| } |
| } |
| // /* hmm even more zero padding? */ |
| // while (i <= --spec.precision) { |
| // ///if (buf < end) |
| // *buf = '0'; |
| // ++buf; |
| // } |
| /* actual digits of result */ |
| while (--i >= 0) { |
| ///if (buf < end) |
| *buf = tmp[i]; |
| ++buf; |
| } |
| /* trailing space padding */ |
| while (--spec.field_width >= 0) { |
| ///if (buf < end) |
| *buf = ' '; |
| ++buf; |
| } |
| |
| return buf; |
| } |
| |
| static noinline_for_stack |
| char *string(char *buf, char *end, const char *s, struct printf_spec spec) |
| { |
| int len, i; |
| |
| if (!s) |
| s = "(null)"; |
| |
| len = strnlen(s, spec.precision); |
| |
| /* We may overflow the buf. Crudely check for it */ |
| i = len; |
| if (i < spec.field_width) |
| i = spec.field_width; |
| if ((end - buf) <= i) |
| return buf + i; |
| |
| if (!(spec.flags & LEFT)) { |
| while (len < spec.field_width--) { |
| ///if (buf < end) |
| *buf = ' '; |
| ++buf; |
| } |
| } |
| for (i = 0; i < len; ++i) { |
| ///if (buf < end) |
| *buf = *s; |
| ++buf; ++s; |
| } |
| while (len < spec.field_width--) { |
| ///if (buf < end) |
| *buf = ' '; |
| ++buf; |
| } |
| |
| return buf; |
| } |
| |
| static noinline_for_stack |
| char *pointer(const char *fmt, char *buf, char *end, void *ptr, |
| struct printf_spec spec) |
| { |
| // spec.flags |= SMALL; |
| if (spec.field_width == -1) { |
| spec.field_width = 2 * sizeof(void *); |
| spec.flags |= ZEROPAD; |
| } |
| spec.base = 16; |
| |
| return number(buf, end, (unsigned long) ptr, spec); |
| } |
| |
| /* |
| * Helper function to decode printf style format. |
| * Each call decode a token from the format and return the |
| * number of characters read (or likely the delta where it wants |
| * to go on the next call). |
| * The decoded token is returned through the parameters |
| * |
| * 'h', 'l', or 'L' for integer fields |
| * 'z' support added 23/7/1999 S.H. |
| * 'z' changed to 'Z' --davidm 1/25/99 |
| * 't' added for ptrdiff_t |
| * |
| * @fmt: the format string |
| * @type of the token returned |
| * @flags: various flags such as +, -, # tokens.. |
| * @field_width: overwritten width |
| * @base: base of the number (octal, hex, ...) |
| * @precision: precision of a number |
| * @qualifier: qualifier of a number (long, size_t, ...) |
| */ |
| static noinline_for_stack |
| int format_decode(const char *fmt, struct printf_spec *spec) |
| { |
| const char *start = fmt; |
| |
| /* we finished early by reading the field width */ |
| if (spec->type == FORMAT_TYPE_WIDTH) { |
| if (spec->field_width < 0) { |
| spec->field_width = -spec->field_width; |
| spec->flags |= LEFT; |
| } |
| spec->type = FORMAT_TYPE_NONE; |
| goto precision; |
| } |
| |
| /* we finished early by reading the precision */ |
| if (spec->type == FORMAT_TYPE_PRECISION) { |
| if (spec->precision < 0) |
| spec->precision = 0; |
| |
| spec->type = FORMAT_TYPE_NONE; |
| goto qualifier; |
| } |
| |
| /* By default */ |
| spec->type = FORMAT_TYPE_NONE; |
| |
| for (;;) { |
| if (*fmt == '\0') |
| return fmt - start; |
| if (*fmt == '%') |
| break; |
| ++fmt; |
| } |
| |
| /* Return the current non-format string */ |
| if (fmt != start) |
| return fmt - start; |
| |
| /* Process flags */ |
| spec->flags = 0; |
| |
| while (1) { /* this also skips first '%' */ |
| bool found = true; |
| |
| ++fmt; |
| |
| switch (*fmt) { |
| case '-': spec->flags |= LEFT; break; |
| // case '+': spec->flags |= PLUS; break; |
| // case ' ': spec->flags |= SPACE; break; |
| case '#': spec->flags |= SPECIAL; break; |
| case '0': spec->flags |= ZEROPAD; break; |
| default: found = false; |
| } |
| |
| if (!found) |
| break; |
| } |
| |
| /* get field width */ |
| spec->field_width = -1; |
| |
| if (isdigit(*fmt)) |
| spec->field_width = skip_atoi(&fmt); |
| else if (*fmt == '*') { |
| /* it's the next argument */ |
| spec->type = FORMAT_TYPE_WIDTH; |
| return ++fmt - start; |
| } |
| |
| precision: |
| /* get the precision */ |
| spec->precision = -1; |
| if (*fmt == '.') { |
| ++fmt; |
| if (isdigit(*fmt)) { |
| spec->precision = skip_atoi(&fmt); |
| // if (spec->precision < 0) |
| // spec->precision = 0; |
| } else if (*fmt == '*') { |
| /* it's the next argument */ |
| spec->type = FORMAT_TYPE_PRECISION; |
| return ++fmt - start; |
| } |
| } |
| |
| qualifier: |
| /* get the conversion qualifier */ |
| spec->qualifier = -1; |
| if (*fmt == 'l') { |
| spec->qualifier = *fmt++; |
| if (unlikely(spec->qualifier == *fmt)) { |
| spec->qualifier = 'L'; |
| ++fmt; |
| } |
| } |
| |
| /* default base */ |
| spec->base = 10; |
| switch (*fmt) { |
| case 'c': |
| spec->type = FORMAT_TYPE_CHAR; |
| return ++fmt - start; |
| |
| case 's': |
| spec->type = FORMAT_TYPE_STR; |
| return ++fmt - start; |
| |
| case 'p': |
| spec->type = FORMAT_TYPE_PTR; |
| return ++fmt - start; |
| |
| case '%': |
| spec->type = FORMAT_TYPE_PERCENT_CHAR; |
| return ++fmt - start; |
| |
| /* integer number formats - set up the flags and "break" */ |
| case 'o': |
| spec->base = 8; |
| break; |
| |
| case 'x': |
| // spec->flags |= SMALL; |
| |
| case 'X': |
| spec->base = 16; |
| break; |
| |
| case 'd': |
| case 'i': |
| spec->flags |= SIGN; |
| case 'u': |
| break; |
| |
| default: |
| spec->type = FORMAT_TYPE_INVALID; |
| return fmt - start; |
| } |
| |
| if (spec->qualifier == 'L') |
| spec->type = FORMAT_TYPE_LONG_LONG; |
| else if (spec->qualifier == 'l') { |
| if (spec->flags & SIGN) |
| spec->type = FORMAT_TYPE_LONG; |
| else |
| spec->type = FORMAT_TYPE_ULONG; |
| } else { |
| if (spec->flags & SIGN) |
| spec->type = FORMAT_TYPE_INT; |
| else |
| spec->type = FORMAT_TYPE_UINT; |
| } |
| |
| return ++fmt - start; |
| } |
| |
| /** |
| * vsnprintf - Format a string and place it in a buffer |
| * @buf: The buffer to place the result into |
| * @size: The size of the buffer, including the trailing null space |
| * @fmt: The format string to use |
| * @args: Arguments for the format string |
| * |
| * The return value is the number of characters which would |
| * be generated for the given input, excluding the trailing |
| * '\0', as per ISO C99. If you want to have the exact |
| * number of characters written into @buf as return value |
| * (not including the trailing '\0'), use vscnprintf(). If the |
| * return is greater than or equal to @size, the resulting |
| * string is truncated. |
| * |
| * If you're not already dealing with a va_list consider using snprintf(). |
| */ |
| static |
| int kernel_vsnprintf(char *buf, size_t size, const char *fmt, va_list args) |
| { |
| unsigned long long num; |
| char *str, *end; |
| struct printf_spec spec = {0}; |
| |
| str = buf; |
| end = buf + size; |
| |
| while (*fmt) { |
| const char *old_fmt = fmt; |
| int read = format_decode(fmt, &spec); |
| |
| fmt += read; |
| |
| switch (spec.type) { |
| case FORMAT_TYPE_NONE: { |
| int copy = read; |
| if (str < end) { |
| if (copy > end - str) |
| copy = end - str; |
| memcpy(str, old_fmt, copy); |
| } |
| str += read; |
| break; |
| } |
| |
| case FORMAT_TYPE_WIDTH: |
| spec.field_width = va_arg(args, int); |
| break; |
| |
| case FORMAT_TYPE_PRECISION: |
| spec.precision = va_arg(args, int); |
| break; |
| |
| case FORMAT_TYPE_CHAR: { |
| char c; |
| |
| if (!(spec.flags & LEFT)) { |
| while (--spec.field_width > 0) { |
| if (str < end) |
| *str = ' '; |
| ++str; |
| |
| } |
| } |
| c = (unsigned char) va_arg(args, int); |
| if (str < end) |
| *str = c; |
| ++str; |
| while (--spec.field_width > 0) { |
| if (str < end) |
| *str = ' '; |
| ++str; |
| } |
| break; |
| } |
| |
| case FORMAT_TYPE_STR: |
| str = string(str, end, va_arg(args, char *), spec); |
| break; |
| |
| case FORMAT_TYPE_PTR: |
| str = pointer(fmt+1, str, end, va_arg(args, void *), |
| spec); |
| // while (isalnum(*fmt)) |
| // fmt++; |
| break; |
| |
| case FORMAT_TYPE_PERCENT_CHAR: |
| if (str < end) |
| *str = '%'; |
| ++str; |
| break; |
| |
| case FORMAT_TYPE_INVALID: |
| if (str < end) |
| *str = '%'; |
| ++str; |
| break; |
| |
| default: |
| switch (spec.type) { |
| case FORMAT_TYPE_LONG_LONG: |
| num = va_arg(args, long long); |
| break; |
| case FORMAT_TYPE_ULONG: |
| num = va_arg(args, unsigned long); |
| break; |
| case FORMAT_TYPE_LONG: |
| num = va_arg(args, long); |
| break; |
| case FORMAT_TYPE_INT: |
| num = (int) va_arg(args, int); |
| break; |
| default: |
| num = va_arg(args, unsigned int); |
| } |
| |
| str = number(str, end, num, spec); |
| } |
| } |
| |
| // if (size > 0) { |
| if (str < end) |
| *str = '\0'; |
| // else |
| // end[-1] = '\0'; |
| // } |
| |
| /* the trailing null byte doesn't count towards the total */ |
| return str-buf; |
| |
| } |
| |
| int strace_vfprintf(FILE *fp, const char *fmt, va_list args) |
| { |
| static char *buf = NULL; |
| static unsigned buflen = 0; |
| |
| int r; |
| va_list a1; |
| |
| va_copy(a1, args); |
| unsigned len = kernel_vsnprintf(buf, buflen, fmt, a1); |
| va_end(a1); |
| |
| if (len >= buflen) { |
| buflen = len + 256; |
| free(buf); |
| buf = malloc(buflen); |
| if (!buf) |
| die_out_of_memory(); |
| /*len =*/ kernel_vsnprintf(buf, buflen, fmt, args); |
| } |
| |
| r = fputs_unlocked(buf, fp); |
| if (r < 0) return r; |
| return len; |
| } |
| |
| #endif /* USE_CUSTOM_PRINTF */ |