[T106][ZXW-22]7520V3SCV2.01.01.02P42U09_VEC_V0.8_AP_VEC origin source commit
Change-Id: Ic6e05d89ecd62fc34f82b23dcf306c93764aec4b
diff --git a/ap/build/uClibc/libc/stdio/old_vfprintf.c b/ap/build/uClibc/libc/stdio/old_vfprintf.c
new file mode 100644
index 0000000..7d4bfea
--- /dev/null
+++ b/ap/build/uClibc/libc/stdio/old_vfprintf.c
@@ -0,0 +1,710 @@
+/*
+ * This file based on printf.c from 'Dlibs' on the atari ST (RdeBath)
+ *
+ *
+ * Dale Schumacher 399 Beacon Ave.
+ * (alias: Dalnefre') St. Paul, MN 55104
+ * dal@syntel.UUCP United States of America
+ * "It's not reality that's important, but how you perceive things."
+ */
+
+/* Altered to use stdarg, made the core function vfnprintf.
+ * Hooked into the stdio package using 'inside information'
+ * Altered sizeof() assumptions, now assumes all integers except chars
+ * will be either
+ * sizeof(xxx) == sizeof(long) or sizeof(xxx) == sizeof(short)
+ *
+ * -RDB
+ */
+
+/*
+ * Manuel Novoa III Dec 2000
+ *
+ * The previous vfnprintf routine was almost completely rewritten with the
+ * goal of fixing some shortcomings and reducing object size.
+ *
+ * The summary of changes:
+ *
+ * Converted print conversion specification parsing from one big switch
+ * to a method using string tables. This new method verifies that the
+ * conversion flags, field width, precision, qualifier, and specifier
+ * appear in the correct order. Many questionable specifications were
+ * accepted by the previous code. This new method also resulted in a
+ * substantial reduction in object size of about 330 bytes (20%) from
+ * the old version (1627 bytes) on i386, even with the following
+ * improvements.
+ *
+ * Implemented %n specifier as required by the standards.
+ * Implemented proper handling of precision for int types.
+ * Implemented # for hex and pointer, fixed error for octal rep of 0.
+ * Implemented return of -1 on stream error.
+ *
+ * Added optional support for the GNU extension %m which prints the string
+ * corresponding the errno.
+ *
+ * Added optional support for long long ints and unsigned long long ints
+ * using the conversion qualifiers "ll", "L", or "q" (like glibc).
+ *
+ * Added optional support for doubles in a very limited form. None of
+ * the formating options are obeyed. The string returned by __dtostr
+ * is printed directly.
+ *
+ * Converted to use my (un)signed long (long) to string routines, which are
+ * smaller than the previous functions and don't require static buffers.
+ *
+ * Other Modifications:
+ * Modified sprintf, snprintf, vsprintf, vsnprintf to share on fake-file.
+ */
+
+/*
+ * Manuel Novoa III Jan 2001
+ *
+ * Removed fake file from *s*printf functions because of possible problems
+ * if called recursively. Instead, have sprintf, snprintf, and vsprintf
+ * call vsnprintf which allocates a fake file on the stack.
+ * Removed WANT_FPUTC option. Always use standard putc macro to avoid
+ * problems with the fake file used by the *s*printf functions.
+ * Fixed bug parsing flags -- did not restart scan.
+ * Added function asprintf.
+ * Fixed 0-pad prefixing bug.
+ * Converted sizeof(int) == sizeof(long) tests to compile time vs run time.
+ * This saves 112 bytes of code on i386.
+ * Fixed precision bug -- when negative set to default.
+ * Added function fnprintf to support __dtostr.
+ * Added floating point support for doubles. Yeah!
+ *
+ *
+ * May 2001 Fixes from Johan Adolfsson (johan.adolfsson@axis.com)
+ * 1) printf("%c",0) returned 0 instead of 1.
+ * 2) unrolled loop in asprintf to reduce size and remove compile warning.
+ *
+ *
+ * June 2001
+ * 1) fix %p so that "0x" is prepended to outputed hex val
+ * 2) fix %p so that "(nil)" is output for (void *)0 to match glibc
+ *
+ * Sep 5, 2003
+ * Convert to new floating point conversion routine.
+ * Fix qualifier handling on integer and %n conversions.
+ * Add support for vsnprintf when in non-buffered/no-wchar configuration.
+ *
+ */
+
+/*****************************************************************************/
+/* OPTIONS */
+/*****************************************************************************/
+/* The optional support for long longs and doubles comes in two forms.
+ *
+ * 1) Normal (or partial for doubles) output support. Set to 1 to turn on.
+ * Adds about 130 bytes for doubles, about 220 bytes for long longs,
+ * and about 275 for both to the base code size of 1163 on i386.
+ */
+
+/* These are now set in uClibc_config.h based on Config. */
+/*
+#define __UCLIBC_HAS_FLOATS__ 1
+*/
+
+/* 2) An error message is inserted into the stream, an arg of the
+ * appropriate size is removed from the arglist, and processing
+ * continues. This is adds less code and may be useful in some
+ * cases. Set to 1 to turn on. Adds about 50 bytes for doubles,
+ * about 140 bytes for long longs, and about 175 bytes for both
+ * to the base code size of 1163 on i386.
+ */
+
+#define WANT_FLOAT_ERROR 0
+
+/*
+ * Set to support GNU extension of %m to print string corresponding to errno.
+ *
+ * Warning: This adds about 50 bytes (i386) to the code but it also pulls in
+ * strerror and the corresponding string table which together are about 3.8k.
+ */
+
+/* Now controlled by uClibc_stdio.h and set below. */
+/* #define WANT_GNU_ERRNO 0 */
+
+/**************************************************************************/
+
+#define _ISOC99_SOURCE /* for ULLONG primarily... */
+#include "_stdio.h"
+/* #include <stdio.h> */
+#include <stdarg.h>
+#include <limits.h>
+#include <stdint.h>
+#include <string.h>
+#include <errno.h>
+#include <ctype.h>
+#include <bits/uClibc_uintmaxtostr.h>
+#include <printf.h>
+
+#ifdef __UCLIBC_HAS_THREADS__
+#include <pthread.h>
+#endif /* __UCLIBC_HAS_THREADS__ */
+
+
+/* #undef __UCLIBC_HAS_FLOATS__ */
+/* #undef WANT_FLOAT_ERROR */
+/* #define WANT_FLOAT_ERROR 1 */
+
+/* #define __isdigit(c) (((unsigned int)(c - '0')) < 10) */
+
+#ifdef __UCLIBC_HAS_PRINTF_M_SPEC__
+#define WANT_GNU_ERRNO 1
+#else
+#define WANT_GNU_ERRNO 0
+#endif
+
+#undef PUTC
+#undef OUTNSTR
+#undef _outnstr
+
+#ifdef __STDIO_BUFFERS
+
+#define PUTC(C,F) putc_unlocked((C),(F))
+#define OUTNSTR _outnstr
+#define _outnstr(stream, string, len) __stdio_fwrite(string, len, stream)
+
+#else /* __STDIO_BUFFERS */
+
+typedef struct {
+ FILE f;
+ unsigned char *bufend; /* pointer to 1 past end of buffer */
+ unsigned char *bufpos;
+} __FILE_vsnprintf;
+
+#ifdef __UCLIBC_HAS_FLOATS__
+static void _outnstr(FILE *stream, const unsigned char *s, size_t n)
+{
+ __FILE_vsnprintf *f = (__FILE_vsnprintf *) stream;
+
+ if (!__STDIO_STREAM_IS_FAKE_VSNPRINTF_NB(&f->f)) {
+ __stdio_fwrite(s, n, &f->f);
+ } else if (f->bufend > f->bufpos) {
+ size_t r = f->bufend - f->bufpos;
+ if (r > n) {
+ r = n;
+ }
+ memcpy(f->bufpos, s, r);
+ f->bufpos += r;
+ }
+}
+#endif
+
+static void putc_unlocked_sprintf(int c, __FILE_vsnprintf *f)
+{
+ if (!__STDIO_STREAM_IS_FAKE_VSNPRINTF_NB(&f->f)) {
+ putc_unlocked(c, &f->f);
+ } else if (f->bufpos < f->bufend) {
+ *f->bufpos++ = c;
+ }
+}
+
+
+#define PUTC(C,F) putc_unlocked_sprintf((C),(__FILE_vsnprintf *)(F))
+#define OUTNSTR _outnstr
+
+#endif /* __STDIO_BUFFERS */
+
+#ifdef __UCLIBC_HAS_FLOATS__
+#include <float.h>
+#include <bits/uClibc_fpmax.h>
+
+typedef void (__fp_outfunc_t)(FILE *fp, intptr_t type, intptr_t len,
+ intptr_t buf);
+
+extern size_t _fpmaxtostr(FILE * fp, __fpmax_t x, struct printf_info *info,
+ __fp_outfunc_t fp_outfunc) attribute_hidden;
+
+static void _charpad(FILE * __restrict stream, int padchar, size_t numpad)
+{
+ /* TODO -- Use a buffer to cut down on function calls... */
+ char pad[1];
+
+ *pad = padchar;
+ while (numpad) {
+ OUTNSTR(stream, pad, 1);
+ --numpad;
+ }
+}
+
+static void _fp_out_narrow(FILE *fp, intptr_t type, intptr_t len, intptr_t buf)
+{
+ if (type & 0x80) { /* Some type of padding needed. */
+ int buflen = strlen((const char *) buf);
+ if ((len -= buflen) > 0) {
+ _charpad(fp, (type & 0x7f), len);
+ }
+ len = buflen;
+ }
+ if (len) {
+ OUTNSTR(fp, (const char *) buf, len);
+ }
+}
+
+#endif
+
+
+enum {
+ FLAG_PLUS = 0,
+ FLAG_MINUS_LJUSTIFY,
+ FLAG_HASH,
+ FLAG_0_PAD,
+ FLAG_SPACE,
+};
+
+/* layout 01234 */
+static const char spec[] = "+-#0 ";
+
+/**********************************************************************/
+
+extern void _store_inttype(void *dest, int desttype, uintmax_t val) attribute_hidden;
+extern uintmax_t _load_inttype(int desttype, const void *src, int uflag) attribute_hidden;
+
+/*
+ * In order to ease translation to what arginfo and _print_info._flags expect,
+ * we map: 0:int 1:char 2:longlong 4:long 8:short
+ * and then _flags |= (((q << 7) + q) & 0x701) and argtype |= (_flags & 0x701)
+ */
+
+#ifdef PDS
+#error PDS already defined!
+#endif
+#ifdef SS
+#error SS already defined!
+#endif
+#ifdef IMS
+#error IMS already defined!
+#endif
+
+#if PTRDIFF_MAX == INT_MAX
+#define PDS 0
+#elif PTRDIFF_MAX == LONG_MAX
+#define PDS 4
+#elif defined(LLONG_MAX) && (PTRDIFF_MAX == LLONG_MAX)
+#define PDS 8
+#else
+#error fix QUAL_CHARS ptrdiff_t entry 't'!
+#endif
+
+#if SIZE_MAX == UINT_MAX
+#define SS 0
+#elif SIZE_MAX == ULONG_MAX
+#define SS 4
+#elif defined(LLONG_MAX) && (SIZE_MAX == ULLONG_MAX)
+#define SS 8
+#else
+#error fix QUAL_CHARS size_t entries 'z', 'Z'!
+#endif
+
+#if INTMAX_MAX == INT_MAX
+#define IMS 0
+#elif INTMAX_MAX == LONG_MAX
+#define IMS 4
+#elif defined(LLONG_MAX) && (INTMAX_MAX == LLONG_MAX)
+#define IMS 8
+#else
+#error fix QUAL_CHARS intmax_t entry 'j'!
+#endif
+
+#define QUAL_CHARS { \
+ /* j:(u)intmax_t z:(s)size_t t:ptrdiff_t \0:int */ \
+ /* q:long_long Z:(s)size_t */ \
+ 'h', 'l', 'L', 'j', 'z', 't', 'q', 'Z', 0, \
+ 2, 4, 8, IMS, SS, PDS, 8, SS, 0, /* TODO -- fix!!! */\
+ 1, 8 \
+}
+
+static const char qual_chars[] = QUAL_CHARS;
+
+/* static const char qual[] = "hlLq"; */
+/**********************************************************************/
+
+#if !defined(__UCLIBC_HAS_FLOATS__) && WANT_FLOAT_ERROR
+static const char dbl_err[] = "<DOUBLE>";
+#endif
+
+#if defined(__UCLIBC_HAS_FLOATS__) || WANT_FLOAT_ERROR
+/* layout 012345678901234567 */
+static const char u_spec[] = "%nbopxXudicsfgGeEaA";
+#else
+/* layout 0123456789012 */
+static const char u_spec[] = "%nbopxXudics";
+#endif
+
+/* WARNING: u_spec and u_radix need to stay in agreement!!! */
+/* u_radix[i] <-> u_spec[i+2] for unsigned entries only */
+static const char u_radix[] = "\x02\x08\x10\x10\x10\x0a";
+
+int vfprintf(FILE * __restrict op, register const char * __restrict fmt,
+ va_list ap)
+{
+ union {
+#ifdef LLONG_MAX
+ long long ll;
+#endif
+#if LONG_MAX != INT_MAX
+ long l;
+#endif
+ int i;
+ } intarg;
+ int i, cnt, dataargtype, len;
+ const void *argptr = argptr; /* ok to be initialized. */
+ register char *p;
+ const char *fmt0;
+ int preci, width;
+#define upcase i
+ int radix, dpoint /*, upcase*/;
+ char tmp[65]; /* TODO - determine needed size from headers */
+ char flag[sizeof(spec)];
+ __STDIO_AUTO_THREADLOCK_VAR;
+
+ __STDIO_AUTO_THREADLOCK(op);
+
+ __STDIO_STREAM_VALIDATE(op);
+
+ cnt = 0;
+
+ if (__STDIO_STREAM_IS_NARROW_WRITING(op)
+ || !__STDIO_STREAM_TRANS_TO_WRITE(op, __FLAG_NARROW)
+ ) {
+
+ while (*fmt) {
+ if (*fmt == '%') {
+ fmt0 = fmt; /* save our position in case of bad format */
+ ++fmt;
+ width = -1; /* min field width */
+ preci = -5; /* max string width or mininum digits */
+ radix = 10; /* number base */
+ dpoint = 0; /* found decimal point */
+
+ /* init flags */
+ for (p =(char *) spec ; *p ; p++) {
+ flag[p-spec] = '\0';
+ }
+ flag[FLAG_0_PAD] = ' ';
+
+ /* process optional flags */
+ for (p = (char *)spec ; *p ; ) {
+ if (*fmt == *p) {
+ flag[p-spec] = *fmt++;
+ p = (char *)spec; /* restart scan */
+ } else {
+ p++;
+ }
+ }
+
+ if (!flag[FLAG_PLUS]) {
+ flag[FLAG_PLUS] = flag[FLAG_SPACE];
+ }
+
+ /* process optional width and precision */
+ do {
+ if (*fmt == '.') {
+ ++fmt;
+ dpoint = 1;
+ }
+ if (*fmt == '*') { /* parameter width value */
+ ++fmt;
+ i = va_arg(ap, int);
+ } else {
+ for ( i = 0 ; (*fmt >= '0') && (*fmt <= '9') ; ++fmt ) {
+ i = (i * 10) + (*fmt - '0');
+ }
+ }
+
+ if (dpoint) {
+ preci = i;
+ if (i<0) {
+ preci = -5;
+ }
+ } else {
+ width = i;
+ if (i<0) {
+ width = -i;
+ flag[FLAG_MINUS_LJUSTIFY] = 1;
+ }
+ }
+ } while ((*fmt == '.') && !dpoint );
+
+ /* process optional qualifier */
+ p = (char *) qual_chars;
+ do {
+ if (*fmt == *p) {
+ ++fmt;
+ break;
+ }
+ } while (*++p);
+ if ((p - qual_chars < 2) && (*fmt == *p)) {
+ p += ((sizeof(qual_chars)-2) / 2);
+ ++fmt;
+ }
+ dataargtype = ((int)(p[(sizeof(qual_chars)-2) / 2])) << 8;
+
+#if WANT_GNU_ERRNO
+ if (*fmt == 'm') {
+ flag[FLAG_PLUS] = '\0';
+ flag[FLAG_0_PAD] = ' ';
+ p = __glibc_strerror_r(errno, tmp, sizeof(tmp));
+ goto print;
+ }
+#endif
+
+ /* process format specifier */
+ for (p = (char *) u_spec ; *p ; p++) {
+ if (*fmt != *p) continue;
+ if (p-u_spec < 1) { /* print a % */
+ goto charout;
+ }
+ if (p-u_spec < 2) { /* store output count in int ptr */
+ _store_inttype(va_arg(ap, void *),
+ dataargtype,
+ (intmax_t) (cnt));
+ goto nextfmt;
+ }
+
+ if (p-u_spec < 10) {
+ if (*p == 'p') {
+#if INTPTR_MAX == INT_MAX
+ dataargtype = 0;
+#else
+#error Fix dataargtype for pointers!
+#endif
+ }
+
+ switch(dataargtype) {
+ case (PA_INT|PA_FLAG_LONG_LONG):
+#ifdef LLONG_MAX
+ intarg.ll = va_arg(ap, long long);
+ argptr = &intarg.ll;
+ break;
+#endif
+ case (PA_INT|PA_FLAG_LONG):
+#if LONG_MAX != INT_MAX
+ intarg.l = va_arg(ap, long);
+ argptr = &intarg.l;
+ break;
+#endif
+ default:
+ intarg.i = va_arg(ap, int);
+ argptr = &intarg.i;
+ break;
+ }
+ }
+
+ if (p-u_spec < 8) { /* unsigned conversion */
+ radix = u_radix[p-u_spec-2];
+ upcase = ((*p == 'x') ? __UIM_LOWER : __UIM_UPPER);
+ if (*p == 'p') {
+ upcase = __UIM_LOWER;
+ flag[FLAG_HASH] = 'p';
+ }
+ p = _uintmaxtostr(tmp + sizeof(tmp) - 1,
+ (uintmax_t)
+ _load_inttype(dataargtype, argptr, radix),
+ radix, upcase);
+
+ flag[FLAG_PLUS] = '\0'; /* meaningless for unsigned */
+ if (*p != '0') { /* non-zero */
+ if (flag[FLAG_HASH]) {
+ if (radix == 8) {
+ *--p = '0'; /* add leadding zero */
+ } else if (radix != 10) { /* either 2 or 16 */
+ flag[FLAG_PLUS] = '0';
+ *--p = 'b';
+ if (radix == 16) {
+ *p = 'x';
+ if (*fmt == 'X') {
+ *p = 'X';
+ }
+ }
+ }
+ }
+ } else if (flag[FLAG_HASH] == 'p') { /* null pointer */
+ p = "(nil)";
+ }
+ } else if (p-u_spec < 10) { /* signed conversion */
+ p = _uintmaxtostr(tmp + sizeof(tmp) - 1,
+ (uintmax_t)
+ _load_inttype(dataargtype, argptr, -radix),
+ -radix, upcase);
+
+ } else if (p-u_spec < 12) { /* character or string */
+ flag[FLAG_PLUS] = '\0';
+ flag[FLAG_0_PAD] = ' ';
+ if (*p == 'c') { /* character */
+ p = tmp;
+ *p = va_arg(ap, int);
+ /* This takes care of the "%c",0 case */
+ len = 1;
+ goto print_len_set;
+ } else { /* string */
+ p = va_arg(ap, char *);
+ if (!p) {
+ p = "(null)";
+ preci = 6;
+ } else {
+ if (preci < 0) {
+ preci = INT_MAX;
+ }
+ }
+ len = strnlen(p, preci);
+ goto print_len_set;
+ }
+#if defined(__UCLIBC_HAS_FLOATS__) || WANT_FLOAT_ERROR
+ } else if (p-u_spec < 27) { /* floating point */
+#endif /* defined(__UCLIBC_HAS_FLOATS__) || WANT_FLOAT_ERROR */
+#if defined(__UCLIBC_HAS_FLOATS__)
+ struct printf_info info;
+ if (preci < 0) {
+ preci = 6;
+ }
+ info.width = width;
+ info.prec = preci;
+ info.spec = *fmt;
+ info.pad = flag[FLAG_0_PAD];
+ info._flags = 0;
+ if (flag[FLAG_PLUS] == '+') {
+ PRINT_INFO_SET_FLAG(&info,showsign);
+ } else if (flag[FLAG_PLUS] == ' ') {
+ PRINT_INFO_SET_FLAG(&info,space);
+ }
+ if (flag[FLAG_HASH]) {
+ PRINT_INFO_SET_FLAG(&info,alt);
+ }
+ if (flag[FLAG_MINUS_LJUSTIFY]) {
+ PRINT_INFO_SET_FLAG(&info,left);
+ }
+#if 1
+ cnt += _fpmaxtostr(op,
+ (__fpmax_t)
+ ((dataargtype == (8 << 8))
+ ? va_arg(ap, long double)
+ : (long double) va_arg(ap, double)),
+ &info, _fp_out_narrow);
+#else
+ cnt += _fpmaxtostr(op,
+ (__fpmax_t)
+ ((lval > 1)
+ ? va_arg(ap, long double)
+ : (long double) va_arg(ap, double)),
+ &info, _fp_out_narrow);
+#endif
+ goto nextfmt;
+#elif WANT_FLOAT_ERROR
+ (void) ((lval > 1) ? va_arg(ap, long double)
+ : va_arg(ap, double)); /* carry on */
+ p = (char *) dbl_err;
+#endif /* defined(__UCLIBC_HAS_FLOATS__) */
+ }
+
+#if WANT_GNU_ERRNO
+ print:
+#endif
+ { /* this used to be printfield */
+ /* cheaper than strlen call */
+/* for ( len = 0 ; p[len] ; len++ ) { } */
+ len = strnlen(p, SIZE_MAX);
+ print_len_set:
+ if ((*p == '-')
+#if WANT_GNU_ERRNO
+ && (*fmt != 'm')
+#endif
+ && (*fmt != 's')) {
+ flag[FLAG_PLUS] = *p++;
+ --len;
+ }
+ if (flag[FLAG_PLUS]) {
+ ++len;
+ ++preci;
+ if (flag[FLAG_PLUS] == '0') { /* base 16 */
+ ++preci; /* account for x or X */
+ }
+ }
+
+ if (preci >= 0) {
+ if ((*fmt == 's')
+#if WANT_GNU_ERRNO
+ || (*fmt == 'm')
+#endif
+ ) {
+ if (len > preci) {
+ len = preci;
+ } else {
+ preci = len;
+ }
+ }
+ preci -= len;
+ if (preci < 0) {
+ preci = 0;
+ }
+ width -= preci;
+ }
+
+ width -= len;
+ if (width < 0) {
+ width = 0;
+ }
+
+ if (preci < 0) {
+ preci = 0;
+ if (!flag[FLAG_MINUS_LJUSTIFY]
+ /* && flag[FLAG_PLUS] */
+ && (flag[FLAG_0_PAD] == '0')) {
+ preci = width;
+ width = 0;
+ }
+ }
+
+ while (width + len + preci) {
+ unsigned char ch;
+ /* right padding || left padding */
+ if ((!len && !preci)
+ || (width && !flag[FLAG_MINUS_LJUSTIFY])) {
+ ch = ' ';
+ --width;
+ } else if (flag[FLAG_PLUS]) {
+ ch = flag[FLAG_PLUS]; /* sign */
+ if (flag[FLAG_PLUS]=='0') { /* base 16 case */
+ flag[FLAG_PLUS] = *p++; /* get the x|X */
+ } else {
+ flag[FLAG_PLUS] = '\0';
+ }
+ --len;
+ } else if (preci) {
+ ch = '0';
+ --preci;
+ } else {
+ ch = *p++; /* main field */
+ --len;
+ }
+ ++cnt;
+ PUTC(ch, op);
+ }
+ }
+ goto nextfmt;
+ }
+
+ fmt = fmt0; /* this was an illegal format */
+ }
+
+ charout:
+ ++cnt;
+ PUTC(*fmt, op); /* normal char out */
+
+ nextfmt:
+ ++fmt;
+ }
+
+ }
+
+ i = (__FERROR_UNLOCKED(op)) ? -1 : cnt;
+
+ __STDIO_STREAM_VALIDATE(op);
+
+ __STDIO_AUTO_THREADUNLOCK(op);
+
+ return i;
+}
+libc_hidden_def(vfprintf)