1411 lines
36 KiB
C
1411 lines
36 KiB
C
/****************************************************************************
|
|
* 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 <nuttx/config.h>
|
|
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <limits.h>
|
|
|
|
#include <nuttx/compiler.h>
|
|
#include <nuttx/streams.h>
|
|
#include <nuttx/allsyms.h>
|
|
#include <nuttx/symtab.h>
|
|
|
|
#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(FAR void *) == sizeof(unsigned long long))
|
|
{
|
|
flags |= (FL_LONG | FL_REPD_TYPE);
|
|
}
|
|
else
|
|
#endif
|
|
if (sizeof(FAR 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);
|
|
}
|