summaryrefslogtreecommitdiff
path: root/libc/stdio/printf.c
diff options
context:
space:
mode:
Diffstat (limited to 'libc/stdio/printf.c')
-rw-r--r--libc/stdio/printf.c3259
1 files changed, 4 insertions, 3255 deletions
diff --git a/libc/stdio/printf.c b/libc/stdio/printf.c
index bc184ee5f..67db4b384 100644
--- a/libc/stdio/printf.c
+++ b/libc/stdio/printf.c
@@ -1,1582 +1,13 @@
-/* Copyright (C) 2002, 2003 Manuel Novoa III
- * My stdio library for linux and (soon) elks.
+/* Copyright (C) 2004 Manuel Novoa III <mjn3@codepoet.org>
*
- * 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.
+ * GNU Library General Public License (LGPL) version 2 or later.
*
- * 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.
+ * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details.
*/
-/* 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 "_stdio.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;
@@ -1588,1685 +19,3 @@ int printf(const char * __restrict format, ...)
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
-/**********************************************************************/