File operations for wide char streams.
authordrepper <drepper>
Wed, 16 Jun 1999 22:09:07 +0000 (22:09 +0000)
committerdrepper <drepper>
Wed, 16 Jun 1999 22:09:07 +0000 (22:09 +0000)
libio/wfileops.c [new file with mode: 0644]

diff --git a/libio/wfileops.c b/libio/wfileops.c
new file mode 100644 (file)
index 0000000..b040b97
--- /dev/null
@@ -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)
+};