From 870f09e54eb0a7e1651dd2066589627d312f77e2 Mon Sep 17 00:00:00 2001
From: Manuel Novoa III <mjn3@codepoet.org>
Date: Tue, 12 Mar 2002 01:41:56 +0000
Subject: Deal with cvs "feature"... or is that cvs _user_...
---
libc/stdio/printf.c | 2033 +++++++++++++++++++++++++++++++++
libc/stdio/stdio.c | 3171 +++++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 5204 insertions(+)
create mode 100644 libc/stdio/printf.c
create mode 100644 libc/stdio/stdio.c
(limited to 'libc')
diff --git a/libc/stdio/printf.c b/libc/stdio/printf.c
new file mode 100644
index 000000000..ad4da445b
--- /dev/null
+++ b/libc/stdio/printf.c
@@ -0,0 +1,2033 @@
+/* Copyright (C) 2002 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! */
+
+#define _ISOC99_SOURCE /* for ULLONG primarily... */
+#define _GNU_SOURCE
+#define _STDIO_UTILITY /* We're using _uintmaxtostr. */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stddef.h>
+#include <ctype.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <stdint.h>
+#include <errno.h>
+
+#define __PRINTF_INFO_NO_BITFIELD
+#include <printf.h>
+
+#ifdef __STDIO_THREADSAFE
+#include <pthread.h>
+#endif /* __STDIO_THREADSAFE */
+
+/**********************************************************************/
+
+#define __STDIO_GLIBC_CUSTOM_PRINTF
+
+/* TODO -- move these to a configuration section? */
+#define MAX_FIELD_WIDTH 4095
+#define MAX_USER_SPEC 10
+#define MAX_POS_ARGS 10
+
+/* TODO - fix the defs below */
+#define MAX_ARGS_PER_SPEC (MAX_POS_ARGS-2)
+
+#if MAX_ARGS_PER_SPEC + 2 > MAX_POS_ARGS
+#define MAX_ARGS MAX_ARGS_PER_SPEC + 2
+#else
+#define MAX_ARGS MAX_POS_ARGS
+#endif
+
+/**********************************************************************/
+
+#define __PA_FLAG_INTMASK \
+ (__PA_FLAG_CHAR|PA_FLAG_SHORT|__PA_FLAG_INT|PA_FLAG_LONG|PA_FLAG_LONG_LONG)
+
+extern printf_function *_custom_printf_handler[MAX_USER_SPEC];
+extern printf_arginfo_function *_custom_printf_arginfo[MAX_USER_SPEC];
+extern char *_custom_printf_spec;
+
+/**********************************************************************/
+
+#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 */
+};
+
+/**********************************************************************/
+
+/* 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,
+ CONV_m,
+ 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. */
+#if PTRDIFF_MAX != INT_MAX
+#error fix QUAL_CHARS ptrdiff_t entry 't'!
+#endif
+#if SIZE_MAX != UINT_MAX
+#error fix QUAL_CHARS size_t entries 'z', 'Z'!
+#endif
+#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
+
+#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, 8, 0, 0, 8, 0, 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
+#ifndef __BCC__
+ double d;
+ long double ld;
+#endif
+ 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;
+ int maxposarg; /* > 0 if args are positional, 0 if not, -1 if unknown */
+ 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
+ /* 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. */
+
+/* TODO -- __isdigit() macro */
+#define __isdigit(c) (((unsigned int)(c - '0')) < 10)
+
+extern size_t _dtostr(FILE * fp, long double x, struct printf_info *info);
+
+#define _outnstr(stream, string, len) _stdio_fwrite(s, len, stream) /* TODO */
+
+extern int _do_one_spec(FILE * __restrict stream, ppfs_t *ppfs, int *count);
+
+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 */
+
+/**********************************************************************/
+#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, int *argtypes)
+{
+ ppfs_t ppfs;
+ size_t i;
+ size_t count = 0;
+
+ if (_ppfs_init(&ppfs, template) >= 0) {
+ 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. */
+ 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;
+ }
+ }
+ }
+ }
+
+ return count;
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_vfprintf
+
+/* 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. */
+
+/* TODO -- Implement grouping flag... on hold (locale support). */
+
+int vfprintf(FILE * __restrict stream, register const char * __restrict format,
+ va_list arg)
+{
+ ppfs_t ppfs;
+ int count, r;
+ register const char *s;
+
+ __STDIO_THREADLOCK(stream);
+
+ count = 0;
+ s = format;
+
+ if (_ppfs_init(&ppfs, format) < 0) { /* Bad format string. */
+ _outnstr(stream, format, strlen(format));
+ count = -1;
+ } else {
+ _ppfs_prepargs(&ppfs, arg);
+
+ 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 = ++format;
+ /* TODO: check -- should only fail on stream error */
+ if ( (r = _do_one_spec(stream, &ppfs, &count)) < 0) {
+ count = -1;
+ break;
+ }
+ s = format = ppfs.fmtpos;
+ } else { /* %% means literal %, so start new string */
+ s = ++format;
+ ++format;
+ }
+ } while (1);
+ }
+
+ __STDIO_THREADUNLOCK(stream);
+
+ 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???? */
+ --ppfs->maxposarg; /* set to -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 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 */
+ }
+
+ /* 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;
+ }
+ }
+
+ return 0;
+}
+#endif
+/**********************************************************************/
+#ifdef L__ppfs_prepargs
+void _ppfs_prepargs(register ppfs_t *ppfs, va_list arg)
+{
+ int i;
+
+ __va_copy(ppfs->arg, arg);
+
+ 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
+/**********************************************************************/
+#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;
+
+ if (ppfs->maxposarg == 0) { /* initing for or no pos args */
+ 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;
+#ifndef __BCC__
+ /* 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
+ case PA_DOUBLE:
+ case (PA_DOUBLE|PA_FLAG_LONG_DOUBLE):
+ assert(0);
+#endif
+ 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;
+ }
+ } 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);
+ }
+ }
+
+ /* 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,
+#ifndef __BCC__
+ /* PA_FLOAT, */
+ PA_DOUBLE,
+ PA_DOUBLE|PA_FLAG_LONG_DOUBLE,
+#endif
+};
+
+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),
+#ifndef __BCC__
+ /* PROMOTED_SIZE_OF(float), */
+ PROMOTED_SIZE_OF(double),
+ PROMOTED_SIZE_OF(long double),
+#endif
+};
+
+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
+
+/* 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];
+
+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;
+ int maxposarg;
+ int p_m_spec_chars;
+ int n;
+ int argtype[MAX_ARGS_PER_SPEC+2];
+ int argnumber[3]; /* width, precision, 1st data arg */
+ unsigned int conv_num;
+ 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;
+
+ /* WIDE note: we can test against '%' here since we don't allow */
+ /* WIDE note: other mappings of '%' in the wide char set. */
+ preci = -1;
+ width = flags = dpoint = 0;
+ argnumber[0] = 0;
+ argnumber[1] = 0;
+ argtype[0] = __PA_NOARG;
+ argtype[1] = __PA_NOARG;
+ maxposarg = ppfs->maxposarg;
+ fmt = ppfs->fmtpos;
+
+ 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 */
+
+ 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) {
+ 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. */
+ }
+
+ 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. */
+ if (maxposarg) {
+ if ((*fmt++ != '$') || (i <= 0)) {
+ /* Using pos args and no $ or invalid arg number. */
+ return -1;
+ }
+ argnumber[-dpoint] = i;
+ } else 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 */
+ }
+
+ 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_GLIBC_CUSTOM_PRINTF
+ /* TODO -- gnu %m support build option. */
+ if (*fmt == 'm') {
+ conv_num = CONV_m;
+ ppfs->num_data_args = 0;
+ goto DONE;
+ }
+
+ /* Handle custom arg -- WARNING -- overwrites p!!! */
+ 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;
+ }
+
+#ifdef __STDIO_GLIBC_CUSTOM_PRINTF
+ DONE:
+#endif
+
+ 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 {
+ ppfs->argnumber[2] = 1;
+ memcpy(ppfs->argtype, argtype + 2, ppfs->num_data_args * sizeof(int));
+ }
+
+ ppfs->maxposarg = maxposarg;
+ ppfs->fmtpos = ++fmt;
+ ppfs->conv_num = conv_num;
+
+ return ppfs->num_data_args + 2;
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_register_printf_function
+
+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
+/**********************************************************************/
+#ifdef L__do_one_spec
+
+printf_function *_custom_printf_handler[MAX_USER_SPEC];
+
+extern void _store_inttype(void *dest, int desttype, uintmax_t val);
+extern uintmax_t _load_inttype(int desttype, const void *src, int uflag);
+extern void _charpad(FILE * __restrict stream, char padchar, size_t numpad);
+extern void output(FILE * __restrict stream, const char *s);
+
+#define output(F,S) fputs(S,F)
+
+#undef putc
+void _charpad(FILE * __restrict stream, char padchar, size_t numpad)
+{
+ /* TODO -- Use a buffer to cut down on function calls... */
+ char pad[1];
+
+ *pad = padchar;
+ while (numpad) {
+ _stdio_fwrite(pad, 1, stream);
+ --numpad;
+ }
+}
+
+/* TODO -- Dynamically allocate work space to accomodate stack-poor archs? */
+
+int _do_one_spec(FILE * __restrict stream, register ppfs_t *ppfs, int *count)
+{
+ static const char spec_base[] = SPEC_BASE;
+ static const char prefix[] = "+\0-\0 \0000x\0000X";
+ /* 0 2 4 6 9 11*/
+ 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;
+ size_t slen;
+ int base;
+ int numpad;
+ int numfill = 0; /* TODO: fix */
+ int prefix_num = PREFIX_NONE;
+ char padchar = ' ';
+ char buf[64];
+
+#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;
+ if (ppfs->maxposarg > 0) { /* Using positional args... */
+ argptr += ppfs->argnumber[2] - 1;
+ }
+#else
+ /* Need to build a local copy... */
+ {
+ register argvalue_t *p = ppfs->argvalue;
+ int i;
+ if (ppfs->maxposarg > 0) { /* Using positional args... */
+ p += ppfs->argnumber[2] - 1;
+ }
+ for (i = 0 ; i < ppfs->num_data_args ; i++ ) {
+ argptr[i] = (void *) p++;
+ }
+ }
+#endif
+ {
+ register char *s;
+
+ 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 */
+ base = spec_base[(int)(ppfs->conv_num - CONV_p)];
+ if (ppfs->conv_num <= CONV_u) { /* pointer or unsigned int */
+ 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;
+ }
+ s = _uintmaxtostr(buf + sizeof(buf) - 1,
+ (uintmax_t)
+ _load_inttype(*argtype & __PA_INTMASK,
+ *argptr, base), base,
+ ((ppfs->conv_num == CONV_X)
+ ? __UIM_UPPER : __UIM_LOWER));
+ 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;
+ 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)";
+ slen = 5;
+ numfill = 0;
+ } else if (numfill == 0) { /* if precision 0, no output */
+ slen = 0;
+ }
+ }
+ numfill = ((numfill > slen) ? numfill - slen : 0);
+ } else if (ppfs->conv_num <= CONV_A) { /* floating point */
+ *count += _dtostr(stream,
+ (PRINT_INFO_FLAG_VAL(&(ppfs->info),is_long_double)
+ ? *(long double *) *argptr
+ : (long double) (* (double *) *argptr)),
+ &ppfs->info);
+ return 0;
+ } else if (ppfs->conv_num <= CONV_S) { /* wide char or string */
+#if 1
+ return -1; /* TODO -- wide */
+#else
+ if (ppfs->conv_num == CONV_S) { /* wide string */
+
+ } else { /* wide char */
+
+ }
+#endif
+ } else if (ppfs->conv_num <= CONV_s) { /* char or string */
+ if (ppfs->conv_num == CONV_s) { /* string */
+ s = *((char **) (*argptr));
+ if (s) {
+ SET_STRING_LEN:
+ slen = strnlen(s, ((ppfs->info.prec >= 0)
+ ? ppfs->info.prec : SIZE_MAX));
+ } else {
+ s = "(null)";
+ slen = 6;
+ }
+ } else { /* char */
+ s = (char *) buf;
+ *s = *((const char *) *argptr);
+ s[1] = 0;
+ slen = 1;
+ }
+ } else if (ppfs->conv_num == CONV_m) {
+ s = strerror(errno);
+ goto SET_STRING_LEN;
+ } else {
+ 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));
+ assert(0);
+ return -1;
+ }
+
+ {
+ 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);
+ _outnstr(stream, s, slen);
+ _charpad(stream, ' ', numpad);
+ }
+
+ return 0;
+}
+#endif
+/**********************************************************************/
+#ifdef L_vsnprintf
+#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.bufrpos = f.bufwpos = 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);
+
+ rv = vfprintf(&f, format, arg);
+ if (size) {
+ if (f.bufwpos == f.bufend) {
+ --f.bufwpos;
+ }
+ *f.bufwpos = 0;
+ }
+ return rv;
+}
+#else /* __STDIO_BUFFERS */
+#ifdef __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(void *cookie, const char *buf, size_t bufsize)
+{
+ size_t count;
+ 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);
+
+ rv = vfprintf(&f, format, arg);
+
+ return rv;
+}
+
+#else /* __STDIO_GLIBC_CUSTOM_STREAMS */
+#warning skipping vsnprintf since no buffering and no custom streams!
+#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */
+#endif /* __STDIO_BUFFERS */
+#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.bufrpos = f.bufwpos = 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);
+
+ rv = vfprintf(&f, format, arg);
+
+ return fflush(&f) ? -1 : rv;
+}
+#endif
+/**********************************************************************/
+#ifdef L_vasprintf
+
+#if !defined(__STDIO_BUFFERS) && !defined(__STDIO_GLIBC_CUSTOM_STREAMS)
+#warning skipping vasprintf since no buffering and no custom streams!
+#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. */
+
+ int rv = vsnprintf(NULL, 0, format, arg);
+
+ 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
+
+#if !defined(__STDIO_BUFFERS) && !defined(__STDIO_GLIBC_CUSTOM_STREAMS)
+#warning skipping vsprintf since no buffering and no custom streams!
+#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
+
+#if !defined(__STDIO_BUFFERS) && !defined(__STDIO_GLIBC_CUSTOM_STREAMS)
+#warning skipping snprintf since no buffering and no custom streams!
+#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
+
+#if !defined(__STDIO_BUFFERS) && !defined(__STDIO_GLIBC_CUSTOM_STREAMS)
+#warning skipping asprintf and __asprintf since no buffering and no custom streams!
+#else
+
+weak_alias(__asprintf,asprintf)
+
+int __asprintf(char **__restrict buf, const char * __restrict format, ...)
+{
+ va_list arg;
+ int rv;
+
+ va_start(arg, format);
+ rv = vasprintf(buf, format, arg);
+ va_end(arg);
+
+ return rv;
+}
+
+#endif
+#endif
+/**********************************************************************/
+#ifdef L_printf
+int printf(const char * __restrict format, ...)
+{
+ va_list arg;
+ int rv;
+
+ va_start(arg, format);
+ rv = vfprintf(stdout, format, arg);
+ va_end(arg);
+
+ return rv;
+}
+#endif
+/**********************************************************************/
+#ifdef L_sprintf
+
+#if !defined(__STDIO_BUFFERS) && !defined(__STDIO_GLIBC_CUSTOM_STREAMS)
+#warning skipping sprintf since no buffering and no custom streams!
+#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__dtostr
+/*
+ * Copyright (C) 2000, 2001 Manuel Novoa III
+ *
+ * Function: size_t _dtostr(FILE *fp, long double x, struct printf_info *info)
+ *
+ * This was written for uClibc to provide floating point support for
+ * the printf functions. It handles +/- infinity and nan on i386.
+ *
+ * Notes:
+ *
+ * At most MAX_DIGITS 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 not assumptions are made about the
+ * bit-layout of doubles.
+ *
+ * It should be too difficult to convert this to handle long doubles on i386.
+ * For information, see the comments below.
+ *
+ * TODO:
+ * long double and/or float version? (note: for float can trim code some).
+ *
+ * Decrease the size. This is really much bigger than I'd like.
+ */
+
+/*****************************************************************************/
+/* Don't change anything that follows unless you know what you're doing. */
+/*****************************************************************************/
+
+/*
+ * Configuration for the scaling power table. Ignoring denormals, you
+ * should have 2**EXP_TABLE_SIZE >= LDBL_MAX_EXP >= 2**(EXP_TABLE_SIZE-1).
+ * The minimum for standard C is 6. For IEEE 8bit doubles, 9 suffices.
+ * For long doubles on i386, use 13.
+ */
+#define EXP_TABLE_SIZE 13
+
+/*
+ * Set this to the maximum number of digits you want converted.
+ * Conversion is done in blocks of DIGITS_PER_BLOCK (9 by default) digits.
+ * (20) 17 digits suffices to uniquely determine a (long) double on i386.
+ */
+#define MAX_DIGITS 20
+
+/*
+ * Set this to the smallest integer type capable of storing a pointer.
+ */
+#define INT_OR_PTR int
+
+/*
+ * This is really only used to check for infinities. The macro produces
+ * smaller code for i386 and, since this is tested before any floating point
+ * calculations, it doesn't appear to suffer from the excess precision problem
+ * caused by the FPU that strtod had. If it causes problems, call the function
+ * and compile zoicheck.c with -ffloat-store.
+ */
+#define _zero_or_inf_check(x) ( x == (x/4) )
+
+/*
+ * Fairly portable nan check. Bitwise for i386 generated larger code.
+ * If you have a better version, comment this out.
+ */
+#define isnan(x) (x != x)
+
+/*****************************************************************************/
+/* Don't change anything that follows peroid!!! ;-) */
+/*****************************************************************************/
+
+#include <float.h>
+
+/*****************************************************************************/
+
+/*
+ * Set things up for the scaling power table.
+ */
+
+#if EXP_TABLE_SIZE < 6
+#error EXP_TABLE_SIZE should be at least 6 to comply with standards
+#endif
+
+#define EXP_TABLE_MAX (1U<<(EXP_TABLE_SIZE-1))
+
+/*
+ * Only bother checking if this is too small.
+ */
+
+#if LDBL_MAX_10_EXP/2 > EXP_TABLE_MAX
+#error larger EXP_TABLE_SIZE needed
+#endif
+
+/*
+ * With 32 bit ints, we can get 9 digits per block.
+ */
+#define DIGITS_PER_BLOCK 9
+
+#if UINT_MAX >= 4294967295UL
+#define DIGIT_BLOCK_TYPE int
+#define DB_FMT "%.*d"
+#elif LONG_MAX >= 4294967295UL
+#define DIGIT_BLOCK_TYPE long
+#define DB_FMT "%.*ld"
+#else
+#error need at least 32 bit longs
+#endif
+
+/* Maximum number of calls to fnprintf to output double. */
+#define MAX_CALLS 8
+
+/*****************************************************************************/
+
+#define NUM_DIGIT_BLOCKS ((MAX_DIGITS+DIGITS_PER_BLOCK-1)/DIGITS_PER_BLOCK)
+
+/* extra space for '-', '.', 'e+###', and nul */
+#define BUF_SIZE ( 3 + NUM_DIGIT_BLOCKS * DIGITS_PER_BLOCK )
+/*****************************************************************************/
+
+static const char *fmts[] = {
+ "%0*d", "%.*s", ".", "inf", "INF", "nan", "NAN", "%*s"
+};
+
+/*****************************************************************************/
+
+size_t _dtostr(FILE * fp, long double x, struct printf_info *info)
+{
+ long double exp_table[EXP_TABLE_SIZE];
+ long double p10;
+ DIGIT_BLOCK_TYPE digit_block; /* int of at least 32 bits */
+ int i, j;
+ int round, o_exp;
+ int exp, exp_neg;
+ int width, preci;
+ char *s;
+ char *e;
+ char buf[BUF_SIZE];
+ INT_OR_PTR pc_fwi[2*MAX_CALLS];
+ INT_OR_PTR *ppc;
+ char exp_buf[8];
+ char drvr[8];
+ char *pdrvr;
+ int npc;
+ int cnt;
+ char sign_str[2];
+ char o_mode;
+ char mode;
+
+ /* check that INT_OR_PTR is sufficiently large */
+ assert( sizeof(INT_OR_PTR) == sizeof(char *) );
+
+ width = info->width;
+ preci = info->prec;
+ mode = info->spec;
+ if (mode == 'a') {
+ mode = 'g'; /* TODO -- fix */
+ }
+ if (mode == 'A') {
+ mode = 'G'; /* TODO -- fix */
+ }
+
+ 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 = flag[FLAG_PLUS]; */
+ *(sign_str+1) = 0;
+ if (isnan(x)) { /* nan check */
+ pdrvr = drvr + 1;
+ *pdrvr++ = 5 + (mode < 'a');
+ pc_fwi[2] = 3;
+ info->pad = ' ';
+/* flag[FLAG_0_PAD] = 0; */
+ goto EXIT_SPECIAL;
+ }
+
+ if (x == 0) { /* handle 0 now to avoid false positive */
+ exp = -1;
+ goto GENERATE_DIGITS;
+ }
+
+ if (x < 0) { /* convert negatives to positives */
+ *sign_str = '-';
+ x = -x;
+ }
+
+ if (_zero_or_inf_check(x)) { /* must be inf since zero handled above */
+ pdrvr = drvr + 1;
+ *pdrvr++ = 3 + + (mode < 'a');
+ pc_fwi[2] = 3;
+ info->pad = ' ';
+/* flag[FLAG_0_PAD] = 0; */
+ goto EXIT_SPECIAL;
+ }
+
+ /* need to build the scaling table */
+ for (i = 0, p10 = 10 ; i < EXP_TABLE_SIZE ; i++) {
+ exp_table[i] = p10;
+ p10 *= p10;
+ }
+
+ exp_neg = 0;
+ if (x < 1e8) { /* do we need to scale up or down? */
+ exp_neg = 1;
+ }
+
+ exp = DIGITS_PER_BLOCK - 1;
+
+ i = EXP_TABLE_SIZE;
+ j = EXP_TABLE_MAX;
+ while ( i-- ) { /* scale x such that 1e8 <= x < 1e9 */
+ if (exp_neg) {
+ if (x * exp_table[i] < 1e9) {
+ x *= exp_table[i];
+ exp -= j;
+ }
+ } else {
+ if (x / exp_table[i] >= 1e8) {
+ x /= exp_table[i];
+ exp += j;
+ }
+ }
+ j >>= 1;
+ }
+ if (x >= 1e9) { /* handle bad rounding case */
+ x /= 10;
+ ++exp;
+ }
+ assert(x < 1e9);
+
+ GENERATE_DIGITS:
+ s = buf + 2; /* leave space for '\0' and '0' */
+#if 1
+#define ONE_E_NINE 1000000000L
+#else
+#define ONE_E_NINE 1e9
+#endif
+ for (i = 0 ; i < NUM_DIGIT_BLOCKS ; ++i ) {
+ digit_block = (DIGIT_BLOCK_TYPE) x;
+ x = (x - digit_block) * ONE_E_NINE;
+ s += sprintf(s, DB_FMT, DIGITS_PER_BLOCK, digit_block);
+ }
+
+ /*************************************************************************/
+
+ *exp_buf = 'e';
+ if (mode < 'a') {
+ *exp_buf = 'E';
+ mode += ('a' - 'A');
+ }
+
+ o_mode = mode;
+
+ round = preci;
+
+ if ((mode == 'g') && (round > 0)){
+ --round;
+ }
+
+ if (mode == 'f') {
+ round += exp;
+ }
+
+ s = buf;
+ *s++ = 0; /* terminator for rounding and 0-triming */
+ *s = '0'; /* space to round */
+
+ i = 0;
+ e = s + MAX_DIGITS + 1;
+ if (round < MAX_DIGITS) {
+ e = s + round + 2;
+ if (*e >= '5') {
+ i = 1;
+ }
+ }
+
+ do { /* handle rounding and trim trailing 0s */
+ *--e += i; /* add the carry */
+ } while ((*e == '0') || (*e > '9'));
+
+ o_exp = exp;
+ if (e <= s) { /* we carried into extra digit */
+ ++o_exp;
+ e = s; /* needed if all 0s */
+ } else {
+ ++s;
+ }
+ *++e = 0; /* ending nul char */
+
+ if ((mode == 'g') && ((o_exp >= -4) && (o_exp <= round))) {
+ mode = 'f';
+ }
+
+ exp = o_exp;
+ if (mode != 'f') {
+ o_exp = 0;
+ }
+
+ if (o_exp < 0) {
+ *--s = '0'; /* fake the first digit */
+ }
+
+ pdrvr = drvr+1;
+ ppc = pc_fwi+2;
+
+ *pdrvr++ = 0;
+ *ppc++ = 1;
+ *ppc++ = (INT_OR_PTR)(*s++ - '0');
+
+ i = e - s; /* total digits */
+ if (o_exp >= 0) {
+ if (o_exp >= i) { /* all digit(s) left of decimal */
+ *pdrvr++ = 1;
+ *ppc++ = i;
+ *ppc++ = (INT_OR_PTR)(s);
+ o_exp -= i;
+ i = 0;
+ if (o_exp>0) { /* have 0s left of decimal */
+ *pdrvr++ = 0;
+ *ppc++ = o_exp;
+ *ppc++ = 0;
+ }
+ } else if (o_exp > 0) { /* decimal between digits */
+ *pdrvr++ = 1;
+ *ppc++ = o_exp;
+ *ppc++ = (INT_OR_PTR)(s);
+ s += o_exp;
+ i -= o_exp;
+ }
+ o_exp = -1;
+ }
+
+ if (PRINT_INFO_FLAG_VAL(info,alt)
+/* flag[FLAG_HASH] */
+ || (i) || ((o_mode != 'g') && (preci > 0))) {
+ *pdrvr++ = 2; /* need decimal */
+ *ppc++ = 1; /* needed for width calc */
+ ppc++;
+ }
+
+ if (++o_exp < 0) { /* have 0s right of decimal */
+ *pdrvr++ = 0;
+ *ppc++ = -o_exp;
+ *ppc++ = 0;
+ }
+ if (i) { /* have digit(s) right of decimal */
+ *pdrvr++ = 1;
+ *ppc++ = i;
+ *ppc++ = (INT_OR_PTR)(s);
+ }
+
+ if (o_mode != 'g') {
+ i -= o_exp;
+ if (i < preci) { /* have 0s right of digits */
+ i = preci - i;
+ *pdrvr++ = 0;
+ *ppc++ = i;
+ *ppc++ = 0;
+ }
+ }
+
+ /* build exponent string */
+ if (mode != 'f') {
+ *pdrvr++ = 1;
+ *ppc++ = sprintf(exp_buf,"%c%+.2d", *exp_buf, exp);
+ *ppc++ = (INT_OR_PTR) exp_buf;
+ }
+
+ EXIT_SPECIAL:
+ npc = pdrvr - drvr;
+ ppc = pc_fwi + 2;
+ for (i=1 ; i< npc ; i++) {
+ width -= *(ppc++);
+ ppc++;
+ }
+ i = 0;
+ if (*sign_str) {
+ i = 1;
+ }
+ width -= i;
+ if (width <= 0) {
+ width = 0;
+ } else {
+ if (PRINT_INFO_FLAG_VAL(info,left)) { /* padding on right */
+/* flag[FLAG_MINUS_LJUSTIFY] */
+ ++npc;
+ *pdrvr++ = 7;
+ *ppc = width;
+ *++ppc = (INT_OR_PTR)("");
+ width = 0;
+ } else if (info->pad == '0') { /* 0 padding */
+/* (flag[FLAG_0_PAD] == '0') */
+ pc_fwi[2] += width;
+ width = 0;
+ }
+ }
+ *drvr = 7;
+ ppc = pc_fwi;
+ *ppc++ = width + i;
+ *ppc = (INT_OR_PTR) sign_str;
+
+ pdrvr = drvr;
+ ppc = pc_fwi;
+ cnt = 0;
+ for (i=0 ; i<npc ; i++) {
+#if 1
+ fprintf(fp, fmts[(int)(*pdrvr++)], (INT_OR_PTR)(*(ppc)),
+ (INT_OR_PTR)(*(ppc+1)));
+#else
+ j = fprintf(fp, fmts[(int)(*pdrvr++)], (INT_OR_PTR)(*(ppc)),
+ (INT_OR_PTR)(*(ppc+1)));
+ assert(j == *ppc);
+#endif
+/* if (size > *ppc) { */
+/* size -= *ppc; */
+/* } */
+ cnt += *ppc; /* to avoid problems if j == -1 */
+ ppc += 2;
+ }
+
+ return cnt;
+}
+#endif
+/**********************************************************************/
+#ifdef L__store_inttype
+/* TODO -- right now, assumes intmax_t is either long or long long */
+
+/* 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, 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 (destsize == 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
+/**********************************************************************/
diff --git a/libc/stdio/stdio.c b/libc/stdio/stdio.c
new file mode 100644
index 000000000..01e0e35e9
--- /dev/null
+++ b/libc/stdio/stdio.c
@@ -0,0 +1,3171 @@
+/* Copyright (C) 2002 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.
+ */
+
+/* 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! */
+
+#define _ISOC99_SOURCE /* for ULLONG primarily... */
+#define _GNU_SOURCE
+#define _STDIO_UTILITY /* for _stdio_fdout and _uintmaxtostr. */
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <stdint.h>
+#include <stdarg.h>
+#include <errno.h>
+#include <assert.h>
+#include <stdio_ext.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+/**********************************************************************/
+/* First deal with some build issues... */
+
+#ifndef __STDIO_THREADSAFE
+/* Just build empty object files if any of these were defined. */
+/* Note though that we do keep the various *_unlocked names as aliases. */
+#undef L___fsetlocking
+#undef L___flockfile
+#undef L___ftrylockfile
+#undef L___funlockfile
+#endif
+
+#ifndef __STDIO_LARGE_FILES
+/* Just build empty object files if any of these were defined. */
+#undef L_fopen64
+#undef L_freopen64
+#undef L_ftello64
+#undef L_fseeko64
+#undef L_fsetpos64
+#undef L_fgetpos64
+#endif
+
+/**********************************************************************/
+
+/* TODO -- make this the default except for bcc with it's broken preproc? */
+#ifdef __UCLIBC__
+#define _stdin stdin
+#define _stdout stdout
+#define _stderr stderr
+#endif /* __UCLIBC__ */
+
+/**********************************************************************/
+
+#ifndef __STDIO_THREADSAFE
+
+#define UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,STREAM) \
+strong_alias(NAME,NAME##_unlocked) \
+RETURNTYPE NAME PARAMS
+
+#define UNLOCKED(RETURNTYPE,NAME,PARAMS,ARGS) \
+ UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,stream)
+
+#define UNLOCKED_VOID_RETURN(NAME,PARAMS,ARGS) \
+strong_alias(NAME,NAME##_unlocked) \
+void NAME PARAMS
+
+#define __STDIO_THREADLOCK_OPENLIST
+#define __STDIO_THREADUNLOCK_OPENLIST
+
+#else /* __STDIO_THREADSAFE */
+
+#include <pthread.h>
+
+#define UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,STREAM) \
+RETURNTYPE NAME PARAMS \
+{ \
+ RETURNTYPE retval; \
+ __STDIO_THREADLOCK(STREAM); \
+ retval = NAME##_unlocked ARGS ; \
+ __STDIO_THREADUNLOCK(STREAM); \
+ return retval; \
+} \
+RETURNTYPE NAME##_unlocked PARAMS
+
+#define UNLOCKED(RETURNTYPE,NAME,PARAMS,ARGS) \
+ UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,stream)
+
+#define UNLOCKED_VOID_RETURN(NAME,PARAMS,ARGS) \
+void NAME PARAMS \
+{ \
+ __STDIO_THREADLOCK(stream); \
+ NAME##_unlocked ARGS ; \
+ __STDIO_THREADUNLOCK(stream); \
+} \
+void NAME##_unlocked PARAMS
+
+#define __STDIO_THREADLOCK_OPENLIST \
+ pthread_mutex_lock(&_stdio_openlist_lock)
+
+#define __STDIO_THREADUNLOCK_OPENLIST \
+ pthread_mutex_unlock(&_stdio_openlist_lock)
+
+#define __STDIO_THREADTRYLOCK_OPENLIST \
+ pthread_mutex_trylock(&_stdio_openlist_lock)
+
+#endif /* __STDIO_THREADSAFE */
+
+/**********************************************************************/
+
+#ifdef __STDIO_WIDE
+#define __STDIO_FILE_INIT_UNGOT { 0, 0 }, { 0, 0 },
+#else
+#define __STDIO_FILE_INIT_UNGOT { 0, 0 },
+#endif
+
+#ifdef __STDIO_GETC_MACRO
+#define __STDIO_FILE_INIT_BUFGETC(x) x,
+#else
+#define __STDIO_FILE_INIT_BUFGETC(x)
+#endif
+
+#ifdef __STDIO_PUTC_MACRO
+#define __STDIO_FILE_INIT_BUFPUTC(x) x,
+#else
+#define __STDIO_FILE_INIT_BUFPUTC(x)
+#endif
+
+#if defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS)
+#define __STDIO_FILE_INIT_NEXT(next) (next),
+#else /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */
+#define __STDIO_FILE_INIT_NEXT(next)
+#endif /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */
+
+#ifdef __STDIO_BUFFERS
+#define __STDIO_FILE_INIT_BUFFERS(buf,bufsize) \
+ (buf), (buf)+(bufsize), (buf), (buf),
+#else
+#define __STDIO_FILE_INIT_BUFFERS(buf,bufsize)
+#endif
+
+#ifdef __STDIO_GLIBC_CUSTOM_STREAMS
+#define __STDIO_FILE_INIT_CUSTOM_STREAM(stream) \
+ &((stream).filedes), { _cs_read, _cs_write, NULL, _cs_close },
+#else
+#define __STDIO_FILE_INIT_CUSTOM_STREAM(stream)
+#endif
+
+#ifdef __STDIO_THREADSAFE
+#define __STDIO_FILE_INIT_THREADSAFE \
+ 0, PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP,
+#else
+#define __STDIO_FILE_INIT_THREADSAFE
+#endif
+
+#define __STDIO_INIT_FILE_STRUCT(stream, flags, filedes, next, buf, bufsize) \
+ { (flags), \
+ __STDIO_FILE_INIT_UNGOT \
+ (filedes), \
+ __STDIO_FILE_INIT_NEXT(next) \
+ __STDIO_FILE_INIT_BUFFERS(buf,bufsize) \
+ __STDIO_FILE_INIT_BUFGETC((buf)) \
+ __STDIO_FILE_INIT_BUFPUTC((buf)) \
+ __STDIO_FILE_INIT_CUSTOM_STREAM(stream) \
+ __STDIO_FILE_INIT_THREADSAFE \
+} /* TODO: mbstate and builtin buf */
+
+#ifdef __STDIO_MBSTATE_DATA
+extern void _init_mbstate(mbstate_t *dest);
+
+#define __COMMA_CLEAN_MBSTATE , 0
+#define __COPY_MBSTATE(dest,src) memcpy(dest, src, sizeof(mbstate_t))
+#define __INIT_MBSTATE(dest) _init_mbstate(dest)
+#else
+#define __COMMA_CLEAN_MBSTATE
+#define __COPY_MBSTATE(dest,src)
+#define __INIT_MBSTATE(dest)
+#endif
+
+#ifdef __STDIO_GLIBC_CUSTOM_STREAMS
+
+/* TODO -- what does glibc do for undefined funcs? errno set? */
+#define __READ(STREAMPTR,BUF,SIZE) \
+ ((((STREAMPTR)->gcs.read) == NULL) ? -1 : \
+ (((STREAMPTR)->gcs.read)((STREAMPTR)->cookie,(BUF),(SIZE))))
+#define __WRITE(STREAMPTR,BUF,SIZE) \
+ ((((STREAMPTR)->gcs.write) == NULL) ? -1 : \
+ (((STREAMPTR)->gcs.write)((STREAMPTR)->cookie,(BUF),(SIZE))))
+#define __CLOSE(STREAMPTR) \
+ ((((STREAMPTR)->gcs.close) == NULL) ? 0 : \
+ (((STREAMPTR)->gcs.close)((STREAMPTR)->cookie)))
+
+#else /* __STDIO_GLIBC_CUSTOM_STREAMS */
+
+#define __READ(STREAMPTR,BUF,SIZE) \
+ (read((STREAMPTR)->filedes,(BUF),(SIZE)))
+#define __WRITE(STREAMPTR,BUF,SIZE) \
+ (write((STREAMPTR)->filedes,(BUF),(SIZE)))
+#define __CLOSE(STREAMPTR) \
+ (close((STREAMPTR)->filedes))
+
+#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */
+
+/**********************************************************************/
+/* POSIX functions */
+/**********************************************************************/
+#ifdef L_getw
+
+/* SUSv2 Legacy function -- need not be reentrant. */
+
+int getw (register FILE *stream)
+{
+ int aw[1];
+
+#ifdef __STDIO_WIDE
+
+ return (fread((void *)aw, sizeof(int), 1, stream) > 0) ? (*aw) : EOF;
+
+#else /* __STDIO_WIDE */
+
+ return (_stdio_fread((unsigned char *)(aw), sizeof(int), stream)
+ == sizeof(int)) ? (*aw) : EOF;
+
+#endif /* __STDIO_WIDE */
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_putw
+
+/* SUSv2 Legacy function -- need not be reentrant. */
+
+int putw (int w, register FILE *stream)
+{
+ int aw[1];
+
+ *aw = w; /* In case 'w' is in a register... */
+
+#ifdef __STDIO_WIDE
+
+ return (fwrite((void *)aw, sizeof(int), 1, stream) == 1) ? 0 : EOF;
+
+#else /* __STDIO_WIDE */
+
+ return (_stdio_fwrite((unsigned char *)aw, sizeof(int), stream)
+ == sizeof(int)) ? 0 : EOF;
+
+#endif /* __STDIO_WIDE */
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_fileno
+
+/* Reentrancy handled by UNLOCKED() macro. */
+
+UNLOCKED(int,fileno,(register FILE *stream),(stream))
+{
+#ifdef __STDIO_GLIBC_CUSTOM_STREAMS
+ return ( ((stream->cookie == &(stream->filedes)) && (stream->filedes >= 0))
+ ? stream->filedes
+ : (__set_errno(EBADF), -1) );
+#else /* __STDIO_GLIBC_CUSTOM_STREAMS */
+ return (stream->filedes >= 0) ? stream->filedes : (__set_errno(EBADF), -1);
+#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_fdopen
+
+/* No reentrancy issues. */
+
+FILE *fdopen(int filedes, const char *mode)
+{
+ register char *cur_mode; /* TODO -- replace by intptr_t?? */
+
+ return (((int)(cur_mode = (char *) fcntl(filedes, F_GETFL))) != -1)
+ ? _stdio_fopen(cur_mode, mode, NULL, filedes)
+ : NULL;
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_fopen64
+
+/* No reentrancy issues. */
+
+FILE *fopen64(const char * __restrict filename, const char * __restrict mode)
+{
+ return _stdio_fopen(filename, mode, NULL, -2);
+}
+
+#endif
+/**********************************************************************/
+/* BSD functions */
+/**********************************************************************/
+#ifdef L_setbuffer
+
+/* No reentrancy issues. */
+
+void setbuffer(FILE * __restrict stream, register char * __restrict buf,
+ size_t size)
+{
+#ifdef __STDIO_BUFFERS
+ setvbuf(stream, buf, (buf ? _IOFBF : _IONBF), size);
+#else /* __STDIO_BUFFERS */
+ /* Nothing to do. */
+#endif /* __STDIO_BUFFERS */
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_setlinebuf
+
+/* No reentrancy issues. */
+
+void setlinebuf(FILE * __restrict stream)
+{
+#ifdef __STDIO_BUFFERS
+ setvbuf(stream, NULL, _IOLBF, (size_t) BUFSIZ);
+#else /* __STDIO_BUFFERS */
+ /* Nothing to do. */
+#endif /* __STDIO_BUFFERS */
+}
+
+#endif
+/**********************************************************************/
+/* GLIBC functions */
+/**********************************************************************/
+#ifdef L_fcloseall
+
+/* NOTE: GLIBC difference!!! -- fcloseall
+ * According to the info pages, glibc actually fclose()s all open files.
+ * Apparently, glibc's new version only fflush()s and unbuffers all
+ * writing streams to cope with unordered destruction of c++ static
+ * objects. Here we implement the old behavior as default.
+ */
+
+/* Not reentrant. */
+
+int fcloseall (void)
+{
+#if defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS)
+ register FILE *stream;
+ int rv;
+
+ _stdio_term(); /* Let _stdio_term() do all the work. */
+
+ rv = 0;
+ for (stream = _stdio_openlist ; stream ; stream = stream->nextopen) {
+ if (stream->modeflags & (__FLAG_WRITING|__FLAG_ERROR)) {
+ /* TODO -- is this correct? Maybe ferror set before flush...
+ * could check if pending writable but what if term unbuffers?
+ * in that case, could clear error flag... */
+ rv = EOF; /* Only care about failed writes. */
+ }
+ }
+
+ /* Make sure _stdio_term() does nothing on exit. */
+ _stdio_openlist = NULL;
+
+ return rv;
+#else /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */
+
+ return 0;
+
+#endif /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_fmemopen
+#ifdef __STDIO_GLIBC_CUSTOM_STREAMS
+
+typedef struct {
+ size_t pos;
+ size_t len;
+ size_t eof;
+ int dynbuf;
+ unsigned char *buf;
+ FILE *fp;
+} __fmo_cookie;
+
+#define COOKIE ((__fmo_cookie *)