about summary refs log tree commit diff
path: root/libio/wfileops.c
diff options
context:
space:
mode:
authorUlrich Drepper <drepper@redhat.com>1999-06-16 22:55:47 +0000
committerUlrich Drepper <drepper@redhat.com>1999-06-16 22:55:47 +0000
commitd64b6ad07585b8a37e5fecc9a47fcee766d52ede (patch)
tree076b36cc9c1b82254348212e75939d842885563a /libio/wfileops.c
parentbc938d3de936a8e429b16237180c046139be8247 (diff)
downloadglibc-d64b6ad07585b8a37e5fecc9a47fcee766d52ede.tar.gz
glibc-d64b6ad07585b8a37e5fecc9a47fcee766d52ede.tar.xz
glibc-d64b6ad07585b8a37e5fecc9a47fcee766d52ede.zip
Update.
	* Versions.def: Add GLIBC_2.2 for libc.

	* iconv/gconv.h: Make header suitable for inclusion in public header
	by protecting all names with __.
	* iconv/gconv.c: Adapt for symbol name changes.
	* iconv/gconv.h: Likewise.
	* iconv/gconv_builtin.c: Likewise.
	* iconv/gconv_close.c: Likewise.
	* iconv/gconv_db.c: Likewise.
	* iconv/gconv_dl.c: Likewise.
	* iconv/gconv_int.h: Likewise.
	* iconv/gconv_open.c: Likewise.
	* iconv/gconv_simple.c: Likewise.
	* iconv/iconv.c: Likewise.
	* iconv/iconv_close.c: Likewise.
	* iconv/iconv_open.c: Likewise.
	* iconv/loop.c: Likewise.
	* iconv/skeleton.c: Likewise.
	* iconvdata/8bit-gap.c: Likewise.
	* iconvdata/8bit-generic.c: Likewise.
	* iconvdata/ansi_x3.110.c: Likewise.
	* iconvdata/big5.c: Likewise.
	* iconvdata/cns11643.h: Likewise.
	* iconvdata/cns11643l1.h: Likewise.
	* iconvdata/euc-cn.c: Likewise.
	* iconvdata/euc-jp.c: Likewise.
	* iconvdata/euc-kr.c: Likewise.
	* iconvdata/euc-tw.c: Likewise.
	* iconvdata/gb2312.h: Likewise.
	* iconvdata/iso-2022-jp.c: Likewise.
	* iconvdata/iso-2022-kr.c: Likewise.
	* iconvdata/iso646.c: Likewise.
	* iconvdata/iso8859-1.c: Likewise.
	* iconvdata/iso_6937-2.c: Likewise.
	* iconvdata/iso_6937.c: Likewise.
	* iconvdata/jis0201.h: Likewise.
	* iconvdata/jis0208.h: Likewise.
	* iconvdata/jis0212.h: Likewise.
	* iconvdata/johab.c: Likewise.
	* iconvdata/ksc5601.h: Likewise.
	* iconvdata/sjis.c: Likewise.
	* iconvdata/t.61.c: Likewise.
	* iconvdata/uhc.c: Likewise.
	* stdlib/mblen.c: Likewise.
	* stdlib/mbtowc.c: Likewise.
	* stdlib/wctomb.c: Likewise.
	* wcsmbs/btowc.c: Likewise.
	* wcsmbs/mbrtowc.c: Likewise.
	* wcsmbs/mbsnrtowcs.c: Likewise.
	* wcsmbs/mbsrtowcs.c: Likewise.
	* wcsmbs/wchar.h: Likewise.
	* wcsmbs/wcrtomb.c: Likewise.
	* wcsmbs/wcsmbsload.c: Likewise.
	* wcsmbs/wcsmbsload.h: Likewise.
	* wcsmbs/wcsnrtombs.c: Likewise.
	* wcsmbs/wcsrtombs.c: Likewise.
	* wcsmbs/wctob.c: Likewise.

	* include/limits.h (MB_LEN_MAX): Increase to 16.

	* sysdeps/generic/_G_config.h: Define _G_fpos_t as struct.  Define
	_G_iconv_t.
	* sysdeps/unix/sysv/linux/_G_config.h: Likewise.
	* include/wchar.h: Change mbstate_t to __mbstate_t.

	* libio/Makefile (routines): Add wfiledoalloc, oldiofgetpos,
	oldiofgetpos64, oldiofsetpos, oldiofsetpos64, fputwc, fputwc_u,
	getwc, getwc_u, getwchar, getwchar_u, iofgetws, iofgetws_u,
	iofputws, iofputws_u, iogetwline, iowpadn, ioungetwc, putwc, putwc_u,
	putchar, putchar_u, swprintf, vwprintf, wprintf, wscanf, fwscanf,
	vwscanf, vswprintf, iovswscanf, swscanf, wgenops, wstrops, wfileops,
	and iofwide.
	(tests): Add tst_swprintf, tst_wprintf, tst_swscanf, and tst_wscanf.
	* libio/Versions: Add _IO_fgetpos, _IO_fgetpos64, _IO_fsetpos,
	_IO_fsetpos64, fgetpos, fgetpos64, fgetwc, fgetwc_unlocked, fgetws,
	fgetws_unlocked, fputwc, fputwc_unlocked, fputws, fputws_unlocked,
	fsetpos, fsetpos64, fwide, fwprintf, fwscanf, getwc, getwc_unlocked,
	getwchar, getwchar_unlocked, putwc, putwc_unlocked, putwchar,
	putwchar_unlocked, swprintf, swscanf, ungetwc, vfwprintf, vswprintf,
	vwprintf, vfwscanf, vswscanf, vwscanf, wprintf, and wscanf to
	GLIBC_2.2 for libc.
	* libio/libio.h: Define codecvt struct.  Define _IO_wide_data.
	Extend _IO_file contain pointer to codecvt, widedata and mode.
	(_IO_getwc_unlocked): New macro.
	(_IO_putwc_unlocked): New macro.
	(_IO_fwide): New macro.
	* libio/libioP.h: Add new prototypes and adjust existing declarations.
	* libio/fileops.c (_IO_new_file_close_it): Reset normal or widedata
	buffers based on mode.
	(new_do_write): Set _IO_write_end to _IO_buf_end if stream is wide
	oriented.
	(_IO_new_file_overflow): Don't depend only on _IO_CURRENTLY_PUTTING
	flag to be enough to signal unallocated buffer.  For wide oriented
	stream don't make it linebuffered.  Don't use _IO_do_flush, use
	_IO_new_do_write directly.
	(_IO_new_file_seekoff): Change return value type to _IO_off64_t.
	(_IO_file_seek): Likewise.
	* libio/genops.c (_IO_least_marker): Make global.
	(__underflow): Orient stream if not already done.
	(__uflow): Likewise.
	(_IO_default_seekpos): Change to type _IO_off64_t.
	(_IO_default_seekoff): Likewise.
	(_IO_default_seek): Likewise.
	(_IO_no_init): New function.  Similar to _IO_init but allows to orient
	in initialization.
	* libio/iolibio.h: Add prototype for _IO_vswprintf.  Change _IO_pos_BAD
	to use _IO_off64_t.
	* libio/ftello.c: Use _IO_off_t.  For now abort when use with wide
	char stream.
	* libio/ftello64.c: Likewise.
	* libio/ioftell.c: Likewise.
	* libio/iofopncook.c: Likewise.
	* libio/ioseekoff.c: Likewise.
	* libio/ioseekpos.c: Likewise.
	* libio/oldfileops.c: Likewise.
	* libio/iofgetpos.c: Store state of conversion if necessary.
	* libio/iofgetpos64.c: Likewise.
	* libio/iofsetpos.c: Restore conversion state if necessary.
	* libio/iofsetpos64.c: Likewise.
	* libio/iofdopen.c: Initialize so that stream can be wide oriented.
	* libio/iofopen.c: Likewise.
	* libio/iofopen64.c: Likewise.
	* libio/iopopen.c: Likewise.
	* libio/iovdprintf.c: Likewise.
	* libio/iovsprintf.c: Likewise.
	* libio/iovsscanf.c: Likewise.
	* libio/memstream.c: Likewise.
	* libio/obprintf.c: Likewise.
	* libio/iofputs.c: Orient stream if not already happened.
	* libio/iofputs_u.c: Likewise.
	* libio/iofwrite.c: Likewise.
	* libio/iofwrite_u.c: Likewise.
	* libio/ioputs.c: Likewise.
	* libio/iosetbuffer.c: Handle not yet oriented stream.
	* libio/iosetvbuf.c: Likewise.
	* libio/oldstdfiles.c: Adjust FILEBUF_LITERAL call.
	* libio/stdfiles.c: Likewise.
	* libio/strops.c (_IO_str_overflow): Correctly free buffer after
	failed allocation.
	(_IO_str_seekoff): Use _IO_off64_t.
	* libio/vasprintf.c: Pre-orient stream.
	* libio/vsnprintf.c: Likewise.
	* libio/fputwc.c: New file.
	* libio/fputwc_u.c: New file.
	* libio/fwprintf.c: New file.
	* libio/fwscanf.c: New file.
	* libio/getwc.c: New file.
	* libio/getwc_u.c: New file.
	* libio/getwchar.c: New file.
	* libio/getwchar_u.c: New file.
	* libio/iofgetws.c: New file.
	* libio/iofgetws_u.c: New file.
	* libio/iofputws.c: New file.
	* libio/iofputws_u.c: New file.
	* libio/iofwide.c: New file.
	* libio/iogetwline.c: New file.
	* libio/ioungetwc.c: New file.
	* libio/iovswscanf.c: New file.
	* libio/iowpadn.c: New file.
	* libio/oldiofgetpos.c: New file.
	* libio/oldiofgetpos64.c: New file.
	* libio/oldiofsetpos.c: New file.
	* libio/oldiofsetpos64.c: New file.
	* libio/putwc.c: New file.
	* libio/putwc_u.c: New file.
	* libio/putwchar.c: New file.
	* libio/putwchar_u.c: New file.
	* libio/swprintf.c: New file.
	* libio/swscanf.c: New file.
	* libio/tst_swprintf.c: New file.
	* libio/tst_swscanf.c: New file.
	* libio/tst_wprintf.c: New file.
	* libio/tst_wscanf.c: New file.
	* libio/tst_wscanf.input: New file.
	* libio/vswprintf.c: New file.
	* libio/vwprintf.c: New file.
	* libio/vwscanf.c: New file.
	* libio/wfiledoalloc.c: New file.
	* libio/wfileops.c: New file.
	* libio/wgenops.c: New file.
	* libio/wprintf.c: New file.
	* libio/wscanf.c: New file.
	* libio/wstrops.c: New file.
	* stdio-common/Makefile (routines): Add _itowa, itowa-digits,
	vfwprintf, and vfwscanf.
	* stdio-common/_itoa.c (base_table): Rename to _IO_base_table and
	make global.
	* stdio-common/_itowa.c: New file.
	* stdio-common/_itowa.h: New file.
	* stdio-common/itoa-digits.c: Minimal optimization.
	* stdio-common/itowa-digits.c: New file.
	* stdio-common/printf-parse.h: Allow use in wide character context.
	* stdio-common/printf-prs.c: Define ISASCII and MBRLEN.
	* stdio-common/printf.h (printf_info): Add wide bit.
	* stdio-common/printf_fp.c: Determine from wide bit whether stream
	is wide oriented or not.
	* stdio-common/printf_size.c: Likewise.
	* sysdeps/generic/printf_fphex.c: Likewise.
	* stdlib/strfmon.c: Call __printf_fp with wide bit cleared.
	* stdio-common/vfprintf.c: Rewrite to allow use in wide character
	context.
	* stdio-common/vfscand.c: Likewise.
	* stdio-common/vfwprintf.c: New file.
	* stdio-common/vfwscanf.c: New file.

	* time/Makefile (routines): Add wcsftime.
	(tests): Add tst_wcsftime.
	* time/Versions: Add wcsftime to GLIBC_2.2 for libc.
	* time/strftime.c: Make usable as wcsftime.
	* time/wcsftime.c: New file.
	* time/tst_wcsftime.c: New file.

	* wcsmbs/Makefile (routines): Add wmempcpy and wcschrnul.
	* wcsmbs/Versions: Add wmempcpy and wcschrnul to GLIBC_2.2 for libc.
	* wcsmbs/wcschrnul.c: New file.
	* wcsmbs/wmemcpy.c: New file.
	* wcsmbs/wmemcpy.c: Rename to __wmemcpy and make wmemcpy weak alias.
	* wcsmbs/wmemmove.c: Likewise for wmemmove.

	* manual/stdio.texi: Document is_char and wide element if printf_info.

	* manual/time.texi: Document wcsftime.

	* include/wchar.h: Add prototypes for __wmemcpy, __wmempcpy,
	__wmemmove, __wcschrnul, and __vfwscanf.

	* locale/langinfo.h: Add new LC_TIME entries for wchar_t data.
	* locale/C-time.c: Adapt for above change.
	* locale/categories.def: Likewise.
	* locale/localeinfo.h: Likewise.
	* localedata/Makefile: Don't run tests for now.
Diffstat (limited to 'libio/wfileops.c')
-rw-r--r--libio/wfileops.c716
1 files changed, 716 insertions, 0 deletions
diff --git a/libio/wfileops.c b/libio/wfileops.c
new file mode 100644
index 0000000000..b040b97491
--- /dev/null
+++ b/libio/wfileops.c
@@ -0,0 +1,716 @@
+/* Copyright (C) 1993, 1995, 1997, 1998, 1999 Free Software Foundation, Inc.
+   This file is part of the GNU IO Library.
+   Written by Ulrich Drepper <drepper@cygnus.com>.
+   Based on the single byte version by Per Bothner <bothner@cygnus.com>.
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2, or (at
+   your option) any later version.
+
+   This library is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this library; see the file COPYING.  If not, write to
+   the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
+   MA 02111-1307, USA.
+
+   As a special exception, if you link this library with files
+   compiled with a GNU compiler to produce an executable, this does
+   not cause the resulting executable to be covered by the GNU General
+   Public License.  This exception does not however invalidate any
+   other reasons why the executable file might be covered by the GNU
+   General Public License.  */
+
+#include <assert.h>
+#include <libioP.h>
+#include <wchar.h>
+#include <gconv.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+_IO_FILE *
+_IO_wfile_setbuf (fp, p, len)
+     _IO_FILE *fp;
+     wchar_t *p;
+     _IO_ssize_t len;
+{
+  if (_IO_wdefault_setbuf (fp, p, len) == NULL)
+    return NULL;
+
+  fp->_wide_data->_IO_write_base = fp->_wide_data->_IO_write_ptr =
+    fp->_wide_data->_IO_write_end = fp->_wide_data->_IO_buf_base;
+  _IO_wsetg (fp, fp->_wide_data->_IO_buf_base, fp->_wide_data->_IO_buf_base,
+	     fp->_wide_data->_IO_buf_base);
+
+  return fp;
+}
+
+
+/* Convert TO_DO wide character from DATA to FP.
+   Then mark FP as having empty buffers. */
+int
+_IO_wdo_write (fp, data, to_do)
+     _IO_FILE *fp;
+     const wchar_t *data;
+     _IO_size_t to_do;
+{
+  struct _IO_codecvt *cc = &fp->_wide_data->_codecvt;
+  _IO_size_t count = 0;
+
+  while (to_do > 0)
+    {
+      enum __codecvt_result result;
+      const wchar_t *new_data;
+
+      if (fp->_IO_write_end == fp->_IO_write_ptr)
+	{
+	  _IO_new_file_overflow (fp, EOF);
+	  assert (fp->_IO_write_end > fp->_IO_write_ptr);
+	}
+
+      /* Now convert from the internal format into the external buffer.  */
+      result = (*cc->__codecvt_do_out) (cc, &fp->_wide_data->_IO_state,
+					data, data + to_do, &new_data,
+					fp->_IO_write_ptr,
+					fp->_IO_write_end,
+					&fp->_IO_write_ptr);
+
+      /* Write out what we produced so far.  */
+      if (_IO_new_do_write (fp, fp->_IO_write_base,
+			    fp->_IO_write_ptr - fp->_IO_write_base) == EOF)
+	/* Something went wrong.  */
+	return EOF;
+
+      count += new_data - data;
+      to_do -= new_data - data;
+      data = new_data;
+
+      /* Next see whether we had problems during the conversion.  If yes,
+	 we cannot go on.  */
+      if (result != __codecvt_ok)
+	break;
+    }
+
+  _IO_wsetg (fp, fp->_wide_data->_IO_buf_base, fp->_wide_data->_IO_buf_base,
+	     fp->_wide_data->_IO_buf_base);
+  fp->_wide_data->_IO_write_base = fp->_wide_data->_IO_write_ptr
+    = fp->_wide_data->_IO_buf_base;
+  fp->_wide_data->_IO_write_end = ((fp->_flags & (_IO_LINE_BUF+_IO_UNBUFFERED))
+				   ? fp->_wide_data->_IO_buf_base
+				   : fp->_wide_data->_IO_buf_end);
+
+  return count;
+}
+
+
+wint_t
+_IO_wfile_underflow (fp)
+     _IO_FILE *fp;
+{
+  struct _IO_codecvt *cd;
+  enum __codecvt_result status;
+  _IO_ssize_t count;
+  int tries;
+  const char *read_ptr_copy;
+
+  if (fp->_flags & _IO_NO_READS)
+    {
+      __set_errno (EBADF);
+      return WEOF;
+    }
+  if (fp->_wide_data->_IO_read_ptr < fp->_wide_data->_IO_read_end)
+    return *fp->_wide_data->_IO_read_ptr;
+
+  cd = &fp->_wide_data->_codecvt;
+
+  /* Maybe there is something left in the external buffer.  */
+  if (fp->_IO_read_ptr < fp->_IO_read_end)
+    {
+      /* Convert it.  */
+      size_t avail_bytes = fp->_IO_read_end - fp->_IO_read_ptr;
+
+      if (avail_bytes >= (*cd->__codecvt_do_max_length) (cd))
+	{
+	  /* There is more in the external.  */
+	  const char *read_stop = (const char *) fp->_IO_read_ptr;
+
+	  fp->_wide_data->_IO_last_state = fp->_wide_data->_IO_state;
+	  status = (*cd->__codecvt_do_in) (cd, &fp->_wide_data->_IO_state,
+					   fp->_IO_read_ptr, fp->_IO_read_end,
+					   &read_stop,
+					   fp->_wide_data->_IO_read_end,
+					   fp->_wide_data->_IO_buf_end,
+					   &fp->_wide_data->_IO_read_end);
+
+	  fp->_IO_read_ptr = (char *) read_stop;
+
+	  /* If we managed to generate some text return the next character.  */
+	  if (fp->_wide_data->_IO_read_ptr < fp->_wide_data->_IO_read_end)
+	    return *fp->_wide_data->_IO_read_ptr;
+
+	  if (status == __codecvt_error)
+	    {
+	      __set_errno (EILSEQ);
+	      fp->_flags |= _IO_ERR_SEEN;
+	      return WEOF;
+	    }
+	}
+
+      /* Move the remaining content of the read buffer to the beginning.  */
+      memmove (fp->_IO_buf_base, fp->_IO_read_ptr,
+	       fp->_IO_read_end - fp->_IO_read_ptr);
+      fp->_IO_read_end = (fp->_IO_buf_base
+			  + (fp->_IO_read_end - fp->_IO_read_ptr));
+      fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_buf_base;
+    }
+  else
+    fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_read_end =
+      fp->_IO_buf_base;
+
+  fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end =
+    fp->_IO_buf_base;
+
+  if (fp->_IO_buf_base == NULL)
+    {
+      /* Maybe we already have a push back pointer.  */
+      if (fp->_IO_save_base != NULL)
+	{
+	  free (fp->_IO_save_base);
+	  fp->_flags &= ~_IO_IN_BACKUP;
+	}
+      _IO_doallocbuf (fp);
+    }
+
+  if (fp->_wide_data->_IO_buf_base == NULL)
+    {
+      /* Maybe we already have a push back pointer.  */
+      if (fp->_wide_data->_IO_save_base != NULL)
+	{
+	  free (fp->_wide_data->_IO_save_base);
+	  fp->_flags &= ~_IO_IN_BACKUP;
+	}
+      _IO_wdoallocbuf (fp);
+    }
+
+  /* Flush all line buffered files before reading. */
+  /* FIXME This can/should be moved to genops ?? */
+  if (fp->_flags & (_IO_LINE_BUF|_IO_UNBUFFERED))
+    _IO_flush_all_linebuffered ();
+
+  _IO_switch_to_get_mode (fp);
+
+  fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_buf_base;
+  fp->_IO_read_end = fp->_IO_buf_base;
+  fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end
+    = fp->_IO_buf_base;
+
+  fp->_wide_data->_IO_read_base = fp->_wide_data->_IO_read_ptr =
+    fp->_wide_data->_IO_buf_base;
+  fp->_wide_data->_IO_read_end = fp->_wide_data->_IO_buf_base;
+  fp->_wide_data->_IO_write_base = fp->_wide_data->_IO_write_ptr =
+    fp->_wide_data->_IO_write_end = fp->_wide_data->_IO_buf_base;
+
+  tries = 0;
+ again:
+  count = _IO_SYSREAD (fp, fp->_IO_read_end,
+		       fp->_IO_buf_end - fp->_IO_read_end);
+  if (count <= 0)
+    {
+      if (count == 0 && tries == 0)
+	fp->_flags |= _IO_EOF_SEEN;
+      else
+	fp->_flags |= _IO_ERR_SEEN, count = 0;
+    }
+  fp->_IO_read_end += count;
+  if (count == 0)
+    {
+      if (tries != 0)
+	/* There are some bytes in the external buffer but they don't
+           convert to anything.  */
+	__set_errno (EILSEQ);
+      return WEOF;
+    }
+  if (fp->_offset != _IO_pos_BAD)
+    _IO_pos_adjust (fp->_offset, count);
+
+  /* Now convert the read input.  */
+  fp->_wide_data->_IO_last_state = fp->_wide_data->_IO_state;
+  fp->_IO_read_base = fp->_IO_read_ptr;
+  status = (*cd->__codecvt_do_in) (cd, &fp->_wide_data->_IO_state,
+				   fp->_IO_read_ptr, fp->_IO_read_end,
+				   &read_ptr_copy,
+				   fp->_wide_data->_IO_read_end,
+				   fp->_wide_data->_IO_buf_end,
+				   &fp->_wide_data->_IO_read_end);
+
+  fp->_IO_read_ptr = (char *) read_ptr_copy;
+  if (fp->_wide_data->_IO_read_end == fp->_wide_data->_IO_buf_base)
+    {
+      if (status == __codecvt_error || fp->_IO_read_end == fp->_IO_buf_end)
+	{
+	  __set_errno (EILSEQ);
+	  fp->_flags |= _IO_ERR_SEEN;
+	  return WEOF;
+	}
+
+      /* The read bytes make no complete character.  Try reading again.  */
+      assert (status == __codecvt_partial);
+      ++tries;
+      goto again;
+    }
+
+  return *fp->_wide_data->_IO_read_ptr;
+}
+
+
+wint_t
+_IO_wfile_overflow (f, wch)
+     _IO_FILE *f;
+     wint_t wch;
+{
+  if (f->_flags & _IO_NO_WRITES) /* SET ERROR */
+    {
+      f->_flags |= _IO_ERR_SEEN;
+      __set_errno (EBADF);
+      return WEOF;
+    }
+  /* If currently reading or no buffer allocated. */
+  if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0)
+    {
+      /* Allocate a buffer if needed. */
+      if (f->_wide_data->_IO_write_base == 0)
+	{
+	  _IO_wdoallocbuf (f);
+	  _IO_wsetg (f, f->_wide_data->_IO_buf_base,
+		     f->_wide_data->_IO_buf_base, f->_wide_data->_IO_buf_base);
+	}
+      else
+	{
+	  /* Otherwise must be currently reading.  If _IO_read_ptr
+	     (and hence also _IO_read_end) is at the buffer end,
+	     logically slide the buffer forwards one block (by setting
+	     the read pointers to all point at the beginning of the
+	     block).  This makes room for subsequent output.
+	     Otherwise, set the read pointers to _IO_read_end (leaving
+	     that alone, so it can continue to correspond to the
+	     external position). */
+	  if (f->_wide_data->_IO_read_ptr == f->_wide_data->_IO_buf_end)
+	    {
+	      f->_IO_read_end = f->_IO_read_ptr = f->_IO_buf_base;
+	      f->_wide_data->_IO_read_end = f->_wide_data->_IO_read_ptr =
+		f->_wide_data->_IO_buf_base;
+	    }
+	}
+      f->_wide_data->_IO_write_ptr = f->_wide_data->_IO_read_ptr;
+      f->_wide_data->_IO_write_base = f->_wide_data->_IO_write_ptr;
+      f->_wide_data->_IO_write_end = f->_wide_data->_IO_buf_end;
+      f->_wide_data->_IO_read_base = f->_wide_data->_IO_read_ptr =
+	f->_wide_data->_IO_read_end;
+
+      f->_flags |= _IO_CURRENTLY_PUTTING;
+      if (f->_flags & (_IO_LINE_BUF+_IO_UNBUFFERED))
+	f->_wide_data->_IO_write_end = f->_wide_data->_IO_write_ptr;
+    }
+  if (wch == WEOF)
+    return _IO_do_flush (f);
+  if (f->_wide_data->_IO_write_ptr == f->_wide_data->_IO_buf_end )
+    /* Buffer is really full */
+    if (_IO_do_flush (f) == WEOF)
+      return WEOF;
+  *f->_wide_data->_IO_write_ptr++ = wch;
+  if ((f->_flags & _IO_UNBUFFERED)
+      || ((f->_flags & _IO_LINE_BUF) && wch == L'\n'))
+    if (_IO_do_flush (f) == WEOF)
+      return WEOF;
+  return wch;
+}
+
+wint_t
+_IO_wfile_sync (fp)
+     _IO_FILE *fp;
+{
+  _IO_ssize_t delta;
+  wint_t retval = 0;
+
+  /*    char* ptr = cur_ptr(); */
+  if (fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_write_base)
+    if (_IO_do_flush (fp))
+      return WEOF;
+  delta = fp->_wide_data->_IO_read_ptr - fp->_wide_data->_IO_read_end;
+  if (delta != 0)
+    {
+      /* We have to find out how many bytes we have to go back in the
+	 external buffer.  */
+      struct _IO_codecvt *cv = &fp->_wide_data->_codecvt;
+      _IO_off64_t new_pos;
+
+      int clen = (*cv->__codecvt_do_encoding) (cv);
+
+      if (clen > 0)
+	/* It is easy, a fixed number of input bytes are used for each
+	   wide character.  */
+	delta *= clen;
+      else
+	{
+	  /* We have to find out the hard way how much to back off.
+             To do this we determine how much input we needed to
+             generate the wide characters up to the current reading
+             position.  */
+	  int nread;
+
+	  fp->_wide_data->_IO_state = fp->_wide_data->_IO_last_state;
+	  nread = (*cv->__codecvt_do_length) (cv, &fp->_wide_data->_IO_state,
+					      fp->_IO_read_base,
+					      fp->_IO_read_end, delta);
+	  fp->_IO_read_ptr = fp->_IO_read_base + nread;
+	  delta = -(fp->_IO_read_end - fp->_IO_read_base - nread);
+	}
+
+      new_pos = _IO_SYSSEEK (fp, delta, 1);
+      if (new_pos != (_IO_off64_t) EOF)
+	{
+	  fp->_wide_data->_IO_read_end = fp->_wide_data->_IO_read_ptr;
+	  fp->_IO_read_end = fp->_IO_read_ptr;
+	}
+#ifdef ESPIPE
+      else if (errno == ESPIPE)
+	; /* Ignore error from unseekable devices. */
+#endif
+      else
+	retval = WEOF;
+    }
+  if (retval != WEOF)
+    fp->_offset = _IO_pos_BAD;
+  /* FIXME: Cleanup - can this be shared? */
+  /*    setg(base(), ptr, ptr); */
+  return retval;
+}
+
+_IO_off64_t
+_IO_wfile_seekoff (fp, offset, dir, mode)
+     _IO_FILE *fp;
+     _IO_off64_t offset;
+     int dir;
+     int mode;
+{
+  _IO_off64_t result;
+  _IO_off64_t delta, new_offset;
+  long int count;
+  /* POSIX.1 8.2.3.7 says that after a call the fflush() the file
+     offset of the underlying file must be exact.  */
+  int must_be_exact = ((fp->_wide_data->_IO_read_base
+			== fp->_wide_data->_IO_read_end)
+		       && (fp->_wide_data->_IO_write_base
+			   == fp->_wide_data->_IO_write_ptr));
+
+  if (mode == 0)
+    dir = _IO_seek_cur, offset = 0; /* Don't move any pointers. */
+
+  /* Flush unwritten characters.
+     (This may do an unneeded write if we seek within the buffer.
+     But to be able to switch to reading, we would need to set
+     egptr to ptr.  That can't be done in the current design,
+     which assumes file_ptr() is eGptr.  Anyway, since we probably
+     end up flushing when we close(), it doesn't make much difference.)
+     FIXME: simulate mem-papped files. */
+
+  if (fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_write_base
+      || _IO_in_put_mode (fp))
+    if (_IO_switch_to_get_mode (fp))
+      return WEOF;
+
+  if (fp->_wide_data->_IO_buf_base == NULL)
+    {
+      /* It could be that we already have a pushback buffer.  */
+      if (fp->_wide_data->_IO_read_base != NULL)
+	{
+	  free (fp->_wide_data->_IO_read_base);
+	  fp->_flags &= ~_IO_IN_BACKUP;
+	}
+      _IO_doallocbuf (fp);
+      _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
+      _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
+      _IO_wsetp (fp, fp->_wide_data->_IO_buf_base,
+		 fp->_wide_data->_IO_buf_base);
+      _IO_wsetg (fp, fp->_wide_data->_IO_buf_base,
+		 fp->_wide_data->_IO_buf_base, fp->_wide_data->_IO_buf_base);
+    }
+
+  switch (dir)
+    {
+      struct _IO_codecvt *cv;
+      int clen;
+
+    case _IO_seek_cur:
+      /* Adjust for read-ahead (bytes is buffer).  To do this we must
+         find out which position in the external buffer corresponds to
+         the current position in the internal buffer.  */
+      cv = &fp->_wide_data->_codecvt;
+      clen = (*cv->__codecvt_do_encoding) (cv);
+
+      if (clen > 0)
+	offset -= (fp->_wide_data->_IO_read_end
+		   - fp->_wide_data->_IO_read_ptr) * clen;
+      else
+	{
+	  int nread;
+
+	  delta = fp->_wide_data->_IO_read_ptr - fp->_wide_data->_IO_read_end;
+	  fp->_wide_data->_IO_state = fp->_wide_data->_IO_last_state;
+	  nread = (*cv->__codecvt_do_length) (cv, &fp->_wide_data->_IO_state,
+					      fp->_IO_read_base,
+					      fp->_IO_read_end, delta);
+	  fp->_IO_read_ptr = fp->_IO_read_base + nread;
+	  offset -= fp->_IO_read_end - fp->_IO_read_base - nread;
+	}
+
+      if (fp->_offset == _IO_pos_BAD)
+	goto dumb;
+      /* Make offset absolute, assuming current pointer is file_ptr(). */
+      offset += fp->_offset;
+
+      dir = _IO_seek_set;
+      break;
+    case _IO_seek_set:
+      break;
+    case _IO_seek_end:
+      {
+	struct _G_stat64 st;
+	if (_IO_SYSSTAT (fp, &st) == 0 && S_ISREG (st.st_mode))
+	  {
+	    offset += st.st_size;
+	    dir = _IO_seek_set;
+	  }
+	else
+	  goto dumb;
+      }
+    }
+  /* At this point, dir==_IO_seek_set. */
+
+  /* If we are only interested in the current position we've found it now.  */
+  if (mode == 0)
+    return offset;
+
+  /* If destination is within current buffer, optimize: */
+  if (fp->_offset != _IO_pos_BAD && fp->_IO_read_base != NULL
+      && !_IO_in_backup (fp))
+    {
+      /* Offset relative to start of main get area. */
+      _IO_off64_t rel_offset = (offset - fp->_offset
+				+ (fp->_IO_read_end - fp->_IO_read_base));
+      if (rel_offset >= 0)
+	{
+#if 0
+	  if (_IO_in_backup (fp))
+	    _IO_switch_to_main_get_area (fp);
+#endif
+	  if (rel_offset <= fp->_IO_read_end - fp->_IO_read_base)
+	    {
+	      fp->_IO_read_ptr = fp->_IO_read_base + rel_offset;
+	      _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
+
+	      /* Now set the pointer for the internal buffer.  This
+                 might be an iterative process.  Though the read
+                 pointer is somewhere in the current external buffer
+                 this does not mean we can convert this whole buffer
+                 at once fitting in the internal buffer.  */
+	      do
+		{
+
+		}
+	      while (0);
+
+	      _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
+	      goto resync;
+	    }
+#ifdef TODO
+	    /* If we have streammarkers, seek forward by reading ahead. */
+	    if (_IO_have_markers (fp))
+	      {
+		int to_skip = rel_offset
+		  - (fp->_IO_read_ptr - fp->_IO_read_base);
+		if (ignore (to_skip) != to_skip)
+		  goto dumb;
+		_IO_mask_flags (fp, 0, _IO_EOF_SEEN);
+		goto resync;
+	      }
+#endif
+	}
+#ifdef TODO
+      if (rel_offset < 0 && rel_offset >= Bbase () - Bptr ())
+	{
+	  if (!_IO_in_backup (fp))
+	    _IO_switch_to_backup_area (fp);
+	  gbump (fp->_IO_read_end + rel_offset - fp->_IO_read_ptr);
+	  _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
+	  goto resync;
+	}
+#endif
+    }
+
+#ifdef TODO
+  _IO_unsave_markers (fp);
+#endif
+
+  if (fp->_flags & _IO_NO_READS)
+    goto dumb;
+
+  /* Try to seek to a block boundary, to improve kernel page management. */
+  new_offset = offset & ~(fp->_IO_buf_end - fp->_IO_buf_base - 1);
+  delta = offset - new_offset;
+  if (delta > fp->_IO_buf_end - fp->_IO_buf_base)
+    {
+      new_offset = offset;
+      delta = 0;
+    }
+  result = _IO_SYSSEEK (fp, new_offset, 0);
+  if (result < 0)
+    return EOF;
+  if (delta == 0)
+    count = 0;
+  else
+    {
+      count = _IO_SYSREAD (fp, fp->_IO_buf_base,
+			   (must_be_exact
+			    ? delta : fp->_IO_buf_end - fp->_IO_buf_base));
+      if (count < delta)
+	{
+	  /* We weren't allowed to read, but try to seek the remainder. */
+	  offset = count == EOF ? delta : delta-count;
+	  dir = _IO_seek_cur;
+	  goto dumb;
+	}
+    }
+  _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base + delta,
+	    fp->_IO_buf_base + count);
+  _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
+  fp->_offset = result + count;
+  _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
+  return offset;
+ dumb:
+
+  _IO_unsave_markers (fp);
+  result = _IO_SYSSEEK (fp, offset, dir);
+  if (result != EOF)
+    {
+      _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
+      fp->_offset = result;
+      _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
+      _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
+    }
+  return result;
+
+resync:
+  /* We need to do it since it is possible that the file offset in
+     the kernel may be changed behind our back. It may happen when
+     we fopen a file and then do a fork. One process may access the
+     the file and the kernel file offset will be changed. */
+  if (fp->_offset >= 0)
+    _IO_SYSSEEK (fp, fp->_offset, 0);
+
+  return offset;
+}
+
+
+_IO_size_t
+_IO_wfile_xsputn (f, data, n)
+     _IO_FILE *f;
+     const void *data;
+     _IO_size_t n;
+{
+  register const wchar_t *s = (const wchar_t *) data;
+  _IO_size_t to_do = n;
+  int must_flush = 0;
+  _IO_size_t count;
+
+  if (n <= 0)
+    return 0;
+  /* This is an optimized implementation.
+     If the amount to be written straddles a block boundary
+     (or the filebuf is unbuffered), use sys_write directly. */
+
+  /* First figure out how much space is available in the buffer. */
+  count = f->_wide_data->_IO_write_end - f->_wide_data->_IO_write_ptr;
+  if ((f->_flags & _IO_LINE_BUF) && (f->_flags & _IO_CURRENTLY_PUTTING))
+    {
+      count = f->_wide_data->_IO_buf_end - f->_wide_data->_IO_write_ptr;
+      if (count >= n)
+	{
+	  register const wchar_t *p;
+	  for (p = s + n; p > s; )
+	    {
+	      if (*--p == L'\n')
+		{
+		  count = p - s + 1;
+		  must_flush = 1;
+		  break;
+		}
+	    }
+	}
+    }
+  /* Then fill the buffer. */
+  if (count > 0)
+    {
+      if (count > to_do)
+	count = to_do;
+      if (count > 20)
+	{
+#ifdef _LIBC
+	  f->_wide_data->_IO_write_ptr =
+	    __wmempcpy (f->_wide_data->_IO_write_ptr, s, count);
+#else
+	  wmemcpy (f->_wide_data->_IO_write_ptr, s, count);
+	  f->_wide_data->_IO_write_ptr += count;
+#endif
+	  s += count;
+	}
+      else
+	{
+	  register wchar_t *p = f->_wide_data->_IO_write_ptr;
+	  register int i = (int) count;
+	  while (--i >= 0)
+	    *p++ = *s++;
+	  f->_wide_data->_IO_write_ptr = p;
+	}
+      to_do -= count;
+    }
+  if (to_do > 0)
+    to_do -= _IO_wdefault_xsputn (f, s, to_do);
+  if (must_flush
+      && f->_wide_data->_IO_write_ptr != f->_wide_data->_IO_write_base)
+    _IO_wdo_write (f, f->_wide_data->_IO_write_base,
+		   f->_wide_data->_IO_write_ptr
+		   - f->_wide_data->_IO_write_base);
+
+  return n - to_do;
+}
+
+
+struct _IO_jump_t _IO_wfile_jumps =
+{
+  JUMP_INIT_DUMMY,
+  JUMP_INIT(finish, _IO_new_file_finish),
+  JUMP_INIT(overflow, (_IO_overflow_t) _IO_wfile_overflow),
+  JUMP_INIT(underflow, (_IO_underflow_t) _IO_wfile_underflow),
+  JUMP_INIT(uflow, (_IO_underflow_t) _IO_wdefault_uflow),
+  JUMP_INIT(pbackfail, _IO_default_pbackfail),
+  JUMP_INIT(xsputn, _IO_wfile_xsputn),
+  JUMP_INIT(xsgetn, _IO_file_xsgetn),
+  JUMP_INIT(seekoff, _IO_wfile_seekoff),
+  JUMP_INIT(seekpos, _IO_default_seekpos),
+  JUMP_INIT(setbuf, _IO_new_file_setbuf),
+  JUMP_INIT(sync, (_IO_sync_t) _IO_wfile_sync),
+  JUMP_INIT(doallocate, _IO_wfile_doallocate),
+  JUMP_INIT(read, _IO_file_read),
+  JUMP_INIT(write, _IO_new_file_write),
+  JUMP_INIT(seek, _IO_file_seek),
+  JUMP_INIT(close, _IO_file_close),
+  JUMP_INIT(stat, _IO_file_stat),
+  JUMP_INIT(showmanyc, _IO_default_showmanyc),
+  JUMP_INIT(imbue, _IO_default_imbue)
+};