import newlib-2000-02-17 snapshot

67 files changed, 9220 insertions, 0 deletions

diff --git a/newlib/libc/stdio/Makefile.am b/newlib/libc/stdio/Makefile.am
new file mode 100644
index 000000000..234da49b6
--- /dev/null
+++ b/newlib/libc/stdio/Makefile.am
@@ -0,0 +1,161 @@
+## Process this file with automake to generate Makefile.in
+
+AUTOMAKE_OPTIONS = cygnus
+
+INCLUDES = $(NEWLIB_CFLAGS) $(CROSS_CFLAGS) $(TARGET_CFLAGS)
+
+noinst_LIBRARIES = lib.a
+
+lib_a_SOURCES = \
+	clearerr.c 			\
+	fclose.c 			\
+	fdopen.c 			\
+	feof.c 				\
+	ferror.c 			\
+	fflush.c 			\
+	fgetc.c 			\
+	fgetpos.c 			\
+	fgets.c 			\
+	fileno.c			\
+	findfp.c 			\
+	fiprintf.c 			\
+	flags.c 			\
+	fopen.c 			\
+	fprintf.c 			\
+	fputc.c 			\
+	fputs.c 			\
+	fread.c 			\
+	freopen.c 			\
+	fscanf.c 			\
+	fseek.c 			\
+	fsetpos.c 			\
+	ftell.c 			\
+	fvwrite.c 			\
+	fwalk.c 			\
+	fwrite.c 			\
+	getc.c 				\
+	getchar.c 			\
+	gets.c 				\
+	iprintf.c 			\
+	makebuf.c			\
+	mktemp.c 			\
+	perror.c 			\
+	printf.c 			\
+	putc.c 				\
+	putchar.c 			\
+	puts.c 				\
+	refill.c 			\
+	remove.c 			\
+	rename.c 			\
+	rewind.c 			\
+	rget.c 				\
+	scanf.c 			\
+	setbuf.c 			\
+	setvbuf.c 			\
+	siprintf.c 			\
+	snprintf.c			\
+	sprintf.c 			\
+	sscanf.c 			\
+	stdio.c 			\
+	tmpfile.c 			\
+	tmpnam.c 			\
+	ungetc.c 			\
+	vfprintf.c 			\
+	vfscanf.c 			\
+	vprintf.c 			\
+	vsnprintf.c			\
+	vsprintf.c 			\
+	wbuf.c 				\
+	wsetup.c 
+
+lib_a_LIBADD = vfiprintf.o
+
+vfiprintf.o: vfprintf.c
+	$(COMPILE) -DINTEGER_ONLY -c $(srcdir)/vfprintf.c -o $@
+
+CHEWOUT_FILES = \
+	clearerr.def		\
+	fclose.def		\
+	fdopen.def		\
+	feof.def		\
+	ferror.def		\
+	fflush.def		\
+	fgetc.def		\
+	fgetpos.def		\
+	fgets.def		\
+	fileno.def		\
+	fiprintf.def		\
+	fopen.def		\
+	fputc.def		\
+	fputs.def		\
+	fread.def		\
+	freopen.def		\
+	fseek.def		\
+	fsetpos.def		\
+	ftell.def		\
+	fwrite.def		\
+	getc.def		\
+	getchar.def		\
+	gets.def		\
+	iprintf.def		\
+	mktemp.def		\
+	perror.def		\
+	putc.def		\
+	putchar.def		\
+	puts.def		\
+	remove.def		\
+	rename.def		\
+	rewind.def		\
+	setbuf.def		\
+	setvbuf.def		\
+	siprintf.def		\
+	sprintf.def		\
+	sscanf.def		\
+	tmpfile.def		\
+	tmpnam.def		\
+	vfprintf.def
+
+SUFFIXES = .def
+
+CHEW = ../../doc/makedoc -f $(srcdir)/../../doc/doc.str
+
+.c.def:
+	$(CHEW) < $< > $*.def 2> $*.ref
+	touch stmp-def
+
+TARGETDOC = ../tmp.texi
+
+doc: $(CHEWOUT_FILES)
+	cat $(srcdir)/stdio.tex >> $(TARGETDOC)
+
+CLEANFILES = $(CHEWOUT_FILES) *.ref
+
+fclose.o: local.h
+fdopen.o: local.h
+fflush.o: local.h
+findfp.o: local.h
+fopen.o: local.h
+fputs.o: fvwrite.h
+fread.o: local.h
+freopen.o: local.h
+fseek.o: local.h
+ftell.o: local.h
+fvwrite.o: local.h fvwrite.h
+fwalk.o: local.h
+fwrite.o: local.h fvwrite.h
+makebuf.o: local.h
+puts.o: fvwrite.h
+refill.o: local.h
+scanf.o: local.h
+setbuf.o: local.h
+setvbuf.o: local.h
+siprintf.o: local.h
+sprintf.o: local.h
+sscanf.o: local.h
+stdio.o: local.h
+ungetc.o: local.h
+vfiprintf.o: local.h
+vfprintf.o: local.h
+vfscanf.o: local.h floatio.h
+wbuf.o: local.h fvwrite.h
+wsetup.o: local.h
diff --git a/newlib/libc/stdio/Makefile.in b/newlib/libc/stdio/Makefile.in
new file mode 100644
index 000000000..ff2a83845
--- /dev/null
+++ b/newlib/libc/stdio/Makefile.in
@@ -0,0 +1,441 @@
+# Makefile.in generated automatically by automake 1.4 from Makefile.am
+
+# Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+
+SHELL = @SHELL@
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+VPATH = @srcdir@
+prefix = @prefix@
+exec_prefix = @exec_prefix@
+
+bindir = @bindir@
+sbindir = @sbindir@
+libexecdir = @libexecdir@
+datadir = @datadir@
+sysconfdir = @sysconfdir@
+sharedstatedir = @sharedstatedir@
+localstatedir = @localstatedir@
+libdir = @libdir@
+infodir = @infodir@
+mandir = @mandir@
+includedir = @includedir@
+oldincludedir = /usr/include
+
+DESTDIR =
+
+pkgdatadir = $(datadir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+
+top_builddir = ..
+
+ACLOCAL = @ACLOCAL@
+AUTOCONF = @AUTOCONF@
+AUTOMAKE = @AUTOMAKE@
+AUTOHEADER = @AUTOHEADER@
+
+INSTALL = @INSTALL@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@ $(AM_INSTALL_PROGRAM_FLAGS)
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+transform = @program_transform_name@
+
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+host_alias = @host_alias@
+host_triplet = @host@
+AR = @AR@
+AS = @AS@
+CC = @CC@
+CPP = @CPP@
+CRT0 = @CRT0@
+EXEEXT = @EXEEXT@
+LIBC_MACHINE_LIB = @LIBC_MACHINE_LIB@
+LIBC_POSIX_LIB = @LIBC_POSIX_LIB@
+LIBC_SIGNAL_DEF = @LIBC_SIGNAL_DEF@
+LIBC_SIGNAL_LIB = @LIBC_SIGNAL_LIB@
+LIBC_SYSCALL_LIB = @LIBC_SYSCALL_LIB@
+LIBC_SYS_LIB = @LIBC_SYS_LIB@
+LIBC_UNIX_LIB = @LIBC_UNIX_LIB@
+MAINT = @MAINT@
+MAKEINFO = @MAKEINFO@
+NEWLIB_CFLAGS = @NEWLIB_CFLAGS@
+PACKAGE = @PACKAGE@
+RANLIB = @RANLIB@
+VERSION = @VERSION@
+machine_dir = @machine_dir@
+newlib_basedir = @newlib_basedir@
+sys_dir = @sys_dir@
+
+AUTOMAKE_OPTIONS = cygnus
+
+INCLUDES = $(NEWLIB_CFLAGS) $(CROSS_CFLAGS) $(TARGET_CFLAGS)
+
+noinst_LIBRARIES = lib.a
+
+lib_a_SOURCES = \
+	clearerr.c 			\
+	fclose.c 			\
+	fdopen.c 			\
+	feof.c 				\
+	ferror.c 			\
+	fflush.c 			\
+	fgetc.c 			\
+	fgetpos.c 			\
+	fgets.c 			\
+	fileno.c			\
+	findfp.c 			\
+	fiprintf.c 			\
+	flags.c 			\
+	fopen.c 			\
+	fprintf.c 			\
+	fputc.c 			\
+	fputs.c 			\
+	fread.c 			\
+	freopen.c 			\
+	fscanf.c 			\
+	fseek.c 			\
+	fsetpos.c 			\
+	ftell.c 			\
+	fvwrite.c 			\
+	fwalk.c 			\
+	fwrite.c 			\
+	getc.c 				\
+	getchar.c 			\
+	gets.c 				\
+	iprintf.c 			\
+	makebuf.c			\
+	mktemp.c 			\
+	perror.c 			\
+	printf.c 			\
+	putc.c 				\
+	putchar.c 			\
+	puts.c 				\
+	refill.c 			\
+	remove.c 			\
+	rename.c 			\
+	rewind.c 			\
+	rget.c 				\
+	scanf.c 			\
+	setbuf.c 			\
+	setvbuf.c 			\
+	siprintf.c 			\
+	snprintf.c			\
+	sprintf.c 			\
+	sscanf.c 			\
+	stdio.c 			\
+	tmpfile.c 			\
+	tmpnam.c 			\
+	ungetc.c 			\
+	vfprintf.c 			\
+	vfscanf.c 			\
+	vprintf.c 			\
+	vsnprintf.c			\
+	vsprintf.c 			\
+	wbuf.c 				\
+	wsetup.c 
+
+
+lib_a_LIBADD = vfiprintf.o
+
+CHEWOUT_FILES = \
+	clearerr.def		\
+	fclose.def		\
+	fdopen.def		\
+	feof.def		\
+	ferror.def		\
+	fflush.def		\
+	fgetc.def		\
+	fgetpos.def		\
+	fgets.def		\
+	fileno.def		\
+	fiprintf.def		\
+	fopen.def		\
+	fputc.def		\
+	fputs.def		\
+	fread.def		\
+	freopen.def		\
+	fseek.def		\
+	fsetpos.def		\
+	ftell.def		\
+	fwrite.def		\
+	getc.def		\
+	getchar.def		\
+	gets.def		\
+	iprintf.def		\
+	mktemp.def		\
+	perror.def		\
+	putc.def		\
+	putchar.def		\
+	puts.def		\
+	remove.def		\
+	rename.def		\
+	rewind.def		\
+	setbuf.def		\
+	setvbuf.def		\
+	siprintf.def		\
+	sprintf.def		\
+	sscanf.def		\
+	tmpfile.def		\
+	tmpnam.def		\
+	vfprintf.def
+
+
+SUFFIXES = .def
+
+CHEW = ../../doc/makedoc -f $(srcdir)/../../doc/doc.str
+
+TARGETDOC = ../tmp.texi
+
+CLEANFILES = $(CHEWOUT_FILES) *.ref
+mkinstalldirs = $(SHELL) $(top_srcdir)/../../mkinstalldirs
+CONFIG_CLEAN_FILES = 
+LIBRARIES =  $(noinst_LIBRARIES)
+
+
+DEFS = @DEFS@ -I. -I$(srcdir) 
+CPPFLAGS = @CPPFLAGS@
+LDFLAGS = @LDFLAGS@
+LIBS = @LIBS@
+lib_a_DEPENDENCIES =  vfiprintf.o
+lib_a_OBJECTS =  clearerr.o fclose.o fdopen.o feof.o ferror.o fflush.o \
+fgetc.o fgetpos.o fgets.o fileno.o findfp.o fiprintf.o flags.o fopen.o \
+fprintf.o fputc.o fputs.o fread.o freopen.o fscanf.o fseek.o fsetpos.o \
+ftell.o fvwrite.o fwalk.o fwrite.o getc.o getchar.o gets.o iprintf.o \
+makebuf.o mktemp.o perror.o printf.o putc.o putchar.o puts.o refill.o \
+remove.o rename.o rewind.o rget.o scanf.o setbuf.o setvbuf.o siprintf.o \
+snprintf.o sprintf.o sscanf.o stdio.o tmpfile.o tmpnam.o ungetc.o \
+vfprintf.o vfscanf.o vprintf.o vsnprintf.o vsprintf.o wbuf.o wsetup.o
+CFLAGS = @CFLAGS@
+COMPILE = $(CC) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+CCLD = $(CC)
+LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(LDFLAGS) -o $@
+DIST_COMMON =  Makefile.am Makefile.in
+
+
+DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST)
+
+TAR = tar
+GZIP_ENV = --best
+SOURCES = $(lib_a_SOURCES)
+OBJECTS = $(lib_a_OBJECTS)
+
+all: all-redirect
+.SUFFIXES:
+.SUFFIXES: .S .c .def .o .s
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ Makefile.am $(top_srcdir)/configure.in $(ACLOCAL_M4) 
+	cd $(top_srcdir) && $(AUTOMAKE) --cygnus stdio/Makefile
+
+Makefile: $(srcdir)/Makefile.in  $(top_builddir)/config.status
+	cd $(top_builddir) \
+	  && CONFIG_FILES=$(subdir)/$@ CONFIG_HEADERS= $(SHELL) ./config.status
+
+
+mostlyclean-noinstLIBRARIES:
+
+clean-noinstLIBRARIES:
+	-test -z "$(noinst_LIBRARIES)" || rm -f $(noinst_LIBRARIES)
+
+distclean-noinstLIBRARIES:
+
+maintainer-clean-noinstLIBRARIES:
+
+.c.o:
+	$(COMPILE) -c $<
+
+.s.o:
+	$(COMPILE) -c $<
+
+.S.o:
+	$(COMPILE) -c $<
+
+mostlyclean-compile:
+	-rm -f *.o core *.core
+
+clean-compile:
+
+distclean-compile:
+	-rm -f *.tab.c
+
+maintainer-clean-compile:
+
+lib.a: $(lib_a_OBJECTS) $(lib_a_DEPENDENCIES)
+	-rm -f lib.a
+	$(AR) cru lib.a $(lib_a_OBJECTS) $(lib_a_LIBADD)
+	$(RANLIB) lib.a
+
+tags: TAGS
+
+ID: $(HEADERS) $(SOURCES) $(LISP)
+	list='$(SOURCES) $(HEADERS)'; \
+	unique=`for i in $$list; do echo $$i; done | \
+	  awk '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	here=`pwd` && cd $(srcdir) \
+	  && mkid -f$$here/ID $$unique $(LISP)
+
+TAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) $(LISP)
+	tags=; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)'; \
+	unique=`for i in $$list; do echo $$i; done | \
+	  awk '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	test -z "$(ETAGS_ARGS)$$unique$(LISP)$$tags" \
+	  || (cd $(srcdir) && etags $(ETAGS_ARGS) $$tags  $$unique $(LISP) -o $$here/TAGS)
+
+mostlyclean-tags:
+
+clean-tags:
+
+distclean-tags:
+	-rm -f TAGS ID
+
+maintainer-clean-tags:
+
+distdir = $(top_builddir)/$(PACKAGE)-$(VERSION)/$(subdir)
+
+subdir = stdio
+
+distdir: $(DISTFILES)
+	@for file in $(DISTFILES); do \
+	  if test -f $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    cp -pr $$/$$file $(distdir)/$$file; \
+	  else \
+	    test -f $(distdir)/$$file \
+	    || ln $$d/$$file $(distdir)/$$file 2> /dev/null \
+	    || cp -p $$d/$$file $(distdir)/$$file || :; \
+	  fi; \
+	done
+info-am:
+info: info-am
+dvi-am:
+dvi: dvi-am
+check-am:
+check: check-am
+installcheck-am:
+installcheck: installcheck-am
+install-info-am: 
+install-info: install-info-am
+install-exec-am:
+install-exec: install-exec-am
+
+install-data-am:
+install-data: install-data-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+install: install-am
+uninstall-am:
+uninstall: uninstall-am
+all-am: Makefile $(LIBRARIES)
+all-redirect: all-am
+install-strip:
+	$(MAKE) $(AM_MAKEFLAGS) AM_INSTALL_PROGRAM_FLAGS=-s install
+installdirs:
+
+
+mostlyclean-generic:
+
+clean-generic:
+	-test -z "$(CLEANFILES)" || rm -f $(CLEANFILES)
+
+distclean-generic:
+	-rm -f Makefile $(CONFIG_CLEAN_FILES)
+	-rm -f config.cache config.log stamp-h stamp-h[0-9]*
+
+maintainer-clean-generic:
+mostlyclean-am:  mostlyclean-noinstLIBRARIES mostlyclean-compile \
+		mostlyclean-tags mostlyclean-generic
+
+mostlyclean: mostlyclean-am
+
+clean-am:  clean-noinstLIBRARIES clean-compile clean-tags clean-generic \
+		mostlyclean-am
+
+clean: clean-am
+
+distclean-am:  distclean-noinstLIBRARIES distclean-compile \
+		distclean-tags distclean-generic clean-am
+
+distclean: distclean-am
+
+maintainer-clean-am:  maintainer-clean-noinstLIBRARIES \
+		maintainer-clean-compile maintainer-clean-tags \
+		maintainer-clean-generic distclean-am
+	@echo "This command is intended for maintainers to use;"
+	@echo "it deletes files that may require special tools to rebuild."
+
+maintainer-clean: maintainer-clean-am
+
+.PHONY: mostlyclean-noinstLIBRARIES distclean-noinstLIBRARIES \
+clean-noinstLIBRARIES maintainer-clean-noinstLIBRARIES \
+mostlyclean-compile distclean-compile clean-compile \
+maintainer-clean-compile tags mostlyclean-tags distclean-tags \
+clean-tags maintainer-clean-tags distdir info-am info dvi-am dvi check \
+check-am installcheck-am installcheck install-info-am install-info \
+install-exec-am install-exec install-data-am install-data install-am \
+install uninstall-am uninstall all-redirect all-am all installdirs \
+mostlyclean-generic distclean-generic clean-generic \
+maintainer-clean-generic clean mostlyclean distclean maintainer-clean
+
+
+vfiprintf.o: vfprintf.c
+	$(COMPILE) -DINTEGER_ONLY -c $(srcdir)/vfprintf.c -o $@
+
+.c.def:
+	$(CHEW) < $< > $*.def 2> $*.ref
+	touch stmp-def
+
+doc: $(CHEWOUT_FILES)
+	cat $(srcdir)/stdio.tex >> $(TARGETDOC)
+
+fclose.o: local.h
+fdopen.o: local.h
+fflush.o: local.h
+findfp.o: local.h
+fopen.o: local.h
+fputs.o: fvwrite.h
+fread.o: local.h
+freopen.o: local.h
+fseek.o: local.h
+ftell.o: local.h
+fvwrite.o: local.h fvwrite.h
+fwalk.o: local.h
+fwrite.o: local.h fvwrite.h
+makebuf.o: local.h
+puts.o: fvwrite.h
+refill.o: local.h
+scanf.o: local.h
+setbuf.o: local.h
+setvbuf.o: local.h
+siprintf.o: local.h
+sprintf.o: local.h
+sscanf.o: local.h
+stdio.o: local.h
+ungetc.o: local.h
+vfiprintf.o: local.h
+vfprintf.o: local.h
+vfscanf.o: local.h floatio.h
+wbuf.o: local.h fvwrite.h
+wsetup.o: local.h
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/newlib/libc/stdio/clearerr.c b/newlib/libc/stdio/clearerr.c
new file mode 100644
index 000000000..861d9a211
--- /dev/null
+++ b/newlib/libc/stdio/clearerr.c
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+/*
+FUNCTION
+<<clearerr>>---clear file or stream error indicator
+
+INDEX
+	clearerr
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	void clearerr(FILE *<[fp]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	void clearerr(<[fp]>)
+	FILE *<[fp]>;
+
+DESCRIPTION
+The <<stdio>> functions maintain an error indicator with each file
+pointer <[fp]>, to record whether any read or write errors have
+occurred on the associated file or stream.  Similarly, it maintains an
+end-of-file indicator to record whether there is no more data in the
+file.
+
+Use <<clearerr>> to reset both of these indicators.
+
+See <<ferror>> and <<feof>> to query the two indicators.
+
+
+RETURNS
+<<clearerr>> does not return a result.
+
+PORTABILITY
+ANSI C requires <<clearerr>>.
+
+No supporting OS subroutines are required.
+*/
+
+#include <stdio.h>
+#undef	clearerr
+
+_VOID
+_DEFUN (clearerr, (fp),
+	FILE * fp)
+{
+  __sclearerr (fp);
+}
diff --git a/newlib/libc/stdio/fclose.c b/newlib/libc/stdio/fclose.c
new file mode 100644
index 000000000..3266d8a55
--- /dev/null
+++ b/newlib/libc/stdio/fclose.c
@@ -0,0 +1,82 @@
+/*
+FUNCTION
+<<fclose>>---close a file
+
+INDEX
+	fclose
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	int fclose(FILE *<[fp]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	int fclose(<[fp]>)
+	FILE *<[fp]>;
+
+DESCRIPTION
+If the file or stream identified by <[fp]> is open, <<fclose>> closes
+it, after first ensuring that any pending data is written (by calling
+<<fflush(<[fp]>)>>).
+
+RETURNS
+<<fclose>> returns <<0>> if successful (including when <[fp]> is
+<<NULL>> or not an open file); otherwise, it returns <<EOF>>.
+
+PORTABILITY
+<<fclose>> is required by ANSI C.
+
+Required OS subroutines: <<close>>, <<fstat>>, <<isatty>>, <<lseek>>,
+<<read>>, <<sbrk>>, <<write>>.
+*/
+
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "local.h"
+
+/*
+ * Close a file.
+ */
+
+int
+_DEFUN (fclose, (fp),
+	register FILE * fp)
+{
+  int r;
+
+  if (fp == NULL)
+    return (0);			/* on NULL */
+
+  CHECK_INIT (fp);
+
+  if (fp->_flags == 0)		/* not open! */
+    return (0);
+  r = fp->_flags & __SWR ? fflush (fp) : 0;
+  if (fp->_close != NULL && (*fp->_close) (fp->_cookie) < 0)
+    r = EOF;
+  if (fp->_flags & __SMBF)
+    _free_r (fp->_data, (char *) fp->_bf._base);
+  if (HASUB (fp))
+    FREEUB (fp);
+  if (HASLB (fp))
+    FREELB (fp);
+  fp->_flags = 0;		/* release this FILE for reuse */
+  return (r);
+}
diff --git a/newlib/libc/stdio/fdopen.c b/newlib/libc/stdio/fdopen.c
new file mode 100644
index 000000000..50698cbf6
--- /dev/null
+++ b/newlib/libc/stdio/fdopen.c
@@ -0,0 +1,116 @@
+/*
+FUNCTION
+<<fdopen>>---turn open file into a stream
+
+INDEX
+	fdopen
+INDEX
+	_fdopen_r
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	FILE *fdopen(int <[fd]>, const char *<[mode]>);
+	FILE *_fdopen_r(void *<[reent]>,
+                     int <[fd]>, const char *<[mode]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	FILE *fdopen(<[fd]>, <[mode]>)
+	int <[fd]>;
+	char *<[mode]>;
+
+	FILE *_fdopen_r(<[reent]>, <[fd]>, <[mode]>)
+	char *<[reent]>;
+        int <[fd]>;
+	char *<[mode]>);
+
+DESCRIPTION
+<<fdopen>> produces a file descriptor of type <<FILE *>>, from a
+descriptor for an already-open file (returned, for example, by the
+system subroutine <<open>> rather than by <<fopen>>).
+The <[mode]> argument has the same meanings as in <<fopen>>.
+
+RETURNS
+File pointer or <<NULL>>, as for <<fopen>>.
+
+PORTABILITY
+<<fdopen>> is ANSI.
+*/
+
+#include <sys/types.h>
+#include <sys/fcntl.h>
+
+#include <stdio.h>
+#include <errno.h>
+#include "local.h"
+#include <_syslist.h>
+
+extern int __sflags ();
+
+FILE *
+_DEFUN (_fdopen_r, (ptr, fd, mode),
+	struct _reent *ptr _AND
+	int fd _AND
+	_CONST char *mode)
+{
+  register FILE *fp;
+  int flags, oflags;
+#ifdef F_GETFL
+  int fdflags, fdmode;
+#endif
+
+  if ((flags = __sflags (ptr, mode, &oflags)) == 0)
+    return 0;
+
+  /* make sure the mode the user wants is a subset of the actual mode */
+#ifdef F_GETFL
+  if ((fdflags = _fcntl (fd, F_GETFL, 0)) < 0)
+    return 0;
+  fdmode = fdflags & O_ACCMODE;
+  if (fdmode != O_RDWR && (fdmode != (oflags & O_ACCMODE)))
+    {
+      ptr->_errno = EBADF;
+      return 0;
+    }
+#endif
+
+  if ((fp = __sfp (ptr)) == 0)
+    return 0;
+  fp->_flags = flags;
+  /*
+   * If opened for appending, but underlying descriptor
+   * does not have O_APPEND bit set, assert __SAPP so that
+   * __swrite() will lseek to end before each write.
+   */
+  if ((oflags & O_APPEND)
+#ifdef F_GETFL
+       && !(fdflags & O_APPEND)
+#endif
+      )
+    fp->_flags |= __SAPP;
+  fp->_file = fd;
+  fp->_cookie = (_PTR) fp;
+
+#undef _read
+#undef _write
+#undef _seek
+#undef _close
+
+  fp->_read = __sread;
+  fp->_write = __swrite;
+  fp->_seek = __sseek;
+  fp->_close = __sclose;
+  return fp;
+}
+
+#ifndef _REENT_ONLY
+
+FILE *
+_DEFUN (fdopen, (fd, mode),
+	int fd _AND
+	_CONST char *mode)
+{
+  return _fdopen_r (_REENT, fd, mode);
+}
+
+#endif
diff --git a/newlib/libc/stdio/feof.c b/newlib/libc/stdio/feof.c
new file mode 100644
index 000000000..55f151bd4
--- /dev/null
+++ b/newlib/libc/stdio/feof.c
@@ -0,0 +1,40 @@
+/*
+FUNCTION
+<<feof>>---test for end of file
+
+INDEX
+	feof
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	int feof(FILE *<[fp]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	int feof(<[fp]>)
+	FILE *<[fp]>;
+
+DESCRIPTION
+<<feof>> tests whether or not the end of the file identified by <[fp]>
+has been reached.
+
+RETURNS
+<<feof>> returns <<0>> if the end of file has not yet been reached; if
+at end of file, the result is nonzero.
+
+PORTABILITY
+<<feof>> is required by ANSI C.
+
+No supporting OS subroutines are required.
+*/
+
+#include <stdio.h>
+
+#undef feof
+
+int 
+_DEFUN (feof, (fp),
+	FILE * fp)
+{
+  return __sfeof (fp);
+}
diff --git a/newlib/libc/stdio/ferror.c b/newlib/libc/stdio/ferror.c
new file mode 100644
index 000000000..19fa78d14
--- /dev/null
+++ b/newlib/libc/stdio/ferror.c
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+/*
+FUNCTION
+<<ferror>>---test whether read/write error has occurred
+
+INDEX
+	ferror
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	int ferror(FILE *<[fp]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	int ferror(<[fp]>)
+	FILE *<[fp]>;
+
+DESCRIPTION
+The <<stdio>> functions maintain an error indicator with each file
+pointer <[fp]>, to record whether any read or write errors have
+occurred on the associated file or stream.
+Use <<ferror>> to query this indicator.
+
+See <<clearerr>> to reset the error indicator.
+
+RETURNS
+<<ferror>> returns <<0>> if no errors have occurred; it returns a
+nonzero value otherwise.
+
+PORTABILITY
+ANSI C requires <<ferror>>.
+
+No supporting OS subroutines are required.
+*/
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "%W% (Berkeley) %G%";
+#endif /* LIBC_SCCS and not lint */
+
+#include <stdio.h>
+
+/* A subroutine version of the macro ferror.  */
+
+#undef ferror
+
+int
+_DEFUN (ferror, (fp),
+	FILE * fp)
+{
+  return __sferror (fp);
+}
diff --git a/newlib/libc/stdio/fflush.c b/newlib/libc/stdio/fflush.c
new file mode 100644
index 000000000..635e5a738
--- /dev/null
+++ b/newlib/libc/stdio/fflush.c
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+/*
+FUNCTION
+<<fflush>>---flush buffered file output
+
+INDEX
+	fflush
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	int fflush(FILE *<[fp]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	int fflush(<[fp]>)
+	FILE *<[fp]>;
+
+DESCRIPTION
+The <<stdio>> output functions can buffer output before delivering it
+to the host system, in order to minimize the overhead of system calls.
+
+Use <<fflush>> to deliver any such pending output (for the file
+or stream identified by <[fp]>) to the host system.
+
+If <[fp]> is <<NULL>>, <<fflush>> delivers pending output from all
+open files.
+
+RETURNS
+<<fflush>> returns <<0>> unless it encounters a write error; in that
+situation, it returns <<EOF>>.
+
+PORTABILITY
+ANSI C requires <<fflush>>.
+
+No supporting OS subroutines are required.
+*/
+
+#include <stdio.h>
+#include "local.h"
+
+/* Flush a single file, or (if fp is NULL) all files.  */
+
+int
+_DEFUN (fflush, (fp),
+	register FILE * fp)
+{
+  register unsigned char *p;
+  register int n, t;
+
+
+
+
+  if (fp == NULL)
+    return _fwalk (_REENT, fflush);
+
+  CHECK_INIT (fp);
+
+  t = fp->_flags;
+  if ((t & __SWR) == 0 || (p = fp->_bf._base) == NULL)
+    return 0;
+  n = fp->_p - p;		/* write this much */
+
+  /*
+   * Set these immediately to avoid problems with longjmp
+   * and to allow exchange buffering (via setvbuf) in user
+   * write function.
+   */
+  fp->_p = p;
+  fp->_w = t & (__SLBF | __SNBF) ? 0 : fp->_bf._size;
+
+  while (n > 0)
+    {
+      t = (*fp->_write) (fp->_cookie, (char *) p, n);
+      if (t <= 0)
+	{
+	  fp->_flags |= __SERR;
+	  return EOF;
+	}
+      p += t;
+      n -= t;
+    }
+  return 0;
+}
diff --git a/newlib/libc/stdio/fgetc.c b/newlib/libc/stdio/fgetc.c
new file mode 100644
index 000000000..3d3d2c4ed
--- /dev/null
+++ b/newlib/libc/stdio/fgetc.c
@@ -0,0 +1,46 @@
+/*
+FUNCTION
+<<fgetc>>---get a character from a file or stream
+
+INDEX
+	fgetc
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	int fgetc(FILE *<[fp]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	int fgetc(<[fp]>)
+	FILE *<[fp]>;
+
+DESCRIPTION
+Use <<fgetc>> to get the next single character from the file or stream
+identified by <[fp]>.  As a side effect, <<fgetc>> advances the file's
+current position indicator.
+
+For a macro version of this function, see <<getc>>.
+
+RETURNS
+The next character (read as an <<unsigned char>>, and cast to
+<<int>>), unless there is no more data, or the host system reports a
+read error; in either of these situations, <<fgetc>> returns <<EOF>>.
+
+You can distinguish the two situations that cause an <<EOF>> result by
+using the <<ferror>> and <<feof>> functions.
+
+PORTABILITY
+ANSI C requires <<fgetc>>.
+
+Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
+<<lseek>>, <<read>>, <<sbrk>>, <<write>>.
+*/
+
+#include <stdio.h>
+
+int
+_DEFUN (fgetc, (fp),
+	FILE * fp)
+{
+  return __sgetc (fp);
+}
diff --git a/newlib/libc/stdio/fgetpos.c b/newlib/libc/stdio/fgetpos.c
new file mode 100644
index 000000000..214021a84
--- /dev/null
+++ b/newlib/libc/stdio/fgetpos.c
@@ -0,0 +1,61 @@
+/*
+FUNCTION
+<<fgetpos>>---record position in a stream or file
+
+INDEX
+	fgetpos
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	int fgetpos(FILE *<[fp]>, fpos_t *<[pos]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	int fgetpos(<[fp]>, <[pos]>)
+	FILE *<[fp]>;
+	fpos_t *<[pos]>;
+
+DESCRIPTION
+Objects of type <<FILE>> can have a ``position'' that records how much
+of the file your program has already read.  Many of the <<stdio>> functions
+depend on this position, and many change it as a side effect.
+
+You can use <<fgetpos>> to report on the current position for a file
+identified by <[fp]>; <<fgetpos>> will write a value
+representing that position at <<*<[pos]>>>.  Later, you can
+use this value with <<fsetpos>> to return the file to this
+position.
+
+In the current implementation, <<fgetpos>> simply uses a character
+count to represent the file position; this is the same number that
+would be returned by <<ftell>>.
+
+RETURNS
+<<fgetpos>> returns <<0>> when successful.  If <<fgetpos>> fails, the
+result is <<1>>.  Failure occurs on streams that do not support
+positioning; the global <<errno>> indicates this condition with the
+value <<ESPIPE>>.
+
+PORTABILITY
+<<fgetpos>> is required by the ANSI C standard, but the meaning of the
+value it records is not specified beyond requiring that it be
+acceptable as an argument to <<fsetpos>>.  In particular, other
+conforming C implementations may return a different result from
+<<ftell>> than what <<fgetpos>> writes at <<*<[pos]>>>.
+
+No supporting OS subroutines are required.
+*/
+
+#include <stdio.h>
+
+int
+_DEFUN (fgetpos, (fp, pos),
+	FILE * fp _AND
+	fpos_t * pos)
+{
+  *pos = ftell (fp);
+
+  if (*pos != -1)
+    return 0;
+  return 1;
+}
diff --git a/newlib/libc/stdio/fgets.c b/newlib/libc/stdio/fgets.c
new file mode 100644
index 000000000..abc2bb97c
--- /dev/null
+++ b/newlib/libc/stdio/fgets.c
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+/*
+
+FUNCTION
+        <<fgets>>---get character string from a file or stream
+INDEX
+	fgets
+
+ANSI_SYNOPSIS
+        #include <stdio.h>
+	char *fgets(char *<[buf]>, int <[n]>, FILE *<[fp]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	char *fgets(<[buf]>,<[n]>,<[fp]>)
+        char *<[buf]>;
+	int <[n]>;
+	FILE *<[fp]>;
+
+DESCRIPTION
+	Reads at most <[n-1]> characters from <[fp]> until a newline
+	is found. The characters including to the newline are stored
+	in <[buf]>. The buffer is terminated with a 0.
+
+
+RETURNS
+	<<fgets>> returns the buffer passed to it, with the data
+	filled in. If end of file occurs with some data already
+	accumulated, the data is returned with no other indication. If
+	no data are read, NULL is returned instead.
+
+PORTABILITY
+	<<fgets>> should replace all uses of <<gets>>. Note however
+	that <<fgets>> returns all of the data, while <<gets>> removes
+	the trailing newline (with no indication that it has done so.)
+
+Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
+<<lseek>>, <<read>>, <<sbrk>>, <<write>>.
+*/
+
+#include <stdio.h>
+#include <string.h>
+
+extern int __srefill ();
+
+/*
+ * Read at most n-1 characters from the given file.
+ * Stop when a newline has been read, or the count runs out.
+ * Return first argument, or NULL if no characters were read.
+ */
+
+char *
+_DEFUN (fgets, (buf, n, fp),
+	char *buf _AND
+	int n _AND
+	FILE * fp)
+{
+  size_t len;
+  char *s;
+  unsigned char *p, *t;
+
+  if (n < 2)			/* sanity check */
+    return 0;
+
+  s = buf;
+  n--;				/* leave space for NUL */
+  do
+    {
+      /*
+       * If the buffer is empty, refill it.
+       */
+      if ((len = fp->_r) <= 0)
+	{
+	  if (__srefill (fp))
+	    {
+	      /* EOF: stop with partial or no line */
+	      if (s == buf)
+		return 0;
+	      break;
+	    }
+	  len = fp->_r;
+	}
+      p = fp->_p;
+
+      /*
+       * Scan through at most n bytes of the current buffer,
+       * looking for '\n'.  If found, copy up to and including
+       * newline, and stop.  Otherwise, copy entire chunk
+       * and loop.
+       */
+      if (len > n)
+	len = n;
+      t = (unsigned char *) memchr ((_PTR) p, '\n', len);
+      if (t != 0)
+	{
+	  len = ++t - p;
+	  fp->_r -= len;
+	  fp->_p = t;
+	  (void) memcpy ((_PTR) s, (_PTR) p, len);
+	  s[len] = 0;
+	  return (buf);
+	}
+      fp->_r -= len;
+      fp->_p += len;
+      (void) memcpy ((_PTR) s, (_PTR) p, len);
+      s += len;
+    }
+  while ((n -= len) != 0);
+  *s = 0;
+  return buf;
+}
diff --git a/newlib/libc/stdio/fileno.c b/newlib/libc/stdio/fileno.c
new file mode 100644
index 000000000..d578c3ede
--- /dev/null
+++ b/newlib/libc/stdio/fileno.c
@@ -0,0 +1,40 @@
+/*
+FUNCTION
+<<fileno>>---return file descriptor associated with stream
+
+INDEX
+	fileno
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	int fileno(FILE *<[fp]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	int fileno(<[fp]>)
+	FILE *<[fp]>;
+
+DESCRIPTION
+You can use <<fileno>> to return the file descriptor identified by <[fp]>.
+
+RETURNS
+<<fileno>> returns a non-negative integer when successful.
+If <[fp]> is not an open stream, <<fileno>> returns -1.
+
+PORTABILITY
+<<fileno>> is not part of ANSI C.
+POSIX requires <<fileno>>.
+
+Supporting OS subroutines required: none.
+*/
+
+#include <stdio.h>
+#include "local.h"
+
+int
+_DEFUN (fileno, (f),
+	FILE * f)
+{
+  CHECK_INIT (f);
+  return __sfileno (f);
+}
diff --git a/newlib/libc/stdio/findfp.c b/newlib/libc/stdio/findfp.c
new file mode 100644
index 000000000..650c638e6
--- /dev/null
+++ b/newlib/libc/stdio/findfp.c
@@ -0,0 +1,153 @@
+/* No user fns here.  Pesch 15apr92. */
+
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include "local.h"
+
+static void
+std (ptr, flags, file, data)
+     FILE *ptr;
+     struct _reent *data;
+{
+  ptr->_p = 0;
+  ptr->_r = 0;
+  ptr->_w = 0;
+  ptr->_flags = flags;
+  ptr->_file = file;
+  ptr->_bf._base = 0;
+  ptr->_bf._size = 0;
+  ptr->_lbfsize = 0;
+  ptr->_cookie = ptr;
+  ptr->_read = __sread;
+  ptr->_write = __swrite;
+  ptr->_seek = __sseek;
+  ptr->_close = __sclose;
+  ptr->_data = data;
+}
+
+struct _glue *
+__sfmoreglue (d, n)
+     struct _reent *d;
+     register int n;
+{
+  struct _glue *g;
+  FILE *p;
+
+  g = (struct _glue *) _malloc_r (d, sizeof (*g) + n * sizeof (FILE));
+  if (g == NULL)
+    return NULL;
+  p = (FILE *) (g + 1);
+  g->_next = NULL;
+  g->_niobs = n;
+  g->_iobs = p;
+  memset (p, 0, n * sizeof (FILE));
+  return g;
+}
+
+/*
+ * Find a free FILE for fopen et al.
+ */
+
+FILE *
+__sfp (d)
+     struct _reent *d;
+{
+  FILE *fp;
+  int n;
+  struct _glue *g;
+
+  if (!d->__sdidinit)
+    __sinit (d);
+  for (g = &d->__sglue;; g = g->_next)
+    {
+      for (fp = g->_iobs, n = g->_niobs; --n >= 0; fp++)
+	if (fp->_flags == 0)
+	  goto found;
+      if (g->_next == NULL &&
+	  (g->_next = __sfmoreglue (d, NDYNAMIC)) == NULL)
+	break;
+    }
+  d->_errno = ENOMEM;
+  return NULL;
+
+found:
+  fp->_flags = 1;		/* reserve this slot; caller sets real flags */
+  fp->_p = NULL;		/* no current pointer */
+  fp->_w = 0;			/* nothing to read or write */
+  fp->_r = 0;
+  fp->_bf._base = NULL;		/* no buffer */
+  fp->_bf._size = 0;
+  fp->_lbfsize = 0;		/* not line buffered */
+  fp->_file = -1;		/* no file */
+  /* fp->_cookie = <any>; */	/* caller sets cookie, _read/_write etc */
+  fp->_ub._base = NULL;		/* no ungetc buffer */
+  fp->_ub._size = 0;
+  fp->_lb._base = NULL;		/* no line buffer */
+  fp->_lb._size = 0;
+  fp->_data = d;
+  return fp;
+}
+
+/*
+ * exit() calls _cleanup() through *__cleanup, set whenever we
+ * open or buffer a file.  This chicanery is done so that programs
+ * that do not use stdio need not link it all in.
+ *
+ * The name `_cleanup' is, alas, fairly well known outside stdio.
+ */
+
+void
+_cleanup_r (ptr)
+     struct _reent *ptr;
+{
+  /* (void) _fwalk(fclose); */
+  (void) _fwalk (ptr, fflush);	/* `cheating' */
+}
+
+#ifndef _REENT_ONLY
+void
+_cleanup ()
+{
+  _cleanup_r (_REENT);
+}
+#endif
+
+/*
+ * __sinit() is called whenever stdio's internal variables must be set up.
+ */
+
+void
+__sinit (s)
+     struct _reent *s;
+{
+  /* make sure we clean up on exit */
+  s->__cleanup = _cleanup_r;	/* conservative */
+  s->__sdidinit = 1;
+
+  std (s->__sf + 0, __SRD, 0, s);
+  std (s->__sf + 1, __SWR | __SLBF, 1, s);
+  std (s->__sf + 2, __SWR | __SNBF, 2, s);
+
+  s->__sglue._next = NULL;
+  s->__sglue._niobs = 3;
+  s->__sglue._iobs = &s->__sf[0];
+}
diff --git a/newlib/libc/stdio/fiprintf.c b/newlib/libc/stdio/fiprintf.c
new file mode 100644
index 000000000..d490ef403
--- /dev/null
+++ b/newlib/libc/stdio/fiprintf.c
@@ -0,0 +1,77 @@
+/*
+FUNCTION
+        <<fiprintf>>---format output to file (integer only)
+INDEX
+	fiprintf
+
+ANSI_SYNOPSIS
+        #include <stdio.h>
+
+        int fiprintf(FILE *<[fd]>, const char *<[format]>, ...);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+
+	int fiprintf(<[fd]>, <[format]> [, <[arg]>, ...]);
+	FILE *<[fd]>;
+	char *<[format]>;
+
+DESCRIPTION
+<<fiprintf>> is a restricted version of <<fprintf>>: it has the same
+arguments and behavior, save that it cannot perform any floating-point
+formatting---the <<f>>, <<g>>, <<G>>, <<e>>, and <<F>> type specifiers
+are not recognized.
+
+RETURNS
+        <<fiprintf>> returns the number of bytes in the output string,
+        save that the concluding <<NULL>> is not counted.
+        <<fiprintf>> returns when the end of the format string is
+        encountered.  If an error occurs, <<fiprintf>>
+        returns <<EOF>>.
+
+PORTABILITY
+<<fiprintf>> is not required by ANSI C.
+
+Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
+<<lseek>>, <<read>>, <<sbrk>>, <<write>>.
+*/
+
+#include <_ansi.h>
+#include <stdio.h>
+
+#ifdef _HAVE_STDC
+
+#include <stdarg.h>
+
+int
+fiprintf (FILE * fp, const char *fmt,...)
+{
+  int ret;
+  va_list ap;
+
+  va_start (ap, fmt);
+  ret = vfiprintf (fp, fmt, ap);
+  va_end (ap);
+  return ret;
+}
+
+#else
+
+#include <varargs.h>
+
+int
+fiprintf (fp, fmt, va_alist)
+     FILE *fp;
+     char *fmt;
+     va_dcl
+{
+  int ret;
+  va_list ap;
+
+  va_start (ap);
+  ret = vfiprintf (fp, fmt, ap);
+  va_end (ap);
+  return ret;
+}
+
+#endif
diff --git a/newlib/libc/stdio/flags.c b/newlib/libc/stdio/flags.c
new file mode 100644
index 000000000..6d62bd5bc
--- /dev/null
+++ b/newlib/libc/stdio/flags.c
@@ -0,0 +1,87 @@
+/* No user fns here. Pesch 15apr92 */
+
+/*
+ * Copyright (c) 1990 Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include <stdio.h>
+#include <time.h>
+#include <fcntl.h>
+
+#include <errno.h>
+#include <sys/types.h>
+
+/*
+ * Return the (stdio) flags for a given mode.  Store the flags
+ * to be passed to an open() syscall through *optr.
+ * Return 0 on error.
+ */
+
+int
+__sflags (ptr, mode, optr)
+     struct _reent *ptr;
+     register char *mode;
+     int *optr;
+{
+  register int ret, m, o;
+
+  switch (mode[0])
+    {
+    case 'r':			/* open for reading */
+      ret = __SRD;
+      m = O_RDONLY;
+      o = 0;
+      break;
+
+    case 'w':			/* open for writing */
+      ret = __SWR;
+      m = O_WRONLY;
+      o = O_CREAT | O_TRUNC;
+      break;
+
+    case 'a':			/* open for appending */
+      ret = __SWR | __SAPP;
+      m = O_WRONLY;
+      o = O_CREAT | O_APPEND;
+      break;
+    default:			/* illegal mode */
+      ptr->_errno = EINVAL;
+      return (0);
+    }
+  if (mode[1] == '+' || mode[2] == '+')
+    {
+      ret = __SRW;
+      m = O_RDWR;
+    }
+  if (mode[1] == 'b' || mode[2] == 'b')
+    {
+#ifdef O_BINARY
+      m |= O_BINARY;
+#endif
+    }
+#ifdef __CYGWIN__
+  else if (mode[1] == 't' || mode[2] == 't')
+#else
+  else
+#endif
+    {
+#ifdef O_TEXT
+      m |= O_TEXT;
+#endif
+    }
+  *optr = m | o;
+  return ret;
+}
diff --git a/newlib/libc/stdio/floatio.h b/newlib/libc/stdio/floatio.h
new file mode 100644
index 000000000..d9577b2b2
--- /dev/null
+++ b/newlib/libc/stdio/floatio.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *	%W% (Berkeley) %G%
+ */
+
+/*
+ * Floating point scanf/printf (input/output) definitions.
+ */
+
+/* 11-bit exponent (VAX G floating point) is 308 decimal digits */
+#define	MAXEXP		308
+/* 128 bit fraction takes up 39 decimal digits; max reasonable precision */
+#define	MAXFRACT	39
diff --git a/newlib/libc/stdio/fopen.c b/newlib/libc/stdio/fopen.c
new file mode 100644
index 000000000..30aa54e04
--- /dev/null
+++ b/newlib/libc/stdio/fopen.c
@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+/*
+FUNCTION
+<<fopen>>---open a file
+
+INDEX
+	fopen
+INDEX
+	_fopen_r
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	FILE *fopen(const char *<[file]>, const char *<[mode]>);
+
+	FILE *_fopen_r(void *<[reent]>, 
+                       const char *<[file]>, const char *<[mode]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	FILE *fopen(<[file]>, <[mode]>)
+	char *<[file]>;
+	char *<[mode]>;
+
+	FILE *_fopen_r(<[reent]>, <[file]>, <[mode]>)
+	char *<[reent]>;
+	char *<[file]>;
+	char *<[mode]>;
+
+DESCRIPTION
+<<fopen>> initializes the data structures needed to read or write a
+file.  Specify the file's name as the string at <[file]>, and the kind
+of access you need to the file with the string at <[mode]>.
+
+The alternate function <<_fopen_r>> is a reentrant version.
+The extra argument <[reent]> is a pointer to a reentrancy structure.
+
+Three fundamental kinds of access are available: read, write, and append.
+<<*<[mode]>>> must begin with one of the three characters `<<r>>',
+`<<w>>', or `<<a>>', to select one of these:
+
+o+
+o r
+Open the file for reading; the operation will fail if the file does
+not exist, or if the host system does not permit you to read it.
+
+o w
+Open the file for writing @emph{from the beginning} of the file:
+effectively, this always creates a new file.  If the file whose name you
+specified already existed, its old contents are discarded.
+
+o a
+Open the file for appending data, that is writing from the end of
+file.  When you open a file this way, all data always goes to the
+current end of file; you cannot change this using <<fseek>>.
+o-
+
+Some host systems distinguish between ``binary'' and ``text'' files.
+Such systems may perform data transformations on data written to, or
+read from, files opened as ``text''.
+If your system is one of these, then you can append a `<<b>>' to any
+of the three modes above, to specify that you are opening the file as
+a binary file (the default is to open the file as a text file).
+
+`<<rb>>', then, means ``read binary''; `<<wb>>', ``write binary''; and
+`<<ab>>', ``append binary''.
+
+To make C programs more portable, the `<<b>>' is accepted on all
+systems, whether or not it makes a difference.
+
+Finally, you might need to both read and write from the same file.
+You can also append a `<<+>>' to any of the three modes, to permit
+this.  (If you want to append both `<<b>>' and `<<+>>', you can do it
+in either order: for example, <<"rb+">> means the same thing as
+<<"r+b">> when used as a mode string.)
+
+Use <<"r+">> (or <<"rb+">>) to permit reading and writing anywhere in
+an existing file, without discarding any data; <<"w+">> (or <<"wb+">>)
+to create a new file (or begin by discarding all data from an old one)
+that permits reading and writing anywhere in it; and <<"a+">> (or
+<<"ab+">>) to permit reading anywhere in an existing file, but writing
+only at the end.
+
+RETURNS
+<<fopen>> returns a file pointer which you can use for other file
+operations, unless the file you requested could not be opened; in that
+situation, the result is <<NULL>>.  If the reason for failure was an
+invalid string at <[mode]>, <<errno>> is set to <<EINVAL>>.
+
+PORTABILITY
+<<fopen>> is required by ANSI C.
+
+Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
+<<lseek>>, <<open>>, <<read>>, <<sbrk>>, <<write>>.
+*/
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "%W% (Berkeley) %G%";
+#endif /* LIBC_SCCS and not lint */
+
+#include <stdio.h>
+#include <errno.h>
+#include "local.h"
+
+FILE *
+_DEFUN (_fopen_r, (ptr, file, mode),
+	struct _reent *ptr _AND
+	_CONST char *file _AND
+	_CONST char *mode)
+{
+  register FILE *fp;
+  register int f;
+  int flags, oflags;
+
+  if ((flags = __sflags (ptr, mode, &oflags)) == 0)
+    return NULL;
+  if ((fp = __sfp (ptr)) == NULL)
+    return NULL;
+
+  if ((f = _open_r (fp->_data, file, oflags, 0666)) < 0)
+    {
+      fp->_flags = 0;		/* release */
+      return NULL;
+    }
+
+  fp->_file = f;
+  fp->_flags = flags;
+  fp->_cookie = (_PTR) fp;
+  fp->_read = __sread;
+  fp->_write = __swrite;
+  fp->_seek = __sseek;
+  fp->_close = __sclose;
+
+  if (fp->_flags & __SAPP)
+    fseek (fp, 0, SEEK_END);
+
+  return fp;
+}
+
+#ifndef _REENT_ONLY
+
+FILE *
+_DEFUN (fopen, (file, mode),
+	_CONST char *file _AND
+	_CONST char *mode)
+{
+  return _fopen_r (_REENT, file, mode);
+}
+
+#endif
diff --git a/newlib/libc/stdio/fprintf.c b/newlib/libc/stdio/fprintf.c
new file mode 100644
index 000000000..de036605f
--- /dev/null
+++ b/newlib/libc/stdio/fprintf.c
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include <_ansi.h>
+#include <stdio.h>
+
+#ifdef _HAVE_STDC
+
+#include <stdarg.h>
+
+int
+fprintf (FILE * fp, const char *fmt,...)
+{
+  int ret;
+  va_list ap;
+
+  va_start (ap, fmt);
+  ret = vfprintf (fp, fmt, ap);
+  va_end (ap);
+  return ret;
+}
+
+#else
+
+#include <varargs.h>
+
+int
+fprintf (fp, fmt, va_alist)
+     FILE *fp;
+     char *fmt;
+     va_dcl
+{
+  int ret;
+  va_list ap;
+
+  va_start (ap);
+  ret = vfprintf (fp, fmt, ap);
+  va_end (ap);
+  return ret;
+}
+
+#endif
diff --git a/newlib/libc/stdio/fputc.c b/newlib/libc/stdio/fputc.c
new file mode 100644
index 000000000..966a0dbf7
--- /dev/null
+++ b/newlib/libc/stdio/fputc.c
@@ -0,0 +1,51 @@
+/*
+FUNCTION
+<<fputc>>---write a character on a stream or file
+
+INDEX
+	fputc
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	int fputc(int <[ch]>, FILE *<[fp]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	int fputc(<[ch]>, <[fp]>)
+	int <[ch]>;
+	FILE *<[fp]>;
+
+DESCRIPTION
+<<fputc>> converts the argument <[ch]> from an <<int>> to an
+<<unsigned char>>, then writes it to the file or stream identified by
+<[fp]>.
+
+If the file was opened with append mode (or if the stream cannot
+support positioning), then the new character goes at the end of the
+file or stream.  Otherwise, the new character is written at the
+current value of the position indicator, and the position indicator
+oadvances by one.
+
+For a macro version of this function, see <<putc>>.
+
+RETURNS
+If successful, <<fputc>> returns its argument <[ch]>.  If an error
+intervenes, the result is <<EOF>>.  You can use `<<ferror(<[fp]>)>>' to
+query for errors.
+
+PORTABILITY
+<<fputc>> is required by ANSI C.
+
+Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
+<<lseek>>, <<read>>, <<sbrk>>, <<write>>.
+*/
+
+#include <stdio.h>
+
+int
+_DEFUN (fputc, (ch, file),
+	int ch _AND
+	FILE * file)
+{
+  return putc (ch, file);
+}
diff --git a/newlib/libc/stdio/fputs.c b/newlib/libc/stdio/fputs.c
new file mode 100644
index 000000000..62ce98fb7
--- /dev/null
+++ b/newlib/libc/stdio/fputs.c
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+/*
+FUNCTION
+<<fputs>>---write a character string in a file or stream
+
+INDEX
+	fputs
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	int fputs(const char *<[s]>, FILE *<[fp]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	int fputs(<[s]>, <[fp]>)
+	char *<[s]>;
+	FILE *<[fp]>;
+
+DESCRIPTION
+<<fputs>> writes the string at <[s]> (but without the trailing null)
+to the file or stream identified by <[fp]>.
+
+RETURNS
+If successful, the result is <<0>>; otherwise, the result is <<EOF>>.
+
+PORTABILITY
+ANSI C requires <<fputs>>, but does not specify that the result on
+success must be <<0>>; any non-negative value is permitted.
+
+Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
+<<lseek>>, <<read>>, <<sbrk>>, <<write>>.
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include "fvwrite.h"
+
+/*
+ * Write the given string to the given file.
+ */
+
+int
+_DEFUN (fputs, (s, fp),
+	char _CONST * s _AND
+	FILE * fp)
+{
+  struct __suio uio;
+  struct __siov iov;
+
+  iov.iov_base = s;
+  iov.iov_len = uio.uio_resid = strlen (s);
+  uio.uio_iov = &iov;
+  uio.uio_iovcnt = 1;
+  return __sfvwrite (fp, &uio);
+}
diff --git a/newlib/libc/stdio/fread.c b/newlib/libc/stdio/fread.c
new file mode 100644
index 000000000..4de7ce290
--- /dev/null
+++ b/newlib/libc/stdio/fread.c
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+/*
+FUNCTION
+<<fread>>---read array elements from a file
+
+INDEX
+	fread
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	size_t fread(void *<[buf]>, size_t <[size]>, size_t <[count]>,
+		     FILE *<[fp]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	size_t fread(<[buf]>, <[size]>, <[count]>, <[fp]>)
+	char *<[buf]>;
+	size_t <[size]>;
+	size_t <[count]>;
+	FILE *<[fp]>;
+
+DESCRIPTION
+<<fread>> attempts to copy, from the file or stream identified by
+<[fp]>, <[count]> elements (each of size <[size]>) into memory,
+starting at <[buf]>.   <<fread>> may copy fewer elements than
+<[count]> if an error, or end of file, intervenes.
+
+<<fread>> also advances the file position indicator (if any) for
+<[fp]> by the number of @emph{characters} actually read.
+
+RETURNS
+The result of <<fread>> is the number of elements it succeeded in
+reading.
+
+PORTABILITY
+ANSI C requires <<fread>>.
+
+Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
+<<lseek>>, <<read>>, <<sbrk>>, <<write>>.
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include "local.h"
+
+size_t
+_DEFUN (fread, (buf, size, count, fp),
+	_PTR buf _AND
+	size_t size _AND
+	size_t count _AND
+	FILE * fp)
+{
+  register size_t resid;
+  register char *p;
+  register int r;
+  size_t total;
+
+  if ((resid = count * size) == 0)
+    return 0;
+  if (fp->_r < 0)
+    fp->_r = 0;
+  total = resid;
+  p = buf;
+  while (resid > (r = fp->_r))
+    {
+      (void) memcpy ((void *) p, (void *) fp->_p, (size_t) r);
+      fp->_p += r;
+      /* fp->_r = 0 ... done in __srefill */
+      p += r;
+      resid -= r;
+      if (__srefill (fp))
+	{
+	  /* no more input: return partial result */
+	  return (total - resid) / size;
+	}
+    }
+  (void) memcpy ((void *) p, (void *) fp->_p, resid);
+  fp->_r -= resid;
+  fp->_p += resid;
+  return count;
+}
diff --git a/newlib/libc/stdio/freopen.c b/newlib/libc/stdio/freopen.c
new file mode 100644
index 000000000..a4ab965e9
--- /dev/null
+++ b/newlib/libc/stdio/freopen.c
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+/*
+FUNCTION
+<<freopen>>---open a file using an existing file descriptor
+
+INDEX
+	freopen
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	FILE *freopen(const char *<[file]>, const char *<[mode]>,
+		      FILE *<[fp]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	FILE *freopen(<[file]>, <[mode]>, <[fp]>)
+	char *<[file]>;
+	char *<[mode]>;
+	FILE *<[fp]>;
+
+DESCRIPTION
+Use this variant of <<fopen>> if you wish to specify a particular file
+descriptor <[fp]> (notably <<stdin>>, <<stdout>>, or <<stderr>>) for
+the file.
+
+If <[fp]> was associated with another file or stream, <<freopen>>
+closes that other file or stream (but ignores any errors while closing
+it).
+
+<[file]> and <[mode]> are used just as in <<fopen>>.
+
+RETURNS
+If successful, the result is the same as the argument <[fp]>.  If the
+file cannot be opened as specified, the result is <<NULL>>.
+
+PORTABILITY
+ANSI C requires <<freopen>>.
+
+Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
+<<lseek>>, <<open>>, <<read>>, <<sbrk>>, <<write>>.
+*/
+
+#include <time.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include "local.h"
+
+/*
+ * Re-direct an existing, open (probably) file to some other file.
+ */
+
+FILE *
+_DEFUN (freopen, (file, mode, fp),
+	_CONST char *file _AND
+	_CONST char *mode _AND
+	register FILE *fp)
+{
+  register int f;
+  int flags, oflags, e;
+  struct _reent *ptr;
+
+  CHECK_INIT (fp);
+  ptr = fp->_data;
+
+  if ((flags = __sflags (ptr, mode, &oflags)) == 0)
+    {
+      (void) fclose (fp);
+      return NULL;
+    }
+
+  /*
+   * Remember whether the stream was open to begin with, and
+   * which file descriptor (if any) was associated with it.
+   * If it was attached to a descriptor, defer closing it,
+   * so that, e.g., freopen("/dev/stdin", "r", stdin) works.
+   * This is unnecessary if it was not a Unix file.
+   */
+
+  if (fp->_flags == 0)
+    fp->_flags = __SEOF;	/* hold on to it */
+  else
+    {
+      if (fp->_flags & __SWR)
+	(void) fflush (fp);
+      /* if close is NULL, closing is a no-op, hence pointless */
+      if (fp->_close != NULL)
+	(void) (*fp->_close) (fp->_cookie);
+    }
+
+  /*
+   * Now get a new descriptor to refer to the new file.
+   */
+
+  f = _open_r (ptr, (char *) file, oflags, 0666);
+  e = ptr->_errno;
+
+  /*
+   * Finish closing fp.  Even if the open succeeded above,
+   * we cannot keep fp->_base: it may be the wrong size.
+   * This loses the effect of any setbuffer calls,
+   * but stdio has always done this before.
+   */
+
+  if (fp->_flags & __SMBF)
+    _free_r (ptr, (char *) fp->_bf._base);
+  fp->_w = 0;
+  fp->_r = 0;
+  fp->_p = NULL;
+  fp->_bf._base = NULL;
+  fp->_bf._size = 0;
+  fp->_lbfsize = 0;
+  if (HASUB (fp))
+    FREEUB (fp);
+  fp->_ub._size = 0;
+  if (HASLB (fp))
+    FREELB (fp);
+  fp->_lb._size = 0;
+
+  if (f < 0)
+    {				/* did not get it after all */
+      fp->_flags = 0;		/* set it free */
+      ptr->_errno = e;		/* restore in case _close clobbered */
+      return NULL;
+    }
+
+  fp->_flags = flags;
+  fp->_file = f;
+  fp->_cookie = (_PTR) fp;
+  fp->_read = __sread;
+  fp->_write = __swrite;
+  fp->_seek = __sseek;
+  fp->_close = __sclose;
+  return fp;
+}
diff --git a/newlib/libc/stdio/fscanf.c b/newlib/libc/stdio/fscanf.c
new file mode 100644
index 000000000..8980410d3
--- /dev/null
+++ b/newlib/libc/stdio/fscanf.c
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include <_ansi.h>
+#include <stdio.h>
+
+#ifdef _HAVE_STDC
+
+#include <stdarg.h>
+
+extern int __svfscanf ();
+
+int
+fscanf (FILE * fp, const char *fmt, ...)
+{
+  int ret;
+  va_list ap;
+
+  va_start (ap, fmt);
+  ret = __svfscanf (fp, fmt, ap);
+  va_end (ap);
+  return ret;
+}
+
+#else
+
+#include <varargs.h>
+
+extern int __svfscanf ();
+
+int
+fscanf (fp, fmt, va_alist)
+     FILE *fp;
+     char *fmt;
+     va_dcl
+{
+  int ret;
+  va_list ap;
+
+  va_start (ap);
+  ret = __svfscanf (fp, fmt, ap);
+  va_end (ap);
+  return ret;
+}
+
+#endif
diff --git a/newlib/libc/stdio/fseek.c b/newlib/libc/stdio/fseek.c
new file mode 100644
index 000000000..d22292e97
--- /dev/null
+++ b/newlib/libc/stdio/fseek.c
@@ -0,0 +1,310 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+/*
+FUNCTION
+<<fseek>>---set file position
+
+INDEX
+	fseek
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	int fseek(FILE *<[fp]>, long <[offset]>, int <[whence]>)
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	int fseek(<[fp]>, <[offset]>, <[whence]>)
+	FILE *<[fp]>;
+	long <[offset]>;
+	int <[whence]>;
+
+DESCRIPTION
+Objects of type <<FILE>> can have a ``position'' that records how much
+of the file your program has already read.  Many of the <<stdio>> functions
+depend on this position, and many change it as a side effect.
+
+You can use <<fseek>> to set the position for the file identified by
+<[fp]>.  The value of <[offset]> determines the new position, in one
+of three ways selected by the value of <[whence]> (defined as macros
+in `<<stdio.h>>'):
+
+<<SEEK_SET>>---<[offset]> is the absolute file position (an offset
+from the beginning of the file) desired.  <[offset]> must be positive.
+
+<<SEEK_CUR>>---<[offset]> is relative to the current file position.
+<[offset]> can meaningfully be either positive or negative.
+
+<<SEEK_END>>---<[offset]> is relative to the current end of file.
+<[offset]> can meaningfully be either positive (to increase the size
+of the file) or negative.
+
+See <<ftell>> to determine the current file position.
+
+RETURNS
+<<fseek>> returns <<0>> when successful.  If <<fseek>> fails, the
+result is <<EOF>>.  The reason for failure is indicated in <<errno>>:
+either <<ESPIPE>> (the stream identified by <[fp]> doesn't support
+repositioning) or <<EINVAL>> (invalid file position).
+
+PORTABILITY
+ANSI C requires <<fseek>>.
+
+Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
+<<lseek>>, <<read>>, <<sbrk>>, <<write>>.
+*/
+
+#include <stdio.h>
+#include <time.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include "local.h"
+
+#define	POS_ERR	(-(fpos_t)1)
+
+/*
+ * Seek the given file to the given offset.
+ * `Whence' must be one of the three SEEK_* macros.
+ */
+
+int
+fseek (fp, offset, whence)
+     register FILE *fp;
+     long offset;
+     int whence;
+{
+  struct _reent *ptr;
+  fpos_t _EXFUN ((*seekfn), (void *, fpos_t, int));
+  fpos_t target, curoff;
+  size_t n;
+  struct stat st;
+  int havepos;
+
+  /* Make sure stdio is set up.  */
+
+  CHECK_INIT (fp);
+  ptr = fp->_data;
+
+  /* If we've been doing some writing, and we're in append mode
+     then we don't really know where the filepos is.  */
+
+  if (fp->_flags & __SAPP && fp->_flags & __SWR)
+    {
+      /* So flush the buffer and seek to the end.  */
+      fflush (fp);
+    }
+
+  /* Have to be able to seek.  */
+
+  if ((seekfn = fp->_seek) == NULL)
+    {
+      ptr->_errno = ESPIPE;	/* ??? */
+      return EOF;
+    }
+
+  /*
+   * Change any SEEK_CUR to SEEK_SET, and check `whence' argument.
+   * After this, whence is either SEEK_SET or SEEK_END.
+   */
+
+  switch (whence)
+    {
+    case SEEK_CUR:
+      /*
+       * In order to seek relative to the current stream offset,
+       * we have to first find the current stream offset a la
+       * ftell (see ftell for details).
+       */
+      fflush(fp);   /* may adjust seek offset on append stream */
+      if (fp->_flags & __SOFF)
+	curoff = fp->_offset;
+      else
+	{
+	  curoff = (*seekfn) (fp->_cookie, (fpos_t) 0, SEEK_CUR);
+	  if (curoff == -1L)
+	    return EOF;
+	}
+      if (fp->_flags & __SRD)
+	{
+	  curoff -= fp->_r;
+	  if (HASUB (fp))
+	    curoff -= fp->_ur;
+	}
+      else if (fp->_flags & __SWR && fp->_p != NULL)
+	curoff += fp->_p - fp->_bf._base;
+
+      offset += curoff;
+      whence = SEEK_SET;
+      havepos = 1;
+      break;
+
+    case SEEK_SET:
+    case SEEK_END:
+      havepos = 0;
+      break;
+
+    default:
+      ptr->_errno = EINVAL;
+      return (EOF);
+    }
+
+  /*
+   * Can only optimise if:
+   *	reading (and not reading-and-writing);
+   *	not unbuffered; and
+   *	this is a `regular' Unix file (and hence seekfn==__sseek).
+   * We must check __NBF first, because it is possible to have __NBF
+   * and __SOPT both set.
+   */
+
+  if (fp->_bf._base == NULL)
+    __smakebuf (fp);
+  if (fp->_flags & (__SWR | __SRW | __SNBF | __SNPT))
+    goto dumb;
+  if ((fp->_flags & __SOPT) == 0)
+    {
+      if (seekfn != __sseek
+	  || fp->_file < 0
+	  || _fstat_r (ptr, fp->_file, &st)
+	  || (st.st_mode & S_IFMT) != S_IFREG)
+	{
+	  fp->_flags |= __SNPT;
+	  goto dumb;
+	}
+#ifdef	HAVE_BLKSIZE
+      fp->_blksize = st.st_blksize;
+#else
+      fp->_blksize = 1024;
+#endif
+      fp->_flags |= __SOPT;
+    }
+
+  /*
+   * We are reading; we can try to optimise.
+   * Figure out where we are going and where we are now.
+   */
+
+  if (whence == SEEK_SET)
+    target = offset;
+  else
+    {
+      if (_fstat_r (ptr, fp->_file, &st))
+	goto dumb;
+      target = st.st_size + offset;
+    }
+
+  if (!havepos)
+    {
+      if (fp->_flags & __SOFF)
+	curoff = fp->_offset;
+      else
+	{
+	  curoff = (*seekfn) (fp->_cookie, 0L, SEEK_CUR);
+	  if (curoff == POS_ERR)
+	    goto dumb;
+	}
+      curoff -= fp->_r;
+      if (HASUB (fp))
+	curoff -= fp->_ur;
+    }
+
+  /*
+   * Compute the number of bytes in the input buffer (pretending
+   * that any ungetc() input has been discarded).  Adjust current
+   * offset backwards by this count so that it represents the
+   * file offset for the first byte in the current input buffer.
+   */
+
+  if (HASUB (fp))
+    {
+      curoff += fp->_r;       /* kill off ungetc */
+      n = fp->_up - fp->_bf._base;
+      curoff -= n;
+      n += fp->_ur;
+    }
+  else
+    {
+      n = fp->_p - fp->_bf._base;
+      curoff -= n;
+      n += fp->_r;
+    }
+
+  /*
+   * If the target offset is within the current buffer,
+   * simply adjust the pointers, clear EOF, undo ungetc(),
+   * and return.  (If the buffer was modified, we have to
+   * skip this; see fgetline.c.)
+   */
+
+  if ((fp->_flags & __SMOD) == 0 &&
+      target >= curoff && target < curoff + n)
+    {
+      register int o = target - curoff;
+
+      fp->_p = fp->_bf._base + o;
+      fp->_r = n - o;
+      if (HASUB (fp))
+	FREEUB (fp);
+      fp->_flags &= ~__SEOF;
+      return 0;
+    }
+
+  /*
+   * The place we want to get to is not within the current buffer,
+   * but we can still be kind to the kernel copyout mechanism.
+   * By aligning the file offset to a block boundary, we can let
+   * the kernel use the VM hardware to map pages instead of
+   * copying bytes laboriously.  Using a block boundary also
+   * ensures that we only read one block, rather than two.
+   */
+
+  curoff = target & ~(fp->_blksize - 1);
+  if ((*seekfn) (fp->_cookie, curoff, SEEK_SET) == POS_ERR)
+    goto dumb;
+  fp->_r = 0;
+  if (HASUB (fp))
+    FREEUB (fp);
+  fp->_flags &= ~__SEOF;
+  n = target - curoff;
+  if (n)
+    {
+      if (__srefill (fp) || fp->_r < n)
+	goto dumb;
+      fp->_p += n;
+      fp->_r -= n;
+    }
+  return 0;
+
+  /*
+   * We get here if we cannot optimise the seek ... just
+   * do it.  Allow the seek function to change fp->_bf._base.
+   */
+
+dumb:
+  if (fflush (fp) || (*seekfn) (fp->_cookie, offset, whence) == POS_ERR)
+    return EOF;
+  /* success: clear EOF indicator and discard ungetc() data */
+  if (HASUB (fp))
+    FREEUB (fp);
+  fp->_p = fp->_bf._base;
+  fp->_r = 0;
+  /* fp->_w = 0; *//* unnecessary (I think...) */
+  fp->_flags &= ~__SEOF;
+  return 0;
+}
diff --git a/newlib/libc/stdio/fsetpos.c b/newlib/libc/stdio/fsetpos.c
new file mode 100644
index 000000000..28cd69ead
--- /dev/null
+++ b/newlib/libc/stdio/fsetpos.c
@@ -0,0 +1,54 @@
+/*
+FUNCTION
+<<fsetpos>>---restore position of a stream or file
+
+INDEX
+	fsetpos
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	int fsetpos(FILE *<[fp]>, const fpos_t *<[pos]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	int fsetpos(<[fp]>, <[pos]>)
+	FILE *<[fp]>;
+	fpos_t *<[pos]>;
+
+DESCRIPTION
+Objects of type <<FILE>> can have a ``position'' that records how much
+of the file your program has already read.  Many of the <<stdio>> functions
+depend on this position, and many change it as a side effect.
+
+You can use <<fsetpos>> to return the file identified by <[fp]> to a previous
+position <<*<[pos]>>> (after first recording it with <<fgetpos>>).
+
+See <<fseek>> for a similar facility.
+
+RETURNS
+<<fgetpos>> returns <<0>> when successful.  If <<fgetpos>> fails, the
+result is <<1>>.  The reason for failure is indicated in <<errno>>:
+either <<ESPIPE>> (the stream identified by <[fp]> doesn't support
+repositioning) or <<EINVAL>> (invalid file position).
+
+PORTABILITY
+ANSI C requires <<fsetpos>>, but does not specify the nature of
+<<*<[pos]>>> beyond identifying it as written by <<fgetpos>>.
+
+Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
+<<lseek>>, <<read>>, <<sbrk>>, <<write>>.
+*/
+
+#include <stdio.h>
+
+int
+_DEFUN (fsetpos, (iop, pos),
+	FILE * iop _AND
+	_CONST fpos_t * pos)
+{
+  int x = fseek (iop, *pos, SEEK_SET);
+
+  if (x != 0)
+    return 1;
+  return 0;
+}
diff --git a/newlib/libc/stdio/ftell.c b/newlib/libc/stdio/ftell.c
new file mode 100644
index 000000000..6a8061816
--- /dev/null
+++ b/newlib/libc/stdio/ftell.c
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+/*
+FUNCTION
+<<ftell>>---return position in a stream or file
+
+INDEX
+	ftell
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	long ftell(FILE *<[fp]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	long ftell(<[fp]>)
+	FILE *<[fp]>;
+
+DESCRIPTION
+Objects of type <<FILE>> can have a ``position'' that records how much
+of the file your program has already read.  Many of the <<stdio>> functions
+depend on this position, and many change it as a side effect.
+
+The result of <<ftell>> is the current position for a file
+identified by <[fp]>.  If you record this result, you can later
+use it with <<fseek>> to return the file to this
+position.
+
+In the current implementation, <<ftell>> simply uses a character
+count to represent the file position; this is the same number that
+would be recorded by <<fgetpos>>.
+
+RETURNS
+<<ftell>> returns the file position, if possible.  If it cannot do
+this, it returns <<-1L>>.  Failure occurs on streams that do not support
+positioning; the global <<errno>> indicates this condition with the
+value <<ESPIPE>>.
+
+PORTABILITY
+<<ftell>> is required by the ANSI C standard, but the meaning of its
+result (when successful) is not specified beyond requiring that it be
+acceptable as an argument to <<fseek>>.  In particular, other
+conforming C implementations may return a different result from
+<<ftell>> than what <<fgetpos>> records.
+
+No supporting OS subroutines are required.
+*/
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "%W% (Berkeley) %G%";
+#endif /* LIBC_SCCS and not lint */
+
+/*
+ * ftell: return current offset.
+ */
+
+#include <stdio.h>
+#include <errno.h>
+
+#include "local.h"
+
+long
+_DEFUN (ftell, (fp),
+	register FILE * fp)
+{
+  fpos_t pos;
+
+  /* Ensure stdio is set up.  */
+
+  CHECK_INIT (fp);
+
+  if (fp->_seek == NULL)
+    {
+      fp->_data->_errno = ESPIPE;
+      return -1L;
+    }
+
+  /* Find offset of underlying I/O object, then
+     adjust for buffered bytes.  */
+  fflush(fp);           /* may adjust seek offset on append stream */
+  if (fp->_flags & __SOFF)
+    pos = fp->_offset;
+  else
+    {
+      pos = (*fp->_seek) (fp->_cookie, (fpos_t) 0, SEEK_CUR);
+      if (pos == -1L)
+	return pos;
+    }
+  if (fp->_flags & __SRD)
+    {
+      /*
+       * Reading.  Any unread characters (including
+       * those from ungetc) cause the position to be
+       * smaller than that in the underlying object.
+       */
+      pos -= fp->_r;
+      if (HASUB (fp))
+	pos -= fp->_ur;
+    }
+  else if (fp->_flags & __SWR && fp->_p != NULL)
+    {
+      /*
+       * Writing.  Any buffered characters cause the
+       * position to be greater than that in the
+       * underlying object.
+       */
+      pos += fp->_p - fp->_bf._base;
+    }
+
+  return pos;
+}
diff --git a/newlib/libc/stdio/fvwrite.c b/newlib/libc/stdio/fvwrite.c
new file mode 100644
index 000000000..00e758a47
--- /dev/null
+++ b/newlib/libc/stdio/fvwrite.c
@@ -0,0 +1,195 @@
+/* No user fns here.  Pesch 15apr92. */
+
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include "local.h"
+#include "fvwrite.h"
+
+#define	MIN(a, b) ((a) < (b) ? (a) : (b))
+#define	COPY(n)	  (void) memmove((void *) fp->_p, (void *) p, (size_t) (n))
+
+#define GETIOV(extra_work) \
+  while (len == 0) \
+    { \
+      extra_work; \
+      p = iov->iov_base; \
+      len = iov->iov_len; \
+      iov++; \
+    }
+
+/*
+ * Write some memory regions.  Return zero on success, EOF on error.
+ *
+ * This routine is large and unsightly, but most of the ugliness due
+ * to the three different kinds of output buffering is handled here.
+ */
+
+int
+__sfvwrite (fp, uio)
+     register FILE *fp;
+     register struct __suio *uio;
+{
+  register size_t len;
+  register _CONST char *p;
+  register struct __siov *iov;
+  register int w, s;
+  char *nl;
+  int nlknown, nldist;
+
+  if ((len = uio->uio_resid) == 0)
+    return 0;
+
+  /* make sure we can write */
+  if (cantwrite (fp))
+    return EOF;
+
+  iov = uio->uio_iov;
+  len = 0;
+  if (fp->_flags & __SNBF)
+    {
+      /*
+       * Unbuffered: write up to BUFSIZ bytes at a time.
+       */
+      do
+	{
+	  GETIOV (;);
+	  w = (*fp->_write) (fp->_cookie, p, MIN (len, BUFSIZ));
+	  if (w <= 0)
+	    goto err;
+	  p += w;
+	  len -= w;
+	}
+      while ((uio->uio_resid -= w) != 0);
+    }
+  else if ((fp->_flags & __SLBF) == 0)
+    {
+      /*
+       * Fully buffered: fill partially full buffer, if any,
+       * and then flush.  If there is no partial buffer, write
+       * one _bf._size byte chunk directly (without copying).
+       *
+       * String output is a special case: write as many bytes
+       * as fit, but pretend we wrote everything.  This makes
+       * snprintf() return the number of bytes needed, rather
+       * than the number used, and avoids its write function
+       * (so that the write function can be invalid).
+       */
+      do
+	{
+	  GETIOV (;);
+	  w = fp->_w;
+	  if (fp->_flags & __SSTR)
+	    {
+	      if (len < w)
+		w = len;
+	      COPY (w);		/* copy MIN(fp->_w,len), */
+	      fp->_w -= w;
+	      fp->_p += w;
+	      w = len;		/* but pretend copied all */
+	    }
+	  else if (fp->_p > fp->_bf._base && len > w)
+	    {
+	      /* fill and flush */
+	      COPY (w);
+	      /* fp->_w -= w; *//* unneeded */
+	      fp->_p += w;
+	      if (fflush (fp))
+		goto err;
+	    }
+	  else if (len >= (w = fp->_bf._size))
+	    {
+	      /* write directly */
+	      w = (*fp->_write) (fp->_cookie, p, w);
+	      if (w <= 0)
+		goto err;
+	    }
+	  else
+	    {
+	      /* fill and done */
+	      w = len;
+	      COPY (w);
+	      fp->_w -= w;
+	      fp->_p += w;
+	    }
+	  p += w;
+	  len -= w;
+	}
+      while ((uio->uio_resid -= w) != 0);
+    }
+  else
+    {
+      /*
+       * Line buffered: like fully buffered, but we
+       * must check for newlines.  Compute the distance
+       * to the first newline (including the newline),
+       * or `infinity' if there is none, then pretend
+       * that the amount to write is MIN(len,nldist).
+       */
+      nlknown = 0;
+      do
+	{
+	  GETIOV (nlknown = 0);
+	  if (!nlknown)
+	    {
+	      nl = memchr ((void *) p, '\n', len);
+	      nldist = nl ? nl + 1 - p : len + 1;
+	      nlknown = 1;
+	    }
+	  s = MIN (len, nldist);
+	  w = fp->_w + fp->_bf._size;
+	  if (fp->_p > fp->_bf._base && s > w)
+	    {
+	      COPY (w);
+	      /* fp->_w -= w; */
+	      fp->_p += w;
+	      if (fflush (fp))
+		goto err;
+	    }
+	  else if (s >= (w = fp->_bf._size))
+	    {
+	      w = (*fp->_write) (fp->_cookie, p, w);
+	      if (w <= 0)
+		goto err;
+	    }
+	  else
+	    {
+	      w = s;
+	      COPY (w);
+	      fp->_w -= w;
+	      fp->_p += w;
+	    }
+	  if ((nldist -= w) == 0)
+	    {
+	      /* copied the newline: flush and forget */
+	      if (fflush (fp))
+		goto err;
+	      nlknown = 0;
+	    }
+	  p += w;
+	  len -= w;
+	}
+      while ((uio->uio_resid -= w) != 0);
+    }
+  return 0;
+
+err:
+  fp->_flags |= __SERR;
+  return EOF;
+}
diff --git a/newlib/libc/stdio/fvwrite.h b/newlib/libc/stdio/fvwrite.h
new file mode 100644
index 000000000..f27abdf81
--- /dev/null
+++ b/newlib/libc/stdio/fvwrite.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+/* %W% (Berkeley) %G% */
+#include <_ansi.h>
+
+/*
+ * I/O descriptors for __sfvwrite().
+ */
+struct __siov {
+	_CONST _PTR     iov_base;
+	size_t	iov_len;
+};
+struct __suio {
+	struct	__siov *uio_iov;
+	int	uio_iovcnt;
+	int	uio_resid;
+};
+
+
+extern int _EXFUN(__sfvwrite,(FILE *, struct __suio *));
+extern int _EXFUN(__swsetup,(FILE *));
+
+
diff --git a/newlib/libc/stdio/fwalk.c b/newlib/libc/stdio/fwalk.c
new file mode 100644
index 000000000..516283466
--- /dev/null
+++ b/newlib/libc/stdio/fwalk.c
@@ -0,0 +1,43 @@
+/* No user fns here.  Pesch 15apr92. */
+
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "%W% (Berkeley) %G%";
+#endif /* LIBC_SCCS and not lint */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include "local.h"
+
+int
+_fwalk (ptr, function)
+     struct _reent *ptr;
+     register int (*function) ();
+{
+  register FILE *fp;
+  register int n, ret = 0;
+  register struct _glue *g;
+
+  for (g = &ptr->__sglue; g != NULL; g = g->_next)
+    for (fp = g->_iobs, n = g->_niobs; --n >= 0; fp++)
+      if (fp->_flags != 0)
+	ret |= (*function) (fp);
+  return ret;
+}
diff --git a/newlib/libc/stdio/fwrite.c b/newlib/libc/stdio/fwrite.c
new file mode 100644
index 000000000..642fb274f
--- /dev/null
+++ b/newlib/libc/stdio/fwrite.c
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+/*
+FUNCTION
+<<fwrite>>---write array elements
+
+INDEX
+	fwrite
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	size_t fwrite(const void *<[buf]>, size_t <[size]>,
+		      size_t <[count]>, FILE *<[fp]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	size_t fwrite(<[buf]>, <[size]>, <[count]>, <[fp]>)
+	char *<[buf]>;
+	size_t <[size]>;
+	size_t <[count]>;
+	FILE *<[fp]>;
+
+DESCRIPTION
+<<fwrite>> attempts to copy, starting from the memory location
+<[buf]>, <[count]> elements (each of size <[size]>) into the file or
+stream identified by <[fp]>.  <<fwrite>> may copy fewer elements than
+<[count]> if an error intervenes.
+
+<<fwrite>> also advances the file position indicator (if any) for
+<[fp]> by the number of @emph{characters} actually written.
+
+RETURNS
+If <<fwrite>> succeeds in writing all the elements you specify, the
+result is the same as the argument <[count]>.  In any event, the
+result is the number of complete elements that <<fwrite>> copied to
+the file.
+
+PORTABILITY
+ANSI C requires <<fwrite>>.
+
+Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
+<<lseek>>, <<read>>, <<sbrk>>, <<write>>.
+*/
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "%W% (Berkeley) %G%";
+#endif /* LIBC_SCCS and not lint */
+
+#include <stdio.h>
+#include <string.h>
+#if 0
+#include <sys/stdc.h>
+#endif
+#include "local.h"
+#if 1
+#include "fvwrite.h"
+#endif
+
+/*
+ * Write `count' objects (each size `size') from memory to the given file.
+ * Return the number of whole objects written.
+ */
+
+size_t
+_DEFUN (fwrite, (buf, size, count, fp),
+	_CONST _PTR buf _AND
+	size_t size _AND
+	size_t count _AND
+	FILE * fp)
+{
+  size_t n;
+  struct __suio uio;
+  struct __siov iov;
+
+  iov.iov_base = buf;
+  uio.uio_resid = iov.iov_len = n = count * size;
+  uio.uio_iov = &iov;
+  uio.uio_iovcnt = 1;
+
+  /*
+   * The usual case is success (__sfvwrite returns 0);
+   * skip the divide if this happens, since divides are
+   * generally slow and since this occurs whenever size==0.
+   */
+
+  if (__sfvwrite (fp, &uio) == 0)
+    return count;
+  return (n - uio.uio_resid) / size;
+}
diff --git a/newlib/libc/stdio/getc.c b/newlib/libc/stdio/getc.c
new file mode 100644
index 000000000..4b2509737
--- /dev/null
+++ b/newlib/libc/stdio/getc.c
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+/*
+FUNCTION
+<<getc>>---read a character (macro)
+
+INDEX
+	getc
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	int getc(FILE *<[fp]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	int getc(<[fp]>)
+	FILE *<[fp]>;
+
+DESCRIPTION
+<<getc>> is a macro, defined in <<stdio.h>>.  You can use <<getc>>
+to get the next single character from the file or stream
+identified by <[fp]>.  As a side effect, <<getc>> advances the file's
+current position indicator.
+
+For a subroutine version of this macro, see <<fgetc>>.
+
+RETURNS
+The next character (read as an <<unsigned char>>, and cast to
+<<int>>), unless there is no more data, or the host system reports a
+read error; in either of these situations, <<getc>> returns <<EOF>>.
+
+You can distinguish the two situations that cause an <<EOF>> result by
+using the <<ferror>> and <<feof>> functions.
+
+PORTABILITY
+ANSI C requires <<getc>>; it suggests, but does not require, that
+<<getc>> be implemented as a macro.  The standard explicitly permits
+macro implementations of <<getc>> to use the argument more than once;
+therefore, in a portable program, you should not use an expression
+with side effects as the <<getc>> argument.
+
+Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
+<<lseek>>, <<read>>, <<sbrk>>, <<write>>.
+*/
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "%W% (Berkeley) %G%";
+#endif /* LIBC_SCCS and not lint */
+
+#include <stdio.h>
+
+/*
+ * A subroutine version of the macro getc.
+ */
+
+#undef getc
+
+int
+getc (fp)
+     register FILE *fp;
+{
+  /* CHECK_INIT is called (eventually) by __srefill.  */
+
+  return __sgetc (fp);
+}
diff --git a/newlib/libc/stdio/getchar.c b/newlib/libc/stdio/getchar.c
new file mode 100644
index 000000000..475cd138b
--- /dev/null
+++ b/newlib/libc/stdio/getchar.c
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+/*
+FUNCTION
+<<getchar>>---read a character (macro)
+
+INDEX
+	getchar
+INDEX
+	_getchar_r
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	int getchar(void);
+
+	int _getchar_r(void *<[reent]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	int getchar();
+
+	int _getchar_r(<[reent]>)
+	char * <[reent]>;
+
+DESCRIPTION
+<<getchar>> is a macro, defined in <<stdio.h>>.  You can use <<getchar>>
+to get the next single character from the standard input stream.
+As a side effect, <<getchar>> advances the standard input's
+current position indicator.
+
+The alternate function <<_getchar_r>> is a reentrant version.  The
+extra argument <[reent]> is a pointer to a reentrancy structure.
+
+
+RETURNS
+The next character (read as an <<unsigned char>>, and cast to
+<<int>>), unless there is no more data, or the host system reports a
+read error; in either of these situations, <<getchar>> returns <<EOF>>.
+
+You can distinguish the two situations that cause an <<EOF>> result by
+using `<<ferror(stdin)>>' and `<<feof(stdin)>>'.
+
+PORTABILITY
+ANSI C requires <<getchar>>; it suggests, but does not require, that
+<<getchar>> be implemented as a macro.
+
+Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
+<<lseek>>, <<read>>, <<sbrk>>, <<write>>.
+*/
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "%W% (Berkeley) %G%";
+#endif /* LIBC_SCCS and not lint */
+
+/*
+ * A subroutine version of the macro getchar.
+ */
+
+#include <stdio.h>
+#include <reent.h>
+
+#undef getchar
+
+int
+_getchar_r (f)
+     struct _reent *f;
+{
+  return getc (_stdin_r (f));
+}
+
+#ifndef _REENT_ONLY
+
+int
+getchar ()
+{
+  /* CHECK_INIT is called (eventually) by __srefill.  */
+
+  return _getchar_r (_REENT);
+}
+
+#endif
diff --git a/newlib/libc/stdio/gets.c b/newlib/libc/stdio/gets.c
new file mode 100644
index 000000000..796100e32
--- /dev/null
+++ b/newlib/libc/stdio/gets.c
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+
+/*
+
+FUNCTION
+        <<gets>>---get character string (obsolete, use <<fgets>> instead)
+INDEX
+	gets
+INDEX
+	_gets_r
+
+ANSI_SYNOPSIS
+        #include <stdio.h>
+
+	char *gets(char *<[buf]>);
+
+	char *_gets_r(void *<[reent]>, char *<[buf]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+
+	char *gets(<[buf]>)
+	char *<[buf]>;
+
+	char *_gets_r(<[reent]>, <[buf]>)
+	char *<[reent]>;
+	char *<[buf]>;
+
+DESCRIPTION
+	Reads characters from standard input until a newline is found.
+	The characters up to the newline are stored in <[buf]>. The
+	newline is discarded, and the buffer is terminated with a 0.
+
+	This is a @emph{dangerous} function, as it has no way of checking
+	the amount of space available in <[buf]>. One of the attacks
+	used by the Internet Worm of 1988 used this to overrun a
+	buffer allocated on the stack of the finger daemon and
+	overwrite the return address, causing the daemon to execute
+	code downloaded into it over the connection.
+
+	The alternate function <<_gets_r>> is a reentrant version.  The extra
+	argument <[reent]> is a pointer to a reentrancy structure.
+
+
+RETURNS
+	<<gets>> returns the buffer passed to it, with the data filled
+	in. If end of file occurs with some data already accumulated,
+	the data is returned with no other indication. If end of file
+	occurs with no data in the buffer, NULL is returned.
+
+Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
+<<lseek>>, <<read>>, <<sbrk>>, <<write>>.
+*/
+
+#include <stdio.h>
+
+char *
+_gets_r (ptr, buf)
+     struct _reent *ptr;
+     char *buf;
+{
+  register int c;
+  register char *s = buf;
+
+  while ((c = _getchar_r (ptr)) != '\n')
+    if (c == EOF)
+      if (s == buf)
+	return NULL;
+      else
+	break;
+    else
+      *s++ = c;
+  *s = 0;
+  return buf;
+}
+
+#ifndef _REENT_ONLY
+
+char *
+gets (buf)
+     char *buf;
+{
+  return _gets_r (_REENT, buf);
+}
+
+#endif
diff --git a/newlib/libc/stdio/iprintf.c b/newlib/libc/stdio/iprintf.c
new file mode 100644
index 000000000..f05404302
--- /dev/null
+++ b/newlib/libc/stdio/iprintf.c
@@ -0,0 +1,118 @@
+/*
+FUNCTION
+        <<iprintf>>---write formatted output (integer only)
+INDEX
+	iprintf
+
+ANSI_SYNOPSIS
+        #include <stdio.h>
+
+        int iprintf(const char *<[format]>, ...);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+
+	int iprintf(<[format]> [, <[arg]>, ...])
+	char *<[format]>;
+
+DESCRIPTION
+<<iprintf>> is a restricted version of <<printf>>: it has the same
+arguments and behavior, save that it cannot perform any floating-point
+formatting: the <<f>>, <<g>>, <<G>>, <<e>>, and <<F>> type specifiers
+are not recognized.
+
+RETURNS
+        <<iprintf>> returns the number of bytes in the output string,
+        save that the concluding <<NULL>> is not counted.
+        <<iprintf>> returns when the end of the format string is
+        encountered.  If an error occurs, <<iprintf>>
+        returns <<EOF>>.
+
+PORTABILITY
+<<iprintf>> is not required by ANSI C.
+
+Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
+<<lseek>>, <<read>>, <<sbrk>>, <<write>>.
+*/
+
+#include <_ansi.h>
+#include <stdio.h>
+
+#ifndef _REENT_ONLY
+
+#ifdef _HAVE_STDC
+
+#include <stdarg.h>
+
+int
+iprintf (const char *fmt,...)
+{
+  int ret;
+  va_list ap;
+
+  va_start (ap, fmt);
+  _stdout_r (_REENT)->_data = _REENT;
+  ret = vfiprintf (stdout, fmt, ap);
+  va_end (ap);
+  return ret;
+}
+
+#else
+
+#include <varargs.h>
+
+int
+iprintf (fmt, va_alist)
+     char *fmt;
+     va_dcl
+{
+  int ret;
+  va_list ap;
+
+  va_start (ap);
+  _stdout_r (_REENT)->_data = _REENT;
+  ret = vfiprintf (stdout, fmt, ap);
+  va_end (ap);
+  return ret;
+}
+
+#endif /* ! _HAVE_STDC */
+#endif /* ! _REENT_ONLY */
+
+#ifdef _HAVE_STDC
+
+#include <stdarg.h>
+
+int
+_iprintf_r (struct _reent *ptr, const char *fmt, ...)
+{
+  int ret;
+  va_list ap;
+
+  va_start (ap, fmt);
+  ret = vfiprintf (_stdout_r (ptr), fmt, ap);
+  va_end (ap);
+  return ret;
+}
+
+#else
+
+#include <varargs.h>
+
+int
+_iprintf_r (data, fmt, va_alist)
+     char *data;
+     char *fmt;
+     va_dcl
+{
+  int ret;
+  struct _reent *ptr = data;
+  va_list ap;
+
+  va_start (ap);
+  ret = vfiprintf (_stdout_r (ptr), fmt, ap);
+  va_end (ap);
+  return ret;
+}
+
+#endif
diff --git a/newlib/libc/stdio/local.h b/newlib/libc/stdio/local.h
new file mode 100644
index 000000000..71e80cc09
--- /dev/null
+++ b/newlib/libc/stdio/local.h
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *	%W% (UofMD/Berkeley) %G%
+ */
+
+/*
+ * Information local to this implementation of stdio,
+ * in particular, macros and private variables.
+ */
+
+#include <_ansi.h>
+#include <stdarg.h>
+#include <reent.h>
+#include <unistd.h>
+
+extern int    _EXFUN(__svfscanf,(FILE *, _CONST char *,va_list));
+extern FILE  *_EXFUN(__sfp,(struct _reent *));
+extern int    _EXFUN(__sflags,(struct _reent *,_CONST char*, int*));
+extern int    _EXFUN(__srefill,(FILE *));
+extern int    _EXFUN(__sread,(void *, char *, int));
+extern int    _EXFUN(__swrite,(void *, char const *, int));
+extern fpos_t _EXFUN(__sseek,(void *, fpos_t, int));
+extern int    _EXFUN(__sclose,(void *));
+extern void   _EXFUN(__sinit,(struct _reent *));
+extern void   _EXFUN(_cleanup_r,(struct _reent *));
+extern void   _EXFUN(__smakebuf,(FILE *));
+extern int    _EXFUN(_fwalk,(struct _reent *, int (*)(FILE *)));
+struct _glue * _EXFUN(__sfmoreglue,(struct _reent *,int n));
+extern int   _EXFUN(__srefill,(FILE *fp));
+
+/* Called by the main entry point fns to ensure stdio has been initialized.  */
+
+#define CHECK_INIT(fp) \
+  do					\
+    {					\
+      if ((fp)->_data == 0)		\
+	(fp)->_data = _REENT;		\
+      if (!(fp)->_data->__sdidinit)	\
+	__sinit ((fp)->_data);		\
+    }					\
+  while (0)
+
+/* Return true iff the given FILE cannot be written now.  */
+
+#define	cantwrite(fp) \
+  ((((fp)->_flags & __SWR) == 0 || (fp)->_bf._base == NULL) && \
+   __swsetup(fp))
+
+/* Test whether the given stdio file has an active ungetc buffer;
+   release such a buffer, without restoring ordinary unread data.  */
+
+#define	HASUB(fp) ((fp)->_ub._base != NULL)
+#define	FREEUB(fp) { \
+	if ((fp)->_ub._base != (fp)->_ubuf) \
+		_free_r(fp->_data, (char *)(fp)->_ub._base); \
+	(fp)->_ub._base = NULL; \
+}
+
+/* Test for an fgetline() buffer.  */
+
+#define	HASLB(fp) ((fp)->_lb._base != NULL)
+#define	FREELB(fp) { _free_r(fp->_data,(char *)(fp)->_lb._base); (fp)->_lb._base = NULL; }
+
+/* WARNING: _dcvt is defined in the stdlib directory, not here!  */
+
+char *_EXFUN(_dcvt,(struct _reent *, char *, double, int, int, char, int));
+char *_EXFUN(_sicvt,(char *, short, char));
+char *_EXFUN(_icvt,(char *, int, char));
+char *_EXFUN(_licvt,(char *, long, char));
+#ifdef __GNUC__
+char *_EXFUN(_llicvt,(char *, long long, char));
+#endif
+
+#define CVT_BUF_SIZE 128
+
+#define	NDYNAMIC 4	/* add four more whenever necessary */
diff --git a/newlib/libc/stdio/makebuf.c b/newlib/libc/stdio/makebuf.c
new file mode 100644
index 000000000..4a09c4d50
--- /dev/null
+++ b/newlib/libc/stdio/makebuf.c
@@ -0,0 +1,96 @@
+/* No user fns here.  Pesch 15apr92. */
+
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/unistd.h>
+
+#include "local.h"
+
+/*
+ * Allocate a file buffer, or switch to unbuffered I/O.
+ * Per the ANSI C standard, ALL tty devices default to line buffered.
+ *
+ * As a side effect, we set __SOPT or __SNPT (en/dis-able fseek
+ * optimization) right after the _fstat() that finds the buffer size.
+ */
+
+void
+__smakebuf (fp)
+     register FILE *fp;
+{
+  register size_t size, couldbetty;
+  register _PTR p;
+  struct stat st;
+
+  if (fp->_flags & __SNBF)
+    {
+      fp->_bf._base = fp->_p = fp->_nbuf;
+      fp->_bf._size = 1;
+      return;
+    }
+  if (fp->_file < 0 || _fstat_r (fp->_data, fp->_file, &st) < 0)
+    {
+      couldbetty = 0;
+      size = BUFSIZ;
+      /* do not try to optimise fseek() */
+      fp->_flags |= __SNPT;
+    }
+  else
+    {
+      couldbetty = (st.st_mode & S_IFMT) == S_IFCHR;
+#ifdef HAVE_BLKSIZE
+      size = st.st_blksize <= 0 ? BUFSIZ : st.st_blksize;
+#else
+      size = BUFSIZ;
+#endif
+      /*
+       * Optimize fseek() only if it is a regular file.
+       * (The test for __sseek is mainly paranoia.)
+       */
+      if ((st.st_mode & S_IFMT) == S_IFREG && fp->_seek == __sseek)
+	{
+	  fp->_flags |= __SOPT;
+#ifdef HAVE_BLKSIZE
+	  fp->_blksize = st.st_blksize;
+#else
+	  fp->_blksize = 1024;
+#endif
+	}
+      else
+	fp->_flags |= __SNPT;
+    }
+  if ((p = _malloc_r (fp->_data, size)) == NULL)
+    {
+      fp->_flags |= __SNBF;
+      fp->_bf._base = fp->_p = fp->_nbuf;
+      fp->_bf._size = 1;
+    }
+  else
+    {
+      fp->_data->__cleanup = _cleanup_r;
+      fp->_flags |= __SMBF;
+      fp->_bf._base = fp->_p = (unsigned char *) p;
+      fp->_bf._size = size;
+      if (couldbetty && isatty (fp->_file))
+	fp->_flags |= __SLBF;
+    }
+}
diff --git a/newlib/libc/stdio/mktemp.c b/newlib/libc/stdio/mktemp.c
new file mode 100644
index 000000000..f6a6b688f
--- /dev/null
+++ b/newlib/libc/stdio/mktemp.c
@@ -0,0 +1,219 @@
+/* This is file MKTEMP.C */
+/* This file may have been modified by DJ Delorie (Jan 1991).  If so,
+** these modifications are Coyright (C) 1991 DJ Delorie, 24 Kirsten Ave,
+** Rochester NH, 03867-2954, USA.
+*/
+
+/*
+ * Copyright (c) 1987 Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that: (1) source distributions retain this entire copyright
+ * notice and comment, and (2) distributions including binaries display
+ * the following acknowledgement:  ``This product includes software
+ * developed by the University of California, Berkeley and its contributors''
+ * in the documentation or other materials provided with the distribution
+ * and in all advertising materials mentioning features or use of this
+ * software. Neither the name of the University nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+/*
+FUNCTION
+<<mktemp>>, <<mkstemp>>---generate unused file name
+
+INDEX
+	mktemp
+INDEX
+	mkstemp
+INDEX
+	_mktemp_r
+INDEX
+	_mkstemp_r
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	char *mktemp(char *<[path]>);
+	int mkstemp(char *<[path]>);
+
+	char *_mktemp_r(void *<[reent]>, char *<[path]>);
+	int *_mkstemp_r(void *<[reent]>, char *<[path]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	char *mktemp(<[path]>)
+	char *<[path]>;
+
+	int mkstemp(<[path]>)
+	char *<[path]>;
+
+	char *_mktemp_r(<[reent]>, <[path]>)
+	char *<[reent]>;
+	char *<[path]>;
+
+	int _mkstemp_r(<[reent]>, <[path]>)
+	char *<[reent]>;
+	char *<[path]>;
+
+DESCRIPTION
+<<mktemp>> and <<mkstemp>> attempt to generate a file name that is not
+yet in use for any existing file.  <<mkstemp>> creates the file and 
+opens it for reading and writing; <<mktemp>> simply generates the file name.
+
+You supply a simple pattern for the generated file name, as the string
+at <[path]>.  The pattern should be a valid filename (including path
+information if you wish) ending with some number of `<<X>>'
+characters.  The generated filename will match the leading part of the
+name you supply, with the trailing `<<X>>' characters replaced by some
+combination of digits and letters.
+
+The alternate functions <<_mktemp_r>> and <<_mkstemp_r>> are reentrant
+versions.  The extra argument <[reent]> is a pointer to a reentrancy
+structure.
+
+RETURNS
+<<mktemp>> returns the pointer <[path]> to the modified string
+representing an unused filename, unless it could not generate one, or
+the pattern you provided is not suitable for a filename; in that case,
+it returns <<NULL>>.
+
+<<mkstemp>> returns a file descriptor to the newly created file,
+unless it could not generate an unused filename, or the pattern you
+provided is not suitable for a filename; in that case, it returns
+<<-1>>.
+
+PORTABILITY
+ANSI C does not require either <<mktemp>> or <<mkstemp>>; the System
+V Interface Definition requires <<mktemp>> as of Issue 2.
+
+Supporting OS subroutines required: <<getpid>>, <<open>>, <<stat>>.
+*/
+
+#include <sys/types.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <reent.h>
+
+static
+_DEFUN (_gettemp, (ptr, path, doopen),
+	struct _reent *ptr _AND
+	char *path _AND
+	register int *doopen)
+{
+  register char *start, *trv;
+  struct stat sbuf;
+  unsigned int pid;
+
+  pid = _getpid_r (ptr);
+  for (trv = path; *trv; ++trv)		/* extra X's get set to 0's */
+    continue;
+  while (*--trv == 'X')
+    {
+      *trv = (pid % 10) + '0';
+      pid /= 10;
+    }
+
+  /*
+   * Check the target directory; if you have six X's and it
+   * doesn't exist this runs for a *very* long time.
+   */
+
+  for (start = trv + 1;; --trv)
+    {
+      if (trv <= path)
+	break;
+      if (*trv == '/')
+	{
+	  *trv = '\0';
+	  if (_stat_r (ptr, path, &sbuf))
+	    return (0);
+	  if (!(sbuf.st_mode & S_IFDIR))
+	    {
+	      ptr->_errno = ENOTDIR;
+	      return (0);
+	    }
+	  *trv = '/';
+	  break;
+	}
+    }
+
+  for (;;)
+    {
+      if (doopen)
+	{
+	  if ((*doopen = _open_r (ptr, path, O_CREAT | O_EXCL | O_RDWR, 0600))
+	      >= 0)
+	    return 1;
+#if defined(__CYGWIN32__) || defined(__CYGWIN__)
+	  if (ptr->_errno != EEXIST && ptr->_errno != EACCES)
+#else
+	  if (ptr->_errno != EEXIST)
+#endif
+	    return 0;
+	}
+      else if (_stat_r (ptr, path, &sbuf))
+	return (ptr->_errno == ENOENT ? 1 : 0);
+
+      /* tricky little algorithm for backward compatibility */
+      for (trv = start;;)
+	{
+	  if (!*trv)
+	    return 0;
+	  if (*trv == 'z')
+	    *trv++ = 'a';
+	  else
+	    {
+	      if (isdigit (*trv))
+		*trv = 'a';
+	      else
+		++ * trv;
+	      break;
+	    }
+	}
+    }
+  /*NOTREACHED*/
+}
+
+_DEFUN (_mkstemp_r, (ptr, path),
+	struct _reent *ptr _AND
+	char *path)
+{
+  int fd;
+
+  return (_gettemp (ptr, path, &fd) ? fd : -1);
+}
+
+char *
+_DEFUN (_mktemp_r, (ptr, path),
+	struct _reent *ptr _AND
+	char *path)
+{
+  return (_gettemp (ptr, path, (int *) NULL) ? path : (char *) NULL);
+}
+
+#ifndef _REENT_ONLY
+
+_DEFUN (mkstemp, (path),
+	char *path)
+{
+  int fd;
+
+  return (_gettemp (_REENT, path, &fd) ? fd : -1);
+}
+
+char *
+_DEFUN (mktemp, (path),
+	char *path)
+{
+  return (_gettemp (_REENT, path, (int *) NULL) ? path : (char *) NULL);
+}
+
+#endif /* ! defined (_REENT_ONLY) */
diff --git a/newlib/libc/stdio/perror.c b/newlib/libc/stdio/perror.c
new file mode 100644
index 000000000..abb595ba9
--- /dev/null
+++ b/newlib/libc/stdio/perror.c
@@ -0,0 +1,80 @@
+/*
+FUNCTION
+<<perror>>---print an error message on standard error
+
+INDEX
+	perror
+INDEX
+	_perror_r
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	void perror(char *<[prefix]>);
+
+	void _perror_r(void *<[reent]>, char *<[prefix]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	void perror(<[prefix]>)
+	char *<[prefix]>;
+
+	void _perror_r(<[reent]>, <[prefix]>)
+	char *<[reent]>;
+	char *<[prefix]>;
+
+DESCRIPTION
+Use <<perror>> to print (on standard error) an error message
+corresponding to the current value of the global variable <<errno>>.
+Unless you use <<NULL>> as the value of the argument <[prefix]>, the
+error message will begin with the string at <[prefix]>, followed by a
+colon and a space (<<: >>). The remainder of the error message is one
+of the strings described for <<strerror>>.
+
+The alternate function <<_perror_r>> is a reentrant version.  The
+extra argument <[reent]> is a pointer to a reentrancy structure.
+
+
+RETURNS
+<<perror>> returns no result.
+
+PORTABILITY
+ANSI C requires <<perror>>, but the strings issued vary from one
+implementation to another.
+
+Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
+<<lseek>>, <<read>>, <<sbrk>>, <<write>>.
+*/
+
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+
+void
+_DEFUN (_perror_r, (ptr, s),
+	struct _reent *ptr _AND
+	_CONST char *s)
+{
+  char *error;
+
+  if (s != NULL && *s != '\0')
+    {
+      fputs (s, _stderr_r (ptr));
+      fputs (": ", _stderr_r (ptr));
+    }
+
+  if ((error = strerror (ptr->_errno)) != NULL)
+    fputs (error, _stderr_r (ptr));
+
+  fputc ('\n', _stderr_r (ptr));
+}
+
+#ifndef _REENT_ONLY
+
+void
+_DEFUN (perror, (s),
+	_CONST char *s)
+{
+  _perror_r (_REENT, s);
+}
+
+#endif
diff --git a/newlib/libc/stdio/printf.c b/newlib/libc/stdio/printf.c
new file mode 100644
index 000000000..81fb8a2cb
--- /dev/null
+++ b/newlib/libc/stdio/printf.c
@@ -0,0 +1,83 @@
+
+#include <_ansi.h>
+#include <stdio.h>
+
+#ifdef _HAVE_STDC
+
+#include <stdarg.h>
+
+int
+_printf_r (struct _reent *ptr, const char *fmt, ...)
+{
+  int ret;
+  va_list ap;
+
+  va_start (ap, fmt);
+  ret = _vfprintf_r (ptr, _stdout_r (ptr), fmt, ap);
+  va_end (ap);
+  return ret;
+}
+
+#else
+
+#include <varargs.h>
+
+int
+_printf_r (ptr, fmt, va_alist)
+     struct _reent *ptr;
+     char *fmt;
+     va_dcl
+{
+  int ret;
+  va_list ap;
+
+  va_start (ap);
+  ret = _vfprintf_r (ptr, _stdout_r (ptr), fmt, ap);
+  va_end (ap);
+  return ret;
+}
+
+#endif
+
+
+#ifndef _REENT_ONLY
+
+#ifdef _HAVE_STDC
+
+#include <stdarg.h>
+
+int
+printf (const char *fmt, ...)
+{
+  int ret;
+  va_list ap;
+
+  va_start (ap, fmt);
+  _stdout_r (_REENT)->_data = _REENT;
+  ret = vfprintf (_stdout_r (_REENT), fmt, ap);
+  va_end (ap);
+  return ret;
+}
+
+#else
+
+#include <varargs.h>
+
+int
+printf (fmt, va_alist)
+     char *fmt;
+     va_dcl
+{
+  int ret;
+  va_list ap;
+
+  va_start (ap);
+  _stdout_r (_REENT)->_data = _REENT;
+  ret = vfprintf (_stdout_r (_REENT), fmt, ap);
+  va_end (ap);
+  return ret;
+}
+
+#endif /* ! _HAVE_STDC */
+
+#endif /* ! _REENT_ONLY */
diff --git a/newlib/libc/stdio/putc.c b/newlib/libc/stdio/putc.c
new file mode 100644
index 000000000..27a7a4280
--- /dev/null
+++ b/newlib/libc/stdio/putc.c
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+/*
+FUNCTION
+<<putc>>---write a character (macro)
+
+INDEX
+	putc
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	int putc(int <[ch]>, FILE *<[fp]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	int putc(<[ch]>, <[fp]>)
+	int <[ch]>;
+	FILE *<[fp]>;
+
+DESCRIPTION
+<<putc>> is a macro, defined in <<stdio.h>>.  <<putc>>
+writes the argument <[ch]> to the file or stream identified by
+<[fp]>, after converting it from an <<int>> to an <<unsigned char>>.
+
+If the file was opened with append mode (or if the stream cannot
+support positioning), then the new character goes at the end of the
+file or stream.  Otherwise, the new character is written at the
+current value of the position indicator, and the position indicator
+advances by one.
+
+For a subroutine version of this macro, see <<fputc>>.
+
+RETURNS
+If successful, <<putc>> returns its argument <[ch]>.  If an error
+intervenes, the result is <<EOF>>.  You can use `<<ferror(<[fp]>)>>' to
+query for errors.
+
+PORTABILITY
+ANSI C requires <<putc>>; it suggests, but does not require, that
+<<putc>> be implemented as a macro.  The standard explicitly permits
+macro implementations of <<putc>> to use the <[fp]> argument more than once;
+therefore, in a portable program, you should not use an expression
+with side effects as this argument.
+
+Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
+<<lseek>>, <<read>>, <<sbrk>>, <<write>>.
+*/
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "%W% (Berkeley) %G%";
+#endif /* LIBC_SCCS and not lint */
+
+#include <stdio.h>
+
+/*
+ * A subroutine version of the macro putc.
+ */
+
+#undef putc
+
+int
+putc (c, fp)
+     int c;
+     register FILE *fp;
+{
+  /* CHECK_INIT is (eventually) called by __swbuf.  */
+
+  return __sputc (c, fp);
+}
diff --git a/newlib/libc/stdio/putchar.c b/newlib/libc/stdio/putchar.c
new file mode 100644
index 000000000..7f7c442e4
--- /dev/null
+++ b/newlib/libc/stdio/putchar.c
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+/*
+FUNCTION
+<<putchar>>---write a character (macro)
+
+INDEX
+	putchar
+INDEX
+	_putchar_r
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	int putchar(int <[ch]>);
+
+	int _putchar_r(void *<[reent]>, int <[ch]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	int putchar(<[ch]>)
+	int <[ch]>;
+
+	int _putchar_r(<[reent]>, <[ch]>)
+	char *<[reent]>;
+	int <[ch]>;
+
+DESCRIPTION
+<<putchar>> is a macro, defined in <<stdio.h>>.  <<putchar>>
+writes its argument to the standard output stream,
+after converting it from an <<int>> to an <<unsigned char>>.
+
+The alternate function <<_putchar_r>> is a reentrant version.  The
+extra argument <[reent]> is a pointer to a reentrancy structure.
+
+RETURNS
+If successful, <<putchar>> returns its argument <[ch]>.  If an error
+intervenes, the result is <<EOF>>.  You can use `<<ferror(stdin)>>' to
+query for errors.
+
+PORTABILITY
+ANSI C requires <<putchar>>; it suggests, but does not require, that
+<<putchar>> be implemented as a macro.
+
+Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
+<<lseek>>, <<read>>, <<sbrk>>, <<write>>.
+*/
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "%W% (Berkeley) %G%";
+#endif /* LIBC_SCCS and not lint */
+
+/*
+ * A subroutine version of the macro putchar
+ */
+
+#include <stdio.h>
+
+#undef putchar
+
+int
+_putchar_r (ptr, c)
+     struct _reent *ptr;
+     int c;
+{
+  return __sputc (c, _stdout_r (ptr));
+}
+
+#ifndef _REENT_ONLY
+
+int
+putchar (c)
+     int c;
+{
+  /* CHECK_INIT is (eventually) called by __swbuf.  */
+
+  _putchar_r (_REENT, c);
+}
+
+#endif
diff --git a/newlib/libc/stdio/puts.c b/newlib/libc/stdio/puts.c
new file mode 100644
index 000000000..44f17cc91
--- /dev/null
+++ b/newlib/libc/stdio/puts.c
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+/*
+FUNCTION
+<<puts>>---write a character string
+
+INDEX
+	puts
+INDEX
+	_puts_r
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	int puts(const char *<[s]>);
+
+	int _puts_r(void *<[reent]>, const char *<[s]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	int puts(<[s]>)
+	char *<[s]>;
+
+	int _puts_r(<[reent]>, <[s]>)
+	char *<[reent]>;
+	char *<[s]>;
+
+DESCRIPTION
+<<puts>> writes the string at <[s]> (followed by a newline, instead of
+the trailing null) to the standard output stream.
+
+The alternate function <<_puts_r>> is a reentrant version.  The extra
+argument <[reent]> is a pointer to a reentrancy structure.
+
+RETURNS
+If successful, the result is a nonnegative integer; otherwise, the
+result is <<EOF>>.
+
+PORTABILITY
+ANSI C requires <<puts>>, but does not specify that the result on
+success must be <<0>>; any non-negative value is permitted.
+
+Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
+<<lseek>>, <<read>>, <<sbrk>>, <<write>>.  */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "%W% (Berkeley) %G%";
+#endif /* LIBC_SCCS and not lint */
+
+#include <stdio.h>
+#include <string.h>
+#include "fvwrite.h"
+
+/*
+ * Write the given string to stdout, appending a newline.
+ */
+
+int
+_DEFUN (_puts_r, (ptr, s),
+	struct _reent *ptr _AND
+	_CONST char * s)
+{
+  size_t c = strlen (s);
+  struct __suio uio;
+  struct __siov iov[2];
+
+  iov[0].iov_base = s;
+  iov[0].iov_len = c;
+  iov[1].iov_base = "\n";
+  iov[1].iov_len = 1;
+  uio.uio_resid = c + 1;
+  uio.uio_iov = &iov[0];
+  uio.uio_iovcnt = 2;
+
+  return (__sfvwrite (_stdout_r (ptr), &uio) ? EOF : '\n');
+}
+
+#ifndef _REENT_ONLY
+
+int
+_DEFUN (puts, (s),
+	char _CONST * s)
+{
+  return _puts_r (_REENT, s);
+}
+
+#endif
diff --git a/newlib/libc/stdio/refill.c b/newlib/libc/stdio/refill.c
new file mode 100644
index 000000000..bc3b83047
--- /dev/null
+++ b/newlib/libc/stdio/refill.c
@@ -0,0 +1,113 @@
+/* No user fns here.  Pesch 15apr92. */
+
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include <stdio.h>
+#include "local.h"
+#include <stdlib.h>
+
+static int
+lflush (fp)
+     FILE *fp;
+{
+  if ((fp->_flags & (__SLBF | __SWR)) == __SLBF | __SWR)
+    return fflush (fp);
+  return 0;
+}
+
+/*
+ * Refill a stdio buffer.
+ * Return EOF on eof or error, 0 otherwise.
+ */
+
+int
+_DEFUN (__srefill, (fp),
+	register FILE * fp)
+{
+  /* make sure stdio is set up */
+
+  CHECK_INIT (fp);
+
+  fp->_r = 0;			/* largely a convenience for callers */
+
+  /* SysV does not make this test; take it out for compatibility */
+  if (fp->_flags & __SEOF)
+    return EOF;
+
+  /* if not already reading, have to be reading and writing */
+  if ((fp->_flags & __SRD) == 0)
+    {
+      if ((fp->_flags & __SRW) == 0)
+	return EOF;
+      /* switch to reading */
+      if (fp->_flags & __SWR)
+	{
+	  if (fflush (fp))
+	    return EOF;
+	  fp->_flags &= ~__SWR;
+	  fp->_w = 0;
+	  fp->_lbfsize = 0;
+	}
+      fp->_flags |= __SRD;
+    }
+  else
+    {
+      /*
+       * We were reading.  If there is an ungetc buffer,
+       * we must have been reading from that.  Drop it,
+       * restoring the previous buffer (if any).  If there
+       * is anything in that buffer, return.
+       */
+      if (HASUB (fp))
+	{
+	  FREEUB (fp);
+	  if ((fp->_r = fp->_ur) != 0)
+	    {
+	      fp->_p = fp->_up;
+	      return 0;
+	    }
+	}
+    }
+
+  if (fp->_bf._base == NULL)
+    __smakebuf (fp);
+
+  /*
+   * Before reading from a line buffered or unbuffered file,
+   * flush all line buffered output files, per the ANSI C
+   * standard.
+   */
+
+  if (fp->_flags & (__SLBF | __SNBF))
+    (void) _fwalk (fp->_data, lflush);
+  fp->_p = fp->_bf._base;
+  fp->_r = (*fp->_read) (fp->_cookie, (char *) fp->_p, fp->_bf._size);
+  fp->_flags &= ~__SMOD;	/* buffer contents are again pristine */
+  if (fp->_r <= 0)
+    {
+      if (fp->_r == 0)
+	fp->_flags |= __SEOF;
+      else
+	{
+	  fp->_r = 0;
+	  fp->_flags |= __SERR;
+	}
+      return EOF;
+    }
+  return 0;
+}
diff --git a/newlib/libc/stdio/remove.c b/newlib/libc/stdio/remove.c
new file mode 100644
index 000000000..074dd9ac8
--- /dev/null
+++ b/newlib/libc/stdio/remove.c
@@ -0,0 +1,69 @@
+/*
+FUNCTION
+<<remove>>---delete a file's name
+
+INDEX
+	remove
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	int remove(char *<[filename]>);
+
+	int _remove_r(void *<[reent]>, char *<[filename]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	int remove(<[filename]>)
+	char *<[filename]>;
+
+	int _remove_r(<[reent]>, <[filename]>)
+	char *<[reent]>;
+	char *<[filename]>;
+
+DESCRIPTION
+Use <<remove>> to dissolve the association between a particular
+filename (the string at <[filename]>) and the file it represents.
+After calling <<remove>> with a particular filename, you will no
+longer be able to open the file by that name.
+
+In this implementation, you may use <<remove>> on an open file without
+error; existing file descriptors for the file will continue to access
+the file's data until the program using them closes the file.
+
+The alternate function <<_remove_r>> is a reentrant version.  The
+extra argument <[reent]> is a pointer to a reentrancy structure.
+
+RETURNS
+<<remove>> returns <<0>> if it succeeds, <<-1>> if it fails.
+
+PORTABILITY
+ANSI C requires <<remove>>, but only specifies that the result on
+failure be nonzero.  The behavior of <<remove>> when you call it on an
+open file may vary among implementations.
+
+Supporting OS subroutine required: <<unlink>>.
+*/
+
+#include <stdio.h>
+
+int
+_remove_r (ptr, filename)
+     struct _reent *ptr;
+     _CONST char *filename;
+{
+  if (_unlink_r (ptr, filename) == -1)
+    return -1;
+
+  return 0;
+}
+
+#ifndef _REENT_ONLY
+
+int
+remove (filename)
+     _CONST char *filename;
+{
+  return _remove_r (_REENT, filename);
+}
+
+#endif
diff --git a/newlib/libc/stdio/rename.c b/newlib/libc/stdio/rename.c
new file mode 100644
index 000000000..19a6afdd3
--- /dev/null
+++ b/newlib/libc/stdio/rename.c
@@ -0,0 +1,86 @@
+/*
+FUNCTION
+<<rename>>---rename a file
+
+INDEX
+	rename
+INDEX
+	_rename_r
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	int rename(const char *<[old]>, const char *<[new]>);
+
+	int _rename_r(void *<[reent]>, 
+                      const char *<[old]>, const char *<[new]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	int rename(<[old]>, <[new]>)
+	char *<[old]>;
+	char *<[new]>;
+
+	int _rename_r(<[reent]>, <[old]>, <[new]>)
+	char *<[reent]>;
+	char *<[old]>;
+	char *<[new]>;
+
+DESCRIPTION
+Use <<rename>> to establish a new name (the string at <[new]>) for a
+file now known by the string at <[old]>.  After a successful
+<<rename>>, the file is no longer accessible by the string at <[old]>.
+
+If <<rename>> fails, the file named <<*<[old]>>> is unaffected.  The
+conditions for failure depend on the host operating system.
+
+The alternate function <<_rename_r>> is a reentrant version.  The
+extra argument <[reent]> is a pointer to a reentrancy structure.
+
+RETURNS
+The result is either <<0>> (when successful) or <<-1>> (when the file
+could not be renamed).
+
+PORTABILITY
+ANSI C requires <<rename>>, but only specifies that the result on
+failure be nonzero.  The effects of using the name of an existing file
+as <<*<[new]>>> may vary from one implementation to another.
+
+Supporting OS subroutines required: <<link>>, <<unlink>>, or <<rename>>.
+*/
+
+#include <stdio.h>
+#include <sys/unistd.h>
+#include <reent.h>
+
+int
+_rename_r (ptr, old, new)
+     struct _reent *ptr;
+     _CONST char *old;
+     _CONST char *new;
+{
+#ifdef HAVE_RENAME
+  return _rename (old,new);
+#else
+  if (_link_r (ptr, old, new) == -1)
+    return -1;
+
+  if (_unlink_r (ptr, old) == -1)
+    {
+      /* ??? Should we unlink new? (rhetorical question) */
+      return -1;
+    }
+#endif
+  return 0;
+}
+
+#ifndef _REENT_ONLY
+
+int
+rename (old, new)
+     _CONST char *old;
+     _CONST char *new;
+{
+  return _rename_r (_REENT, old, new);
+}
+
+#endif
diff --git a/newlib/libc/stdio/rewind.c b/newlib/libc/stdio/rewind.c
new file mode 100644
index 000000000..905275741
--- /dev/null
+++ b/newlib/libc/stdio/rewind.c
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+/*
+FUNCTION
+<<rewind>>---reinitialize a file or stream
+
+INDEX
+	rewind
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	void rewind(FILE *<[fp]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	void rewind(<[fp]>)
+	FILE *<[fp]>;
+
+DESCRIPTION
+<<rewind>> returns the file position indicator (if any) for the file
+or stream identified by <[fp]> to the beginning of the file.  It also
+clears any error indicator and flushes any pending output.
+
+RETURNS
+<<rewind>> does not return a result.
+
+PORTABILITY
+ANSI C requires <<rewind>>.
+
+No supporting OS subroutines are required.
+*/
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "%W% (Berkeley) %G%";
+#endif /* LIBC_SCCS and not lint */
+
+#include <stdio.h>
+
+void
+_DEFUN (rewind, (fp),
+	register FILE * fp)
+{
+	(void) fseek(fp, 0L, SEEK_SET);
+	clearerr(fp);
+}
diff --git a/newlib/libc/stdio/rget.c b/newlib/libc/stdio/rget.c
new file mode 100644
index 000000000..ea29c2bce
--- /dev/null
+++ b/newlib/libc/stdio/rget.c
@@ -0,0 +1,43 @@
+/* No user fns here. Pesch 15apr92. */
+
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "%W% (Berkeley) %G%";
+#endif /* LIBC_SCCS and not lint */
+
+#include <stdio.h>
+#include "local.h"
+
+/*
+ * Handle getc() when the buffer ran out:
+ * Refill, then return the first character
+ * in the newly-filled buffer.
+ */
+
+int
+__srget (fp)
+     register FILE *fp;
+{
+  if (__srefill (fp) == 0)
+    {
+      fp->_r--;
+      return *fp->_p++;
+    }
+  return EOF;
+}
diff --git a/newlib/libc/stdio/scanf.c b/newlib/libc/stdio/scanf.c
new file mode 100644
index 000000000..0a4818934
--- /dev/null
+++ b/newlib/libc/stdio/scanf.c
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include <_ansi.h>
+#include <stdio.h>
+#include "local.h"
+
+#ifdef _HAVE_STDC
+#include <stdarg.h>
+#else
+#include <varargs.h>
+#endif
+
+#ifndef _REENT_ONLY
+
+int
+#ifdef _HAVE_STDC
+scanf (const char *fmt, ...)
+#else
+scanf (fmt, va_alist)
+     char *fmt;
+     va_dcl
+#endif
+{
+  int ret;
+  va_list ap;
+
+#ifdef _HAVE_STDC
+  va_start (ap, fmt);
+#else
+  va_start (ap);
+#endif
+  ret = __svfscanf (_stdin_r (_REENT), fmt, ap);
+  va_end (ap);
+  return ret;
+}
+
+#endif
+
+int
+#ifdef _HAVE_STDC
+_scanf_r (struct _reent *ptr, const char *fmt, ...)
+#else
+_scanf_r (ptr, fmt, va_alist)
+     struct _reent *ptr;
+     char *fmt;
+     va_dcl
+#endif
+{
+  int ret;
+  va_list ap;
+
+#ifdef _HAVE_STDC
+  va_start (ap, fmt);
+#else
+  va_start (ap);
+#endif
+  ret = __svfscanf (_stdin_r (ptr), fmt, ap);
+  va_end (ap);
+  return (ret);
+}
diff --git a/newlib/libc/stdio/setbuf.c b/newlib/libc/stdio/setbuf.c
new file mode 100644
index 000000000..15d09e0f3
--- /dev/null
+++ b/newlib/libc/stdio/setbuf.c
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+/*
+FUNCTION
+<<setbuf>>---specify full buffering for a file or stream
+
+INDEX
+	setbuf
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	void setbuf(FILE *<[fp]>, char *<[buf]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	void setbuf(<[fp]>, <[buf]>)
+	FILE *<[fp]>;
+	char *<[buf]>;
+
+DESCRIPTION
+<<setbuf>> specifies that output to the file or stream identified by <[fp]>
+should be fully buffered.  All output for this file will go to a
+buffer (of size <<BUFSIZ>>, specified in `<<stdio.h>>').  Output will
+be passed on to the host system only when the buffer is full, or when
+an input operation intervenes.
+
+You may, if you wish, supply your own buffer by passing a pointer to
+it as the argument <[buf]>.  It must have size <<BUFSIZ>>.  You can
+also use <<NULL>> as the value of <[buf]>, to signal that the
+<<setbuf>> function is to allocate the buffer.
+
+WARNINGS
+You may only use <<setbuf>> before performing any file operation other
+than opening the file.
+
+If you supply a non-null <[buf]>, you must ensure that the associated
+storage continues to be available until you close the stream
+identified by <[fp]>.
+
+RETURNS
+<<setbuf>> does not return a result.
+
+PORTABILITY
+Both ANSI C and the System V Interface Definition (Issue 2) require
+<<setbuf>>.  However, they differ on the meaning of a <<NULL>> buffer
+pointer: the SVID issue 2 specification says that a <<NULL>> buffer
+pointer requests unbuffered output.  For maximum portability, avoid
+<<NULL>> buffer pointers.
+
+Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
+<<lseek>>, <<read>>, <<sbrk>>, <<write>>.
+*/
+
+#include <_ansi.h>
+#include <stdio.h>
+#include "local.h"
+
+void
+_DEFUN (setbuf, (fp, buf),
+	FILE * fp _AND
+	char *buf)
+{
+  (void) setvbuf (fp, buf, buf ? _IOFBF : _IONBF, BUFSIZ);
+}
diff --git a/newlib/libc/stdio/setvbuf.c b/newlib/libc/stdio/setvbuf.c
new file mode 100644
index 000000000..357ea5142
--- /dev/null
+++ b/newlib/libc/stdio/setvbuf.c
@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+/*
+FUNCTION
+<<setvbuf>>---specify file or stream buffering
+
+INDEX
+	setvbuf
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	int setvbuf(FILE *<[fp]>, char *<[buf]>,
+	            int <[mode]>, size_t <[size]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	int setvbuf(<[fp]>, <[buf]>, <[mode]>, <[size]>)
+	FILE *<[fp]>;
+	char *<[buf]>;
+	int <[mode]>;
+	size_t <[size]>;
+
+DESCRIPTION
+Use <<setvbuf>> to specify what kind of buffering you want for the
+file or stream identified by <[fp]>, by using one of the following
+values (from <<stdio.h>>) as the <[mode]> argument:
+
+o+
+o _IONBF
+Do not use a buffer: send output directly to the host system for the
+file or stream identified by <[fp]>.
+
+o _IOFBF
+Use full output buffering: output will be passed on to the host system
+only when the buffer is full, or when an input operation intervenes.
+
+o _IOLBF
+Use line buffering: pass on output to the host system at every
+newline, as well as when the buffer is full, or when an input
+operation intervenes.
+o-
+
+Use the <[size]> argument to specify how large a buffer you wish.  You
+can supply the buffer itself, if you wish, by passing a pointer to a
+suitable area of memory as <[buf]>.  Otherwise, you may pass <<NULL>>
+as the <[buf]> argument, and <<setvbuf>> will allocate the buffer.
+
+WARNINGS
+You may only use <<setvbuf>> before performing any file operation other
+than opening the file.
+
+If you supply a non-null <[buf]>, you must ensure that the associated
+storage continues to be available until you close the stream
+identified by <[fp]>.
+
+RETURNS
+A <<0>> result indicates success, <<EOF>> failure (invalid <[mode]> or
+<[size]> can cause failure).
+
+PORTABILITY
+Both ANSI C and the System V Interface Definition (Issue 2) require
+<<setvbuf>>. However, they differ on the meaning of a <<NULL>> buffer
+pointer: the SVID issue 2 specification says that a <<NULL>> buffer
+pointer requests unbuffered output.  For maximum portability, avoid
+<<NULL>> buffer pointers.
+
+Both specifications describe the result on failure only as a
+nonzero value.
+
+Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
+<<lseek>>, <<read>>, <<sbrk>>, <<write>>.
+*/
+
+#include <_ansi.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "local.h"
+
+/*
+ * Set one of the three kinds of buffering, optionally including a buffer.
+ */
+
+int
+_DEFUN (setvbuf, (fp, buf, mode, size),
+	register FILE * fp _AND
+	char *buf _AND
+	register int mode _AND
+	register size_t size)
+{
+  int ret = 0;
+  CHECK_INIT (fp);
+
+  /*
+   * Verify arguments.  The `int' limit on `size' is due to this
+   * particular implementation.
+   */
+
+  if ((mode != _IOFBF && mode != _IOLBF && mode != _IONBF) || (int)(_POINTER_INT) size < 0)
+    return (EOF);
+
+  /*
+   * Write current buffer, if any; drop read count, if any.
+   * Make sure putc() will not think fp is line buffered.
+   * Free old buffer if it was from malloc().  Clear line and
+   * non buffer flags, and clear malloc flag.
+   */
+
+  (void) fflush (fp);
+  fp->_r = 0;
+  fp->_lbfsize = 0;
+  if (fp->_flags & __SMBF)
+    _free_r (fp->_data, (void *) fp->_bf._base);
+  fp->_flags &= ~(__SLBF | __SNBF | __SMBF);
+
+  if (mode == _IONBF)
+    goto nbf;
+
+  /*
+   * Allocate buffer if needed. */
+  if (buf == NULL)
+    {
+      /* we need this here because malloc() may return a pointer
+	 even if size == 0 */
+      if (!size) size = BUFSIZ;
+      if ((buf = malloc (size)) == NULL)
+	{
+	  ret = EOF;
+	  /* Try another size... */
+	  buf = malloc (BUFSIZ);
+	  size = BUFSIZ;
+	}
+      if (buf == NULL)
+	{
+	  /* Can't allocate it, let's try another approach */
+nbf:
+	  fp->_flags |= __SNBF;
+	  fp->_w = 0;
+	  fp->_bf._base = fp->_p = fp->_nbuf;
+	  fp->_bf._size = 1;
+	  return (ret);
+	}
+      fp->_flags |= __SMBF;
+    }
+  /*
+   * Now put back whichever flag is needed, and fix _lbfsize
+   * if line buffered.  Ensure output flush on exit if the
+   * stream will be buffered at all.
+   * If buf is NULL then make _lbfsize 0 to force the buffer
+   * to be flushed and hence malloced on first use
+   */
+
+  switch (mode)
+    {
+    case _IOLBF:
+      fp->_flags |= __SLBF;
+      fp->_lbfsize = buf ? -size : 0;
+      /* FALLTHROUGH */
+
+    case _IOFBF:
+      /* no flag */
+      fp->_data->__cleanup = _cleanup_r;
+      fp->_bf._base = fp->_p = (unsigned char *) buf;
+      fp->_bf._size = size;
+      break;
+    }
+
+  /*
+   * Patch up write count if necessary.
+   */
+
+  if (fp->_flags & __SWR)
+    fp->_w = fp->_flags & (__SLBF | __SNBF) ? 0 : size;
+
+  return 0;
+}
diff --git a/newlib/libc/stdio/siprintf.c b/newlib/libc/stdio/siprintf.c
new file mode 100644
index 000000000..40bd01696
--- /dev/null
+++ b/newlib/libc/stdio/siprintf.c
@@ -0,0 +1,70 @@
+/*
+FUNCTION
+        <<siprintf>>---write formatted output (integer only)
+INDEX
+	siprintf
+
+ANSI_SYNOPSIS
+        #include <stdio.h>
+
+        int siprintf(char *<[str]>, const char *<[format]> [, <[arg]>, ...]);
+
+
+DESCRIPTION
+<<siprintf>> is a restricted version of <<sprintf>>: it has the same
+arguments and behavior, save that it cannot perform any floating-point
+formatting: the <<f>>, <<g>>, <<G>>, <<e>>, and <<F>> type specifiers
+are not recognized.
+
+RETURNS
+        <<siprintf>> returns the number of bytes in the output string,
+        save that the concluding <<NULL>> is not counted.
+        <<siprintf>> returns when the end of the format string is
+        encountered.
+
+PORTABILITY
+<<siprintf>> is not required by ANSI C.
+
+Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
+<<lseek>>, <<read>>, <<sbrk>>, <<write>>.
+*/
+
+#include <stdio.h>
+#ifdef _HAVE_STDC
+#include <stdarg.h>
+#else
+#include <varargs.h>
+#endif
+#include <limits.h>
+#include <_ansi.h>
+#include <reent.h>
+#include "local.h"
+
+int
+#ifdef _HAVE_STDC
+_DEFUN (siprintf, (str, fmt), char *str _AND _CONST char *fmt _DOTS)
+#else
+siprintf (str, fmt, va_alist)
+     char *str;
+     _CONST char *fmt;
+     va_dcl
+#endif
+{
+  int ret;
+  va_list ap;
+  FILE f;
+
+  f._flags = __SWR | __SSTR;
+  f._bf._base = f._p = (unsigned char *) str;
+  f._bf._size = f._w = INT_MAX;
+  f._data = _REENT;
+#ifdef _HAVE_STDC
+  va_start (ap, fmt);
+#else
+  va_start (ap);
+#endif
+  ret = vfiprintf (&f, fmt, ap);
+  va_end (ap);
+  *f._p = 0;
+  return (ret);
+}
diff --git a/newlib/libc/stdio/snprintf.c b/newlib/libc/stdio/snprintf.c
new file mode 100644
index 000000000..333e808e4
--- /dev/null
+++ b/newlib/libc/stdio/snprintf.c
@@ -0,0 +1,95 @@
+/* doc in sprintf.c */
+
+/* This code created by modifying sprintf.c so copyright inherited. */
+
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include <stdio.h>
+#ifdef _HAVE_STDC
+#include <stdarg.h>
+#else
+#include <varargs.h>
+#endif
+#include <limits.h>
+#include <_ansi.h>
+#include "local.h"
+
+int
+#ifdef _HAVE_STDC
+_DEFUN (_snprintf_r, (ptr, str, size, fmt), struct _reent *ptr _AND char *str _AND size_t size _AND _CONST char *fmt _DOTS)
+#else
+_snprintf_r (ptr, str, size, fmt, va_alist)
+     struct _reent *ptr;
+     char *str;
+     size_t size;
+     _CONST char *fmt;
+     va_dcl
+#endif
+{
+  int ret;
+  va_list ap;
+  FILE f;
+
+  f._flags = __SWR | __SSTR;
+  f._bf._base = f._p = (unsigned char *) str;
+  f._bf._size = f._w = size;
+  f._data = ptr;
+#ifdef _HAVE_STDC
+  va_start (ap, fmt);
+#else
+  va_start (ap);
+#endif
+  ret = vfprintf (&f, fmt, ap);
+  va_end (ap);
+  *f._p = 0;
+  return (ret);
+}
+
+#ifndef _REENT_ONLY
+
+int
+#ifdef _HAVE_STDC
+_DEFUN (snprintf, (str, size, fmt), char *str _AND size_t size _AND _CONST char *fmt _DOTS)
+#else
+snprintf (str, size, fmt, va_alist)
+     char *str;
+     size_t size;
+     _CONST char *fmt;
+     va_dcl
+#endif
+{
+  int ret;
+  va_list ap;
+  FILE f;
+
+  f._flags = __SWR | __SSTR;
+  f._bf._base = f._p = (unsigned char *) str;
+  f._bf._size = f._w = size;
+  f._data = _REENT;
+#ifdef _HAVE_STDC
+  va_start (ap, fmt);
+#else
+  va_start (ap);
+#endif
+  ret = vfprintf (&f, fmt, ap);
+  va_end (ap);
+  *f._p = 0;
+  return (ret);
+}
+
+#endif
diff --git a/newlib/libc/stdio/sprintf.c b/newlib/libc/stdio/sprintf.c
new file mode 100644
index 000000000..b5376327e
--- /dev/null
+++ b/newlib/libc/stdio/sprintf.c
@@ -0,0 +1,360 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+/*
+
+FUNCTION
+        <<printf>>, <<fprintf>>, <<sprintf>>, <<snprintf>>---format output
+INDEX
+	fprintf
+INDEX
+	printf
+INDEX
+	sprintf
+INDEX
+	snprintf
+
+ANSI_SYNOPSIS
+        #include <stdio.h>
+
+        int printf(const char *<[format]> [, <[arg]>, ...]);
+        int fprintf(FILE *<[fd]>, const char *<[format]> [, <[arg]>, ...]);
+        int sprintf(char *<[str]>, const char *<[format]> [, <[arg]>, ...]);
+        int snprintf(char *<[str]>, size_t <[size]>, const char *<[format]> [, <[arg]>, ...]);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+
+	int printf(<[format]> [, <[arg]>, ...])
+	char *<[format]>;
+
+	int fprintf(<[fd]>, <[format]> [, <[arg]>, ...]);
+	FILE *<[fd]>;
+	char *<[format]>;
+
+	int sprintf(<[str]>, <[format]> [, <[arg]>, ...]);
+	char *<[str]>;
+	char *<[format]>;
+
+	int snprintf(<[str]>, size_t <[size]>, <[format]> [, <[arg]>, ...]);
+	char *<[str]>;
+        size_t <[size]>;
+	char *<[format]>;
+
+DESCRIPTION
+        <<printf>> accepts a series of arguments, applies to each a
+        format specifier from <<*<[format]>>>, and writes the
+        formatted data to <<stdout>>, terminated with a null character.
+        The behavior of <<printf>> is undefined if there are not enough
+        arguments for the format.
+        <<printf>> returns when it reaches the end of the format string.
+        If there are more arguments than the format requires, excess
+        arguments are ignored.
+
+        <<fprintf>>, <<sprintf>> and <<snprintf>> are identical to <<printf>>,
+        other than the destination of the formatted output: <<fprintf>> sends
+        the output to a specified file <[fd]>, while <<sprintf>> stores the
+        output in the specified char array <[str]> and <<snprintf>> limits
+        number of characters written to <[str]> to at most <[size]> (including
+        terminating <<0>>).  For <<sprintf>> and <<snprintf>>, the behavior is
+        also undefined if the output <<*<[str]>>> overlaps with one of the
+        arguments. <[format]> is a pointer to a charater string containing
+        two types of objects: ordinary characters (other than <<%>>), which
+        are copied unchanged to the output, and conversion
+        specifications, each of which is introduced by <<%>>.
+        (To include <<%>> in the output, use <<%%>> in the format string.)
+        A conversion specification has the following form:
+
+.       %[<[flags]>][<[width]>][.<[prec]>][<[size]>][<[type]>]
+
+        The fields of the conversion specification have the following meanings:
+
+        O+
+	o <[flags]>
+
+	an optional sequence of characters which control
+	output justification, numeric signs, decimal points,
+	trailing zeroes, and octal and hex prefixes.
+	The flag characters are minus (<<->>), plus (<<+>>),
+	space ( ), zero (<<0>>), and sharp (<<#>>).  They can
+	appear in any combination.
+
+	o+
+    	o -
+		The result of the conversion is left justified, and the right is
+		padded with blanks.  If you do not use this flag, the result is right
+		justified, and padded on the left.
+
+        o +
+		The result of a signed conversion (as determined by <[type]>)
+		will always begin with a plus or minus sign.  (If you do not use
+        this flag, positive values do not begin with a plus sign.)
+
+        o " " (space)
+		If the first character of a signed conversion specification
+        is not a sign, or if a signed conversion results in no
+		characters, the result will begin with a space.  If the
+        space ( ) flag and the plus (<<+>>) flag both appear,
+		the space flag is ignored.
+
+        o 0
+		If the <[type]> character is <<d>>, <<i>>, <<o>>, <<u>>,
+		<<x>>, <<X>>, <<e>>, <<E>>, <<f>>, <<g>>, or <<G>>: leading zeroes,
+		are used to pad the field width (following any indication of sign or
+		base); no spaces are used for padding.  If the zero (<<0>>) and
+		minus (<<->>) flags both appear, the zero (<<0>>) flag will
+		be ignored.  For <<d>>, <<i>>, <<o>>, <<u>>, <<x>>, and <<X>>
+		conversions, if a precision <[prec]> is specified, the zero (<<0>>)
+        flag is ignored.
+		
+		Note that <<0>> is interpreted as a flag, not as the beginning
+        of a field width.
+
+        o #
+		The result is to be converted to an alternative form, according
+		to the next character:
+
+	    o+
+		    o 0
+			increases precision to force the first digit
+                        of the result to be a zero.
+
+			o x
+			a non-zero result will have a <<0x>> prefix.
+
+			o X
+			a non-zero result will have a <<0X>> prefix.
+
+			o e, E or f
+			The result will always contain a decimal point
+		        even if no digits follow the point.
+                        (Normally, a decimal point appears only if a
+			digit follows it.)  Trailing zeroes are removed.
+
+			o g or G
+			same as <<e>> or <<E>>, but trailing zeroes
+                        are not removed.
+
+			o all others
+			undefined.
+
+			o-
+      o-
+
+      o <[width]>
+
+	  <[width]> is an optional minimum field width.  You can either
+	  specify it directly as a decimal integer, or indirectly by
+          using instead an asterisk (<<*>>), in which case an <<int>>
+          argument is used as the field width.  Negative field widths
+          are not supported; if you attempt to specify a negative field
+          width, it is interpreted as a minus (<<->>) flag followed by a
+          positive field width.
+
+      o <[prec]>
+
+	  an optional field; if present, it is introduced with `<<.>>'
+	  (a period). This field gives the maximum number of
+	  characters to print in a conversion; the minimum number of
+	  digits of an integer to print, for conversions with <[type]>
+	  <<d>>, <<i>>, <<o>>, <<u>>, <<x>>, and <<X>>; the maximum number of
+	  significant digits, for the <<g>> and <<G>> conversions;
+	  or the number of digits to print after the decimal
+	  point, for <<e>>, <<E>>, and <<f>> conversions.  You can specify
+	  the precision either directly as a decimal integer or
+	  indirectly by using an asterisk (<<*>>), in which case
+	  an <<int>> argument is used as the precision.  Supplying a negative
+      precision is equivalent to omitting the precision.
+	  If only a period is specified the precision is zero.
+	  If a precision appears with any other conversion <[type]>
+	  than those listed here, the behavior is undefined.
+
+      o  <[size]>
+
+		<<h>>, <<l>>, and <<L>> are optional size characters which
+		override the default way that <<printf>> interprets the
+		data type of the corresponding argument.  <<h>> forces
+		the following <<d>>, <<i>>, <<o>>, <<u>>, <<x>> or <<X>> conversion
+		<[type]> to apply to a <<short>> or <<unsigned short>>. <<h>> also
+		forces a following <<n>> <[type]> to apply to
+		a pointer to a <<short>>. Similarily, an
+		<<l>> forces the following <<d>>, <<i>>, <<o>>, <<u>>,
+		<<x>> or <<X>> conversion <[type]> to apply to a <<long>> or
+		<<unsigned long>>.  <<l>> also forces a following <<n>> <[type]> to
+		apply to a pointer to a <<long>>. If an <<h>>
+		or an <<l>> appears with another conversion
+		specifier, the behavior is undefined.  <<L>> forces a
+		following <<e>>, <<E>>, <<f>>, <<g>> or <<G>> conversion <[type]> to
+		apply to a <<long double>> argument.  If <<L>> appears with
+		any other conversion <[type]>, the behavior is undefined.
+
+     o   <[type]>
+
+		<[type]> specifies what kind of conversion <<printf>> performs.
+		Here is a table of these:
+
+	o+
+		o %
+		prints the percent character (<<%>>)
+
+		o c
+		prints <[arg]> as single character
+		
+		o s
+		prints characters until precision is reached or a null terminator
+		is encountered; takes a string pointer
+
+		o d
+		prints a signed decimal integer; takes an <<int>> (same as <<i>>)
+
+		o i
+		prints a signed decimal integer; takes an <<int>> (same as <<d>>)
+
+		o o
+		prints a signed octal integer; takes an <<int>>
+
+		o u
+		prints an unsigned decimal integer; takes an <<int>>
+
+		o x
+		prints an unsigned hexadecimal integer (using <<abcdef>> as
+		digits beyond <<9>>); takes an <<int>>
+
+		o X
+		prints an unsigned hexadecimal integer (using <<ABCDEF>> as
+		digits beyond <<9>>); takes an <<int>>
+
+		o f
+		prints a signed value of the form <<[-]9999.9999>>; takes
+		a floating point number
+	
+		o e
+		prints a signed	value of the form <<[-]9.9999e[+|-]999>>; takes a
+		floating point number
+
+		o E
+		prints the same way as <<e>>, but using <<E>> to introduce the
+		exponent; takes a floating point number
+
+		o g
+		prints a signed value in either <<f>> or <<e>> form, based on given
+		value and precision---trailing zeros and the decimal point are
+		printed only if necessary; takes a floating point number
+	
+		o G
+		prints the same way as <<g>>, but using <<E>> for the exponent if an
+		exponent is needed; takes a floating point number
+
+		o n
+		stores (in the same object) a count of the characters written;
+		takes a pointer to <<int>>
+
+		o p
+		prints a pointer in an implementation-defined format.
+		This implementation treats the pointer as an
+		<<unsigned long>> (same as <<Lu>>).
+	o-
+O-
+
+
+RETURNS
+<<sprintf>> returns the number of bytes in the output string,
+save that the concluding <<NULL>> is not counted.
+<<printf>> and <<fprintf>> return the number of characters transmitted.
+If an error occurs, <<printf>> and <<fprintf>> return <<EOF>>. No
+error returns occur for <<sprintf>>.
+
+PORTABILITY
+        The  ANSI C standard specifies that implementations must
+        support at least formatted output of up to 509 characters.
+
+Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
+<<lseek>>, <<read>>, <<sbrk>>, <<write>>.
+*/
+
+#include <stdio.h>
+#ifdef _HAVE_STDC
+#include <stdarg.h>
+#else
+#include <varargs.h>
+#endif
+#include <limits.h>
+#include <_ansi.h>
+#include "local.h"
+
+int
+#ifdef _HAVE_STDC
+_DEFUN (_sprintf_r, (ptr, str, fmt), struct _reent *ptr _AND char *str _AND _CONST char *fmt _DOTS)
+#else
+_sprintf_r (ptr, str, fmt, va_alist)
+     struct _reent *ptr;
+     char *str;
+     _CONST char *fmt;
+     va_dcl
+#endif
+{
+  int ret;
+  va_list ap;
+  FILE f;
+
+  f._flags = __SWR | __SSTR;
+  f._bf._base = f._p = (unsigned char *) str;
+  f._bf._size = f._w = INT_MAX;
+  f._data = ptr;
+#ifdef _HAVE_STDC
+  va_start (ap, fmt);
+#else
+  va_start (ap);
+#endif
+  ret = vfprintf (&f, fmt, ap);
+  va_end (ap);
+  *f._p = 0;
+  return (ret);
+}
+
+#ifndef _REENT_ONLY
+
+int
+#ifdef _HAVE_STDC
+_DEFUN (sprintf, (str, fmt), char *str _AND _CONST char *fmt _DOTS)
+#else
+sprintf (str, fmt, va_alist)
+     char *str;
+     _CONST char *fmt;
+     va_dcl
+#endif
+{
+  int ret;
+  va_list ap;
+  FILE f;
+
+  f._flags = __SWR | __SSTR;
+  f._bf._base = f._p = (unsigned char *) str;
+  f._bf._size = f._w = INT_MAX;
+  f._data = _REENT;
+#ifdef _HAVE_STDC
+  va_start (ap, fmt);
+#else
+  va_start (ap);
+#endif
+  ret = vfprintf (&f, fmt, ap);
+  va_end (ap);
+  *f._p = 0;
+  return (ret);
+}
+
+#endif
diff --git a/newlib/libc/stdio/sscanf.c b/newlib/libc/stdio/sscanf.c
new file mode 100644
index 000000000..eb344238d
--- /dev/null
+++ b/newlib/libc/stdio/sscanf.c
@@ -0,0 +1,386 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+/*
+
+FUNCTION
+	<<scanf>>, <<fscanf>>, <<sscanf>>---scan and format input
+
+INDEX
+	scanf
+INDEX
+	fscanf
+INDEX
+	sscanf
+
+ANSI_SYNOPSIS
+        #include <stdio.h>
+
+        int scanf(const char *<[format]> [, <[arg]>, ...]);
+        int fscanf(FILE *<[fd]>, const char *<[format]> [, <[arg]>, ...]);
+        int sscanf(const char *<[str]>, const char *<[format]> 
+                   [, <[arg]>, ...]);
+
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+
+	int scanf(<[format]> [, <[arg]>, ...])
+	char *<[format]>;
+
+	int fscanf(<[fd]>, <[format]> [, <[arg]>, ...]);
+	FILE *<[fd]>;
+	char *<[format]>;
+
+	int sscanf(<[str]>, <[format]> [, <[arg]>, ...]);
+	char *<[str]>;
+	char *<[format]>;
+
+
+DESCRIPTION
+        <<scanf>> scans a series of input fields from standard input,
+		one character at a time.  Each field is interpreted according to
+		a format specifier passed to <<scanf>> in the format string at
+        <<*<[format]>>>.  <<scanf>> stores the interpreted input from
+		each field at the address passed to it as the corresponding argument
+		following <[format]>.  You must supply the same number of
+		format specifiers and address arguments as there are input fields.
+
+        There must be sufficient address arguments for the given format
+        specifiers; if not the results are unpredictable and likely
+        disasterous.  Excess address arguments are merely ignored.
+
+        <<scanf>> often produces unexpected results if the input diverges from
+        an expected pattern. Since the combination of <<gets>> or <<fgets>>
+        followed by <<sscanf>> is safe and easy, that is the preferred way
+        to be certain that a program is synchronized with input at the end
+		of a line.
+
+        <<fscanf>> and <<sscanf>> are identical to <<scanf>>, other than the
+        source of input: <<fscanf>> reads from a file, and <<sscanf>>
+		from a string.
+
+        The string at <<*<[format]>>> is a character sequence composed
+        of zero or more directives. Directives are composed of
+        one or more whitespace characters, non-whitespace characters,
+        and format specifications.
+
+        Whitespace characters are blank (<< >>), tab (<<\t>>), or
+		newline (<<\n>>).
+        When <<scanf>> encounters a whitespace character in the format string
+        it will read (but not store) all consecutive whitespace characters
+        up to the next non-whitespace character in the input.
+
+        Non-whitespace characters are all other ASCII characters except the
+        percent sign (<<%>>).  When <<scanf>> encounters a non-whitespace
+        character in the format string it will read, but not store
+        a matching non-whitespace character.
+
+        Format specifications tell <<scanf>> to read and convert characters
+        from the input field into specific types of values, and store then
+        in the locations specified by the address arguments.
+
+        Trailing whitespace is left unread unless explicitly
+        matched in the format string.
+
+        The format specifiers must begin with a percent sign (<<%>>)
+        and have the following form:
+
+.       %[*][<[width]>][<[size]>]<[type]>
+
+        Each format specification begins with the percent character (<<%>>).
+        The other fields are:
+	o+
+		o *
+		an optional marker; if present, it suppresses interpretation and
+        assignment of this input field.
+
+        o <[width]>
+		an optional maximum field width: a decimal integer,
+		which controls the maximum number of characters that
+		will be read before converting the current input field.  If the
+		input field has fewer than <[width]> characters, <<scanf>>
+		reads all the characters in the field, and then
+		proceeds with the next field and its format specification.
+
+		If a whitespace or a non-convertable character occurs
+		before <[width]> character are read, the characters up
+		to that character are read, converted, and stored.
+		Then <<scanf>> proceeds to the next format specification.
+
+        o size
+		<<h>>, <<l>>, and <<L>> are optional size characters which
+		override the default way that <<scanf>> interprets the
+		data type of the corresponding argument.
+
+
+.Modifier   Type(s)
+.   h       d, i, o, u, x     convert input to short,
+.                             store in short object
+.
+.   h       D, I, O, U, X     no effect
+.           e, f, c, s, n, p
+.
+.   l       d, i, o, u, x     convert input to long,
+.                             store in long object
+.
+.   l       e, f, g           convert input to double
+.                             store in a double object
+.
+.   l       D, I, O, U, X     no effect
+.           c, s, n, p
+.
+.   L       d, i, o, u, x     convert to long double,
+.                             store in long double
+.
+.   L      all others         no effect
+
+
+        o <[type]>
+
+		A character to specify what kind of conversion
+                <<scanf>> performs.  Here is a table of the conversion
+                characters:
+
+		o+
+		o  %
+		No conversion is done; the percent character (<<%>>) is stored.
+
+		o c
+		Scans one character.  Corresponding <[arg]>: <<(char *arg)>>.
+
+		o s
+		Reads a character string into the array supplied.
+		Corresponding <[arg]>: <<(char arg[])>>.
+
+		o  [<[pattern]>]
+		Reads a non-empty character string into memory
+		starting at <[arg]>.  This area must be large
+		enough to accept the sequence and a
+		terminating null character which will be added
+		automatically.  (<[pattern]> is discussed in the paragraph following
+		this table). Corresponding <[arg]>: <<(char *arg)>>.
+
+		o d
+		Reads a decimal integer into the corresponding <[arg]>: <<(int *arg)>>.
+
+		o D
+		Reads a decimal integer into the corresponding
+		<[arg]>: <<(long *arg)>>.
+
+		o o
+		Reads an octal integer into the corresponding <[arg]>: <<(int *arg)>>.
+
+		o O
+		Reads an octal integer into the corresponding <[arg]>: <<(long *arg)>>.
+
+		o u
+		Reads an unsigned decimal integer into the corresponding
+		<[arg]>: <<(unsigned int *arg)>>.
+			
+
+		o U
+		Reads an unsigned decimal integer into the corresponding <[arg]>:
+		<<(unsigned long *arg)>>.
+
+		o x,X
+		Read a hexadecimal integer into the corresponding <[arg]>:
+		<<(int *arg)>>.
+
+		o e, f, g
+		Read a floating point number into the corresponding <[arg]>:
+		<<(float *arg)>>.
+
+		o E, F, G
+		Read a floating point number into the corresponding <[arg]>:
+		<<(double *arg)>>.
+
+		o  i
+		Reads a decimal, octal or hexadecimal integer into the
+		corresponding <[arg]>: <<(int *arg)>>.
+
+		o  I
+		Reads a decimal, octal or hexadecimal integer into the
+		corresponding <[arg]>: <<(long *arg)>>.
+
+		o  n
+		Stores the number of characters read in the corresponding
+		<[arg]>: <<(int *arg)>>.
+
+		o  p
+                Stores a scanned pointer.  ANSI C leaves the details
+		to each implementation; this implementation treats
+		<<%p>> exactly the same as <<%U>>.  Corresponding
+		<[arg]>: <<(void **arg)>>.  
+                o-
+
+	A <[pattern]> of characters surrounded by square brackets can be used
+	instead of the <<s>> type character.  <[pattern]> is a set of
+	characters which define a search set of possible characters making up
+	the <<scanf>> input field.  If the first character in the brackets is a
+	caret (<<^>>), the search set is inverted to include all ASCII characters
+	except those between the brackets.  There is also a range facility
+	which you can use as a shortcut. <<%[0-9] >> matches all decimal digits.
+	The hyphen must not be the first or last character in the set.
+	The character prior to the hyphen must be lexically less than the
+	character after it.
+
+	Here are some <[pattern]> examples:
+		o+
+		o %[abcd]
+		matches strings containing only <<a>>, <<b>>, <<c>>, and <<d>>.
+
+		o %[^abcd]
+		matches strings containing any characters except <<a>>, <<b>>,
+		<<c>>, or <<d>>
+
+		o %[A-DW-Z]
+		matches strings containing <<A>>, <<B>>, <<C>>, <<D>>, <<W>>,
+		<<X>>, <<Y>>, <<Z>>
+
+		o %[z-a]
+		matches the characters  <<z>>, <<->>, and <<a>>
+		o-
+
+	Floating point numbers (for field types <<e>>, <<f>>, <<g>>, <<E>>,
+	<<F>>, <<G>>) must correspond to the following general form:
+
+.		[+/-] ddddd[.]ddd [E|e[+|-]ddd]
+
+	where objects inclosed in square brackets are optional, and <<ddd>>
+	represents decimal, octal, or hexadecimal digits.
+	o-
+
+RETURNS
+        <<scanf>> returns the number of input fields successfully
+        scanned, converted and stored; the return value does
+        not include scanned fields which were not stored.
+
+        If <<scanf>> attempts to read at end-of-file, the return
+        value is <<EOF>>.
+
+        If no fields were stored, the return value is <<0>>.
+
+        <<scanf>> might stop scanning a particular field before
+        reaching the normal field end character, or may
+        terminate entirely.
+
+        <<scanf>> stops scanning and storing the current field
+        and moves to the next input field (if any)
+        in any of the following situations:
+
+	O+
+	o       The assignment suppressing character (<<*>>) appears
+	after the <<%>> in the format specification; the current
+	input field is scanned but not stored.
+
+	o       <[width]> characters have been read (<[width]> is a
+	width specification, a positive decimal integer).
+
+	o       The next character read cannot be converted
+	under the the current format (for example,
+	if a <<Z>> is read when the format is decimal).
+
+	o       The next character in the input field does not appear
+	in the search set (or does appear in the inverted search set).
+	O-
+
+	When <<scanf>> stops scanning the current input field for one of
+	these reasons, the next character is considered unread and
+	used as the first character of the following input field, or the
+	first character in a subsequent read operation on the input.
+
+	<<scanf>> will terminate under the following circumstances:
+
+	O+
+	o       The next character in the input field conflicts
+	with a corresponding non-whitespace character in the
+	format string.
+
+	o       The next character in the input field is <<EOF>>.
+
+	o       The format string has been exhausted.
+	O-
+
+	When the format string contains a character sequence that is
+	not part of a format specification, the same character
+	sequence must appear in the input; <<scanf>> will
+	scan but not store the matched characters.  If a
+	conflict occurs, the first conflicting character remains in the input
+	as if it had never been read.
+
+PORTABILITY
+<<scanf>> is ANSI C.
+
+Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
+<<lseek>>, <<read>>, <<sbrk>>, <<write>>.
+*/
+
+#include <_ansi.h>
+#include <reent.h>
+#include <stdio.h>
+#include <string.h>
+#ifdef _HAVE_STDC
+#include <stdarg.h>
+#else
+#include <varargs.h>
+#endif
+#include "local.h"
+
+/* | ARGSUSED */
+/*SUPPRESS 590*/
+static
+int
+eofread (cookie, buf, len)
+     _PTR cookie;
+     char *buf;
+     int len;
+{
+  return 0;
+}
+
+#ifdef _HAVE_STDC
+int 
+_DEFUN (sscanf, (str, fmt), _CONST char *str _AND _CONST char *fmt _DOTS)
+#else
+int 
+sscanf (str, fmt, va_alist)
+     _CONST char *str;
+     _CONST char *fmt;
+     va_dcl
+#endif
+{
+  int ret;
+  va_list ap;
+  FILE f;
+
+  f._flags = __SRD;
+  f._bf._base = f._p = (unsigned char *) str;
+  f._bf._size = f._r = strlen (str);
+  f._read = eofread;
+  f._ub._base = NULL;
+  f._lb._base = NULL;
+  f._data = _REENT;
+#ifdef _HAVE_STDC
+  va_start (ap, fmt);
+#else
+  va_start (ap);
+#endif
+  ret = __svfscanf (&f, fmt, ap);
+  va_end (ap);
+  return ret;
+}
diff --git a/newlib/libc/stdio/stdio.c b/newlib/libc/stdio/stdio.c
new file mode 100644
index 000000000..c06f51aa0
--- /dev/null
+++ b/newlib/libc/stdio/stdio.c
@@ -0,0 +1,92 @@
+/* No user fns here.  Pesch 15apr92. */
+
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <sys/unistd.h>
+#include "local.h"
+
+/*
+ * Small standard I/O/seek/close functions.
+ * These maintain the `known seek offset' for seek optimisation.
+ */
+
+int
+__sread (cookie, buf, n)
+     _PTR cookie;
+     char *buf;
+     int n;
+{
+  register FILE *fp = (FILE *) cookie;
+  register int ret;
+
+  ret = _read_r (fp->_data, fp->_file, buf, n);
+
+  /* If the read succeeded, update the current offset.  */
+
+  if (ret >= 0)
+    fp->_offset += ret;
+  else
+    fp->_flags &= ~__SOFF;	/* paranoia */
+  return ret;
+}
+
+int
+__swrite (cookie, buf, n)
+     _PTR cookie;
+     char _CONST *buf;
+     int n;
+{
+  register FILE *fp = (FILE *) cookie;
+
+  if (fp->_flags & __SAPP)
+    (void) _lseek_r (fp->_data, fp->_file, (off_t) 0, SEEK_END);
+  fp->_flags &= ~__SOFF;	/* in case O_APPEND mode is set */
+  return _write_r (fp->_data, fp->_file, buf, n);
+}
+
+fpos_t
+__sseek (cookie, offset, whence)
+     _PTR cookie;
+     fpos_t offset;
+     int whence;
+{
+  register FILE *fp = (FILE *) cookie;
+  register off_t ret;
+
+  ret = _lseek_r (fp->_data, fp->_file, (off_t) offset, whence);
+  if (ret == -1L)
+    fp->_flags &= ~__SOFF;
+  else
+    {
+      fp->_flags |= __SOFF;
+      fp->_offset = ret;
+    }
+  return ret;
+}
+
+int
+__sclose (cookie)
+     _PTR cookie;
+{
+  FILE *fp = (FILE *) cookie;
+
+  return _close_r (fp->_data, fp->_file);
+}
diff --git a/newlib/libc/stdio/stdio.tex b/newlib/libc/stdio/stdio.tex
new file mode 100644
index 000000000..466e1f0db
--- /dev/null
+++ b/newlib/libc/stdio/stdio.tex
@@ -0,0 +1,183 @@
+@node Stdio
+@chapter Input and Output (@file{stdio.h}) 
+
+This chapter comprises functions to manage files
+or other input/output streams. Among these functions are subroutines
+to generate or scan strings according to specifications from a format string. 
+
+The underlying facilities for input and output depend on the host
+system, but these functions provide a uniform interface.
+
+The corresponding declarations are in @file{stdio.h}.
+
+The reentrant versions of these functions use macros
+
+@example
+_stdin_r(@var{reent})
+_stdout_r(@var{reent})
+_stderr_r(@var{reent})
+@end example
+
+@noindent
+instead of the globals @code{stdin}, @code{stdout}, and
+@code{stderr}.  The argument <[reent]> is a pointer to a reentrancy
+structure.
+ 
+@menu  
+* clearerr::    Clear file or stream error indicator
+* fclose::      Close a file
+* feof::        Test for end of file
+* ferror::      Test whether read/write error has occurred
+* fflush::      Flush buffered file output
+* fgetc::       Get a character from a file or stream
+* fgetpos::     Record position in a stream or file
+* fgets::       Get character string from a file or stream
+* fiprintf::    Write formatted output to file (integer only)
+* fopen::       Open a file
+* fdopen::	Turn an open file into a stream
+* fputc::       Write a character on a stream or file
+* fputs::       Write a character string in a file or stream
+* fread::       Read array elements from a file
+* freopen::     Open a file using an existing file descriptor
+* fseek::       Set file position
+* fsetpos::     Restore position of a stream or file
+* ftell::       Return position in a stream or file
+* fwrite::      Write array elements from memory to a file or stream
+* getc::        Get a character from a file or stream (macro)
+* getchar::     Get a character from standard input (macro)
+* gets::        Get character string from standard input (obsolete)
+* iprintf::     Write formatted output (integer only)
+* mktemp::      Generate unused file name
+* perror::      Print an error message on standard error
+* putc::        Write a character on a stream or file (macro)
+* putchar::     Write a character on standard output (macro)
+* puts::        Write a character string on standard output
+* remove::      Delete a file's name
+* rename::      Rename a file
+* rewind::      Reinitialize a file or stream
+* setbuf::      Specify full buffering for a file or stream
+* setvbuf::     Specify buffering for a file or stream
+* siprintf::    Write formatted output (integer only)
+* printf::      Write formatted output
+* scanf::       Scan and format input
+* tmpfile::     Create a temporary file
+* tmpnam::      Generate name for a temporary file
+* vprintf::     Format variable argument list
+@end menu 
+
+@page
+@include stdio/clearerr.def
+
+@page
+@include stdio/fclose.def
+
+@page
+@include stdio/feof.def
+
+@page
+@include stdio/ferror.def
+
+@page
+@include stdio/fflush.def
+
+@page 
+@include stdio/fgetc.def 
+
+@page
+@include stdio/fgetpos.def
+
+@page 
+@include stdio/fgets.def 
+
+@page
+@include stdio/fiprintf.def
+
+@page
+@include stdio/fopen.def
+
+@page
+@include stdio/fdopen.def
+
+@page
+@include stdio/fputc.def
+
+@page
+@include stdio/fputs.def
+
+@page
+@include stdio/fread.def
+
+@page
+@include stdio/freopen.def
+
+@page
+@include stdio/fseek.def
+
+@page
+@include stdio/fsetpos.def
+
+@page
+@include stdio/ftell.def
+
+@page
+@include stdio/fwrite.def
+
+@page 
+@include stdio/getc.def 
+
+@page
+@include stdio/getchar.def 
+
+@page 
+@include stdio/gets.def
+
+@page
+@include stdio/iprintf.def 
+
+@page
+@include stdio/mktemp.def
+
+@page
+@include stdio/perror.def
+
+@page
+@include stdio/putc.def
+
+@page
+@include stdio/putchar.def
+
+@page
+@include stdio/puts.def
+
+@page
+@include stdio/remove.def
+
+@page
+@include stdio/rename.def
+
+@page
+@include stdio/rewind.def
+
+@page
+@include stdio/setbuf.def
+
+@page
+@include stdio/setvbuf.def
+
+@page 
+@include stdio/siprintf.def 
+
+@page 
+@include stdio/sprintf.def 
+
+@page
+@include stdio/sscanf.def 
+
+@page
+@include stdio/tmpfile.def
+
+@page
+@include stdio/tmpnam.def
+
+@page 
+@include stdio/vfprintf.def 
diff --git a/newlib/libc/stdio/tmpfile.c b/newlib/libc/stdio/tmpfile.c
new file mode 100644
index 000000000..4b31396e2
--- /dev/null
+++ b/newlib/libc/stdio/tmpfile.c
@@ -0,0 +1,77 @@
+/*
+FUNCTION
+<<tmpfile>>---create a temporary file
+
+INDEX
+	tmpfile
+INDEX
+	_tmpfile_r
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	FILE *tmpfile(void);
+
+	FILE *_tmpfile_r(void *<[reent]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	FILE *tmpfile();
+
+	FILE *_tmpfile_r(<[reent]>)
+	char *<[reent]>;
+
+DESCRIPTION
+Create a temporary file (a file which will be deleted automatically),
+using a name generated by <<tmpnam>>.  The temporary file is opened with
+the mode <<"wb+">>, permitting you to read and write anywhere in it
+as a binary file (without any data transformations the host system may
+perform for text files).
+
+The alternate function <<_tmpfile_r>> is a reentrant version.  The
+argument <[reent]> is a pointer to a reentrancy structure.
+
+RETURNS
+<<tmpfile>> normally returns a pointer to the temporary file.  If no
+temporary file could be created, the result is NULL, and <<errno>>
+records the reason for failure.
+
+PORTABILITY
+Both ANSI C and the System V Interface Definition (Issue 2) require
+<<tmpfile>>.
+
+Supporting OS subroutines required: <<close>>, <<fstat>>, <<getpid>>,
+<<isatty>>, <<lseek>>, <<open>>, <<read>>, <<sbrk>>, <<write>>.
+
+<<tmpfile>> also requires the global pointer <<environ>>.
+*/
+
+#include <stdio.h>
+#include <errno.h>
+
+FILE *
+_DEFUN (_tmpfile_r, (ptr),
+	struct _reent *ptr)
+{
+  FILE *fp;
+  int e;
+  char *f;
+  char buf[L_tmpnam];
+
+  if ((f = _tmpnam_r (ptr, buf)) == NULL)
+    return NULL;
+  fp = fopen (f, "wb+");
+  e = ptr->_errno;
+  _CAST_VOID remove (f);
+  ptr->_errno = e;
+  return fp;
+}
+
+#ifndef _REENT_ONLY
+
+FILE *
+_DEFUN_VOID (tmpfile)
+{
+  return _tmpfile_r (_REENT);
+}
+
+#endif
diff --git a/newlib/libc/stdio/tmpnam.c b/newlib/libc/stdio/tmpnam.c
new file mode 100644
index 000000000..28b394f10
--- /dev/null
+++ b/newlib/libc/stdio/tmpnam.c
@@ -0,0 +1,208 @@
+/*
+ * tmpname.c
+ * Original Author:	G. Haley
+ */
+
+/*
+FUNCTION
+<<tmpnam>>, <<tempnam>>---name for a temporary file
+
+INDEX
+	tmpnam
+INDEX
+	tempnam
+INDEX
+	_tmpnam_r
+INDEX
+	_tempnam_r
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	char *tmpnam(char *<[s]>);
+	char *tempnam(char *<[dir]>, char *<[pfx]>);
+	char *_tmpnam_r(void *<[reent]>, char *<[s]>);
+	char *_tempnam_r(void *<[reent]>, char *<[dir]>, char *<[pfx]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	char *tmpnam(<[s]>)
+	char *<[s]>;
+
+	char *tempnam(<[dir]>, <[pfx]>)
+	char *<[dir]>;
+	char *<[pfx]>;
+
+	char *_tmpnam_r(<[reent]>, <[s]>)
+	char *<[reent]>;
+	char *<[s]>;
+
+	char *_tempnam_r(<[reent]>, <[dir]>, <[pfx]>)
+	char *<[reent]>;
+	char *<[dir]>;
+	char *<[pfx]>;
+
+DESCRIPTION
+Use either of these functions to generate a name for a temporary file.
+The generated name is guaranteed to avoid collision with other files
+(for up to <<TMP_MAX>> calls of either function).
+
+<<tmpnam>> generates file names with the value of <<P_tmpdir>>
+(defined in `<<stdio.h>>') as the leading directory component of the path.
+
+You can use the <<tmpnam>> argument <[s]> to specify a suitable area
+of memory for the generated filename; otherwise, you can call
+<<tmpnam(NULL)>> to use an internal static buffer.
+
+<<tempnam>> allows you more control over the generated filename: you
+can use the argument <[dir]> to specify the path to a directory for
+temporary files, and you can use the argument <[pfx]> to specify a
+prefix for the base filename.
+
+If <[dir]> is <<NULL>>, <<tempnam>> will attempt to use the value of
+environment variable <<TMPDIR>> instead; if there is no such value,
+<<tempnam>> uses the value of <<P_tmpdir>> (defined in `<<stdio.h>>').
+
+If you don't need any particular prefix to the basename of temporary
+files, you can pass <<NULL>> as the <[pfx]> argument to <<tempnam>>.
+
+<<_tmpnam_r>> and <<_tempnam_r>> are reentrant versions of <<tmpnam>>
+and <<tempnam>> respectively.  The extra argument <[reent]> is a
+pointer to a reentrancy structure.
+
+WARNINGS
+The generated filenames are suitable for temporary files, but do not
+in themselves make files temporary.  Files with these names must still
+be explicitly removed when you no longer want them.
+
+If you supply your own data area <[s]> for <<tmpnam>>, you must ensure
+that it has room for at least <<L_tmpnam>> elements of type <<char>>.
+
+RETURNS
+Both <<tmpnam>> and <<tempnam>> return a pointer to the newly
+generated filename.
+
+PORTABILITY
+ANSI C requires <<tmpnam>>, but does not specify the use of
+<<P_tmpdir>>.  The System V Interface Definition (Issue 2) requires
+both <<tmpnam>> and <<tempnam>>.
+
+Supporting OS subroutines required: <<close>>,  <<fstat>>, <<getpid>>,
+<<isatty>>, <<lseek>>, <<open>>, <<read>>, <<sbrk>>, <<write>>.
+
+The global pointer <<environ>> is also required.
+*/
+
+#include <_ansi.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <reent.h>
+#include <errno.h>
+
+/* Try to open the file specified, if it can't be opened then try
+   another one.  Return nonzero if successful, otherwise zero.  */
+
+static int
+worker (ptr, result, part1, part2, part3, part4)
+     struct _reent *ptr;
+     char *result;
+     _CONST char *part1;
+     _CONST char *part2;
+     int part3;
+     int *part4;
+{
+  /*  Generate the filename and make sure that there isn't one called
+      it already.  */
+
+  while (1)
+    {
+      int t;
+      _sprintf_r (ptr, result, "%s/%s%x.%x", part1, part2, part3, *part4);
+      (*part4)++;
+      t = _open_r (ptr, result, O_RDONLY, 0);
+      if (t == -1)
+	{
+	  if (ptr->_errno == ENOSYS)
+	    {
+	      result[0] = '\0';
+	      return 0;
+	    }
+	  break;
+	}
+      _close_r (ptr, t);
+    }
+  return 1;
+}
+
+char *
+_DEFUN (_tmpnam_r, (p, s),
+	struct _reent *p _AND
+	char *s)
+{
+  char *result;
+  int pid;
+
+  if (s == NULL)
+    {
+      /* ANSI states we must use an internal static buffer if s is NULL */
+      result = p->_emergency;
+    }
+  else
+    {
+      result = s;
+    }
+  pid = _getpid_r (p);
+
+  if (worker (p, result, P_tmpdir, "t", pid, &p->_inc))
+    {
+      p->_inc++;
+      return result;
+    }
+
+  return NULL;
+}
+
+char *
+_DEFUN (_tempnam_r, (p, dir, pfx),
+	struct _reent *p _AND
+	_CONST char *dir _AND
+	_CONST char *pfx)
+{
+  char *filename;
+  int length;
+  _CONST char *prefix = (pfx) ? pfx : "";
+  if (dir == NULL && (dir = getenv ("TMPDIR")) == NULL)
+    dir = P_tmpdir;
+
+  /* two 8 digit numbers + . / */
+  length = strlen (dir) + strlen (prefix) + (4 * sizeof (int)) + 2 + 1;
+
+  filename = _malloc_r (p, length);
+  if (filename)
+    {
+      if (! worker (p, filename, dir, prefix,
+		    _getpid_r (p) ^ (int) (_POINTER_INT) p, &p->_inc))
+	return NULL;
+    }
+  return filename;
+}
+
+#ifndef _REENT_ONLY
+
+char *
+_DEFUN (tempnam, (dir, pfx),
+	_CONST char *dir _AND
+	_CONST char *pfx)
+{
+  return _tempnam_r (_REENT, dir, pfx);
+}
+
+char *
+_DEFUN (tmpnam, (s),
+	char *s)
+{
+  return _tmpnam_r (_REENT, s);
+}
+
+#endif
diff --git a/newlib/libc/stdio/ungetc.c b/newlib/libc/stdio/ungetc.c
new file mode 100644
index 000000000..418717e68
--- /dev/null
+++ b/newlib/libc/stdio/ungetc.c
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "%W% (Berkeley) %G%";
+#endif /* LIBC_SCCS and not lint */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "local.h"
+
+/*
+ * Expand the ungetc buffer `in place'.  That is, adjust fp->_p when
+ * the buffer moves, so that it points the same distance from the end,
+ * and move the bytes in the buffer around as necessary so that they
+ * are all at the end (stack-style).
+ */
+
+/*static*/
+int
+__submore (fp)
+     register FILE *fp;
+{
+  register int i;
+  register unsigned char *p;
+
+  if (fp->_ub._base == fp->_ubuf)
+    {
+      /*
+       * Get a new buffer (rather than expanding the old one).
+       */
+      if ((p = (unsigned char *) _malloc_r (fp->_data, (size_t) BUFSIZ)) == NULL)
+	return EOF;
+      fp->_ub._base = p;
+      fp->_ub._size = BUFSIZ;
+      p += BUFSIZ - sizeof (fp->_ubuf);
+      for (i = sizeof (fp->_ubuf); --i >= 0;)
+	p[i] = fp->_ubuf[i];
+      fp->_p = p;
+      return 0;
+    }
+  i = fp->_ub._size;
+  p = (unsigned char *) _realloc_r (fp->_data, (_PTR) (fp->_ub._base), i << 1);
+  if (p == NULL)
+    return EOF;
+  (void) memcpy ((void *) (p + i), (void *) p, (size_t) i);
+  fp->_p = p + i;
+  fp->_ub._base = p;
+  fp->_ub._size = i << 1;
+  return 0;
+}
+
+int
+ungetc (c, fp)
+     int c;
+     register FILE *fp;
+{
+  if (c == EOF)
+    return (EOF);
+
+  /* Ensure stdio has been initialized.
+     ??? Might be able to remove this as some other stdio routine should
+     have already been called to get the char we are un-getting.  */
+
+  CHECK_INIT (fp);
+
+  /* After ungetc, we won't be at eof anymore */
+  fp->_flags &= ~__SEOF;
+
+  if ((fp->_flags & __SRD) == 0)
+    {
+      /*
+       * Not already reading: no good unless reading-and-writing.
+       * Otherwise, flush any current write stuff.
+       */
+      if ((fp->_flags & __SRW) == 0)
+	return EOF;
+      if (fp->_flags & __SWR)
+	{
+	  if (fflush (fp))
+	    return EOF;
+	  fp->_flags &= ~__SWR;
+	  fp->_w = 0;
+	  fp->_lbfsize = 0;
+	}
+      fp->_flags |= __SRD;
+    }
+  c = (unsigned char) c;
+
+  /*
+   * If we are in the middle of ungetc'ing, just continue.
+   * This may require expanding the current ungetc buffer.
+   */
+
+  if (HASUB (fp))
+    {
+      if (fp->_r >= fp->_ub._size && __submore (fp))
+	return EOF;
+      *--fp->_p = c;
+      fp->_r++;
+      return c;
+    }
+
+  /*
+   * If we can handle this by simply backing up, do so,
+   * but never replace the original character.
+   * (This makes sscanf() work when scanning `const' data.)
+   */
+
+  if (fp->_bf._base != NULL && fp->_p > fp->_bf._base && fp->_p[-1] == c)
+    {
+      fp->_p--;
+      fp->_r++;
+      return c;
+    }
+
+  /*
+   * Create an ungetc buffer.
+   * Initially, we will use the `reserve' buffer.
+   */
+
+  fp->_ur = fp->_r;
+  fp->_up = fp->_p;
+  fp->_ub._base = fp->_ubuf;
+  fp->_ub._size = sizeof (fp->_ubuf);
+  fp->_ubuf[sizeof (fp->_ubuf) - 1] = c;
+  fp->_p = &fp->_ubuf[sizeof (fp->_ubuf) - 1];
+  fp->_r = 1;
+  return c;
+}
diff --git a/newlib/libc/stdio/vfieeefp.h b/newlib/libc/stdio/vfieeefp.h
new file mode 100644
index 000000000..6843d5f47
--- /dev/null
+++ b/newlib/libc/stdio/vfieeefp.h
@@ -0,0 +1,205 @@
+/****************************************************************
+ *
+ * The author of this software is David M. Gay.
+ *
+ * Copyright (c) 1991 by AT&T.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ *
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHOR NOR AT&T MAKES ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ *
+ ***************************************************************/
+
+/* Please send bug reports to
+	David M. Gay
+	AT&T Bell Laboratories, Room 2C-463
+	600 Mountain Avenue
+	Murray Hill, NJ 07974-2070
+	U.S.A.
+	dmg@research.att.com or research!dmg
+ */
+
+/* This header file is a modification of mprec.h that only contains floating
+   point union code. */
+
+#include <ieeefp.h>
+#include <math.h>
+#include <float.h>
+#include <errno.h>
+#include <sys/config.h>
+
+#ifdef __IEEE_LITTLE_ENDIAN
+#define IEEE_8087
+#endif
+
+#ifdef __IEEE_BIG_ENDIAN
+#define IEEE_MC68k
+#endif
+
+#ifdef __Z8000__
+#define Just_16
+#endif
+
+#ifdef Unsigned_Shifts
+#define Sign_Extend(a,b) if (b < 0) a |= (__uint32_t)0xffff0000;
+#else
+#define Sign_Extend(a,b) /*no-op*/
+#endif
+
+#if defined(IEEE_8087) + defined(IEEE_MC68k) + defined(VAX) + defined(IBM) != 1
+Exactly one of IEEE_8087, IEEE_MC68k, VAX, or IBM should be defined.
+#endif
+
+/* If we are going to examine or modify specific bits in a double using
+   the word0 and/or word1 macros, then we must wrap the double inside
+   a union.  This is necessary to avoid undefined behavior according to
+   the ANSI C spec.  */
+union double_union
+{
+  double d;
+  __uint32_t i[2];
+};
+
+#ifdef IEEE_8087
+#define word0(x) (x.i[1])
+#define word1(x) (x.i[0])
+#else
+#define word0(x) (x.i[0])
+#define word1(x) (x.i[1])
+#endif
+
+/* #define P DBL_MANT_DIG */
+/* Ten_pmax = floor(P*log(2)/log(5)) */
+/* Bletch = (highest power of 2 < DBL_MAX_10_EXP) / 16 */
+/* Quick_max = floor((P-1)*log(FLT_RADIX)/log(10) - 1) */
+/* Int_max = floor(P*log(FLT_RADIX)/log(10) - 1) */
+
+#if defined(IEEE_8087) + defined(IEEE_MC68k)
+#if defined (_DOUBLE_IS_32BITS) 
+#define Exp_shift   23
+#define Exp_shift1  23
+#define Exp_msk1    ((__uint32_t)0x00800000L)
+#define Exp_msk11   ((__uint32_t)0x00800000L)
+#define Exp_mask    ((__uint32_t)0x7f800000L)
+#define P    	    24
+#define Bias 	    127
+#if 0
+#define IEEE_Arith  /* it is, but the code doesn't handle IEEE singles yet */
+#endif
+#define Emin        (-126)
+#define Exp_1       ((__uint32_t)0x3f800000L)
+#define Exp_11      ((__uint32_t)0x3f800000L)
+#define Ebits 	    8
+#define Frac_mask   ((__uint32_t)0x007fffffL)
+#define Frac_mask1  ((__uint32_t)0x007fffffL)
+#define Ten_pmax    10
+#define Sign_bit    ((__uint32_t)0x80000000L)
+#define Ten_pmax    10
+#define Bletch	    2
+#define Bndry_mask  ((__uint32_t)0x007fffffL)
+#define Bndry_mask1 ((__uint32_t)0x007fffffL)
+#define LSB 1
+#define Sign_bit    ((__uint32_t)0x80000000L)
+#define Log2P 	    1
+#define Tiny0 	    0
+#define Tiny1 	    1
+#define Quick_max   5
+#define Int_max     6
+#define Infinite(x) (word0(x) == ((__uint32_t)0x7f800000L))
+#undef word0
+#undef word1
+
+#define word0(x) (x.i[0])
+#define word1(x) 0
+#else
+
+#define Exp_shift  20
+#define Exp_shift1 20
+#define Exp_msk1    ((__uint32_t)0x100000L)
+#define Exp_msk11   ((__uint32_t)0x100000L)
+#define Exp_mask  ((__uint32_t)0x7ff00000L)
+#define P 53
+#define Bias 1023
+#define IEEE_Arith
+#define Emin (-1022)
+#define Exp_1  ((__uint32_t)0x3ff00000L)
+#define Exp_11 ((__uint32_t)0x3ff00000L)
+#define Ebits 11
+#define Frac_mask  ((__uint32_t)0xfffffL)
+#define Frac_mask1 ((__uint32_t)0xfffffL)
+#define Ten_pmax 22
+#define Bletch 0x10
+#define Bndry_mask  ((__uint32_t)0xfffffL)
+#define Bndry_mask1 ((__uint32_t)0xfffffL)
+#define LSB 1
+#define Sign_bit ((__uint32_t)0x80000000L)
+#define Log2P 1
+#define Tiny0 0
+#define Tiny1 1
+#define Quick_max 14
+#define Int_max 14
+#define Infinite(x) (word0(x) == ((__uint32_t)0x7ff00000L)) /* sufficient test for here */
+#endif
+
+#else
+#undef  Sudden_Underflow
+#define Sudden_Underflow
+#ifdef IBM
+#define Exp_shift  24
+#define Exp_shift1 24
+#define Exp_msk1   ((__uint32_t)0x1000000L)
+#define Exp_msk11  ((__uint32_t)0x1000000L)
+#define Exp_mask  ((__uint32_t)0x7f000000L)
+#define P 14
+#define Bias 65
+#define Exp_1  ((__uint32_t)0x41000000L)
+#define Exp_11 ((__uint32_t)0x41000000L)
+#define Ebits 8	/* exponent has 7 bits, but 8 is the right value in b2d */
+#define Frac_mask  ((__uint32_t)0xffffffL)
+#define Frac_mask1 ((__uint32_t)0xffffffL)
+#define Bletch 4
+#define Ten_pmax 22
+#define Bndry_mask  ((__uint32_t)0xefffffL)
+#define Bndry_mask1 ((__uint32_t)0xffffffL)
+#define LSB 1
+#define Sign_bit ((__uint32_t)0x80000000L)
+#define Log2P 4
+#define Tiny0 ((__uint32_t)0x100000L)
+#define Tiny1 0
+#define Quick_max 14
+#define Int_max 15
+#else /* VAX */
+#define Exp_shift  23
+#define Exp_shift1 7
+#define Exp_msk1    0x80
+#define Exp_msk11   ((__uint32_t)0x800000L)
+#define Exp_mask  ((__uint32_t)0x7f80L)
+#define P 56
+#define Bias 129
+#define Exp_1  ((__uint32_t)0x40800000L)
+#define Exp_11 ((__uint32_t)0x4080L)
+#define Ebits 8
+#define Frac_mask  ((__uint32_t)0x7fffffL)
+#define Frac_mask1 ((__uint32_t)0xffff007fL)
+#define Ten_pmax 24
+#define Bletch 2
+#define Bndry_mask  ((__uint32_t)0xffff007fL)
+#define Bndry_mask1 ((__uint32_t)0xffff007fL)
+#define LSB ((__uint32_t)0x10000L)
+#define Sign_bit ((__uint32_t)0x8000L)
+#define Log2P 1
+#define Tiny0 0x80
+#define Tiny1 0
+#define Quick_max 15
+#define Int_max 15
+#endif
+#endif
+
+
diff --git a/newlib/libc/stdio/vfprintf.c b/newlib/libc/stdio/vfprintf.c
new file mode 100644
index 000000000..4b2043e49
--- /dev/null
+++ b/newlib/libc/stdio/vfprintf.c
@@ -0,0 +1,939 @@
+/*
+FUNCTION
+<<vprintf>>, <<vfprintf>>, <<vsprintf>>---format argument list
+
+INDEX
+	vprintf
+INDEX
+	vfprintf
+INDEX
+	vsprintf
+INDEX
+	vsnprintf
+
+ANSI_SYNOPSIS
+	#include <stdio.h>
+	#include <stdarg.h>
+	int vprintf(const char *<[fmt]>, va_list <[list]>);
+	int vfprintf(FILE *<[fp]>, const char *<[fmt]>, va_list <[list]>);
+	int vsprintf(char *<[str]>, const char *<[fmt]>, va_list <[list]>);
+	int vsnprintf(char *<[str]>, size_t <[size]>, const char *<[fmt]>, va_list <[list]>);
+
+	int _vprintf_r(void *<[reent]>, const char *<[fmt]>,
+                        va_list <[list]>);
+	int _vfprintf_r(void *<[reent]>, FILE *<[fp]>, const char *<[fmt]>,
+                        va_list <[list]>);
+	int _vsprintf_r(void *<[reent]>, char *<[str]>, const char *<[fmt]>,
+                        va_list <[list]>);
+	int _vsnprintf_r(void *<[reent]>, char *<[str]>, size_t <[size]>, const char *<[fmt]>,
+                        va_list <[list]>);
+
+TRAD_SYNOPSIS
+	#include <stdio.h>
+	#include <varargs.h>
+	int vprintf( <[fmt]>, <[list]>)
+	char *<[fmt]>;
+	va_list <[list]>;
+
+	int vfprintf(<[fp]>, <[fmt]>, <[list]>)
+	FILE *<[fp]>;
+	char *<[fmt]>;
+	va_list <[list]>;
+
+	int vsprintf(<[str]>, <[fmt]>, <[list]>)
+	char *<[str]>;
+	char *<[fmt]>;
+	va_list <[list]>;
+
+	int vsnprintf(<[str]>, <[size]>, <[fmt]>, <[list]>)
+	char *<[str]>;
+        size_t <[size]>;
+	char *<[fmt]>;
+	va_list <[list]>;
+
+	int _vprintf_r(<[reent]>, <[fmt]>, <[list]>)
+	char *<[reent]>;
+	char *<[fmt]>;
+	va_list <[list]>;
+
+	int _vfprintf_r(<[reent]>, <[fp]>, <[fmt]>, <[list]>)
+	char *<[reent]>;
+	FILE *<[fp]>;
+	char *<[fmt]>;
+	va_list <[list]>;
+
+	int _vsprintf_r(<[reent]>, <[str]>, <[fmt]>, <[list]>)
+	char *<[reent]>;
+	char *<[str]>;
+	char *<[fmt]>;
+	va_list <[list]>;
+
+	int _vsnprintf_r(<[reent]>, <[str]>, <[size]>, <[fmt]>, <[list]>)
+	char *<[reent]>;
+	char *<[str]>;
+        size_t <[size]>;
+	char *<[fmt]>;
+	va_list <[list]>;
+
+DESCRIPTION
+<<vprintf>>, <<vfprintf>>, <<vsprintf>> and <<vsnprintf>> are (respectively)
+variants of <<printf>>, <<fprintf>>, <<sprintf>> and <<snprintf>>.  They differ
+only in allowing their caller to pass the variable argument list as a
+<<va_list>> object (initialized by <<va_start>>) rather than directly
+accepting a variable number of arguments.
+
+RETURNS
+The return values are consistent with the corresponding functions:
+<<vsprintf>> returns the number of bytes in the output string,
+save that the concluding <<NULL>> is not counted.
+<<vprintf>> and <<vfprintf>> return the number of characters transmitted.
+If an error occurs, <<vprintf>> and <<vfprintf>> return <<EOF>>. No
+error returns occur for <<vsprintf>>.
+
+PORTABILITY
+ANSI C requires all three functions.
+
+Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
+<<lseek>>, <<read>>, <<sbrk>>, <<write>>.
+*/
+
+/*-
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+/*static char *sccsid = "from: @(#)vfprintf.c	5.50 (Berkeley) 12/16/92";*/
+static char *rcsid = "$Id$";
+#endif /* LIBC_SCCS and not lint */
+
+/*
+ * Actual printf innards.
+ *
+ * This code is large and complicated...
+ */
+
+#ifdef INTEGER_ONLY
+#define VFPRINTF vfiprintf
+#define _VFPRINTF_R _vfiprintf_r
+#else
+#define VFPRINTF vfprintf
+#define _VFPRINTF_R _vfprintf_r
+#define FLOATING_POINT
+#endif
+
+#define _NO_LONGLONG
+#if defined WANT_PRINTF_LONG_LONG && defined __GNUC__
+# undef _NO_LONGLONG
+#endif
+
+#include <_ansi.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <reent.h>
+
+#ifdef _HAVE_STDC
+#include <stdarg.h>
+#else
+#include <varargs.h>
+#endif
+
+#include "local.h"
+#include "fvwrite.h"
+#include "vfieeefp.h"
+
+/*
+ * Flush out all the vectors defined by the given uio,
+ * then reset it so that it can be reused.
+ */
+static int
+__sprint(fp, uio)
+	FILE *fp;
+	register struct __suio *uio;
+{
+	register int err;
+
+	if (uio->uio_resid == 0) {
+		uio->uio_iovcnt = 0;
+		return (0);
+	}
+	err = __sfvwrite(fp, uio);
+	uio->uio_resid = 0;
+	uio->uio_iovcnt = 0;
+	return (err);
+}
+
+/*
+ * Helper function for `fprintf to unbuffered unix file': creates a
+ * temporary buffer.  We only work on write-only files; this avoids
+ * worries about ungetc buffers and so forth.
+ */
+static int
+__sbprintf(fp, fmt, ap)
+	register FILE *fp;
+	const char *fmt;
+	va_list ap;
+{
+	int ret;
+	FILE fake;
+	unsigned char buf[BUFSIZ];
+
+	/* copy the important variables */
+	fake._data = fp->_data;
+	fake._flags = fp->_flags & ~__SNBF;
+	fake._file = fp->_file;
+	fake._cookie = fp->_cookie;
+	fake._write = fp->_write;
+
+	/* set up the buffer */
+	fake._bf._base = fake._p = buf;
+	fake._bf._size = fake._w = sizeof(buf);
+	fake._lbfsize = 0;	/* not actually used, but Just In Case */
+
+	/* do the work, then copy any error status */
+	ret = VFPRINTF(&fake, fmt, ap);
+	if (ret >= 0 && fflush(&fake))
+		ret = EOF;
+	if (fake._flags & __SERR)
+		fp->_flags |= __SERR;
+	return (ret);
+}
+
+
+#ifdef FLOATING_POINT
+#include <locale.h>
+#include <math.h>
+#include "floatio.h"
+
+#define	BUF		(MAXEXP+MAXFRACT+1)	/* + decimal point */
+#define	DEFPREC		6
+
+static char *cvt _PARAMS((struct _reent *, double, int, int, char *, int *, int, int *));
+static int exponent _PARAMS((char *, int, int));
+
+#else /* no FLOATING_POINT */
+
+#define	BUF		40
+
+#endif /* FLOATING_POINT */
+
+
+/*
+ * Macros for converting digits to letters and vice versa
+ */
+#define	to_digit(c)	((c) - '0')
+#define is_digit(c)	((unsigned)to_digit(c) <= 9)
+#define	to_char(n)	((n) + '0')
+
+/*
+ * Flags used during conversion.
+ */
+#define	ALT		0x001		/* alternate form */
+#define	HEXPREFIX	0x002		/* add 0x or 0X prefix */
+#define	LADJUST		0x004		/* left adjustment */
+#define	LONGDBL		0x008		/* long double; unimplemented */
+#define	LONGINT		0x010		/* long integer */
+#define	QUADINT		0x020		/* quad integer */
+#define	SHORTINT	0x040		/* short integer */
+#define	ZEROPAD		0x080		/* zero (as opposed to blank) pad */
+#define FPT		0x100		/* Floating point number */
+
+int 
+_DEFUN (VFPRINTF, (fp, fmt0, ap),
+	FILE * fp _AND
+	_CONST char *fmt0 _AND
+	va_list ap)
+{
+  return _VFPRINTF_R (fp->_data, fp, fmt0, ap);
+}
+
+int 
+_DEFUN (_VFPRINTF_R, (data, fp, fmt0, ap),
+	struct _reent *data _AND
+	FILE * fp _AND
+	_CONST char *fmt0 _AND
+	va_list ap)
+{
+	register char *fmt;	/* format string */
+	register int ch;	/* character from fmt */
+	register int n, m;	/* handy integers (short term usage) */
+	register char *cp;	/* handy char pointer (short term usage) */
+	register struct __siov *iovp;/* for PRINT macro */
+	register int flags;	/* flags as above */
+	int ret;		/* return value accumulator */
+	int width;		/* width from format (%8d), or 0 */
+	int prec;		/* precision from format (%.3d), or -1 */
+	char sign;		/* sign prefix (' ', '+', '-', or \0) */
+	wchar_t wc;
+#ifdef FLOATING_POINT
+	char *decimal_point = localeconv()->decimal_point;
+	char softsign;		/* temporary negative sign for floats */
+	double _double;		/* double precision arguments %[eEfgG] */
+	int expt;		/* integer value of exponent */
+	int expsize;		/* character count for expstr */
+	int ndig;		/* actual number of digits returned by cvt */
+	char expstr[7];		/* buffer for exponent string */
+#endif
+
+#ifndef _NO_LONGLONG
+#define	quad_t	  long long
+#define	u_quad_t  unsigned long long
+#endif
+
+#ifndef _NO_LONGLONG
+	u_quad_t _uquad;	/* integer arguments %[diouxX] */
+#else
+	u_long _uquad;
+#endif
+	enum { OCT, DEC, HEX } base;/* base for [diouxX] conversion */
+	int dprec;		/* a copy of prec if [diouxX], 0 otherwise */
+	int realsz;		/* field size expanded by dprec */
+	int size;		/* size of converted field or string */
+	char *xdigs;		/* digits for [xX] conversion */
+#define NIOV 8
+	struct __suio uio;	/* output information: summary */
+	struct __siov iov[NIOV];/* ... and individual io vectors */
+	char buf[BUF];		/* space for %c, %[diouxX], %[eEfgG] */
+	char ox[2];		/* space for 0x hex-prefix */
+        int state = 0;          /* mbtowc calls from library must not change state */
+
+	/*
+	 * Choose PADSIZE to trade efficiency vs. size.  If larger printf
+	 * fields occur frequently, increase PADSIZE and make the initialisers
+	 * below longer.
+	 */
+#define	PADSIZE	16		/* pad chunk size */
+	static _CONST char blanks[PADSIZE] =
+	 {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '};
+	static _CONST char zeroes[PADSIZE] =
+	 {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'};
+
+	/*
+	 * BEWARE, these `goto error' on error, and PAD uses `n'.
+	 */
+#define	PRINT(ptr, len) { \
+	iovp->iov_base = (ptr); \
+	iovp->iov_len = (len); \
+	uio.uio_resid += (len); \
+	iovp++; \
+	if (++uio.uio_iovcnt >= NIOV) { \
+		if (__sprint(fp, &uio)) \
+			goto error; \
+		iovp = iov; \
+	} \
+}
+#define	PAD(howmany, with) { \
+	if ((n = (howmany)) > 0) { \
+		while (n > PADSIZE) { \
+			PRINT(with, PADSIZE); \
+			n -= PADSIZE; \
+		} \
+		PRINT(with, n); \
+	} \
+}
+#define	FLUSH() { \
+	if (uio.uio_resid && __sprint(fp, &uio)) \
+		goto error; \
+	uio.uio_iovcnt = 0; \
+	iovp = iov; \
+}
+
+	/*
+	 * To extend shorts properly, we need both signed and unsigned
+	 * argument extraction methods.
+	 */
+#ifndef _NO_LONGLONG
+#define	SARG() \
+	(flags&QUADINT ? va_arg(ap, quad_t) : \
+	    flags&LONGINT ? va_arg(ap, long) : \
+	    flags&SHORTINT ? (long)(short)va_arg(ap, int) : \
+	    (long)va_arg(ap, int))
+#define	UARG() \
+	(flags&QUADINT ? va_arg(ap, u_quad_t) : \
+	    flags&LONGINT ? va_arg(ap, u_long) : \
+	    flags&SHORTINT ? (u_long)(u_short)va_arg(ap, int) : \
+	    (u_long)va_arg(ap, u_int))
+#else
+#define	SARG() \
+	(flags&LONGINT ? va_arg(ap, long) : \
+	    flags&SHORTINT ? (long)(short)va_arg(ap, int) : \
+	    (long)va_arg(ap, int))
+#define	UARG() \
+	(flags&LONGINT ? va_arg(ap, u_long) : \
+	    flags&SHORTINT ? (u_long)(u_short)va_arg(ap, int) : \
+	    (u_long)va_arg(ap, u_int))
+#endif
+
+	CHECK_INIT (fp);
+
+	/* sorry, fprintf(read_only_file, "") returns EOF, not 0 */
+	if (cantwrite(fp))
+		return (EOF);
+
+	/* optimise fprintf(stderr) (and other unbuffered Unix files) */
+	if ((fp->_flags & (__SNBF|__SWR|__SRW)) == (__SNBF|__SWR) &&
+	    fp->_file >= 0)
+		return (__sbprintf(fp, fmt0, ap));
+
+	fmt = (char *)fmt0;
+	uio.uio_iov = iovp = iov;
+	uio.uio_resid = 0;
+	uio.uio_iovcnt = 0;
+	ret = 0;
+
+	/*
+	 * Scan the format for conversions (`%' character).
+	 */
+	for (;;) {
+	        cp = fmt;
+	        while ((n = _mbtowc_r(_REENT, &wc, fmt, MB_CUR_MAX, &state)) > 0) {
+			fmt += n;
+			if (wc == '%') {
+				fmt--;
+				break;
+			}
+		}
+		if ((m = fmt - cp) != 0) {
+			PRINT(cp, m);
+			ret += m;
+		}
+		if (n <= 0)
+			goto done;
+		fmt++;		/* skip over '%' */
+
+		flags = 0;
+		dprec = 0;
+		width = 0;
+		prec = -1;
+		sign = '\0';
+
+rflag:		ch = *fmt++;
+reswitch:	switch (ch) {
+		case ' ':
+			/*
+			 * ``If the space and + flags both appear, the space
+			 * flag will be ignored.''
+			 *	-- ANSI X3J11
+			 */
+			if (!sign)
+				sign = ' ';
+			goto rflag;
+		case '#':
+			flags |= ALT;
+			goto rflag;
+		case '*':
+			/*
+			 * ``A negative field width argument is taken as a
+			 * - flag followed by a positive field width.''
+			 *	-- ANSI X3J11
+			 * They don't exclude field widths read from args.
+			 */
+			if ((width = va_arg(ap, int)) >= 0)
+				goto rflag;
+			width = -width;
+			/* FALLTHROUGH */
+		case '-':
+			flags |= LADJUST;
+			goto rflag;
+		case '+':
+			sign = '+';
+			goto rflag;
+		case '.':
+			if ((ch = *fmt++) == '*') {
+				n = va_arg(ap, int);
+				prec = n < 0 ? -1 : n;
+				goto rflag;
+			}
+			n = 0;
+			while (is_digit(ch)) {
+				n = 10 * n + to_digit(ch);
+				ch = *fmt++;
+			}
+			prec = n < 0 ? -1 : n;
+			goto reswitch;
+		case '0':
+			/*
+			 * ``Note that 0 is taken as a flag, not as the
+			 * beginning of a field width.''
+			 *	-- ANSI X3J11
+			 */
+			flags |= ZEROPAD;
+			goto rflag;
+		case '1': case '2': case '3': case '4':
+		case '5': case '6': case '7': case '8': case '9':
+			n = 0;
+			do {
+				n = 10 * n + to_digit(ch);
+				ch = *fmt++;
+			} while (is_digit(ch));
+			width = n;
+			goto reswitch;
+#ifdef FLOATING_POINT
+		case 'L':
+			flags |= LONGDBL;
+			goto rflag;
+#endif
+		case 'h':
+			flags |= SHORTINT;
+			goto rflag;
+		case 'l':
+			if (*fmt == 'l') {
+				fmt++;
+				flags |= QUADINT;
+			} else {
+				flags |= LONGINT;
+			}
+			goto rflag;
+		case 'q':
+			flags |= QUADINT;
+			goto rflag;
+		case 'c':
+			*(cp = buf) = va_arg(ap, int);
+			size = 1;
+			sign = '\0';
+			break;
+		case 'D':
+			flags |= LONGINT;
+			/*FALLTHROUGH*/
+		case 'd':
+		case 'i':
+			_uquad = SARG();
+#ifndef _NO_LONGLONG
+			if ((quad_t)_uquad < 0)
+#else
+			if ((long) _uquad < 0)
+#endif
+			{
+
+				_uquad = -_uquad;
+				sign = '-';
+			}
+			base = DEC;
+			goto number;
+#ifdef FLOATING_POINT
+		case 'e':
+		case 'E':
+		case 'f':
+		case 'g':
+		case 'G':
+			if (prec == -1) {
+				prec = DEFPREC;
+			} else if ((ch == 'g' || ch == 'G') && prec == 0) {
+				prec = 1;
+			}
+
+			if (flags & LONGDBL) {
+				_double = (double) va_arg(ap, long double);
+			} else {
+				_double = va_arg(ap, double);
+			}
+
+			/* do this before tricky precision changes */
+			if (isinf(_double)) {
+				if (_double < 0)
+					sign = '-';
+				cp = "Inf";
+				size = 3;
+				break;
+			}
+			if (isnan(_double)) {
+				cp = "NaN";
+				size = 3;
+				break;
+			}
+
+			flags |= FPT;
+			cp = cvt(data, _double, prec, flags, &softsign,
+				&expt, ch, &ndig);
+			if (ch == 'g' || ch == 'G') {
+				if (expt <= -4 || expt > prec)
+					ch = (ch == 'g') ? 'e' : 'E';
+				else
+					ch = 'g';
+			} 
+			if (ch <= 'e') {	/* 'e' or 'E' fmt */
+				--expt;
+				expsize = exponent(expstr, expt, ch);
+				size = expsize + ndig;
+				if (ndig > 1 || flags & ALT)
+					++size;
+			} else if (ch == 'f') {		/* f fmt */
+				if (expt > 0) {
+					size = expt;
+					if (prec || flags & ALT)
+						size += prec + 1;
+				} else	/* "0.X" */
+					size = prec + 2;
+			} else if (expt >= ndig) {	/* fixed g fmt */
+				size = expt;
+				if (flags & ALT)
+					++size;
+			} else
+				size = ndig + (expt > 0 ?
+					1 : 2 - expt);
+
+			if (softsign)
+				sign = '-';
+			break;
+#endif /* FLOATING_POINT */
+		case 'n':
+#ifndef _NO_LONGLONG
+			if (flags & QUADINT)
+				*va_arg(ap, quad_t *) = ret;
+			else 
+#endif
+			if (flags & LONGINT)
+				*va_arg(ap, long *) = ret;
+			else if (flags & SHORTINT)
+				*va_arg(ap, short *) = ret;
+			else
+				*va_arg(ap, int *) = ret;
+			continue;	/* no output */
+		case 'O':
+			flags |= LONGINT;
+			/*FALLTHROUGH*/
+		case 'o':
+			_uquad = UARG();
+			base = OCT;
+			goto nosign;
+		case 'p':
+			/*
+			 * ``The argument shall be a pointer to void.  The
+			 * value of the pointer is converted to a sequence
+			 * of printable characters, in an implementation-
+			 * defined manner.''
+			 *	-- ANSI X3J11
+			 */
+			/* NOSTRICT */
+			_uquad = (u_long)(unsigned _POINTER_INT)va_arg(ap, void *);
+			base = HEX;
+			xdigs = "0123456789abcdef";
+			flags |= HEXPREFIX;
+			ch = 'x';
+			goto nosign;
+		case 's':
+			if ((cp = va_arg(ap, char *)) == NULL)
+				cp = "(null)";
+			if (prec >= 0) {
+				/*
+				 * can't use strlen; can only look for the
+				 * NUL in the first `prec' characters, and
+				 * strlen() will go further.
+				 */
+				char *p = memchr(cp, 0, prec);
+
+				if (p != NULL) {
+					size = p - cp;
+					if (size > prec)
+						size = prec;
+				} else
+					size = prec;
+			} else
+				size = strlen(cp);
+			sign = '\0';
+			break;
+		case 'U':
+			flags |= LONGINT;
+			/*FALLTHROUGH*/
+		case 'u':
+			_uquad = UARG();
+			base = DEC;
+			goto nosign;
+		case 'X':
+			xdigs = "0123456789ABCDEF";
+			goto hex;
+		case 'x':
+			xdigs = "0123456789abcdef";
+hex:			_uquad = UARG();
+			base = HEX;
+			/* leading 0x/X only if non-zero */
+			if (flags & ALT && _uquad != 0)
+				flags |= HEXPREFIX;
+
+			/* unsigned conversions */
+nosign:			sign = '\0';
+			/*
+			 * ``... diouXx conversions ... if a precision is
+			 * specified, the 0 flag will be ignored.''
+			 *	-- ANSI X3J11
+			 */
+number:			if ((dprec = prec) >= 0)
+				flags &= ~ZEROPAD;
+
+			/*
+			 * ``The result of converting a zero value with an
+			 * explicit precision of zero is no characters.''
+			 *	-- ANSI X3J11
+			 */
+			cp = buf + BUF;
+			if (_uquad != 0 || prec != 0) {
+				/*
+				 * Unsigned mod is hard, and unsigned mod
+				 * by a constant is easier than that by
+				 * a variable; hence this switch.
+				 */
+				switch (base) {
+				case OCT:
+					do {
+						*--cp = to_char(_uquad & 7);
+						_uquad >>= 3;
+					} while (_uquad);
+					/* handle octal leading 0 */
+					if (flags & ALT && *cp != '0')
+						*--cp = '0';
+					break;
+
+				case DEC:
+					/* many numbers are 1 digit */
+					while (_uquad >= 10) {
+						*--cp = to_char(_uquad % 10);
+						_uquad /= 10;
+					}
+					*--cp = to_char(_uquad);
+					break;
+
+				case HEX:
+					do {
+						*--cp = xdigs[_uquad & 15];
+						_uquad >>= 4;
+					} while (_uquad);
+					break;
+
+				default:
+					cp = "bug in vfprintf: bad base";
+					size = strlen(cp);
+					goto skipsize;
+				}
+			}
+			size = buf + BUF - cp;
+		skipsize:
+			break;
+		default:	/* "%?" prints ?, unless ? is NUL */
+			if (ch == '\0')
+				goto done;
+			/* pretend it was %c with argument ch */
+			cp = buf;
+			*cp = ch;
+			size = 1;
+			sign = '\0';
+			break;
+		}
+
+		/*
+		 * All reasonable formats wind up here.  At this point, `cp'
+		 * points to a string which (if not flags&LADJUST) should be
+		 * padded out to `width' places.  If flags&ZEROPAD, it should
+		 * first be prefixed by any sign or other prefix; otherwise,
+		 * it should be blank padded before the prefix is emitted.
+		 * After any left-hand padding and prefixing, emit zeroes
+		 * required by a decimal [diouxX] precision, then print the
+		 * string proper, then emit zeroes required by any leftover
+		 * floating precision; finally, if LADJUST, pad with blanks.
+		 *
+		 * Compute actual size, so we know how much to pad.
+		 * size excludes decimal prec; realsz includes it.
+		 */
+		realsz = dprec > size ? dprec : size;
+		if (sign)
+			realsz++;
+		else if (flags & HEXPREFIX)
+			realsz+= 2;
+
+		/* right-adjusting blank padding */
+		if ((flags & (LADJUST|ZEROPAD)) == 0)
+			PAD(width - realsz, blanks);
+
+		/* prefix */
+		if (sign) {
+			PRINT(&sign, 1);
+		} else if (flags & HEXPREFIX) {
+			ox[0] = '0';
+			ox[1] = ch;
+			PRINT(ox, 2);
+		}
+
+		/* right-adjusting zero padding */
+		if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD)
+			PAD(width - realsz, zeroes);
+
+		/* leading zeroes from decimal precision */
+		PAD(dprec - size, zeroes);
+
+		/* the string or number proper */
+#ifdef FLOATING_POINT
+		if ((flags & FPT) == 0) {
+			PRINT(cp, size);
+		} else {	/* glue together f_p fragments */
+			if (ch >= 'f') {	/* 'f' or 'g' */
+				if (_double == 0) {
+					/* kludge for __dtoa irregularity */
+					PRINT("0", 1);
+					if (expt < ndig || (flags & ALT) != 0) {
+						PRINT(decimal_point, 1);
+						PAD(ndig - 1, zeroes);
+					}
+				} else if (expt <= 0) {
+					PRINT("0", 1);
+					PRINT(decimal_point, 1);
+					PAD(-expt, zeroes);
+					PRINT(cp, ndig);
+				} else if (expt >= ndig) {
+					PRINT(cp, ndig);
+					PAD(expt - ndig, zeroes);
+					if (flags & ALT)
+						PRINT(".", 1);
+				} else {
+					PRINT(cp, expt);
+					cp += expt;
+					PRINT(".", 1);
+					PRINT(cp, ndig-expt);
+				}
+			} else {	/* 'e' or 'E' */
+				if (ndig > 1 || flags & ALT) {
+					ox[0] = *cp++;
+					ox[1] = '.';
+					PRINT(ox, 2);
+					if (_double || flags & ALT == 0) {
+						PRINT(cp, ndig-1);
+					} else	/* 0.[0..] */
+						/* __dtoa irregularity */
+						PAD(ndig - 1, zeroes);
+				} else	/* XeYYY */
+					PRINT(cp, 1);
+				PRINT(expstr, expsize);
+			}
+		}
+#else
+		PRINT(cp, size);
+#endif
+		/* left-adjusting padding (always blank) */
+		if (flags & LADJUST)
+			PAD(width - realsz, blanks);
+
+		/* finally, adjust ret */
+		ret += width > realsz ? width : realsz;
+
+		FLUSH();	/* copy out the I/O vectors */
+	}
+done:
+	FLUSH();
+error:
+	return (__sferror(fp) ? EOF : ret);
+	/* NOTREACHED */
+}
+
+#ifdef FLOATING_POINT
+
+extern char *_dtoa_r _PARAMS((struct _reent *, double, int,
+			      int, int *, int *, char **));
+
+static char *
+cvt(data, value, ndigits, flags, sign, decpt, ch, length)
+	struct _reent *data;
+	double value;
+	int ndigits, flags, *decpt, ch, *length;
+	char *sign;
+{
+	int mode, dsgn;
+	char *digits, *bp, *rve;
+        union double_union tmp;
+
+	if (ch == 'f') {
+		mode = 3;		/* ndigits after the decimal point */
+	} else {
+		/* To obtain ndigits after the decimal point for the 'e' 
+		 * and 'E' formats, round to ndigits + 1 significant 
+		 * figures.
+		 */
+		if (ch == 'e' || ch == 'E') {
+			ndigits++;
+		}
+		mode = 2;		/* ndigits significant digits */
+	}
+
+        tmp.d = value;
+	if (word0(tmp) & Sign_bit) { /* this will check for < 0 and -0.0 */
+		value = -value;
+		*sign = '-';
+        } else
+		*sign = '\000';
+	digits = _dtoa_r(data, value, mode, ndigits, decpt, &dsgn, &rve);
+	if ((ch != 'g' && ch != 'G') || flags & ALT) {	/* Print trailing zeros */
+		bp = digits + ndigits;
+		if (ch == 'f') {
+			if (*digits == '0' && value)
+				*decpt = -ndigits + 1;
+			bp += *decpt;
+		}
+		if (value == 0)	/* kludge for __dtoa irregularity */
+			rve = bp;
+		while (rve < bp)
+			*rve++ = '0';
+	}
+	*length = rve - digits;
+	return (digits);
+}
+
+static int
+exponent(p0, exp, fmtch)
+	char *p0;
+	int exp, fmtch;
+{
+	register char *p, *t;
+	char expbuf[MAXEXP];
+
+	p = p0;
+	*p++ = fmtch;
+	if (exp < 0) {
+		exp = -exp;
+		*p++ = '-';
+	}
+	else
+		*p++ = '+';
+	t = expbuf + MAXEXP;
+	if (exp > 9) {
+		do {
+			*--t = to_char(exp % 10);
+		} while ((exp /= 10) > 9);
+		*--t = to_char(exp);
+		for (; t < expbuf + MAXEXP; *p++ = *t++);
+	}
+	else {
+		*p++ = '0';
+		*p++ = to_char(exp);
+	}
+	return (p - p0);
+}
+#endif /* FLOATING_POINT */
diff --git a/newlib/libc/stdio/vfscanf.c b/newlib/libc/stdio/vfscanf.c
new file mode 100644
index 000000000..00fd98d76
--- /dev/null
+++ b/newlib/libc/stdio/vfscanf.c
@@ -0,0 +1,956 @@
+/* No user fns here. Pesch 15apr92. */
+
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include <_ansi.h>
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+#ifdef _HAVE_STDC
+#include <stdarg.h>
+#else
+#include <varargs.h>
+#endif
+#include "local.h"
+
+#ifndef	NO_FLOATING_POINT
+#define FLOATING_POINT
+#endif
+
+#ifdef FLOATING_POINT
+#include "floatio.h"
+#define	BUF	(MAXEXP+MAXFRACT+3)	/* 3 = sign + decimal point + NUL */
+/* An upper bound for how long a long prints in decimal.  4 / 13 approximates
+   log (2).  Add one char for roundoff compensation and one for the sign.  */
+#define MAX_LONG_LEN ((CHAR_BIT * sizeof (long)  - 1) * 4 / 13 + 2)
+#else
+#define	BUF	40
+#endif
+
+/*
+ * Flags used during conversion.
+ */
+
+#define	LONG		0x01	/* l: long or double */
+#define	LONGDBL		0x02	/* L: long double; unimplemented */
+#define	SHORT		0x04	/* h: short */
+#define	SUPPRESS	0x08	/* suppress assignment */
+#define	POINTER		0x10	/* weird %p pointer (`fake hex') */
+#define	NOSKIP		0x20	/* do not skip blanks */
+
+/*
+ * The following are used in numeric conversions only:
+ * SIGNOK, NDIGITS, DPTOK, and EXPOK are for floating point;
+ * SIGNOK, NDIGITS, PFXOK, and NZDIGITS are for integral.
+ */
+
+#define	SIGNOK		0x40	/* +/- is (still) legal */
+#define	NDIGITS		0x80	/* no digits detected */
+
+#define	DPTOK		0x100	/* (float) decimal point is still legal */
+#define	EXPOK		0x200	/* (float) exponent (e+3, etc) still legal */
+
+#define	PFXOK		0x100	/* 0x prefix is (still) legal */
+#define	NZDIGITS	0x200	/* no zero digits detected */
+
+/*
+ * Conversion types.
+ */
+
+#define	CT_CHAR		0	/* %c conversion */
+#define	CT_CCL		1	/* %[...] conversion */
+#define	CT_STRING	2	/* %s conversion */
+#define	CT_INT		3	/* integer, i.e., strtol or strtoul */
+#define	CT_FLOAT	4	/* floating, i.e., strtod */
+
+#if 0
+#define u_char unsigned char
+#endif
+#define u_char char
+#define u_long unsigned long
+
+/*static*/ u_char *__sccl ();
+
+/*
+ * vfscanf
+ */
+
+#define BufferEmpty (fp->_r <= 0 && __srefill(fp))
+
+int
+__svfscanf (fp, fmt0, ap)
+     register FILE *fp;
+     char _CONST *fmt0;
+     va_list ap;
+{
+  register u_char *fmt = (u_char *) fmt0;
+  register int c;		/* character from format, or conversion */
+  register size_t width;	/* field width, or 0 */
+  register char *p;		/* points into all kinds of strings */
+  register int n;		/* handy integer */
+  register int flags;		/* flags as defined above */
+  register char *p0;		/* saves original value of p when necessary */
+  int nassigned;		/* number of fields assigned */
+  int nread;			/* number of characters consumed from fp */
+  int base = 0;			/* base argument to strtol/strtoul */
+  int nbytes = 1;               /* number of bytes read from fmt string */
+  wchar_t wc;                   /* wchar to use to read format string */
+
+  u_long (*ccfn) () = 0;	/* conversion function (strtol/strtoul) */
+  char ccltab[256];		/* character class table for %[...] */
+  char buf[BUF];		/* buffer for numeric conversions */
+  char *lptr;                   /* literal pointer */
+  int state = 0;                /* value to keep track of multibyte state */
+
+  short *sp;
+  int *ip;
+  float *flp;
+  _LONG_DOUBLE *ldp;
+  double *dp;
+  long *lp;
+
+  /* `basefix' is used to avoid `if' tests in the integer scanner */
+  static _CONST short basefix[17] =
+    {10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
+
+  nassigned = 0;
+  nread = 0;
+  for (;;)
+    {
+#ifndef MB_CAPABLE
+      wc = *fmt;
+#else
+      nbytes = _mbtowc_r (_REENT, &wc, fmt, MB_CUR_MAX, &state);
+#endif
+      fmt += nbytes;
+      if (wc == 0)
+	return nassigned;
+      if (nbytes == 1 && isspace (wc))
+	{
+	  for (;;)
+	    {
+	      if (BufferEmpty)
+		return nassigned;
+	      if (!isspace (*fp->_p))
+		break;
+	      nread++, fp->_r--, fp->_p++;
+	    }
+	  continue;
+	}
+      if (wc != '%')
+	goto literal;
+      width = 0;
+      flags = 0;
+
+      /*
+       * switch on the format.  continue if done; break once format
+       * type is derived.
+       */
+
+    again:
+      c = *fmt++;
+
+      switch (c)
+	{
+	case '%':
+	literal:
+          lptr = fmt - nbytes;
+          for (n = 0; n < nbytes; ++n)
+            {
+	      if (BufferEmpty)
+	        goto input_failure;
+	      if (*fp->_p != *lptr)
+	        goto match_failure;
+	      fp->_r--, fp->_p++;
+	      nread++;
+              ++lptr;
+            }
+	  continue;
+
+	case '*':
+	  flags |= SUPPRESS;
+	  goto again;
+	case 'l':
+	  flags |= LONG;
+	  goto again;
+	case 'L':
+	  flags |= LONGDBL;
+	  goto again;
+	case 'h':
+	  flags |= SHORT;
+	  goto again;
+
+	case '0':
+	case '1':
+	case '2':
+	case '3':
+	case '4':
+	case '5':
+	case '6':
+	case '7':
+	case '8':
+	case '9':
+	  width = width * 10 + c - '0';
+	  goto again;
+
+	  /*
+	   * Conversions. Those marked `compat' are for
+	   * 4.[123]BSD compatibility.
+	   *
+	   * (According to ANSI, E and X formats are supposed to
+	   * the same as e and x.  Sorry about that.)
+	   */
+
+	case 'D':		/* compat */
+	  flags |= LONG;
+	  /* FALLTHROUGH */
+	case 'd':
+	  c = CT_INT;
+	  ccfn = (u_long (*)())strtol;
+	  base = 10;
+	  break;
+
+	case 'i':
+	  c = CT_INT;
+	  ccfn = (u_long (*)())strtol;
+	  base = 0;
+	  break;
+
+	case 'O':		/* compat */
+	  flags |= LONG;
+	  /* FALLTHROUGH */
+	case 'o':
+	  c = CT_INT;
+	  ccfn = strtoul;
+	  base = 8;
+	  break;
+
+	case 'u':
+	  c = CT_INT;
+	  ccfn = strtoul;
+	  base = 10;
+	  break;
+
+	case 'X':		/* compat   XXX */
+	case 'x':
+	  flags |= PFXOK;	/* enable 0x prefixing */
+	  c = CT_INT;
+	  ccfn = strtoul;
+	  base = 16;
+	  break;
+
+#ifdef FLOATING_POINT
+	case 'E':		/* compat   XXX */
+	case 'G':		/* compat   XXX */
+/* ANSI says that E,G and X behave the same way as e,g,x */
+	  /* FALLTHROUGH */
+	case 'e':
+	case 'f':
+	case 'g':
+	  c = CT_FLOAT;
+	  break;
+#endif
+
+	case 's':
+	  c = CT_STRING;
+	  break;
+
+	case '[':
+	  fmt = __sccl (ccltab, fmt);
+	  flags |= NOSKIP;
+	  c = CT_CCL;
+	  break;
+
+	case 'c':
+	  flags |= NOSKIP;
+	  c = CT_CHAR;
+	  break;
+
+	case 'p':		/* pointer format is like hex */
+	  flags |= POINTER | PFXOK;
+	  c = CT_INT;
+	  ccfn = strtoul;
+	  base = 16;
+	  break;
+
+	case 'n':
+	  if (flags & SUPPRESS)	/* ??? */
+	    continue;
+	  if (flags & SHORT)
+	    {
+	      sp = va_arg (ap, short *);
+	      *sp = nread;
+	    }
+	  else if (flags & LONG)
+	    {
+	      lp = va_arg (ap, long *);
+	      *lp = nread;
+	    }
+	  else
+	    {
+	      ip = va_arg (ap, int *);
+	      *ip = nread;
+	    }
+	  continue;
+
+	  /*
+	   * Disgusting backwards compatibility hacks.	XXX
+	   */
+	case '\0':		/* compat */
+	  return EOF;
+
+	default:		/* compat */
+	  if (isupper (c))
+	    flags |= LONG;
+	  c = CT_INT;
+	  ccfn = (u_long (*)())strtol;
+	  base = 10;
+	  break;
+	}
+
+      /*
+       * We have a conversion that requires input.
+       */
+      if (BufferEmpty)
+	goto input_failure;
+
+      /*
+       * Consume leading white space, except for formats that
+       * suppress this.
+       */
+      if ((flags & NOSKIP) == 0)
+	{
+	  while (isspace (*fp->_p))
+	    {
+	      nread++;
+	      if (--fp->_r > 0)
+		fp->_p++;
+	      else
+#ifndef CYGNUS_NEC
+	      if (__srefill (fp))
+#endif
+		goto input_failure;
+	    }
+	  /*
+	   * Note that there is at least one character in the
+	   * buffer, so conversions that do not set NOSKIP ca
+	   * no longer result in an input failure.
+	   */
+	}
+
+      /*
+       * Do the conversion.
+       */
+      switch (c)
+	{
+
+	case CT_CHAR:
+	  /* scan arbitrary characters (sets NOSKIP) */
+	  if (width == 0)
+	    width = 1;
+	  if (flags & SUPPRESS)
+	    {
+	      size_t sum = 0;
+
+	      for (;;)
+		{
+		  if ((n = fp->_r) < width)
+		    {
+		      sum += n;
+		      width -= n;
+		      fp->_p += n;
+#ifndef CYGNUS_NEC
+		      if (__srefill (fp))
+			{
+#endif
+			  if (sum == 0)
+			    goto input_failure;
+			  break;
+#ifndef CYGNUS_NEC
+			}
+#endif
+		    }
+		  else
+		    {
+		      sum += width;
+		      fp->_r -= width;
+		      fp->_p += width;
+		      break;
+		    }
+		}
+	      nread += sum;
+	    }
+	  else
+	    {
+#ifdef CYGNUS_NEC
+	      /* Kludge city for the moment */
+	      char *dest = va_arg (ap, char *);
+	      int n = width;
+	      if (fp->_r == 0)
+		goto input_failure;
+
+	      while (n && fp->_r)
+		{
+		  *dest++ = *(fp->_p++);
+		  n--;
+		  fp->_r--;
+		  nread++;
+		}
+#else
+	      size_t r = fread ((_PTR) va_arg (ap, char *), 1, width, fp);
+
+	      if (r == 0)
+		goto input_failure;
+	      nread += r;
+#endif
+	      nassigned++;
+	    }
+	  break;
+
+	case CT_CCL:
+	  /* scan a (nonempty) character class (sets NOSKIP) */
+	  if (width == 0)
+	    width = ~0;		/* `infinity' */
+	  /* take only those things in the class */
+	  if (flags & SUPPRESS)
+	    {
+	      n = 0;
+	      while (ccltab[*fp->_p])
+		{
+		  n++, fp->_r--, fp->_p++;
+		  if (--width == 0)
+		    break;
+		  if (BufferEmpty)
+		    {
+		      if (n == 0)
+			goto input_failure;
+		      break;
+		    }
+		}
+	      if (n == 0)
+		goto match_failure;
+	    }
+	  else
+	    {
+	      p0 = p = va_arg (ap, char *);
+	      while (ccltab[*fp->_p])
+		{
+		  fp->_r--;
+		  *p++ = *fp->_p++;
+		  if (--width == 0)
+		    break;
+		  if (BufferEmpty)
+		    {
+		      if (p == p0)
+			goto input_failure;
+		      break;
+		    }
+		}
+	      n = p - p0;
+	      if (n == 0)
+		goto match_failure;
+	      *p = 0;
+	      nassigned++;
+	    }
+	  nread += n;
+	  break;
+
+	case CT_STRING:
+	  /* like CCL, but zero-length string OK, & no NOSKIP */
+	  if (width == 0)
+	    width = ~0;
+	  if (flags & SUPPRESS)
+	    {
+	      n = 0;
+	      while (!isspace (*fp->_p))
+		{
+		  n++, fp->_r--, fp->_p++;
+		  if (--width == 0)
+		    break;
+		  if (BufferEmpty)
+		    break;
+		}
+	      nread += n;
+	    }
+	  else
+	    {
+	      p0 = p = va_arg (ap, char *);
+	      while (!isspace (*fp->_p))
+		{
+		  fp->_r--;
+		  *p++ = *fp->_p++;
+		  if (--width == 0)
+		    break;
+		  if (BufferEmpty)
+		    break;
+		}
+	      *p = 0;
+	      nread += p - p0;
+	      nassigned++;
+	    }
+	  continue;
+
+	case CT_INT:
+	  /* scan an integer as if by strtol/strtoul */
+#ifdef hardway
+	  if (width == 0 || width > sizeof (buf) - 1)
+	    width = sizeof (buf) - 1;
+#else
+	  /* size_t is unsigned, hence this optimisation */
+	  if (--width > sizeof (buf) - 2)
+	    width = sizeof (buf) - 2;
+	  width++;
+#endif
+	  flags |= SIGNOK | NDIGITS | NZDIGITS;
+	  for (p = buf; width; width--)
+	    {
+	      c = *fp->_p;
+	      /*
+	       * Switch on the character; `goto ok' if we
+	       * accept it as a part of number.
+	       */
+	      switch (c)
+		{
+		  /*
+		   * The digit 0 is always legal, but is special.
+		   * For %i conversions, if no digits (zero or nonzero)
+		   * have been scanned (only signs), we will have base==0.
+		   * In that case, we should set it to 8 and enable 0x
+		   * prefixing. Also, if we have not scanned zero digits
+		   * before this, do not turn off prefixing (someone else
+		   * will turn it off if we have scanned any nonzero digits).
+		   */
+		case '0':
+		  if (base == 0)
+		    {
+		      base = 8;
+		      flags |= PFXOK;
+		    }
+		  if (flags & NZDIGITS)
+		    flags &= ~(SIGNOK | NZDIGITS | NDIGITS);
+		  else
+		    flags &= ~(SIGNOK | PFXOK | NDIGITS);
+		  goto ok;
+
+		  /* 1 through 7 always legal */
+		case '1':
+		case '2':
+		case '3':
+		case '4':
+		case '5':
+		case '6':
+		case '7':
+		  base = basefix[base];
+		  flags &= ~(SIGNOK | PFXOK | NDIGITS);
+		  goto ok;
+
+		  /* digits 8 and 9 ok iff decimal or hex */
+		case '8':
+		case '9':
+		  base = basefix[base];
+		  if (base <= 8)
+		    break;	/* not legal here */
+		  flags &= ~(SIGNOK | PFXOK | NDIGITS);
+		  goto ok;
+
+		  /* letters ok iff hex */
+		case 'A':
+		case 'B':
+		case 'C':
+		case 'D':
+		case 'E':
+		case 'F':
+		case 'a':
+		case 'b':
+		case 'c':
+		case 'd':
+		case 'e':
+		case 'f':
+		  /* no need to fix base here */
+		  if (base <= 10)
+		    break;	/* not legal here */
+		  flags &= ~(SIGNOK | PFXOK | NDIGITS);
+		  goto ok;
+
+		  /* sign ok only as first character */
+		case '+':
+		case '-':
+		  if (flags & SIGNOK)
+		    {
+		      flags &= ~SIGNOK;
+		      goto ok;
+		    }
+		  break;
+
+		  /* x ok iff flag still set & 2nd char */
+		case 'x':
+		case 'X':
+		  if (flags & PFXOK && p == buf + 1)
+		    {
+		      base = 16;/* if %i */
+		      flags &= ~PFXOK;
+		      goto ok;
+		    }
+		  break;
+		}
+
+	      /*
+	       * If we got here, c is not a legal character
+	       * for a number.  Stop accumulating digits.
+	       */
+	      break;
+	    ok:
+	      /*
+	       * c is legal: store it and look at the next.
+	       */
+	      *p++ = c;
+	      if (--fp->_r > 0)
+		fp->_p++;
+	      else
+#ifndef CYGNUS_NEC
+	      if (__srefill (fp))
+#endif
+		break;		/* EOF */
+	    }
+	  /*
+	   * If we had only a sign, it is no good; push back the sign.
+	   * If the number ends in `x', it was [sign] '0' 'x', so push back
+	   * the x and treat it as [sign] '0'.
+	   */
+	  if (flags & NDIGITS)
+	    {
+	      if (p > buf)
+		_CAST_VOID ungetc (*(u_char *)-- p, fp);
+	      goto match_failure;
+	    }
+	  c = ((u_char *) p)[-1];
+	  if (c == 'x' || c == 'X')
+	    {
+	      --p;
+	      /*(void)*/ ungetc (c, fp);
+	    }
+	  if ((flags & SUPPRESS) == 0)
+	    {
+	      u_long res;
+
+	      *p = 0;
+	      res = (*ccfn) (buf, (char **) NULL, base);
+	      if (flags & POINTER)
+		*(va_arg (ap, _PTR *)) = (_PTR) (unsigned _POINTER_INT) res;
+	      else if (flags & SHORT)
+		{
+		  sp = va_arg (ap, short *);
+		  *sp = res;
+		}
+	      else if (flags & LONG)
+		{
+		  lp = va_arg (ap, long *);
+		  *lp = res;
+		}
+	      else
+		{
+		  ip = va_arg (ap, int *);
+		  *ip = res;
+		}
+	      nassigned++;
+	    }
+	  nread += p - buf;
+	  break;
+
+#ifdef FLOATING_POINT
+	case CT_FLOAT:
+	{
+	  /* scan a floating point number as if by strtod */
+	  /* This code used to assume that the number of digits is reasonable.
+	     However, ANSI / ISO C makes no such stipulation; we have to get
+	     exact results even when there is an unreasonable amount of
+	     leading zeroes.  */
+	  long leading_zeroes, zeroes, exp_adjust;
+	  char *exp_start;
+#ifdef hardway
+	  if (width == 0 || width > sizeof (buf) - 1)
+	    width = sizeof (buf) - 1;
+#else
+	  /* size_t is unsigned, hence this optimisation */
+	  if (--width > sizeof (buf) - 2)
+	    width = sizeof (buf) - 2;
+	  width++;
+#endif
+	  flags |= SIGNOK | NDIGITS | DPTOK | EXPOK;
+	  zeroes = 0;
+	  exp_adjust = 0;
+	  for (p = buf; width; )
+	    {
+	      c = *fp->_p;
+	      /*
+	       * This code mimicks the integer conversion
+	       * code, but is much simpler.
+	       */
+	      switch (c)
+		{
+
+		case '0':
+		  if (flags & NDIGITS)
+		    {
+		      flags &= ~SIGNOK;
+		      zeroes++;
+		      goto fskip;
+		    }
+		  /* Fall through.  */
+		case '1':
+		case '2':
+		case '3':
+		case '4':
+		case '5':
+		case '6':
+		case '7':
+		case '8':
+		case '9':
+		  flags &= ~(SIGNOK | NDIGITS);
+		  goto fok;
+
+		case '+':
+		case '-':
+		  if (flags & SIGNOK)
+		    {
+		      flags &= ~SIGNOK;
+		      goto fok;
+		    }
+		  break;
+		case '.':
+		  if (flags & DPTOK)
+		    {
+		      flags &= ~(SIGNOK | DPTOK);
+		      leading_zeroes = zeroes;
+		      goto fok;
+		    }
+		  break;
+		case 'e':
+		case 'E':
+		  /* no exponent without some digits */
+		  if ((flags & (NDIGITS | EXPOK)) == EXPOK
+		      || ((flags & EXPOK) && zeroes))
+		    {
+		      if (! (flags & DPTOK))
+			{
+			  exp_adjust = zeroes - leading_zeroes;
+			  exp_start = p;
+			}
+		      flags =
+			(flags & ~(EXPOK | DPTOK)) |
+			SIGNOK | NDIGITS;
+		      zeroes = 0;
+		      goto fok;
+		    }
+		  break;
+		}
+	      break;
+	    fok:
+	      *p++ = c;
+	      width--;
+	    fskip:
+	      if (--fp->_r > 0)
+		fp->_p++;
+	      else
+#ifndef CYGNUS_NEC
+	      if (__srefill (fp))
+#endif
+		break;		/* EOF */
+	    }
+	  if (zeroes)
+	    flags &= ~NDIGITS;
+	  /*
+	   * If no digits, might be missing exponent digits
+	   * (just give back the exponent) or might be missing
+	   * regular digits, but had sign and/or decimal point.
+	   */
+	  if (flags & NDIGITS)
+	    {
+	      if (flags & EXPOK)
+		{
+		  /* no digits at all */
+		  while (p > buf)
+		    ungetc (*(u_char *)-- p, fp);
+		  goto match_failure;
+		}
+	      /* just a bad exponent (e and maybe sign) */
+	      c = *(u_char *)-- p;
+	      if (c != 'e' && c != 'E')
+		{
+		  _CAST_VOID ungetc (c, fp);	/* sign */
+		  c = *(u_char *)-- p;
+		}
+	      _CAST_VOID ungetc (c, fp);
+	    }
+	  if ((flags & SUPPRESS) == 0)
+	    {
+	      double res;
+	      long new_exp;
+
+	      *p = 0;
+	      if ((flags & (DPTOK | EXPOK)) == EXPOK)
+		{
+		  exp_adjust = zeroes - leading_zeroes;
+		  new_exp = -exp_adjust;
+		  exp_start = p;
+		}
+	      else if (exp_adjust)
+		new_exp = atol (exp_start + 1) - exp_adjust;
+	      if (exp_adjust)
+		{
+
+		  /* If there might not be enough space for the new exponent,
+		     truncate some trailing digits to make room.  */
+		  if (exp_start >= buf + sizeof (buf) - MAX_LONG_LEN)
+		    exp_start = buf + sizeof (buf) - MAX_LONG_LEN - 1;
+		  sprintf (exp_start, "e%d", new_exp);
+		}
+	      res = atof (buf);
+	      if (flags & LONG)
+		{
+		  dp = va_arg (ap, double *);
+		  *dp = res;
+		}
+	      else if (flags & LONGDBL)
+		{
+		  ldp = va_arg (ap, _LONG_DOUBLE *);
+		  *ldp = res;
+		}
+	      else
+		{
+		  flp = va_arg (ap, float *);
+		  *flp = res;
+		}
+	      nassigned++;
+	    }
+	  nread += p - buf;
+	  break;
+	}
+#endif /* FLOATING_POINT */
+	}
+    }
+input_failure:
+  return nassigned ? nassigned : -1;
+match_failure:
+  return nassigned;
+}
+
+/*
+ * Fill in the given table from the scanset at the given format
+ * (just after `[').  Return a pointer to the character past the
+ * closing `]'.  The table has a 1 wherever characters should be
+ * considered part of the scanset.
+ */
+
+/*static*/
+u_char *
+__sccl (tab, fmt)
+     register char *tab;
+     register u_char *fmt;
+{
+  register int c, n, v;
+
+  /* first `clear' the whole table */
+  c = *fmt++;			/* first char hat => negated scanset */
+  if (c == '^')
+    {
+      v = 1;			/* default => accept */
+      c = *fmt++;		/* get new first char */
+    }
+  else
+    v = 0;			/* default => reject */
+  /* should probably use memset here */
+  for (n = 0; n < 256; n++)
+    tab[n] = v;
+  if (c == 0)
+    return fmt - 1;		/* format ended before closing ] */
+
+  /*
+   * Now set the entries corresponding to the actual scanset to the
+   * opposite of the above.
+   *
+   * The first character may be ']' (or '-') without being special; the
+   * last character may be '-'.
+   */
+
+  v = 1 - v;
+  for (;;)
+    {
+      tab[c] = v;		/* take character c */
+    doswitch:
+      n = *fmt++;		/* and examine the next */
+      switch (n)
+	{
+
+	case 0:		/* format ended too soon */
+	  return fmt - 1;
+
+	case '-':
+	  /*
+	   * A scanset of the form [01+-] is defined as `the digit 0, the
+	   * digit 1, the character +, the character -', but the effect of a
+	   * scanset such as [a-zA-Z0-9] is implementation defined.  The V7
+	   * Unix scanf treats `a-z' as `the letters a through z', but treats
+	   * `a-a' as `the letter a, the character -, and the letter a'.
+	   *
+	   * For compatibility, the `-' is not considerd to define a range if
+	   * the character following it is either a close bracket (required by
+	   * ANSI) or is not numerically greater than the character we just
+	   * stored in the table (c).
+	   */
+	  n = *fmt;
+	  if (n == ']' || n < c)
+	    {
+	      c = '-';
+	      break;		/* resume the for(;;) */
+	    }
+	  fmt++;
+	  do
+	    {			/* fill in the range */
+	      tab[++c] = v;
+	    }
+	  while (c < n);
+#if 1			/* XXX another disgusting compatibility hack */
+	  /*
+	   * Alas, the V7 Unix scanf also treats formats such
+	   * as [a-c-e] as `the letters a through e'. This too
+	   * is permitted by the standard....
+	   */
+	  goto doswitch;
+#else
+	  c = *fmt++;
+	  if (c == 0)
+	    return fmt - 1;
+	  if (c == ']')
+	    return fmt;
+#endif
+
+	  break;
+
+
+	case ']':		/* end of scanset */
+	  return fmt;
+
+	default:		/* just another character */
+	  c = n;
+	  break;
+	}
+    }
+  /* NOTREACHED */
+}
diff --git a/newlib/libc/stdio/vprintf.c b/newlib/libc/stdio/vprintf.c
new file mode 100644
index 000000000..c270141f0
--- /dev/null
+++ b/newlib/libc/stdio/vprintf.c
@@ -0,0 +1,35 @@
+/* doc in vfprintf.c */
+
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include <_ansi.h>
+#include <stdio.h>
+
+#ifdef _HAVE_STDC
+#include <stdarg.h>
+#else
+#include <varargs.h>
+#endif
+
+int
+vprintf (fmt, ap)
+     char _CONST *fmt;
+     va_list ap;
+{
+  return vfprintf (stdout, fmt, ap);
+}
diff --git a/newlib/libc/stdio/vsnprintf.c b/newlib/libc/stdio/vsnprintf.c
new file mode 100644
index 000000000..18df5864a
--- /dev/null
+++ b/newlib/libc/stdio/vsnprintf.c
@@ -0,0 +1,73 @@
+/* doc in vfprintf.c */
+
+/* This code created by modifying vsprintf.c so copyright inherited. */
+
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "%W% (Berkeley) %G%";
+#endif /* LIBC_SCCS and not lint */
+
+#include <_ansi.h>
+#include <reent.h>
+#include <stdio.h>
+#include <limits.h>
+#ifdef _HAVE_STDC
+#include <stdarg.h>
+#else
+#include <varargs.h>
+#endif
+
+int
+vsnprintf (str, size, fmt, ap)
+     char *str;
+     size_t size;
+     char _CONST *fmt;
+     va_list ap;
+{
+  int ret;
+  FILE f;
+
+  f._flags = __SWR | __SSTR;
+  f._bf._base = f._p = (unsigned char *) str;
+  f._bf._size = f._w = size;
+  f._data = _REENT;
+  ret = vfprintf (&f, fmt, ap);
+  *f._p = 0;
+  return ret;
+}
+
+int
+vsnprintf_r (ptr, str, size, fmt, ap)
+     struct _reent *ptr;
+     char *str;
+     size_t size;
+     char _CONST *fmt;
+     va_list ap;
+{
+  int ret;
+  FILE f;
+
+  f._flags = __SWR | __SSTR;
+  f._bf._base = f._p = (unsigned char *) str;
+  f._bf._size = f._w = size;
+  f._data = ptr;
+  ret = vfprintf (&f, fmt, ap);
+  *f._p = 0;
+  return ret;
+}
diff --git a/newlib/libc/stdio/vsprintf.c b/newlib/libc/stdio/vsprintf.c
new file mode 100644
index 000000000..416c184e8
--- /dev/null
+++ b/newlib/libc/stdio/vsprintf.c
@@ -0,0 +1,70 @@
+/* doc in vfprintf.c */
+
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "%W% (Berkeley) %G%";
+#endif /* LIBC_SCCS and not lint */
+
+#include <_ansi.h>
+#include <reent.h>
+#include <stdio.h>
+#include <limits.h>
+#ifdef _HAVE_STDC
+#include <stdarg.h>
+#else
+#include <varargs.h>
+#endif
+
+int
+vsprintf (str, fmt, ap)
+     char *str;
+     char _CONST *fmt;
+     va_list ap;
+{
+  int ret;
+  FILE f;
+
+  f._flags = __SWR | __SSTR;
+  f._bf._base = f._p = (unsigned char *) str;
+  f._bf._size = f._w = INT_MAX;
+  f._data = _REENT;
+  ret = vfprintf (&f, fmt, ap);
+  *f._p = 0;
+  return ret;
+}
+
+int
+vsprintf_r (ptr, str, fmt, ap)
+     struct _reent *ptr;
+     char *str;
+     char _CONST *fmt;
+     va_list ap;
+{
+  int ret;
+  FILE f;
+
+  f._flags = __SWR | __SSTR;
+  f._bf._base = f._p = (unsigned char *) str;
+  f._bf._size = f._w = INT_MAX;
+  f._data = ptr;
+  ret = vfprintf (&f, fmt, ap);
+  *f._p = 0;
+  return ret;
+}
+
diff --git a/newlib/libc/stdio/wbuf.c b/newlib/libc/stdio/wbuf.c
new file mode 100644
index 000000000..110682971
--- /dev/null
+++ b/newlib/libc/stdio/wbuf.c
@@ -0,0 +1,81 @@
+/* No user fns here.  Pesch 15apr92. */
+
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "%W% (Berkeley) %G%";
+#endif /* LIBC_SCCS and not lint */
+
+#include <stdio.h>
+#include "local.h"
+#include "fvwrite.h"
+
+/*
+ * Write the given character into the (probably full) buffer for
+ * the given file.  Flush the buffer out if it is or becomes full,
+ * or if c=='\n' and the file is line buffered.
+ */
+
+int
+__swbuf (c, fp)
+     register int c;
+     register FILE *fp;
+{
+  register int n;
+
+  /* Ensure stdio has been initialized.  */
+
+  CHECK_INIT (fp);
+
+  /*
+   * In case we cannot write, or longjmp takes us out early,
+   * make sure _w is 0 (if fully- or un-buffered) or -_bf._size
+   * (if line buffered) so that we will get called again.
+   * If we did not do this, a sufficient number of putc()
+   * calls might wrap _w from negative to positive.
+   */
+
+  fp->_w = fp->_lbfsize;
+  if (cantwrite (fp))
+    return EOF;
+  c = (unsigned char) c;
+
+  /*
+   * If it is completely full, flush it out.  Then, in any case,
+   * stuff c into the buffer.  If this causes the buffer to fill
+   * completely, or if c is '\n' and the file is line buffered,
+   * flush it (perhaps a second time).  The second flush will always
+   * happen on unbuffered streams, where _bf._size==1; fflush()
+   * guarantees that putc() will always call wbuf() by setting _w
+   * to 0, so we need not do anything else.
+   */
+
+  n = fp->_p - fp->_bf._base;
+  if (n >= fp->_bf._size)
+    {
+      if (fflush (fp))
+	return EOF;
+      n = 0;
+    }
+  fp->_w--;
+  *fp->_p++ = c;
+  if (++n == fp->_bf._size || (fp->_flags & __SLBF && c == '\n'))
+    if (fflush (fp))
+      return EOF;
+  return c;
+}
diff --git a/newlib/libc/stdio/wsetup.c b/newlib/libc/stdio/wsetup.c
new file mode 100644
index 000000000..23b032efe
--- /dev/null
+++ b/newlib/libc/stdio/wsetup.c
@@ -0,0 +1,79 @@
+/* No user fns here. Pesch 15apr92. */
+
+/*
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "local.h"
+
+/*
+ * Various output routines call wsetup to be sure it is safe to write,
+ * because either _flags does not include __SWR, or _buf is NULL.
+ * _wsetup returns 0 if OK to write, nonzero otherwise.
+ */
+
+int
+_DEFUN (__swsetup, (fp),
+	register FILE * fp)
+{
+  /* Make sure stdio is set up.  */
+
+  CHECK_INIT (fp);
+
+  /*
+   * If we are not writing, we had better be reading and writing.
+   */
+
+  if ((fp->_flags & __SWR) == 0)
+    {
+      if ((fp->_flags & __SRW) == 0)
+	return EOF;
+      if (fp->_flags & __SRD)
+	{
+	  /* clobber any ungetc data */
+	  if (HASUB (fp))
+	    FREEUB (fp);
+	  fp->_flags &= ~(__SRD | __SEOF);
+	  fp->_r = 0;
+	  fp->_p = fp->_bf._base;
+	}
+      fp->_flags |= __SWR;
+    }
+
+  /*
+   * Make a buffer if necessary, then set _w.
+   */
+  /* NOT NEEDED FOR CYGNUS SPRINTF ONLY jpg */
+  if (fp->_bf._base == NULL)
+    __smakebuf (fp);
+
+  if (fp->_flags & __SLBF)
+    {
+      /*
+       * It is line buffered, so make _lbfsize be -_bufsize
+       * for the putc() macro.  We will change _lbfsize back
+       * to 0 whenever we turn off __SWR.
+       */
+      fp->_w = 0;
+      fp->_lbfsize = -fp->_bf._size;
+    }
+  else
+    fp->_w = fp->_flags & __SNBF ? 0 : fp->_bf._size;
+
+  return 0;
+}