Swap in the new stdio code.

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
-