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