URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [uClibc/] [libc/] [stdio/] [printf.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

/*  Copyright (C) 2002, 2003     Manuel Novoa III
 *  My stdio library for linux and (soon) elks.
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Library General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Library General Public License for more details.
 *
 *  You should have received a copy of the GNU Library General Public
 *  License along with this library; if not, write to the Free
 *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
/* This code needs a lot of clean up.  Some of that is on hold until uClibc
 * gets a better configuration system (on Erik's todo list).
 * The other cleanup will take place during the implementation/integration of
 * the wide char (un)formatted i/o functions which I'm currently working on.
 */
 
/*  ATTENTION!   ATTENTION!   ATTENTION!   ATTENTION!   ATTENTION!
 *
 *  This code is currently under development.  Also, I plan to port
 *  it to elks which is a 16-bit environment with a fairly limited
 *  compiler.  Therefore, please refrain from modifying this code
 *  and, instead, pass any bug-fixes, etc. to me.  Thanks.  Manuel
 *
 *  ATTENTION!   ATTENTION!   ATTENTION!   ATTENTION!   ATTENTION! */
 
 
/* April 1, 2002
 * Initialize thread locks for fake files in vsnprintf and vdprintf.
 *    reported by Erik Andersen (andersen@codepoet.com)
 * Fix an arg promotion handling bug in _do_one_spec for %c.
 *    reported by Ilguiz Latypov <ilatypov@superbt.com>
 *
 * May 10, 2002
 * Remove __isdigit and use new ctype.h version.
 * Add conditional setting of QUAL_CHARS for size_t and ptrdiff_t.
 *
 * Aug 16, 2002
 * Fix two problems that showed up with the python 2.2.1 tests; one
 *    involving %o and one involving %f.
 *
 * Oct 28, 2002
 * Fix a problem in vasprintf (reported by vodz a while back) when built
 *    without custom stream support.  In that case, it is necessary to do
 *    a va_copy.
 * Make sure each va_copy has a matching va_end, as required by C99.
 *
 * Nov 4, 2002
 * Add locale-specific grouping support for integer decimal conversion.
 * Add locale-specific decimal point support for floating point conversion.
 *   Note: grouping will have to wait for _dtostr() rewrite.
 * Add printf wchar support for %lc (%C) and %ls (%S).
 * Require printf format strings to be valid multibyte strings beginning and
 *   ending in their initial shift state, as per the stds.
 *
 * Nov 21, 2002
 * Add *wprintf functions.  Currently they don't support floating point
 *   conversions.  That will wait until the rewrite of _dtostr.
 *
 * Aug 1, 2003
 * Optional hexadecimal float notation support for %a/%A.
 * Floating point output now works for *wprintf.
 * Support for glibc locale-specific digit grouping for floats.
 * Misc bug fixes.
 *
 * Aug 31, 2003
 * Fix precision bug for %g conversion specifier when using %f style.
 *
 * Sep 5, 2003
 * Implement *s*scanf for the non-buffered stdio case with old_vfprintf.
 *
 * Sep 23, 2003
 * vfprintf was not always checking for narrow stream orientation.
 */
 
/* TODO:
 *
 * Should we validate that *printf format strings are valid multibyte
 *   strings in the current locale?  ANSI/ISO C99 seems to imply this
 *   and Plauger's printf implementation in his Standard C Library book
 *   treats this as an error.
 */
 
 
#define _ISOC99_SOURCE                  /* for ULLONG primarily... */
#define _GNU_SOURCE
#define _STDIO_UTILITY                  /* We're using _uintmaxtostr. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <ctype.h>
#include <limits.h>
#include <stdarg.h>
#include <assert.h>
#include <stdint.h>
#include <errno.h>
#include <locale.h>
 
#define __PRINTF_INFO_NO_BITFIELD
#include <printf.h>
 
#ifdef __STDIO_THREADSAFE
#include <stdio_ext.h>
#include <pthread.h>
#endif /* __STDIO_THREADSAFE */
 
#ifdef __UCLIBC_HAS_WCHAR__
#include <wchar.h>
#endif /* __UCLIBC_HAS_WCHAR__ */
 
/* Some older or broken gcc toolchains define LONG_LONG_MAX but not
 * LLONG_MAX.  Since LLONG_MAX is part of the standard, that's what
 * we use.  So complain if we do not have it but should.
 */
#if !defined(LLONG_MAX) && defined(LONG_LONG_MAX)
#error Apparently, LONG_LONG_MAX is defined but LLONG_MAX is not.  You need to fix your toolchain headers to support the standard macros for (unsigned) long long.
#endif
 
/**********************************************************************/
/* These provide some control over printf's feature set */
 
/* This is undefined below depeding on uClibc's configuration. */
#define __STDIO_PRINTF_FLOAT 1
 
/* Now controlled by uClibc_stdio.h. */
/* #define __STDIO_PRINTF_M_SUPPORT */
 
 
/**********************************************************************/
 
#if defined(__UCLIBC__) && !defined(__UCLIBC_HAS_FLOATS__)
#undef __STDIO_PRINTF_FLOAT
#endif
 
#ifdef __BCC__
#undef __STDIO_PRINTF_FLOAT
#endif
 
#ifdef __STDIO_PRINTF_FLOAT
#include <float.h>
#include <bits/uClibc_fpmax.h>
#else  /* __STDIO_PRINTF_FLOAT */
#undef L__fpmaxtostr
#endif /* __STDIO_PRINTF_FLOAT */
 
 
#undef __STDIO_HAS_VSNPRINTF
#if defined(__STDIO_BUFFERS) || defined(__USE_OLD_VFPRINTF__) || defined(__STDIO_GLIBC_CUSTOM_STREAMS)
#define __STDIO_HAS_VSNPRINTF 1
#endif
 
/**********************************************************************/
 
/* Now controlled by uClibc_stdio.h. */
/* #define __STDIO_GLIBC_CUSTOM_PRINTF */
 
/* TODO -- move these to a configuration section? */
#define MAX_FIELD_WIDTH         4095
 
#ifdef __UCLIBC_MJN3_ONLY__
#ifdef L_register_printf_function
/* emit only once */
#warning WISHLIST: Make MAX_USER_SPEC configurable?
#warning WISHLIST: Make MAX_ARGS_PER_SPEC configurable?
#endif
#endif /* __UCLIBC_MJN3_ONLY__ */
 
#ifdef __STDIO_GLIBC_CUSTOM_PRINTF
 
#define MAX_USER_SPEC       10
#define MAX_ARGS_PER_SPEC    5
 
#else  /* __STDIO_GLIBC_CUSTOM_PRINTF */
 
#undef MAX_USER_SPEC
#define MAX_ARGS_PER_SPEC    1
 
#endif /* __STDIO_GLIBC_CUSTOM_PRINTF */
 
#if MAX_ARGS_PER_SPEC < 1
#error MAX_ARGS_PER_SPEC < 1!
#undef MAX_ARGS_PER_SPEC
#define MAX_ARGS_PER_SPEC    1
#endif
 
#if defined(NL_ARGMAX) && (NL_ARGMAX < 9)
#error NL_ARGMAX < 9!
#endif
 
#if defined(NL_ARGMAX) && (NL_ARGMAX >= (MAX_ARGS_PER_SPEC + 2))
#define MAX_ARGS        NL_ARGMAX
#else
/* N for spec itself, plus 1 each for width and precision */
#define MAX_ARGS        (MAX_ARGS_PER_SPEC + 2)
#endif
 
 
/**********************************************************************/
/* Deal with pre-C99 compilers. */
 
#ifndef va_copy
 
#ifdef __va_copy
#define va_copy(A,B)    __va_copy(A,B)
#else
        /* TODO -- maybe create a bits/vacopy.h for arch specific versions
         * to ensure we get the right behavior?  Either that or fall back
         * on the portable (but costly in size) method of using a va_list *.
         * That means a pointer derefs in the va_arg() invocations... */
#warning Neither va_copy (C99/SUSv3) or __va_copy is defined.  Using a simple copy instead.  But you should really check that this is appropriate...
        /* the glibc manual suggests that this will usually suffice when
        __va_copy doesn't exist.  */
#define va_copy(A,B)    A = B
#endif
 
#endif /* va_copy */
 
/**********************************************************************/
 
#define __PA_FLAG_INTMASK \
        (__PA_FLAG_CHAR|PA_FLAG_SHORT|__PA_FLAG_INT|PA_FLAG_LONG|PA_FLAG_LONG_LONG)
 
#ifdef __STDIO_GLIBC_CUSTOM_PRINTF
extern printf_function _custom_printf_handler[MAX_USER_SPEC];
extern printf_arginfo_function *_custom_printf_arginfo[MAX_USER_SPEC];
extern char *_custom_printf_spec;
#endif /* __STDIO_GLIBC_CUSTOM_PRINTF */
 
/**********************************************************************/
 
#define SPEC_FLAGS              " +0-#'I"
enum {
        FLAG_SPACE              =       0x01,
        FLAG_PLUS               =       0x02,   /* must be 2 * FLAG_SPACE */
        FLAG_ZERO               =       0x04,
        FLAG_MINUS              =       0x08,   /* must be 2 * FLAG_ZERO */
        FLAG_HASH               =       0x10,
        FLAG_THOUSANDS  =       0x20,
        FLAG_I18N               =       0x40,   /* only works for d, i, u */
        FLAG_WIDESTREAM =   0x80
};
 
/**********************************************************************/
 
/* float layout          01234567890123456789   TODO: B?*/
#define SPEC_CHARS              "npxXoudifFeEgGaACScs"
enum {
        CONV_n = 0,
        CONV_p,
        CONV_x, CONV_X, CONV_o, CONV_u, CONV_d, CONV_i,
        CONV_f, CONV_F, CONV_e, CONV_E, CONV_g, CONV_G, CONV_a, CONV_A,
        CONV_C, CONV_S, CONV_c, CONV_s,
#ifdef __STDIO_PRINTF_M_SUPPORT
        CONV_m,
#endif
        CONV_custom0                            /* must be last */
};
 
/*                         p   x   X  o   u   d   i */
#define SPEC_BASE               { 16, 16, 16, 8, 10, 10, 10 }
 
#define SPEC_RANGES             { CONV_n, CONV_p, CONV_i, CONV_A, \
                                                  CONV_C, CONV_S, CONV_c, CONV_s, CONV_custom0 }
 
#define SPEC_OR_MASK             { \
        /* n */                 (PA_FLAG_PTR|PA_INT), \
        /* p */                 PA_POINTER, \
        /* oxXudi */    PA_INT, \
        /* fFeEgGaA */  PA_DOUBLE, \
        /* C */                 PA_WCHAR, \
        /* S */                 PA_WSTRING, \
        /* c */                 PA_CHAR, \
        /* s */                 PA_STRING, \
}
 
#define SPEC_AND_MASK           { \
        /* n */                 (PA_FLAG_PTR|__PA_INTMASK), \
        /* p */                 PA_POINTER, \
        /* oxXudi */    (__PA_INTMASK), \
        /* fFeEgGaA */  (PA_FLAG_LONG_DOUBLE|PA_DOUBLE), \
        /* C */                 (PA_WCHAR), \
        /* S */                 (PA_WSTRING), \
        /* c */                 (PA_CHAR), \
        /* s */                 (PA_STRING), \
}
 
/**********************************************************************/
/*
 * 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)
 */
 
/* TODO -- Fix the table below to take into account stdint.h. */
/*  #ifndef LLONG_MAX */
/*  #error fix QUAL_CHARS for no long long!  Affects 'L', 'j', 'q', 'll'. */
/*  #else */
/*  #if LLONG_MAX != INTMAX_MAX */
/*  #error fix QUAL_CHARS intmax_t entry 'j'! */
/*  #endif */
/*  #endif */
 
#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 \
}
 
/**********************************************************************/
 
#ifdef __STDIO_VA_ARG_PTR
#ifdef __BCC__
#define __va_arg_ptr(ap,type)           (((type *)(ap += sizeof(type))) - 1)
#endif
 
#if 1
#ifdef __GNUC__
/* TODO -- need other than for 386 as well! */
 
#ifndef __va_rounded_size
#define __va_rounded_size(TYPE)  \
  (((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))
#endif
#define __va_arg_ptr(AP, TYPE)                                          \
 (AP = (va_list) ((char *) (AP) + __va_rounded_size (TYPE)),    \
  ((void *) ((char *) (AP) - __va_rounded_size (TYPE))))
#endif
#endif
#endif /* __STDIO_VA_ARG_PTR */
 
#ifdef __va_arg_ptr
#define GET_VA_ARG(AP,F,TYPE,ARGS)      (*(AP) = __va_arg_ptr(ARGS,TYPE))
#define GET_ARG_VALUE(AP,F,TYPE)        (*((TYPE *)(*(AP))))
#else
typedef union {
        wchar_t wc;
        unsigned int u;
        unsigned long ul;
#ifdef ULLONG_MAX
        unsigned long long ull;
#endif
#ifdef __STDIO_PRINTF_FLOAT
        double d;
        long double ld;
#endif /* __STDIO_PRINTF_FLOAT */
        void *p;
} argvalue_t;
 
#define GET_VA_ARG(AU,F,TYPE,ARGS)      (AU->F = va_arg(ARGS,TYPE))
#define GET_ARG_VALUE(AU,F,TYPE)        ((TYPE)((AU)->F))
#endif
 
typedef struct {
        const char *fmtpos;                     /* TODO: move below struct?? */
        struct printf_info info;
#ifdef NL_ARGMAX
        int maxposarg;                          /* > 0 if args are positional, 0 if not, -1 if unknown */
#endif /* NL_ARGMAX */
        int num_data_args;                      /* TODO: use sentinal??? */
        unsigned int conv_num;
        unsigned char argnumber[4]; /* width | prec | 1st data | unused */
        int argtype[MAX_ARGS];
        va_list arg;
#ifdef __va_arg_ptr
        void *argptr[MAX_ARGS];
#else
/* if defined(NL_ARGMAX) || defined(__STDIO_GLIBC_CUSTOM_PRINTF) */
        /* While this is wasteful of space in the case where pos args aren't
         * enabled, it is also needed to support custom printf handlers. */
        argvalue_t argvalue[MAX_ARGS];
#endif
} ppfs_t;                                               /* parse printf format state */
 
/**********************************************************************/
 
/* TODO: fix printf to return 0 and set errno if format error.  Standard says
   only returns -1 if sets error indicator for the stream. */
 
#ifdef __STDIO_PRINTF_FLOAT
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);
#endif
 
extern int _ppfs_init(ppfs_t *ppfs, const char *fmt0); /* validates */
extern void _ppfs_prepargs(ppfs_t *ppfs, va_list arg); /* sets posargptrs */
extern void _ppfs_setargs(ppfs_t *ppfs); /* sets argptrs for current spec */
extern int _ppfs_parsespec(ppfs_t *ppfs); /* parses specifier */
 
extern void _store_inttype(void *dest, int desttype, uintmax_t val);
extern uintmax_t _load_inttype(int desttype, const void *src, int uflag);
 
/**********************************************************************/
#ifdef L_parse_printf_format
 
/* NOTE: This function differs from the glibc version in that parsing stops
 * upon encountering an invalid conversion specifier.  Since this is the way
 * my printf functions work, I think it makes sense to do it that way here.
 * Unfortunately, since glibc sets the return type as size_t, we have no way
 * of returning that the template is illegal, other than returning 0.
 */
 
size_t parse_printf_format(register const char *template,
                                                   size_t n, register int *argtypes)
{
        ppfs_t ppfs;
        size_t i;
        size_t count = 0;
 
        if (_ppfs_init(&ppfs, template) >= 0) {
#ifdef NL_ARGMAX
                if (ppfs.maxposarg > 0)  { /* Using positional args. */
                        count = ppfs.maxposarg;
                        if (n > count) {
                                n = count;
                        }
                        for (i = 0 ; i < n ; i++) {
                                *argtypes++ = ppfs.argtype[i];
                        }
                } else {                                /* Not using positional args. */
#endif /* NL_ARGMAX */
                        while (*template) {
                                if ((*template == '%') && (*++template != '%')) {
                                        ppfs.fmtpos = template;
                                        _ppfs_parsespec(&ppfs); /* Can't fail. */
                                        template = ppfs.fmtpos; /* Update to one past spec end. */
                                        if (ppfs.info.width == INT_MIN) {
                                                ++count;
                                                if (n > 0) {
                                                        *argtypes++ = PA_INT;
                                                        --n;
                                                }
                                        }
                                        if (ppfs.info.prec == INT_MIN) {
                                                ++count;
                                                if (n > 0) {
                                                        *argtypes++ = PA_INT;
                                                        --n;
                                                }
                                        }
                                        for (i = 0 ; i < ppfs.num_data_args ; i++) {
                                                if ((ppfs.argtype[i]) != __PA_NOARG) {
                                                        ++count;
                                                        if (n > 0) {
                                                                *argtypes++ = ppfs.argtype[i];
                                                                --n;
                                                        }
                                                }
                                        }
                                } else {
                                        ++template;
                                }
                        }
#ifdef NL_ARGMAX
                }
#endif /* NL_ARGMAX */
        }
 
        return count;
}
 
#endif
/**********************************************************************/
#ifdef L__ppfs_init
 
int _ppfs_init(register ppfs_t *ppfs, const char *fmt0)
{
        int r;
 
        /* First, zero out everything... argnumber[], argtype[], argptr[] */
        memset(ppfs, 0, sizeof(ppfs_t)); /* TODO: nonportable???? */
#ifdef NL_ARGMAX
        --ppfs->maxposarg;                      /* set to -1 */
#endif /* NL_ARGMAX */
        ppfs->fmtpos = fmt0;
#ifdef __UCLIBC_MJN3_ONLY__
#warning TODO: Make checking of the format string in C locale an option.
#endif
#ifdef __UCLIBC_HAS_LOCALE__
        /* To support old programs, don't check mb validity if in C locale. */
        if (((__UCLIBC_CURLOCALE_DATA).encoding) != __ctype_encoding_7_bit) {
                /* ANSI/ISO C99 requires format string to be a valid multibyte string
                 * beginning and ending in its initial shift state. */
                static const char invalid_mbs[] = "Invalid multibyte format string.";
                mbstate_t mbstate;
                const char *p;
                mbstate.mask = 0;        /* Initialize the mbstate. */
                p = fmt0;
                if (mbsrtowcs(NULL, &p, SIZE_MAX, &mbstate) == ((size_t)(-1))) {
                        ppfs->fmtpos = invalid_mbs;
                        return -1;
                }
        }
#endif /* __UCLIBC_HAS_LOCALE__ */
        /* now set all argtypes to no-arg */
        {
#if 1
                /* TODO - use memset here since already "paid for"? */
                register int *p = ppfs->argtype;
 
                r = MAX_ARGS;
                do {
                        *p++ = __PA_NOARG;
                } while (--r);
#else
                /* TODO -- get rid of this?? */
                register char *p = (char *) ((MAX_ARGS-1) * sizeof(int));
 
                do {
                        *((int *)(((char *)ppfs) + ((int)p) + offsetof(ppfs_t,argtype))) = __PA_NOARG;
                        p -= sizeof(int);
                } while (p);
#endif
        }
 
        /*
         * Run through the entire format string to validate it and initialize
         * the positional arg numbers (if any).
         */
        {
                register const char *fmt = fmt0;
 
                while (*fmt) {
                        if ((*fmt == '%') && (*++fmt != '%')) {
                                ppfs->fmtpos = fmt; /* back up to the '%' */
                                if ((r = _ppfs_parsespec(ppfs)) < 0) {
                                        return -1;
                                }
                                fmt = ppfs->fmtpos;     /* update to one past end of spec */
                        } else {
                                ++fmt;
                        }
                }
                ppfs->fmtpos = fmt0;            /* rewind */
        }
 
#ifdef NL_MAX_ARG
        /* If we have positional args, make sure we know all the types. */
        {
                register int *p = ppfs->argtype;
                r = ppfs->maxposarg;
                while (--r >= 0) {
                        if ( *p == __PA_NOARG ) { /* missing arg type!!! */
                                return -1;
                        }
                        ++p;
                }
        }
#endif /* NL_MAX_ARG */
 
        return 0;
}
#endif
/**********************************************************************/
#ifdef L__ppfs_prepargs
void _ppfs_prepargs(register ppfs_t *ppfs, va_list arg)
{
        int i;
 
        va_copy(ppfs->arg, arg);
 
#ifdef NL_ARGMAX
        if ((i = ppfs->maxposarg) > 0)  { /* init for positional args */
                ppfs->num_data_args = i;
                ppfs->info.width = ppfs->info.prec = ppfs->maxposarg = 0;
                _ppfs_setargs(ppfs);
                ppfs->maxposarg = i;
        }
#endif /* NL_ARGMAX */
}
#endif
/**********************************************************************/
#ifdef L__ppfs_setargs
 
void _ppfs_setargs(register ppfs_t *ppfs)
{
#ifdef __va_arg_ptr
        register void **p = ppfs->argptr;
#else
        register argvalue_t *p = ppfs->argvalue;
#endif
        int i;
 
#ifdef NL_ARGMAX
        if (ppfs->maxposarg == 0) {      /* initing for or no pos args */
#endif /* NL_ARGMAX */
                if (ppfs->info.width == INT_MIN) {
                        ppfs->info.width =
#ifdef __va_arg_ptr
                                *(int *)
#endif
                                GET_VA_ARG(p,u,unsigned int,ppfs->arg);
                }
                if (ppfs->info.prec == INT_MIN) {
                        ppfs->info.prec =
#ifdef __va_arg_ptr
                                *(int *)
#endif
                                GET_VA_ARG(p,u,unsigned int,ppfs->arg);
                }
                i = 0;
                while (i < ppfs->num_data_args) {
                        switch(ppfs->argtype[i++]) {
                                case (PA_INT|PA_FLAG_LONG_LONG):
#ifdef ULLONG_MAX
                                        GET_VA_ARG(p,ull,unsigned long long,ppfs->arg);
                                        break;
#endif
                                case (PA_INT|PA_FLAG_LONG):
#if ULONG_MAX != UINT_MAX
                                        GET_VA_ARG(p,ul,unsigned long,ppfs->arg);
                                        break;
#endif
                                case PA_CHAR:   /* TODO - be careful */
                                        /* ... users could use above and really want below!! */
                                case (PA_INT|__PA_FLAG_CHAR):/* TODO -- translate this!!! */
                                case (PA_INT|PA_FLAG_SHORT):
                                case PA_INT:
                                        GET_VA_ARG(p,u,unsigned int,ppfs->arg);
                                        break;
                                case PA_WCHAR:  /* TODO -- assume int? */
                                        /* we're assuming wchar_t is at least an int */
                                        GET_VA_ARG(p,wc,wchar_t,ppfs->arg);
                                        break;
#ifdef __STDIO_PRINTF_FLOAT
                                        /* PA_FLOAT */
                                case PA_DOUBLE:
                                        GET_VA_ARG(p,d,double,ppfs->arg);
                                        break;
                                case (PA_DOUBLE|PA_FLAG_LONG_DOUBLE):
                                        GET_VA_ARG(p,ld,long double,ppfs->arg);
                                        break;
#else  /* __STDIO_PRINTF_FLOAT */
                                case PA_DOUBLE:
                                case (PA_DOUBLE|PA_FLAG_LONG_DOUBLE):
                                        assert(0);
                                        continue;
#endif /* __STDIO_PRINTF_FLOAT */
                                default:
                                        /* TODO -- really need to ensure this can't happen */
                                        assert(ppfs->argtype[i-1] & PA_FLAG_PTR);
                                case PA_POINTER:
                                case PA_STRING:
                                case PA_WSTRING:
                                        GET_VA_ARG(p,p,void *,ppfs->arg);
                                        break;
                                case __PA_NOARG:
                                        continue;
                        }
                        ++p;
                }
#ifdef NL_ARGMAX
        } else {
                if (ppfs->info.width == INT_MIN) {
                        ppfs->info.width
                                = (int) GET_ARG_VALUE(p + ppfs->argnumber[0] - 1,u,unsigned int);
                }
                if (ppfs->info.prec == INT_MIN) {
                        ppfs->info.prec
                                = (int) GET_ARG_VALUE(p + ppfs->argnumber[1] - 1,u,unsigned int);
                }
        }
#endif /* NL_ARGMAX */
 
        /* Now we know the width and precision. */
        if (ppfs->info.width < 0) {
                ppfs->info.width = -ppfs->info.width;
                PRINT_INFO_SET_FLAG(&(ppfs->info),left);
                PRINT_INFO_CLR_FLAG(&(ppfs->info),space);
                ppfs->info.pad = ' ';
        }
#if 0
        /* NOTE -- keep neg for now so float knows! */
        if (ppfs->info.prec < 0) {       /* spec says treat as omitted. */
                /* so use default prec... 1 for everything but floats and strings. */
                ppfs->info.prec = 1;
        }
#endif
}
#endif
/**********************************************************************/
#ifdef L__ppfs_parsespec
 
/* Notes: argtype differs from glibc for the following:
 *         mine              glibc
 *  lc     PA_WCHAR          PA_CHAR       the standard says %lc means %C
 *  ls     PA_WSTRING        PA_STRING     the standard says %ls means %S
 *  {*}n   {*}|PA_FLAG_PTR   PA_FLAG_PTR   size of n can be qualified
 */
 
/* TODO: store positions of positional args */
 
/* TODO -- WARNING -- assumes aligned on integer boundaries!!! */
 
/* TODO -- disable if not using positional args!!! */
#define _OVERLAPPING_DIFFERENT_ARGS
 
/* TODO -- rethink this -- perhaps we should set to largest type??? */
 
#ifdef _OVERLAPPING_DIFFERENT_ARGS 
 
#define PROMOTED_SIZE_OF(X)             ((sizeof(X) + sizeof(int) - 1) / sizeof(X))
 
static const short int type_codes[] = {
        __PA_NOARG,                                     /* must be first entry */
        PA_POINTER,
        PA_STRING,
        PA_WSTRING,
        PA_CHAR,
        PA_INT|PA_FLAG_SHORT,
        PA_INT,
        PA_INT|PA_FLAG_LONG,
        PA_INT|PA_FLAG_LONG_LONG,
        PA_WCHAR,
#ifdef __STDIO_PRINTF_FLOAT
        /* PA_FLOAT, */
        PA_DOUBLE,
        PA_DOUBLE|PA_FLAG_LONG_DOUBLE,
#endif /* __STDIO_PRINTF_FLOAT */
};
 
static const unsigned char type_sizes[] = {
        /* unknown type consumes no arg */
        0,                                                       /* must be first entry */
        PROMOTED_SIZE_OF(void *),
        PROMOTED_SIZE_OF(char *),
        PROMOTED_SIZE_OF(wchar_t *),
        PROMOTED_SIZE_OF(char),
        PROMOTED_SIZE_OF(short),
        PROMOTED_SIZE_OF(int),
        PROMOTED_SIZE_OF(long),
#ifdef ULLONG_MAX
        PROMOTED_SIZE_OF(long long),
#else
        PROMOTED_SIZE_OF(long),         /* TODO -- is this correct? (above too) */
#endif
        PROMOTED_SIZE_OF(wchar_t),
#ifdef __STDIO_PRINTF_FLOAT
        /* PROMOTED_SIZE_OF(float), */
        PROMOTED_SIZE_OF(double),
        PROMOTED_SIZE_OF(long double),
#endif /* __STDIO_PRINTF_FLOAT */
};
 
static int _promoted_size(int argtype)
{
        register const short int *p;
 
        /* note -- since any unrecognized type is treated as a pointer */
        p = type_codes + sizeof(type_codes)/sizeof(type_codes[0]);
        do {
                if (*--p == argtype) {
                        break;
                }
        } while (p > type_codes);
 
        return type_sizes[(int)(p - type_codes)];
}
 
static int _is_equal_or_bigger_arg(int curtype, int newtype)
{
        /* Quick test */
        if (newtype == __PA_NOARG) {
                return 0;
        }
        if ((curtype == __PA_NOARG) || (curtype == newtype)) {
                return 1;
        }
        /* Ok... slot is already filled and types are different in name. */
        /* So, compare promoted sizes of curtype and newtype args. */
        return _promoted_size(curtype) <= _promoted_size(newtype);
}
 
#else
 
#define _is_equal_or_bigger_arg(C,N)    (((C) == __PA_NOARG) || ((C) == (N)))
 
#endif
 
#ifdef __STDIO_GLIBC_CUSTOM_PRINTF
/* TODO - do this differently? */
static char _bss_custom_printf_spec[MAX_USER_SPEC]; /* 0-init'd for us.  */
 
char *_custom_printf_spec = _bss_custom_printf_spec;
printf_arginfo_function *_custom_printf_arginfo[MAX_USER_SPEC];
printf_function _custom_printf_handler[MAX_USER_SPEC];
#endif /* __STDIO_GLIBC_CUSTOM_PRINTF */
 
extern int _ppfs_parsespec(ppfs_t *ppfs)
{
        register const char *fmt;
        register const char *p;
        int preci;
        int width;
        int flags;
        int dataargtype;
        int i;
        int dpoint;
#ifdef NL_ARGMAX
        int maxposarg;
#endif /* NL_ARGMAX */
        int p_m_spec_chars;
        int n;
        int argtype[MAX_ARGS_PER_SPEC+2];
        int argnumber[3];                       /* width, precision, 1st data arg */
        static const char spec_flags[] = SPEC_FLAGS;
        static const char spec_chars[] = SPEC_CHARS;/* TODO: b? */
        static const char spec_ranges[] = SPEC_RANGES;
        static const short spec_or_mask[] = SPEC_OR_MASK;
        static const short spec_and_mask[] = SPEC_AND_MASK;
        static const char qual_chars[] = QUAL_CHARS;
#ifdef __UCLIBC_HAS_WCHAR__
        char buf[32];
#endif /* __UCLIBC_HAS_WCHAR__ */
 
        /* WIDE note: we can test against '%' here since we don't allow */
        /* WIDE note: other mappings of '%' in the wide char set. */
        preci = -1;
        argnumber[0] = 0;
        argnumber[1] = 0;
        argtype[0] = __PA_NOARG;
        argtype[1] = __PA_NOARG;
#ifdef NL_ARGMAX
        maxposarg = ppfs->maxposarg;
#endif /* NL_ARGMAX */
 
#ifdef __UCLIBC_HAS_WCHAR__
        /* This is somewhat lame, but saves a lot of code.  If we're dealing with
         * a wide stream, that means the format is a wchar string.  So, copy it
         * char-by-char into a normal char buffer for processing.  Make the buffer
         * (buf) big enough so that any reasonable format specifier will fit.
         * While there a legal specifiers that won't, the all involve duplicate
         * flags or outrageous field widths/precisions. */
        width = dpoint = 0;
        if ((flags = ppfs->info._flags & FLAG_WIDESTREAM) == 0) {
                fmt = ppfs->fmtpos;
        } else {
                fmt = buf + 1;
                i = 0;
                do {
                        if ((buf[i] = (char) (((wchar_t *) ppfs->fmtpos)[i-1]))
                                != (((wchar_t *) ppfs->fmtpos)[i-1])
                                ) {
                                return -1;
                        }
                } while (buf[i++]);
                buf[sizeof(buf)-1] = 0;
        }
#else  /* __UCLIBC_HAS_WCHAR__ */
        width = flags = dpoint = 0;
        fmt = ppfs->fmtpos;
#endif /* __UCLIBC_HAS_WCHAR__ */
 
        assert(fmt[-1] == '%');
        assert(fmt[0] != '%');
 
        /* Process arg pos and/or flags and/or width and/or precision. */
 width_precision:
        p = fmt;
        if (*fmt == '*') {
                argtype[-dpoint] = PA_INT;
                ++fmt;
        }
        i = 0;
        while (isdigit(*fmt)) {
                if (i < MAX_FIELD_WIDTH) { /* Avoid overflow. */
                        i = (i * 10) + (*fmt - '0');
                }
                ++fmt;
        }
        if (p[-1] == '%') { /* Check for a position. */
 
                /* TODO: if val not in range, then error */
 
#ifdef NL_ARGMAX
                if ((*fmt == '$') && (i > 0)) {/* Positional spec. */
                        ++fmt;
                        if (maxposarg == 0) {
                                return -1;
                        }
                        if ((argnumber[2] = i) > maxposarg) {
                                maxposarg = i;
                        }
                        /* Now fall through to check flags. */
                } else {
                        if (maxposarg > 0) {
#ifdef __STDIO_PRINTF_M_SUPPORT
#ifdef __UCLIBC_MJN3_ONLY__
#warning TODO: Support prec and width for %m when positional args used
                                /* Actually, positional arg processing will fail in general
                                 * for specifiers that don't require an arg. */
#endif /* __UCLIBC_MJN3_ONLY__ */
                                if (*fmt == 'm') {
                                        goto PREC_WIDTH;
                                }
#endif /* __STDIO_PRINTF_M_SUPPORT */
                                return -1;
                        }
                        maxposarg = 0;           /* Possible redundant store, but cuts size. */
 
                        if ((fmt > p) && (*p != '0')) {
                                goto PREC_WIDTH;
                        }
 
                        fmt = p;                        /* Back up for possible '0's flag. */
                        /* Now fall through to check flags. */
                }
#else  /* NL_ARGMAX */
                if (*fmt == '$') {              /* Positional spec. */
                        return -1;
                }
 
                if ((fmt > p) && (*p != '0')) {
                        goto PREC_WIDTH;
                }
 
                fmt = p;                        /* Back up for possible '0's flag. */
                /* Now fall through to check flags. */
#endif /* NL_ARGMAX */
 
        restart_flags:          /* Process flags. */
                i = 1;
                p = spec_flags;
 
                do {
                        if (*fmt == *p++) {
                                ++fmt;
                                flags |= i;
                                goto restart_flags;
                        }
                        i += i;                         /* Better than i <<= 1 for bcc */
                } while (*p);
                i = 0;
 
                /* If '+' then ignore ' ', and if '-' then ignore '0'. */
                /* Note: Need to ignore '0' when prec is an arg with val < 0, */
                /*       but that test needs to wait until the arg is retrieved. */
                flags &= ~((flags & (FLAG_PLUS|FLAG_MINUS)) >> 1);
                /* Note: Ignore '0' when prec is specified < 0 too (in printf). */
 
                if (fmt[-1] != '%') {   /* If we've done anything, loop for width. */
                        goto width_precision;
                }
        }
 PREC_WIDTH:
        if (*p == '*') {                        /* Prec or width takes an arg. */
#ifdef NL_ARGMAX
                if (maxposarg) {
                        if ((*fmt++ != '$') || (i <= 0)) {
                                /* Using pos args and no $ or invalid arg number. */
                                return -1;
                        }
                        argnumber[-dpoint] = i;
                } else
#endif /* NL_ARGMAX */
                if (++p != fmt) {
                         /* Not using pos args but digits followed *. */
                        return -1;
                }
                i = INT_MIN;
        }
 
        if (!dpoint) {
                width = i;
                if (*fmt == '.') {
                        ++fmt;
                        dpoint = -1;            /* To use as default precison. */
                        goto width_precision;
                }
        } else {
                preci = i;
        }
 
        /* Process qualifier. */
        p = 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;
 
        /* Process conversion specifier. */
        if (!*fmt) {
                return -1;
        }
 
        p = spec_chars;
 
        do {
                if (*fmt == *p) {
                        p_m_spec_chars = p - spec_chars;
 
                        if ((p_m_spec_chars >= CONV_c)
                                && (dataargtype & PA_FLAG_LONG)) {
                                p_m_spec_chars -= 2; /* lc -> C and ls -> S */
                        }
 
                        ppfs->conv_num = p_m_spec_chars;
                        p = spec_ranges-1;
                        while (p_m_spec_chars > *++p) {}
 
                        i = p - spec_ranges;
                        argtype[2] = (dataargtype | spec_or_mask[i]) & spec_and_mask[i];
                        p = spec_chars;
                        break;
                }
        } while(*++p);
 
        ppfs->info.spec = *fmt;
        ppfs->info.prec = preci;
        ppfs->info.width = width;
        ppfs->info.pad = ((flags & FLAG_ZERO) ? '0' : ' ');
        ppfs->info._flags = (flags & ~FLAG_ZERO) | (dataargtype & __PA_INTMASK);
        ppfs->num_data_args = 1;
 
        if (!*p) {
#ifdef __STDIO_PRINTF_M_SUPPORT
                if (*fmt == 'm') {
                        ppfs->conv_num = CONV_m;
                        ppfs->num_data_args = 0;
                        goto DONE;
                }
#endif
#ifdef __STDIO_GLIBC_CUSTOM_PRINTF
 
                /* Handle custom arg -- WARNING -- overwrites p!!! */
                ppfs->conv_num = CONV_custom0;
                p = _custom_printf_spec;
                do {
                        if (*p == *fmt) {
                                if ((ppfs->num_data_args
                                         = ((*_custom_printf_arginfo[(int)(p-_custom_printf_spec)])
                                                (&(ppfs->info), MAX_ARGS_PER_SPEC, argtype+2)))
                                        > MAX_ARGS_PER_SPEC) {
                                        break;          /* Error -- too many args! */
                                }
                                goto DONE;
                        }
                } while (++p < (_custom_printf_spec + MAX_USER_SPEC));
#endif /* __STDIO_GLIBC_CUSTOM_PRINTF */
                /* Otherwise error. */
                return -1;
        }
 
#if defined(__STDIO_GLIBC_CUSTOM_PRINTF) || defined(__STDIO_PRINTF_M_SUPPORT)
 DONE:
#endif
 
#ifdef NL_ARGMAX
        if (maxposarg > 0) {
                i = 0;
                do {
                        /* Update maxposarg and check that NL_ARGMAX is not exceeded. */
                        n = ((i <= 2)
                                 ? (ppfs->argnumber[i] = argnumber[i])
                                 : argnumber[2] + (i-2));
                        if (n > maxposarg) {
                                if ((maxposarg = n) > NL_ARGMAX) {
                                        return -1;
                                }
                        }
                        --n;
                        /* Record argtype with largest size (current, new). */
                        if (_is_equal_or_bigger_arg(ppfs->argtype[n], argtype[i])) {
                                ppfs->argtype[n] = argtype[i];
                        }
                } while (++i < ppfs->num_data_args + 2);
        } else {
#endif /* NL_ARGMAX */
                ppfs->argnumber[2] = 1;
                memcpy(ppfs->argtype, argtype + 2, ppfs->num_data_args * sizeof(int));
#ifdef NL_ARGMAX
        }
 
        ppfs->maxposarg = maxposarg;
#endif /* NL_ARGMAX */
 
#ifdef __UCLIBC_HAS_WCHAR__
        if ((flags = ppfs->info._flags & FLAG_WIDESTREAM) == 0) {
                ppfs->fmtpos = ++fmt;
        } else {
                ppfs->fmtpos = (const char *) (((const wchar_t *)(ppfs->fmtpos))
                                                                           + (fmt - buf) );
        }
#else  /* __UCLIBC_HAS_WCHAR__ */
        ppfs->fmtpos = ++fmt;
#endif /* __UCLIBC_HAS_WCHAR__ */
 
        return ppfs->num_data_args + 2;
}
 
#endif
/**********************************************************************/
#ifdef L_register_printf_function
 
#ifdef __STDIO_GLIBC_CUSTOM_PRINTF
 
int register_printf_function(int spec, printf_function handler,
                                                         printf_arginfo_function arginfo)
{
        register char *r;
        register char *p;
 
        if (spec && (arginfo != NULL)) { /* TODO -- check if spec is valid char */
                r = NULL;
                p = _custom_printf_spec + MAX_USER_SPEC;
                do {
                        --p;
                        if (!*p) {
                                r = p;
                        }
#ifdef __BCC__
                        else                            /* bcc generates less code with fall-through */
#endif
                        if (*p == spec) {
                                r = p;
                                p = _custom_printf_spec;
                        }
                } while (p > _custom_printf_spec);
 
                if (r) {
                        if (handler) {
                                *r = spec;
                                _custom_printf_handler[(int)(r - p)] = handler;
                                _custom_printf_arginfo[(int)(r - p)] = arginfo;
                        } else {
                                *r = 0;
                        }
                        return 0;
                }
                /* TODO -- if asked to unregister a non-existent spec, return what? */
        }
        return -1;
}
 
#endif
 
#endif
/**********************************************************************/
#ifdef L_vsnprintf
 
#ifdef __UCLIBC_MJN3_ONLY__
#warning WISHLIST: Implement vsnprintf for non-buffered and no custom stream case.
#endif /* __UCLIBC_MJN3_ONLY__ */
 
#ifdef __STDIO_BUFFERS
 
int vsnprintf(char *__restrict buf, size_t size,
                          const char * __restrict format, va_list arg)
{
        FILE f;
        int rv;
 
#ifdef __STDIO_GETC_MACRO
        f.bufgetc =
#endif
        f.bufpos = f.bufread = f.bufstart = buf;
 
        if (size > SIZE_MAX - (size_t) buf) {
                size = SIZE_MAX - (size_t) buf;
        }
#ifdef __STDIO_PUTC_MACRO
        f.bufputc =
#endif
        f.bufend = buf + size;
 
#if 0                                                   /* shouldn't be necessary */
/*  #ifdef __STDIO_GLIBC_CUSTOM_STREAMS */
        f.cookie = &(f.filedes);
        f.gcs.read = 0;
        f.gcs.write = 0;
        f.gcs.seek = 0;
        f.gcs.close = 0;
#endif
        f.filedes = -2;                         /* for debugging */
        f.modeflags = (__FLAG_NARROW|__FLAG_WRITEONLY|__FLAG_WRITING);
 
#ifdef __STDIO_MBSTATE
        __INIT_MBSTATE(&(f.state));
#endif /* __STDIO_MBSTATE */
 
#ifdef __STDIO_THREADSAFE
        f.user_locking = 0;
        __stdio_init_mutex(&f.lock);
#endif
 
        rv = vfprintf(&f, format, arg);
        if (size) {
                if (f.bufpos == f.bufend) {
                        --f.bufpos;
                }
                *f.bufpos = 0;
        }
        return rv;
}
 
#elif defined(__USE_OLD_VFPRINTF__)
 
typedef struct {
        FILE f;
        unsigned char *bufend;          /* pointer to 1 past end of buffer */
        unsigned char *bufpos;
} __FILE_vsnprintf;
 
int vsnprintf(char *__restrict buf, size_t size,
                          const char * __restrict format, va_list arg)
{
        __FILE_vsnprintf f;
        int rv;
 
        f.bufpos = buf;
 
        if (size > SIZE_MAX - (size_t) buf) {
                size = SIZE_MAX - (size_t) buf;
        }
        f.bufend = buf + size;
 
#if 0                                                   /* shouldn't be necessary */
/*  #ifdef __STDIO_GLIBC_CUSTOM_STREAMS */
        f.f.cookie = &(f.f.filedes);
        f.f.gcs.read = 0;
        f.f.gcs.write = 0;
        f.f.gcs.seek = 0;
        f.f.gcs.close = 0;
#endif
        f.f.filedes = -2;                               /* for debugging */
        f.f.modeflags = (__FLAG_NARROW|__FLAG_WRITEONLY|__FLAG_WRITING);
 
#ifdef __STDIO_MBSTATE
        __INIT_MBSTATE(&(f.f.state));
#endif /* __STDIO_MBSTATE */
 
#ifdef __STDIO_THREADSAFE
        f.f.user_locking = 0;
        __stdio_init_mutex(&f.f.lock);
#endif
 
        rv = vfprintf((FILE *) &f, format, arg);
        if (size) {
                if (f.bufpos == f.bufend) {
                        --f.bufpos;
                }
                *f.bufpos = 0;
        }
        return rv;
}
 
#elif defined(__STDIO_GLIBC_CUSTOM_STREAMS)
 
typedef struct {
        size_t pos;
        size_t len;
        unsigned char *buf;
        FILE *fp;
} __snpf_cookie;
 
#define COOKIE ((__snpf_cookie *) cookie)
 
static ssize_t snpf_write(register void *cookie, const char *buf,
                                                  size_t bufsize)
{
        size_t count;
        register char *p;
 
        /* Note: bufsize < SSIZE_MAX because of _stdio_WRITE. */
 
        if (COOKIE->len > COOKIE->pos) {
                count = COOKIE->len - COOKIE->pos - 1; /* Leave space for nul. */
                if (count > bufsize) {
                        count = bufsize;
                }
 
                p = COOKIE->buf + COOKIE->pos;
                while (count) {
                        *p++ = *buf++;
                        --count;
                }
                *p = 0;
        }
 
        COOKIE->pos += bufsize;
 
        return bufsize;
}
 
#undef COOKIE
 
int vsnprintf(char *__restrict buf, size_t size,
                          const char * __restrict format, va_list arg)
{
        FILE f;
        __snpf_cookie cookie;
        int rv;
 
        cookie.buf = buf;
        cookie.len = size;
        cookie.pos = 0;
        cookie.fp = &f;
 
        f.cookie = &cookie;
        f.gcs.write = snpf_write;
        f.gcs.read = NULL;
        f.gcs.seek = NULL;
        f.gcs.close = NULL;
 
        f.filedes = -1;                         /* For debugging. */
        f.modeflags = (__FLAG_NARROW|__FLAG_WRITEONLY|__FLAG_WRITING);
 
#ifdef __STDIO_MBSTATE
        __INIT_MBSTATE(&(f.state));
#endif /* __STDIO_MBSTATE */
 
#ifdef __STDIO_THREADSAFE
        f.user_locking = 0;
        __stdio_init_mutex(&f.lock);
#endif
 
        rv = vfprintf(&f, format, arg);
 
        return rv;
}
 
#else
#warning Skipping vsnprintf since no buffering, no custom streams, and not old vfprintf!
#ifdef __STDIO_HAS_VSNPRINTF
#error WHOA! __STDIO_HAS_VSNPRINTF is defined!
#endif
#endif
 
#endif
/**********************************************************************/
#ifdef L_vdprintf
 
int vdprintf(int filedes, const char * __restrict format, va_list arg)
{
        FILE f;
        int rv;
#ifdef __STDIO_BUFFERS
        char buf[64];                           /* TODO: provide _optional_ buffering? */
 
#ifdef __STDIO_GETC_MACRO
        f.bufgetc =
#endif
        f.bufpos = f.bufread = f.bufstart = buf;
#ifdef __STDIO_PUTC_MACRO
        f.bufputc =
#endif
        f.bufend = buf + sizeof(buf);
#endif /* __STDIO_BUFFERS */
#ifdef __STDIO_GLIBC_CUSTOM_STREAMS
        f.cookie = &(f.filedes);
        f.gcs.read = _cs_read;
        f.gcs.write = _cs_write;
        f.gcs.seek = 0;                          /* The internal seek func handles normals. */
        f.gcs.close = _cs_close;
#endif
        f.filedes = filedes;
        f.modeflags = (__FLAG_NARROW|__FLAG_WRITEONLY|__FLAG_WRITING);
 
#ifdef __STDIO_MBSTATE
        __INIT_MBSTATE(&(f.state));
#endif /* __STDIO_MBSTATE */
 
#ifdef __STDIO_THREADSAFE
        f.user_locking = 0;
        __stdio_init_mutex(&f.lock);
#endif
 
        rv = vfprintf(&f, format, arg);
 
        return fflush(&f) ? -1 : rv;
}
 
#endif
/**********************************************************************/
#ifdef L_vasprintf
 
#ifndef __STDIO_HAS_VSNPRINTF
#warning Skipping vasprintf since no vsnprintf!
#else
 
int vasprintf(char **__restrict buf, const char * __restrict format,
                         va_list arg)
{
        /* TODO -- change the default implementation? */
#ifndef __STDIO_GLIBC_CUSTOM_STREAMS
        /* This implementation actually calls the printf machinery twice, but only
         * only does one malloc.  This can be a problem though when custom printf
         * specs or the %m specifier are involved because the results of the
         * second call might be different from the first. */
        va_list arg2;
        int rv;
 
        va_copy(arg2, arg);
        rv = vsnprintf(NULL, 0, format, arg2);
        va_end(arg2);
 
        return (((rv >= 0) && ((*buf = malloc(++rv)) != NULL))
                        ? vsnprintf(*buf, rv, format, arg)
                        : -1);
#else
        FILE *f;
        size_t size;
        int rv;
 
        /* TODO - do the memstream stuff inline here to avoid fclose and the openlist? */
        if ((f = open_memstream(buf, &size)) == NULL) {
                return -1;
        }
        rv = vfprintf(f, format, arg);
        fclose(f);
        if (rv < 0) {
                free(*buf);
                *buf = NULL;
                return -1;
        }
        return rv;
#endif
}
#endif
#endif
/**********************************************************************/
#ifdef L_vprintf
int vprintf(const char * __restrict format, va_list arg)
{
        return vfprintf(stdout, format, arg);
}
#endif
/**********************************************************************/
#ifdef L_vsprintf
 
#ifndef __STDIO_HAS_VSNPRINTF
#warning Skipping vsprintf since no vsnprintf!
#else
 
int vsprintf(char *__restrict buf, const char * __restrict format,
                         va_list arg)
{
        return vsnprintf(buf, SIZE_MAX, format, arg);
}
 
#endif
#endif
/**********************************************************************/
#ifdef L_fprintf
 
int fprintf(FILE * __restrict stream, const char * __restrict format, ...)
{
        va_list arg;
        int rv;
 
        va_start(arg, format);
        rv = vfprintf(stream, format, arg);
        va_end(arg);
 
        return rv;
}
 
#endif
/**********************************************************************/
#ifdef L_snprintf
 
#ifndef __STDIO_HAS_VSNPRINTF
#warning Skipping snprintf since no vsnprintf!
#else
 
int snprintf(char *__restrict buf, size_t size,
                         const char * __restrict format, ...)
{
        va_list arg;
        int rv;
 
        va_start(arg, format);
        rv = vsnprintf(buf, size, format, arg);
        va_end(arg);
        return rv;
}
 
#endif
#endif
/**********************************************************************/
#ifdef L_dprintf
 
int dprintf(int filedes, const char * __restrict format, ...)
{
        va_list arg;
        int rv;
 
        va_start(arg, format);
        rv = vdprintf(filedes, format, arg);
        va_end(arg);
 
        return rv;
}
 
#endif
/**********************************************************************/
#ifdef L_asprintf
 
#ifndef __STDIO_HAS_VSNPRINTF
#warning Skipping asprintf and __asprintf since no vsnprintf!
#else
 
weak_alias(__asprintf,asprintf)
 
int __asprintf(char **__restrict buf, const char * __restrict format, ...)
{
        va_list arg;
        int rv;
 
        va_start(arg, format);
        rv = vasprintf(buf, format, arg);
        va_end(arg);
 
        return rv;
}
 
#endif
#endif
/**********************************************************************/
#ifdef L_printf
int printf(const char * __restrict format, ...)
{
        va_list arg;
        int rv;
 
        va_start(arg, format);
        rv = vfprintf(stdout, format, arg);
        va_end(arg);
 
        return rv;
}
#endif
/**********************************************************************/
#ifdef L_sprintf
 
#ifndef __STDIO_HAS_VSNPRINTF
#warning Skipping sprintf since no vsnprintf!
#else
 
int sprintf(char *__restrict buf, const char * __restrict format, ...)
{
        va_list arg;
        int rv;
 
        va_start(arg, format);
        rv = vsnprintf(buf, SIZE_MAX, format, arg);
        va_end(arg);
 
        return rv;
}
 
#endif
#endif
/**********************************************************************/
#ifdef L_vswprintf
 
#ifdef __STDIO_BUFFERS
int vswprintf(wchar_t *__restrict buf, size_t size,
                          const wchar_t * __restrict format, va_list arg)
{
        FILE f;
        int rv;
 
#ifdef __STDIO_GETC_MACRO
        f.bufgetc =
#endif
        f.bufpos = f.bufread = f.bufstart = (char *) buf;
 
/*      if (size > SIZE_MAX - (size_t) buf) { */
/*              size = SIZE_MAX - (size_t) buf; */
/*      } */
#ifdef __STDIO_PUTC_MACRO
        f.bufputc =
#endif
        f.bufend = (char *)(buf + size);
 
#if 0                                                   /* shouldn't be necessary */
/*  #ifdef __STDIO_GLIBC_CUSTOM_STREAMS */
        f.cookie = &(f.filedes);
        f.gcs.read = 0;
        f.gcs.write = 0;
        f.gcs.seek = 0;
        f.gcs.close = 0;
#endif
        f.filedes = -3;                         /* for debugging */
        f.modeflags = (__FLAG_WIDE|__FLAG_WRITEONLY|__FLAG_WRITING);
 
#ifdef __STDIO_MBSTATE
        __INIT_MBSTATE(&(f.state));
#endif /* __STDIO_MBSTATE */
 
#ifdef __STDIO_THREADSAFE
        f.user_locking = 0;
        __stdio_init_mutex(&f.lock);
#endif
 
        rv = vfwprintf(&f, format, arg);
 
        /* NOTE: Return behaviour differs from snprintf... */
        if (f.bufpos == f.bufend) {
                rv = -1;
                if (size) {
                        f.bufpos = (char *)(((wchar_t *) f.bufpos) - 1);
                }
        }
        if (size) {
                *((wchar_t *) f.bufpos) = 0;
        }
        return rv;
}
#else  /* __STDIO_BUFFERS */
#warning Skipping vswprintf since no buffering!
#endif /* __STDIO_BUFFERS */
#endif
/**********************************************************************/
#ifdef L_swprintf
#ifdef __STDIO_BUFFERS
 
int swprintf(wchar_t *__restrict buf, size_t size,
                         const wchar_t * __restrict format, ...)
{
        va_list arg;
        int rv;
 
        va_start(arg, format);
        rv = vswprintf(buf, size, format, arg);
        va_end(arg);
        return rv;
}
 
#else  /* __STDIO_BUFFERS */
#warning Skipping vsWprintf since no buffering!
#endif /* __STDIO_BUFFERS */
#endif
/**********************************************************************/
#ifdef L_fwprintf
 
int fwprintf(FILE * __restrict stream, const wchar_t * __restrict format, ...)
{
        va_list arg;
        int rv;
 
        va_start(arg, format);
        rv = vfwprintf(stream, format, arg);
        va_end(arg);
 
        return rv;
}
 
#endif
/**********************************************************************/
#ifdef L_vwprintf
int vwprintf(const wchar_t * __restrict format, va_list arg)
{
        return vfwprintf(stdout, format, arg);
}
#endif
/**********************************************************************/
#ifdef L_wprintf
int wprintf(const wchar_t * __restrict format, ...)
{
        va_list arg;
        int rv;
 
        va_start(arg, format);
        rv = vfwprintf(stdout, format, arg);
        va_end(arg);
 
        return rv;
}
#endif
/**********************************************************************/
#ifdef L__fpmaxtostr
 
/* Copyright (C) 2000, 2001, 2003      Manuel Novoa III
 *
 * Function:
 *
 *     size_t _fpmaxtostr(FILE * fp, __fpmax_t x, struct printf_info *info,
 *                         __fp_outfunc_t fp_outfunc);
 *
 * This is derived from the old _dtostr, whic I wrote for uClibc to provide
 * floating point support for the printf functions.  It handles +/- infinity,
 * nan, and signed 0 assuming you have ieee arithmetic.  It also now handles
 * digit grouping (for the uClibc supported locales) and hexadecimal float
 * notation.  Finally, via the fp_outfunc parameter, it now supports wide
 * output.
 *
 * Notes:
 *
 * At most DECIMAL_DIG significant digits are kept.  Any trailing digits
 * are treated as 0 as they are really just the results of rounding noise
 * anyway.  If you want to do better, use an arbitary precision arithmetic
 * package.  ;-)
 *
 * It should also be fairly portable, as no assumptions are made about the
 * bit-layout of doubles.  Of course, that does make it less efficient than
 * it could be.
 *
 */
 
/*****************************************************************************/
/* Don't change anything that follows unless you know what you're doing.     */
/*****************************************************************************/
/* Fairly portable nan check.  Bitwise for i386 generated larger code.
 * If you have a better version, comment this out.
 */
#define isnan(x)             ((x) != (x))
 
/* Without seminumerical functions to examine the sign bit, this is
 * about the best we can do to test for '-0'.
 */
#define zeroisnegative(x)    ((1./(x)) < 0)
 
/*****************************************************************************/
/* Don't change anything that follows peroid!!!  ;-)                         */
/*****************************************************************************/
#ifdef __UCLIBC_HAS_HEXADECIMAL_FLOATS__
#if FLT_RADIX != 2
#error FLT_RADIX != 2 is not currently supported
#endif
#endif /* __UCLIBC_HAS_HEXADECIMAL_FLOATS__ */
 
#define NUM_HEX_DIGITS      ((FPMAX_MANT_DIG + 3)/ 4)
 
/* WARNING: Adjust _fp_out_wide() below if this changes! */
/* With 32 bit ints, we can get 9 decimal digits per block. */
#define DIGITS_PER_BLOCK     9
#define HEX_DIGITS_PER_BLOCK 8
 
/* Maximum number of subcases to output double is...
 *  0 - sign
 *  1 - padding and initial digit
 *  2 - digits left of the radix
 *  3 - 0s left of the radix        or   radix
 *  4 - radix                       or   digits right of the radix
 *  5 - 0s right of the radix
 *  6 - exponent
 *  7 - trailing space padding
 * although not all cases may occur.
 */
#define MAX_CALLS 8
 
/*****************************************************************************/
 
#define NUM_DIGIT_BLOCKS   ((DECIMAL_DIG+DIGITS_PER_BLOCK-1)/DIGITS_PER_BLOCK)
#define NUM_HEX_DIGIT_BLOCKS \
   ((NUM_HEX_DIGITS+HEX_DIGITS_PER_BLOCK-1)/HEX_DIGITS_PER_BLOCK)
 
/* WARNING: Adjust _fp_out_wide() below if this changes! */
 
/* extra space for '-', '.', 'e+###', and nul */
#define BUF_SIZE  ( 3 + NUM_DIGIT_BLOCKS * DIGITS_PER_BLOCK )
 
/*****************************************************************************/
 
static const char fmt[] = "inf\0INF\0nan\0NAN\0.\0,";
 
#define INF_OFFSET        0             /* must be 1st */
#define NAN_OFFSET        8             /* must be 2nd.. see hex sign handling */
#define DECPT_OFFSET     16
#define THOUSEP_OFFSET   18
 
#define EMPTY_STRING_OFFSET 3
 
/*****************************************************************************/
#if FPMAX_MAX_10_EXP < -FPMAX_MIN_10_EXP
#error scaling code can not handle FPMAX_MAX_10_EXP < -FPMAX_MIN_10_EXP
#endif
 
static const __fpmax_t exp10_table[] =
{
        1e1L, 1e2L, 1e4L, 1e8L, 1e16L, 1e32L,   /* floats */
#if FPMAX_MAX_10_EXP < 32
#error unsupported FPMAX_MAX_10_EXP (< 32).  ANSI/ISO C requires >= 37.
#endif
#if FPMAX_MAX_10_EXP >= 64
        1e64L,
#endif
#if FPMAX_MAX_10_EXP >= 128
        1e128L,
#endif
#if FPMAX_MAX_10_EXP >= 256
        1e256L,
#endif
#if FPMAX_MAX_10_EXP >= 512
        1e512L,
#endif
#if FPMAX_MAX_10_EXP >= 1024
        1e1024L,
#endif
#if FPMAX_MAX_10_EXP >= 2048
        1e2048L,
#endif
#if FPMAX_MAX_10_EXP >= 4096
        1e4096L
#endif
#if FPMAX_MAX_10_EXP >= 8192
#error unsupported FPMAX_MAX_10_EXP.  please increase table
#endif
};
 
#define EXP10_TABLE_SIZE     (sizeof(exp10_table)/sizeof(exp10_table[0]))
#define EXP10_TABLE_MAX      (1U<<(EXP10_TABLE_SIZE-1))
 
/*****************************************************************************/
#ifdef __UCLIBC_HAS_HEXADECIMAL_FLOATS__
 
#if FLT_RADIX != 2
#error FLT_RADIX != 2 is not currently supported
#endif
 
#if FPMAX_MAX_EXP < -FPMAX_MIN_EXP
#error scaling code can not handle FPMAX_MAX_EXP < -FPMAX_MIN_EXP
#endif
 
static const __fpmax_t exp16_table[] = {
        0x1.0p4L, 0x1.0p8L, 0x1.0p16L, 0x1.0p32L, 0x1.0p64L,
#if FPMAX_MAX_EXP >= 128
        0x1.0p128L,
#endif
#if FPMAX_MAX_EXP >= 256
        0x1.0p256L,
#endif
#if FPMAX_MAX_EXP >= 512
        0x1.0p512L,
#endif
#if FPMAX_MAX_EXP >= 1024
        0x1.0p1024L,
#endif
#if FPMAX_MAX_EXP >= 2048
        0x1.0p2048L,
#endif
#if FPMAX_MAX_EXP >= 4096
        0x1.0p4096L,
#endif
#if FPMAX_MAX_EXP >= 8192
        0x1.0p8192L,
#endif
#if FPMAX_MAX_EXP >= 16384
        0x1.0p16384L
#endif
#if FPMAX_MAX_EXP >= 32768 
#error unsupported FPMAX_MAX_EXP.  please increase table
#endif
};
 
#define EXP16_TABLE_SIZE     (sizeof(exp16_table)/sizeof(exp16_table[0]))
#define EXP16_TABLE_MAX      (1U<<(EXP16_TABLE_SIZE-1))
 
#endif /* __UCLIBC_HAS_HEXADECIMAL_FLOATS__ */
/*****************************************************************************/
 
#define FPO_ZERO_PAD    (0x80 | '0')
#define FPO_STR_WIDTH   (0x80 | ' ');
#define FPO_STR_PREC    'p'
 
size_t _fpmaxtostr(FILE * fp, __fpmax_t x, struct printf_info *info,
                                   __fp_outfunc_t fp_outfunc)
{
#ifdef __UCLIBC_HAS_HEXADECIMAL_FLOATS__
        __fpmax_t lower_bnd;
        __fpmax_t upper_bnd = 1e9;
#endif /* __UCLIBC_HAS_HEXADECIMAL_FLOATS__ */
        uint_fast32_t digit_block;
#ifdef __UCLIBC_HAS_HEXADECIMAL_FLOATS__
        uint_fast32_t base = 10;
        const __fpmax_t *power_table;
        int dpb = DIGITS_PER_BLOCK;
        int ndb = NUM_DIGIT_BLOCKS;
        int nd = DECIMAL_DIG;
        int sufficient_precision = 0;
#endif /* __UCLIBC_HAS_HEXADECIMAL_FLOATS__ */
#ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__
        int num_groups = 0;
        int initial_group;         /* This does not need to be initialized. */
        int tslen;                         /* This does not need to be initialized. */
        int nblk2;                         /* This does not need to be initialized. */
        const char *ts;            /* This does not need to be initialized. */
#endif /* __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ */
        int i, j;
        int round, o_exp;
        int exp, exp_neg;
        int width, preci;
        int cnt;
        char *s;
        char *e;
        intptr_t pc_fwi[3*MAX_CALLS];
        intptr_t *ppc;
        intptr_t *ppc_last;
#ifdef __UCLIBC_MJN3_ONLY__
#warning TODO: The size of exp_buf[] should really be determined by the float constants.
#endif /* __UCLIBC_MJN3_ONLY__ */
        char exp_buf[16];
        char buf[BUF_SIZE];
        char sign_str[6];                       /* Last 2 are for 1st digit + nul. */
        char o_mode;
        char mode;
 
 
        width = info->width;
        preci = info->prec;
        mode = info->spec;
 
        *exp_buf = 'e';
        if ((mode|0x20) == 'a') {
#ifdef __UCLIBC_HAS_HEXADECIMAL_FLOATS__
                *exp_buf = 'p';
                if (preci < 0) {
                        preci = NUM_HEX_DIGITS;
                        sufficient_precision = 1;
                }
#else
                mode += ('g' - 'a');
#endif
        }
 
        if (preci < 0) {
                preci = 6;
        }
 
        *sign_str = '\0';
        if (PRINT_INFO_FLAG_VAL(info,showsign)) {
                *sign_str = '+';
        } else if (PRINT_INFO_FLAG_VAL(info,space)) {
                *sign_str = ' ';
        }
 
        *(sign_str+1) = 0;
        pc_fwi[5] = INF_OFFSET;
        if (isnan(x)) {                         /* First, check for nan. */
                pc_fwi[5] = NAN_OFFSET;
                goto INF_NAN;
        }
 
        if (x == 0) {                            /* Handle 0 now to avoid false positive. */
#if 1
                if (zeroisnegative(x)) { /* Handle 'signed' zero. */
                        *sign_str = '-';
                }
#endif
                exp = -1;
                goto GENERATE_DIGITS;
        }
 
        if (x < 0) {                             /* Convert negatives to positives. */
                *sign_str = '-';
                x = -x;
        }
 
        if (__FPMAX_ZERO_OR_INF_CHECK(x)) {     /* Inf since zero handled above. */
        INF_NAN:
                info->pad = ' ';
                ppc = pc_fwi + 6;
                pc_fwi[3] = FPO_STR_PREC;
                pc_fwi[4] = 3;
                if (mode < 'a') {
                        pc_fwi[5] += 4;
                }
                pc_fwi[5] = (intptr_t)(fmt + pc_fwi[5]);
                goto EXIT_SPECIAL;
        }
 
#ifdef __UCLIBC_MJN3_ONLY__
#warning TODO: Clean up defines when hexadecimal float notation is unsupported.
#endif /* __UCLIBC_MJN3_ONLY__ */
 
#ifdef __UCLIBC_HAS_HEXADECIMAL_FLOATS__
 
        if ((mode|0x20) == 'a') {
                lower_bnd = 0x1.0p31L;
                upper_bnd = 0x1.0p32L;
                power_table = exp16_table;
                exp = HEX_DIGITS_PER_BLOCK - 1;
                i = EXP16_TABLE_SIZE;
                j = EXP16_TABLE_MAX;
                dpb = HEX_DIGITS_PER_BLOCK;
                ndb = NUM_HEX_DIGIT_BLOCKS;
                nd = NUM_HEX_DIGITS;
                base = 16;
        } else {
                lower_bnd = 1e8;
/*              upper_bnd = 1e9; */
                power_table = exp10_table;
                exp = DIGITS_PER_BLOCK - 1;
                i = EXP10_TABLE_SIZE;
                j = EXP10_TABLE_MAX;
/*              dpb = DIGITS_PER_BLOCK; */
/*              ndb = NUM_DIGIT_BLOCKS; */
/*              base = 10; */
        }
 
 
 
#else  /* __UCLIBC_HAS_HEXADECIMAL_FLOATS__ */
 
#define lower_bnd    1e8
#define upper_bnd    1e9
#define power_table  exp10_table
#define dpb          DIGITS_PER_BLOCK
#define base         10
#define ndb          NUM_DIGIT_BLOCKS
#define nd           DECIMAL_DIG
 
        exp = DIGITS_PER_BLOCK - 1;
        i = EXP10_TABLE_SIZE;
        j = EXP10_TABLE_MAX;
 
#endif /* __UCLIBC_HAS_HEXADECIMAL_FLOATS__ */
 
        exp_neg = 0;
        if (x < lower_bnd) {            /* Do we need to scale up or down? */
                exp_neg = 1;
        }
 
        do {
                --i;
                if (exp_neg) {
                        if (x * power_table[i] < upper_bnd) {
                                x *= power_table[i];
                                exp -= j;
                        }
                } else {
                        if (x / power_table[i] >= lower_bnd) {
                                x /= power_table[i];
                                exp += j;
                        }
                }
                j >>= 1;
        } while (i);
        if (x >= upper_bnd) {           /* Handle bad rounding case. */
                x /= power_table[0];
                ++exp;
        }
        assert(x < upper_bnd);
 
 GENERATE_DIGITS:
        s = buf + 2;                            /* Leave space for '\0' and '0'. */
        i = 0;
        do {
                digit_block = (uint_fast32_t) x;
                assert(digit_block < upper_bnd);
#ifdef __UCLIBC_MJN3_ONLY__
#warning CONSIDER: Can rounding be a problem?
#endif /* __UCLIBC_MJN3_ONLY__ */
                x = (x - digit_block) * upper_bnd;
                s += dpb;
                j = 0;
                do {
                        s[- ++j] = '0' + (digit_block % base);
                        digit_block /= base;
                } while (j < dpb);
        } while (++i < ndb);
 
        /*************************************************************************/
 
        if (mode < 'a') {
                *exp_buf -= ('a' - 'A'); /* e->E and p->P */
                mode += ('a' - 'A');
        }
 
        o_mode = mode;
        if ((mode == 'g') && (preci > 0)){
                --preci;
        }
        round = preci;
 
        if (mode == 'f') {
                round += exp;
                if (round < -1) {
                        memset(buf, '0', DECIMAL_DIG); /* OK, since 'f' -> decimal case. */
                    exp = -1;
                    round = -1;
                }
        }
 
        s = buf;
        *s++ = 0;                                        /* Terminator for rounding and 0-triming. */
        *s = '0';                                       /* Space to round. */
 
        i = 0;
        e = s + nd + 1;
        if (round < nd) {
                e = s + round + 2;
                if (*e >= '0' + (base/2)) {     /* NOTE: We always round away from 0! */
                        i = 1;
                }
        }
 
        do {                                            /* Handle rounding and trim trailing 0s. */
                *--e += i;                              /* Add the carry. */
        } while ((*e == '0') || (*e > '0' - 1 + base));
 
#ifdef __UCLIBC_HAS_HEXADECIMAL_FLOATS__
        if ((mode|0x20) == 'a') {
                char *q;
 
                for (q = e ; *q ; --q) {
                        if (*q > '9') {
                                *q += (*exp_buf - ('p' - 'a') - '9' - 1);
                        }
                }
 
                if (e > s) {
                        exp *= 4;                       /* Change from base 16 to base 2. */
                }
        }
#endif /* __UCLIBC_HAS_HEXADECIMAL_FLOATS__ */
 
        o_exp = exp;
        if (e <= s) {                           /* We carried into an extra digit. */
                ++o_exp;
                e = s;                                  /* Needed if all 0s. */
        } else {
                ++s;
        }
        *++e = 0;                                        /* Terminating nul char. */
 
        if ((mode == 'g') && ((o_exp >= -4) && (o_exp <= round))) {
                mode = 'f';
                preci = round - o_exp;
        }
 
        exp = o_exp;
        if (mode != 'f') {
                o_exp = 0;
        }
 
        if (o_exp < 0) {                 /* Exponent is < 0, so */
                *--s = '0';                             /* fake the first 0 digit. */
        }
 
        pc_fwi[3] = FPO_ZERO_PAD;
        pc_fwi[4] = 1;
        pc_fwi[5] = (intptr_t)(sign_str + 4);
        sign_str[4] = *s++;
        sign_str[5] = 0;
        ppc = pc_fwi + 6;
 
        i = e - s;                                      /* Total digits is 'i'. */
        if (o_exp >= 0) {
#ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__
 
                const char *p;
 
                if (PRINT_INFO_FLAG_VAL(info,group)
                        && *(p = __UCLIBC_CURLOCALE_DATA.grouping)
                        ) {
                        int nblk1;
 
                        nblk2 = nblk1 = *p;
                        if (*++p) {
                                nblk2 = *p;
                                assert(!*++p);
                        }
 
                        if (o_exp >= nblk1) {
                                num_groups = (o_exp - nblk1) / nblk2 + 1;
                                initial_group = (o_exp - nblk1) % nblk2;
 
#ifdef __UCLIBC_HAS_WCHAR__
                                if (PRINT_INFO_FLAG_VAL(info,wide)) {
                                        /* _fp_out_wide() will fix this up. */
                                        ts = fmt + THOUSEP_OFFSET;
                                        tslen = 1;
                                } else {
#endif /* __UCLIBC_HAS_WCHAR__ */
                                        ts = __UCLIBC_CURLOCALE_DATA.thousands_sep;
                                        tslen = __UCLIBC_CURLOCALE_DATA.thousands_sep_len;
#ifdef __UCLIBC_HAS_WCHAR__
                                }
#endif /* __UCLIBC_HAS_WCHAR__ */
 
                                width -= num_groups * tslen;
                        }
                }
 
 
#endif /* __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ */
                ppc[0] = FPO_STR_PREC;
                ppc[2] = (intptr_t)(s);
                if (o_exp >= i) {               /* all digit(s) left of decimal */
                        ppc[1] = i;
                        ppc += 3;
                        o_exp -= i;
                        i = 0;
                        if (o_exp>0) {           /* have 0s left of decimal */
                                ppc[0] = FPO_ZERO_PAD;
                                ppc[1] = o_exp;
                                ppc[2] = (intptr_t)(fmt + EMPTY_STRING_OFFSET);
                                ppc += 3;
                        }
                } else if (o_exp > 0) {  /* decimal between digits */
                        ppc[1] = o_exp;
                        ppc += 3;
                        s += o_exp;
                        i -= o_exp;
                }
                o_exp = -1;
        }
 
        if (PRINT_INFO_FLAG_VAL(info,alt)
                || (i)
                || ((o_mode != 'g')
#ifdef __UCLIBC_HAS_HEXADECIMAL_FLOATS__
                        && (o_mode != 'a')
#endif /* __UCLIBC_HAS_HEXADECIMAL_FLOATS__ */
                        && (preci > 0))
                ) {
                ppc[0] = FPO_STR_PREC;
#ifdef __LOCALE_C_ONLY
                ppc[1] = 1;
                ppc[2] = (intptr_t)(fmt + DECPT_OFFSET);
#else  /* __LOCALE_C_ONLY */
#ifdef __UCLIBC_HAS_WCHAR__
                        if (PRINT_INFO_FLAG_VAL(info,wide)) {
                                /* _fp_out_wide() will fix this up. */
                                ppc[1] = 1;
                                ppc[2] = (intptr_t)(fmt + DECPT_OFFSET);
                        } else {
#endif /* __UCLIBC_HAS_WCHAR__ */
                                ppc[1] = __UCLIBC_CURLOCALE_DATA.decimal_point_len;
                                ppc[2] = (intptr_t)(__UCLIBC_CURLOCALE_DATA.decimal_point);
#ifdef __UCLIBC_HAS_WCHAR__
                        }
#endif /* __UCLIBC_HAS_WCHAR__ */
#endif /* __LOCALE_C_ONLY */
                        ppc += 3;
        }
 
        if (++o_exp < 0) {                       /* Have 0s right of decimal. */
                ppc[0] = FPO_ZERO_PAD;
                ppc[1] = -o_exp;
                ppc[2] = (intptr_t)(fmt + EMPTY_STRING_OFFSET);
                ppc += 3;
        }
        if (i) {                                        /* Have digit(s) right of decimal. */
                ppc[0] = FPO_STR_PREC;
                ppc[1] = i;
                ppc[2] = (intptr_t)(s);
                ppc += 3;
        }
 
        if (((o_mode != 'g') || PRINT_INFO_FLAG_VAL(info,alt))
#ifdef __UCLIBC_HAS_HEXADECIMAL_FLOATS__
                && !sufficient_precision
#endif /* __UCLIBC_HAS_HEXADECIMAL_FLOATS__ */
                ) {
                i -= o_exp;
                if (i < preci) {                /* Have 0s right of digits. */
                        i = preci - i;
                        ppc[0] = FPO_ZERO_PAD;
                        ppc[1] = i;
                        ppc[2] = (intptr_t)(fmt + EMPTY_STRING_OFFSET);
                        ppc += 3;
                }
        }
 
        /* Build exponent string. */
        if (mode != 'f') {
                char *p = exp_buf + sizeof(exp_buf);
                char exp_char = *exp_buf;
                char exp_sign = '+';
#ifdef __UCLIBC_HAS_HEXADECIMAL_FLOATS__
                int min_exp_dig_plus_2 = ((o_mode != 'a') ? (2+2) : (2+1));
#else  /* __UCLIBC_HAS_HEXADECIMAL_FLOATS__ */
#define min_exp_dig_plus_2  (2+2)
#endif /* __UCLIBC_HAS_HEXADECIMAL_FLOATS__ */
 
                if (exp < 0) {
                        exp_sign = '-';
                        exp = -exp;
                }
 
                *--p = 0;                        /* nul-terminate */
                j = 2;                          /* Count exp_char and exp_sign. */
                do {
                        *--p = '0' + (exp % 10);
                        exp /= 10;
                } while ((++j < min_exp_dig_plus_2) || exp); /* char+sign+mindigits */
                *--p = exp_sign;
                *--p = exp_char;
 
                ppc[0] = FPO_STR_PREC;
                ppc[1] = j;
                ppc[2] = (intptr_t)(p);
                ppc += 3;
        }
 
 EXIT_SPECIAL:
        ppc_last = ppc;
        ppc = pc_fwi + 4;        /* Need width fields starting with second. */
        do {
                width -= *ppc;
                ppc += 3;
        } while (ppc < ppc_last);
 
        ppc = pc_fwi;
        ppc[0] = FPO_STR_WIDTH;
        ppc[1] = i = ((*sign_str) != 0);
        ppc[2] = (intptr_t) sign_str;
 
#ifdef __UCLIBC_HAS_HEXADECIMAL_FLOATS__
        if (((mode|0x20) == 'a') && (pc_fwi[3] >= 16)) { /* Hex sign handling. */
                /* Hex and not inf or nan, so prefix with 0x. */
                char *h = sign_str + i;
                *h = '0';
                *++h = 'x' - 'p' + *exp_buf;
                *++h = 0;
                ppc[1] = (i += 2);
        }
#endif /* __UCLIBC_HAS_HEXADECIMAL_FLOATS__ */
 
        if ((width -= i) > 0) {
                if (PRINT_INFO_FLAG_VAL(info,left)) { /* Left-justified. */
                        ppc_last[0] = FPO_STR_WIDTH;
                        ppc_last[1] = width;
                        ppc_last[2] = (intptr_t)(fmt + EMPTY_STRING_OFFSET);
                        ppc_last += 3;
                } else if (info->pad == '0') { /* 0 padding */
                        ppc[4] += width;        /* Pad second field. */
                } else {
                        ppc[1] += width;        /* Pad first (sign) field. */
                }
        }
 
        cnt = 0;
 
        do {
#ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__
 
                if ((ppc == pc_fwi + 6) && num_groups) {
                        const char *gp = (const char *) ppc[2];
                        int len = ppc[1];
                        int blk = initial_group;
 
                        cnt += num_groups * tslen; /* Adjust count now for sep chars. */
 
/*                      printf("\n"); */
                        do {
                                if (!blk) {             /* Initial group could be 0 digits long! */
                                        blk = nblk2;
                                } else if (len >= blk) { /* Enough digits for a group. */
/*                                      printf("norm:  len=%d blk=%d  \"%.*s\"\n", len, blk, blk, gp); */
                                        fp_outfunc(fp, *ppc, blk, (intptr_t) gp);
                                        assert(gp);
                                        if (*gp) {
                                                gp += blk;
                                        }
                                        len -= blk;
                                } else {                /* Transition to 0s. */
/*                                      printf("trans: len=%d blk=%d  \"%.*s\"\n", len, blk, len, gp); */
                                        if (len) {
/*                                              printf("len\n"); */
                                                fp_outfunc(fp, *ppc, len, (intptr_t) gp);
                                                gp += len;
                                        }
 
                                        if (ppc[3] == FPO_ZERO_PAD) { /* Need to group 0s */
/*                                              printf("zeropad\n"); */
                                                cnt += ppc[1];
                                                ppc += 3;
                                                gp = (const char *) ppc[2];
                                                blk -= len;     /* blk > len, so blk still > 0. */
                                                len = ppc[1];
                                                continue; /* Don't decrement num_groups here. */
                                        } else {
                                                assert(num_groups == 0);
                                                break;
                                        }
                                }
 
                                if (num_groups <= 0) {
                                        break;
                                }
                                --num_groups;
 
                                fp_outfunc(fp, FPO_STR_PREC, tslen, (intptr_t) ts);
                                blk = nblk2;
 
/*                              printf("num_groups=%d   blk=%d\n", num_groups, blk); */
 
                        } while (1);
                } else
 
#endif /* __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ */
 
                fp_outfunc(fp, *ppc, ppc[1], ppc[2]); /* NOTE: Remember 'else' above! */
 
                cnt += ppc[1];
                ppc += 3;
        } while (ppc < ppc_last);
 
        return cnt;
}
 
#endif
/**********************************************************************/
#ifdef L__store_inttype
 
/* Right now, we assume intmax_t is either long or long long */
 
#ifdef INTMAX_MAX
 
#ifdef LLONG_MAX
 
#if INTMAX_MAX > LLONG_MAX
#error INTMAX_MAX > LLONG_MAX!  The printf code needs to be updated!
#endif
 
#elif INTMAX_MAX > LONG_MAX
 
#error No LLONG_MAX and INTMAX_MAX > LONG_MAX!  The printf code needs to be updated!
 
#endif /* LLONG_MAX */
 
#endif /* INTMAX_MAX */
 
/* We assume int may be short or long, but short and long are different. */
 
void _store_inttype(register void *dest, int desttype, uintmax_t val)
{
        if (desttype == __PA_FLAG_CHAR) { /* assume char not int */
                *((unsigned char *) dest) = val;
                return;
        }
#if defined(LLONG_MAX) && (LONG_MAX != LLONG_MAX)
        if (desttype == PA_FLAG_LONG_LONG) {
                *((unsigned long long int *) dest) = val;
                return;
        }
#endif /* LLONG_MAX */
#if SHRT_MAX != INT_MAX
        if (desttype == PA_FLAG_SHORT) {
                *((unsigned short int *) dest) = val;
                return;
        }
#endif /* SHRT_MAX */
#if LONG_MAX != INT_MAX
        if (desttype == PA_FLAG_LONG) {
                *((unsigned long int *) dest) = val;
                return;
        }
#endif /* LONG_MAX */
 
        *((unsigned int *) dest) = val;
}
 
#endif
/**********************************************************************/
#ifdef L__load_inttype
 
extern uintmax_t _load_inttype(int desttype, register const void *src,
                                                           int uflag)
{
        if (uflag >= 0) {                        /* unsigned */
#if LONG_MAX != INT_MAX
                if (desttype & (PA_FLAG_LONG|PA_FLAG_LONG_LONG)) {
#ifdef LLONG_MAX
                        if (desttype == PA_FLAG_LONG_LONG) {
                                return *((unsigned long long int *) src);
                        }
#endif
                        return *((unsigned long int *) src);
                }
#else  /* LONG_MAX != INT_MAX */
#ifdef LLONG_MAX
                if (desttype & PA_FLAG_LONG_LONG) {
                        return *((unsigned long long int *) src);
                }
#endif
#endif /* LONG_MAX != INT_MAX */
                {
                        unsigned int x;
                        x = *((unsigned int *) src);
                        if (desttype == __PA_FLAG_CHAR) x = (unsigned char) x;
#if SHRT_MAX != INT_MAX
                        if (desttype == PA_FLAG_SHORT) x = (unsigned short int) x;
#endif
                        return x;
                }
        } else {                                        /* signed */
#if LONG_MAX != INT_MAX
                if (desttype & (PA_FLAG_LONG|PA_FLAG_LONG_LONG)) {
#ifdef LLONG_MAX
                        if (desttype == PA_FLAG_LONG_LONG) {
                                return *((long long int *) src);
                        }
#endif
                        return *((long int *) src);
                }
#else  /* LONG_MAX != INT_MAX */
#ifdef LLONG_MAX
                if (desttype & PA_FLAG_LONG_LONG) {
                        return *((long long int *) src);
                }
#endif
#endif /* LONG_MAX != INT_MAX */
                {
                        int x;
                        x = *((int *) src);
                        if (desttype == __PA_FLAG_CHAR) x = (char) x;
#if SHRT_MAX != INT_MAX
                        if (desttype == PA_FLAG_SHORT) x = (short int) x;
#endif
                        return x;
                }
        }
}
 
#endif
/**********************************************************************/
#if defined(L_vfprintf) || defined(L_vfwprintf)
 
/* We only support ascii digits (or their USC equivalent codes) in
 * precision and width settings in *printf (wide) format strings.
 * In other words, we don't currently support glibc's 'I' flag.
 * We do accept it, but it is currently ignored. */
 
static void _charpad(FILE * __restrict stream, int padchar, size_t numpad);
 
#ifdef L_vfprintf
 
#define VFPRINTF vfprintf
#define FMT_TYPE char
#define OUTNSTR _outnstr
#define STRLEN  strlen
#define _PPFS_init _ppfs_init
#define OUTPUT(F,S)                     fputs(S,F)
#define _outnstr(stream, string, len)   _stdio_fwrite(string, len, stream)
#define FP_OUT _fp_out_narrow
 
#ifdef __STDIO_PRINTF_FLOAT
 
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;
        }
        OUTNSTR(fp, (const char *) buf, len);
}
 
#endif /* __STDIO_PRINTF_FLOAT */
 
#else  /* L_vfprintf */
 
#define VFPRINTF vfwprintf
#define FMT_TYPE wchar_t
#define OUTNSTR _outnwcs
#define STRLEN  wcslen
#define _PPFS_init _ppwfs_init
#define OUTPUT(F,S)                     fputws(S,F)
#define _outnwcs(stream, wstring, len)  _wstdio_fwrite(wstring, len, stream)
#define FP_OUT _fp_out_wide
 
static void _outnstr(FILE *stream, const char *s, size_t wclen)
{
        /* NOTE!!! len here is the number of wchars we want to generate!!! */
        wchar_t wbuf[64];
        mbstate_t mbstate;
        size_t todo, r;
 
        mbstate.mask = 0;
        todo = wclen;
 
        while (todo) {
                r = mbsrtowcs(wbuf, &s,
                                          ((todo <= sizeof(wbuf)/sizeof(wbuf[0]))
                                           ? todo
                                           : sizeof(wbuf)/sizeof(wbuf[0])),
                                          &mbstate);
                assert(((ssize_t)r) > 0);
                _outnwcs(stream, wbuf, r);
                todo -= r;
        }
}
 
#ifdef __STDIO_PRINTF_FLOAT
 
#ifdef __UCLIBC_MJN3_ONLY__
#warning TODO: Move defines from _fpmaxtostr.  Put them in a common header.
#endif
 
/* The following defines are from _fpmaxtostr.*/
#define DIGITS_PER_BLOCK     9
#define NUM_DIGIT_BLOCKS   ((DECIMAL_DIG+DIGITS_PER_BLOCK-1)/DIGITS_PER_BLOCK)
#define BUF_SIZE  ( 3 + NUM_DIGIT_BLOCKS * DIGITS_PER_BLOCK )
 
static void _fp_out_wide(FILE *fp, intptr_t type, intptr_t len, intptr_t buf)
{
        wchar_t wbuf[BUF_SIZE];
        const char *s = (const char *) buf;
        int i;
 
        if (type & 0x80) {                      /* Some type of padding needed */
                int buflen = strlen(s);
                if ((len -= buflen) > 0) {
                        _charpad(fp, (type & 0x7f), len);
                }
                len = buflen;
        }
 
        if (len > 0) {
                i = 0;
                do {
#ifdef __LOCALE_C_ONLY
                        wbuf[i] = s[i];
#else  /* __LOCALE_C_ONLY */
 
#ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__
                        if (s[i] == ',') {
                                wbuf[i] = __UCLIBC_CURLOCALE_DATA.thousands_sep_wc;
                        } else
#endif /* __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ */
                        if (s[i] == '.') {
                                wbuf[i] = __UCLIBC_CURLOCALE_DATA.decimal_point_wc;
                        } else {
                                wbuf[i] = s[i];
                        }
#endif /* __LOCALE_C_ONLY */
 
                } while (++i < len);
 
                OUTNSTR(fp, wbuf, len);
        }
}
 
#endif /* __STDIO_PRINTF_FLOAT */
 
static int _ppwfs_init(register ppfs_t *ppfs, const wchar_t *fmt0)
{
        static const wchar_t invalid_wcs[] = L"Invalid wide format string.";
        int r;
 
        /* First, zero out everything... argnumber[], argtype[], argptr[] */
        memset(ppfs, 0, sizeof(ppfs_t)); /* TODO: nonportable???? */
#ifdef NL_ARGMAX
        --ppfs->maxposarg;                      /* set to -1 */
#endif /* NL_ARGMAX */
        ppfs->fmtpos = (const char *) fmt0;
        ppfs->info._flags = FLAG_WIDESTREAM;
 
        {
                mbstate_t mbstate;
                const wchar_t *p;
                mbstate.mask = 0;        /* Initialize the mbstate. */
                p = fmt0;
                if (wcsrtombs(NULL, &p, SIZE_MAX, &mbstate) == ((size_t)(-1))) {
                        ppfs->fmtpos = (const char *) invalid_wcs;
                        return -1;
                }
        }
 
        /* now set all argtypes to no-arg */
        {
#if 1
                /* TODO - use memset here since already "paid for"? */
                register int *p = ppfs->argtype;
 
                r = MAX_ARGS;
                do {
                        *p++ = __PA_NOARG;
                } while (--r);
#else
                /* TODO -- get rid of this?? */
                register char *p = (char *) ((MAX_ARGS-1) * sizeof(int));
 
                do {
                        *((int *)(((char *)ppfs) + ((int)p) + offsetof(ppfs_t,argtype))) = __PA_NOARG;
                        p -= sizeof(int);
                } while (p);
#endif
        }
 
        /*
         * Run through the entire format string to validate it and initialize
         * the positional arg numbers (if any).
         */
        {
                register const wchar_t *fmt = fmt0;
 
                while (*fmt) {
                        if ((*fmt == '%') && (*++fmt != '%')) {
                                ppfs->fmtpos = (const char *) fmt; /* back up to the '%' */
                                if ((r = _ppfs_parsespec(ppfs)) < 0) {
                                        return -1;
                                }
                                fmt = (const wchar_t *) ppfs->fmtpos; /* update to one past end of spec */
                        } else {
                                ++fmt;
                        }
                }
                ppfs->fmtpos = (const char *) fmt0; /* rewind */
        }
 
#ifdef NL_ARGMAX
        /* If we have positional args, make sure we know all the types. */
        {
                register int *p = ppfs->argtype;
                r = ppfs->maxposarg;
                while (--r >= 0) {
                        if ( *p == __PA_NOARG ) { /* missing arg type!!! */
                                return -1;
                        }
                        ++p;
                }
        }
#endif /* NL_ARGMAX */
 
        return 0;
}
 
#endif /* L_vfprintf */
 
static void _charpad(FILE * __restrict stream, int padchar, size_t numpad)
{
        /* TODO -- Use a buffer to cut down on function calls... */
        FMT_TYPE pad[1];
 
        *pad = padchar;
        while (numpad) {
                OUTNSTR(stream, pad, 1);
                --numpad;
        }
}
 
/* TODO -- Dynamically allocate work space to accomodate stack-poor archs? */
static int _do_one_spec(FILE * __restrict stream,
                                                 register ppfs_t *ppfs, int *count)
{
        static const char spec_base[] = SPEC_BASE;
#ifdef L_vfprintf
        static const char prefix[] = "+\0-\0 \0000x\0000X";
        /*                            0  2  4  6   9 11*/
#else  /* L_vfprintf */
        static const wchar_t prefix[] = L"+\0-\0 \0000x\0000X";
#endif /* L_vfprintf */
        enum {
                PREFIX_PLUS = 0,
                PREFIX_MINUS = 2,
                PREFIX_SPACE = 4,
                PREFIX_LWR_X = 6,
                PREFIX_UPR_X = 9,
                PREFIX_NONE = 11
        };
 
#ifdef __va_arg_ptr
        const void * const *argptr;
#else
        const void * argptr[MAX_ARGS_PER_SPEC];
#endif
        int *argtype;
#ifdef __UCLIBC_HAS_WCHAR__
        const wchar_t *ws = NULL;
        mbstate_t mbstate;
#endif /* __UCLIBC_HAS_WCHAR__ */
        size_t slen;
#ifdef L_vfprintf
#define SLEN slen
#else
        size_t SLEN;
        wchar_t wbuf[2];
#endif
        int base;
        int numpad;
        int alphacase;
        int numfill = 0;                 /* TODO: fix */
        int prefix_num = PREFIX_NONE;
        char padchar = ' ';
#ifdef __UCLIBC_MJN3_ONLY__
#warning TODO: Determine appropriate buf size.
#endif /* __UCLIBC_MJN3_ONLY__ */
        /* TODO: buf needs to be big enough for any possible error return strings
         * and also for any locale-grouped long long integer strings generated.
         * This should be large enough for any of the current archs/locales, but
         * eventually this should be handled robustly. */
        char buf[128];
 
#ifdef NDEBUG
        _ppfs_parsespec(ppfs);
#else
        if (_ppfs_parsespec(ppfs) < 0) { /* TODO: just for debugging */
                abort();
        }
#endif
        _ppfs_setargs(ppfs);
 
        argtype = ppfs->argtype + ppfs->argnumber[2] - 1;
        /* Deal with the argptr vs argvalue issue. */
#ifdef __va_arg_ptr
        argptr = (const void * const *) ppfs->argptr;
#ifdef NL_ARGMAX
        if (ppfs->maxposarg > 0) {       /* Using positional args... */
                argptr += ppfs->argnumber[2] - 1;
        }
#endif /* NL_ARGMAX */
#else
        /* Need to build a local copy... */
        {
                register argvalue_t *p = ppfs->argvalue;
                int i;
#ifdef NL_ARGMAX
                if (ppfs->maxposarg > 0) {       /* Using positional args... */
                        p += ppfs->argnumber[2] - 1;
                }
#endif /* NL_ARGMAX */
                for (i = 0 ; i < ppfs->num_data_args ; i++ ) {
                        argptr[i] = (void *) p++;
                }
        }
#endif
        {
                register char *s = NULL; /* TODO: Should s be unsigned char * ? */
 
                if (ppfs->conv_num == CONV_n) {
                        _store_inttype(*(void **)*argptr,
                                                   ppfs->info._flags & __PA_INTMASK,
                                                   (intmax_t) (*count));
                        return 0;
                }
                if (ppfs->conv_num <= CONV_i) { /* pointer or (un)signed int */
                        alphacase = __UIM_LOWER;
 
#ifdef __UCLIBC_MJN3_ONLY__
#ifdef L_vfprintf
#warning CONSIDER: Should we ignore these flags if stub locale?  What about custom specs?
#endif
#endif /* __UCLIBC_MJN3_ONLY__ */
                        if ((base = spec_base[(int)(ppfs->conv_num - CONV_p)]) == 10) {
                                if (PRINT_INFO_FLAG_VAL(&(ppfs->info),group)) {
                                        alphacase = __UIM_GROUP;
                                }
                                if (PRINT_INFO_FLAG_VAL(&(ppfs->info),i18n)) {
                                        alphacase |= 0x80;
                                }
                        }
 
                        if (ppfs->conv_num <= CONV_u) { /* pointer or unsigned int */
                                if (ppfs->conv_num == CONV_X) {
                                        alphacase = __UIM_UPPER;
                                }
                                if (ppfs->conv_num == CONV_p) { /* pointer */
                                        prefix_num = PREFIX_LWR_X;
                                } else {                /* unsigned int */
                                }
                        } else {                        /* signed int */
                                base = -base;
                        }
                        if (ppfs->info.prec < 0) { /* Ignore '0' flag if prec specified. */
                                padchar = ppfs->info.pad;
                        }
#ifdef __UCLIBC_MJN3_ONLY__
#ifdef L_vfprintf
#warning CONSIDER: If using outdigits and/or grouping, how should we interpret precision?
#endif
#endif /* __UCLIBC_MJN3_ONLY__ */
                        s = _uintmaxtostr(buf + sizeof(buf) - 1,
                                                          (uintmax_t)
                                                          _load_inttype(*argtype & __PA_INTMASK,
                                                                                        *argptr, base), base, alphacase);
                        if (ppfs->conv_num > CONV_u) { /* signed int */
                                if (*s == '-') {
                                        PRINT_INFO_SET_FLAG(&(ppfs->info),showsign);
                                        ++s;            /* handle '-' in the prefix string */
                                        prefix_num = PREFIX_MINUS;
                                } else if (PRINT_INFO_FLAG_VAL(&(ppfs->info),showsign)) {
                                        prefix_num = PREFIX_PLUS;
                                } else if (PRINT_INFO_FLAG_VAL(&(ppfs->info),space)) {
                                        prefix_num = PREFIX_SPACE;
                                }
                        }
                        slen = (char *)(buf + sizeof(buf) - 1) - s;
#ifdef L_vfwprintf
                        {
                                const char *q = s;
                                mbstate.mask = 0; /* Initialize the mbstate. */
                                SLEN = mbsrtowcs(NULL, &q, 0, &mbstate);
                        }
#endif
                        numfill = ((ppfs->info.prec < 0) ? 1 : ppfs->info.prec);
                        if (PRINT_INFO_FLAG_VAL(&(ppfs->info),alt)) {
                                if (ppfs->conv_num <= CONV_x) { /* x or p */
                                        prefix_num = PREFIX_LWR_X;
                                }
                                if (ppfs->conv_num == CONV_X) {
                                        prefix_num = PREFIX_UPR_X;
                                }
                                if ((ppfs->conv_num == CONV_o) && (numfill <= SLEN)) {
                                        numfill = ((*s == '0') ? 1 : SLEN + 1);
                                }
                        }
                        if (*s == '0') {
                                if (prefix_num >= PREFIX_LWR_X) {
                                        prefix_num = PREFIX_NONE;
                                }
                                if (ppfs->conv_num == CONV_p) {/* null pointer */
                                        s = "(nil)";
#ifdef L_vfwprintf
                                        SLEN =
#endif
                                        slen = 5;
                                        numfill = 0;
                                } else if (numfill == 0) {       /* if precision 0, no output */
#ifdef L_vfwprintf
                                        SLEN =
#endif
                                        slen = 0;
                                }
                        }
                        numfill = ((numfill > SLEN) ? numfill - SLEN : 0);
                } else if (ppfs->conv_num <= CONV_A) {  /* floating point */
#ifdef __STDIO_PRINTF_FLOAT
                        *count +=
                                _fpmaxtostr(stream,
                                                        (__fpmax_t)
                                                        (PRINT_INFO_FLAG_VAL(&(ppfs->info),is_long_double)
                                                         ? *(long double *) *argptr
                                                         : (long double) (* (double *) *argptr)),
                                                        &ppfs->info, FP_OUT );
                        return 0;
#else  /* __STDIO_PRINTF_FLOAT */
                        return -1;                      /* TODO -- try to continue? */
#endif /* __STDIO_PRINTF_FLOAT */
                } else if (ppfs->conv_num <= CONV_S) {  /* wide char or string */
#ifdef L_vfprintf
 
#ifdef __UCLIBC_HAS_WCHAR__
                        mbstate.mask = 0;        /* Initialize the mbstate. */
                        if (ppfs->conv_num == CONV_S) { /* wide string */
                                if (!(ws = *((const wchar_t **) *argptr))) {
                                        goto NULL_STRING;
                                }
                                /* We use an awful uClibc-specific hack here, passing
                                 * (char*) &ws as the conversion destination.  This signals
                                 * uClibc's wcsrtombs that we want a "restricted" length
                                 * such that the mbs fits in a buffer of the specified
                                 * size with no partial conversions. */
                                if ((slen = wcsrtombs((char *) &ws, &ws, /* Use awful hack! */
                                                                          ((ppfs->info.prec >= 0)
                                                                           ? ppfs->info.prec
                                                                           : SIZE_MAX), &mbstate))
                                        == ((size_t)-1)
                                        ) {
                                        return -1;      /* EILSEQ */
                                }
                        } else {                        /* wide char */
                                s = buf;
                                slen = wcrtomb(s, (*((const wchar_t *) *argptr)), &mbstate);
                                if (slen == ((size_t)-1)) {
                                        return -1;      /* EILSEQ */
                                }
                                s[slen] = 0;     /* TODO - Is this necessary? */
                        }
#else  /* __UCLIBC_HAS_WCHAR__ */
                        return -1;
#endif /* __UCLIBC_HAS_WCHAR__ */
                } else if (ppfs->conv_num <= CONV_s) {  /* char or string */
                        if (ppfs->conv_num == CONV_s) { /* string */
                                s = *((char **) (*argptr));
                                if (s) {
#ifdef __STDIO_PRINTF_M_SUPPORT
                                SET_STRING_LEN:
#endif
                                        slen = strnlen(s, ((ppfs->info.prec >= 0)
                                                                           ? ppfs->info.prec : SIZE_MAX));
                                } else {
#ifdef __UCLIBC_HAS_WCHAR__
                                NULL_STRING:
#endif
                                        s = "(null)";
                                        slen = 6;
                                }
                        } else {                        /* char */
                                s = buf;
                                *s = (unsigned char)(*((const int *) *argptr));
                                s[1] = 0;
                                slen = 1;
                        }
 
#else  /* L_vfprintf */
 
                        if (ppfs->conv_num == CONV_S) { /* wide string */
                                ws = *((wchar_t **) (*argptr));
                                if (!ws) {
                                        goto NULL_STRING;
                                }
                                SLEN = wcsnlen(ws, ((ppfs->info.prec >= 0)
                                                                        ? ppfs->info.prec : SIZE_MAX));
                        } else {                        /* wide char */
                                *wbuf = (wchar_t)(*((const wint_t *) *argptr));
                        CHAR_CASE:
                                ws = wbuf;
                                wbuf[1] = 0;
                                SLEN = 1;
                        }
 
                } else if (ppfs->conv_num <= CONV_s) {  /* char or string */
 
                        if (ppfs->conv_num == CONV_s) { /* string */
#ifdef __UCLIBC_MJN3_ONLY__
#warning TODO: Fix %s for vfwprintf... output upto illegal sequence?
#endif /* __UCLIBC_MJN3_ONLY__ */
                                s = *((char **) (*argptr));
                                if (s) {
#ifdef __STDIO_PRINTF_M_SUPPORT
                                SET_STRING_LEN:
#endif
                                        /* We use an awful uClibc-specific hack here, passing
                                         * (wchar_t*) &mbstate as the conversion destination.
                                         *  This signals uClibc's mbsrtowcs that we want a
                                         * "restricted" length such that the mbs fits in a buffer
                                         * of the specified size with no partial conversions. */
                                        {
                                                const char *q = s;
                                                mbstate.mask = 0;        /* Initialize the mbstate. */
                                                SLEN = mbsrtowcs((wchar_t *) &mbstate, &q,
                                                                                 ((ppfs->info.prec >= 0)
                                                                                  ? ppfs->info.prec : SIZE_MAX),
                                                                                 &mbstate);
                                        }
                                        if (SLEN == ((size_t)(-1))) {
                                                return -1;      /* EILSEQ */
                                        }
                                } else {
                                NULL_STRING:
                                        s = "(null)";
                                        SLEN = slen = 6;
                                }
                        } else {                        /* char */
                                *wbuf = btowc( (unsigned char)(*((const int *) *argptr)) );
                                goto CHAR_CASE;
                        }
 
#endif /* L_vfprintf */
 
#ifdef __STDIO_PRINTF_M_SUPPORT
                } else if (ppfs->conv_num == CONV_m) {
                        s = _glibc_strerror_r(errno, buf, sizeof(buf));
                        goto SET_STRING_LEN;
#endif
                } else {
#ifdef __STDIO_GLIBC_CUSTOM_PRINTF
                        assert(ppfs->conv_num == CONV_custom0);
 
                        s = _custom_printf_spec;
                        do {
                                if (*s == ppfs->info.spec) {
                                        int rv;
                                        /* TODO -- check return value for sanity? */
                                        rv = (*_custom_printf_handler
                                                  [(int)(s-_custom_printf_spec)])
                                                (stream, &ppfs->info, argptr);
                                        if (rv < 0) {
                                                return -1;
                                        }
                                        *count += rv;
                                        return 0;
                                }
                        } while (++s < (_custom_printf_spec + MAX_USER_SPEC));
#endif /* __STDIO_GLIBC_CUSTOM_PRINTF */
                        assert(0);
                        return -1;
                }
 
#ifdef __UCLIBC_MJN3_ONLY__
#ifdef L_vfprintf
#warning CONSIDER: If using outdigits and/or grouping, how should we pad?
#endif
#endif /* __UCLIBC_MJN3_ONLY__ */
                {
                        size_t t;
 
                        t = SLEN + numfill;
                        if (prefix_num != PREFIX_NONE) {
                                t += ((prefix_num < PREFIX_LWR_X) ? 1 : 2);
                        }
                        numpad = ((ppfs->info.width > t) ? (ppfs->info.width - t) : 0);
                        *count += t + numpad;
                }
                if (padchar == '0') { /* TODO: check this */
                        numfill += numpad;
                        numpad = 0;
                }
 
                /* Now handle the output itself. */
                if (!PRINT_INFO_FLAG_VAL(&(ppfs->info),left)) {
                        _charpad(stream, ' ', numpad);
                        numpad = 0;
                }
                OUTPUT(stream, prefix + prefix_num);
                _charpad(stream, '0', numfill);
 
#ifdef L_vfprintf
 
#ifdef __UCLIBC_HAS_WCHAR__
                if (!ws) {
                        assert(s);
                        _outnstr(stream, s, slen);
                } else {                                /* wide string */
                        size_t t;
                        mbstate.mask = 0;        /* Initialize the mbstate. */
                        while (slen) {
                                t = (slen <= sizeof(buf)) ? slen : sizeof(buf);
                                t = wcsrtombs(buf, &ws, t, &mbstate);
                                assert (t != ((size_t)(-1)));
                                _outnstr(stream, buf, t);
                                slen -= t;
                        }
                }
#else  /* __UCLIBC_HAS_WCHAR__ */
                _outnstr(stream, s, slen);
#endif /* __UCLIBC_HAS_WCHAR__ */
 
#else  /* L_vfprintf */
 
                if (!ws) {
                        assert(s);
                        _outnstr(stream, s, SLEN);
                } else {
                        _outnwcs(stream, ws, SLEN);
                }
 
#endif /* L_vfprintf */
                _charpad(stream, ' ', numpad);
        }
 
        return 0;
}
 
int VFPRINTF (FILE * __restrict stream,
                          register const FMT_TYPE * __restrict format,
                          va_list arg)
{
        ppfs_t ppfs;
        int count, r;
        register const FMT_TYPE *s;
 
        __STDIO_THREADLOCK(stream);
 
        count = 0;
        s = format;
 
#if defined(L_vfprintf) && defined(__UCLIBC_HAS_WCHAR__)
        /* Sigh... I forgot that by calling _stdio_fwrite, vfprintf doesn't
         * always check the stream's orientation.  This is just a temporary
         * fix until I rewrite the stdio core work routines. */
        if (stream->modeflags & __FLAG_WIDE) {
                stream->modeflags |= __FLAG_ERROR;
                count = -1;
                goto DONE;
        }
        stream->modeflags |= __FLAG_NARROW;
#endif
 
        if (_PPFS_init(&ppfs, format) < 0) { /* Bad format string. */
                OUTNSTR(stream, (const FMT_TYPE *) ppfs.fmtpos,
                                STRLEN((const FMT_TYPE *)(ppfs.fmtpos)));
#if defined(L_vfprintf) && !defined(NDEBUG)
                fprintf(stderr,"\nIMbS: \"%s\"\n\n", format);
#endif
                count = -1;
        } else {
                _ppfs_prepargs(&ppfs, arg);     /* This did a va_copy!!! */
 
                do {
                        while (*format && (*format != '%')) {
                                ++format;
                        }
 
                        if (format-s) {         /* output any literal text in format string */
                                if ( (r = OUTNSTR(stream, s, format-s)) < 0) {
                                        count = -1;
                                        break;
                                }
                                count += r;
                        }
 
                        if (!*format) {                 /* we're done */
                                break;
                        }
 
                        if (format[1] != '%') { /* if we get here, *format == '%' */
                                /* TODO: _do_one_spec needs to know what the output funcs are!!! */
                                ppfs.fmtpos = (const char *)(++format);
                                /* TODO: check -- should only fail on stream error */
                                if ( (r = _do_one_spec(stream, &ppfs, &count)) < 0) {
                                        count = -1;
                                        break;
                                }
                                s = format = (const FMT_TYPE *) ppfs.fmtpos;
                        } else {                        /* %% means literal %, so start new string */
                                s = ++format;
                                ++format;
                        }
                } while (1);
 
                va_end(ppfs.arg);               /* Need to clean up after va_copy! */
        }
 
#if defined(L_vfprintf) && defined(__UCLIBC_HAS_WCHAR__)
 DONE:
#endif
 
        __STDIO_THREADUNLOCK(stream);
 
        return count;
}
#endif
/**********************************************************************/
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [uClibc/] [libc/] [stdio/] [printf.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1325	phoenix	`/* Copyright (C) 2002, 2003 Manuel Novoa III`
2			`* My stdio library for linux and (soon) elks.`
3			`*`
4			`* This library is free software; you can redistribute it and/or`
5			`* modify it under the terms of the GNU Library General Public`
6			`* License as published by the Free Software Foundation; either`
7			`* version 2 of the License, or (at your option) any later version.`
8			`*`
9			`* This library is distributed in the hope that it will be useful,`
10			`* but WITHOUT ANY WARRANTY; without even the implied warranty of`
11			`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU`
12			`* Library General Public License for more details.`
13			`*`
14			`* You should have received a copy of the GNU Library General Public`
15			`* License along with this library; if not, write to the Free`
16			`* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.`
17			`*/`
18
19			`/* This code needs a lot of clean up. Some of that is on hold until uClibc`
20			`* gets a better configuration system (on Erik's todo list).`
21			`* The other cleanup will take place during the implementation/integration of`
22			`* the wide char (un)formatted i/o functions which I'm currently working on.`
23			`*/`
24
25			`/* ATTENTION! ATTENTION! ATTENTION! ATTENTION! ATTENTION!`
26			`*`
27			`* This code is currently under development. Also, I plan to port`
28			`* it to elks which is a 16-bit environment with a fairly limited`
29			`* compiler. Therefore, please refrain from modifying this code`
30			`* and, instead, pass any bug-fixes, etc. to me. Thanks. Manuel`
31			`*`
32			`* ATTENTION! ATTENTION! ATTENTION! ATTENTION! ATTENTION! */`
33
34
35			`/* April 1, 2002`
36			`* Initialize thread locks for fake files in vsnprintf and vdprintf.`
37			`* reported by Erik Andersen (andersen@codepoet.com)`
38			`* Fix an arg promotion handling bug in _do_one_spec for %c.`
39			`* reported by Ilguiz Latypov <ilatypov@superbt.com>`
40			`*`