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