libio/wfileops.c

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