libio/wfileops.c

   1 /* Copyright (C) 1993, 95, 97, 98, 99, 2000 Free Software Foundation, Inc.
   2    This file is part of the GNU IO Library.
   3    Written by Ulrich Drepper <drepper@cygnus.com>.
   4    Based on the single byte version by Per Bothner <bothner@cygnus.com>.
   5
   6    This library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU General Public License as
   8    published by the Free Software Foundation; either version 2, or (at
   9    your option) any later version.
  10
  11    This library is distributed in the hope that it will be useful, but
  12    WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this library; see the file COPYING.  If not, write to
  18    the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
  19    MA 02111-1307, USA.
  20
  21    As a special exception, if you link this library with files
  22    compiled with a GNU compiler to produce an executable, this does
  23    not cause the resulting executable to be covered by the GNU General
  24    Public License.  This exception does not however invalidate any
  25    other reasons why the executable file might be covered by the GNU
  26    General Public License.  */
  27
  28 #include <assert.h>
  29 #include <libioP.h>
  30 #include <wchar.h>
  31 #include <gconv.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34
  35
  36 #ifndef _LIBC
  37 # define _IO_new_do_write _IO_do_write
  38 # define _IO_new_file_attach _IO_file_attach
  39 # define _IO_new_file_close_it _IO_file_close_it
  40 # define _IO_new_file_finish _IO_file_finish
  41 # define _IO_new_file_fopen _IO_file_fopen
  42 # define _IO_new_file_init _IO_file_init
  43 # define _IO_new_file_setbuf _IO_file_setbuf
  44 # define _IO_new_file_sync _IO_file_sync
  45 # define _IO_new_file_overflow _IO_file_overflow
  46 # define _IO_new_file_seekoff _IO_file_seekoff
  47 # define _IO_new_file_underflow _IO_file_underflow
  48 # define _IO_new_file_write _IO_file_write
  49 # define _IO_new_file_xsputn _IO_file_xsputn
  50 #endif
  51
  52
  53 _IO_FILE *
  54 _IO_wfile_setbuf (fp, p, len)
  55      _IO_FILE *fp;
  56      wchar_t *p;
  57      _IO_ssize_t len;
  58 {
  59   if (_IO_wdefault_setbuf (fp, p, len) == NULL)
  60     return NULL;
  61
  62   fp->_wide_data->_IO_write_base = fp->_wide_data->_IO_write_ptr =
  63     fp->_wide_data->_IO_write_end = fp->_wide_data->_IO_buf_base;
  64   _IO_wsetg (fp, fp->_wide_data->_IO_buf_base, fp->_wide_data->_IO_buf_base,
  65              fp->_wide_data->_IO_buf_base);
  66
  67   return fp;
  68 }
  69
  70
  71 /* Convert TO_DO wide character from DATA to FP.
  72    Then mark FP as having empty buffers. */
  73 int
  74 _IO_wdo_write (fp, data, to_do)
  75      _IO_FILE *fp;
  76      const wchar_t *data;
  77      _IO_size_t to_do;
  78 {
  79   struct _IO_codecvt *cc = fp->_codecvt;
  80
  81   if (to_do > 0)
  82     {
  83       if (fp->_IO_write_end == fp->_IO_write_ptr
  84           && fp->_IO_write_end != fp->_IO_write_base)
  85         {
  86           if (_IO_new_do_write (fp, fp->_IO_write_base,
  87                                 fp->_IO_write_ptr - fp->_IO_write_base) == EOF)
  88             return EOF;
  89         }
  90
  91       do
  92         {
  93           enum __codecvt_result result;
  94           const wchar_t *new_data;
  95
  96           /* Now convert from the internal format into the external buffer.  */
  97           result = (*cc->__codecvt_do_out) (cc, &fp->_wide_data->_IO_state,
  98                                             data, data + to_do, &new_data,
  99                                             fp->_IO_write_ptr,
 100                                             fp->_IO_buf_end,
 101                                             &fp->_IO_write_ptr);
 102
 103           /* Write out what we produced so far.  */
 104           if (_IO_new_do_write (fp, fp->_IO_write_base,
 105                                 fp->_IO_write_ptr - fp->_IO_write_base) == EOF)
 106             /* Something went wrong.  */
 107             return EOF;
 108
 109           to_do -= new_data - data;
 110
 111           /* Next see whether we had problems during the conversion.  If yes,
 112              we cannot go on.  */
 113           if (result != __codecvt_ok
 114               && (result != __codecvt_partial || new_data - data == 0))
 115             break;
 116
 117           data = new_data;
 118         }
 119       while (to_do > 0);
 120     }
 121
 122   _IO_wsetg (fp, fp->_wide_data->_IO_buf_base, fp->_wide_data->_IO_buf_base,
 123              fp->_wide_data->_IO_buf_base);
 124   fp->_wide_data->_IO_write_base = fp->_wide_data->_IO_write_ptr
 125     = fp->_wide_data->_IO_buf_base;
 126   fp->_wide_data->_IO_write_end = ((fp->_flags & (_IO_LINE_BUF+_IO_UNBUFFERED))
 127                                    ? fp->_wide_data->_IO_buf_base
 128                                    : fp->_wide_data->_IO_buf_end);
 129
 130   return to_do == 0 ? 0 : WEOF;
 131 }
 132
 133
 134 wint_t
 135 _IO_wfile_underflow (fp)
 136      _IO_FILE *fp;
 137 {
 138   struct _IO_codecvt *cd;
 139   enum __codecvt_result status;
 140   _IO_ssize_t count;
 141   int tries;
 142   const char *read_ptr_copy;
 143
 144   if (fp->_flags & _IO_NO_READS)
 145     {
 146       fp->_flags |= _IO_ERR_SEEN;
 147       __set_errno (EBADF);
 148       return WEOF;
 149     }
 150   if (fp->_wide_data->_IO_read_ptr < fp->_wide_data->_IO_read_end)
 151     return *fp->_wide_data->_IO_read_ptr;
 152
 153   cd = fp->_codecvt;
 154
 155   /* Maybe there is something left in the external buffer.  */
 156   if (fp->_IO_read_ptr < fp->_IO_read_end)
 157     {
 158       /* Convert it.  */
 159       size_t avail_bytes = fp->_IO_read_end - fp->_IO_read_ptr;
 160
 161       if (avail_bytes >= (*cd->__codecvt_do_max_length) (cd))
 162         {
 163           /* There is more in the external.  */
 164           const char *read_stop = (const char *) fp->_IO_read_ptr;
 165
 166           fp->_wide_data->_IO_last_state = fp->_wide_data->_IO_state;
 167           status = (*cd->__codecvt_do_in) (cd, &fp->_wide_data->_IO_state,
 168                                            fp->_IO_read_ptr, fp->_IO_read_end,
 169                                            &read_stop,
 170                                            fp->_wide_data->_IO_read_end,
 171                                            fp->_wide_data->_IO_buf_end,
 172                                            &fp->_wide_data->_IO_read_end);
 173
 174           fp->_IO_read_ptr = (char *) read_stop;
 175
 176           /* If we managed to generate some text return the next character.  */
 177           if (fp->_wide_data->_IO_read_ptr < fp->_wide_data->_IO_read_end)
 178             return *fp->_wide_data->_IO_read_ptr;
 179
 180           if (status == __codecvt_error)
 181             {
 182               __set_errno (EILSEQ);
 183               fp->_flags |= _IO_ERR_SEEN;
 184               return WEOF;
 185             }
 186         }
 187
 188       /* Move the remaining content of the read buffer to the beginning.  */
 189       memmove (fp->_IO_buf_base, fp->_IO_read_ptr,
 190                fp->_IO_read_end - fp->_IO_read_ptr);
 191       fp->_IO_read_end = (fp->_IO_buf_base
 192                           + (fp->_IO_read_end - fp->_IO_read_ptr));
 193       fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_buf_base;
 194     }
 195   else
 196     fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_read_end =
 197       fp->_IO_buf_base;
 198
 199   if (fp->_IO_buf_base == NULL)
 200     {
 201       /* Maybe we already have a push back pointer.  */
 202       if (fp->_IO_save_base != NULL)
 203         {
 204           free (fp->_IO_save_base);
 205           fp->_flags &= ~_IO_IN_BACKUP;
 206         }
 207       _IO_doallocbuf (fp);
 208
 209       fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_read_end =
 210         fp->_IO_buf_base;
 211     }
 212
 213   fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end =
 214     fp->_IO_buf_base;
 215
 216   if (fp->_wide_data->_IO_buf_base == NULL)
 217     {
 218       /* Maybe we already have a push back pointer.  */
 219       if (fp->_wide_data->_IO_save_base != NULL)
 220         {
 221           free (fp->_wide_data->_IO_save_base);
 222           fp->_flags &= ~_IO_IN_BACKUP;
 223         }
 224       _IO_wdoallocbuf (fp);
 225     }
 226
 227   /* Flush all line buffered files before reading. */
 228   /* FIXME This can/should be moved to genops ?? */
 229   if (fp->_flags & (_IO_LINE_BUF|_IO_UNBUFFERED))
 230     _IO_flush_all_linebuffered ();
 231
 232   _IO_switch_to_get_mode (fp);
 233
 234   fp->_wide_data->_IO_read_base = fp->_wide_data->_IO_read_ptr =
 235     fp->_wide_data->_IO_buf_base;
 236   fp->_wide_data->_IO_read_end = fp->_wide_data->_IO_buf_base;
 237   fp->_wide_data->_IO_write_base = fp->_wide_data->_IO_write_ptr =
 238     fp->_wide_data->_IO_write_end = fp->_wide_data->_IO_buf_base;
 239
 240   tries = 0;
 241  again:
 242   count = _IO_SYSREAD (fp, fp->_IO_read_end,
 243                        fp->_IO_buf_end - fp->_IO_read_end);
 244   if (count <= 0)
 245     {
 246       if (count == 0 && tries == 0)
 247         fp->_flags |= _IO_EOF_SEEN;
 248       else
 249         fp->_flags |= _IO_ERR_SEEN, count = 0;
 250     }
 251   fp->_IO_read_end += count;
 252   if (count == 0)
 253     {
 254       if (tries != 0)
 255         /* There are some bytes in the external buffer but they don't
 256            convert to anything.  */
 257         __set_errno (EILSEQ);
 258       return WEOF;
 259     }
 260   if (fp->_offset != _IO_pos_BAD)
 261     _IO_pos_adjust (fp->_offset, count);
 262
 263   /* Now convert the read input.  */
 264   fp->_wide_data->_IO_last_state = fp->_wide_data->_IO_state;
 265   fp->_IO_read_base = fp->_IO_read_ptr;
 266   status = (*cd->__codecvt_do_in) (cd, &fp->_wide_data->_IO_state,
 267                                    fp->_IO_read_ptr, fp->_IO_read_end,
 268                                    &read_ptr_copy,
 269                                    fp->_wide_data->_IO_read_end,
 270                                    fp->_wide_data->_IO_buf_end,
 271                                    &fp->_wide_data->_IO_read_end);
 272
 273   fp->_IO_read_ptr = (char *) read_ptr_copy;
 274   if (fp->_wide_data->_IO_read_end == fp->_wide_data->_IO_buf_base)
 275     {
 276       if (status == __codecvt_error || fp->_IO_read_end == fp->_IO_buf_end)
 277         {
 278           __set_errno (EILSEQ);
 279           fp->_flags |= _IO_ERR_SEEN;
 280           return WEOF;
 281         }
 282
 283       /* The read bytes make no complete character.  Try reading again.  */
 284       assert (status == __codecvt_partial);
 285       ++tries;
 286       goto again;
 287     }
 288
 289   return *fp->_wide_data->_IO_read_ptr;
 290 }
 291
 292
 293 wint_t
 294 _IO_wfile_overflow (f, wch)
 295      _IO_FILE *f;
 296      wint_t wch;
 297 {
 298   if (f->_flags & _IO_NO_WRITES) /* SET ERROR */
 299     {
 300       f->_flags |= _IO_ERR_SEEN;
 301       __set_errno (EBADF);
 302       return WEOF;
 303     }
 304   /* If currently reading or no buffer allocated. */
 305   if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0)
 306     {
 307       /* Allocate a buffer if needed. */
 308       if (f->_wide_data->_IO_write_base == 0)
 309         {
 310           _IO_wdoallocbuf (f);
 311           _IO_wsetg (f, f->_wide_data->_IO_buf_base,
 312                      f->_wide_data->_IO_buf_base, f->_wide_data->_IO_buf_base);
 313
 314           if (f->_IO_write_base == NULL)
 315             {
 316               _IO_doallocbuf (f);
 317               _IO_setg (f, f->_IO_buf_base, f->_IO_buf_base, f->_IO_buf_base);
 318             }
 319         }
 320       else
 321         {
 322           /* Otherwise must be currently reading.  If _IO_read_ptr
 323              (and hence also _IO_read_end) is at the buffer end,
 324              logically slide the buffer forwards one block (by setting
 325              the read pointers to all point at the beginning of the
 326              block).  This makes room for subsequent output.
 327              Otherwise, set the read pointers to _IO_read_end (leaving
 328              that alone, so it can continue to correspond to the
 329              external position). */
 330           if (f->_wide_data->_IO_read_ptr == f->_wide_data->_IO_buf_end)
 331             {
 332               f->_IO_read_end = f->_IO_read_ptr = f->_IO_buf_base;
 333               f->_wide_data->_IO_read_end = f->_wide_data->_IO_read_ptr =
 334                 f->_wide_data->_IO_buf_base;
 335             }
 336         }
 337       f->_wide_data->_IO_write_ptr = f->_wide_data->_IO_read_ptr;
 338       f->_wide_data->_IO_write_base = f->_wide_data->_IO_write_ptr;
 339       f->_wide_data->_IO_write_end = f->_wide_data->_IO_buf_end;
 340       f->_wide_data->_IO_read_base = f->_wide_data->_IO_read_ptr =
 341         f->_wide_data->_IO_read_end;
 342
 343       f->_IO_write_ptr = f->_IO_read_ptr;
 344       f->_IO_write_base = f->_IO_write_ptr;
 345       f->_IO_write_end = f->_IO_buf_end;
 346       f->_IO_read_base = f->_IO_read_ptr = f->_IO_read_end;
 347
 348       f->_flags |= _IO_CURRENTLY_PUTTING;
 349       if (f->_flags & (_IO_LINE_BUF+_IO_UNBUFFERED))
 350         f->_wide_data->_IO_write_end = f->_wide_data->_IO_write_ptr;
 351     }
 352   if (wch == WEOF)
 353     return _IO_do_flush (f);
 354   if (f->_wide_data->_IO_write_ptr == f->_wide_data->_IO_buf_end)
 355     /* Buffer is really full */
 356     if (_IO_do_flush (f) == WEOF)
 357       return WEOF;
 358   *f->_wide_data->_IO_write_ptr++ = wch;
 359   if ((f->_flags & _IO_UNBUFFERED)
 360       || ((f->_flags & _IO_LINE_BUF) && wch == L'\n'))
 361     if (_IO_do_flush (f) == WEOF)
 362       return WEOF;
 363   return wch;
 364 }
 365
 366 wint_t
 367 _IO_wfile_sync (fp)
 368      _IO_FILE *fp;
 369 {
 370   _IO_ssize_t delta;
 371   wint_t retval = 0;
 372
 373   /*    char* ptr = cur_ptr(); */
 374   if (fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_write_base)
 375     if (_IO_do_flush (fp))
 376       return WEOF;
 377   delta = fp->_wide_data->_IO_read_ptr - fp->_wide_data->_IO_read_end;
 378   if (delta != 0)
 379     {
 380       /* We have to find out how many bytes we have to go back in the
 381          external buffer.  */
 382       struct _IO_codecvt *cv = fp->_codecvt;
 383       _IO_off64_t new_pos;
 384
 385       int clen = (*cv->__codecvt_do_encoding) (cv);
 386
 387       if (clen > 0)
 388         /* It is easy, a fixed number of input bytes are used for each
 389            wide character.  */
 390         delta *= clen;
 391       else
 392         {
 393           /* We have to find out the hard way how much to back off.
 394              To do this we determine how much input we needed to
 395              generate the wide characters up to the current reading
 396              position.  */
 397           int nread;
 398
 399           fp->_wide_data->_IO_state = fp->_wide_data->_IO_last_state;
 400           nread = (*cv->__codecvt_do_length) (cv, &fp->_wide_data->_IO_state,
 401                                               fp->_IO_read_base,
 402                                               fp->_IO_read_end, delta);
 403           fp->_IO_read_ptr = fp->_IO_read_base + nread;
 404           delta = -(fp->_IO_read_end - fp->_IO_read_base - nread);
 405         }
 406
 407       new_pos = _IO_SYSSEEK (fp, delta, 1);
 408       if (new_pos != (_IO_off64_t) EOF)
 409         {
 410           fp->_wide_data->_IO_read_end = fp->_wide_data->_IO_read_ptr;
 411           fp->_IO_read_end = fp->_IO_read_ptr;
 412         }
 413 #ifdef ESPIPE
 414       else if (errno == ESPIPE)
 415         ; /* Ignore error from unseekable devices. */
 416 #endif
 417       else
 418         retval = WEOF;
 419     }
 420   if (retval != WEOF)
 421     fp->_offset = _IO_pos_BAD;
 422   /* FIXME: Cleanup - can this be shared? */
 423   /*    setg(base(), ptr, ptr); */
 424   return retval;
 425 }
 426
 427 _IO_off64_t
 428 _IO_wfile_seekoff (fp, offset, dir, mode)
 429      _IO_FILE *fp;
 430      _IO_off64_t offset;
 431      int dir;
 432      int mode;
 433 {
 434   _IO_off64_t result;
 435   _IO_off64_t delta, new_offset;
 436   long int count;
 437   /* POSIX.1 8.2.3.7 says that after a call the fflush() the file
 438      offset of the underlying file must be exact.  */
 439   int must_be_exact = ((fp->_wide_data->_IO_read_base
 440                         == fp->_wide_data->_IO_read_end)
 441                        && (fp->_wide_data->_IO_write_base
 442                            == fp->_wide_data->_IO_write_ptr));
 443
 444   if (mode == 0)
 445     dir = _IO_seek_cur, offset = 0; /* Don't move any pointers. */
 446
 447   /* Flush unwritten characters.
 448      (This may do an unneeded write if we seek within the buffer.
 449      But to be able to switch to reading, we would need to set
 450      egptr to ptr.  That can't be done in the current design,
 451      which assumes file_ptr() is eGptr.  Anyway, since we probably
 452      end up flushing when we close(), it doesn't make much difference.)
 453      FIXME: simulate mem-papped files. */
 454
 455   if (fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_write_base
 456       || _IO_in_put_mode (fp))
 457     if (_IO_switch_to_wget_mode (fp))
 458       return WEOF;
 459
 460   if (fp->_wide_data->_IO_buf_base == NULL)
 461     {
 462       /* It could be that we already have a pushback buffer.  */
 463       if (fp->_wide_data->_IO_read_base != NULL)
 464         {
 465           free (fp->_wide_data->_IO_read_base);
 466           fp->_flags &= ~_IO_IN_BACKUP;
 467         }
 468       _IO_doallocbuf (fp);
 469       _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
 470       _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
 471       _IO_wsetp (fp, fp->_wide_data->_IO_buf_base,
 472                  fp->_wide_data->_IO_buf_base);
 473       _IO_wsetg (fp, fp->_wide_data->_IO_buf_base,
 474                  fp->_wide_data->_IO_buf_base, fp->_wide_data->_IO_buf_base);
 475     }
 476
 477   switch (dir)
 478     {
 479       struct _IO_codecvt *cv;
 480       int clen;
 481
 482     case _IO_seek_cur:
 483       /* Adjust for read-ahead (bytes is buffer).  To do this we must
 484          find out which position in the external buffer corresponds to
 485          the current position in the internal buffer.  */
 486       cv = fp->_codecvt;
 487       clen = (*cv->__codecvt_do_encoding) (cv);
 488
 489       if (clen > 0)
 490         offset -= (fp->_wide_data->_IO_read_end
 491                    - fp->_wide_data->_IO_read_ptr) * clen;
 492       else
 493         {
 494           int nread;
 495
 496           delta = fp->_wide_data->_IO_read_ptr - fp->_wide_data->_IO_read_end;
 497           fp->_wide_data->_IO_state = fp->_wide_data->_IO_last_state;
 498           nread = (*cv->__codecvt_do_length) (cv, &fp->_wide_data->_IO_state,
 499                                               fp->_IO_read_base,
 500                                               fp->_IO_read_end, delta);
 501           fp->_IO_read_ptr = fp->_IO_read_base + nread;
 502           offset -= fp->_IO_read_end - fp->_IO_read_base - nread;
 503         }
 504
 505       if (fp->_offset == _IO_pos_BAD)
 506         goto dumb;
 507       /* Make offset absolute, assuming current pointer is file_ptr(). */
 508       offset += fp->_offset;
 509
 510       dir = _IO_seek_set;
 511       break;
 512     case _IO_seek_set:
 513       break;
 514     case _IO_seek_end:
 515       {
 516         struct _G_stat64 st;
 517         if (_IO_SYSSTAT (fp, &st) == 0 && S_ISREG (st.st_mode))
 518           {
 519             offset += st.st_size;
 520             dir = _IO_seek_set;
 521           }
 522         else
 523           goto dumb;
 524       }
 525     }
 526   /* At this point, dir==_IO_seek_set. */
 527
 528   /* If we are only interested in the current position we've found it now.  */
 529   if (mode == 0)
 530     return offset;
 531
 532   /* If destination is within current buffer, optimize: */
 533   if (fp->_offset != _IO_pos_BAD && fp->_IO_read_base != NULL
 534       && !_IO_in_backup (fp))
 535     {
 536       /* Offset relative to start of main get area. */
 537       _IO_off64_t rel_offset = (offset - fp->_offset
 538                                 + (fp->_IO_read_end - fp->_IO_read_base));
 539       if (rel_offset >= 0)
 540         {
 541 #if 0
 542           if (_IO_in_backup (fp))
 543             _IO_switch_to_main_get_area (fp);
 544 #endif
 545           if (rel_offset <= fp->_IO_read_end - fp->_IO_read_base)
 546             {
 547               fp->_IO_read_ptr = fp->_IO_read_base + rel_offset;
 548               _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
 549
 550               /* Now set the pointer for the internal buffer.  This
 551                  might be an iterative process.  Though the read
 552                  pointer is somewhere in the current external buffer
 553                  this does not mean we can convert this whole buffer
 554                  at once fitting in the internal buffer.  */
 555               do
 556                 {
 557
 558                 }
 559               while (0);
 560
 561               _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
 562               goto resync;
 563             }
 564 #ifdef TODO
 565             /* If we have streammarkers, seek forward by reading ahead. */
 566             if (_IO_have_markers (fp))
 567               {
 568                 int to_skip = rel_offset
 569                   - (fp->_IO_read_ptr - fp->_IO_read_base);
 570                 if (ignore (to_skip) != to_skip)
 571                   goto dumb;
 572                 _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
 573                 goto resync;
 574               }
 575 #endif
 576         }
 577 #ifdef TODO
 578       if (rel_offset < 0 && rel_offset >= Bbase () - Bptr ())
 579         {
 580           if (!_IO_in_backup (fp))
 581             _IO_switch_to_backup_area (fp);
 582           gbump (fp->_IO_read_end + rel_offset - fp->_IO_read_ptr);
 583           _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
 584           goto resync;
 585         }
 586 #endif
 587     }
 588
 589 #ifdef TODO
 590   _IO_unsave_markers (fp);
 591 #endif
 592
 593   if (fp->_flags & _IO_NO_READS)
 594     goto dumb;
 595
 596   /* Try to seek to a block boundary, to improve kernel page management. */
 597   new_offset = offset & ~(fp->_IO_buf_end - fp->_IO_buf_base - 1);
 598   delta = offset - new_offset;
 599   if (delta > fp->_IO_buf_end - fp->_IO_buf_base)
 600     {
 601       new_offset = offset;
 602       delta = 0;
 603     }
 604   result = _IO_SYSSEEK (fp, new_offset, 0);
 605   if (result < 0)
 606     return EOF;
 607   if (delta == 0)
 608     count = 0;
 609   else
 610     {
 611       count = _IO_SYSREAD (fp, fp->_IO_buf_base,
 612                            (must_be_exact
 613                             ? delta : fp->_IO_buf_end - fp->_IO_buf_base));
 614       if (count < delta)
 615         {
 616           /* We weren't allowed to read, but try to seek the remainder. */
 617           offset = count == EOF ? delta : delta-count;
 618           dir = _IO_seek_cur;
 619           goto dumb;
 620         }
 621     }
 622   _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base + delta,
 623             fp->_IO_buf_base + count);
 624   _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
 625   fp->_offset = result + count;
 626   _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
 627   return offset;
 628  dumb:
 629
 630   _IO_unsave_markers (fp);
 631   result = _IO_SYSSEEK (fp, offset, dir);
 632   if (result != EOF)
 633     {
 634       _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
 635       fp->_offset = result;
 636       _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
 637       _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
 638     }
 639   return result;
 640
 641 resync:
 642   /* We need to do it since it is possible that the file offset in
 643      the kernel may be changed behind our back. It may happen when
 644      we fopen a file and then do a fork. One process may access the
 645      the file and the kernel file offset will be changed. */
 646   if (fp->_offset >= 0)
 647     _IO_SYSSEEK (fp, fp->_offset, 0);
 648
 649   return offset;
 650 }
 651
 652
 653 _IO_size_t
 654 _IO_wfile_xsputn (f, data, n)
 655      _IO_FILE *f;
 656      const void *data;
 657      _IO_size_t n;
 658 {
 659   register const wchar_t *s = (const wchar_t *) data;
 660   _IO_size_t to_do = n;
 661   int must_flush = 0;
 662   _IO_size_t count;
 663
 664   if (n <= 0)
 665     return 0;
 666   /* This is an optimized implementation.
 667      If the amount to be written straddles a block boundary
 668      (or the filebuf is unbuffered), use sys_write directly. */
 669
 670   /* First figure out how much space is available in the buffer. */
 671   count = f->_wide_data->_IO_write_end - f->_wide_data->_IO_write_ptr;
 672   if ((f->_flags & _IO_LINE_BUF) && (f->_flags & _IO_CURRENTLY_PUTTING))
 673     {
 674       count = f->_wide_data->_IO_buf_end - f->_wide_data->_IO_write_ptr;
 675       if (count >= n)
 676         {
 677           register const wchar_t *p;
 678           for (p = s + n; p > s; )
 679             {
 680               if (*--p == L'\n')
 681                 {
 682                   count = p - s + 1;
 683                   must_flush = 1;
 684                   break;
 685                 }
 686             }
 687         }
 688     }
 689   /* Then fill the buffer. */
 690   if (count > 0)
 691     {
 692       if (count > to_do)
 693         count = to_do;
 694       if (count > 20)
 695         {
 696 #ifdef _LIBC
 697           f->_wide_data->_IO_write_ptr =
 698             __wmempcpy (f->_wide_data->_IO_write_ptr, s, count);
 699 #else
 700           wmemcpy (f->_wide_data->_IO_write_ptr, s, count);
 701           f->_wide_data->_IO_write_ptr += count;
 702 #endif
 703           s += count;
 704         }
 705       else
 706         {
 707           register wchar_t *p = f->_wide_data->_IO_write_ptr;
 708           register int i = (int) count;
 709           while (--i >= 0)
 710             *p++ = *s++;
 711           f->_wide_data->_IO_write_ptr = p;
 712         }
 713       to_do -= count;
 714     }
 715   if (to_do > 0)
 716     to_do -= _IO_wdefault_xsputn (f, s, to_do);
 717   if (must_flush
 718       && f->_wide_data->_IO_write_ptr != f->_wide_data->_IO_write_base)
 719     _IO_wdo_write (f, f->_wide_data->_IO_write_base,
 720                    f->_wide_data->_IO_write_ptr
 721                    - f->_wide_data->_IO_write_base);
 722
 723   return n - to_do;
 724 }
 725
 726
 727 struct _IO_jump_t _IO_wfile_jumps =
 728 {
 729   JUMP_INIT_DUMMY,
 730   JUMP_INIT(finish, _IO_new_file_finish),
 731   JUMP_INIT(overflow, (_IO_overflow_t) _IO_wfile_overflow),
 732   JUMP_INIT(underflow, (_IO_underflow_t) _IO_wfile_underflow),
 733   JUMP_INIT(uflow, (_IO_underflow_t) _IO_wdefault_uflow),
 734   JUMP_INIT(pbackfail, (_IO_pbackfail_t) _IO_wdefault_pbackfail),
 735   JUMP_INIT(xsputn, _IO_wfile_xsputn),
 736   JUMP_INIT(xsgetn, _IO_file_xsgetn),
 737   JUMP_INIT(seekoff, _IO_wfile_seekoff),
 738   JUMP_INIT(seekpos, _IO_default_seekpos),
 739   JUMP_INIT(setbuf, _IO_new_file_setbuf),
 740   JUMP_INIT(sync, (_IO_sync_t) _IO_wfile_sync),
 741   JUMP_INIT(doallocate, _IO_wfile_doallocate),
 742   JUMP_INIT(read, _IO_file_read),
 743   JUMP_INIT(write, _IO_new_file_write),
 744   JUMP_INIT(seek, _IO_file_seek),
 745   JUMP_INIT(close, _IO_file_close),
 746   JUMP_INIT(stat, _IO_file_stat),
 747   JUMP_INIT(showmanyc, _IO_default_showmanyc),
 748   JUMP_INIT(imbue, _IO_default_imbue)
 749 };