Logo Search packages:      
Sourcecode: uclibc version File versions  Download package

vfprintf.c

/*  Copyright (C) 2002-2004     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 <features.h>
#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 __UCLIBC_HAS_THREADS__
#include <stdio_ext.h>
#include <pthread.h>
#endif /* __UCLIBC_HAS_THREADS__ */

#ifdef __UCLIBC_HAS_WCHAR__
#include <wchar.h>
#endif /* __UCLIBC_HAS_WCHAR__ */

#include <bits/uClibc_uintmaxtostr.h>

/* 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 __UCLIBC_HAS_PRINTF_M_SPEC__ */


/**********************************************************************/

#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(__UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__)
#define __STDIO_HAS_VSNPRINTF 1
#endif

/**********************************************************************/

/* Now controlled by uClibc_stdio.h. */
/* #define __UCLIBC_HAS_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 __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__

#define MAX_USER_SPEC       10
#define MAX_ARGS_PER_SPEC    5

#else  /* __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ */

#undef MAX_USER_SPEC
#define MAX_ARGS_PER_SPEC    1

#endif /* __UCLIBC_HAS_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 __UCLIBC_HAS_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 /* __UCLIBC_HAS_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 __UCLIBC_HAS_PRINTF_M_SPEC__
      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(__UCLIBC_HAS_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 __UCLIBC_HAS_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 /* __UCLIBC_HAS_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 __UCLIBC_HAS_PRINTF_M_SPEC__
#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 /* __UCLIBC_HAS_PRINTF_M_SPEC__ */
                        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 __UCLIBC_HAS_PRINTF_M_SPEC__
            if (*fmt == 'm') {
                  ppfs->conv_num = CONV_m;
                  ppfs->num_data_args = 0;
                  goto DONE;
            }
#endif
#ifdef __UCLIBC_HAS_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 /* __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ */
            /* Otherwise error. */
            return -1;
      }
            
#if defined(__UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__) || defined(__UCLIBC_HAS_PRINTF_M_SPEC__)
 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 __UCLIBC_HAS_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
/**********************************************************************/
#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_unlocked(S,F)
/* #define _outnstr(stream, string, len)  __stdio_fwrite(string, len, stream) */
#define _outnstr(stream, string, len)     ((len > 0) ? __stdio_fwrite(string, len, stream) : 0)
#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 __UCLIBC_HAS_PRINTF_M_SPEC__
                        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 __UCLIBC_HAS_PRINTF_M_SPEC__
                        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 __UCLIBC_HAS_PRINTF_M_SPEC__
            } else if (ppfs->conv_num == CONV_m) {
                  s = _glibc_strerror_r(errno, buf, sizeof(buf));
                  goto SET_STRING_LEN;
#endif
            } else {
#ifdef __UCLIBC_HAS_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 /* __UCLIBC_HAS_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_AUTO_THREADLOCK_VAR;

      __STDIO_AUTO_THREADLOCK(stream);

      count = 0;
      s = format;

      if 
#ifdef L_vfprintf
      (!__STDIO_STREAM_IS_NARROW_WRITING(stream)
       && __STDIO_STREAM_TRANS_TO_WRITE(stream, __FLAG_NARROW))
#else
      (!__STDIO_STREAM_IS_WIDE_WRITING(stream)
       && __STDIO_STREAM_TRANS_TO_WRITE(stream, __FLAG_WIDE))
#endif
      {
            count = -1;
      } else 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_AUTO_THREADUNLOCK(stream);

      return count;
}
#endif
/**********************************************************************/

Generated by  Doxygen 1.6.0   Back to index