libio/oldfileops.c

   1 /* Copyright (C) 1993, 1995, 1997 Free Software Foundation, Inc.
   2    This file is part of the GNU IO Library.
   3    Written by Per Bothner <bothner@cygnus.com>.
   4
   5    This library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU General Public License as
   7    published by the Free Software Foundation; either version 2, or (at
   8    your option) any later version.
   9
  10    This library is distributed in the hope that it will be useful, but
  11    WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this library; see the file COPYING.  If not, write to
  17    the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
  18    MA 02111-1307, USA.
  19
  20    As a special exception, if you link this library with files
  21    compiled with a GNU compiler to produce an executable, this does
  22    not cause the resulting executable to be covered by the GNU General
  23    Public License.  This exception does not however invalidate any
  24    other reasons why the executable file might be covered by the GNU
  25    General Public License.  */
  26
  27 /* This is a compatibility file.  If we don't build the libc with
  28    versioning don't compile this file.  */
  29 #if DO_VERSIONING
  30
  31
  32 #ifndef _POSIX_SOURCE
  33 # define _POSIX_SOURCE
  34 #endif
  35 #define _IO_USE_OLD_IO_FILE
  36 #include "libioP.h"
  37 #include <fcntl.h>
  38 #include <sys/types.h>
  39 #include <sys/stat.h>
  40 #include <string.h>
  41 #include <errno.h>
  42 #ifndef errno
  43 extern int errno;
  44 #endif
  45 #ifndef __set_errno
  46 # define __set_errno(Val) errno = (Val)
  47 #endif
  48
  49
  50 #ifdef _LIBC
  51 # define open(Name, Flags, Prot) __open (Name, Flags, Prot)
  52 # define close(FD) __close (FD)
  53 # define lseek(FD, Offset, Whence) __lseek (FD, Offset, Whence)
  54 # define read(FD, Buf, NBytes) __read (FD, Buf, NBytes)
  55 # define write(FD, Buf, NBytes) __write (FD, Buf, NBytes)
  56 #endif
  57
  58 /* An fstream can be in at most one of put mode, get mode, or putback mode.
  59    Putback mode is a variant of get mode.
  60
  61    In a filebuf, there is only one current position, instead of two
  62    separate get and put pointers.  In get mode, the current position
  63    is that of gptr(); in put mode that of pptr().
  64
  65    The position in the buffer that corresponds to the position
  66    in external file system is normally _IO_read_end, except in putback
  67    mode, when it is _IO_save_end.
  68    If the field _fb._offset is >= 0, it gives the offset in
  69    the file as a whole corresponding to eGptr(). (?)
  70
  71    PUT MODE:
  72    If a filebuf is in put mode, then all of _IO_read_ptr, _IO_read_end,
  73    and _IO_read_base are equal to each other.  These are usually equal
  74    to _IO_buf_base, though not necessarily if we have switched from
  75    get mode to put mode.  (The reason is to maintain the invariant
  76    that _IO_read_end corresponds to the external file position.)
  77    _IO_write_base is non-NULL and usually equal to _IO_base_base.
  78    We also have _IO_write_end == _IO_buf_end, but only in fully buffered mode.
  79    The un-flushed character are those between _IO_write_base and _IO_write_ptr.
  80
  81    GET MODE:
  82    If a filebuf is in get or putback mode, eback() != egptr().
  83    In get mode, the unread characters are between gptr() and egptr().
  84    The OS file position corresponds to that of egptr().
  85
  86    PUTBACK MODE:
  87    Putback mode is used to remember "excess" characters that have
  88    been sputbackc'd in a separate putback buffer.
  89    In putback mode, the get buffer points to the special putback buffer.
  90    The unread characters are the characters between gptr() and egptr()
  91    in the putback buffer, as well as the area between save_gptr()
  92    and save_egptr(), which point into the original reserve buffer.
  93    (The pointers save_gptr() and save_egptr() are the values
  94    of gptr() and egptr() at the time putback mode was entered.)
  95    The OS position corresponds to that of save_egptr().
  96
  97    LINE BUFFERED OUTPUT:
  98    During line buffered output, _IO_write_base==base() && epptr()==base().
  99    However, ptr() may be anywhere between base() and ebuf().
 100    This forces a call to filebuf::overflow(int C) on every put.
 101    If there is more space in the buffer, and C is not a '\n',
 102    then C is inserted, and pptr() incremented.
 103
 104    UNBUFFERED STREAMS:
 105    If a filebuf is unbuffered(), the _shortbuf[1] is used as the buffer.
 106 */
 107
 108 #define CLOSED_FILEBUF_FLAGS \
 109   (_IO_IS_FILEBUF+_IO_NO_READS+_IO_NO_WRITES+_IO_TIED_PUT_GET)
 110
 111
 112 void
 113 _IO_old_file_init (fp)
 114      _IO_FILE *fp;
 115 {
 116   /* POSIX.1 allows another file handle to be used to change the position
 117      of our file descriptor.  Hence we actually don't know the actual
 118      position before we do the first fseek (and until a following fflush). */
 119   fp->_old_offset = _IO_pos_BAD;
 120   fp->_IO_file_flags |= CLOSED_FILEBUF_FLAGS;
 121
 122   _IO_link_in(fp);
 123   fp->_vtable_offset = ((int) sizeof (struct _IO_FILE)
 124                         - (int) sizeof (struct _IO_FILE_complete));
 125   fp->_fileno = -1;
 126 }
 127
 128 int
 129 _IO_old_file_close_it (fp)
 130      _IO_FILE *fp;
 131 {
 132   int write_status, close_status;
 133   if (!_IO_file_is_open (fp))
 134     return EOF;
 135
 136   write_status = _IO_old_do_flush (fp);
 137
 138   _IO_unsave_markers(fp);
 139
 140   close_status = _IO_SYSCLOSE (fp);
 141
 142   /* Free buffer. */
 143   _IO_setb (fp, NULL, NULL, 0);
 144   _IO_setg (fp, NULL, NULL, NULL);
 145   _IO_setp (fp, NULL, NULL);
 146
 147   _IO_un_link (fp);
 148   fp->_flags = _IO_MAGIC|CLOSED_FILEBUF_FLAGS;
 149   fp->_fileno = EOF;
 150   fp->_old_offset = _IO_pos_BAD;
 151
 152   return close_status ? close_status : write_status;
 153 }
 154
 155 void
 156 _IO_old_file_finish (fp, dummy)
 157      _IO_FILE *fp;
 158      int dummy;
 159 {
 160   if (_IO_file_is_open (fp))
 161     {
 162       _IO_old_do_flush (fp);
 163       if (!(fp->_flags & _IO_DELETE_DONT_CLOSE))
 164         _IO_SYSCLOSE (fp);
 165     }
 166   _IO_default_finish (fp, 0);
 167 }
 168
 169 _IO_FILE *
 170 _IO_old_file_fopen (fp, filename, mode)
 171      _IO_FILE *fp;
 172      const char *filename;
 173      const char *mode;
 174 {
 175   int oflags = 0, omode;
 176   int read_write, fdesc;
 177   int oprot = 0666;
 178   if (_IO_file_is_open (fp))
 179     return 0;
 180   switch (*mode++)
 181     {
 182     case 'r':
 183       omode = O_RDONLY;
 184       read_write = _IO_NO_WRITES;
 185       break;
 186     case 'w':
 187       omode = O_WRONLY;
 188       oflags = O_CREAT|O_TRUNC;
 189       read_write = _IO_NO_READS;
 190       break;
 191     case 'a':
 192       omode = O_WRONLY;
 193       oflags = O_CREAT|O_APPEND;
 194       read_write = _IO_NO_READS|_IO_IS_APPENDING;
 195       break;
 196     default:
 197       __set_errno (EINVAL);
 198       return NULL;
 199     }
 200   if (mode[0] == '+' || (mode[0] == 'b' && mode[1] == '+'))
 201     {
 202       omode = O_RDWR;
 203       read_write &= _IO_IS_APPENDING;
 204     }
 205   fdesc = open (filename, omode|oflags, oprot);
 206   if (fdesc < 0)
 207     return NULL;
 208   fp->_fileno = fdesc;
 209   _IO_mask_flags (fp, read_write,_IO_NO_READS+_IO_NO_WRITES+_IO_IS_APPENDING);
 210   if (read_write & _IO_IS_APPENDING)
 211     if (_IO_SEEKOFF (fp, (_IO_off_t)0, _IO_seek_end, _IOS_INPUT|_IOS_OUTPUT)
 212         == _IO_pos_BAD && errno != ESPIPE)
 213       return NULL;
 214   _IO_link_in (fp);
 215   return fp;
 216 }
 217
 218 _IO_FILE *
 219 _IO_old_file_attach (fp, fd)
 220      _IO_FILE *fp;
 221      int fd;
 222 {
 223   if (_IO_file_is_open (fp))
 224     return NULL;
 225   fp->_fileno = fd;
 226   fp->_flags &= ~(_IO_NO_READS+_IO_NO_WRITES);
 227   fp->_flags |= _IO_DELETE_DONT_CLOSE;
 228   /* Get the current position of the file. */
 229   /* We have to do that since that may be junk. */
 230   fp->_old_offset = _IO_pos_BAD;
 231   if (_IO_SEEKOFF (fp, (_IO_off_t)0, _IO_seek_cur, _IOS_INPUT|_IOS_OUTPUT)
 232       == _IO_pos_BAD && errno != ESPIPE)
 233     return NULL;
 234   return fp;
 235 }
 236
 237 _IO_FILE *
 238 _IO_old_file_setbuf (fp, p, len)
 239      _IO_FILE *fp;
 240      char *p;
 241      _IO_ssize_t len;
 242 {
 243     if (_IO_default_setbuf (fp, p, len) == NULL)
 244       return NULL;
 245
 246     fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end
 247       = fp->_IO_buf_base;
 248     _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
 249
 250     return fp;
 251 }
 252
 253 /* Write TO_DO bytes from DATA to FP.
 254    Then mark FP as having empty buffers. */
 255
 256 int
 257 _IO_old_do_write (fp, data, to_do)
 258      _IO_FILE *fp;
 259      const char *data;
 260      _IO_size_t to_do;
 261 {
 262   _IO_size_t count;
 263   if (to_do == 0)
 264     return 0;
 265   if (fp->_flags & _IO_IS_APPENDING)
 266     /* On a system without a proper O_APPEND implementation,
 267        you would need to sys_seek(0, SEEK_END) here, but is
 268        is not needed nor desirable for Unix- or Posix-like systems.
 269        Instead, just indicate that offset (before and after) is
 270        unpredictable. */
 271     fp->_old_offset = _IO_pos_BAD;
 272   else if (fp->_IO_read_end != fp->_IO_write_base)
 273     {
 274       _IO_pos_t new_pos
 275         = _IO_SYSSEEK (fp, fp->_IO_write_base - fp->_IO_read_end, 1);
 276       if (new_pos == _IO_pos_BAD)
 277         return EOF;
 278       fp->_old_offset = new_pos;
 279     }
 280   count = _IO_SYSWRITE (fp, data, to_do);
 281   if (fp->_cur_column)
 282     fp->_cur_column = _IO_adjust_column (fp->_cur_column - 1, data, to_do) + 1;
 283   _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
 284   fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_buf_base;
 285   fp->_IO_write_end = ((fp->_flags & (_IO_LINE_BUF+_IO_UNBUFFERED))
 286                        ? fp->_IO_buf_base : fp->_IO_buf_end);
 287   return count != to_do ? EOF : 0;
 288 }
 289
 290 int
 291 _IO_old_file_underflow (fp)
 292      _IO_FILE *fp;
 293 {
 294   _IO_ssize_t count;
 295 #if 0
 296   /* SysV does not make this test; take it out for compatibility */
 297   if (fp->_flags & _IO_EOF_SEEN)
 298     return (EOF);
 299 #endif
 300
 301   if (fp->_flags & _IO_NO_READS)
 302     {
 303       __set_errno (EBADF);
 304       return EOF;
 305     }
 306   if (fp->_IO_read_ptr < fp->_IO_read_end)
 307     return *(unsigned char *) fp->_IO_read_ptr;
 308
 309   if (fp->_IO_buf_base == NULL)
 310     _IO_doallocbuf (fp);
 311
 312   /* Flush all line buffered files before reading. */
 313   /* FIXME This can/should be moved to genops ?? */
 314   if (fp->_flags & (_IO_LINE_BUF|_IO_UNBUFFERED))
 315     _IO_flush_all_linebuffered ();
 316
 317   _IO_switch_to_get_mode (fp);
 318
 319   /* This is very tricky. We have to adjust those
 320      pointers before we call _IO_SYSREAD () since
 321      we may longjump () out while waiting for
 322      input. Those pointers may be screwed up. H.J. */
 323   fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_buf_base;
 324   fp->_IO_read_end = fp->_IO_buf_base;
 325   fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end
 326     = fp->_IO_buf_base;
 327
 328   count = _IO_SYSREAD (fp, fp->_IO_buf_base,
 329                        fp->_IO_buf_end - fp->_IO_buf_base);
 330   if (count <= 0)
 331     {
 332       if (count == 0)
 333         fp->_flags |= _IO_EOF_SEEN;
 334       else
 335         fp->_flags |= _IO_ERR_SEEN, count = 0;
 336   }
 337   fp->_IO_read_end += count;
 338   if (count == 0)
 339     return EOF;
 340   if (fp->_old_offset != _IO_pos_BAD)
 341     _IO_pos_adjust (fp->_old_offset, count);
 342   return *(unsigned char *) fp->_IO_read_ptr;
 343 }
 344
 345 int
 346 _IO_old_file_overflow (f, ch)
 347       _IO_FILE *f;
 348       int ch;
 349 {
 350   if (f->_flags & _IO_NO_WRITES) /* SET ERROR */
 351     {
 352       f->_flags |= _IO_ERR_SEEN;
 353       __set_errno (EBADF);
 354       return EOF;
 355     }
 356   /* If currently reading or no buffer allocated. */
 357   if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0)
 358     {
 359       /* Allocate a buffer if needed. */
 360       if (f->_IO_write_base == 0)
 361         {
 362           _IO_doallocbuf (f);
 363           _IO_setg (f, f->_IO_buf_base, f->_IO_buf_base, f->_IO_buf_base);
 364         }
 365       /* Otherwise must be currently reading.
 366          If _IO_read_ptr (and hence also _IO_read_end) is at the buffer end,
 367          logically slide the buffer forwards one block (by setting the
 368          read pointers to all point at the beginning of the block).  This
 369          makes room for subsequent output.
 370          Otherwise, set the read pointers to _IO_read_end (leaving that
 371          alone, so it can continue to correspond to the external position). */
 372       if (f->_IO_read_ptr == f->_IO_buf_end)
 373         f->_IO_read_end = f->_IO_read_ptr = f->_IO_buf_base;
 374       f->_IO_write_ptr = f->_IO_read_ptr;
 375       f->_IO_write_base = f->_IO_write_ptr;
 376       f->_IO_write_end = f->_IO_buf_end;
 377       f->_IO_read_base = f->_IO_read_ptr = f->_IO_read_end;
 378
 379       if (f->_flags & (_IO_LINE_BUF+_IO_UNBUFFERED))
 380         f->_IO_write_end = f->_IO_write_ptr;
 381       f->_flags |= _IO_CURRENTLY_PUTTING;
 382     }
 383   if (ch == EOF)
 384     return _IO_old_do_flush (f);
 385   if (f->_IO_write_ptr == f->_IO_buf_end ) /* Buffer is really full */
 386     if (_IO_old_do_flush (f) == EOF)
 387       return EOF;
 388   *f->_IO_write_ptr++ = ch;
 389   if ((f->_flags & _IO_UNBUFFERED)
 390       || ((f->_flags & _IO_LINE_BUF) && ch == '\n'))
 391     if (_IO_old_do_flush (f) == EOF)
 392       return EOF;
 393   return (unsigned char) ch;
 394 }
 395
 396 int
 397 _IO_old_file_sync (fp)
 398      _IO_FILE *fp;
 399 {
 400   _IO_size_t delta;
 401   int retval = 0;
 402
 403   _IO_cleanup_region_start ((void (*) __P ((void *))) _IO_funlockfile, fp);
 404   _IO_flockfile (fp);
 405   /*    char* ptr = cur_ptr(); */
 406   if (fp->_IO_write_ptr > fp->_IO_write_base)
 407     if (_IO_old_do_flush(fp)) return EOF;
 408   delta = fp->_IO_read_ptr - fp->_IO_read_end;
 409   if (delta != 0)
 410     {
 411 #ifdef TODO
 412       if (_IO_in_backup (fp))
 413         delta -= eGptr () - Gbase ();
 414 #endif
 415       _IO_off_t new_pos = _IO_SYSSEEK (fp, delta, 1);
 416       if (new_pos != (_IO_off_t) EOF)
 417         fp->_IO_read_end = fp->_IO_read_ptr;
 418 #ifdef ESPIPE
 419       else if (errno == ESPIPE)
 420         ; /* Ignore error from unseekable devices. */
 421 #endif
 422       else
 423         retval = EOF;
 424     }
 425   if (retval != EOF)
 426     fp->_old_offset = _IO_pos_BAD;
 427   /* FIXME: Cleanup - can this be shared? */
 428   /*    setg(base(), ptr, ptr); */
 429   _IO_cleanup_region_end (1);
 430   return retval;
 431 }
 432
 433 _IO_fpos64_t
 434 _IO_old_file_seekoff (fp, offset, dir, mode)
 435      _IO_FILE *fp;
 436      _IO_off64_t offset;
 437      int dir;
 438      int mode;
 439 {
 440   _IO_pos_t result;
 441   _IO_off64_t delta, new_offset;
 442   long count;
 443   /* POSIX.1 8.2.3.7 says that after a call the fflush() the file
 444      offset of the underlying file must be exact.  */
 445   int must_be_exact = (fp->_IO_read_base == fp->_IO_read_end
 446                        && fp->_IO_write_base == fp->_IO_write_ptr);
 447
 448   if (mode == 0)
 449     dir = _IO_seek_cur, offset = 0; /* Don't move any pointers. */
 450
 451   /* Flush unwritten characters.
 452      (This may do an unneeded write if we seek within the buffer.
 453      But to be able to switch to reading, we would need to set
 454      egptr to ptr.  That can't be done in the current design,
 455      which assumes file_ptr() is eGptr.  Anyway, since we probably
 456      end up flushing when we close(), it doesn't make much difference.)
 457      FIXME: simulate mem-papped files. */
 458
 459   if (fp->_IO_write_ptr > fp->_IO_write_base || _IO_in_put_mode (fp))
 460     if (_IO_switch_to_get_mode (fp))
 461       return EOF;
 462
 463   if (fp->_IO_buf_base == NULL)
 464     {
 465       _IO_doallocbuf (fp);
 466       _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
 467       _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
 468     }
 469
 470   switch (dir)
 471     {
 472     case _IO_seek_cur:
 473       /* Adjust for read-ahead (bytes is buffer). */
 474       offset -= fp->_IO_read_end - fp->_IO_read_ptr;
 475       if (fp->_old_offset == _IO_pos_BAD)
 476         goto dumb;
 477       /* Make offset absolute, assuming current pointer is file_ptr(). */
 478       offset += _IO_pos_as_off (fp->_old_offset);
 479
 480       dir = _IO_seek_set;
 481       break;
 482     case _IO_seek_set:
 483       break;
 484     case _IO_seek_end:
 485       {
 486         struct stat st;
 487         if (_IO_SYSSTAT (fp, &st) == 0 && S_ISREG (st.st_mode))
 488           {
 489             offset += st.st_size;
 490             dir = _IO_seek_set;
 491           }
 492         else
 493           goto dumb;
 494       }
 495     }
 496   /* At this point, dir==_IO_seek_set. */
 497
 498   /* If destination is within current buffer, optimize: */
 499   if (fp->_old_offset != _IO_pos_BAD && fp->_IO_read_base != NULL
 500       && !_IO_in_backup (fp))
 501     {
 502       /* Offset relative to start of main get area. */
 503       _IO_pos_t rel_offset = (offset - fp->_old_offset
 504                               + (fp->_IO_read_end - fp->_IO_read_base));
 505       if (rel_offset >= 0)
 506         {
 507 #if 0
 508           if (_IO_in_backup (fp))
 509             _IO_switch_to_main_get_area (fp);
 510 #endif
 511           if (rel_offset <= fp->_IO_read_end - fp->_IO_read_base)
 512             {
 513               _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base + rel_offset,
 514                         fp->_IO_read_end);
 515               _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
 516               return offset;
 517             }
 518 #ifdef TODO
 519             /* If we have streammarkers, seek forward by reading ahead. */
 520             if (_IO_have_markers (fp))
 521               {
 522                 int to_skip = rel_offset
 523                   - (fp->_IO_read_ptr - fp->_IO_read_base);
 524                 if (ignore (to_skip) != to_skip)
 525                   goto dumb;
 526                 return offset;
 527               }
 528 #endif
 529         }
 530 #ifdef TODO
 531       if (rel_offset < 0 && rel_offset >= Bbase () - Bptr ())
 532         {
 533           if (!_IO_in_backup (fp))
 534             _IO_switch_to_backup_area (fp);
 535           gbump (fp->_IO_read_end + rel_offset - fp->_IO_read_ptr);
 536           return offset;
 537         }
 538 #endif
 539     }
 540
 541 #ifdef TODO
 542   _IO_unsave_markers (fp);
 543 #endif
 544
 545   if (fp->_flags & _IO_NO_READS)
 546     goto dumb;
 547
 548   /* Try to seek to a block boundary, to improve kernel page management. */
 549   new_offset = offset & ~(fp->_IO_buf_end - fp->_IO_buf_base - 1);
 550   delta = offset - new_offset;
 551   if (delta > fp->_IO_buf_end - fp->_IO_buf_base)
 552     {
 553       new_offset = offset;
 554       delta = 0;
 555     }
 556   result = _IO_SYSSEEK (fp, new_offset, 0);
 557   if (result < 0)
 558     return EOF;
 559   if (delta == 0)
 560     count = 0;
 561   else
 562     {
 563       count = _IO_SYSREAD (fp, fp->_IO_buf_base,
 564                            (must_be_exact
 565                             ? delta : fp->_IO_buf_end - fp->_IO_buf_base));
 566       if (count < delta)
 567         {
 568           /* We weren't allowed to read, but try to seek the remainder. */
 569           offset = count == EOF ? delta : delta-count;
 570           dir = _IO_seek_cur;
 571           goto dumb;
 572         }
 573     }
 574   _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base + delta,
 575             fp->_IO_buf_base + count);
 576   _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
 577   fp->_old_offset = result + count;
 578   _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
 579   return offset;
 580  dumb:
 581
 582   _IO_unsave_markers (fp);
 583   result = _IO_SYSSEEK (fp, offset, dir);
 584   if (result != EOF)
 585     _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
 586   fp->_old_offset = result;
 587   _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
 588   _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
 589   return result;
 590 }
 591
 592 _IO_ssize_t
 593 _IO_old_file_write (f, data, n)
 594      _IO_FILE *f;
 595      const void *data;
 596      _IO_ssize_t n;
 597 {
 598   _IO_ssize_t to_do = n;
 599   while (to_do > 0)
 600     {
 601       _IO_ssize_t count = write (f->_fileno, data, to_do);
 602       if (count == EOF)
 603         {
 604           f->_flags |= _IO_ERR_SEEN;
 605           break;
 606         }
 607       to_do -= count;
 608       data = (void *) ((char *) data + count);
 609     }
 610   n -= to_do;
 611   if (f->_old_offset >= 0)
 612     f->_old_offset += n;
 613   return n;
 614 }
 615
 616 _IO_size_t
 617 _IO_old_file_xsputn (f, data, n)
 618      _IO_FILE *f;
 619      const void *data;
 620      _IO_size_t n;
 621 {
 622   register const char *s = (char *) data;
 623   _IO_size_t to_do = n;
 624   int must_flush = 0;
 625   _IO_size_t count;
 626
 627   if (n <= 0)
 628     return 0;
 629   /* This is an optimized implementation.
 630      If the amount to be written straddles a block boundary
 631      (or the filebuf is unbuffered), use sys_write directly. */
 632
 633   /* First figure out how much space is available in the buffer. */
 634   count = f->_IO_write_end - f->_IO_write_ptr; /* Space available. */
 635   if ((f->_flags & _IO_LINE_BUF) && (f->_flags & _IO_CURRENTLY_PUTTING))
 636     {
 637       count = f->_IO_buf_end - f->_IO_write_ptr;
 638       if (count >= n)
 639         {
 640           register const char *p;
 641           for (p = s + n; p > s; )
 642             {
 643               if (*--p == '\n')
 644                 {
 645                   count = p - s + 1;
 646                   must_flush = 1;
 647                   break;
 648                 }
 649             }
 650         }
 651     }
 652   /* Then fill the buffer. */
 653   if (count > 0)
 654     {
 655       if (count > to_do)
 656         count = to_do;
 657       if (count > 20)
 658         {
 659           memcpy (f->_IO_write_ptr, s, count);
 660           s += count;
 661         }
 662       else
 663         {
 664           register char *p = f->_IO_write_ptr;
 665           register int i = (int) count;
 666           while (--i >= 0)
 667             *p++ = *s++;
 668         }
 669       f->_IO_write_ptr += count;
 670       to_do -= count;
 671     }
 672   if (to_do + must_flush > 0)
 673     {
 674       _IO_size_t block_size, dont_write;
 675       /* Next flush the (full) buffer. */
 676       if (__overflow (f, EOF) == EOF)
 677         return n - to_do;
 678
 679       /* Try to maintain alignment: write a whole number of blocks.
 680          dont_write is what gets left over. */
 681       block_size = f->_IO_buf_end - f->_IO_buf_base;
 682       dont_write = block_size >= 128 ? to_do % block_size : 0;
 683
 684       count = to_do - dont_write;
 685       if (_IO_old_do_write (f, s, count) == EOF)
 686         return n - to_do;
 687       to_do = dont_write;
 688
 689       /* Now write out the remainder.  Normally, this will fit in the
 690          buffer, but it's somewhat messier for line-buffered files,
 691          so we let _IO_default_xsputn handle the general case. */
 692       if (dont_write)
 693         to_do -= _IO_default_xsputn (f, s+count, dont_write);
 694     }
 695   return n - to_do;
 696 }
 697
 698
 699 struct _IO_jump_t _IO_old_file_jumps =
 700 {
 701   JUMP_INIT_DUMMY,
 702   JUMP_INIT(finish, _IO_old_file_finish),
 703   JUMP_INIT(overflow, _IO_old_file_overflow),
 704   JUMP_INIT(underflow, _IO_old_file_underflow),
 705   JUMP_INIT(uflow, _IO_default_uflow),
 706   JUMP_INIT(pbackfail, _IO_default_pbackfail),
 707   JUMP_INIT(xsputn, _IO_old_file_xsputn),
 708   JUMP_INIT(xsgetn, _IO_default_xsgetn),
 709   JUMP_INIT(seekoff, _IO_old_file_seekoff),
 710   JUMP_INIT(seekpos, _IO_default_seekpos),
 711   JUMP_INIT(setbuf, _IO_old_file_setbuf),
 712   JUMP_INIT(sync, _IO_old_file_sync),
 713   JUMP_INIT(doallocate, _IO_file_doallocate),
 714   JUMP_INIT(read, _IO_file_read),
 715   JUMP_INIT(write, _IO_old_file_write),
 716   JUMP_INIT(seek, _IO_file_seek),
 717   JUMP_INIT(close, _IO_file_close),
 718   JUMP_INIT(stat, _IO_file_stat)
 719 };
 720
 721
 722 #endif /* DO_VERSIONING */