libio/fileops.c

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