/**************************************************************************** * libs/libc/stdio/lib_libvsprintf.c * * Copyright (c) 2002, Alexander Popov (sasho@vip.bg) * Copyright (c) 2002,2004,2005 Joerg Wunsch * Copyright (c) 2005, Helmut Wallner * Copyright (c) 2007, Dmitry Xmelkov * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * 3. Neither the name NuttX nor the names of its contributors may be * used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * ****************************************************************************/ /**************************************************************************** * Included Files ****************************************************************************/ #include #include #include #include #include #include #include #include #include #include #include "lib_dtoa_engine.h" #include "lib_ultoa_invert.h" /**************************************************************************** * Pre-processor Definitions ****************************************************************************/ /* CONFIG_LIBC_LONG_LONG is not a valid selection of the compiler does not * support long long types. */ #ifndef CONFIG_HAVE_LONG_LONG # undef CONFIG_LIBC_LONG_LONG #endif #define stream_putc(c,stream) (total_len++, lib_stream_putc(stream, c)) #define stream_puts(buf, len, stream) \ (total_len += len, lib_stream_puts(stream, buf, len)) /* Order is relevant here and matches order in format string */ #define FL_ZFILL 0x0001 #define FL_PLUS 0x0002 #define FL_SPACE 0x0004 #define FL_LPAD 0x0008 #define FL_ALT 0x0010 #define FL_ARGNUMBER 0x0020 #define FL_ASTERISK 0x0040 #define FL_WIDTH 0x0080 #define FL_PREC 0x0100 #define FL_LONG 0x0200 #define FL_SHORT 0x0400 #define FL_REPD_TYPE 0x0800 #define FL_NEGATIVE 0x1000 /* The next 2 groups are Exclusive Or */ #define FL_ALTUPP 0x2000 #define FL_ALTHEX 0x4000 #define FL_FLTUPP 0x2000 #define FL_FLTEXP 0x4000 #define FL_FLTFIX 0x8000 #define TYPE_INT 1 #define TYPE_LONG 2 #define TYPE_LONG_LONG 3 #define TYPE_DOUBLE 4 #define TYPE_CHAR_POINTER 5 /* Support special access to CODE-space strings for Harvard architectures */ #ifdef CONFIG_ARCH_ROMGETC # define fmt_char(fmt) up_romgetc((fmt)++) #else # define fmt_char(fmt) (*(fmt)++) #endif #define fmt_ungetc(fmt) ((fmt)--) /**************************************************************************** * Private Types ****************************************************************************/ struct arg_s { unsigned char type; union { unsigned int u; unsigned long ul; #ifdef CONFIG_HAVE_LONG_LONG unsigned long long ull; #endif #ifdef CONFIG_HAVE_DOUBLE double d; #endif FAR char *cp; } value; }; /**************************************************************************** * Private Constant Data ****************************************************************************/ static const char g_nullstring[] = "(null)"; /**************************************************************************** * Private Function Prototypes ****************************************************************************/ static int vsprintf_internal(FAR struct lib_outstream_s *stream, FAR struct arg_s *arglist, int numargs, FAR const IPTR char *fmt, va_list ap) printf_like(4, 0); /**************************************************************************** * Private Functions ****************************************************************************/ static int vsprintf_internal(FAR struct lib_outstream_s *stream, FAR struct arg_s *arglist, int numargs, FAR const IPTR char *fmt, va_list ap) { unsigned char c; /* Holds a char from the format string */ uint16_t flags; int width; int prec; union { #if defined (CONFIG_LIBC_LONG_LONG) || (ULONG_MAX > 4294967295UL) char __buf[22]; /* Size for -1 in octal, without '\0' */ #else char __buf[11]; /* Size for -1 in octal, without '\0' */ #endif #ifdef CONFIG_LIBC_FLOATINGPOINT struct dtoa_s __dtoa; #endif } u; #define buf (u.__buf) #define _dtoa (u.__dtoa) FAR const char *pnt; size_t size; unsigned char len; int total_len = 0; #ifdef CONFIG_LIBC_NUMBERED_ARGS int argnumber = 0; #endif for (; ; ) { for (; ; ) { c = fmt_char(fmt); if (c == '\0') { goto ret; } if (c == '%') { c = fmt_char(fmt); if (c != '%') { break; } } #ifdef CONFIG_LIBC_NUMBERED_ARGS if (stream != NULL) { stream_putc(c, stream); } #else stream_putc(c, stream); #endif } flags = 0; width = 0; prec = 0; do { if (flags < FL_ASTERISK) { switch (c) { case '0': flags |= FL_ZFILL; continue; case '+': flags |= FL_PLUS; /* FALLTHROUGH */ case ' ': flags |= FL_SPACE; continue; case '-': flags |= FL_LPAD; continue; case '#': flags |= FL_ALT; continue; } } if (flags < FL_LONG) { #ifdef CONFIG_LIBC_NUMBERED_ARGS if (c == '$') { if ((flags & FL_ARGNUMBER) == 0) { /* No other flag except FL_WIDTH or FL_ZFILL (leading * zeros) and argument number must be at least 1 */ if ((flags & ~(FL_WIDTH | FL_ZFILL)) != 0 || width == 0) { goto ret; } /* It had been the argument number. */ argnumber = width; width = 0; flags = FL_ARGNUMBER; } else if ((flags & FL_ASTERISK) != 0) { int index; flags &= ~FL_ASTERISK; if ((flags & FL_PREC) == 0) { index = width; } else { index = prec; } if (index > 0 && index <= numargs) { if (stream == NULL) { arglist[index - 1].type = TYPE_INT; if (index > total_len) { total_len = index; } } else { if ((flags & FL_PREC) == 0) { width = (int)arglist[index - 1].value.u; } else { prec = (int)arglist[index - 1].value.u; } } } else { goto ret; } } else { goto ret; } continue; } #endif if (c >= '0' && c <= '9') { c -= '0'; if ((flags & FL_PREC) != 0) { prec = 10 * prec + c; continue; } width = 10 * width + c; flags |= FL_WIDTH; continue; } if (c == '*') { #ifdef CONFIG_LIBC_NUMBERED_ARGS if ((flags & FL_ARGNUMBER) != 0) { flags |= FL_ASTERISK; continue; } else if (stream == NULL) { continue; /* We do only parsing */ } #endif if ((flags & FL_PREC) != 0) { prec = va_arg(ap, int); if (prec < 0) { prec = 0; } } else { width = va_arg(ap, int); flags |= FL_WIDTH; if (width < 0) { width = -width; flags |= FL_LPAD; } } continue; } if (c == '.') { if ((flags & FL_PREC) != 0) { goto ret; } flags |= FL_PREC; continue; } } /* Note: On NuttX, ptrdiff_t == intptr_t == ssize_t. */ if (c == 'z' || c == 't') { if (sizeof(size_t) == sizeof(unsigned short)) { c = 'h'; } else if (sizeof(size_t) == sizeof(unsigned long)) { c = 'l'; } #if defined(CONFIG_HAVE_LONG_LONG) && ULLONG_MAX != ULONG_MAX else if (sizeof(size_t) == sizeof(unsigned long long)) { c = 'l'; flags |= FL_LONG; flags &= ~FL_SHORT; } #endif else { /* The only known cases that the default will be hit are * (1) the eZ80 which has sizeof(size_t) = 3 which is the * same as the sizeof(int). And (2) if * CONFIG_HAVE_LONG_LONG * is not enabled and sizeof(size_t) is equal to * sizeof(unsigned long long). This latter case is an * error. * Treat as integer with no size qualifier. */ continue; } } if (c == 'j') { /* Same as long long if available. Otherwise, long. */ #ifdef CONFIG_HAVE_LONG_LONG flags |= FL_REPD_TYPE; #endif flags |= FL_LONG; flags &= ~FL_SHORT; continue; } if (c == 'l') { if ((flags & FL_LONG) != 0) { flags |= FL_REPD_TYPE; } else { flags |= FL_LONG; } flags &= ~FL_SHORT; continue; } if (c == 'h') { if ((flags & FL_SHORT) != 0) { flags |= FL_REPD_TYPE; } else { flags |= FL_SHORT; } flags &= ~FL_LONG; continue; } break; } while ((c = fmt_char(fmt)) != 0); /* Only a format character is valid. */ #if 'F' != 'E'+1 || 'G' != 'F'+1 || 'f' != 'e'+1 || 'g' != 'f'+1 # error #endif if (c == 'p') { /* Determine size of pointer and set flags accordingly */ flags &= ~(FL_LONG | FL_REPD_TYPE); #ifdef CONFIG_HAVE_LONG_LONG if (sizeof(void *) == sizeof(unsigned long long)) { flags |= (FL_LONG | FL_REPD_TYPE); } else #endif if (sizeof(void *) == sizeof(unsigned long)) { flags |= FL_LONG; } } #ifdef CONFIG_LIBC_NUMBERED_ARGS if ((flags & FL_ARGNUMBER) != 0) { if (argnumber > 0 && argnumber <= numargs) { if (stream == NULL) { if ((c >= 'E' && c <= 'G') || (c >= 'e' && c <= 'g')) { arglist[argnumber - 1].type = TYPE_DOUBLE; } else if (c == 'i' || c == 'd' || c == 'u' || c == 'p') { if ((flags & FL_LONG) == 0) { arglist[argnumber - 1].type = TYPE_INT; } else if ((flags & FL_REPD_TYPE) == 0) { arglist[argnumber - 1].type = TYPE_LONG; } else { arglist[argnumber - 1].type = TYPE_LONG_LONG; } } else if (c == 'c') { arglist[argnumber - 1].type = TYPE_INT; } else if (c == 's') { arglist[argnumber - 1].type = TYPE_CHAR_POINTER; } if (argnumber > total_len) { total_len = argnumber; } continue; /* We do only parsing */ } } else { goto ret; } } else if (stream == NULL) { continue; /* We do only parsing */ } #endif #ifdef CONFIG_LIBC_FLOATINGPOINT if (c >= 'E' && c <= 'G') { flags |= FL_FLTUPP; c += 'e' - 'E'; goto flt_oper; } else if (c >= 'e' && c <= 'g') { double value; int exp; /* Exponent of master decimal digit */ int n; uint8_t sign; /* Sign character (or 0) */ uint8_t ndigs; /* Number of digits to convert */ uint8_t ndecimal; /* Digits after decimal (for 'f' format), 0 if * no limit */ flags &= ~FL_FLTUPP; flt_oper: ndigs = 0; if ((flags & FL_PREC) == 0) { prec = 6; } flags &= ~(FL_FLTEXP | FL_FLTFIX); if (c == 'e') { ndigs = prec + 1; ndecimal = 0; flags |= FL_FLTEXP; } else if (c == 'f') { ndigs = DTOA_MAX_DIG; ndecimal = prec; flags |= FL_FLTFIX; } else { ndigs = prec; ndecimal = 0; } if (ndigs > DTOA_MAX_DIG) { ndigs = DTOA_MAX_DIG; } #ifdef CONFIG_LIBC_NUMBERED_ARGS if ((flags & FL_ARGNUMBER) != 0) { value = arglist[argnumber - 1].value.d; } else { value = va_arg(ap, double); } #else value = va_arg(ap, double); #endif ndigs = __dtoa_engine(value, &_dtoa, ndigs, ndecimal); exp = _dtoa.exp; sign = 0; if (_dtoa.flags & DTOA_MINUS) { sign = '-'; } else if ((flags & FL_PLUS) != 0) { sign = '+'; } else if ((flags & FL_SPACE) != 0) { sign = ' '; } if (_dtoa.flags & (DTOA_NAN | DTOA_INF)) { FAR const char *p; ndigs = sign ? 4 : 3; if (width > ndigs) { width -= ndigs; if ((flags & FL_LPAD) == 0) { do { stream_putc(' ', stream); } while (--width); } } else { width = 0; } if (sign) { stream_putc(sign, stream); } p = "inf"; if (_dtoa.flags & DTOA_NAN) { p = "nan"; } # if ('I'-'i' != 'N'-'n') || ('I'-'i' != 'F'-'f') || ('I'-'i' != 'A'-'a') # error # endif while ((ndigs = *p) != 0) { if ((flags & FL_FLTUPP) != 0) { ndigs += 'I' - 'i'; } stream_putc(ndigs, stream); p++; } goto tail; } if ((flags & (FL_FLTEXP | FL_FLTFIX)) == 0) { /* 'g(G)' format */ prec = ndigs; /* Remove trailing zeros */ while (ndigs > 0 && _dtoa.digits[ndigs - 1] == '0') { ndigs--; } if (-4 <= exp && exp < prec) { flags |= FL_FLTFIX; if (exp < 0 || ndigs > exp) { prec = ndigs - (exp + 1); } else { prec = 0; } } else { /* Limit displayed precision to available precision */ prec = ndigs - 1; } } /* Conversion result length, width := free space length */ if ((flags & FL_FLTFIX) != 0) { n = (exp > 0 ? exp + 1 : 1); } else { n = 5; /* 1e+00 */ } if (sign != 0) { n += 1; } if (prec != 0) { n += prec + 1; } else if ((flags & FL_ALT) != 0) { n += 1; } width = width > n ? width - n : 0; /* Output before first digit */ if ((flags & (FL_LPAD | FL_ZFILL)) == 0) { while (width) { stream_putc(' ', stream); width--; } } if (sign != 0) { stream_putc(sign, stream); } if ((flags & FL_LPAD) == 0) { while (width) { stream_putc('0', stream); width--; } } if ((flags & FL_FLTFIX) != 0) { /* 'f' format */ char out; /* At this point, we should have exp exponent of leftmost digit * in _dtoa.digits ndigs number of buffer digits to print prec * number of digits after decimal In the loop, 'n' walks over * the exponent value */ n = exp > 0 ? exp : 0; /* Exponent of left digit */ do { /* Insert decimal point at correct place */ if (n == -1) { stream_putc('.', stream); } /* Pull digits from buffer when in-range, otherwise use 0 */ if (0 <= exp - n && exp - n < ndigs) { out = _dtoa.digits[exp - n]; } else { out = '0'; } if (--n < -prec) { break; } stream_putc(out, stream); } while (1); if (n == exp && (_dtoa.digits[0] > '5' || (_dtoa.digits[0] == '5' && !(_dtoa.flags & DTOA_CARRY)))) { out = '1'; } stream_putc(out, stream); if ((flags & FL_ALT) != 0 && n == -1) { stream_putc('.', stream); } } else { /* 'e(E)' format * * Mantissa */ if (_dtoa.digits[0] != '1') { _dtoa.flags &= ~DTOA_CARRY; } stream_putc(_dtoa.digits[0], stream); if (prec > 0) { uint8_t pos; stream_putc('.', stream); for (pos = 1; pos < 1 + prec; pos++) { stream_putc(pos < ndigs ? _dtoa.digits[pos] : '0', stream); } } else if ((flags & FL_ALT) != 0) { stream_putc('.', stream); } /* Exponent */ stream_putc(flags & FL_FLTUPP ? 'E' : 'e', stream); ndigs = '+'; if (exp < 0 || (exp == 0 && (_dtoa.flags & DTOA_CARRY) != 0)) { exp = -exp; ndigs = '-'; } stream_putc(ndigs, stream); c = __ultoa_invert(exp, buf, 10) - buf; if (exp >= 0 && exp <= 9) { stream_putc('0', stream); } while (c > 0) { stream_putc(buf[c - 1], stream); c--; } } goto tail; } #else /* !CONFIG_LIBC_FLOATINGPOINT */ if ((c >= 'E' && c <= 'G') || (c >= 'e' && c <= 'g')) { # ifndef CONFIG_LIBC_NUMBERED_ARGS va_arg(ap, double); # endif pnt = "*float*"; size = sizeof("*float*") - 1; goto str_lpad; } #endif switch (c) { case 'c': #ifdef CONFIG_LIBC_NUMBERED_ARGS if ((flags & FL_ARGNUMBER) != 0) { buf[0] = (int)arglist[argnumber - 1].value.u; } else { buf[0] = va_arg(ap, int); } #else buf[0] = va_arg(ap, int); #endif pnt = buf; size = 1; goto str_lpad; case 's': case 'S': #ifdef CONFIG_LIBC_NUMBERED_ARGS if ((flags & FL_ARGNUMBER) != 0) { pnt = arglist[argnumber - 1].value.cp; } else { pnt = va_arg(ap, FAR char *); } #else pnt = va_arg(ap, FAR char *); #endif if (pnt == NULL) { pnt = g_nullstring; } size = strnlen(pnt, (flags & FL_PREC) ? prec : ~0); str_lpad: if ((flags & FL_LPAD) == 0) { while (size < width) { stream_putc(' ', stream); width--; } } stream_puts(pnt, size, stream); width = width >= size ? width - size : 0; size = 0; goto tail; } if (c == 'd' || c == 'i') { #ifndef CONFIG_HAVE_LONG_LONG long x; #else long long x; if ((flags & FL_LONG) != 0 && (flags & FL_REPD_TYPE) != 0) { #ifdef CONFIG_LIBC_NUMBERED_ARGS if ((flags & FL_ARGNUMBER) != 0) { x = (long long)arglist[argnumber - 1].value.ull; } else { x = va_arg(ap, long long); } #else x = va_arg(ap, long long); #endif } else #endif if ((flags & FL_LONG) != 0) { #ifdef CONFIG_LIBC_NUMBERED_ARGS if ((flags & FL_ARGNUMBER) != 0) { x = (long)arglist[argnumber - 1].value.ul; } else { x = va_arg(ap, long); } #else x = va_arg(ap, long); #endif } else { #ifdef CONFIG_LIBC_NUMBERED_ARGS if ((flags & FL_ARGNUMBER) != 0) { x = (int)arglist[argnumber - 1].value.u; } else { x = va_arg(ap, int); } #else x = va_arg(ap, int); #endif if ((flags & FL_SHORT) != 0) { if ((flags & FL_REPD_TYPE) == 0) { x = (short)x; } else { x = (signed char)x; } } } flags &= ~(FL_NEGATIVE | FL_ALT); if (x < 0) { x = -x; flags |= FL_NEGATIVE; } if ((flags & FL_PREC) != 0 && prec == 0 && x == 0) { c = 0; } else { #if !defined(CONFIG_LIBC_LONG_LONG) && defined(CONFIG_HAVE_LONG_LONG) DEBUGASSERT(x >= 0 && x <= ULONG_MAX); #endif c = __ultoa_invert(x, buf, 10) - buf; } } else { int base; #ifndef CONFIG_HAVE_LONG_LONG unsigned long x; #else unsigned long long x; if ((flags & FL_LONG) != 0 && (flags & FL_REPD_TYPE) != 0) { #ifdef CONFIG_LIBC_NUMBERED_ARGS if ((flags & FL_ARGNUMBER) != 0) { x = arglist[argnumber - 1].value.ull; } else { x = va_arg(ap, unsigned long long); } #else x = va_arg(ap, unsigned long long); #endif } else #endif if ((flags & FL_LONG) != 0) { #ifdef CONFIG_LIBC_NUMBERED_ARGS if ((flags & FL_ARGNUMBER) != 0) { x = arglist[argnumber - 1].value.ul; } else { x = va_arg(ap, unsigned long); } #else x = va_arg(ap, unsigned long); #endif } else { #ifdef CONFIG_LIBC_NUMBERED_ARGS if ((flags & FL_ARGNUMBER) != 0) { x = (unsigned int)arglist[argnumber - 1].value.u; } else { x = va_arg(ap, unsigned int); } #else x = va_arg(ap, unsigned int); #endif if ((flags & FL_SHORT) != 0) { if ((flags & FL_REPD_TYPE) == 0) { x = (unsigned short)x; } else { x = (unsigned char)x; } } } flags &= ~(FL_PLUS | FL_SPACE); switch (c) { case 'u': flags &= ~FL_ALT; base = 10; break; case 'o': base = 8; break; case 'p': c = fmt_char(fmt); switch (c) { case 'V': { FAR struct va_format *vaf = (FAR void *)(uintptr_t)x; #ifdef va_copy va_list copy; va_copy(copy, *vaf->va); lib_vsprintf(stream, vaf->fmt, copy); va_end(copy); #else lib_vsprintf(stream, vaf->fmt, *vaf->va); #endif continue; } case 'S': case 's': { #ifdef CONFIG_ALLSYMS FAR const struct symtab_s *symbol; FAR void *addr = (FAR void *)(uintptr_t)x; size_t symbolsize; symbol = allsyms_findbyvalue(addr, &symbolsize); if (symbol != NULL) { pnt = symbol->sym_name; while (*pnt != '\0') { stream_putc(*pnt++, stream); } if (c == 'S') { total_len += lib_sprintf_internal(stream, "+%#tx/%#zx", addr - symbol->sym_value, symbolsize); } continue; } #endif break; } default: fmt_ungetc(fmt); break; } flags |= FL_ALT; /* no break */ case 'x': if ((flags & FL_ALT) != 0) { flags |= FL_ALTHEX; } base = 16; break; case 'X': if ((flags & FL_ALT) != 0) { flags |= (FL_ALTHEX | FL_ALTUPP); } base = 16 | XTOA_UPPER; break; default: stream_putc('%', stream); stream_putc(c, stream); continue; } if ((flags & FL_PREC) != 0 && prec == 0 && x == 0) { c = 0; } else { #if !defined(CONFIG_LIBC_LONG_LONG) && defined(CONFIG_HAVE_LONG_LONG) DEBUGASSERT(x <= ULONG_MAX); #endif c = __ultoa_invert(x, buf, base) - buf; } flags &= ~FL_NEGATIVE; } len = c; if ((flags & FL_PREC) != 0) { flags &= ~FL_ZFILL; if (len < prec) { len = prec; if ((flags & FL_ALT) != 0 && (flags & FL_ALTHEX) == 0) { flags &= ~FL_ALT; } } } if ((flags & FL_ALT) != 0) { if (buf[c - 1] == '0') { flags &= ~(FL_ALT | FL_ALTHEX | FL_ALTUPP); } else { len += 1; if ((flags & FL_ALTHEX) != 0) { len += 1; } } } else if ((flags & (FL_NEGATIVE | FL_PLUS | FL_SPACE)) != 0) { len += 1; } if ((flags & FL_LPAD) == 0) { if ((flags & FL_ZFILL) != 0) { prec = c; if (len < width) { prec += width - len; len = width; } } while (len < width) { stream_putc(' ', stream); len++; } } width = (len < width) ? width - len : 0; if ((flags & FL_ALT) != 0) { stream_putc('0', stream); if ((flags & FL_ALTHEX) != 0) { stream_putc(flags & FL_ALTUPP ? 'X' : 'x', stream); } } else if ((flags & (FL_NEGATIVE | FL_PLUS | FL_SPACE)) != 0) { unsigned char z = ' '; if ((flags & FL_PLUS) != 0) { z = '+'; } if ((flags & FL_NEGATIVE) != 0) { z = '-'; } stream_putc(z, stream); } while (prec > c) { stream_putc('0', stream); prec--; } while (c) { stream_putc(buf[--c], stream); } tail: /* Tail is possible. */ while (width) { stream_putc(' ', stream); width--; } } ret: return total_len; } /**************************************************************************** * Public Functions ****************************************************************************/ int lib_vsprintf(FAR struct lib_outstream_s *stream, FAR const IPTR char *fmt, va_list ap) { #ifdef CONFIG_LIBC_NUMBERED_ARGS struct arg_s arglist[NL_ARGMAX]; int numargs; int i; /* We do 2 passes of parsing and fill the arglist between the passes. */ numargs = vsprintf_internal(NULL, arglist, NL_ARGMAX, fmt, ap); for (i = 0; i < numargs; i++) { switch (arglist[i].type) { case TYPE_LONG_LONG: #ifdef CONFIG_HAVE_LONG_LONG arglist[i].value.ull = va_arg(ap, unsigned long long); break; #endif case TYPE_LONG: arglist[i].value.ul = va_arg(ap, unsigned long); break; case TYPE_INT: arglist[i].value.u = va_arg(ap, unsigned int); break; #ifdef CONFIG_HAVE_DOUBLE case TYPE_DOUBLE: arglist[i].value.d = va_arg(ap, double); break; #endif case TYPE_CHAR_POINTER: arglist[i].value.cp = va_arg(ap, FAR char *); break; } } return vsprintf_internal(stream, arglist, numargs, fmt, ap); #else return vsprintf_internal(stream, NULL, 0, fmt, ap); #endif } /**************************************************************************** * Name: lib_sprintf_internal * * Description: * This function does not take numbered arguments in printf. * Equivalent to lib_sprintf when CONFIG_LIBC_NUMBERED_ARGS is not enabled * ****************************************************************************/ int lib_sprintf_internal(FAR struct lib_outstream_s *stream, FAR const IPTR char *fmt, ...) { va_list ap; int n; /* Then let vsprintf_internal do the real work */ va_start(ap, fmt); n = vsprintf_internal(stream, NULL, 0, fmt, ap); va_end(ap); return n; } /**************************************************************************** * Name: lib_vsprintf_internal * * Description: * This function does not take numbered arguments in printf. * Equivalent to lib_sprintf when CONFIG_LIBC_NUMBERED_ARGS is not enabled * ****************************************************************************/ int lib_vsprintf_internal(FAR struct lib_outstream_s *stream, FAR const IPTR char *fmt, va_list ap) { return vsprintf_internal(stream, NULL, 0, fmt, ap); }