diff options
Diffstat (limited to 'libc')
| -rw-r--r-- | libc/stdio/printf.c | 2033 | ||||
| -rw-r--r-- | libc/stdio/stdio.c | 3171 |
2 files changed, 5204 insertions, 0 deletions
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 *) cookie) + +static ssize_t fmo_read(void *cookie, register char *buf, size_t bufsize) +{ + size_t count = COOKIE->len - COOKIE->pos; + + /* Note: bufsize < SSIZE_MAX because of _stdio_READ. */ + + if (bufsize > count) { + bufsize = count; + } + +#if 1 /* TODO - choose code option */ + memcpy(buf, COOKIE->buf + COOKIE->pos, bufsize); + COOKIE->pos += bufsize; +#else + { + register char *p = COOKIE->buf + COOKIE->pos; + + count = bufsize; + while (count) { + *buf++ = *p++; + --count; + } + COOKIE->pos += bufsize; + } +#endif + + return bufsize; +} + +static ssize_t fmo_write(void *cookie, register const char *buf, size_t bufsize) +{ + size_t count; + + /* Note: bufsize < SSIZE_MAX because of _stdio_WRITE. */ + + /* If appending, need to seek to end of file!!!! */ + if (COOKIE->fp->modeflags & __FLAG_APPEND) { + COOKIE->pos = COOKIE->eof; + } + + count = COOKIE->len - COOKIE->pos; + + if (bufsize > count) { + bufsize = count; + if (count == 0) { /* We're at the end of the buffer... */ + errno = EFBIG; + return -1; + } + } + +#if 1 /* TODO - choose code option */ + memcpy(COOKIE->buf + COOKIE->pos, buf, bufsize); + COOKIE->pos += bufsize; + + if (COOKIE->pos > COOKIE->eof) { + COOKIE->eof = COOKIE->pos; + if (bufsize < count) { /* New eof and still room in buffer? */ + *(COOKIE->buf + COOKIE->pos) = 0; + } + } + +#else + { + register char *p = COOKIE->buf + COOKIE->pos; + size_t i = bufsize; + + while (i > 0) { + *p++ = *buf++; + --i; + } + COOKIE->pos += bufsize; + + if (COOKIE->pos > COOKIE->eof) { + COOKIE->eof = COOKIE->pos; + if (bufsize < count) { /* New eof and still room in buffer? */ + *p = 0; + } + } + } + +#endif + + return bufsize; +} + +/* glibc doesn't allow seeking, but it has in-buffer seeks... we don't. */ +static int fmo_seek(void *cookie, __offmax_t *pos, int whence) +{ + __offmax_t p = *pos; + + /* Note: fseek already checks that whence is legal, so don't check here + * unless debugging. */ + assert(((unsigned int) whence) <= 2); + + if (whence != SEEK_SET) { + p += (whence == SEEK_CUR) ? COOKIE->pos : /* SEEK_END */ COOKIE->eof; + } + + /* Note: glibc only allows seeking in the buffer. We'll actually restrict + * to the data. */ + /* Check for offset < 0, offset > eof, or offset overflow... */ + if (((uintmax_t) p) > COOKIE->eof) { + return -1; + } + + COOKIE->pos = *pos = p; + return 0; +} + +static int fmo_close(void *cookie) +{ + if (COOKIE->dynbuf) { + free(COOKIE->buf); + } + free(cookie); + return 0; +} + +#undef COOKIE + +static const cookie_io_functions_t _fmo_io_funcs = { + fmo_read, fmo_write, fmo_seek, fmo_close +}; + +/* TODO: If we have buffers enabled, it might be worthwile to add a pointer + * to the FILE in the cookie and have read, write, and seek operate directly + * on the buffer itself (ie replace the FILE buffer with the cookie buffer + * and update FILE bufstart, etc. whenever we seek). */ + +FILE *fmemopen(void *s, size_t len, const char *modes) +{ + FILE *fp; + __fmo_cookie *cookie; + size_t i; + + if ((cookie = malloc(sizeof(__fmo_cookie))) != NULL) { + cookie->len = len; + cookie->eof = cookie->pos = 0; /* pos and eof adjusted below. */ + cookie->dynbuf = 0; + if (((cookie->buf = s) == NULL) && (len > 0)) { + if ((cookie->buf = malloc(len)) == NULL) { + goto EXIT_cookie; + } + cookie->dynbuf = 1; + *cookie->buf = 0; /* If we're appending, treat as empty file. */ + } + +#ifndef __BCC__ + fp = fopencookie(cookie, modes, _fmo_io_funcs); +#else + fp = fopencookie(cookie, modes, &_fmo_io_funcs); +#endif + /* Note: We don't need to worry about locking fp in the thread case + * as the only possible access would be a close or flush with + * nothing currently in the FILE's write buffer. */ + + if (fp != NULL) { + cookie->fp = fp; + if ((fp->modeflags & __FLAG_APPEND) && (len > 0)) { + for (i = 0 ; i < len ; i++) { + if (cookie->buf[i] == 0) { + break; + } + } + cookie->eof = cookie->pos = i; /* Adjust eof and pos. */ + } + return fp; + } + } + + if (!s) { + free(cookie->buf); + } + EXIT_cookie: + free(cookie); + + return NULL; +} + +#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */ +#endif +/**********************************************************************/ +#ifdef L_open_memstream +#ifdef __STDIO_GLIBC_CUSTOM_STREAMS + +#define COOKIE ((__oms_cookie *) cookie) + +typedef struct { + char *buf; + size_t len; + size_t pos; + size_t eof; + char **bufloc; + size_t *sizeloc; +} __oms_cookie; + +/* Nothing to do here, as memstreams are write-only. */ +/* static ssize_t oms_read(void *cookie, char *buf, size_t bufsize) */ +/* { */ +/* } */ + +static ssize_t oms_write(void *cookie, const char *buf, size_t bufsize) +{ + char *newbuf; + size_t count; + + /* Note: we already know bufsize < SSIZE_MAX... */ + + count = COOKIE->len - COOKIE->pos - 1; + assert(COOKIE->pos < COOKIE->len); /* Always nul-terminate! */ + + if (bufsize > count) { + newbuf = realloc(COOKIE->buf, COOKIE->len + bufsize - count); + if (newbuf) { + *COOKIE->bufloc = COOKIE->buf = newbuf; + COOKIE->len += (bufsize - count); + } else { + bufsize = count; + if (count == 0) { + errno = EFBIG; /* TODO: check glibc errno setting... */ + return -1; + } + } + } + + memcpy(COOKIE->buf + COOKIE->pos, buf, bufsize); + COOKIE->pos += bufsize; + + if (COOKIE->pos > COOKIE->eof) { + *COOKIE->sizeloc = COOKIE->eof = COOKIE->pos; + } + + return bufsize; +} + +static int oms_seek(void *cookie, __offmax_t *pos, int whence) +{ + __offmax_t p = *pos; + char *buf; + size_t leastlen; + + /* Note: fseek already checks that whence is legal, so don't check here + * unless debugging. */ + assert(((unsigned int) whence) <= 2); + + if (whence != SEEK_SET) { + p += (whence == SEEK_CUR) ? COOKIE->pos : /* SEEK_END */ COOKIE->eof; + } + + /* Note: glibc only allows seeking in the buffer. We'll actually restrict + * to the data. */ + /* Check for offset < 0, offset >= too big (need nul), or overflow... */ + if (((uintmax_t) p) >= SIZE_MAX - 1) { + return -1; + } + + leastlen = ((size_t) p) + 1; /* New pos + 1 for nul if necessary. */ + + if (leastlen >= COOKIE->len) { /* Need to grow buffer... */ + buf = realloc(COOKIE->buf, leastlen); + if (buf) { + *COOKIE->bufloc = COOKIE->buf = buf; + COOKIE->len = leastlen; + memset(buf + COOKIE->eof, leastlen - COOKIE->eof, 0); /* 0-fill */ + } else { + /* TODO: check glibc errno setting... */ + return -1; + } + } + + *pos = COOKIE->pos = --leastlen; + + if (leastlen > COOKIE->eof) { + memset(COOKIE->buf + COOKIE->eof, leastlen - COOKIE->eof, 0); + *COOKIE->sizeloc = COOKIE->eof; + } + + return 0; +} + +static int oms_close(void *cookie) +{ + free(cookie); + return 0; +} + +#undef COOKIE + +static const cookie_io_functions_t _oms_io_funcs = { + NULL, oms_write, oms_seek, oms_close +}; + +/* TODO: If we have buffers enabled, it might be worthwile to add a pointer + * to the FILE in the cookie and operate directly on the buffer itself + * (ie replace the FILE buffer with the cookie buffer and update FILE bufstart, + * etc. whenever we seek). */ + +FILE *open_memstream(char **__restrict bufloc, size_t *__restrict sizeloc) +{ + __oms_cookie *cookie; + FILE *fp; + + if ((cookie = malloc(sizeof(__oms_cookie))) != NULL) { + if ((cookie->buf = malloc(cookie->len = BUFSIZ)) == NULL) { + goto EXIT_cookie; + } + *cookie->buf = 0; /* Set nul terminator for buffer. */ + *(cookie->bufloc = bufloc) = cookie->buf; + *(cookie->sizeloc = sizeloc) = cookie->eof = cookie->pos = 0; + +#ifndef __BCC__ + fp = fopencookie(cookie, "w", _oms_io_funcs); +#else + fp = fopencookie(cookie, "w", &_oms_io_funcs); +#endif + /* Note: We don't need to worry about locking fp in the thread case + * as the only possible access would be a close or flush with + * nothing currently in the FILE's write buffer. */ + + if (fp != NULL) { + return fp; + } + } + + if (cookie->buf != NULL) { + free(cookie->buf); + } + EXIT_cookie: + free(cookie); + + return NULL; +} + +#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */ +#endif +/**********************************************************************/ +#ifdef L_fopencookie +#ifdef __STDIO_GLIBC_CUSTOM_STREAMS + +/* NOTE: GLIBC difference!!! -- fopencookie + * According to the info pages, glibc allows seeking within buffers even if + * no seek function is supplied. We don't. */ + +/* NOTE: GLIBC difference!!! -- fopencookie + * When compiled without large file support, the offset pointer for the + * cookie_seek function is off_t * and not off64_t * as for glibc. */ + +/* TODO: rewrite _stdio_fopen() to avoid the fopencookie() kludge. */ + +/* Currently no real reentrancy issues other than a possible double close(). */ + +#ifndef __BCC__ + +FILE *fopencookie (void * __restrict cookie, const char * __restrict mode, + cookie_io_functions_t io_functions) +{ + FILE *stream; + int fd; + + if ((stream = _stdio_fopen("/dev/null", mode, NULL, -1)) != NULL) { + fd = stream->filedes; + stream->filedes = -1; + close(fd); + stream->gcs = io_functions; + stream->cookie = cookie; + } + +#if !defined(__STDIO_BUFFERS) && !defined(__STDIO_THREADSAFE) + /* I we don't have buffers or threads, we only need to worry about + * custom streams on the open list, as no flushing is necessary and + * no locking of possible underlying normal streams need be done. + * We do need to explicitly close custom streams on termination of stdio, + * and we need to lock the list as it can be modified by fclose(). */ + __STDIO_THREADLOCK_OPENLIST; + stream->nextopen = _stdio_openlist; /* New files are inserted at */ + _stdio_openlist = stream; /* the head of the list. */ + __STDIO_THREADUNLOCK_OPENLIST; +#endif /* !defined(__STDIO_BUFFERS) && !defined(__STDIO_THREADSAFE) */ + + return stream; +} + +#else /* __BCC__ */ + +/* NOTE: GLIBC difference!!! -- fopencookie (bcc only) + * Since bcc doesn't support passing of structs, we define fopencookie as a + * macro in terms of _fopencookie which takes a struct * for the io functions + * instead. + */ + +FILE *_fopencookie (void * __restrict cookie, const char * __restrict mode, + cookie_io_functions_t *io_functions) +{ + FILE *stream; + + if ((stream = _stdio_fopen("/dev/null", mode, NULL, -1)) != NULL) { + int fd = stream->filedes; + stream->filedes = -1; + close(fd); + stream->gcs.read = io_functions->read; + stream->gcs.write = io_functions->write; + stream->gcs.seek = io_functions->seek; + stream->gcs.close = io_functions->close; + stream->cookie = cookie; + } + +#if !defined(__STDIO_BUFFERS) && !defined(__STDIO_THREADSAFE) + /* I we don't have buffers or threads, we only need to worry about + * custom streams on the open list, as no flushing is necessary and + * no locking of possible underlying normal streams need be done. + * We do need to explicitly close custom streams on termination of stdio, + * and we need to lock the list as it can be modified by fclose(). */ + __STDIO_THREADLOCK_OPENLIST; + stream->nextopen = _stdio_openlist; /* New files are inserted at */ + _stdio_openlist = stream; /* the head of the list. */ + __STDIO_THREADUNLOCK_OPENLIST; +#endif /* !defined(__STDIO_BUFFERS) && !defined(__STDIO_THREADSAFE) */ + + return stream; +} + +#endif /* __BCC__ */ + +#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */ +#endif +/**********************************************************************/ +#ifdef L___fbufsize + +/* Not reentrant. */ + +size_t __fbufsize(register FILE * __restrict stream) +{ +#ifdef __STDIO_BUFFERS + return (stream->modeflags & __FLAG_NBF) + ? 0 : (stream->bufend - stream->bufstart); +#else /* __STDIO_BUFFERS */ + return 0; +#endif /* __STDIO_BUFFERS */ +} + +#endif +/**********************************************************************/ +#ifdef L___freading + +/* No reentrancy issues. */ + +int __freading(FILE * __restrict stream) +{ + return stream->modeflags & (__FLAG_READING|__FLAG_READONLY); +} + +#endif +/**********************************************************************/ +#ifdef L___fwriting + +/* No reentrancy issues. */ + +int __fwriting(FILE * __restrict stream) +{ + return stream->modeflags & (__FLAG_WRITING|__FLAG_WRITEONLY); +} + +#endif +/**********************************************************************/ +#ifdef L___freadable + +/* No reentrancy issues. */ + +int __freadable(FILE * __restrict stream) +{ + return ~(stream->modeflags & __FLAG_WRITEONLY); +} + +#endif +/**********************************************************************/ +#ifdef L___fwritable + +/* No reentrancy issues. */ + +int __fwritable(FILE * __restrict stream) +{ + return ~(stream->modeflags & __FLAG_READONLY); +} + +#endif +/**********************************************************************/ +#ifdef L___flbf + +/* No reentrancy issues. */ + +int __flbf(FILE * __restrict stream) +{ +#ifdef __STDIO_BUFFERS + return (stream->modeflags & __FLAG_LBF); +#else /* __STDIO_BUFFERS */ + /* TODO -- Even though there is no buffer, return flag setting? */ + return __FLAG_NBF; +#endif /* __STDIO_BUFFERS */ +} + +#endif +/**********************************************************************/ +#ifdef L___fpurge + +/* Not reentrant. */ + +void __fpurge(register FILE * __restrict stream) +{ +#ifdef __STDIO_BUFFERS +#ifdef __STDIO_PUTC_MACRO + stream->bufputc = /* Must disable putc. */ +#endif /* __STDIO_PUTC_MACRO */ +#ifdef __STDIO_GETC_MACRO + stream->bufgetc = /* Must disable getc. */ +#endif + stream->bufwpos = stream->bufrpos = stream->bufstart; /* Reset pointers. */ +#endif /* __STDIO_BUFFERS */ + /* Reset r/w flags and clear ungots. */ + stream->modeflags &= ~(__FLAG_READING|__FLAG_WRITING|__MASK_UNGOT); +} + +#endif +/**********************************************************************/ +#ifdef L___fpending + +/* Not reentrant. */ + +#ifdef __STDIO_WIDE +#warning TODO -- implement __fpending for wide streams! */ +#else /* __STDIO_WIDE */ +size_t __fpending(register FILE * __restrict stream) +{ +#ifdef __STDIO_BUFFERS + /* TODO -- should we check this? should we set errno? just assert? */ + return (stream->modeflags & (__FLAG_READING|__FLAG_READONLY)) + ? 0 : (stream->bufwpos - stream->bufstart); +#else /* __STDIO_BUFFERS */ + return 0; +#endif /* __STDIO_BUFFERS */ +} +#endif /* __STDIO_WIDE */ + +#endif +/**********************************************************************/ +#ifdef L__flushlbf + +/* No reentrancy issues. */ + +void _flushlbf(void) +{ +#ifdef __STDIO_BUFFERS + fflush((FILE *) &_stdio_openlist); /* Uses an implementation hack!!! */ +#else /* __STDIO_BUFFERS */ + /* Nothing to do. */ +#endif /* __STDIO_BUFFERS */ +} + +#endif +/**********************************************************************/ +#ifdef L___fsetlocking + +/* No (serious) reentrancy issues -- return value could be incorrect. */ +/* TODO -- fix race */ + +int __fsetlocking(FILE *stream, int locking_mode) +{ + int old_mode; + + assert((FSETLOCKING_QUERY == 0) && (FSETLOCKING_INTERNAL == 1) + && (FSETLOCKING_BYCALLER == 2)); + + assert(((unsigned int) locking_mode) <= 2); + + /* Note: don't even bother locking here... */ + + old_mode = stream->user_locking; + + if (locking_mode != FSETLOCKING_QUERY) { + /* In case we're not debugging, treat any unknown as a request to + * set internal locking, in order to match glibc behavior. */ + stream->user_locking = ((locking_mode == FSETLOCKING_BYCALLER) + ? FSETLOCKING_BYCALLER + : FSETLOCKING_INTERNAL); + } + + return old_mode; +} + +#endif +/**********************************************************************/ +#ifdef L_flockfile + +void flockfile(FILE *stream) +{ + pthread_mutex_lock(&stream->lock); +} + +#endif +/**********************************************************************/ +#ifdef L_ftrylockfile + +int ftrylockfile(FILE *stream) +{ + return pthread_mutex_trylock(&stream->lock); +} + +#endif +/**********************************************************************/ +#ifdef L_funlockfile + +void funlockfile(FILE *stream) +{ + pthread_mutex_unlock(&stream->lock); +} + +#endif +/**********************************************************************/ +/* my extension functions */ +/**********************************************************************/ +#ifdef L__stdio_fsfopen +/* + * Stack|Static File open -- open a file where the FILE is either + * stack or staticly allocated. + */ + +/* No reentrancy issues. */ + +FILE *_stdio_fsfopen(const char * __restrict filename, + const char * __restrict mode, + register FILE * __restrict stream) +{ +#ifdef __STDIO_BUFFERS + stream->modeflags = __FLAG_FBF; +#if __STDIO_BUILTIN_BUF_SIZE > 0 + stream->bufstart = stream->builtinbuf; + stream->bufend = stream->builtinbuf + sizeof(stream->builtinbuf); +#else /* __STDIO_BUILTIN_BUF_SIZE > 0 */ + stream->bufend = stream->bufstart = NULL; +#endif /* __STDIO_BUILTIN_BUF_SIZE > 0 */ +#endif /* __STDIO_BUFFERS */ + + return _stdio_fopen(filename, mode, stream, -1); +} +#endif +/**********************************************************************/ +/* stdio internal functions */ +/**********************************************************************/ +#ifdef L__stdio_adjpos +/* + * ANSI/ISO p. 370: The file positioning indicator is unspecified after + * a successful call to ungetwc. + * Note however, that this applies only to _user_ calls to ungetwc. We + * need to allow for internal calls by scanf. So we store the byte count + * of the first ungot wide char in ungot0_bytes. If it is 0 (user case) + * then the file position is treated as unknown. + */ + + +/* Internal function -- not reentrant. */ + +int _stdio_adjpos(register FILE * __restrict stream, + register __offmax_t *pos) +{ + __offmax_t r; + int cor = stream->modeflags & __MASK_UNGOT; /* handle ungots */ + +#ifdef __STDIO_WIDE + /* Assumed narrow stream so correct if wide. */ + if (cor && (stream->modeflags & __FLAG_WIDE)) { + cor = cor - 1 + stream->ungot_width[0]; + if ((stream->ungot_width[0] == 0) /* don't know byte count or */ + || ((stream->modeflags & __MASK_UNGOT) > 1)) { /* app case */ + return -1; + } + } +#endif /* __STDIO_WIDE */ +#ifdef __STDIO_BUFFERS + if (stream->modeflags & __FLAG_WRITING) { + cor -= (stream->bufwpos - stream->bufstart); /* pending writes */ + } + if (stream->modeflags & __FLAG_READING) { + cor += (stream->bufwpos - stream->bufrpos); /* extra's read */ + } +#endif /* __STDIO_BUFFERS */ + + r = *pos; + return ((*pos -= cor) > r) ? -cor : cor; +} + +#endif +/**********************************************************************/ +#ifdef L__stdio_lseek +/* + * This function is only called by fseek and ftell. + * fseek -- doesn't care about pos val, just success or failure. + * ftell -- needs pos val but offset == 0 and whence == SET_CUR. + */ + +/* Internal function -- not reentrant. */ + +int _stdio_lseek(FILE *stream, __offmax_t *pos, int whence) +{ + __offmax_t res; + +#ifdef __STDIO_GLIBC_CUSTOM_STREAMS + if (stream->cookie != &stream->filedes) { + return (((stream->gcs.seek == NULL) + || ((stream->gcs.seek)(stream->cookie, pos, whence) < 0)) + ? -1 : 0); + } +#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */ +#ifdef __STDIO_LARGE_FILES + res = lseek64(stream->filedes, *pos, whence); +#else + res = lseek(stream->filedes, *pos, whence); +#endif /* __STDIO_LARGE_FILES */ + return (res >= 0) ? ((*pos = res), 0) : -1; +} + +#endif +/**********************************************************************/ +#ifdef L__stdio_fread +/* + * NOTE!!! This routine is meant to be callable by both narrow and wide + * functions. However, if called by a wide function, there must be + * NO pending ungetwc()s!!! + */ + +/* Unlike write, it's ok for read to return fewer than bufsize, since + * we may not need all of them. */ +static ssize_t _stdio_READ(FILE *stream, void *buf, size_t bufsize) +{ + ssize_t rv; + + if (bufsize == 0) { + return 0; + } + + if (bufsize > SSIZE_MAX) { + bufsize = SSIZE_MAX; + } + +#ifdef __BCC__ + TRY_READ: +#endif + rv = __READ(stream, buf, bufsize); + if (rv > 0) { +#ifdef __STDIO_GLIBC_CUSTOM_STREAMS + assert(rv <= bufsize); /* buggy user handler... TODO: check? */ + if (rv > bufsize) { /* Num reported written > number requested */ + rv = bufsize; /* Treat as a full read??? */ + } +#endif + } else if (rv == 0) { + stream->modeflags |= __FLAG_EOF; + } else { +#ifdef __BCC__ + if (errno == EINTR) { + goto TRY_READ; + } +#endif + stream->modeflags |= __FLAG_ERROR; + rv = 0; + } + + return rv; +} + +/* Internal function -- not reentrant. */ + +size_t _stdio_fread(unsigned char *buffer, size_t bytes, + register FILE *stream) +{ + __stdio_validate_FILE(stream); /* debugging only */ + +#ifdef __STDIO_BUFFERS + + if (stream->modeflags +#ifdef __STDIO_AUTO_RW_TRANSITION + & (__FLAG_WRITEONLY) +#else /* __STDIO_AUTO_RW_TRANSITION */ + /* ANSI/ISO and SUSv3 require not currently writing. */ + & (__FLAG_WRITEONLY|__FLAG_WRITING) +#endif /* __STDIO_AUTO_RW_TRANSITION */ + ) { +#ifdef __STDIO_PUTC_MACRO + stream->bufputc = stream->bufstart; /* Must disable putc. */ +#endif /* __STDIO_PUTC_MACRO */ + stream->modeflags |= __FLAG_ERROR; + /* TODO: This is for posix behavior if writeonly. To save space, we + * use this errno for read attempt while writing, as no errno is + * specified by posix for this case, even though the restriction is + * mentioned in fopen(). */ + errno = EBADF; + return 0; + } + + /* We need to disable putc and getc macros in case of error */ +#if defined(__STDIO_PUTC_MACRO) || defined(__STDIO_GETC_MACRO) +#ifdef __STDIO_PUTC_MACRO + stream->bufputc = +#endif /* __STDIO_GETC_MACRO */ +#ifdef __STDIO_GETC_MACRO + stream->bufgetc = +#endif /* __STDIO_GETC_MACRO */ + stream->bufstart; +#endif /* defined(__STDIO_PUTC_MACRO) || defined(__STDIO_GETC_MACRO) */ + + if (stream->modeflags & __MASK_BUFMODE) { + /* If the stream is readable and not fully buffered, we must first + * flush all line buffered output streams. Do this before the + * error check as this may be a read/write line-buffered stream. */ + fflush((FILE *) &_stdio_openlist); /* Uses an implementation hack!!! */ + } + +#ifdef __STDIO_AUTO_RW_TRANSITION + if (stream->modeflags & __FLAG_WRITING) { + /* TODO -- return if error? Test glibc behavior with a custom r/w. */ + fflush(stream); + } +#endif /* __STDIO_AUTO_RW_TRANSITION */ + + stream->modeflags |= __FLAG_READING; /* Make sure Reading flag is set. */ + + { + register unsigned char *p = (unsigned char *) buffer; + + /* First, grab appropriate ungetc() chars. NOT FOR WIDE ORIENTATED! */ + while (bytes && (stream->modeflags & __MASK_UNGOT)) { +#ifdef __STDIO_WIDE + assert(stream->modeflags & __FLAG_NARROW); +#endif /* __STDIO_WIDE */ + *p++ = stream->ungot[(--stream->modeflags) & __MASK_UNGOT]; + stream->ungot[1] = 0; + --bytes; + } + + /* Now get any other needed chars from the buffer or the file. */ + FROM_BUF: + while (bytes && (stream->bufrpos < stream->bufwpos)) { + --bytes; + *p++ = *stream->bufrpos++; + } + + if (bytes > 0) { + ssize_t len; + + /* The buffer is exhausted, but we still need chars. */ + stream->bufrpos = stream->bufwpos = stream->bufstart; + + if (bytes <= stream->bufend - stream->bufwpos) { + /* We have sufficient space in the buffer. */ + len = _stdio_READ(stream, stream->bufwpos, + stream->bufend - stream->bufwpos); + if (len > 0) { + stream->bufwpos += len; + goto FROM_BUF; + } + } else { + /* More bytes needed than fit in the buffer, so read */ + /* directly into caller's buffer. */ + len = _stdio_READ(stream, p, bytes); + if (len > 0) { + p += len; + bytes -= len; + goto FROM_BUF; /* Redundant work, but stops extra read. */ + } + } + } + +#ifdef __STDIO_GETC_MACRO + if (!(stream->modeflags & (__FLAG_WIDE|__MASK_UNGOT|__MASK_BUFMODE))) { + stream->bufgetc = stream->bufwpos; /* Enable getc macro. */ + } +#endif + + __stdio_validate_FILE(stream); /* debugging only */ + return (p - (unsigned char *)buffer); + } + +#else /* __STDIO_BUFFERS --------------------------------------- */ + + if (stream->modeflags +#ifdef __STDIO_AUTO_RW_TRANSITION + & (__FLAG_WRITEONLY) +#else /* __STDIO_AUTO_RW_TRANSITION */ + /* ANSI/ISO and SUSv3 require not currently writing. */ + & (__FLAG_WRITEONLY|__FLAG_WRITING) +#endif /* __STDIO_AUTO_RW_TRANSITION */ + ) { + stream->modeflags |= __FLAG_ERROR; + /* TODO: This is for posix behavior if writeonly. To save space, we + * use this errno for read attempt while writing, as no errno is + * specified by posix for this case, even though the restriction is + * mentioned in fopen(). */ + errno = EBADF; + return 0; + } + +#ifdef __STDIO_AUTO_RW_TRANSITION + stream->modeflags &= ~(__FLAG_WRITING); /* Make sure Writing flag clear. */ +#endif /* __STDIO_AUTO_RW_TRANSITION */ + + stream->modeflags |= __FLAG_READING; /* Make sure Reading flag is set. */ + + { + register unsigned char *p = (unsigned char *) buffer; + + /* First, grab appropriate ungetc() chars. NOT FOR WIDE ORIENTATED! */ + while (bytes && (stream->modeflags & __MASK_UNGOT)) { +#ifdef __STDIO_WIDE + assert(stream->modeflags & __FLAG_NARROW); +#endif /* __STDIO_WIDE */ + *p++ = stream->ungot[(--stream->modeflags) & __MASK_UNGOT]; + stream->ungot[1] = 0; + --bytes; + } + + while (bytes > 0) { + ssize_t len = _stdio_READ(stream, p, (unsigned) bytes); + if (len == 0) { + break; + } + p += len; + bytes -= len; + } + + __stdio_validate_FILE(stream); /* debugging only */ + return (p - (unsigned char *)buffer); + } + +#endif /* __STDIO_BUFFERS */ +} + +#endif +/**********************************************************************/ +#ifdef L__stdio_fwrite +/* + * If buffer == NULL, attempt to fflush and return number of chars + * remaining in buffer (0 if successful fflush). + */ + +/* WARNING!!!! Current standards say that termination due to an asyncronous + * signal may not result in stdio streams being flushed. This libary makes + * an effort to do so but there is no way, short of blocking signals for + * each _stdio_fwrite call, that we can maintain the correct state if a + * signal is recieved mid-call. So any stream in mid-_stdio_fwrite could + * not some flush data or even duplicate-flush some data. It is possible + * to avoid the duplicate-flush case by setting/clearing the stream + * error flag before/after the write process, but it doesn't seem worth + * the trouble. */ + +/* Like standard write, but always does a full write unless error plus + *deals correctly with bufsize > SSIZE_MAX... not much on an issue on linux + * but definitly could be on Elks. Also on Elks, always loops for EINTR.. + * Returns number of bytes written, so a short write indicates an error */ +static size_t _stdio_WRITE(FILE *stream, const void *buf, size_t bufsize) +{ + size_t todo; + ssize_t rv, stodo; + + todo = bufsize; + + while (todo) { + stodo = (todo <= SSIZE_MAX) ? todo : SSIZE_MAX; + rv = __WRITE(stream, buf, stodo); + if (rv >= 0) { +#ifdef __STDIO_GLIBC_CUSTOM_STREAMS + assert(rv <= stodo); /* buggy user handler... TODO: check? */ + if (rv > stodo) { /* Num reported written > number requested */ + rv = stodo; /* Treat as a full write??? */ + } +#endif + todo -= rv; + buf += rv; + } else +#ifdef __BCC__ + if (errno != EINTR) +#endif + { + stream->modeflags |= __FLAG_ERROR; + break; + } + } + + return bufsize - todo; +} + +/* Internal function -- not reentrant. */ + +size_t _stdio_fwrite(const unsigned char *buffer, size_t bytes, + register FILE *stream) +{ +#ifdef __STDIO_BUFFERS + register const unsigned char *p; + + __stdio_validate_FILE(stream); /* debugging only */ + + if ((stream->modeflags & __FLAG_READONLY) +#ifndef __STDIO_AUTO_RW_TRANSITION + /* ANSI/ISO requires either at EOF or currently not reading. */ + || ((stream->modeflags & (__FLAG_READING|__FLAG_EOF)) + == __FLAG_READING) +#endif /* __STDIO_AUTO_RW_TRANSITION */ + ) { + stream->modeflags |= __FLAG_ERROR; + /* TODO: This is for posix behavior if readonly. To save space, we + * use this errno for write attempt while reading, as no errno is + * specified by posix for this case, even though the restriction is + * mentioned in fopen(). */ + errno = EBADF; + return 0; + } + +#ifdef __STDIO_AUTO_RW_TRANSITION + /* If we were reading, deal with ungots and buffered chars. */ + if ((stream->modeflags & (__FLAG_EOF|__FLAG_WRITING|__FLAG_WRITEONLY)) + == 0) { + /* If appending, we might as well seek to end to save a seek. */ + fseek(stream, 0L, + ((stream->modeflags & __FLAG_APPEND) ? SEEK_END : SEEK_CUR)); + /* TODO: set EOF in fseek when appropriate? */ + } +#endif + + /* We need to disable putc and getc macros in case of error */ +#if defined(__STDIO_AUTO_RW_TRANSITION) \ + || defined(__STDIO_PUTC_MACRO) || defined(__STDIO_GETC_MACRO) +#ifdef __STDIO_AUTO_RW_TRANSITION + stream->bufrpos = /* TODO -- necessary? */ +#endif /* __STDIO_AUTO_RW_TRANSITION */ +#ifdef __STDIO_PUTC_MACRO + stream->bufputc = +#endif /* __STDIO_GETC_MACRO */ +#ifdef __STDIO_GETC_MACRO + stream->bufgetc = +#endif /* __STDIO_GETC_MACRO */ + stream->bufstart; +#endif /* not using ansi restrictions ; or using putc and/or getc macro */ + + /* Clear both reading and writing flags. We need to clear the writing + * flag in case we're fflush()ing or in case of an error. */ + stream->modeflags &= ~(__FLAG_READING|__FLAG_WRITING); + + { + const unsigned char *buf0 = buffer; + + if (!buffer) { /* fflush the stream */ + FFLUSH: + { + size_t count = stream->bufwpos - stream->bufstart; + p = stream->bufstart; + + if (stream->filedes == -2) { /* TODO -- document this hack! */ + stream->modeflags |= __FLAG_WRITING; + return (!buffer) ? 0 : ((buffer - buf0) + bytes); + } + + { + size_t rv = _stdio_WRITE(stream, p, count); + p += rv; + count -= rv; + } + + stream->bufwpos = stream->bufstart; + while (count) { + *stream->bufwpos++ = *p++; + --count; + } + + if (!buffer) { /* fflush case... */ + __stdio_validate_FILE(stream); /* debugging only */ + return stream->bufwpos - stream->bufstart; + } + } + } + +#if 1 + /* TODO: If the stream is buffered, we may be able to omit. */ + if ((stream->bufwpos == stream->bufstart) /* buf empty */ + && (stream->bufend - stream->bufstart <= bytes) /* fills */ + && (stream->filedes != -2)) { /* not strinf fake file */ + /* so want to do a direct write of supplied buffer */ + { + size_t rv = _stdio_WRITE(stream, buffer, bytes); + buffer += rv; + bytes -= rv; + } + } else +#endif + /* otherwise buffer not empty and/or data fits */ + { + size_t count = stream->bufend - stream->bufwpos; + p = buffer; + + if (count > bytes) { + count = bytes; + } + bytes -= count; + + while (count) { + *stream->bufwpos++ = *buffer++; + --count; + } + + if (bytes) { + goto FFLUSH; + } + + if (stream->modeflags & __FLAG_LBF) { + while (p < buffer) { /* check for newline. */ + if (*p++ == '\n') { + goto FFLUSH; + } + } + } + } + +#ifdef __STDIO_PUTC_MACRO + if (!(stream->modeflags & (__FLAG_WIDE|__MASK_BUFMODE))) { + /* Not wide, no errors and fully buffered, so enable putc macro. */ + stream->bufputc = stream->bufend; + } +#endif /* __STDIO_GETC_MACRO */ + stream->modeflags |= __FLAG_WRITING; /* Ensure Writing flag is set. */ + + __stdio_validate_FILE(stream); /* debugging only */ + return buffer - buf0; + + } + +#else /* __STDIO_BUFFERS --------------------------------------- */ + + __stdio_validate_FILE(stream); /* debugging only */ + + if ((stream->modeflags & __FLAG_READONLY) +#ifndef __STDIO_AUTO_RW_TRANSITION + /* ANSI/ISO requires either at EOF or currently not reading. */ + || ((stream->modeflags & (__FLAG_READING|__FLAG_EOF)) + == __FLAG_READING) +#endif /* __STDIO_AUTO_RW_TRANSITION */ + ) { + stream->modeflags |= __FLAG_ERROR; + /* TODO: This is for posix behavior if readonly. To save space, we + * use this errno for write attempt while reading, as no errno is + * specified by posix for this case, even though the restriction is + * mentioned in fopen(). */ + errno = EBADF; + return 0; + } + + /* We always clear the reading flag in case at EOF. */ + stream->modeflags &= ~(__FLAG_READING); + /* Unlike the buffered case, we set the writing flag now since we don't + * need to do anything here for fflush(). */ + stream->modeflags |= __FLAG_WRITING; + + { + register unsigned char *p = (unsigned char *) buffer; + + ssize_t rv = _stdio_WRITE(stream, p, bytes); + + p += rv; + bytes -= rv; + + __stdio_validate_FILE(stream); /* debugging only */ + return (p - (unsigned char *)buffer); + } + +#endif /* __STDIO_BUFFERS *****************************************/ +} + +#endif +/**********************************************************************/ +#ifdef L__stdio_init + +/* Internal functions -- _stdio_init() and __stdio_validate_FILE + * are not reentrant, but _stdio_term() is through fflush(). + * Also, the _cs_{read|write|close} functions are not reentrant. */ + +#ifndef NDEBUG +void __stdio_validate_FILE(FILE *stream) +{ + if (stream->filedes == -2) { /* fake FILE for sprintf, scanf, etc. */ + return; + } + + __STDIO_THREADLOCK(stream); + +#ifdef __STDIO_BUFFERS + assert(stream->bufstart <= stream->bufrpos); + assert(stream->bufrpos <= stream->bufwpos); + assert(stream->bufwpos <= stream->bufend); + assert(stream->bufwpos <= stream->bufend); + if ((stream->modeflags & __MASK_BUFMODE) == __FLAG_NBF) { + assert(stream->bufstart == stream->bufend); + } + assert((stream->modeflags & __MASK_BUFMODE) <= __FLAG_NBF); +#endif +#ifdef __STDIO_PUTC_MACRO + assert(stream->bufstart <= stream->bufputc); + assert(stream->bufputc <= stream->bufend); + if (stream->bufstart < stream->bufputc) { + assert(stream->bufputc == stream->bufend); + assert(stream->modeflags & (__FLAG_WRITING)); + assert(!(stream->modeflags + & (__FLAG_WIDE|__MASK_BUFMODE|__MASK_UNGOT|__FLAG_READONLY)) + ); + } +#endif +#ifdef __STDIO_GETC_MACRO + assert(stream->bufstart <= stream->bufgetc); + assert(stream->bufgetc <= stream->bufwpos); + if (stream->bufstart < stream->bufgetc) { + assert(stream->modeflags & (__FLAG_READING)); + assert(!(stream->modeflags + & (__FLAG_WIDE|__MASK_BUFMODE|__MASK_UNGOT|__FLAG_WRITEONLY)) + ); + } +#endif + assert((stream->modeflags & __MASK_UNGOT) != __MASK_UNGOT); + if (stream->modeflags & __MASK_UNGOT1) { + assert(stream->ungot[1] <= 1); + } + if (stream->modeflags & __MASK_UNGOT) { + assert(!(stream->modeflags & __FLAG_EOF)); + } + assert((stream->modeflags & (__FLAG_READONLY|__FLAG_WRITEONLY)) + != (__FLAG_READONLY|__FLAG_WRITEONLY)); + + /* TODO -- filepos? ungot_width? filedes? nextopen? */ + + __STDIO_THREADUNLOCK(stream); +} +#endif + +#ifdef __STDIO_GLIBC_CUSTOM_STREAMS +ssize_t _cs_read(void *cookie, char *buf, size_t bufsize) +{ + return read(*((int *) cookie), buf, bufsize); +} + +ssize_t _cs_write(void *cookie, const char *buf, size_t bufsize) +{ + return write(*((int *) cookie), (char *) buf, bufsize); +} + +int _cs_close(void *cookie) +{ + return close(*((int *) cookie)); +} +#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */ + +#ifdef __STDIO_BUFFERS +static unsigned char _fixed_buffers[2 * BUFSIZ]; +#define bufin (_fixed_buffers) +#define bufout (_fixed_buffers + BUFSIZ) +#endif /* __STDIO_BUFFERS */ + +static FILE _stdio_streams[] = { + __STDIO_INIT_FILE_STRUCT(_stdio_streams[0], __FLAG_LBF|__FLAG_READONLY, \ + 0, _stdio_streams + 1, bufin, BUFSIZ ), + __STDIO_INIT_FILE_STRUCT(_stdio_streams[1], __FLAG_LBF|__FLAG_WRITEONLY, \ + 1, _stdio_streams + 2, bufout, BUFSIZ ), + __STDIO_INIT_FILE_STRUCT(_stdio_streams[2], __FLAG_NBF|__FLAG_WRITEONLY, \ + 2, 0, 0, 0 ) +}; + +FILE *_stdin = _stdio_streams + 0; +FILE *_stdout = _stdio_streams + 1; +FILE *_stderr = _stdio_streams + 2; + +#if defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) + +#ifdef __STDIO_BUFFERS +FILE *_stdio_openlist = _stdio_streams; +#else /* __STDIO_BUFFERS */ +FILE *_stdio_openlist = NULL; +#endif /* __STDIO_BUFFERS */ + +#ifdef __STDIO_THREADSAFE +pthread_mutex_t _stdio_openlist_lock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP; + + +void __stdio_init_mutex(pthread_mutex_t *m) +{ + static const pthread_mutex_t __stdio_mutex_initializer + = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP; + + memcpy(m, &__stdio_mutex_initializer, sizeof(__stdio_mutex_initializer)); +} +#endif /* __STDIO_THREADSAFE */ + +/* TODO - do we need to lock things, or do we just assume we're the only + * remaining thread? */ + +/* Note: We assume here that we are the only remaining thread. */ +void _stdio_term(void) +{ +#if defined(__STDIO_GLIBC_CUSTOM_STREAMS) || defined(__STDIO_THREADSAFE) + FILE *ptr; +#endif + + /* TODO: if called via a signal handler for a signal mid _stdio_fwrite, + * the stream may be in an unstable state... what do we do? + * perhaps set error flag before and clear when done if successful? */ + +#ifdef __STDIO_THREADSAFE + /* First, forceably unlock the open file list and all files. + * Note: Set locking mode to "by caller" to save some overhead later. */ + __stdio_init_mutex(&_stdio_openlist_lock); + for (ptr = _stdio_openlist ; ptr ; ptr = ptr->nextopen ) { + ptr->user_locking = FSETLOCKING_BYCALLER; + __stdio_init_mutex(&ptr->lock); + } +#endif /* __STDIO_THREADSAFE */ + + /* TODO -- set an alarm and flush each file "by hand"? to avoid blocking? */ + + /* Now flush all streams. */ + fflush(NULL); + + /* Next close all custom streams in case of any special cleanup, but + * don't use fclose() because that pulls in free and malloc. Also, + * don't worry about removing them from the list. Just set the cookie + * pointer to NULL so that an error will be generated if someone tries + * to use the stream. */ +#ifdef __STDIO_GLIBC_CUSTOM_STREAMS + for (ptr = _stdio_openlist ; ptr ; ptr = ptr->nextopen ) { + if (ptr->cookie != &ptr->filedes) { /* custom stream */ + __CLOSE(ptr); + ptr->cookie = NULL; /* Generate an error if used later. */ +#if 0 +/* #ifdef __STDIO_BUFFERS */ + } else { + /* TODO: "unbuffer" files like glibc does? Inconsistent with + * custom stream handling above, but that's necessary to deal + * with special user-defined close behavior. */ + stream->bufwpos = stream->bufrpos = stream->bufend +#ifdef __STDIO_GETC_MACRO + = stream->bufgetc +#endif +#ifdef __STDIO_PUTC_MACRO + = stream->bufputc +#endif + = stream->bufstart; +#endif /* __STDIO_BUFFERS */ + } + } +#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */ +} + + +#if defined(__STDIO_BUFFERS) || !defined(__UCLIBC__) +void _stdio_init(void) +{ +#ifdef __STDIO_BUFFERS + /* stdin and stdout uses line buffering when connected to a tty. */ + _stdio_streams[0].modeflags ^= isatty(0) * __FLAG_LBF; + _stdio_streams[1].modeflags ^= isatty(1) * __FLAG_LBF; +#endif /* __STDIO_BUFFERS */ +#ifndef __UCLIBC__ +/* __stdio_term is automatically when exiting if stdio is used. + * See misc/internals/__uClibc_main.c and and stdlib/atexit.c. */ + atexit(_stdio_term); +#endif /* __UCLIBC__ */ +} +#endif /* defined(__STDIO_BUFFERS) || !defined(__UCLIBC__) */ +#endif /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */ + +#endif +/**********************************************************************/ +/* ANSI/ISO functions. */ +/**********************************************************************/ +#ifdef L_remove +#include <unistd.h> +#include <errno.h> + +/* No reentrancy issues. */ + +int remove(register const char *filename) +{ + int old_errno = errno; + + /* SUSv3 says equivalent to rmdir() if a directory, and unlink() + * otherwise. Hence, we need to try rmdir() first. */ + + return (((rmdir(filename) == 0) + || ((errno == ENOTDIR) + && ((__set_errno(old_errno), unlink(filename)) == 0))) + ? 0 : -1); +} +#endif +/**********************************************************************/ +/* rename is a syscall +#ifdef L_rename +int rename(const char *old, const char *new); +#endif +*/ +/**********************************************************************/ +/* TODO: tmpfile */ +/* #ifdef L_tmpfile */ +/* FILE *tmpfile(void); */ +/* #endif */ +/**********************************************************************/ +/* TODO: tmpname */ +/* #ifdef L_tmpname */ +/* char *tmpname(char *s); */ +/* #endif */ +/**********************************************************************/ +#ifdef L_fclose + +/* We need to be careful here to avoid deadlock when threading, as we + * need to lock both the file and the open file list. This can clash + * with fflush. Since fflush is much more common, we do the extra + * work here. */ + +int fclose(register FILE *stream) +{ +#if defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) + + register FILE *ptr; + int rv = 0; + +#ifdef __STDIO_THREADSAFE + /* Need two non-heirchal mutexs... be careful to avoid deadlock*/ + do { + __STDIO_THREADLOCK(stream); + if (__STDIO_THREADTRYLOCK_OPENLIST == 0) { + break; + } + __STDIO_THREADUNLOCK(stream); + usleep(10000); + } while (1); +#endif /* __STDIO_THREADSAFE */ + + __stdio_validate_FILE(stream); /* debugging only */ + +#ifdef __STDIO_BUFFERS + if (stream->modeflags & __FLAG_WRITING) { + rv = fflush(stream); /* Write any pending buffered chars. */ + } /* Also disables putc macro if used. */ + +#ifdef __STDIO_GETC_MACRO + /* Not necessary after fflush, but always do this to reduce size. */ + stream->bufgetc = stream->bufstart; /* Disable getc macro for safety. */ +#endif /* __STDIO_GETC_MACRO */ +#endif /* __STDIO_BUFFERS */ + + /* Remove file from open list before closing file descriptor. */ + ptr = _stdio_openlist; + if (ptr == stream) { + _stdio_openlist = stream->nextopen; + } else { + while (ptr) { + if (ptr->nextopen == stream) { + ptr->nextopen = stream->nextopen; + break; + } + ptr = ptr->nextopen; + } + } + __STDIO_THREADUNLOCK_OPENLIST; /* We're done with the open file list. */ + + if (__CLOSE(stream) < 0) { /* Must close even if fflush failed. */ + rv = EOF; + } +#ifdef __STDIO_GLIBC_CUSTOM_STREAMS + stream->cookie = NULL; /* To aid debugging... */ +#endif + stream->filedes = -1; /* To aid debugging... */ + +#ifdef __STDIO_BUFFERS + if (stream->modeflags & __FLAG_FREEBUF) { + free(stream->bufstart); + } +#endif /* __STDIO_BUFFERS */ + + /* TODO -- leave the stream locked to catch any dangling refs? */ + __STDIO_THREADUNLOCK(stream); + + /* At this point, any dangling refs to the stream are the result of + * a programming bug... so free the unlocked stream. */ + if (stream->modeflags & __FLAG_FREEFILE) { + free(stream); + } + + return rv; + +#else /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */ + + int rv = 0; + + __STDIO_THREADLOCK(stream); + + __stdio_validate_FILE(stream); /* debugging only */ + + if (__CLOSE(stream) < 0) { /* Must close even if fflush failed. */ + rv = EOF; + } + +#ifdef __STDIO_GLIBC_CUSTOM_STREAMS + stream->cookie = NULL; /* To aid debugging... */ +#endif + stream->filedes = -1; /* To aid debugging... */ + + __STDIO_THREADUNLOCK(stream); + + /* At this point, any dangling refs to the stream are the result of + * a programming bug... so free the unlocked stream. */ + if (stream->modeflags & __FLAG_FREEFILE) { + free(stream); + } + + return rv; + +#endif /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS )*/ +} + +#endif +/**********************************************************************/ +#ifdef L_fflush + +/* + * Special cases: + * stream == NULL means fflush all writing streams (ANSI/ISO). + * stream == (FILE *) &_stdio_openlist -- implementation-specific hack + * meaning fflush all line buffered writing streams + */ + +/* + * NOTE: ANSI/ISO difference!!! According to the standard, fflush is only + * defined for write-only streams, or read/write streams whose last op + * was a write. However, reading is allowed for a read/write stream if + * a file positioning operation was done (fseek, fsetpos) even though there + * is no guarantee of flushing the write data in that case. Hence, for + * this case we keep a flag to indicate whether or not the buffer needs to + * be flushed even if the last operation was a read. This falls under the + * implementation-defined behavior. Otherwise, we would need to flush + * every time we did fseek, etc. even if we were still in the buffer's range. + */ + +/* Since the stream pointer arg is allowed to be NULL, or the address of the + * stdio open file list if stdio is buffered in this implementation, we can't + * use the UNLOCKED() macro here. */ + +#ifndef __STDIO_THREADSAFE +strong_alias(fflush_unlocked,fflush) +#else /* __STDIO_THREADSAFE */ +int fflush(register FILE *stream) +{ + int retval; + + if ((stream != NULL) +#ifdef __STDIO_BUFFERS + && (stream != (FILE *) &_stdio_openlist) +#endif /* __STDIO_BUFFERS */ + ) { + __STDIO_THREADLOCK(stream); + retval = fflush_unlocked(stream); + __STDIO_THREADUNLOCK(stream); + } else { + retval = fflush_unlocked(stream); + } + + return retval; +} +#endif /* __STDIO_THREADSAFE */ + +int fflush_unlocked(register FILE *stream) +{ +#ifdef __STDIO_BUFFERS + + int rv = 0; + unsigned short mask = (__FLAG_NBF|__FLAG_LBF); + +#ifndef NDEBUG + if ((stream != NULL) && (stream != (FILE *) &_stdio_openlist)) { + __stdio_validate_FILE(stream); /* debugging only */ + } +#endif + + if (stream == (FILE *) &_stdio_openlist) { /* fflush all line-buffered */ + stream = NULL; + mask = __FLAG_LBF; + } + + if (stream == NULL) { /* flush all (line) buffered writing streams */ + /* Note -- We have to lock the list even in the unlocked function. */ + __STDIO_THREADLOCK_OPENLIST; + /* TODO -- Can we work around locking the list to avoid keeping it + * locked if the write blocks? */ + for (stream = _stdio_openlist; stream; stream = stream->nextopen) { + if (((stream->modeflags ^ __FLAG_NBF) & mask) + && (stream->modeflags & __FLAG_WRITING) + && fflush(stream)) { + rv = EOF; + } + } + __STDIO_THREADUNLOCK_OPENLIST; + } else if (stream->modeflags & __FLAG_WRITING) { + if (_stdio_fwrite(NULL, 0, stream) > 0) { /* flush buffer contents. */ + rv = -1; /* Not all chars written. */ + } + } else if (stream->modeflags & (__FLAG_READONLY|__FLAG_READING)) { + /* TODO - __FLAG_READING too? check glibc behavior */ + /* According to info, glibc returns an error when the file is opened + * in read-only mode. + * ANSI/ISO says behavior in this case is undefined but also says you + * shouldn't flush a stream you were reading from. + */ + stream->modeflags |= __FLAG_ERROR; /* TODO - check glibc behavior */ + __set_errno(EBADF); + rv = -1; + } + +#ifndef NDEBUG + if ((stream != NULL) && (stream != (FILE *) &_stdio_openlist)) { + __stdio_validate_FILE(stream); /* debugging only */ + } +#endif + return rv; + +#else /* __STDIO_BUFFERS --------------------------------------- */ + + __stdio_validate_FILE(stream); /* debugging only */ + /* TODO -- check glibc behavior regarding error indicator */ + return (stream->modeflags & (__FLAG_READONLY|__FLAG_READING) + ? ((stream->modeflags |= __FLAG_ERROR), __set_errno(EBADF), EOF) + : 0 ); + +#endif /* __STDIO_BUFFERS */ +} +#endif +/**********************************************************************/ +#ifdef L_fopen + +/* No reentrancy issues. */ + +FILE *fopen(const char * __restrict filename, const char * __restrict mode) +{ + return _stdio_fopen(filename, mode, NULL, -1); +} + +#endif +/**********************************************************************/ +#ifdef L__stdio_fopen + +/* + * Cases: + * fopen : filename != NULL, stream == NULL, filedes == -1 + * freopen : filename != NULL, stream != NULL, filedes == -1 + * fdopen : filename == NULL, stream == NULL, filedes valid + * fsfopen : filename != NULL, stream != NULL, filedes == -1 + * fopen64 : filename != NULL, stream == NULL, filedes == -2 + */ + +#if O_ACCMODE != 3 || O_RDONLY != 0 || O_WRONLY != 1 || O_RDWR != 2 || O_APPEND != __FLAG_APPEND || O_LARGEFILE != __FLAG_LARGEFILE +#error Assumption violated - mode constants +#endif + +/* Internal function -- reentrant (locks open file list) */ + +FILE *_stdio_fopen(const char * __restrict filename, + register const char * __restrict mode, + register FILE * __restrict stream, int filedes) +{ + __mode_t open_mode; + + /* parse mode */ + open_mode = O_RDONLY; + if (*mode != 'r') { /* not read */ + open_mode = (O_WRONLY | O_CREAT | O_TRUNC); + if (*mode != 'w') { /* not write (create or truncate)*/ + open_mode = (O_WRONLY | O_CREAT | O_APPEND); + if (*mode != 'a') { /* not write (create or append) */ + __set_errno(EINVAL); /* then illegal mode */ + if (stream) { /* If this is freopen, free the stream. */ + goto FREE_STREAM; + } + return NULL; + } + } + } + + if ((*++mode == 'b')) { /* binary mode (NOP currently) */ + ++mode; + } + + if (*mode == '+') { /* read-write */ + ++mode; + open_mode &= ~(O_RDONLY | O_WRONLY); + open_mode |= O_RDWR; + } + +#if defined(__STDIO_GNU_FEATURE) || defined(__STDIO_FOPEN_LARGEFILE_MODE) + while (*mode) { /* ignore everything else except ... */ +#ifdef __STDIO_FOPEN_EXCLUSIVE_MODE + if (*mode++ == 'x') { /* open exclusive -- glibc extension */ + open_mode |= O_EXCL; + } +#endif /* __STDIO_FOPEN_EXCLUSIVE_MODE */ +#ifdef __STDIO_FOPEN_LARGEFILE_MODE + if (*mode++ == 'F') { /* open large file */ + open_mode |= O_LARGEFILE; + } +#endif /* __STDIO_FOPEN_LARGEFILE_MODE */ + } +#endif /* __STDIO_FOPEN_EXCLUSIVE_MODE or __STDIO_FOPEN_LARGEFILE_MODE def'd */ + +#ifdef __BCC__ + mode = filename; /* TODO: help BCC with register allocation. */ +#define filename mode +#endif /* __BCC__ */ + + if (!stream) { /* Need to allocate a FILE. */ +#ifdef __STDIO_BUFFERS + if ((stream = malloc(sizeof(FILE))) == NULL) { + return stream; + } + stream->modeflags = __FLAG_FREEFILE; + if ((stream->bufstart = malloc(BUFSIZ)) != 0) { + stream->bufend = stream->bufstart + BUFSIZ; + stream->modeflags |= __FLAG_FREEBUF; + } else { +#if __STDIO_BUILTIN_BUF_SIZE > 0 + stream->bufstart = stream->unbuf; + stream->bufend = stream->unbuf + sizeof(stream->unbuf); +#else /* __STDIO_BUILTIN_BUF_SIZE > 0 */ + stream->bufstart = stream->bufend = NULL; +#endif /* __STDIO_BUILTIN_BUF_SIZE > 0 */ + } +#else /* __STDIO_BUFFERS */ + if ((stream = malloc(sizeof(FILE))) == NULL) { + return stream; + } + stream->modeflags = __FLAG_FREEFILE; +#endif /* __STDIO_BUFFERS */ + } + + if (filedes >= 0) { /* Handle fdopen trickery. */ + /* + * NOTE: it is insufficient to just check R/W/RW agreement. + * We must also check for append mode agreement, as well as + * largefile agreement if applicable. + */ + int i = (open_mode & (O_ACCMODE|O_APPEND|O_LARGEFILE)) + 1; + + if ((i & (((int) filename) + 1)) != i) { + __set_errno(EINVAL); + filedes = -1; + } + stream->filedes = filedes; + } else { +#ifdef __STDIO_LARGE_FILES + if (filedes < -1) { + open_mode |= __FLAG_LARGEFILE; + } +#endif /* __STDIO_LARGE_FILES */ + stream->filedes = open(filename, open_mode, 0666); + } + + if (stream->filedes < 0) { + FREE_STREAM: +#ifdef __STDIO_BUFFERS + if (stream->modeflags & __FLAG_FREEBUF) { + free(stream->bufstart); + } +#endif /* __STDIO_BUFFERS */ + if (stream->modeflags & __FLAG_FREEFILE) { + free(stream); + } + return NULL; + } + +#ifdef __STDIO_BUFFERS + stream->modeflags |= (isatty(stream->filedes) * __FLAG_LBF) + | ((((open_mode & O_ACCMODE) + 1) ^ 0x03) * __FLAG_WRITEONLY) + | (open_mode & (O_APPEND|O_LARGEFILE)); + + +#ifdef __STDIO_GETC_MACRO + stream->bufgetc = +#endif +#ifdef __STDIO_PUTC_MACRO + stream->bufputc = +#endif + stream->bufwpos = stream->bufrpos = stream->bufstart; + +#else /* __STDIO_BUFFERS */ + stream->modeflags |= + ((((open_mode & O_ACCMODE) + 1) ^ 0x03) * __FLAG_WRITEONLY) + | (open_mode & (O_APPEND|O_LARGEFILE)); +#endif /* __STDIO_BUFFERS */ + +#ifdef __STDIO_GLIBC_CUSTOM_STREAMS + stream->cookie = &(stream->filedes); + stream->gcs.read = _cs_read; + stream->gcs.write = _cs_write; + stream->gcs.seek = 0; /* The internal seek func handles normals. */ + stream->gcs.close = _cs_close; +#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */ + +#ifdef __STDIO_THREADSAFE + __stdio_init_mutex(&stream->lock); +#endif /* __STDIO_THREADSAFE */ + +#if defined(__STDIO_BUFFERS) \ +|| (defined(__STDIO_THREADSAFE) && defined(__STDIO_GLIBC_CUSTOM_STREAMS)) + __STDIO_THREADLOCK_OPENLIST; + stream->nextopen = _stdio_openlist; /* New files are inserted at */ + _stdio_openlist = stream; /* the head of the list. */ + __STDIO_THREADUNLOCK_OPENLIST; +#endif + + __stdio_validate_FILE(stream); /* debugging only */ + return stream; +#ifdef __BCC__ +#undef filename +#endif /* __BCC__ */ +} + +#endif +/**********************************************************************/ +#ifdef L_freopen + +/* Reentrant. */ + +FILE *freopen(const char * __restrict filename, const char * __restrict mode, + register FILE * __restrict stream) +{ + /* + * ANSI/ISO allow (implementation-defined) change of mode for an + * existing file if filename is NULL. It doesn't look like Linux + * supports this, so we don't here. + * + * NOTE: Whether or not the stream is free'd on failure is unclear + * w.r.t. ANSI/ISO. This implementation chooses to free the + * stream and associated buffer if they were dynamically + * allocated. + * TODO: Check the above. + * TODO: Apparently linux allows setting append mode. Implement? + */ + unsigned short dynmode; + FILE *fp; + + __STDIO_THREADLOCK(stream); + + /* First, flush and close, but don't deallocate, the stream. */ + /* This also removes the stream for the open file list. */ + dynmode = +#ifdef __STDIO_BUFFERS + // __MASK_BUFMODE | /* TODO: check */ +#endif /* __STDIO_BUFFERS */ + (stream->modeflags & (__FLAG_FREEBUF|__FLAG_FREEFILE)); + + stream->modeflags &= ~(__FLAG_FREEBUF|__FLAG_FREEFILE); + fclose(stream); /* Failures are ignored. */ + stream->modeflags = dynmode; + + fp = _stdio_fopen(filename, mode, stream, -1); + + __STDIO_THREADUNLOCK(stream); + + return fp; +} +#endif +/**********************************************************************/ +#ifdef L_freopen64 + +/* Reentrant. */ + +/* TODO -- is it collecting the common work (40 bytes) into a function? */ +FILE *freopen64(const char * __restrict filename, const char * __restrict mode, + register FILE * __restrict stream) +{ + unsigned short dynmode; + FILE *fp; + + __STDIO_THREADLOCK(stream); + + /* First, flush and close, but don't deallocate, the stream. */ + /* This also removes the stream for the open file list. */ + dynmode = +#ifdef __STDIO_BUFFERS + // __MASK_BUFMODE | /* TODO: check */ +#endif /* __STDIO_BUFFERS */ + (stream->modeflags & (__FLAG_FREEBUF|__FLAG_FREEFILE)); + + stream->modeflags &= ~(__FLAG_FREEBUF|__FLAG_FREEFILE); + fclose(stream); /* Failures are ignored. */ + stream->modeflags = dynmode; + + fp = _stdio_fopen(filename, mode, stream, -2); /* TODO -- magic const */ + + __STDIO_THREADUNLOCK(stream); + + return fp; +} + +#endif +/**********************************************************************/ +#ifdef L_setbuf + +/* Reentrant through setvbuf(). */ + +void setbuf(FILE * __restrict stream, register char * __restrict buf) +{ +#ifdef __STDIO_BUFFERS + int mode; + + mode = (buf != NULL) ? _IOFBF : _IONBF; + setvbuf(stream, buf, mode, BUFSIZ); +#else /* __STDIO_BUFFERS */ + /* TODO -- assert on stream? */ + /* Nothing to do. */ +#endif /* __STDIO_BUFFERS */ +} + +#endif +/**********************************************************************/ +#ifdef L_setvbuf + +/* Reentrant. */ + +int setvbuf(register FILE * __restrict stream, register char * __restrict buf, + int mode, size_t size) +{ +#ifdef __STDIO_BUFFERS + + int allocated_buf_flag; + int rv = EOF; + + __STDIO_THREADLOCK(stream); + + __stdio_validate_FILE(stream); /* debugging only */ + + if (((unsigned int) mode) > 2) { /* Illegal mode. */ + /* TODO -- set an errno? */ + goto DONE; + } + +#ifdef __STDIO_FLEXIBLE_SETVBUF + /* C89 standard requires no ops before setvbuf, but we can be flexible. */ + /* NOTE: This will trash any chars ungetc'd!!! */ + /* TODO: hmm could preserve unget count since ungot slots aren't changed (true?) + * but this will fail when buffered chars read from a pipe unless the user buf + * is big enough to copy everything over. */ + if (fseek(stream, 0L, SEEK_CUR)) { + goto DONE; + } +#else /* __STDIO_FLEXIBLE_SETVBUF */ + /* + * Note: ANSI/ISO requires setvbuf to be called after opening the file + * but before any other operation other than a failed setvbuf call. + * We'll cheat here and only test if the wide or narrow mode flag has + * been set; i.e. no read or write (or unget or fwide) operations have + * taken place. + */ +#ifdef __STDIO_WIDE + if (stream->modeflags & (__FLAG_WIDE|__FLAG_NARROW)) { + goto DONE; + } +#else /* __STDIO_WIDE */ + /* Note: This only checks if not currently reading or writing. */ + if (stream->modeflags & (__FLAG_READING|__FLAG_WRITING)) { + goto DONE; + } +#endif /* __STDIO_WIDE */ +#endif /* __STDIO_FLEXIBLE_SETVBUF */ + + if (mode == _IONBF) { + size = 0; + buf = NULL; + } + + stream->modeflags &= ~(__MASK_BUFMODE); /* Clear current mode */ + stream->modeflags |= mode * __FLAG_LBF; /* and set new one. */ + + allocated_buf_flag = 0; + if ((!buf) && (size != (stream->bufend - stream->bufstart))) { + /* No buffer supplied and requested size different from current. */ + allocated_buf_flag = __FLAG_FREEBUF; + /* If size == 0, create a (hopefully) bogus non-null pointer... */ + if (!(buf = ((size > 0) ? malloc(size) : ((char *)NULL) + 1))) { + goto DONE; /* Keep current buffer. */ + } + } + + /* TODO: setvbuf "signal" safety */ + if (buf && (buf != (char *) stream->bufstart)) { /* Want new buffer. */ + if (stream->modeflags & __FLAG_FREEBUF) { + stream->modeflags &= ~(__FLAG_FREEBUF); + free(stream->bufstart); + } + stream->modeflags |= allocated_buf_flag; /* Free-able buffer? */ +#ifdef __STDIO_GETC_MACRO + stream->bufgetc = +#endif +#ifdef __STDIO_PUTC_MACRO + stream->bufputc = +#endif + stream->bufwpos = stream->bufrpos = stream->bufstart = buf; + stream->bufend = buf + size; + } + + __stdio_validate_FILE(stream); /* debugging only */ + + rv = 0; + + DONE: + __STDIO_THREADUNLOCK(stream); + + return rv; + +#else /* __STDIO_BUFFERS */ + __stdio_validate_FILE(stream); /* debugging only */ + /* TODO -- set errno for illegal mode? */ + + return EOF; +#endif /* __STDIO_BUFFERS */ +} + +#endif +/********************************************************************** +int fprintf(FILE * __restrict stream, const char * __restrict format, ...); +int fscanf(FILE * __restrict stream, const char * __restrict format, ...); +int printf(const char * __restrict format, ...); +int scanf(const char * __restrict format, ...); +int snprintf(char * __restrict s, size_t n, + const char * __restrict format, ...); +int sprintf(char * __restrict s, const char * __restrict format, ...); +int sscanf(char * __restrict s, const char * __restrict format, ...); +int vfprintf(FILE * __restrict stream, const char * __restrict format, + va_list arg); +int vfscanf(FILE * __restrict stream, const char * __restrict format, + va_list arg); +int vprintf(const char * __restrict format, va_list arg); +int vscanf(const char * __restrict format, va_list arg); +int vsnprintf(char * __restrict s, size_t n, + const char * __restrict format, va_list arg); +int vsprintf(char * __restrict s, const char * __restrict format, + va_list arg); +int vsscanf(char * __restrict s, const char * __restrict format, + va_list arg); +**********************************************************************/ +#ifdef L_fgetc + +/* Reentrancy handled by UNLOCKED() macro. */ + +UNLOCKED(int,fgetc,(FILE *stream),(stream)) +{ + unsigned char buf[1]; + +#ifdef __STDIO_WIDE + + return (fread(buf, (size_t) 1, (size_t) 1, stream) > 0) ? *buf : EOF; + +#else /* __STDIO_WIDE */ + + return (_stdio_fread(buf, (size_t) 1, stream) > 0) ? *buf : EOF; + +#endif /* __STDIO_WIDE */ +} + +#endif +/**********************************************************************/ +#ifdef L_fgets + +/* Reentrancy handled by UNLOCKED() macro. */ + +UNLOCKED(char *,fgets, + (char *__restrict s, int n, register FILE * __restrict stream), + (s, n, stream)) +{ + register char *p; + int c; + + p = s; + while ((n > 1) && ((c = getc(stream)) != EOF) && ((*p++ = c) != '\n')) { + --n; + } + if (p == s) { + /* TODO -- should we set errno? */ +/* if (n <= 0) { */ +/* errno = EINVAL; */ +/* } */ + return NULL; + } + *p = 0; + return s; +} + +#endif +/**********************************************************************/ +#ifdef L_fputc + +/* Reentrancy handled by UNLOCKED() macro. */ + +UNLOCKED(int,fputc,(int c, FILE *stream),(c,stream)) +{ + unsigned char buf[1]; + + *buf = (unsigned char) c; + +#ifdef __STDIO_WIDE + + return (fwrite(buf, (size_t) 1, (size_t) 1, stream) > 0) ? (*buf) : EOF; + +#else /* __STDIO_WIDE */ + + return (_stdio_fwrite(buf, (size_t) 1, stream) > 0) ? (*buf) : EOF; + +#endif /* __STDIO_WIDE */ +} +#endif +/**********************************************************************/ +#ifdef L_fputs + +/* Reentrancy handled by UNLOCKED() macro. */ + +UNLOCKED(int,fputs, + (register const char * __restrict s, FILE * __restrict stream), + (s, stream)) +{ + size_t n = strlen(s); + +#ifdef __STDIO_WIDE + + return (fwrite(s, n, (size_t) 1, stream) > 0) ? n : EOF; + +#else /* __STDIO_WIDE */ + + return (_stdio_fwrite(s, n, stream) == n) ? n : EOF; + +#endif /* __STDIO_WIDE */ +} + +#endif +/**********************************************************************/ +#ifdef L_getc +#undef getc + +/* Reentrancy handled by UNLOCKED() macro. */ + +UNLOCKED(int,getc,(register FILE *stream),(stream)) +{ + return __GETC(stream); /* Invoke the macro. */ +} + +#endif +/**********************************************************************/ +#ifdef L_getchar +#undef getchar /* Just in case. */ + +/* Reentrancy handled by UNLOCKED() macro. */ + +UNLOCKED_STREAM(int,getchar,(void),(),_stdin) +{ + register FILE *stream = _stdin; /* This helps bcc optimize. */ + + return __GETC(stream); +} + +#endif +/**********************************************************************/ +#ifdef L_gets + +link_warning(gets, "the 'gets' function is dangerous and should not be used.") + +/* Reentrant. */ + +char *gets(char *s) /* WARNING!!! UNSAFE FUNCTION!!! */ +{ + register FILE *stream = _stdin; /* This helps bcc optimize. */ + register char *p = s; + int c; + + __STDIO_THREADLOCK(stream); + + /* Note: don't worry about performance here... this shouldn't be used! + * Therefore, force actual function call. */ + while (((c = (*getc)(stream)) != EOF) && ((*p = c) != '\n')) { + ++p; + } + if ((c == EOF) || (s == p)) { + s = NULL; + } else { + *p = 0; + } + + __STDIO_THREADUNLOCK(stream); + + return s; +} + +#endif +/**********************************************************************/ +#ifdef L_putc +#undef putc + +/* Reentrancy handled by UNLOCKED() macro. */ + +UNLOCKED(int,putc,(int c, register FILE *stream),(c,stream)) +{ + return __PUTC(c, stream); /* Invoke the macro. */ +} + +#endif +/**********************************************************************/ +#ifdef L_putchar +#undef putchar /* Just in case. */ + +/* Reentrancy handled by UNLOCKED() macro. */ + +UNLOCKED_STREAM(int,putchar,(int c),(c),_stdout) +{ + register FILE *stream = _stdout; /* This helps bcc optimize. */ + + return __PUTC(c, stream); +} + +#endif +/**********************************************************************/ +#ifdef L_puts + +/* Reentrant. */ + +int puts(register const char *s) +{ + register FILE *stream = _stdout; /* This helps bcc optimize. */ + int n; + + __STDIO_THREADLOCK(stream); + + n = fputs(s,stream) + 1; + if ( +#if 1 + fputc('\n',stream) +#else + fputs("\n",stream) +#endif + == EOF) { + n = EOF; + } + + __STDIO_THREADUNLOCK(stream); + + return n; +} + +#endif +/**********************************************************************/ +#ifdef L_ungetc +/* + * Note: This is the application-callable ungetc. If scanf calls this, it + * should also set stream->ungot[1] to 0 if this is the only ungot. + */ + +/* Reentrant. */ + +int ungetc(int c, register FILE *stream) +{ + __STDIO_THREADLOCK(stream); + + __stdio_validate_FILE(stream); /* debugging only */ + +#ifdef __STDIO_WIDE + if (stream->modeflags & __FLAG_WIDE) { + stream->modeflags |= __FLAG_ERROR; + c = EOF; + goto DONE; + } + stream->modeflags |= __FLAG_NARROW; +#endif /* __STDIO_WIDE */ + + /* If can't read or there's been an error, or c == EOF, or ungot slots + * already filled, then return EOF */ + if ((stream->modeflags + & (__MASK_UNGOT2|__FLAG_WRITEONLY +#ifndef __STDIO_AUTO_RW_TRANSITION + |__FLAG_WRITING /* Note: technically no, but yes in spirit */ +#endif /* __STDIO_AUTO_RW_TRANSITION */ + )) + || ((stream->modeflags & __MASK_UNGOT1) && (stream->ungot[1])) + || (c == EOF) ) { + c = EOF; + goto DONE;; + } + +#ifdef __STDIO_BUFFERS + /* TODO: shouldn't allow writing??? */ + if (stream->modeflags & __FLAG_WRITING) { + fflush(stream); /* Commit any write-buffered chars. */ + } +#endif /* __STDIO_BUFFERS */ + + /* Clear EOF and WRITING flags, and set READING FLAG */ + stream->modeflags &= ~(__FLAG_EOF|__FLAG_WRITING); + stream->modeflags |= __FLAG_READING; + stream->ungot[1] = 1; /* Flag as app ungetc call; scanf fixes up. */ + stream->ungot[(stream->modeflags++) & __MASK_UNGOT] = c; + +#ifdef __STDIO_GETC_MACRO + stream->bufgetc = stream->bufstart; /* Must disable getc macro. */ +#endif + + __stdio_validate_FILE(stream); /* debugging only */ + + DONE: + __STDIO_THREADUNLOCK(stream); + + return c; +} + +#endif +/**********************************************************************/ +#ifdef L_fread +/* NOTE: Surely ptr cannot point to a buffer of size > SIZE_MAX. + * Therefore, we treat the case size * nmemb > SIZE_MAX as an error, + * and include an assert() for it. */ + +/* Reentrancy handled by UNLOCKED() macro. */ + +UNLOCKED(size_t,fread, + (void * __restrict ptr, size_t size, size_t nmemb, + FILE * __restrict stream), + (ptr,size,nmemb,stream)) +{ +#ifdef __STDIO_WIDE + if (stream->modeflags & __FLAG_WIDE) { + stream->modeflags |= __FLAG_ERROR; + /* TODO -- errno? it this correct? */ + return 0; + } + stream->modeflags |= __FLAG_NARROW; +#endif /* __STDIO_WIDE */ + + return (size == 0) + ? 0 + : ( assert( ((size_t)(-1)) / size >= nmemb ), + _stdio_fread(ptr, nmemb * size, stream) / size ); +} + +#endif +/**********************************************************************/ +#ifdef L_fwrite +/* NOTE: Surely ptr cannot point to a buffer of size > SIZE_MAX. + * Therefore, we treat the case size * nmemb > SIZE_MAX as an error, + * and include an assert() for it. */ + +/* Reentrancy handled by UNLOCKED() macro. */ + +UNLOCKED(size_t,fwrite, + (const void * __restrict ptr, size_t size, size_t nmemb, + FILE * __restrict stream), + (ptr,size,nmemb,stream)) +{ +#ifdef __STDIO_WIDE + if (stream->modeflags & __FLAG_WIDE) { + stream->modeflags |= __FLAG_ERROR; + /* TODO -- errno? it this correct? */ + return 0; + } + stream->modeflags |= __FLAG_NARROW; +#endif /* __STDIO_WIDE */ + + return (size == 0) + ? 0 + : ( assert( ((size_t)(-1)) / size >= nmemb ), + _stdio_fwrite(ptr, nmemb * size, stream) / size ); +} + +#endif +/**********************************************************************/ +#if defined(L_fgetpos) || defined(L_fgetpos64) + +/* Reentrant -- fgetpos() and fgetpos64(). */ + +#if defined(L_fgetpos) && defined(L_fgetpos64) +#error L_fgetpos and L_fgetpos64 are defined simultaneously! +#endif + +#ifndef L_fgetpos64 +#define fgetpos64 fgetpos +#define fpos64_t fpos_t +#define ftello64 ftell +#endif + + +int fgetpos64(FILE * __restrict stream, register fpos64_t * __restrict pos) +{ + int retval; + + __STDIO_THREADLOCK(stream); + + retval = ((pos != NULL) && ((pos->__pos = ftello64(stream)) >= 0)) + ? ( +#ifdef __STDIO_MBSTATE_DATA + __COPY_MBSTATE(&(pos->__mbstate), &(stream->mbstate)), +#endif /* __STDIO_MBSTATE_DATA */ + 0) + : (__set_errno(EINVAL), -1); + + __STDIO_THREADUNLOCK(stream); + + return retval; +} + +#ifndef L_fgetpos64 +#undef fgetpos64 +#undef fpos64_t +#undef ftello64 +#endif + +#endif +/**********************************************************************/ +#ifdef L_fseek +strong_alias(fseek, fseeko); +#endif + +#if defined(L_fseek) && defined(__STDIO_LARGE_FILES) + +int fseek(register FILE *stream, long int offset, int whence) +{ + return fseeko64(stream, offset, whence); +} + +#endif + +#if defined(L_fseeko64) || (defined(L_fseek) && !defined(__STDIO_LARGE_FILES)) + +#ifndef L_fseeko64 +#define fseeko64 fseek +#define __off64_t long int +#endif + +/* Reentrant -- fseek(), fseeko(), fseeko64() */ + +int fseeko64(register FILE *stream, __off64_t offset, int whence) +{ +#if SEEK_SET != 0 || SEEK_CUR != 1 || SEEK_END != 2 +#error Assumption violated -- values of SEEK_SET, SEEK_CUR, SEEK_END +#endif + __offmax_t pos[1]; + int retval; + + if ( ((unsigned int) whence) > 2 ) { + __set_errno(EINVAL); + return -1; + } + + __STDIO_THREADLOCK(stream); + + __stdio_validate_FILE(stream); /* debugging only */ + + retval = -1; + *pos = offset; + if ( +#ifdef __STDIO_BUFFERS + /* First commit any pending buffered writes. */ + ((stream->modeflags & __FLAG_WRITING) && fflush(stream)) || +#endif /* __STDIO_BUFFERS */ + ((whence == SEEK_CUR) && (_stdio_adjpos(stream, pos) < 0)) + || (_stdio_lseek(stream, pos, whence) < 0) + ) { + __stdio_validate_FILE(stream); /* debugging only */ + goto DONE; + } + +#ifdef __STDIO_BUFFERS + /* only needed if reading but do it anyway to avoid test */ +#ifdef __STDIO_GETC_MACRO + stream->bufgetc = /* Must disable getc. */ +#endif + stream->bufwpos = stream->bufrpos = stream->bufstart; +#endif /* __STDIO_BUFFERS */ + + stream->modeflags &= + ~(__FLAG_READING|__FLAG_WRITING|__FLAG_EOF|__MASK_UNGOT); + +#ifdef __STDIO_MBSTATE_DATA + /* TODO: don't clear state if don't move? */ + __INIT_MBSTATE(&(stream->mbstate)); +#endif /* __STDIO_MBSTATE_DATA */ + __stdio_validate_FILE(stream); /* debugging only */ + + retval = 0; + + DONE: + __STDIO_THREADUNLOCK(stream); + + return retval; +} + +#ifndef L_fseeko64 +#undef fseeko64 +#undef __off64_t +#endif + +#endif +/**********************************************************************/ +#if defined(L_fsetpos) || defined(L_fsetpos64) + +#if defined(L_fsetpos) && defined(L_fsetpos64) +#error L_fsetpos and L_fsetpos64 are defined simultaneously! +#endif + +#ifndef L_fsetpos64 +#define fsetpos64 fsetpos +#define fpos64_t fpos_t +#define fseeko64 fseek +#endif + +/* Reentrant -- fgetpos{64}() through fseek{64}(). */ + +int fsetpos64(FILE *stream, register const fpos64_t *pos) +{ + if (!pos) { + __set_errno(EINVAL); + return EOF; + } +#ifdef __STDIO_MBSTATE_DATA +#error unimplemented and non-reentrant besides! + { + int retval; + if ((retval = fseeko64(stream, pos->__pos, SEEK_SET)) == 0) { + __COPY_MBSTATE(&(stream->mbstate), &(pos->__mbstate)); + } + return retval; + } +#else /* __STDIO_MBSTATE_DATA */ + return fseeko64(stream, pos->__pos, SEEK_SET); +#endif /* __STDIO_MBSTATE_DATA */ +} + +#ifndef L_fsetpos64 +#undef fsetpos64 +#undef fpos64_t +#undef fseeko64 +#endif + +#endif +/**********************************************************************/ +#ifdef L_ftell +strong_alias(ftell, ftello); +#endif + +#if defined(L_ftell) && defined(__STDIO_LARGE_FILES) +long int ftell(register FILE *stream) +{ + __offmax_t pos = ftello64(stream); + + return (pos == ((long int) pos)) ? pos : (__set_errno(EOVERFLOW), -1); +} +#endif + +#if defined(L_ftello64) || (defined(L_ftell) && !defined(__STDIO_LARGE_FILES)) + +#ifndef L_ftello64 +#define ftello64 ftell +#define __off64_t long int +#endif + +/* Reentrant -- ftell, ftello, ftello64. */ + +__off64_t ftello64(register FILE *stream) +{ + __offmax_t pos[1]; + __off64_t retval; + + __STDIO_THREADLOCK(stream); + + retval = (((*pos = 0), (_stdio_lseek(stream, pos, SEEK_CUR) < 0)) + || (_stdio_adjpos(stream, pos) < 0)) ? -1 : *pos; + + __STDIO_THREADUNLOCK(stream); + + return retval; +} + +#ifndef L_ftello64 +#undef ftello64 +#undef __off64_t +#endif + +#endif +/**********************************************************************/ +#ifdef L_rewind + +void rewind(register FILE *stream) +{ + __STDIO_THREADLOCK(stream); + + __CLEARERR(stream); /* Clear errors first and then seek */ + fseek(stream, 0L, SEEK_SET); /* in case there is an error seeking. */ + + __STDIO_THREADUNLOCK(stream); +} + +#endif +/**********************************************************************/ +#ifdef L_clearerr +#undef clearerr + +/* Reentrancy handled by UNLOCKED_VOID_RETURN() macro. */ + +UNLOCKED_VOID_RETURN(clearerr,(FILE *stream),(stream)) +{ + __CLEARERR(stream); +} + +#endif +/**********************************************************************/ +#ifdef L_feof +#undef feof + +/* Reentrancy handled by UNLOCKED() macro. */ + +UNLOCKED(int,feof,(FILE *stream),(stream)) +{ + return __FEOF(stream); +} + +#endif +/**********************************************************************/ +#ifdef L_ferror +#undef ferror + +/* Reentrancy handled by UNLOCKED() macro. */ + +UNLOCKED(int,ferror,(FILE *stream),(stream)) +{ + return __FERROR(stream); +} + +#endif +/**********************************************************************/ +#ifdef L_perror + +/* TODO -- not allowed to interfere with static storage of strerror(). */ + +void perror(register const char *s) +{ + /* If the program is calling perror, it's a safe bet that printf and + * friends are used as well. It is also possible that the calling + * program could buffer stderr, or reassign it. */ + + register const char *sep; + + sep = ": "; + if (!(s && *s)) { /* Caller did not supply a prefix message */ + s = (sep += 2); /* or passed an empty string. */ + } + +#if 1 +#ifdef __STDIO_PRINTF_M_SPEC + fprintf(_stderr, "%s%s%m\n", s, sep); /* Use the gnu %m feature. */ +#else + /* TODO: use strerror_r instead? */ + fprintf(_stderr, "%s%s%s\n", s, sep, strerror(errno)); +#endif +#else + /* Note: Assumes stderr not closed or buffered. */ + __STDIO_THREADLOCK(stderr); + _stdio_fdout(STDERR_FILENO, s, sep, strerror(errno)); + __STDIO_THREADUNLOCK(stderr); +#endif +} + +#endif +/**********************************************************************/ +/* UTILITY funcs */ +/**********************************************************************/ +#ifdef L__stdio_fdout + +/* Not reentrant -- TODO: lock associated stream if a know file descriptor? */ + +void _stdio_fdout(int fd, ...) +{ + va_list arg; + const char *p; + + va_start(arg, fd); + while ((p = va_arg(arg, const char *)) != NULL) { + write(fd, p, strlen(p)); + } + va_end(arg); +} + +#endif +/**********************************************************************/ +#ifdef L__uintmaxtostr + +/* Avoid using long long / and % operations to cut down dependencies on + * libgcc.a. Definitely helps on i386 at least. */ +#if (UINTMAX_MAX > UINT_MAX) && ((UINTMAX_MAX/UINT_MAX) - 2 <= UINT_MAX) +#define INTERNAL_DIV_MOD +#endif + +char *_uintmaxtostr(char * __restrict bufend, uintmax_t uval, + int base, __UIM_CASE alphacase) +{ + int negative; + unsigned int digit; +#ifdef INTERNAL_DIV_MOD + unsigned int H, L, high, low, rh; +#endif + + negative = 0; + if (base < 0) { /* signed value */ + base = -base; + if (uval > INTMAX_MAX) { + uval = -uval; + negative = 1; + } + } + + /* this is an internal routine -- we shouldn't need to check this */ + assert(!((base < 2) || (base > 36))); + + *bufend = '\0'; + +#ifndef INTERNAL_DIV_MOD + do { + digit = uval % base; + uval /= base; + + *--bufend = ( (digit < 10) ? digit + '0' : digit + alphacase ); + } while (uval); + +#else /* ************************************************** */ + + H = (UINT_MAX / base); + L = UINT_MAX % base + 1; + if (L == base) { + ++H; + L = 0; + } + low = (unsigned int) uval; + high = (unsigned int) (uval >> (sizeof(unsigned int) * CHAR_BIT)); + + do { + rh = high % base; + high /= base; + digit = (low % base) + (L * rh); + low = (low / base) + (H * rh) + (digit / base); + digit %= base; + + *--bufend = ( (digit < 10) ? digit + '0' : digit + alphacase ); + } while (low | high); + +#endif /******************************************************/ + + if (negative) { + *--bufend = '-'; + } + + return bufend; +} +#undef INTERNAL_DIV_MOD + +#endif |