diff options
Diffstat (limited to 'libc/stdio')
| -rw-r--r-- | libc/stdio/Makefile | 75 | ||||
| -rw-r--r-- | libc/stdio/getw.c | 36 | ||||
| -rw-r--r-- | libc/stdio/old_vfprintf.c (renamed from libc/stdio/printf.c) | 376 | ||||
| -rw-r--r-- | libc/stdio/perror.c | 27 | ||||
| -rw-r--r-- | libc/stdio/putw.c | 34 | ||||
| -rw-r--r-- | libc/stdio/remove.c | 23 | ||||
| -rw-r--r-- | libc/stdio/scanf.c | 83 | ||||
| -rw-r--r-- | libc/stdio/stdio.c | 1117 |
8 files changed, 199 insertions, 1572 deletions
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 <stdio.h> - -#ifdef USE_IN_LIBIO -# include <libio/iolibio.h> -# 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/printf.c b/libc/stdio/old_vfprintf.c index 2940e44be..c7c07f34a 100644 --- a/libc/stdio/printf.c +++ b/libc/stdio/old_vfprintf.c @@ -97,7 +97,6 @@ /* These are now set in uClibc_config.h based on Config. */ /* -#define __UCLIBC_HAS_LONG_LONG__ 1 #define __UCLIBC_HAS_FLOATS__ 1 */ @@ -109,7 +108,6 @@ * to the base code size of 1163 on i386. */ -#define WANT_LONG_LONG_ERROR 0 #define WANT_FLOAT_ERROR 0 /* @@ -123,200 +121,29 @@ /**************************************************************************/ -#include <sys/types.h> -#include <fcntl.h> -#include <string.h> -#include <stdlib.h> +#define _GNU_SOURCE /* for strnlen */ +#define _STDIO_UTILITY +#include <stdio.h> +#include <stdarg.h> #include <limits.h> -#include <assert.h> - -#if WANT_GNU_ERRNO +#include <string.h> #include <errno.h> -#endif -#ifdef __STDC__ -#include <stdarg.h> -#define va_strt va_start -#else -#include <varargs.h> -#define va_strt(p,i) va_start(p) -#endif +#define __PRINTF_INFO_NO_BITFIELD +#include <printf.h> -#include "stdio.h" +#ifdef __STDIO_THREADSAFE +#include <pthread.h> +#endif /* __STDIO_THREADSAFE */ -extern int vfnprintf(FILE * op, size_t max_size, - register __const char *fmt, register va_list ap); +/* #undef __UCLIBC_HAS_FLOATS__ */ +/* #undef WANT_FLOAT_ERROR */ +/* #define WANT_FLOAT_ERROR 1 */ -#ifdef L_printf -int printf(const char *fmt, ...) -{ - va_list ptr; - int rv; +#define __isdigit(c) (((unsigned int)(c - '0')) < 10) - va_strt(ptr, fmt); - rv = vfnprintf(stdout, -1, fmt, ptr); - va_end(ptr); - return rv; -} -#endif +extern size_t _dtostr(FILE * fp, long double x, struct printf_info *info); -#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, @@ -329,15 +156,7 @@ enum { /* 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[] = "<LONG-LONG>"; -#endif #if !defined(__UCLIBC_HAS_FLOATS__) && WANT_FLOAT_ERROR static const char dbl_err[] = "<DOUBLE>"; @@ -355,27 +174,21 @@ static const char u_spec[] = "%nbopxXudics"; /* 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 vfprintf(FILE * __restrict op, register const char * __restrict 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 tmp[65]; /* TODO - determing needed size from headers */ char flag[sizeof(spec)]; - cnt = 0; + __STDIO_THREADLOCK(op); - /* This speeds things up a bit for line unbuffered */ - buffer_mode = (op->mode & __MODE_BUF); - op->mode &= (~__MODE_BUF); + cnt = 0; while (*fmt) { if (*fmt == '%') { @@ -391,8 +204,6 @@ int vfnprintf(FILE * op, size_t max_size, const char *fmt, va_list ap) 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'; @@ -446,13 +257,11 @@ int vfnprintf(FILE * op, size_t max_size, const char *fmt, va_list ap) for (p = (char *) qual ; *p ; p++) { if (*p == *fmt) { lval = p - qual; - ++fmt; -#if defined(__UCLIBC_HAS_LONG_LONG__) || WANT_LONG_LONG_ERROR + ++fmt; /* TODO - hh */ if ((*p == 'l') && (*fmt == *p)) { ++lval; ++fmt; } -#endif /* defined(__UCLIBC_HAS_LONG_LONG__) || WANT_LONG_LONG_ERROR */ } } @@ -477,40 +286,20 @@ int vfnprintf(FILE * op, size_t max_size, const char *fmt, va_list ap) } if (p-u_spec < 8) { /* unsigned conversion */ radix = u_radix[p-u_spec-2]; - upcase = ((int)'x') - *p; + upcase = ((*p == 'x') ? __UIM_LOWER : __UIM_UPPER); if (*p == 'p') { lval = (sizeof(char *) == sizeof(long)); - upcase = 0; + upcase = __UIM_LOWER; 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), + + 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); -#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]) { @@ -531,31 +320,14 @@ int vfnprintf(FILE * op, size_t max_size, const char *fmt, va_list ap) 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 */ + + 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] = ' '; @@ -569,21 +341,44 @@ int vfnprintf(FILE * op, size_t max_size, const char *fmt, va_list ap) 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; } - 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); + 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) @@ -597,7 +392,8 @@ int vfnprintf(FILE * op, size_t max_size, const char *fmt, va_list ap) #endif { /* this used to be printfield */ /* cheaper than strlen call */ - for ( len = 0 ; p[len] ; len++ ) { } +/* for ( len = 0 ; p[len] ; len++ ) { } */ + len = strnlen(p, SIZE_MAX); print_len_set: if ((*p == '-') #if WANT_GNU_ERRNO @@ -671,13 +467,8 @@ int vfnprintf(FILE * op, size_t max_size, const char *fmt, va_list ap) ch = *p++; /* main field */ --len; } - - if (++cnt < max_size) { - putc(ch, op); - } - if ((ch == '\n') && (buffer_mode == _IOLBF)) { - fflush(op); - } + ++cnt; + putc(ch, op); } } goto nextfmt; @@ -686,28 +477,17 @@ int vfnprintf(FILE * op, size_t max_size, const char *fmt, va_list ap) 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); - } + charout: + ++cnt; + putc(*fmt, op); /* normal char out */ nextfmt: ++fmt; } - op->mode |= buffer_mode; - if (buffer_mode == _IOLBF) { - op->bufwrite = op->bufpos; - } + i = (__FERROR(op)) ? -1 : cnt; - if (ferror(op)) { - cnt = -1; - } - return (cnt); -} - -#endif + __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 <string.h> -#include <stdio.h> -#include <errno.h> - -/* - * 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/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 <stdio.h> - -#ifdef USE_IN_LIBIO -# include <libio/iolibio.h> -# 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 <rdebath@cix.compulink.co.uk> - * This file is part of the Linux-8086 C library and is distributed - * under the GNU Library General Public License. - */ -#include <unistd.h> -#include <string.h> -#include <sys/types.h> -#include <errno.h> - -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 <stdlib.h> -#include <unistd.h> +#define _GNU_SOURCE +#include <features.h> +#if defined(__UCLIBC__) && !defined(__USE_ISOC99) #define __USE_ISOC99 +#endif + +#define _STDIO_UTILITY #include <stdio.h> +#include <stdlib.h> +#include <unistd.h> #include <ctype.h> #include <string.h> #include <stdarg.h> +#ifdef __STDIO_THREADSAFE +#include <pthread.h> +#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 <rdebath@cix.compulink.co.uk> - * 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 <stdlib.h> -#include <stdio.h> -#include <unistd.h> -#include <fcntl.h> -#include <sys/types.h> -#include <malloc.h> -#include <errno.h> -#include <string.h> -#include <assert.h> -#include <limits.h> - -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 - |