From 03e039820dc5092e27e81f3671652f25da7f25f1 Mon Sep 17 00:00:00 2001 From: Manuel Novoa III Date: Tue, 12 Mar 2002 01:18:50 +0000 Subject: Swap in the new stdio code. --- libc/inet/addr.c | 17 +- libc/misc/assert/__assert.c | 81 +- libc/misc/internals/Makefile | 8 +- libc/misc/internals/__uClibc_main.c | 18 +- libc/misc/internals/dtostr.c | 423 ---------- libc/misc/internals/lltostr.c | 39 - libc/misc/internals/ltostr.c | 39 - libc/misc/internals/tempname.c | 37 +- libc/misc/internals/ulltostr.c | 37 - libc/misc/internals/ultostr.c | 37 - libc/misc/internals/zoicheck.c | 16 - libc/stdio/Makefile | 75 +- libc/stdio/getw.c | 36 - libc/stdio/old_vfprintf.c | 493 +++++++++++ libc/stdio/perror.c | 27 - libc/stdio/printf.c | 713 ---------------- libc/stdio/putw.c | 34 - libc/stdio/remove.c | 23 - libc/stdio/scanf.c | 83 +- libc/stdio/stdio.c | 1117 ------------------------- libc/stdlib/atexit.c | 13 +- libc/stdlib/ptsname.c | 13 +- libc/string/strerror.c | 26 +- libc/string/strsignal.c | 28 +- libc/sysdeps/linux/common/bits/uClibc_stdio.h | 494 +++++++++++ 25 files changed, 1231 insertions(+), 2696 deletions(-) delete mode 100644 libc/misc/internals/dtostr.c delete mode 100644 libc/misc/internals/lltostr.c delete mode 100644 libc/misc/internals/ltostr.c delete mode 100644 libc/misc/internals/ulltostr.c delete mode 100644 libc/misc/internals/ultostr.c delete mode 100644 libc/misc/internals/zoicheck.c delete mode 100644 libc/stdio/getw.c create mode 100644 libc/stdio/old_vfprintf.c delete mode 100644 libc/stdio/perror.c delete mode 100644 libc/stdio/printf.c delete mode 100644 libc/stdio/putw.c delete mode 100644 libc/stdio/remove.c delete mode 100644 libc/stdio/stdio.c create mode 100644 libc/sysdeps/linux/common/bits/uClibc_stdio.h (limited to 'libc') diff --git a/libc/inet/addr.c b/libc/inet/addr.c index d1f9c04e6..6b143c6ba 100644 --- a/libc/inet/addr.c +++ b/libc/inet/addr.c @@ -10,10 +10,16 @@ * are smaller than the previous functions and don't require static buffers. * In the process, removed the reference to strcat and cut object size of * inet_ntoa in half (from 190 bytes down to 94). + * + * Manuel Novoa III Feb 2002 + * + * Changed to use _int10tostr. */ #define __FORCE_GLIBC #include +#define _STDIO_UTILITY /* For _int10tostr. */ +#include #include #include #include @@ -80,15 +86,6 @@ const char *cp; #ifdef L_inet_ntoa -#include - -#if (ULONG_MAX >> 32) -/* We're set up for 32 bit unsigned longs */ -#error need to check size allocation for static buffer 'buf' -#endif - -extern char *__ultostr(char *buf, unsigned long uval, int base, int uppercase); - char *inet_ntoa(in) struct in_addr in; { @@ -101,7 +98,7 @@ struct in_addr in; q = 0; p = buf + sizeof(buf) - 1; for (i=0 ; i < 4 ; i++ ) { - p = __ultostr(p, addr & 0xff, 10, 0 ) - 1; + p = _int10tostr(p, addr & 0xff) - 1; addr >>= 8; if (q) { *q = '.'; diff --git a/libc/misc/assert/__assert.c b/libc/misc/assert/__assert.c index b98958f43..fba9dc719 100644 --- a/libc/misc/assert/__assert.c +++ b/libc/misc/assert/__assert.c @@ -1,49 +1,52 @@ -/* Copyright (C) 1996 Robert de Bath - * This file is part of the Linux-8086 C library and is distributed - * under the GNU Library General Public License. - */ - -/* - * Manuel Novoa III Dec 2000 +/* Copyright (C) 2002 Manuel Novoa III + * An __assert() function compatible with the modified glibc assert.h + * that is used by uClibc. + * + * 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. * - * Converted to use my new (un)signed long (long) to string routines, which - * are smaller than the previous functions and don't require static buffers. + * 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. */ -#include -#include +#define _STDIO_UTILITY /* For _stdio_fdout and _int10tostr. */ +#include #include -#include - -#if (INT_MAX >> 31) -/* We're set up for 32 bit ints */ -#error need to check size allocation for buffer 'buf' -#endif - -extern char *__ltostr(char *buf, unsigned long uval, int base, int uppercase); +#include -static void errput(str) -const char *str; -{ - write(2, str, strlen(str)); -} +/* Get the prototype from assert.h as a double-check. */ +#undef NDEBUG +#include +#undef assert -void __assert(assertion, filename, linenumber, function) -const char *assertion; -const char *filename; -int linenumber; -const char *function; +void __assert(const char *assertion, const char * filename, + int linenumber, const char * function) { - char buf[12]; + char buf[__BUFLEN_INT10TOSTR]; - errput(filename); - errput(":"); - errput(__ltostr(buf + sizeof(buf) - 1, linenumber, 10, 0)); - errput(function ? ": " : ""); - errput(function ? function : ""); - errput(function ? "() " : ""); - errput(": Assertion \""); - errput(assertion); - errput("\" failed.\n"); + _stdio_fdout(STDERR_FILENO, +#if 0 + program_name, /* TODO: support program_name like glibc? */ + ": ", +#endif + filename, + ":", + _int10tostr(buf+sizeof(buf)-1, linenumber), + ": ", + /* Function name isn't available with some compilers. */ + ((function == NULL) ? "?function?" : function), + ": Assertion `", + assertion, + "' failed.\n", + NULL + ); abort(); } diff --git a/libc/misc/internals/Makefile b/libc/misc/internals/Makefile index 6e1c2c29d..c35c636ef 100644 --- a/libc/misc/internals/Makefile +++ b/libc/misc/internals/Makefile @@ -24,13 +24,7 @@ TOPDIR=../../../ include $(TOPDIR)Rules.mak -CSRC=ultostr.c ltostr.c __uClibc_main.c tempname.c errno.c __errno_location.c __h_errno_location.c -ifeq ($(HAS_FLOATING_POINT),true) - CSRC += dtostr.c zoicheck.c -endif -ifeq ($(HAS_LONG_LONG),true) - CSRC += ulltostr.c lltostr.c -endif +CSRC=__uClibc_main.c tempname.c errno.c __errno_location.c __h_errno_location.c COBJS=$(patsubst %.c,%.o, $(CSRC)) OBJS=$(COBJS) diff --git a/libc/misc/internals/__uClibc_main.c b/libc/misc/internals/__uClibc_main.c index 7f5e6e805..7c2eaf35c 100644 --- a/libc/misc/internals/__uClibc_main.c +++ b/libc/misc/internals/__uClibc_main.c @@ -28,13 +28,13 @@ void __uClibc_main(int argc, char **argv, char **envp) #ifdef HAVE_ELF weak_alias(__environ, environ); -extern void weak_function __init_stdio(void); -extern void weak_function __stdio_flush_buffers(void); +extern void weak_function _stdio_init(void); +extern void weak_function _stdio_term(void); extern int *weak_const_function __errno_location (void); extern int *weak_const_function __h_errno_location (void); #else -extern void __init_stdio(void); -extern void __stdio_flush_buffers(void); +extern void _stdio_init(void); +extern void _stdio_term(void); extern int *__errno_location (void); extern int *__h_errno_location (void); #endif @@ -71,8 +71,8 @@ void __uClibc_main(int argc, char **argv, char **envp) * Initialize stdio here. In the static library case, this will * be bypassed if not needed because of the weak alias above. */ - if (__init_stdio) - __init_stdio(); + if (_stdio_init) + _stdio_init(); /* * Note: It is possible that any initialization done above could @@ -95,7 +95,7 @@ void __uClibc_main(int argc, char **argv, char **envp) /* * Define an empty function and use it as a weak alias for the stdio * initialization routine. That way we don't pull in all the stdio - * code unless we need to. Similarly, do the same for __stdio_flush_buffers + * code unless we need to. Similarly, do the same for _stdio_term * so as not to include atexit unnecessarily. * * NOTE!!! This is only true for the _static_ case!!! @@ -106,7 +106,7 @@ weak_alias(__environ, environ); void __uClibc_empty_func(void) { } -weak_alias(__uClibc_empty_func, __init_stdio); -weak_alias(__uClibc_empty_func, __stdio_flush_buffers); +weak_alias(__uClibc_empty_func, _stdio_init); +weak_alias(__uClibc_empty_func, _stdio_term); #endif #endif diff --git a/libc/misc/internals/dtostr.c b/libc/misc/internals/dtostr.c deleted file mode 100644 index 85ec69b12..000000000 --- a/libc/misc/internals/dtostr.c +++ /dev/null @@ -1,423 +0,0 @@ -/* - * Copyright (C) 2000, 2001 Manuel Novoa III - * - * Function: int __dtostr(FILE * fp, size_t size, long double x, - * char flag[], int width, int preci, char mode) - * - * 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 -#include -#include -#include -#include - -extern int fnprintf(FILE * fp, size_t size, const char *fmt, ...); - -/* from printf.c -- should really be in an internal header file */ -enum { - FLAG_PLUS = 0, - FLAG_MINUS_LJUSTIFY, - FLAG_HASH, - FLAG_0_PAD, - FLAG_SPACE, -}; - -/*****************************************************************************/ - -/* - * 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 (INT_MAX >> 30) -#define DIGIT_BLOCK_TYPE int -#define DB_FMT "%.*d" -#elif (LONG_MAX >> 30) -#define DIGIT_BLOCK_TYPE long -#define DB_FMT "%.*ld" -#else -#error need at least 32 bit longs -#endif - -/* Are there actually any machines where this might fail? */ -#if 'A' > 'a' -#error ordering assumption violated : 'A' > 'a' -#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" -}; - -/*****************************************************************************/ - -int __dtostr(FILE * fp, size_t size, long double x, - char flag[], int width, int preci, char mode) -{ - 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; - 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; - - /* check that INT_OR_PTR is sufficiently large */ - assert( sizeof(INT_OR_PTR) == sizeof(char *) ); - - *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; - 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; - 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' */ - - for (i = 0 ; i < NUM_DIGIT_BLOCKS ; ++i ) { - digit_block = (DIGIT_BLOCK_TYPE) x; - x = (x - digit_block) * 1e9; - 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 (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 (flag[FLAG_MINUS_LJUSTIFY]) { /* padding on right */ - ++npc; - *pdrvr++ = 7; - *ppc = width; - *++ppc = (INT_OR_PTR)(""); - width = 0; - } else if (flag[FLAG_0_PAD] == '0') { /* 0 padding */ - 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 *ppc) { - size -= *ppc; - } - cnt += *ppc; /* to avoid problems if j == -1 */ - ppc += 2; - } - - return cnt; -} - - - - - - diff --git a/libc/misc/internals/lltostr.c b/libc/misc/internals/lltostr.c deleted file mode 100644 index 2ce359615..000000000 --- a/libc/misc/internals/lltostr.c +++ /dev/null @@ -1,39 +0,0 @@ -/* - * Copyright (C) 2000 Manuel Novoa III - * - * Note: buf is a pointer to the END of the buffer passed. - * Call like this: - * char buf[SIZE], *p; - * p = __lltostr(buf + sizeof(buf) - 1, ...) - * For long longs of 64 bits, appropriate buffer sizes are: - * base = 2 66 = 1 (possible -) sign + 64 digits + 1 nul - * base = 10 21 = 1 (possible -) sign + 19 digits + 1 nul - * base = 16 18 = 1 (possible -) sign + 16 hex digits + 1 nul - */ - -extern char *__ulltostr(char *buf, unsigned long long uval, int base, - int uppercase); - -char *__lltostr(char *buf, long long val, int base, int uppercase) -{ - unsigned long long uval; - char *pos; - int negative; - - negative = 0; - if (val < 0) { - negative = 1; - uval = ((unsigned long long)(-(1+val))) + 1; - } else { - uval = val; - } - - - pos = __ulltostr(buf, uval, base, uppercase); - - if (pos && negative) { - *--pos = '-'; - } - - return pos; -} diff --git a/libc/misc/internals/ltostr.c b/libc/misc/internals/ltostr.c deleted file mode 100644 index 7e45fec30..000000000 --- a/libc/misc/internals/ltostr.c +++ /dev/null @@ -1,39 +0,0 @@ -/* - * Copyright (C) 2000 Manuel Novoa III - * - * Note: buf is a pointer to the END of the buffer passed. - * Call like this: - * char buf[SIZE], *p; - * p = __ltostr(buf + sizeof(buf) - 1, ...) - * - * For longs of 32 bits, appropriate buffer sizes are: - * base = 2 34 = 1 (possible -) sign + 32 digits + 1 nul - * base = 10 12 = 1 (possible -) sign + 10 digits + 1 nul - * base = 16 10 = 1 (possible -) sign + 8 hex digits + 1 nul - */ - -extern char *__ultostr(char *buf, unsigned long uval, int base, int uppercase); - -char *__ltostr(char *buf, long val, int base, int uppercase) -{ - unsigned long uval; - char *pos; - int negative; - - negative = 0; - if (val < 0) { - negative = 1; - uval = ((unsigned long)(-(1+val))) + 1; - } else { - uval = val; - } - - - pos = __ultostr(buf, uval, base, uppercase); - - if (pos && negative) { - *--pos = '-'; - } - - return pos; -} diff --git a/libc/misc/internals/tempname.c b/libc/misc/internals/tempname.c index 3c43f9b85..41325d998 100644 --- a/libc/misc/internals/tempname.c +++ b/libc/misc/internals/tempname.c @@ -16,6 +16,11 @@ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +/* March 11, 2002 Manuel Novoa III + * + * Modify code to remove dependency on libgcc long long arith support funcs. + */ + #include #include #include @@ -117,8 +122,11 @@ int __gen_tempname (char *tmpl, int openit) char *XXXXXX; static uint64_t value; struct timeval tv; + uint32_t high, low, rh; + unsigned int k; int count, fd; int save_errno = errno; + int i; len = strlen (tmpl); if (len < 6 || strcmp (&tmpl[len - 6], "XXXXXX")) @@ -136,20 +144,21 @@ int __gen_tempname (char *tmpl, int openit) for (count = 0; count < TMP_MAX; value += 7777, ++count) { - uint64_t v = value; - - /* Fill in the random bits. */ - XXXXXX[0] = letters[v % 62]; - v /= 62; - XXXXXX[1] = letters[v % 62]; - v /= 62; - XXXXXX[2] = letters[v % 62]; - v /= 62; - XXXXXX[3] = letters[v % 62]; - v /= 62; - XXXXXX[4] = letters[v % 62]; - v /= 62; - XXXXXX[5] = letters[v % 62]; + low = value & UINT32_MAX; + high = value >> 32; + + for (i = 0 ; i < 6 ; i++) { + rh = high % 62; + high /= 62; +#define L ((UINT32_MAX % 62 + 1) % 62) + k = (low % 62) + (L * rh); +#undef L +#define H ((UINT32_MAX / 62) + ((UINT32_MAX % 62 + 1) / 62)) + low = (low / 62) + (H * rh) + (k / 62); +#undef H + k %= 62; + XXXXXX[i] = letters[k]; + } if (openit) { diff --git a/libc/misc/internals/ulltostr.c b/libc/misc/internals/ulltostr.c deleted file mode 100644 index 50246d3bc..000000000 --- a/libc/misc/internals/ulltostr.c +++ /dev/null @@ -1,37 +0,0 @@ -/* - * Copyright (C) 2000 Manuel Novoa III - * - * Note: buf is a pointer to the END of the buffer passed. - * Call like this: - * char buf[SIZE], *p; - * p = __ulltostr(buf + sizeof(buf) - 1, ...) - * - * For long longs of 64 bits, appropriate buffer sizes are: - * base = 2 65 = 64 digits + 1 nul - * base = 10 20 = 19 digits + 1 nul - * base = 16 17 = 16 hex digits + 1 nul - */ - -char *__ulltostr(char *buf, unsigned long long uval, int base, int uppercase) -{ - int digit; - - if ((base < 2) || (base > 36)) { - return 0; - } - - *buf = '\0'; - - do { - digit = uval % base; - uval /= base; - - /* note: slightly slower but generates less code */ - *--buf = '0' + digit; - if (digit > 9) { - *buf = (uppercase ? 'A' : 'a') + digit - 10; - } - } while (uval); - - return buf; -} diff --git a/libc/misc/internals/ultostr.c b/libc/misc/internals/ultostr.c deleted file mode 100644 index d4663fb39..000000000 --- a/libc/misc/internals/ultostr.c +++ /dev/null @@ -1,37 +0,0 @@ -/* - * Copyright (C) 2000 Manuel Novoa III - * - * Note: buf is a pointer to the END of the buffer passed. - * Call like this; - * char buf[SIZE], *p; - * p = __ultostr(buf + sizeof(buf) - 1, ...) - * - * For longs of 32 bits, appropriate buffer sizes are: - * base = 2 33 = 32 digits + 1 nul - * base = 10 11 = 10 digits + 1 nul - * base = 16 9 = 8 hex digits + 1 nul - */ - -char *__ultostr(char *buf, unsigned long uval, int base, int uppercase) -{ - int digit; - - if ((base < 2) || (base > 36)) { - return 0; - } - - *buf = '\0'; - - do { - digit = uval % base; - uval /= base; - - /* note: slightly slower but generates less code */ - *--buf = '0' + digit; - if (digit > 9) { - *buf = (uppercase ? 'A' : 'a') + digit - 10; - } - } while (uval); - - return buf; -} diff --git a/libc/misc/internals/zoicheck.c b/libc/misc/internals/zoicheck.c deleted file mode 100644 index 2113c6298..000000000 --- a/libc/misc/internals/zoicheck.c +++ /dev/null @@ -1,16 +0,0 @@ - -/* - * Copyright (C) 2000 Manuel Novoa III - * - * This is a utility routine for strtod errno support. - * As the name implies, it checks if a double is either 0 or +/-infinity. - * Doing this inline doesn't work on i386 because of excess precission - * stored in the FPU. - * - * TODO: Check bitmasks directly? - */ - -int _zero_or_inf_check(double x) -{ - return ( x == x/4 ); -} diff --git a/libc/stdio/Makefile b/libc/stdio/Makefile index bbbc46664..c2a557a45 100644 --- a/libc/stdio/Makefile +++ b/libc/stdio/Makefile @@ -24,26 +24,73 @@ TOPDIR=../../ include $(TOPDIR)Rules.mak -MSRC=stdio.c -MOBJ=_stdio_init.o _alloc_stdio_buffer.o _free_stdio_buffer_of_file.o \ - _free_stdio_stream.o clearerr.o feof.o ferror.o fileno.o setbuffer.o \ - setvbuf.o setbuf.o setlinebuf.o fclose.o _fopen.o fopen.o freopen.o \ - fdopen.o fflush.o fsfopen.o fseek.o rewind.o ftell.o fgetpos.o fsetpos.o \ - fputc.o fgetc.o fgets.o gets.o fputs.o puts.o ungetc.o fread.o fwrite.o \ - getchar.o putchar.o _uClibc_fwrite.o _uClibc_fread.o fopen64.o getc.o putc.o - -MSRC2=printf.c -MOBJ2=printf.o sprintf.o fprintf.o vprintf.o vsprintf.o vfprintf.o snprintf.o \ - vsnprintf.o asprintf.o vfnprintf.o fnprintf.o vdprintf.o +# Set to true to use the old vfprintf instead of the new. The old is roughly +# C89 compliant, but doesn't deal with qualifiers on %n and doesn't deal with +# %h correctly or %hh at all on the interger conversions. But on i386 it is +# over 1.5k smaller than the new code. Of course, the new code fixes the +# above mentioned deficiencies and adds custom specifier support similar to +# glibc, as well as handling positional args. This option is here temporarily +# until the configuration system gets rewritten. Note also that the old +# vfprintf code will be rewritten at some point to bring it into at least C89 +# standards compliance. + +USE_OLD_VFPRINTF = false + +# Note: The *64.o objects are empty when compiled without large file support. +# To not build them at all, remove the appropriate line from the MOBJ +# definition and uncomment the DOLFS test below. + +# Note: Use the libpthreads of: flockfile.o ftrylockfile.o funlockfile.o +# Also, maybe move __fsetlocking.o as well? + +MSRC = stdio.c +MOBJ = fclose.o fflush.o fopen.o freopen.o perror.o remove.o \ + setbuf.o setvbuf.o fgetc.o fgets.o fputc.o fputs.o \ + getc.o getchar.o gets.o putc.o putchar.o puts.o \ + ungetc.o fread.o fwrite.o fgetpos.o fseek.o fsetpos.o ftell.o \ + rewind.o clearerr.o feof.o ferror.o \ + fileno.o fdopen.o getw.o putw.o setbuffer.o setlinebuf.o fcloseall.o \ + fopen64.o freopen64.o ftello64.o fseeko64.o fsetpos64.o fgetpos64.o \ + __fbufsize.o __freading.o __fwriting.o __freadable.o __fwritable.o \ + __flbf.o __fpurge.o __fpending.o _flushlbf.o \ + fopencookie.o fmemopen.o open_memstream.o \ + __fsetlocking.o \ + _stdio_fopen.o _stdio_fread.o _stdio_fwrite.o _stdio_adjpos.o \ + _stdio_lseek.o _stdio_init.o \ + _stdio_fsfopen.o _stdio_fdout.o _uintmaxtostr.o + +# ifeq ($(DOLFS),true) +# MOBJ += fopen64.o freopen64.o ftello64.o fseeko64.o fsetpos64.o fgetpos64.o +# endif + +MSRC2= printf.c +MOBJ2= vsnprintf.o vdprintf.o vasprintf.o vprintf.o vsprintf.o \ + fprintf.o snprintf.o dprintf.o asprintf.o printf.o sprintf.o + +ifneq ($(USE_OLD_VFPRINTF),true) + MOBJ2 += _ppfs_init.o _ppfs_prepargs.o _ppfs_setargs.o \ + _ppfs_parsespec.o _do_one_spec.o vfprintf.o \ + _store_inttype.o _load_inttype.o \ + register_printf_function.o parse_printf_format.o +endif + + + +ifeq ($(HAS_FLOATING_POINT),true) + MOBJ2 += _dtostr.o +endif MSRC3=scanf.c MOBJ3=scanf.o sscanf.o fscanf.o vscanf.o vsscanf.o vfscanf.o -CSRC=popen.c perror.c remove.c getdelim.c getline.c tmpfile.c tmpnam.c \ - tmpnam_r.c tempnam.c ctermid.c getw.c putw.c +CSRC=popen.c getdelim.c getline.c tmpfile.c tmpnam.c \ + tmpnam_r.c tempnam.c ctermid.c +ifeq ($(USE_OLD_VFPRINTF),true) + CSRC += old_vfprintf.c +endif COBJS=$(patsubst %.c,%.o, $(CSRC)) -OBJS=$(MOBJ) $(MOBJ2) $(MOBJ3) $(COBJS) +OBJS=$(MOBJ) $(MOBJ2) $(MOBJ3) $(COBJS) all: $(OBJS) $(LIBC) diff --git a/libc/stdio/getw.c b/libc/stdio/getw.c deleted file mode 100644 index 75e73667f..000000000 --- a/libc/stdio/getw.c +++ /dev/null @@ -1,36 +0,0 @@ -/* Copyright (C) 1991, 1997, 1998 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C 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 - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library; if not, write to the Free - Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA - 02111-1307 USA. */ - -#include - -#ifdef USE_IN_LIBIO -# include -# define fread(p, m, n, s) _IO_fread (p, m, n, s) -#endif - -/* Read a word (int) from STREAM. */ -int -getw (FILE *stream) -{ - int w; - - /* Is there a better way? */ - if (fread ((void *) &w, sizeof (w), 1, stream) != 1) - return EOF; - return w; -} diff --git a/libc/stdio/old_vfprintf.c b/libc/stdio/old_vfprintf.c new file mode 100644 index 000000000..c7c07f34a --- /dev/null +++ b/libc/stdio/old_vfprintf.c @@ -0,0 +1,493 @@ +/* + * This file based on printf.c from 'Dlibs' on the atari ST (RdeBath) + * + * + * Dale Schumacher 399 Beacon Ave. + * (alias: Dalnefre') St. Paul, MN 55104 + * dal@syntel.UUCP United States of America + * "It's not reality that's important, but how you perceive things." + */ + +/* Altered to use stdarg, made the core function vfnprintf. + * Hooked into the stdio package using 'inside information' + * Altered sizeof() assumptions, now assumes all integers except chars + * will be either + * sizeof(xxx) == sizeof(long) or sizeof(xxx) == sizeof(short) + * + * -RDB + */ + +/* + * Manuel Novoa III Dec 2000 + * + * The previous vfnprintf routine was almost completely rewritten with the + * goal of fixing some shortcomings and reducing object size. + * + * The summary of changes: + * + * Converted print conversion specification parsing from one big switch + * to a method using string tables. This new method verifies that the + * conversion flags, field width, precision, qualifier, and specifier + * appear in the correct order. Many questionable specifications were + * accepted by the previous code. This new method also resulted in a + * substantial reduction in object size of about 330 bytes (20%) from + * the old version (1627 bytes) on i386, even with the following + * improvements. + * + * Implemented %n specifier as required by the standards. + * Implemented proper handling of precision for int types. + * Implemented # for hex and pointer, fixed error for octal rep of 0. + * Implemented return of -1 on stream error. + * + * Added optional support for the GNU extension %m which prints the string + * corresponding the errno. + * + * Added optional support for long long ints and unsigned long long ints + * using the conversion qualifiers "ll", "L", or "q" (like glibc). + * + * Added optional support for doubles in a very limited form. None of + * the formating options are obeyed. The string returned by __dtostr + * is printed directly. + * + * Converted to use my (un)signed long (long) to string routines, which are + * smaller than the previous functions and don't require static buffers. + * + * Other Modifications: + * Modified sprintf, snprintf, vsprintf, vsnprintf to share on fake-file. + */ + +/* + * Manuel Novoa III Jan 2001 + * + * Removed fake file from *s*printf functions because of possible problems + * if called recursively. Instead, have sprintf, snprintf, and vsprintf + * call vsnprintf which allocates a fake file on the stack. + * Removed WANT_FPUTC option. Always use standard putc macro to avoid + * problems with the fake file used by the *s*printf functions. + * Fixed bug parsing flags -- did not restart scan. + * Added function asprintf. + * Fixed 0-pad prefixing bug. + * Converted sizeof(int) == sizeof(long) tests to compile time vs run time. + * This saves 112 bytes of code on i386. + * Fixed precision bug -- when negative set to default. + * Added function fnprintf to support __dtostr. + * Added floating point support for doubles. Yeah! + * + * + * May 2001 Fixes from Johan Adolfsson (johan.adolfsson@axis.com) + * 1) printf("%c",0) returned 0 instead of 1. + * 2) unrolled loop in asprintf to reduce size and remove compile warning. + * + * + * June 2001 + * 1) fix %p so that "0x" is prepended to outputed hex val + * 2) fix %p so that "(nil)" is output for (void *)0 to match glibc + * + */ + +/*****************************************************************************/ +/* OPTIONS */ +/*****************************************************************************/ +/* The optional support for long longs and doubles comes in two forms. + * + * 1) Normal (or partial for doubles) output support. Set to 1 to turn on. + * Adds about 130 bytes for doubles, about 220 bytes for long longs, + * and about 275 for both to the base code size of 1163 on i386. + */ + +/* These are now set in uClibc_config.h based on Config. */ +/* +#define __UCLIBC_HAS_FLOATS__ 1 +*/ + +/* 2) An error message is inserted into the stream, an arg of the + * appropriate size is removed from the arglist, and processing + * continues. This is adds less code and may be useful in some + * cases. Set to 1 to turn on. Adds about 50 bytes for doubles, + * about 140 bytes for long longs, and about 175 bytes for both + * to the base code size of 1163 on i386. + */ + +#define WANT_FLOAT_ERROR 0 + +/* + * Set to support GNU extension of %m to print string corresponding to errno. + * + * Warning: This adds about 50 bytes (i386) to the code but it also pulls in + * strerror and the corresponding string table which together are about 3.8k. + */ + +#define WANT_GNU_ERRNO 0 + +/**************************************************************************/ + +#define _GNU_SOURCE /* for strnlen */ +#define _STDIO_UTILITY +#include +#include +#include +#include +#include + +#define __PRINTF_INFO_NO_BITFIELD +#include + +#ifdef __STDIO_THREADSAFE +#include +#endif /* __STDIO_THREADSAFE */ + +/* #undef __UCLIBC_HAS_FLOATS__ */ +/* #undef WANT_FLOAT_ERROR */ +/* #define WANT_FLOAT_ERROR 1 */ + +#define __isdigit(c) (((unsigned int)(c - '0')) < 10) + +extern size_t _dtostr(FILE * fp, long double x, struct printf_info *info); + + +enum { + FLAG_PLUS = 0, + FLAG_MINUS_LJUSTIFY, + FLAG_HASH, + FLAG_0_PAD, + FLAG_SPACE, +}; + +/* layout 01234 */ +static const char spec[] = "+-#0 "; + +static const char qual[] = "hlLq"; + +#if !defined(__UCLIBC_HAS_FLOATS__) && WANT_FLOAT_ERROR +static const char dbl_err[] = ""; +#endif + +#if defined(__UCLIBC_HAS_FLOATS__) || WANT_FLOAT_ERROR +/* layout 012345678901234567 */ +static const char u_spec[] = "%nbopxXudicsfgGeEaA"; +#else +/* layout 0123456789012 */ +static const char u_spec[] = "%nbopxXudics"; +#endif + +/* WARNING: u_spec and u_radix need to stay in agreement!!! */ +/* u_radix[i] <-> u_spec[i+2] for unsigned entries only */ +static const char u_radix[] = "\x02\x08\x10\x10\x10\x0a"; + +int vfprintf(FILE * __restrict op, register const char * __restrict fmt, + va_list ap) +{ + int i, cnt, lval, len; + char *p; + const char *fmt0; + int preci, width; +#define upcase i + int radix, dpoint /*, upcase*/; + char tmp[65]; /* TODO - determing needed size from headers */ + char flag[sizeof(spec)]; + + __STDIO_THREADLOCK(op); + + cnt = 0; + + while (*fmt) { + if (*fmt == '%') { + fmt0 = fmt; /* save our position in case of bad format */ + ++fmt; + width = -1; /* min field width */ + preci = -5; /* max string width or mininum digits */ + radix = 10; /* number base */ + dpoint = 0; /* found decimal point */ +#if INT_MAX != LONG_MAX + lval = 0; /* sizeof(int) != sizeof(long) */ +#else + lval = 1; /* sizeof(int) == sizeof(long) */ +#endif + + /* init flags */ + for (p =(char *) spec ; *p ; p++) { + flag[p-spec] = '\0'; + } + flag[FLAG_0_PAD] = ' '; + + /* process optional flags */ + for (p = (char *)spec ; *p ; ) { + if (*fmt == *p) { + flag[p-spec] = *fmt++; + p = (char *)spec; /* restart scan */ + } else { + p++; + } + } + + if (!flag[FLAG_PLUS]) { + flag[FLAG_PLUS] = flag[FLAG_SPACE]; + } + + /* process optional width and precision */ + do { + if (*fmt == '.') { + ++fmt; + dpoint = 1; + } + if (*fmt == '*') { /* parameter width value */ + ++fmt; + i = va_arg(ap, int); + } else { + for ( i = 0 ; (*fmt >= '0') && (*fmt <= '9') ; ++fmt ) { + i = (i * 10) + (*fmt - '0'); + } + } + + if (dpoint) { + preci = i; + if (i<0) { + preci = -5; + } + } else { + width = i; + if (i<0) { + width = -i; + flag[FLAG_MINUS_LJUSTIFY] = 1; + } + } + } while ((*fmt == '.') && !dpoint ); + + /* process optional qualifier */ + for (p = (char *) qual ; *p ; p++) { + if (*p == *fmt) { + lval = p - qual; + ++fmt; /* TODO - hh */ + if ((*p == 'l') && (*fmt == *p)) { + ++lval; + ++fmt; + } + } + } + +#if WANT_GNU_ERRNO + if (*fmt == 'm') { + flag[FLAG_PLUS] = '\0'; + flag[FLAG_0_PAD] = ' '; + p = strerror(errno); + goto print; + } +#endif + + /* process format specifier */ + for (p = (char *) u_spec ; *p ; p++) { + if (*fmt != *p) continue; + if (p-u_spec < 1) { /* print a % */ + goto charout; + } + if (p-u_spec < 2) { /* store output count in int ptr */ + *(va_arg(ap, int *)) = cnt; + goto nextfmt; + } + if (p-u_spec < 8) { /* unsigned conversion */ + radix = u_radix[p-u_spec-2]; + upcase = ((*p == 'x') ? __UIM_LOWER : __UIM_UPPER); + if (*p == 'p') { + lval = (sizeof(char *) == sizeof(long)); + upcase = __UIM_LOWER; + flag[FLAG_HASH] = 'p'; + } + + p = _uintmaxtostr((tmp + sizeof(tmp) - 1), + ((lval>1) /* TODO -- longlong/long/int/short/char */ + ? va_arg(ap, uintmax_t) + : (uintmax_t) + va_arg(ap, unsigned long)), + radix, upcase); + + flag[FLAG_PLUS] = '\0'; /* meaningless for unsigned */ + if (*p != '0') { /* non-zero */ + if (flag[FLAG_HASH]) { + if (radix == 8) { + *--p = '0'; /* add leadding zero */ + } else if (radix != 10) { /* either 2 or 16 */ + flag[FLAG_PLUS] = '0'; + *--p = 'b'; + if (radix == 16) { + *p = 'x'; + if (*fmt == 'X') { + *p = 'X'; + } + } + } + } + } else if (flag[FLAG_HASH] == 'p') { /* null pointer */ + p = "(nil)"; + } + } else if (p-u_spec < 10) { /* signed conversion */ + + p = _uintmaxtostr((tmp + sizeof(tmp) - 1), + ((lval>1) /* TODO -- longlong/long/int/short/char */ + ? va_arg(ap, uintmax_t) + : (uintmax_t) ((long long) /* sign-extend! */ + va_arg(ap, long))), + -radix, upcase); + + } else if (p-u_spec < 12) { /* character or string */ + flag[FLAG_PLUS] = '\0'; + flag[FLAG_0_PAD] = ' '; + if (*p == 'c') { /* character */ + p = tmp; + *p = va_arg(ap, int); + /* This takes care of the "%c",0 case */ + len = 1; + goto print_len_set; + } else { /* string */ + p = va_arg(ap, char *); + if (!p) { + p = "(null)"; + preci = 6; + } else { + if (preci < 0) { + preci = INT_MAX; + } + } + len = strnlen(p, preci); + goto print_len_set; + } +#if defined(__UCLIBC_HAS_FLOATS__) || WANT_FLOAT_ERROR + } else if (p-u_spec < 27) { /* floating point */ +#endif /* defined(__UCLIBC_HAS_FLOATS__) || WANT_FLOAT_ERROR */ +#if defined(__UCLIBC_HAS_FLOATS__) + struct printf_info info; + if (preci < 0) { + preci = 6; + } + info.width = width; + info.prec = preci; + info.spec = *fmt; + info.pad = flag[FLAG_0_PAD]; + info._flags = 0; + if (flag[FLAG_PLUS] == '+') { + PRINT_INFO_SET_FLAG(&info,showsign); + } else if (flag[FLAG_PLUS] == ' ') { + PRINT_INFO_SET_FLAG(&info,space); + } + if (flag[FLAG_HASH]) { + PRINT_INFO_SET_FLAG(&info,alt); + } + if (flag[FLAG_MINUS_LJUSTIFY]) { + PRINT_INFO_SET_FLAG(&info,left); + } + cnt += _dtostr(op, + ((lval > 1) + ? va_arg(ap, long double) + : (long double) va_arg(ap, double)), + &info); + goto nextfmt; +#elif WANT_FLOAT_ERROR + (void) ((lval > 1) ? va_arg(ap, long double) + : va_arg(ap, double)); /* carry on */ + p = (char *) dbl_err; +#endif /* defined(__UCLIBC_HAS_FLOATS__) */ + } + +#if WANT_GNU_ERRNO + print: +#endif + { /* this used to be printfield */ + /* cheaper than strlen call */ +/* for ( len = 0 ; p[len] ; len++ ) { } */ + len = strnlen(p, SIZE_MAX); + print_len_set: + if ((*p == '-') +#if WANT_GNU_ERRNO + && (*fmt != 'm') +#endif + && (*fmt != 's')) { + flag[FLAG_PLUS] = *p++; + --len; + } + if (flag[FLAG_PLUS]) { + ++len; + ++preci; + if (flag[FLAG_PLUS] == '0') { /* base 16 */ + ++preci; /* account for x or X */ + } + } + + if (preci >= 0) { + if ((*fmt == 's') +#if WANT_GNU_ERRNO + || (*fmt == 'm') +#endif + ) { + if (len > preci) { + len = preci; + } else { + preci = len; + } + } + preci -= len; + if (preci < 0) { + preci = 0; + } + width -= preci; + } + + width -= len; + if (width < 0) { + width = 0; + } + + if (preci < 0) { + preci = 0; + if (!flag[FLAG_MINUS_LJUSTIFY] + /* && flag[FLAG_PLUS] */ + && (flag[FLAG_0_PAD] == '0')) { + preci = width; + width = 0; + } + } + + while (width + len + preci) { + unsigned char ch; + /* right padding || left padding */ + if ((!len && !preci) + || (width && !flag[FLAG_MINUS_LJUSTIFY])) { + ch = ' '; + --width; + } else if (flag[FLAG_PLUS]) { + ch = flag[FLAG_PLUS]; /* sign */ + if (flag[FLAG_PLUS]=='0') { /* base 16 case */ + flag[FLAG_PLUS] = *p++; /* get the x|X */ + } else { + flag[FLAG_PLUS] = '\0'; + } + --len; + } else if (preci) { + ch = '0'; + --preci; + } else { + ch = *p++; /* main field */ + --len; + } + ++cnt; + putc(ch, op); + } + } + goto nextfmt; + } + + fmt = fmt0; /* this was an illegal format */ + } + + charout: + ++cnt; + putc(*fmt, op); /* normal char out */ + + nextfmt: + ++fmt; + } + + i = (__FERROR(op)) ? -1 : cnt; + + __STDIO_THREADLOCK(op); + + return i; +} diff --git a/libc/stdio/perror.c b/libc/stdio/perror.c deleted file mode 100644 index 33b5e08b0..000000000 --- a/libc/stdio/perror.c +++ /dev/null @@ -1,27 +0,0 @@ -#include -#include -#include - -/* - * Manuel Novoa III Feb 2001 - * - * Replaced old version that did write(2,...)'s with a version using - * stream functions. 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. - * Also, the old version did not conform the standards when the - * passed char * was either NULL or pointed to an empty string. - */ - -void perror(__const char *str) -{ - static const char perror_str[] = ": "; - const char *sep; - - sep = perror_str; - if (!(str && *str)) { /* Caller did not supply a prefix message */ - sep += 2; /* or passed an empty string. */ - str = sep; - } - fprintf(stderr, "%s%s%s\n", str, sep, strerror(errno)); -} diff --git a/libc/stdio/printf.c b/libc/stdio/printf.c deleted file mode 100644 index 2940e44be..000000000 --- a/libc/stdio/printf.c +++ /dev/null @@ -1,713 +0,0 @@ -/* - * This file based on printf.c from 'Dlibs' on the atari ST (RdeBath) - * - * - * Dale Schumacher 399 Beacon Ave. - * (alias: Dalnefre') St. Paul, MN 55104 - * dal@syntel.UUCP United States of America - * "It's not reality that's important, but how you perceive things." - */ - -/* Altered to use stdarg, made the core function vfnprintf. - * Hooked into the stdio package using 'inside information' - * Altered sizeof() assumptions, now assumes all integers except chars - * will be either - * sizeof(xxx) == sizeof(long) or sizeof(xxx) == sizeof(short) - * - * -RDB - */ - -/* - * Manuel Novoa III Dec 2000 - * - * The previous vfnprintf routine was almost completely rewritten with the - * goal of fixing some shortcomings and reducing object size. - * - * The summary of changes: - * - * Converted print conversion specification parsing from one big switch - * to a method using string tables. This new method verifies that the - * conversion flags, field width, precision, qualifier, and specifier - * appear in the correct order. Many questionable specifications were - * accepted by the previous code. This new method also resulted in a - * substantial reduction in object size of about 330 bytes (20%) from - * the old version (1627 bytes) on i386, even with the following - * improvements. - * - * Implemented %n specifier as required by the standards. - * Implemented proper handling of precision for int types. - * Implemented # for hex and pointer, fixed error for octal rep of 0. - * Implemented return of -1 on stream error. - * - * Added optional support for the GNU extension %m which prints the string - * corresponding the errno. - * - * Added optional support for long long ints and unsigned long long ints - * using the conversion qualifiers "ll", "L", or "q" (like glibc). - * - * Added optional support for doubles in a very limited form. None of - * the formating options are obeyed. The string returned by __dtostr - * is printed directly. - * - * Converted to use my (un)signed long (long) to string routines, which are - * smaller than the previous functions and don't require static buffers. - * - * Other Modifications: - * Modified sprintf, snprintf, vsprintf, vsnprintf to share on fake-file. - */ - -/* - * Manuel Novoa III Jan 2001 - * - * Removed fake file from *s*printf functions because of possible problems - * if called recursively. Instead, have sprintf, snprintf, and vsprintf - * call vsnprintf which allocates a fake file on the stack. - * Removed WANT_FPUTC option. Always use standard putc macro to avoid - * problems with the fake file used by the *s*printf functions. - * Fixed bug parsing flags -- did not restart scan. - * Added function asprintf. - * Fixed 0-pad prefixing bug. - * Converted sizeof(int) == sizeof(long) tests to compile time vs run time. - * This saves 112 bytes of code on i386. - * Fixed precision bug -- when negative set to default. - * Added function fnprintf to support __dtostr. - * Added floating point support for doubles. Yeah! - * - * - * May 2001 Fixes from Johan Adolfsson (johan.adolfsson@axis.com) - * 1) printf("%c",0) returned 0 instead of 1. - * 2) unrolled loop in asprintf to reduce size and remove compile warning. - * - * - * June 2001 - * 1) fix %p so that "0x" is prepended to outputed hex val - * 2) fix %p so that "(nil)" is output for (void *)0 to match glibc - * - */ - -/*****************************************************************************/ -/* OPTIONS */ -/*****************************************************************************/ -/* The optional support for long longs and doubles comes in two forms. - * - * 1) Normal (or partial for doubles) output support. Set to 1 to turn on. - * Adds about 130 bytes for doubles, about 220 bytes for long longs, - * and about 275 for both to the base code size of 1163 on i386. - */ - -/* These are now set in uClibc_config.h based on Config. */ -/* -#define __UCLIBC_HAS_LONG_LONG__ 1 -#define __UCLIBC_HAS_FLOATS__ 1 -*/ - -/* 2) An error message is inserted into the stream, an arg of the - * appropriate size is removed from the arglist, and processing - * continues. This is adds less code and may be useful in some - * cases. Set to 1 to turn on. Adds about 50 bytes for doubles, - * about 140 bytes for long longs, and about 175 bytes for both - * to the base code size of 1163 on i386. - */ - -#define WANT_LONG_LONG_ERROR 0 -#define WANT_FLOAT_ERROR 0 - -/* - * Set to support GNU extension of %m to print string corresponding to errno. - * - * Warning: This adds about 50 bytes (i386) to the code but it also pulls in - * strerror and the corresponding string table which together are about 3.8k. - */ - -#define WANT_GNU_ERRNO 0 - -/**************************************************************************/ - -#include -#include -#include -#include -#include -#include - -#if WANT_GNU_ERRNO -#include -#endif - -#ifdef __STDC__ -#include -#define va_strt va_start -#else -#include -#define va_strt(p,i) va_start(p) -#endif - -#include "stdio.h" - -extern int vfnprintf(FILE * op, size_t max_size, - register __const char *fmt, register va_list ap); - -#ifdef L_printf -int printf(const char *fmt, ...) -{ - va_list ptr; - int rv; - - va_strt(ptr, fmt); - rv = vfnprintf(stdout, -1, fmt, ptr); - va_end(ptr); - return rv; -} -#endif - -#ifdef L_asprintf -int asprintf(char **app, const char *fmt, ...) -{ - va_list ptr; - int rv; - char *p; - - /* - * First iteration - find out size of buffer required and allocate it. - */ - va_strt(ptr, fmt); - rv = vsnprintf(NULL, 0, fmt, ptr); - va_end(ptr); - - p = malloc(++rv); /* allocate the buffer */ - *app = p; - if (!p) { - return -1; - } - - /* - * Second iteration - actually produce output. - */ - va_strt(ptr, fmt); - rv = vsnprintf(p, rv, fmt, ptr); - va_end(ptr); - - return rv; -} -#endif - -#ifdef L_sprintf -int sprintf(char *sp, const char *fmt, ...) -{ - va_list ptr; - int rv; - - va_strt(ptr, fmt); - rv = vsnprintf(sp, -1, fmt, ptr); - va_end(ptr); - return rv; -} -#endif - - -#ifdef L_snprintf -int snprintf(char *sp, size_t size, const char *fmt, ...) -{ - va_list ptr; - int rv; - - va_strt(ptr, fmt); - rv = vsnprintf(sp, size, fmt, ptr); - va_end(ptr); - return rv; -} -#endif - -#ifdef L_fprintf -int fprintf(FILE * fp, const char *fmt, ...) -{ - va_list ptr; - int rv; - - va_strt(ptr, fmt); - rv = vfnprintf(fp, -1, fmt, ptr); - va_end(ptr); - return rv; -} -#endif - -#ifdef L_fnprintf -int fnprintf(FILE * fp, size_t size, const char *fmt, ...) -{ - va_list ptr; - int rv; - - va_strt(ptr, fmt); - rv = vfnprintf(fp, size, fmt, ptr); - va_end(ptr); - return rv; -} -#endif - -#ifdef L_vprintf -int vprintf(const char *fmt, va_list ap) -{ - return vfprintf(stdout, fmt, ap); -} -#endif - -#ifdef L_vfprintf - -int vfprintf(FILE * op, register __const char *fmt, register va_list ap) -{ - return vfnprintf(op, -1, fmt, ap); -} - -#endif - -#ifdef L_vsprintf -int vsprintf(char *sp, __const char *fmt, va_list ap) -{ - return vsnprintf(sp, -1, fmt, ap); -} -#endif - -#ifdef L_vsnprintf -int vsnprintf(char *sp, size_t size, __const char *fmt, va_list ap) -{ - int rv; - FILE f; - - /* - * As we're only using the putc macro in vfnprintf, we don't need to - * initialize all FILE f's fields. - */ - f.bufwrite = (char *) ((unsigned) -1); - f.bufpos = sp; - f.mode = _IOFBF; - - rv = vfnprintf(&f, size, fmt, ap); - if (size) { /* If this is going to a buffer, */ - *(f.bufpos) = 0; /* don't forget to nul-terminate. */ - } - return rv; -} -#endif - -#ifdef L_vdprintf -/* - * Note: If fd has an associated buffered FILE, bad things happen. - */ -extern int vdprintf(int fd, const char *fmt, va_list ap) -{ - char buf[BUFSIZ]; - FILE f = {buf, 0, buf+sizeof(buf), buf, buf+sizeof(buf), 0, fd, _IOFBF}; - int rv; - - rv = vfnprintf(&f, -1, fmt, ap); - - if (fflush(&f)) { - return -1; - } - - return rv; -} -#endif - -#ifdef L_vfnprintf - -extern char *__ultostr(char *buf, unsigned long uval, int base, int uppercase); -extern char *__ltostr(char *buf, long val, int base, int uppercase); -extern char *__ulltostr(char *buf, unsigned long long uval, int base, int uppercase); -extern char *__lltostr(char *buf, long long val, int base, int uppercase); -extern int __dtostr(FILE * fp, size_t size, long double x, - char flag[], int width, int preci, char mode); - -enum { - FLAG_PLUS = 0, - FLAG_MINUS_LJUSTIFY, - FLAG_HASH, - FLAG_0_PAD, - FLAG_SPACE, -}; - -/* layout 01234 */ -static const char spec[] = "+-#0 "; - -#if defined(__UCLIBC_HAS_LONG_LONG__) || WANT_LONG_LONG_ERROR -static const char qual[] = "hlLq"; -#else -static const char qual[] = "hl"; -#endif - -#if !defined(__UCLIBC_HAS_LONG_LONG__) && WANT_LONG_LONG_ERROR -static const char ll_err[] = ""; -#endif - -#if !defined(__UCLIBC_HAS_FLOATS__) && WANT_FLOAT_ERROR -static const char dbl_err[] = ""; -#endif - -#if defined(__UCLIBC_HAS_FLOATS__) || WANT_FLOAT_ERROR -/* layout 012345678901234567 */ -static const char u_spec[] = "%nbopxXudicsfgGeEaA"; -#else -/* layout 0123456789012 */ -static const char u_spec[] = "%nbopxXudics"; -#endif - -/* WARNING: u_spec and u_radix need to stay in agreement!!! */ -/* u_radix[i] <-> u_spec[i+2] for unsigned entries only */ -static const char u_radix[] = "\x02\x08\x10\x10\x10\x0a"; - -int vfnprintf(FILE * op, size_t max_size, const char *fmt, va_list ap) -{ - int i, cnt, lval, len; - char *p; - const char *fmt0; - int buffer_mode; - int preci, width; -#define upcase i - int radix, dpoint /*, upcase*/; -#if defined(__UCLIBC_HAS_LONG_LONG__) - char tmp[65]; -#else - char tmp[33]; -#endif - char flag[sizeof(spec)]; - - cnt = 0; - - /* This speeds things up a bit for line unbuffered */ - buffer_mode = (op->mode & __MODE_BUF); - op->mode &= (~__MODE_BUF); - - while (*fmt) { - if (*fmt == '%') { - fmt0 = fmt; /* save our position in case of bad format */ - ++fmt; - width = -1; /* min field width */ - preci = -5; /* max string width or mininum digits */ - radix = 10; /* number base */ - dpoint = 0; /* found decimal point */ -#if INT_MAX != LONG_MAX - lval = 0; /* sizeof(int) != sizeof(long) */ -#else - lval = 1; /* sizeof(int) == sizeof(long) */ -#endif - - tmp[1] = 0; /* set things up for %c -- better done here */ - - /* init flags */ - for (p =(char *) spec ; *p ; p++) { - flag[p-spec] = '\0'; - } - flag[FLAG_0_PAD] = ' '; - - /* process optional flags */ - for (p = (char *)spec ; *p ; ) { - if (*fmt == *p) { - flag[p-spec] = *fmt++; - p = (char *)spec; /* restart scan */ - } else { - p++; - } - } - - if (!flag[FLAG_PLUS]) { - flag[FLAG_PLUS] = flag[FLAG_SPACE]; - } - - /* process optional width and precision */ - do { - if (*fmt == '.') { - ++fmt; - dpoint = 1; - } - if (*fmt == '*') { /* parameter width value */ - ++fmt; - i = va_arg(ap, int); - } else { - for ( i = 0 ; (*fmt >= '0') && (*fmt <= '9') ; ++fmt ) { - i = (i * 10) + (*fmt - '0'); - } - } - - if (dpoint) { - preci = i; - if (i<0) { - preci = -5; - } - } else { - width = i; - if (i<0) { - width = -i; - flag[FLAG_MINUS_LJUSTIFY] = 1; - } - } - } while ((*fmt == '.') && !dpoint ); - - /* process optional qualifier */ - for (p = (char *) qual ; *p ; p++) { - if (*p == *fmt) { - lval = p - qual; - ++fmt; -#if defined(__UCLIBC_HAS_LONG_LONG__) || WANT_LONG_LONG_ERROR - if ((*p == 'l') && (*fmt == *p)) { - ++lval; - ++fmt; - } -#endif /* defined(__UCLIBC_HAS_LONG_LONG__) || WANT_LONG_LONG_ERROR */ - } - } - -#if WANT_GNU_ERRNO - if (*fmt == 'm') { - flag[FLAG_PLUS] = '\0'; - flag[FLAG_0_PAD] = ' '; - p = strerror(errno); - goto print; - } -#endif - - /* process format specifier */ - for (p = (char *) u_spec ; *p ; p++) { - if (*fmt != *p) continue; - if (p-u_spec < 1) { /* print a % */ - goto charout; - } - if (p-u_spec < 2) { /* store output count in int ptr */ - *(va_arg(ap, int *)) = cnt; - goto nextfmt; - } - if (p-u_spec < 8) { /* unsigned conversion */ - radix = u_radix[p-u_spec-2]; - upcase = ((int)'x') - *p; - if (*p == 'p') { - lval = (sizeof(char *) == sizeof(long)); - upcase = 0; - flag[FLAG_HASH] = 'p'; - } -#if defined(__UCLIBC_HAS_LONG_LONG__) || WANT_LONG_LONG_ERROR - if (lval >= 2) { -#if defined(__UCLIBC_HAS_LONG_LONG__) - p = __ulltostr(tmp + sizeof(tmp) - 1, - va_arg(ap, unsigned long long), - radix, upcase); -#else - (void) va_arg(ap, unsigned long long); /* cary on */ - p = (char *) ll_err; -#endif /* defined(__UCLIBC_HAS_LONG_LONG__) */ - } else { -#endif /* defined(__UCLIBC_HAS_LONG_LONG__) || WANT_LONG_LONG_ERROR */ -#if UINT_MAX != ULONG_MAX - /* sizeof(unsigned int) != sizeof(unsigned long) */ - p = __ultostr(tmp + sizeof(tmp) - 1, (unsigned long) - ((lval) - ? va_arg(ap, unsigned long) - : va_arg(ap, unsigned int)), - radix, upcase); -#else - /* sizeof(unsigned int) == sizeof(unsigned long) */ - p = __ultostr(tmp + sizeof(tmp) - 1, (unsigned long) - va_arg(ap, unsigned long), - radix, upcase); -#endif -#if defined(__UCLIBC_HAS_LONG_LONG__) || WANT_LONG_LONG_ERROR - } -#endif /* defined(__UCLIBC_HAS_LONG_LONG__) || WANT_LONG_LONG_ERROR */ - flag[FLAG_PLUS] = '\0'; /* meaningless for unsigned */ - if (*p != '0') { /* non-zero */ - if (flag[FLAG_HASH]) { - if (radix == 8) { - *--p = '0'; /* add leadding zero */ - } else if (radix != 10) { /* either 2 or 16 */ - flag[FLAG_PLUS] = '0'; - *--p = 'b'; - if (radix == 16) { - *p = 'x'; - if (*fmt == 'X') { - *p = 'X'; - } - } - } - } - } else if (flag[FLAG_HASH] == 'p') { /* null pointer */ - p = "(nil)"; - } - } else if (p-u_spec < 10) { /* signed conversion */ -#if defined(__UCLIBC_HAS_LONG_LONG__) || WANT_LONG_LONG_ERROR - if (lval >= 2) { -#if defined(__UCLIBC_HAS_LONG_LONG__) - p = __lltostr(tmp + sizeof(tmp) - 1, - va_arg(ap, long long), 10, 0); -#else - (void) va_arg(ap, long long); /* carry on */ - p = (char *) ll_err; -#endif /* defined(__UCLIBC_HAS_LONG_LONG__) */ - } else { -#endif /* defined(__UCLIBC_HAS_LONG_LONG__) || WANT_LONG_LONG_ERROR */ -#if INT_MAX != LONG_MAX - /* sizeof(int) != sizeof(long) */ - p = __ltostr(tmp + sizeof(tmp) - 1, (long) - ((lval) - ? va_arg(ap, long) - : va_arg(ap, int)), 10, 0); -#else - /* sizeof(int) == sizeof(long) */ - p = __ltostr(tmp + sizeof(tmp) - 1, (long) - va_arg(ap, long), 10, 0); -#endif -#if defined(__UCLIBC_HAS_LONG_LONG__) || WANT_LONG_LONG_ERROR - } -#endif /* defined(__UCLIBC_HAS_LONG_LONG__) || WANT_LONG_LONG_ERROR */ - } else if (p-u_spec < 12) { /* character or string */ - flag[FLAG_PLUS] = '\0'; - flag[FLAG_0_PAD] = ' '; - if (*p == 'c') { /* character */ - p = tmp; - *p = va_arg(ap, int); - /* This takes care of the "%c",0 case */ - len = 1; - goto print_len_set; - } else { /* string */ - p = va_arg(ap, char *); - if (!p) { - p = "(null)"; - } - } -#if defined(__UCLIBC_HAS_FLOATS__) || WANT_FLOAT_ERROR - } else if (p-u_spec < 27) { /* floating point */ -#endif /* defined(__UCLIBC_HAS_FLOATS__) || WANT_FLOAT_ERROR */ -#if defined(__UCLIBC_HAS_FLOATS__) - if (preci < 0) { - preci = 6; - } - cnt += __dtostr(op, - (max_size > cnt ? max_size - cnt : 0), - (long double) ((lval > 1) - ? va_arg(ap, long double) - : va_arg(ap, double)), - flag, width, preci, *fmt); - goto nextfmt; -#elif WANT_FLOAT_ERROR - (void) ((lval > 1) ? va_arg(ap, long double) - : va_arg(ap, double)); /* carry on */ - p = (char *) dbl_err; -#endif /* defined(__UCLIBC_HAS_FLOATS__) */ - } - -#if WANT_GNU_ERRNO - print: -#endif - { /* this used to be printfield */ - /* cheaper than strlen call */ - for ( len = 0 ; p[len] ; len++ ) { } - print_len_set: - if ((*p == '-') -#if WANT_GNU_ERRNO - && (*fmt != 'm') -#endif - && (*fmt != 's')) { - flag[FLAG_PLUS] = *p++; - --len; - } - if (flag[FLAG_PLUS]) { - ++len; - ++preci; - if (flag[FLAG_PLUS] == '0') { /* base 16 */ - ++preci; /* account for x or X */ - } - } - - if (preci >= 0) { - if ((*fmt == 's') -#if WANT_GNU_ERRNO - || (*fmt == 'm') -#endif - ) { - if (len > preci) { - len = preci; - } else { - preci = len; - } - } - preci -= len; - if (preci < 0) { - preci = 0; - } - width -= preci; - } - - width -= len; - if (width < 0) { - width = 0; - } - - if (preci < 0) { - preci = 0; - if (!flag[FLAG_MINUS_LJUSTIFY] - /* && flag[FLAG_PLUS] */ - && (flag[FLAG_0_PAD] == '0')) { - preci = width; - width = 0; - } - } - - while (width + len + preci) { - unsigned char ch; - /* right padding || left padding */ - if ((!len && !preci) - || (width && !flag[FLAG_MINUS_LJUSTIFY])) { - ch = ' '; - --width; - } else if (flag[FLAG_PLUS]) { - ch = flag[FLAG_PLUS]; /* sign */ - if (flag[FLAG_PLUS]=='0') { /* base 16 case */ - flag[FLAG_PLUS] = *p++; /* get the x|X */ - } else { - flag[FLAG_PLUS] = '\0'; - } - --len; - } else if (preci) { - ch = '0'; - --preci; - } else { - ch = *p++; /* main field */ - --len; - } - - if (++cnt < max_size) { - putc(ch, op); - } - if ((ch == '\n') && (buffer_mode == _IOLBF)) { - fflush(op); - } - } - } - goto nextfmt; - } - - fmt = fmt0; /* this was an illegal format */ - } - - charout: - if (++cnt < max_size) { - putc(*fmt, op); /* normal char out */ - } - if ((*fmt == '\n') && (buffer_mode == _IOLBF)) { - fflush(op); - } - - nextfmt: - ++fmt; - } - - op->mode |= buffer_mode; - if (buffer_mode == _IOLBF) { - op->bufwrite = op->bufpos; - } - - if (ferror(op)) { - cnt = -1; - } - return (cnt); -} - -#endif - diff --git a/libc/stdio/putw.c b/libc/stdio/putw.c deleted file mode 100644 index d1b68ab27..000000000 --- a/libc/stdio/putw.c +++ /dev/null @@ -1,34 +0,0 @@ -/* Copyright (C) 1991, 1997, 1998 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C 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 - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library; if not, write to the Free - Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA - 02111-1307 USA. */ - -#include - -#ifdef USE_IN_LIBIO -# include -# define fwrite(p, n, m, s) _IO_fwrite (p, n, m, s) -#endif - -/* Write the word (int) W to STREAM. */ -int -putw (int w, FILE *stream) -{ - /* Is there a better way? */ - if (fwrite ((const void *) &w, sizeof (w), 1, stream) < 1) - return EOF; - return 0; -} diff --git a/libc/stdio/remove.c b/libc/stdio/remove.c deleted file mode 100644 index af256e4aa..000000000 --- a/libc/stdio/remove.c +++ /dev/null @@ -1,23 +0,0 @@ -/* Copyright (C) 1995,1996 Robert de Bath - * This file is part of the Linux-8086 C library and is distributed - * under the GNU Library General Public License. - */ -#include -#include -#include -#include - -int remove(src) -__const char *src; -{ - extern int errno; - int er = errno; - int rv = unlink(src); - - if (rv < 0 && errno == EISDIR) - rv = rmdir(src); - if (rv >= 0) - __set_errno(er); - return rv; -} - diff --git a/libc/stdio/scanf.c b/libc/stdio/scanf.c index c8b487ed1..fc70b9244 100644 --- a/libc/stdio/scanf.c +++ b/libc/stdio/scanf.c @@ -31,14 +31,24 @@ * implementation doesn't for the "100ergs" case mentioned above. */ -#include -#include +#define _GNU_SOURCE +#include +#if defined(__UCLIBC__) && !defined(__USE_ISOC99) #define __USE_ISOC99 +#endif + +#define _STDIO_UTILITY #include +#include +#include #include #include #include +#ifdef __STDIO_THREADSAFE +#include +#endif /* __STDIO_THREADSAFE */ + #ifdef L_scanf #ifdef __STDC__ int scanf(const char *fmt, ...) @@ -59,29 +69,22 @@ va_dcl #endif #ifdef L_sscanf -#ifdef __STDC__ -int sscanf(const char *sp, const char *fmt, ...) +#if !defined(__STDIO_BUFFERS) && !defined(__STDIO_GLIBC_CUSTOM_STREAMS) +#warning skipping sscanf since no buffering and no custom streams! #else -int sscanf(sp, fmt, va_alist) -__const char *sp; -__const char *fmt; -va_dcl -#endif -{ - FILE string[1] = { - {0, (unsigned char *) ((unsigned) -1), 0, 0, (char *) ((unsigned) -1), - 0, -1, _IOFBF} - }; +int sscanf(const char *sp, const char *fmt, ...) +{ va_list ptr; int rv; - string->bufpos = (unsigned char *) ((void *) sp); va_start(ptr, fmt); - rv = vfscanf(string, fmt, ptr); + rv = vsscanf(sp, fmt, ptr); va_end(ptr); return rv; } + +#endif #endif #ifdef L_fscanf @@ -114,16 +117,37 @@ va_list ap; #endif #ifdef L_vsscanf +#ifdef __STDIO_BUFFERS int vsscanf(__const char *sp, __const char *fmt, va_list ap) { - FILE string[1] = { - {0, (unsigned char *) ((unsigned) -1), 0, 0, (char *) ((unsigned) -1), - 0, -1, _IOFBF} - }; + FILE string[1]; + + string->filedes = -2; /* for debugging */ + string->modeflags = (__FLAG_NARROW|__FLAG_READONLY); + string->bufstart = string->bufrpos = (unsigned char *) ((void *) sp); + string->bufgetc = (char *) ((unsigned) -1); - string->bufpos = (unsigned char *) sp; return vfscanf(string, fmt, ap); } +#else /* __STDIO_BUFFERS */ +#ifdef __STDIO_GLIBC_CUSTOM_STREAMS +int vsscanf(__const char *sp, __const char *fmt, va_list ap) +{ + FILE *f; + int rv; + + if ((f = fmemopen((char *)sp, strlen(sp), "r")) == NULL) { + return -1; + } + rv = vfscanf(f, fmt, ap); + fclose(f); + + return rv; +} +#else /* __STDIO_GLIBC_CUSTOM_STREAMS */ +#warning skipping vsscanf since no buffering and no custom streams! +#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */ +#endif /* __STDIO_BUFFERS */ #endif #ifdef L_vfscanf @@ -154,6 +178,7 @@ struct scan_cookie { int width_flag; int ungot_char; int ungot_flag; + int app_ungot; }; #ifdef __UCLIBC_HAS_LONG_LONG__ @@ -181,8 +206,11 @@ static void init_scan_cookie(struct scan_cookie *sc, FILE *fp) sc->nread = 0; sc->width_flag = 0; sc->ungot_flag = 0; + sc->app_ungot = ((fp->modeflags & __MASK_UNGOT) ? fp->ungot[1] : 0); } +/* TODO -- what about literal '\0' chars in a file??? */ + static int scan_getc_nw(struct scan_cookie *sc) { if (sc->ungot_flag == 0) { @@ -233,6 +261,10 @@ static void kill_scan_cookie(struct scan_cookie *sc) { if (sc->ungot_flag) { ungetc(sc->ungot_char,sc->fp); + /* Deal with distiction between user and scanf ungots. */ + if (sc->nread == 0) { /* Only one char was read... app ungot? */ + sc->fp->ungot[1] = sc->app_ungot; /* restore ungot state. */ + } } } @@ -267,6 +299,8 @@ va_list ap; unsigned char buf[MAX_DIGITS+2]; unsigned char scanset[UCHAR_MAX + 1]; + __STDIO_THREADLOCK(fp); + init_scan_cookie(&sc,fp); fmt = (unsigned const char *) format; @@ -547,7 +581,7 @@ va_list ap; goto done; } /* Unrecognized specifier! */ - goto done; + goto RETURN_cnt; } if (isspace(*fmt)) { /* Consume all whitespace. */ while (isspace(scan_getc_nw(&sc))) {} @@ -567,9 +601,12 @@ va_list ap; kill_scan_cookie(&sc); if ((sc.ungot_char <= 0) && (cnt == 0) && (*fmt)) { - return (EOF); + cnt = EOF; } + RETURN_cnt: + __STDIO_THREADUNLOCK(fp); + return (cnt); } diff --git a/libc/stdio/stdio.c b/libc/stdio/stdio.c deleted file mode 100644 index 4a0dc8188..000000000 --- a/libc/stdio/stdio.c +++ /dev/null @@ -1,1117 +0,0 @@ -/* Copyright (C) 1996 Robert de Bath - * This file is part of the Linux-8086 C library and is distributed - * under the GNU Library General Public License. - */ - -/* This is an implementation of the C standard IO package. - * - * Updates: - * 29-Sep-2000 W. Greathouse 1. fgetc copying beyond end of buffer - * 2. stdout needs flushed when input requested on - * stdin. - * 3. bufend was set incorrectly to 4 bytes beyond - * bufin (sizeof a pointer) instead of BUFSIZ. - * This resulted in 4 byte buffers for full - * buffered stdin and stdout and an 8 byte - * buffer for the unbuffered stderr! - */ - -/* - * Feb 27, 2001 Manuel Novoa III - * - * Most of the core functionality has been completely rewritten. - * A number of functions have been added as well, as mandated by C89. - * - * An extension function "fsfopen" has been added: - * Open a file using an automatically (stack) or statically allocated FILE. - * The FILE * returned behaves just as any other FILE * with respect to the - * stdio functions, but be aware of the following: - * NOTE: The buffer used for the file is FILE's builtin 2-byte buffer, so - * setting a new buffer is probably advisable. - * NOTE: This function is primarily intended to be used for stack-allocated - * FILEs when uClibc stdio has no dynamic memory support. - * For the statically allocated case, it is probably better to increase - * the value of FIXED_STREAMS in stdio.c. - * WARNING: If allocated on the stack, make sure you call fclose before the - * stack memory is reclaimed! - */ - - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -extern off_t _uClibc_fwrite(const unsigned char *buf, off_t bytes, FILE *fp); -extern off_t _uClibc_fread(unsigned char *buf, off_t bytes, FILE *fp); - -/* Used internally to actually open files */ -extern FILE *__fopen __P((__const char *__restrict __filename, int __fd, - FILE *__restrict __stream, __const char *__restrict __mode, - int extra_modes)); - -/* Note: This def of READING is ok since 1st ungetc puts in buf. */ -#define READING(fp) (fp->bufstart < fp->bufread) -#define WRITING(fp) (fp->bufwrite > fp->bufstart) - -#define READABLE(fp) (fp->bufread != 0) -#define WRITEABLE(fp) (fp->bufwrite != 0) -#define EOF_OR_ERROR(fp) (fp->mode & (__MODE_EOF | __MODE_ERR)) - -/***********************************************************************/ -/* BUILD TIME OPTIONS */ -/***********************************************************************/ -/* - * FIXED_STREAMS must be >= 3 and FIXED_BUFFERS must be >= 2. - * As a feature, these can be increased, although this is probably - * only useful if DISABLE_DYNAMIC is set to 1 below. - */ - -#define FIXED_STREAMS 3 -#define FIXED_BUFFERS 2 - -/* - * As a feature, you can build uClibc with no dynamic allocation done - * by the stdio package. Just set DISABLE_DYNAMIC to nonzero. Note that - * use of asprintf, getdelim, or getline will pull malloc into the link. - * - * Note: You can't trust FOPEN_MAX if DISABLE_DYNAMIC != 0. - */ -#define DISABLE_DYNAMIC 0 - -/* - * As a feature, you can try to allow setvbuf calls after file operations. - * Setting FLEXIBLE_SETVBUF to nonzero will cause setvbuf to try to fflush - * any buffered writes or sync the file position for buffered reads. If it - * is successful, the buffer change can then take place. - */ -#define FLEXIBLE_SETVBUF 0 -/***********************************************************************/ - -#if DISABLE_DYNAMIC != 0 -#undef malloc -#undef free -#define malloc(x) 0 -#define free(x) -#endif - -extern FILE *__IO_list; /* For fflush. */ -extern FILE *_free_file_list; -extern char _free_buffer_index; -extern FILE _stdio_streams[FIXED_STREAMS]; -extern unsigned char _fixed_buffers[FIXED_BUFFERS * BUFSIZ]; - -extern unsigned char *_alloc_stdio_buffer(size_t size); -extern void _free_stdio_buffer_of_file(FILE *fp); -extern void _free_stdio_stream(FILE *fp); - -#ifdef L__alloc_stdio_buffer -unsigned char *_alloc_stdio_buffer(size_t size) -{ - unsigned char *buf; - - if ((size == BUFSIZ) && (_free_buffer_index < FIXED_BUFFERS)) { - buf = _fixed_buffers + ((unsigned int)_free_buffer_index) * BUFSIZ; - _free_buffer_index = *buf; - return buf; - } - return malloc(size); -} -#endif - -#ifdef L__free_stdio_buffer_of_file -void _free_stdio_buffer_of_file(FILE *fp) -{ - unsigned char *buf; - - if (!(fp->mode & __MODE_FREEBUF)) { - return; - } - fp->mode &= ~(__MODE_FREEBUF); - buf = fp->bufstart; - - if ((buf >= _fixed_buffers) - && (buf < _fixed_buffers + (FIXED_BUFFERS * BUFSIZ))) { - *buf = _free_buffer_index; - _free_buffer_index = (buf - _fixed_buffers)/BUFSIZ; - return; - } - free(buf); -} -#endif - -#ifdef L__stdio_init - -#if FIXED_BUFFERS < 2 -#error FIXED_BUFFERS must be >= 2 -#endif - -#if FIXED_BUFFERS >= UCHAR_MAX -#error FIXED_BUFFERS must be < UCHAR_MAX -#endif - -#define bufin (_fixed_buffers) -#define bufout (_fixed_buffers + BUFSIZ) -#define buferr (_stdio_streams[2].unbuf) /* Stderr is unbuffered */ - -unsigned char _fixed_buffers[FIXED_BUFFERS * BUFSIZ]; - -#if FIXED_STREAMS < 3 -#error FIXED_STREAMS must be >= 3 -#endif - -FILE _stdio_streams[FIXED_STREAMS] = { - {bufin, bufin, 0, bufin, bufin + BUFSIZ, - _stdio_streams + 1, - 0, _IOFBF | __MODE_FREEFIL | __MODE_FREEBUF | __MODE_TIED }, - {bufout, 0, bufout, bufout, bufout + BUFSIZ, - _stdio_streams + 2, - 1, _IOFBF | __MODE_FREEFIL | __MODE_FREEBUF | __MODE_TIED }, - {buferr, 0, buferr, buferr, buferr + 1, - NULL, - 2, _IONBF | __MODE_FREEFIL } -}; - -FILE *stdin = _stdio_streams + 0; -FILE *stdout = _stdio_streams + 1; -FILE *stderr = _stdio_streams + 2; - -/* - * Note: the following forces linking of the __init_stdio function if - * any of the stdio functions are used since they all call fflush directly - * or indirectly. - */ -FILE *__IO_list = _stdio_streams; /* For fflush. */ - -FILE *_free_file_list = 0; -char _free_buffer_index = FIXED_BUFFERS; - -/* - * __stdio_flush_buffers is automatically when exiting if stdio is used. - * See misc/internals/__uClibc_main.c and and stdlib/atexit.c. - */ -void __stdio_flush_buffers(void) -{ - FILE *fp; - for (fp = __IO_list; fp; fp = fp->next) { - if (WRITEABLE(fp)) { - /* Set the underlying fd to non-block mode to ensure - * that calls to _exit() and abort() will not block */ - int opts; - opts = fcntl(fp->fd, F_GETFL); - fcntl(fp->fd, F_SETFL, opts|O_NONBLOCK); - fflush(fp); - fcntl(fp->fd, F_SETFL, opts); - } - } -} - -/* - * __init_stdio is automatically by __uClibc_main if stdio is used. - */ -void __init_stdio(void) -{ -#if (FIXED_BUFFERS > 2) || (FIXED_STREAMS > 3) - int i; -#endif -#if FIXED_BUFFERS > 2 - _free_buffer_index = 2; - for ( i = 2 ; i < FIXED_BUFFERS ; i++ ) { - _fixed_buffers[i*BUFSIZ] = i; - } -#endif -#if FIXED_STREAMS > 3 - _free_file_list = _stdio_streams + 3; - for ( i = 3 ; i < FIXED_STREAMS-1 ; i++ ) { - _stdio_streams[i].next = _stdio_streams + i + 1; - } - _stdio_streams[i].next = 0; -#endif - -#if _IOFBF != 0 || _IOLBF != 1 -#error Assumption violated -- values of _IOFBF and/or _IOLBF -/* This asssumption is also made in _fopen. */ -#endif - - /* stdout uses line buffering when connected to a tty. */ - _stdio_streams[1].mode |= isatty(1); -} -#endif - -#ifdef L_fputc -int fputc(int c, FILE *fp) -{ - unsigned char buf[1]; - - *buf = (unsigned char) c; - - if (_uClibc_fwrite(buf, 1, fp)) { - return (unsigned char) c; - } - return EOF; -} -#endif - -#ifdef L_fgetc -int fgetc(FILE *fp) -{ - unsigned char buf[1]; - - if (_uClibc_fread(buf, 1, fp)) { - return *buf; - } - return EOF; -} -#endif - -#ifdef L_fflush -int fflush(FILE *fp) -{ - int rv; - - rv = 0; - - if (fp == NULL) { /* On NULL flush the lot. */ - for (fp = __IO_list; fp; fp = fp->next) { - if (WRITEABLE(fp) && fflush(fp)) { - rv = EOF; - } - } - } else if (WRITING(fp)) { /* Output buffer contents. */ - _uClibc_fwrite(NULL, 0, fp); - if (fp->mode & __MODE_ERR) { - rv = -1; - } - } else if (!WRITEABLE(fp)) { /* File opened read-only!!! */ - /* - * According to info, glibc returns an error when the file is opened - * in read-only mode. - * ANSI says behavior in this case is undefined but also says you - * shouldn't flush a stream you were reading from. - */ - __set_errno(EBADF); /* Should we set stream error indicator? */ - rv = -1; - } - - return rv; -} -#endif - -#ifdef L_fgets -/* Nothing special here ... */ -char *fgets(char *s, int count, FILE *fp) -{ - int ch; - char *p; - - p = s; - while (count-- > 1) { /* Guard against count arg == INT_MIN. */ - ch = getc(fp); - if (ch == EOF) { - break; - } - *p++ = ch; - if (ch == '\n') { - break; - } - } - if (ferror(fp) || (s == p)) { - return 0; - } - *p = 0; - return s; -} -#endif - -#ifdef L_gets -link_warning (gets, "the `gets' function is dangerous and should not be used.") -char *gets(char *str) /* This is an UNSAFE function! */ -{ - /* - * Strictly speaking, this implementation is incorrect as the number - * of chars gets can read should be unlimited. However, I can't - * imagine anyone wanting to gets() into a buffer bigger than INT_MAX. - * - * Besides, this function is inherently unsafe and shouldn't be used. - */ - return fgets(str, INT_MAX, stdin); -} -#endif - -#ifdef L_fputs -int fputs(const char *str, FILE *fp) -{ - int n; - - n = strlen(str); - - _uClibc_fwrite((const unsigned char *)str, n, fp); - if (fp->mode & __MODE_ERR) { - n = EOF; - } - return n; -} -#endif - -#ifdef L_puts -int puts(const char *str) -{ - int n; - - n = fputs(str, stdout); /* Let next fputc handle EOF or error. */ - if (fputc('\n', stdout) == EOF) { /* Don't use putc since we want to */ - return EOF; /* fflush stdout if it is line buffered. */ - } - return n + 1; -} -#endif - -#ifdef L_fread -/* - * fread will often be used to read in large chunks of data calling read() - * directly can be a big win in this case. Beware also fgetc calls this - * function to fill the buffer. - */ -size_t fread(buf, size, nelm, fp) -void *buf; -size_t size; -size_t nelm; -FILE *fp; -{ - unsigned char *p; - unsigned char *q; - -#warning TODO: handle possible overflow of size * nelm - p = (unsigned char *) buf; - q = p + (size * nelm); - - while ((p < q) && !EOF_OR_ERROR(fp)) { - p += _uClibc_fread(p, q - p, fp); - } - return (p - (unsigned char *) buf)/size; -} -#endif - -#ifdef L__uClibc_fread -off_t _uClibc_fread(unsigned char *buf, off_t bytes, FILE *fp) -{ - unsigned char *p; - off_t len; - - if (!READABLE(fp)) { - fp->mode |= __MODE_ERR; - } else if (WRITING(fp)) { - fflush(fp); - } else if (fp->mode & stdout->mode & __MODE_TIED) { - fflush(stdout); - } - if (EOF_OR_ERROR(fp) || (bytes <= 0)) { - return 0; - } - - p = (unsigned char *) buf; - - if (fp->mode & __MODE_UNGOT) { /* If we had an ungetc'd char, */ - fp->mode ^= __MODE_UNGOT; /* reset the flag and return it. */ - *p++ = fp->ungot; - --bytes; - } - - FROM_BUF: - len = fp->bufread - fp->bufpos; - if (len > bytes) { /* Enough buffered */ - len = bytes; - } - - bytes -= len; - while (len--) { - *p++ = *fp->bufpos++; - } - - if (bytes && !EOF_OR_ERROR(fp)) { /* More requested but buffer empty. */ - if (bytes < fp->bufend - fp->bufstart) { - fp->bufpos = fp->bufread = fp->bufstart; /* Reset pointers. */ - fp->bufread += _uClibc_fread(fp->bufstart, - fp->bufend - fp->bufstart, fp); - goto FROM_BUF; - } - - len = read(fp->fd, p, (unsigned) bytes); - if (len < 0) { - fp->mode |= __MODE_ERR; - } else { - p += len; - if (len == 0) { - fp->mode |= __MODE_EOF; - } - } - } - - return (p - (unsigned char *)buf); - -} -#endif - -#ifdef L_fwrite -/* - * Like fread, fwrite will often be used to write out large chunks of - * data; calling write() directly can be a big win in this case. - * - * But first we check to see if there's space in the buffer. - */ -size_t fwrite(buf, size, nelm, fp) -const void *buf; -size_t size; -size_t nelm; -FILE *fp; -{ - off_t bytes; - -#warning TODO: handle possible overflow for bytes - bytes = size * nelm; /* How many bytes do we want? */ - - bytes = _uClibc_fwrite((const unsigned char *)buf, bytes, fp); - - return bytes/size; -} -#endif - -#ifdef L__uClibc_fwrite -/* - * If buf == NULL, fflush. - * If buf != NULL, (fflush and) write - * Returns number of chars written from fp buffer _OR_ from buf. - */ - -off_t _uClibc_fwrite(const unsigned char *buf, off_t bytes, FILE *fp) -{ - unsigned char *p; - int rv, had_newline; - - /* - * Fail if stream isn't writable, if we were reading and get an error - * changing over to write mode (ie. can't update stream position), - * or if the stream was already in an error state. - */ - if (!WRITEABLE(fp)) { /* Fail if stream isn't writable. */ - fp->mode |= __MODE_ERR; - } else if (READING(fp)) { /* If read buffer isn't empty, */ - fseek(fp, 0, SEEK_CUR); /* stop reading and update position. */ - } else if (READABLE(fp)) { - fp->bufread = fp->bufstart; /* Reset start of read buffer. */ - } - if (EOF_OR_ERROR(fp)) { - return 0; - } - - p = (unsigned char *)buf; - if (p && (fp->bufpos + bytes <= fp->bufend)) { /* Enough buffer space? */ - had_newline = 0; - while (bytes--) { - if (*p == '\n') { - had_newline = 1; - } - *fp->bufpos++ = *p++; - } - if (fp->bufpos < fp->bufend) { /* Buffer is not full. */ - fp->bufwrite = fp->bufend; - if ((fp->mode & __MODE_BUF) == _IOLBF) { - fp->bufwrite = fp->bufpos; - if (had_newline) { - goto FFLUSH; - } - } - goto DONE; - } - FFLUSH: - /* If we get here, either buffer is full or we need to flush anyway. */ - buf = fp->bufpos - (p - (unsigned char *)buf); - p = NULL; - } - if (!p) { /* buf == NULL means fflush */ - p = fp->bufstart; - bytes = fp->bufpos - p; - fp->bufpos = fp->bufwrite = p; - } else if (fp->bufpos > fp->bufstart) { /* If there are buffered chars, */ - _uClibc_fwrite(NULL, 0, fp); /* write them. */ - if (ferror(fp)) { - return 0; - } - } - - while (bytes) { - if ((rv = write(fp->fd, p, bytes)) < 0) { - rv = 0; - break; - } - p += rv; - bytes -= rv; - } - if (bytes) { - fp->mode |= __MODE_ERR; - } - - DONE: - return (p - (unsigned char *)buf); -} -#endif - -#ifdef L_rewind -void rewind(fp) -FILE *fp; -{ - clearerr(fp); /* Clear errors first, then seek in case */ - fseek(fp, 0, SEEK_SET); /* there is an error seeking. */ -} -#endif - -#ifdef L_fseek -int fseek(FILE *fp, long int offset, int ref) -{ -#if SEEK_SET != 0 || SEEK_CUR != 1 || SEEK_END != 2 -#error Assumption violated -- values of SEEK_SET, SEEK_CUR, SEEK_END -#endif - - if ((ref < 0) || (ref > 2)) { - __set_errno(EINVAL); - return -1; - } - - if (WRITING(fp)) { - fflush(fp); /* We'll deal with errors below. */ - /* After fflush, bufpos is at CUR. */ - } else if (READING(fp)) { - if (ref == SEEK_CUR) { - /* Correct offset to take into account position in buffer. */ - offset -= (fp->bufread - fp->bufpos); - if (fp->mode & __MODE_UNGOT) { /* If we had an ungetc'd char, */ - --offset; /* adjust offset (clear flag below). */ - } - } - } - - if ((fp->mode & __MODE_ERR) || - (((ref != SEEK_CUR) || offset) && (lseek(fp->fd, offset, ref) < 0))) { - return -1; - } - - if (READING(fp)) { - fp->bufpos = fp->bufread = fp->bufstart; - } - fp->mode &= ~(__MODE_EOF | __MODE_UNGOT); - - return 0; -} -#endif - -#ifdef L_ftell -long ftell(fp) -FILE *fp; -{ - /* Note: can't do fflush here since it would discard any ungetc's. */ - off_t pos; - - pos = lseek(fp->fd, 0, SEEK_CUR); /* Get kernels idea of position. */ - if (pos < 0) { - return -1; - } - - if (WRITING(fp)) { - pos += (fp->bufpos - fp->bufstart); /* Adjust for buffer position. */ - } else if (READING(fp)) { - pos -= (fp->bufread - fp->bufpos); /* Adjust for buffer position. */ - if (fp->mode & __MODE_UNGOT) { - --pos; - } - if (pos < 0) { /* ungetcs at start of file? */ - __set_errno(EIO); - pos = -1; - } - } - - return pos; -} -#endif - -#ifdef L__fopen -/* - * This Fopen is all three of fopen, fdopen and freopen. The macros in - * stdio.h show the other names. - */ -static __inline FILE *_alloc_stdio_stream(void) -{ - FILE *fp; - - if (_free_file_list) { - fp = _free_file_list; - _free_file_list = fp->next; - } else if (!(fp = malloc(sizeof(FILE)))) { - return 0; - } - fp->mode = __MODE_FREEFIL | _IOFBF; - /* Initially set to use builtin buffer of FILE structure. */ - fp->bufstart = fp->unbuf; - fp->bufend = fp->unbuf + sizeof(fp->unbuf); - return fp; -} - -FILE *__fopen(fname, fd, fp, mode, extra_modes) -const char *fname; -int fd; -FILE *fp; -const char *mode; -int extra_modes; -{ - FILE *nfp; - unsigned char *p; - int open_mode; - int cur_mode; - - nfp = fp; - - /* Parse the mode string arg. */ - switch (*mode++) { - case 'r': /* read */ - open_mode = O_RDONLY | extra_modes; - break; - case 'w': /* write (create or truncate)*/ - open_mode = (O_WRONLY | O_CREAT | O_TRUNC | extra_modes); - break; - case 'a': /* write (create or append) */ - open_mode = (O_WRONLY | O_CREAT | O_APPEND | extra_modes); - break; - default: /* illegal mode */ - __set_errno(EINVAL); - goto _fopen_ERROR; - } - - if ((*mode == 'b')) { /* binary mode (nop for uClibc) */ - ++mode; - } - - -#if O_RDONLY != 0 || O_WRONLY != 1 || O_RDWR != 2 -#error Assumption violated concerning open mode constants! -#endif - - if (*mode == '+') { /* read-write */ - ++mode; - open_mode &= ~(O_RDONLY | O_WRONLY); - open_mode |= O_RDWR; - } - - while (*mode) { /* ignore everything else except ... */ - if (*mode == 'x') { /* open exclusive -- GNU extension */ - open_mode |= O_EXCL; - } - ++mode; - } - - if (fp == 0) { /* We need a FILE so allocate it before */ - if (!(nfp = _alloc_stdio_stream())) { - return 0; - } - } - - if (fname) { /* Open the file itself */ - fd = open(fname, open_mode, 0666); - } else { /* fdopen -- check mode is compatible. */ -#if O_ACCMODE != 3 || O_RDONLY != 0 || O_WRONLY != 1 || O_RDWR != 2 -#error Assumption violated - mode constants -#endif - cur_mode = fcntl(fd, F_GETFL); - if (cur_mode == -1) { - fd = -1; - } else if (!(cur_mode & O_RDWR) - && ((cur_mode ^ open_mode) & O_ACCMODE)) { - __set_errno(EINVAL); - fd = -1; - } - } - - if (fd < 0) { /* Error from open or bad arg passed. */ - _fopen_ERROR: - if (nfp) { - _free_stdio_stream(nfp); - } - return 0; - } - - nfp->fd = fd; /* Set FILE's fd before adding to open list. */ - - if (fp == 0) { /* Not freopen so... */ - nfp->next = __IO_list; /* use newly created FILE and */ - __IO_list = nfp; /* add it to the list of open files. */ - - if ((p = _alloc_stdio_buffer(BUFSIZ)) != 0) { - nfp->bufstart = p; - nfp->bufend = p + BUFSIZ; - nfp->mode |= __MODE_FREEBUF; - } - } - - /* Ok, file's ready clear the buffer and save important bits */ - nfp->bufpos = nfp->bufstart; - nfp->mode |= isatty(fd); - nfp->bufread = nfp->bufwrite = 0; - if (!(open_mode & O_WRONLY)) { - nfp->bufread = nfp->bufstart; - } - if (open_mode & (O_WRONLY | O_RDWR)) { - nfp->bufwrite = nfp->bufstart; - } - - return nfp; -} -#endif - -#ifdef L_fclose -int fclose(fp) -FILE *fp; -{ - FILE *prev; - FILE *ptr; - int rv; - - rv = 0; - if (WRITING(fp)) { /* If there are buffered chars to write... */ - rv = fflush(fp); /* write them. */ - } - if (close(fp->fd)) { /* Need to close even if fflush fails. */ - rv = EOF; - } - - prev = 0; /* Remove file from open list. */ - for (ptr = __IO_list; ptr ; ptr = ptr->next) { - if (ptr == fp) { - if (prev == 0) { - __IO_list = fp->next; - } else { - prev->next = fp->next; - } - break; - } - prev = ptr; - } - - _free_stdio_stream(fp); /* Finally free the stream if necessary. */ - - return rv; -} -#endif - -#ifdef L__free_stdio_stream -/* The following is only called by fclose and _fopen. */ -void _free_stdio_stream(FILE *fp) -{ - _free_stdio_buffer_of_file(fp); /* Free buffer if necessary. */ - - if (!(fp->mode & __MODE_FREEFIL)) { - return; - } - - /* Note: we generally won't bother checking for bad pointers here. */ - if ((fp >= _stdio_streams) && (fp < _stdio_streams + FIXED_STREAMS)) { - assert( (fp - _stdio_streams) % ((_stdio_streams+1) -_stdio_streams) - == 0 ); - fp->next = _free_file_list; - _free_file_list = fp; - return; - } - free(fp); -} -#endif - -#ifdef L_setbuffer -void setbuffer(FILE *fp, char *buf, size_t size) -{ - int mode; - - mode = _IOFBF; - if (!buf) { - mode = _IONBF; - } - setvbuf(fp, buf, mode, size); -} -#endif - -#ifdef L_setvbuf -int setvbuf(FILE *fp, char *ubuf, int mode, size_t size) -{ - unsigned char *buf = ubuf; - int allocated_buf_flag; - - if ((mode < 0) || (mode > 2)) { /* Illegal mode. */ - return EOF; - } - -#if FLEXIBLE_SETVBUF - /* C89 standard requires no ops before setvbuf, but we can be flexible. */ - /* NOTE: This will trash any chars ungetc'd!!! */ - if (fseek(fp, 0, SEEK_CUR)) { - return EOF; - } -#endif - - /* Note: If size == 2 we could use FILE's builting buffer as well, but */ - /* I don't think the benefit is worth the code size increase. */ - if ((mode == _IONBF) || (size < 1)) { - size = 1; /* size == 1 _REQUIRED_ for _IONBF!!! */ - buf = fp->unbuf; - } - - fp->mode &= ~(__MODE_BUF); /* Clear current mode */ - fp->mode |= mode; /* and set new one. */ - - allocated_buf_flag = 0; - if ((!buf) && (size != (fp->bufend - fp->bufstart))) { - /* No buffer supplied and requested size different from current. */ - allocated_buf_flag = __MODE_FREEBUF; - if (!(buf = _alloc_stdio_buffer(size))) { - return EOF; /* Keep current buffer. */ - } - } - - if (buf && (buf != fp->bufstart)) { /* Want different buffer. */ - _free_stdio_buffer_of_file(fp); /* Free the old buffer. */ - fp->mode |= allocated_buf_flag; /* Allocated? or FILE's builtin. */ - fp->bufstart = buf; - fp->bufend = buf + size; - fp->bufpos = fp->bufstart; - if (READABLE(fp)) { - fp->bufread = fp->bufstart; - } - if (WRITEABLE(fp)) { - fp->bufwrite = fp->bufstart; - } - } - - return 0; -} -#endif - -#ifdef L_setbuf -void setbuf(FILE *fp, char *buf) -{ - int mode; - - mode = _IOFBF; - if (!buf) { - mode = _IONBF; - } - setvbuf(fp, buf, mode, BUFSIZ); -} -#endif - -#ifdef L_setlinebuf -void setlinebuf(FILE *fp) -{ - setvbuf(fp, NULL, _IOLBF, BUFSIZ); -} -#endif - -#ifdef L_ungetc -/* - * NOTE: Only one character of pushback is guaranteed, although sometimes - * it is possible to do more. You have 1 plus as many characters of pushback - * as have been read since that last buffer-fill. - */ -int ungetc(c, fp) -int c; -FILE *fp; -{ - unsigned char *p; - - /* If can't read or there's been an error, or c == EOF, or ungot slot - * already filled, then return EOF */ - /* - * This can only happen if an fgetc triggered a read (that filled - * the buffer for case 2 above) and then we ungetc 3 chars. - */ - if (!READABLE(fp) || (fp->mode & (__MODE_UNGOT | __MODE_ERR)) - || (c == EOF) ) { - return EOF; - } - - if (WRITING(fp)) { /* Commit any write-buffered chars. */ - fflush(fp); - } - - if (fp->bufpos > fp->bufstart) { /* We have space before bufpos. */ - p = --fp->bufpos; - } else if (fp->bufread == fp->bufpos) { /* Buffer is empty. */ - p = fp->bufread++; - } else { - fp->mode |= __MODE_UNGOT; - p = &(fp->ungot); - } - fp->mode &= ~(__MODE_EOF); /* Clear EOF indicator. */ - - if (*p != (unsigned char) c) { /* Don't store if same, because could */ - *p = (unsigned char) c; /* be sscanf from a const string!!! */ - } - - return c; -} -#endif - -#ifdef L_fopen -#undef fopen -FILE *fopen(const char *__restrict filename, - const char *__restrict mode) -{ - return __fopen(filename, -1, NULL, mode, 0); -} -#endif - -#ifdef L_freopen -FILE *freopen(__const char *__restrict filename, - __const char *__restrict mode, FILE *__restrict fp) -{ - /* fflush file, close the old fd, and reset modes. */ - if (WRITING(fp)) { /* If anything in the write buffer... */ - fflush(fp); /* write it. */ - } - close(fp->fd); /* Close the file. */ - fp->mode &= (__MODE_FREEFIL | __MODE_FREEBUF); /* Reset the FILE modes. */ - fp->mode |= _IOFBF; - - return __fopen(filename, -1, fp, mode, 0); -} -#endif - -#ifdef L_fsfopen -FILE *fsfopen(__const char *__restrict filename, - __const char *__restrict mode, FILE *__restrict fp) -{ - fp->mode = _IOFBF; - fp->bufstart = fp->unbuf; - fp->bufend = fp->unbuf + sizeof(fp->unbuf); - - return __fopen(filename, -1, fp, mode, 0); -} -#endif - -#ifdef L_fdopen -#undef fdopen -FILE *fdopen(int fd, __const char *mode) -{ - return __fopen(NULL, fd, NULL, mode, 0); -} -#endif - - -#ifdef L_getc -#undef getc -int getc(FILE *stream) -{ - return(((stream)->bufpos >= (stream)->bufread)? fgetc(stream) : - (*(stream)->bufpos++)); -} -#endif - -#ifdef L_putc -#undef putc -int putc(int c, FILE *stream) -{ - return(((stream)->bufpos >= (stream)->bufwrite)? fputc((c), (stream)) : - (unsigned char) (*(stream)->bufpos++ = (c)) ); -} -#endif - -#ifdef L_getchar -#undef getchar -int getchar(void) -{ - return getc(stdin); -} -#endif - -#ifdef L_putchar -#undef putchar -int putchar(int c) -{ - return putc(c, stdout); -} -#endif - -#ifdef L_clearerr -#undef clearerr -void clearerr(FILE *fp) -{ - fp->mode &= ~(__MODE_EOF | __MODE_ERR); -} -#endif - -#ifdef L_feof -#undef feof -int feof(FILE *fp) -{ - return fp->mode & __MODE_EOF; -} -#endif - -#ifdef L_ferror -#undef ferror -int ferror(FILE *fp) -{ - return fp->mode & __MODE_ERR; -} -#endif - -#ifdef L_fileno -int fileno(FILE *fp) -{ - return fp->fd; -} -#endif - -#ifdef L_fgetpos -int fgetpos(FILE *fp, fpos_t *pos) -{ - fpos_t p; - - if (!pos) { /* NULL pointer. */ - __set_errno(EINVAL); - return -1; - } - - if ((p = ftell(fp)) < 0) { /* ftell failed. */ - return -1; /* errno set by ftell. */ - } - - *pos = p; - return 0; -} -#endif - -#ifdef L_fsetpos -int fsetpos(FILE *fp, __const fpos_t *pos) -{ - if (pos) { /* Pointer ok. */ - return fseek(fp, *pos, SEEK_SET); - } - __set_errno(EINVAL); /* NULL pointer. */ - return EOF; -} -#endif - -#ifdef L_fopen64 -#ifdef __UCLIBC_HAVE_LFS__ -#ifndef O_LARGEFILE -#define O_LARGEFILE 0100000 -#endif -FILE *fopen64(const char *__restrict filename, - const char *__restrict mode) -{ - return __fopen(filename, -1, NULL, mode, O_LARGEFILE); -} -#endif /* __UCLIBC_HAVE_LFS__ */ -#endif - diff --git a/libc/stdlib/atexit.c b/libc/stdlib/atexit.c index d22d6a5e7..95047e78f 100644 --- a/libc/stdlib/atexit.c +++ b/libc/stdlib/atexit.c @@ -17,7 +17,7 @@ * Changed name of __cleanup to __uClibc_cleanup. * Moved declaration of __uClibc_cleanup to __uClibc_main * where it is initialized with (possibly weak alias) - * __stdio_flush_buffers. + * _stdio_term. * * Jul 2001 Steve Thayer * @@ -141,7 +141,7 @@ void __exit_handler(int status) #endif #ifdef L_exit -extern void weak_function __stdio_flush_buffers(void); +extern void weak_function _stdio_term(void); void (*__exit_cleanup) (int) = 0; /* @@ -154,9 +154,12 @@ void exit(int rv) __exit_cleanup(rv); } - /* Clean up everything else */ - if (__stdio_flush_buffers) - __stdio_flush_buffers(); + /* If we are using stdio, try to shut it down. At the very least, + * this will attempt to commit all buffered writes. It may also + * unbuffer all writable files, or close them outright. + * Check the stdio routines for details. */ + if (_stdio_term) + _stdio_term(); _exit(rv); } diff --git a/libc/stdlib/ptsname.c b/libc/stdlib/ptsname.c index 659049a4c..636e9c121 100644 --- a/libc/stdlib/ptsname.c +++ b/libc/stdlib/ptsname.c @@ -17,6 +17,8 @@ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +#define _STDIO_UTILITY /* For _int10tostr. */ +#include #include #include #include @@ -27,6 +29,7 @@ #include #include + #if !defined UNIX98PTY_ONLY /* Check if DEV corresponds to a master pseudo terminal device. */ @@ -55,8 +58,6 @@ extern const char _ptyname2[]; /* Directory where we can find the slave pty nodes. */ #define _PATH_DEVPTS "/dev/pts/" -extern char *__ultostr(char *buf, unsigned long uval, int base, int uppercase); - /* Store at most BUFLEN characters of the pathname of the slave pseudo terminal associated with the master FD is open on in BUF. Return 0 on success, otherwise an error number. */ @@ -86,14 +87,12 @@ int ptsname_r (int fd, char *buf, size_t buflen) #ifdef TIOCGPTN if (ioctl (fd, TIOCGPTN, &ptyno) == 0) { - /* Buffer we use to print the number in. For a maximum size for - `int' of 8 bytes we never need more than 20 digits. */ - char numbuf[21]; + /* Buffer we use to print the number in. */ + char numbuf[__BUFLEN_INT10TOSTR]; static const char devpts[] = _PATH_DEVPTS; char *p; - numbuf[20] = '\0'; - p = __ultostr (&numbuf[sizeof numbuf - 1], ptyno, 10, 0); + p = _int10tostr(&numbuf[sizeof numbuf - 1], ptyno); if (buflen < sizeof devpts + &numbuf[sizeof numbuf - 1] - p) { diff --git a/libc/string/strerror.c b/libc/string/strerror.c index e157835c8..890a03d1a 100644 --- a/libc/string/strerror.c +++ b/libc/string/strerror.c @@ -28,26 +28,25 @@ Cambridge, MA 02139, USA. */ * * Added the option WANT_ERRORLIST for low-memory applications to omit the * error message strings and only output the error number. + * + * Manuel Novoa III Feb 2002 + * + * Change to _int10tostr and fix a bug in end-of-buf arg. */ #define WANT_ERRORLIST 1 +#define _STDIO_UTILITY /* For _int10tostr. */ #include #include #include -#include - -#if (INT_MAX >> 31) -/* We're set up for 32 bit ints */ -#error need to check size allocation for static buffer 'retbuf' -#endif - -extern char *__ltostr(char *buf, long uval, int base, int uppercase); - #if WANT_ERRORLIST static char retbuf[48]; #else +#if __BUFLEN_INT10TOSTR > 12 +#error currently set up for 32 bit ints max! +#endif static char retbuf[33]; /* 33 is sufficient for 32 bit ints */ #endif static const char unknown_error[] = "Unknown Error: errno"; /* = */ @@ -66,9 +65,8 @@ char *strerror(int err) } #endif - /* unknown error */ - pos = __ltostr(retbuf + sizeof(retbuf) + 1, err, 10, 0) - - sizeof(unknown_error); /* leave space for the '=' */ + /* unknown error -- leave space for the '=' */ + pos = _int10tostr(retbuf+sizeof(retbuf)-1, err) - sizeof(unknown_error); strcpy(pos, unknown_error); *(pos + sizeof(unknown_error) - 1) = '='; return pos; @@ -97,8 +95,8 @@ int main(void) #endif p = strerror(INT_MIN); - j = strlen(p)+1; - if (j > max) { + j = retbuf+sizeof(retbuf) - p; + if ( > max) { max = j; printf("strerror.c - Test of INT_MIN: <%s> %d\n", p, j); } diff --git a/libc/string/strsignal.c b/libc/string/strsignal.c index 145488aa9..04459402e 100644 --- a/libc/string/strsignal.c +++ b/libc/string/strsignal.c @@ -34,22 +34,23 @@ * * Added the option WANT_SIGLIST for low-memory applications to omit the * signal message strings and only output the signal number. + * + * Manuel Novoa III Feb 2002 + * + * Change to use _int10tostr and fix a bug in end-of-buf arg. */ #define WANT_SIGLIST 1 + +#define _STDIO_UTILITY /* For _int10tostr. */ +#include #include #include #include -#include +#ifndef __USE_GNU #define __USE_GNU -#include - -#if (INT_MAX >> 31) -/* We're set up for 32 bit ints */ -#error need to check size allocation for static buffer 'retbuf' #endif - -extern char *__ltostr(char *buf, long uval, int base, int uppercase); +#include /********************** Function strsignal ************************************/ #ifdef L_strsignal @@ -96,6 +97,10 @@ const char *const sys_siglist[] = { #define NUM_KNOWN_SIGNALS 32 +#if __BUFLEN_INT10TOSTR > 12 +#error currently set up for 32 bit ints max! +#endif + static char retbuf[28]; /* 28 is sufficient for 32 bit ints */ static const char unknown_signal[] = "Unknown Signal:"; @@ -112,8 +117,7 @@ char *strsignal(int sig) } #endif - pos = __ltostr(retbuf + sizeof(unknown_signal) + 1, sig, 10, 0) - - sizeof(unknown_signal); + pos = _int10tostr(retbuf+sizeof(retbuf)-1, sig) - sizeof(unknown_signal); strcpy(pos, unknown_signal); *(pos + sizeof(unknown_signal) - 1) = ' '; return pos; @@ -123,8 +127,6 @@ char *strsignal(int sig) /********************** Function psignal ************************************/ #ifdef L_psignal -#include - void psignal(int sig, const char *s) { fprintf(stderr, "%s: %s\n", s, strsignal(sig)); @@ -161,7 +163,7 @@ int main(void) #endif p = strsignal(INT_MIN); - j = strlen(p)+1; + j = retbuf+sizeof(retbuf) - p; if (j > max) max = j; /*printf("strsignal.c - Test of INT_MIN: <%s> %d\n", p, j);*/ diff --git a/libc/sysdeps/linux/common/bits/uClibc_stdio.h b/libc/sysdeps/linux/common/bits/uClibc_stdio.h new file mode 100644 index 000000000..87d4b99ae --- /dev/null +++ b/libc/sysdeps/linux/common/bits/uClibc_stdio.h @@ -0,0 +1,494 @@ +/* Copyright (C) 2002 Manuel Novoa III + * Header for 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! */ + +#ifndef _STDIO_H +#error Always include rather than +#endif + +/**********************************************************************/ +#ifdef __UCLIBC__ + +#ifdef __UCLIBC_HAS_THREADS__ +#define __STDIO_THREADSAFE +#endif + +#ifdef __UCLIBC_HAVE_LFS__ +#define __STDIO_LARGE_FILES +#endif /* __UCLIBC_HAVE_LFS__ */ + +/* Make sure defines related to large files are consistent. */ +#ifdef _LIBC + +#ifdef __UCLIBC_HAVE_LFS__ +#undef __USE_LARGEFILE +#undef __USE_LARGEFILE64 +#undef __USE_FILE_OFFSET64 +/* if we're actually building uClibc with large file support, only define... */ +#define __USE_LARGEFILE64 1 +#endif /* __UCLIBC_HAVE_LFS__ */ + +#else /* not _LIBC */ + +#ifndef __UCLIBC_HAVE_LFS__ +#if defined(__LARGEFILE64_SOURCE) || defined(__USE_LARGEFILE64) \ + || defined(__USE_FILE_OFFSET64) +#error Sorry... uClibc was built without large file support! +#endif +#endif /* __UCLIBC_HAVE_LFS__ */ + +#endif /* _LIBC */ + +#endif /* __UCLIBC__ */ +/**********************************************************************/ +/* These are the stdio configuration options. Keep them here until + uClibc's configuration process gets reworked. */ + +/* #define __STDIO_WIDE */ +#ifdef __STDIO_WIDE +typedef int __wchar_t; /* TODO: temporary, as not currently uClibc */ +#endif + +#define __STDIO_BUFFERS +#define __STDIO_GETC_MACRO +#define __STDIO_PUTC_MACRO + +/* For uClibc, these are currently handled above. */ +/* #define __STDIO_LARGE_FILES */ +#define __STDIO_THREADSAFE + +/* L mode extension for fopen. */ +#define __STDIO_FOPEN_LARGEFILE_MODE + +/* size of builtin buf -- only tested with 0 */ +#define _STDIO_BUILTIN_BUF_SIZE 0 + +/* TODO - enable features based on __STDIO_GLIBC_FEATURES */ + +/* #define __STDIO_GLIBC_FEATURES */ +#define __STDIO_AUTO_RW_TRANSITION +#define __STDIO_FOPEN_EXCLUSIVE_MODE +#define __STDIO_PRINTF_M_SPEC +#define __STDIO_GLIBC_CUSTOM_STREAMS + + +/* ANSI/ISO mandate at least 256. */ +#define _STDIO_BUFSIZ 256 + +/* Currently unimplemented/untested */ +/* #define __STDIO_FLEXIBLE_SETVBUF */ + +/**********************************************************************/ +/* TODO -- posix or gnu -- belongs in limits.h and >= 9 for sus */ +/* NOTE: for us it is currently _always_ 9 */ +#define NL_ARGMAX 9 + +/* TODO -- where should this go? */ +#ifndef O_LARGEFILE +#define O_LARGEFILE 0100000 +#endif + +/**********************************************************************/ + +/* These are consistency checks on the different options */ + +#ifndef __STDIO_BUFFERS +#undef __STDIO_GETC_MACRO +#undef __STDIO_PUTC_MACRO +#endif + +#ifdef __BCC__ +#undef __STDIO_LARGE_FILES +#endif + +#ifndef __STDIO_LARGE_FILES +#undef __STDIO_FOPEN_LARGEFILE_MODE +#endif + +/**********************************************************************/ + +#ifdef __STDIO_THREADSAFE +/* Need this for pthread_mutex_t. */ +#include + +#define __STDIO_THREADLOCK(STREAM) \ + if ((STREAM)->user_locking == 0) { \ + pthread_mutex_lock(&(STREAM)->lock); \ + } + +#define __STDIO_THREADUNLOCK(STREAM) \ + if ((STREAM)->user_locking == 0) { \ + pthread_mutex_unlock(&(STREAM)->lock); \ + } + +#define __STDIO_THREADTRYLOCK(STREAM) \ + if ((STREAM)->user_locking == 0) { \ + pthread_mutex_trylock(&(STREAM)->lock); \ + } + +#else /* __STDIO_THREADSAFE */ + +#define __STDIO_THREADLOCK(STREAM) +#define __STDIO_THREADUNLOCK(STREAM) +#define __STDIO_THREADTRYLOCK(STREAM) + +#endif /* __STDIO_THREADSAFE */ + +/* This file may eventually have two personalities: + 1) core stuff (similar to glibc's libio.h) + 2) extern inlines (for glibc's bits/stdio.h) + Right now, only (1) is implemented. */ + +#define _STDIO_IOFBF 0 /* Fully buffered. */ +#define _STDIO_IOLBF 1 /* Line buffered. */ +#define _STDIO_IONBF 2 /* No buffering. */ + +typedef struct { + __off_t __pos; +/* __mbstate_t __state; */ +} __stdio_fpos_t; + +typedef struct { + __off64_t __pos; +/* __mbstate_t __state; */ +} __stdio_fpos64_t; + + +/**********************************************************************/ +#ifdef __STDIO_LARGE_FILES +typedef __off64_t __offmax_t; /* TODO -- rename this? */ +#else +typedef __off_t __offmax_t; /* TODO -- rename this? */ +#endif + +/**********************************************************************/ + +#ifdef __STDIO_GLIBC_CUSTOM_STREAMS + +typedef __ssize_t __io_read_fn(void *cookie, + char *buf, size_t bufsize); +typedef __ssize_t __io_write_fn(void *cookie, + const char *buf, size_t bufsize); +/* NOTE: GLIBC difference!!! -- fopencookie seek function + * For glibc, the type of pos is always (__off64_t *) but in our case + * it is type (__off_t *) when the lib is built without large file support. + */ +typedef int __io_seek_fn(void *cookie, + __offmax_t *pos, int whence); +typedef int __io_close_fn(void *cookie); + +typedef struct { + __io_read_fn *read; + __io_write_fn *write; + __io_seek_fn *seek; + __io_close_fn *close; +} _IO_cookie_io_functions_t; + +#if defined(_LIBC) || defined(_GNU_SOURCE) +typedef __io_read_fn cookie_read_function_t; +typedef __io_write_fn cookie_write_function_t; +typedef __io_seek_fn cookie_seek_function_t; +typedef __io_close_fn cookie_close_function_t; + +typedef _IO_cookie_io_functions_t cookie_io_functions_t; +#endif /* _GNU_SOURCE */ + +#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */ + +/* + * ungot scheme: + * 0 0 none + * 0 1 one user (unused ungot is 1) or one scanf (unused ungot is 0) + * 1 0 must be scanf[0] and user[1] + * 1 1 illegal -- could be used to signal safe for setbuf + */ + +#ifdef __UCLIBC__ +#define __stdio_file_struct _UC_FILE +#endif + +struct __stdio_file_struct { + unsigned short modeflags; + /* There could be a hole here, but modeflags is used most.*/ +#ifdef __STDIO_WIDE + unsigned char ungot_width[2]; + __wchar_t ungot[2]; +#else /* __STDIO_WIDE */ + unsigned char ungot[2]; +#endif /* __STDIO_WIDE */ + int filedes; +#if defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) + struct __stdio_file_struct *nextopen; +#endif /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */ +#ifdef __STDIO_BUFFERS + unsigned char *bufstart; /* pointer to buffer */ + unsigned char *bufend; /* pointer to 1 past end of buffer */ + unsigned char *bufwpos; /* pointer to 1 past last buffered */ + unsigned char *bufrpos; /* pointer to next readable buffered */ +#ifdef __STDIO_GETC_MACRO + unsigned char *bufgetc; /* 1 past last readable by getc */ +#endif /* __STDIO_GETC_MACRO */ +#ifdef __STDIO_PUTC_MACRO + unsigned char *bufputc; /* 1 past last writeable by putc */ +#endif /* __STDIO_PUTC_MACRO */ +#endif /* __STDIO_BUFFERS */ +#ifdef __STDIO_GLIBC_CUSTOM_STREAMS + void *cookie; + _IO_cookie_io_functions_t gcs; +#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */ +#ifdef __STDIO_THREADSAFE + int user_locking; + pthread_mutex_t lock; +#endif +/* Everything after this is unimplemented... and may be trashed. */ +#if __STDIO_BUILTIN_BUF_SIZE > 0 + unsigned char builtinbuf[__STDIO_BUILTIN_BUF_SIZE]; +#endif /* __STDIO_BUILTIN_BUF_SIZE > 0 */ +}; + + +/***********************************************************************/ + +#define __MASK_UNGOT (0x0002|0x0001) +#define __MASK_UNGOT1 0x0001 +#define __MASK_UNGOT2 0x0002 +#define __FLAG_EOF 0x0004 /* EOF reached? */ +#define __FLAG_ERROR 0x0008 /* stream in error state? */ +#define __FLAG_WRITEONLY 0x0010 /* unreadable */ +#define __FLAG_READONLY 0x0020 /* unwriteable */ +#define __FLAG_FREEFILE 0x0040 /* free FILE struct after use */ +#define __FLAG_NARROW 0x0080 + +#define __FLAG_FBF 0 /* convenience value */ +#define __FLAG_LBF 0x0100 +#define __FLAG_NBF 0x0200 +#define __MASK_BUFMODE 0x0300 + +#define __FLAG_APPEND 0x0400 +#define __FLAG_WIDE 0x0800 + +#define __FLAG_READING 0x1000 +#define __FLAG_WRITING 0x2000 + +#define __FLAG_FREEBUF 0x4000 /* free buffer after use */ +#define __FLAG_LARGEFILE 0x8000 + +/**********************************************************************/ + +#ifdef __STDIO_GLIBC_CUSTOM_STREAMS +extern __ssize_t _cs_read(void *cookie, char *buf, size_t bufsize); +extern __ssize_t _cs_write(void *cookie, const char *buf, size_t bufsize); +extern int _cs_seek(void *cookie, __offmax_t *pos, int whence); +extern int _cs_close(void *cookie); +#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */ + +/**********************************************************************/ + +/* TODO -- thread safety issues */ +#define __CLEARERR(stream) \ + ((stream)->modeflags &= ~(__FLAG_EOF|__FLAG_ERROR), (void)0) +#define __FEOF(stream) ((stream)->modeflags & __FLAG_EOF) +#define __FERROR(stream) ((stream)->modeflags & __FLAG_ERROR) + +#define __FEOF_OR_FERROR(stream) \ + ((stream)->modeflags & (__FLAG_EOF|__FLAG_ERROR)) + + +/* TODO: check this + * If we want to implement the getc and putc macros, we need to take + * into account wide streams. So... would need two additional variables + * if we have wide streams (bufread and bufwrite), and one otherwise + * (bufwrite). getc would be effective for FBF streams. It isn't for + * LBF streams because other LBF streams need to be flushed. putc + * thouch is only effective for FBF streams. Of course, to support + * threads, we have to use functions. + */ + +#ifdef __STDIO_GETC_MACRO +#define __GETC(stream) ( ((stream)->bufrpos < (stream)->bufgetc) \ + ? (*(stream)->bufrpos++) \ + : fgetc_unlocked(stream) ) +#else /* __STDIO_GETC_MACRO */ +#define __GETC(stream) fgetc_unlocked(stream) +#endif /* __STDIO_GETC_MACRO */ + +#ifdef __STDIO_PUTC_MACRO +#define __PUTC(c, stream) ( ((stream)->bufwpos < (stream)->bufputc) \ + ? (*(stream)->bufwpos++) = (c) \ + : fputc_unlocked((c),(stream)) ) +#else /* __STDIO_PUTC_MACRO */ +#define __PUTC(c, stream) fputc_unlocked(c, stream); +#endif /* __STDIO_PUTC_MACRO */ + + +#if 0 +/* TODO: disabled for now */ +/* Masking macros for the above _are_ allowed by the standard. */ +#define clearerr(stream) __CLEARERR(stream) +#define feof(stream) __FEOF(stream) +#define ferror(stream) __FERROR(stream) +#endif + +#if 0 +/* TODO -- what about custom streams!!! */ +/* Only use the macro below if you know fp is a valid FILE for a valid fd. */ +#define __fileno(fp) ((fp)->filedes) +#endif + +/********************************************************************** + * PROTOTYPES OF INTERNAL FUNCTIONS + **********************************************************************/ + +extern FILE *_stdio_openlist; + +#ifdef __STDIO_THREADSAFE +extern pthread_mutex_t _stdio_openlist_lock; +extern void __stdio_init_mutex(pthread_mutex_t *m); +#endif + +extern int _stdio_adjpos(FILE * __restrict stream, __offmax_t * pos); +extern int _stdio_lseek(FILE *stream, __offmax_t *pos, int whence); +/* TODO: beware of signals with _stdio_fwrite!!!! */ +extern size_t _stdio_fwrite(const unsigned char *buffer, size_t bytes, + FILE *stream); +extern size_t _stdio_fread(unsigned char *buffer, size_t bytes, + FILE *stream); + +extern FILE *_stdio_fopen(const char * __restrict filename, + const char * __restrict mode, + FILE * __restrict stream, int filedes); + +extern FILE *_stdio_fsfopen(const char * __restrict filename, + const char * __restrict mode, + register FILE * __restrict stream); + +extern void _stdio_init(void); +extern void _stdio_term(void); + +#ifndef NDEBUG +extern void __stdio_validate_FILE(FILE *stream); +#else +#define __stdio_validate_FILE(stream) ((void)0) +#endif + +/********************************************************************** + * UTILITY functions + **********************************************************************/ +#ifdef _STDIO_UTILITY + +#include +#include +#include + +#if UINTMAX_MAX <= 4294967295UL +#define __UIM_BUFLEN 12 /* 10 digits + 1 nul + 1 sign */ +#elif UINTMAX_MAX <= 18446744073709551615ULL +#define __UIM_BUFLEN 22 /* 20 digits + 1 nul + 1 sign */ +#else +#error unknown number of digits for intmax_t! +#endif + +#ifdef ULLONG_MAX /* --------------- */ +#if ULLONG_MAX <= 4294967295UL +#define __UIM_BUFLEN_LLONG 12 /* 10 digits + 1 nul + 1 sign */ +#elif ULLONG_MAX <= 18446744073709551615ULL +#define __UIM_BUFLEN_LLONG 22 /* 20 digits + 1 nul + 1 sign */ +#else +#error unknown number of digits for long long! +#endif +#endif /* ULLONG_MAX ----------------------------- */ + +#if ULONG_MAX <= 4294967295UL +#define __UIM_BUFLEN_LONG 12 /* 10 digits + 1 nul + 1 sign */ +#elif ULONG_MAX <= 18446744073709551615ULL +#define __UIM_BUFLEN_LONG 22 /* 20 digits + 1 nul + 1 sign */ +#else +#error unknown number of digits for long! +#endif + +#if UINT_MAX <= 65536U +#define __UIM_BUFLEN_INT 7 /* 10 digits + 1 nul + 1 sign */ +#elif UINT_MAX <= 4294967295UL +#define __UIM_BUFLEN_INT 12 /* 10 digits + 1 nul + 1 sign */ +#else +#error unknown number of digits for int! +#endif + +typedef enum { + __UIM_DECIMAL = 0, + __UIM_LOWER = 'a' - 10, + __UIM_UPPER = 'A' - 10, +} __UIM_CASE; + +/* Write a NULL-terminated list of "char *" args to file descriptor fd. + * For an example of usage, see __assert.c. + */ +extern void _stdio_fdout(int fd, ...); + +/* Convert the int val to a string in base abs(base). val is treated as + * an unsigned ??? int type if base > 0, and signed if base < 0. This + * is an internal function with _no_ error checking done unless assert()s + * are enabled. + * + * Note: bufend is a pointer to the END of the buffer passed. + * Call like this: + * char buf[SIZE], *p; + * p = _xltostr(buf + sizeof(buf) - 1, {unsigned int}, 10, __UIM_DECIMAL) + * p = _xltostr(buf + sizeof(buf) - 1, {int}, -10, __UIM_DECIMAL) + * + * WARNING: If base > 10, case _must_be_ either __UIM_LOWER or __UIM_UPPER + * for lower and upper case alphas respectively. + * WARNING: If val is really a signed type, make sure base is negative! + * Otherwise, you could overflow your buffer. + */ +extern char *_uintmaxtostr(char * __restrict bufend, uintmax_t uval, + int base, __UIM_CASE alphacase); + +/* TODO -- make this either a (possibly inline) function? */ +#ifndef __BCC__ +#define _int10tostr(bufend, intval) \ + _uintmaxtostr((bufend), (intval), -10, __UIM_DECIMAL) +#else /* bcc doesn't do prototypes, we need to explicitly cast */ +#define _int10tostr(bufend, intval) \ + _uintmaxtostr((bufend), (uintmax_t)(intval), -10, __UIM_DECIMAL) +#endif + +#define __BUFLEN_INT10TOSTR __UIM_BUFLEN_INT + +#endif /* _STDIO_UTILITY */ +/**********************************************************************/ +/* uClibc translations */ +/**********************************************************************/ + +/* TODO: note done above.. typedef struct __stdio_file_struct _UC_FILE; */ +typedef __stdio_fpos_t _UC_fpos_t; +typedef __stdio_fpos64_t _UC_fpos64_t; + +#define _UC_IOFBF _STDIO_IOFBF /* Fully buffered. */ +#define _UC_IOLBF _STDIO_IOLBF /* Line buffered. */ +#define _UC_IONBF _STDIO_IONBF /* No buffering. */ + +#define _UC_BUFSIZ _STDIO_BUFSIZ -- cgit v1.2.3