update from main archive 961127
[kopensolaris-gnu/glibc.git] / 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     __set_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          If _IO_read_ptr (and hence also _IO_read_end) is at the buffer end,
313          logically slide the buffer forwards one block (by setting the
314          read pointers to all point at the beginning of the block).  This
315          makes room for subsequent output.
316          Otherwise, set the read pointers to _IO_read_end (leaving that
317          alone, so it can continue to correspond to the external position). */
318       if (f->_IO_read_ptr == f->_IO_buf_end)
319         f->_IO_read_end = f->_IO_read_ptr = f->_IO_buf_base;
320       f->_IO_write_ptr = f->_IO_read_ptr;
321       f->_IO_write_base = f->_IO_write_ptr;
322       f->_IO_write_end = f->_IO_buf_end;
323       f->_IO_read_base = f->_IO_read_ptr = f->_IO_read_end;
324
325       if (f->_flags & (_IO_LINE_BUF+_IO_UNBUFFERED))
326         f->_IO_write_end = f->_IO_write_ptr;
327       f->_flags |= _IO_CURRENTLY_PUTTING;
328     }
329   if (ch == EOF)
330     return _IO_do_flush(f);
331   if (f->_IO_write_ptr == f->_IO_buf_end ) /* Buffer is really full */
332     if (_IO_do_flush(f) == EOF)
333       return EOF;
334   *f->_IO_write_ptr++ = ch;
335   if ((f->_flags & _IO_UNBUFFERED)
336       || ((f->_flags & _IO_LINE_BUF) && ch == '\n'))
337     if (_IO_do_flush(f) == EOF)
338       return EOF;
339   return (unsigned char)ch;
340 }
341
342 int
343 DEFUN(_IO_file_sync, (fp),
344       register _IO_FILE* fp)
345 {
346   _IO_size_t delta;
347   /*    char* ptr = cur_ptr(); */
348   if (fp->_IO_write_ptr > fp->_IO_write_base)
349     if (_IO_do_flush(fp)) return EOF;
350   delta = fp->_IO_read_ptr - fp->_IO_read_end;
351   if (delta != 0)
352     {
353 #ifdef TODO
354       if (_IO_in_backup(fp))
355         delta -= eGptr() - Gbase();
356 #endif
357       _IO_off_t new_pos = _IO_SYSSEEK (fp, delta, 1);
358       if (new_pos != (_IO_off_t)EOF)
359         fp->_IO_read_end = fp->_IO_read_ptr;
360 #ifdef ESPIPE
361       else if (errno == ESPIPE)
362         ; /* Ignore error from unseekable devices. */
363 #endif
364       else
365         return EOF;
366     }
367   fp->_offset = _IO_pos_BAD;
368   /* FIXME: Cleanup - can this be shared? */
369   /*    setg(base(), ptr, ptr); */
370   return 0;
371 }
372
373 _IO_pos_t
374 DEFUN(_IO_file_seekoff, (fp, offset, dir, mode),
375       register _IO_FILE *fp AND _IO_off_t offset AND int dir AND int mode)
376 {
377   _IO_pos_t result;
378   _IO_off_t delta, new_offset;
379   long count;
380
381   if (mode == 0)
382     dir = _IO_seek_cur, offset = 0; /* Don't move any pointers. */
383
384   /* Flush unwritten characters.
385      (This may do an unneeded write if we seek within the buffer.
386      But to be able to switch to reading, we would need to set
387      egptr to ptr.  That can't be done in the current design,
388      which assumes file_ptr() is eGptr.  Anyway, since we probably
389      end up flushing when we close(), it doesn't make much difference.)
390      FIXME: simulate mem-papped files. */
391
392   if (fp->_IO_write_ptr > fp->_IO_write_base || _IO_in_put_mode(fp))
393     if (_IO_switch_to_get_mode(fp)) return EOF;
394
395   if (fp->_IO_buf_base == NULL)
396     {
397       _IO_doallocbuf(fp);
398       _IO_setp(fp, fp->_IO_buf_base, fp->_IO_buf_base);
399       _IO_setg(fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
400     }
401
402   switch (dir)
403     {
404     case _IO_seek_cur:
405       /* Adjust for read-ahead (bytes is buffer). */
406       offset -= fp->_IO_read_end - fp->_IO_read_ptr;
407       if (fp->_offset == _IO_pos_BAD)
408         goto dumb;
409       /* Make offset absolute, assuming current pointer is file_ptr(). */
410       offset += _IO_pos_as_off(fp->_offset);
411
412       dir = _IO_seek_set;
413       break;
414     case _IO_seek_set:
415       break;
416     case _IO_seek_end:
417       {
418         struct stat st;
419         if (_IO_SYSSTAT (fp, &st) == 0 && S_ISREG(st.st_mode))
420           {
421             offset += st.st_size;
422             dir = _IO_seek_set;
423           }
424         else
425           goto dumb;
426       }
427     }
428   /* At this point, dir==_IO_seek_set. */
429
430   /* If destination is within current buffer, optimize: */
431   if (fp->_offset != _IO_pos_BAD && fp->_IO_read_base != NULL
432       && !_IO_in_backup (fp))
433     {
434       /* Offset relative to start of main get area. */
435       _IO_pos_t rel_offset = offset - fp->_offset
436         + (fp->_IO_read_end - fp->_IO_read_base);
437       if (rel_offset >= 0)
438         {
439 #if 0
440           if (_IO_in_backup(fp))
441             _IO_switch_to_main_get_area(fp);
442 #endif
443           if (rel_offset <= fp->_IO_read_end - fp->_IO_read_base)
444             {
445               _IO_setg(fp, fp->_IO_buf_base, fp->_IO_buf_base + rel_offset,
446                        fp->_IO_read_end);
447               _IO_setp(fp, fp->_IO_buf_base, fp->_IO_buf_base);
448               return offset;
449             }
450 #ifdef TODO
451             /* If we have streammarkers, seek forward by reading ahead. */
452             if (_IO_have_markers(fp))
453               {
454                 int to_skip = rel_offset
455                   - (fp->_IO_read_ptr - fp->_IO_read_base);
456                 if (ignore(to_skip) != to_skip)
457                   goto dumb;
458                 return offset;
459               }
460 #endif
461         }
462 #ifdef TODO
463       if (rel_offset < 0 && rel_offset >= Bbase() - Bptr())
464         {
465           if (!_IO_in_backup(fp))
466             _IO_switch_to_backup_area(fp);
467           gbump(fp->_IO_read_end + rel_offset - fp->_IO_read_ptr);
468           return offset;
469         }
470 #endif
471     }
472
473 #ifdef TODO
474   _IO_unsave_markers(fp);
475 #endif
476
477   if (fp->_flags & _IO_NO_READS)
478     goto dumb;
479
480   /* Try to seek to a block boundary, to improve kernel page management. */
481   new_offset = offset & ~(fp->_IO_buf_end - fp->_IO_buf_base - 1);
482   delta = offset - new_offset;
483   if (delta > fp->_IO_buf_end - fp->_IO_buf_base)
484     {
485       new_offset = offset;
486       delta = 0;
487     }
488   result = _IO_SYSSEEK (fp, new_offset, 0);
489   if (result < 0)
490     return EOF;
491   if (delta == 0)
492     count = 0;
493   else
494     {
495       count = _IO_SYSREAD (fp, fp->_IO_buf_base,
496                            fp->_IO_buf_end - fp->_IO_buf_base);
497       if (count < delta)
498         {
499           /* We weren't allowed to read, but try to seek the remainder. */
500           offset = count == EOF ? delta : delta-count;
501           dir = _IO_seek_cur;
502           goto dumb;
503         }
504     }
505   _IO_setg(fp, fp->_IO_buf_base, fp->_IO_buf_base+delta, fp->_IO_buf_base+count);
506   _IO_setp(fp, fp->_IO_buf_base, fp->_IO_buf_base);
507   fp->_offset = result + count;
508   _IO_mask_flags(fp, 0, _IO_EOF_SEEN);
509   return offset;
510  dumb:
511
512   _IO_unsave_markers(fp);
513   result = _IO_SYSSEEK (fp, offset, dir);
514   if (result != EOF)
515     _IO_mask_flags(fp, 0, _IO_EOF_SEEN);
516   fp->_offset = result;
517   _IO_setg(fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
518   _IO_setp(fp, fp->_IO_buf_base, fp->_IO_buf_base);
519   return result;
520 }
521
522 _IO_ssize_t
523 DEFUN(_IO_file_read, (fp, buf, size),
524       register _IO_FILE* fp AND void* buf AND _IO_ssize_t size)
525 {
526   for (;;)
527     {
528       _IO_ssize_t count = _IO_read(fp->_fileno, buf, size);
529 #ifdef EINTR
530       if (count == -1 && errno == EINTR)
531         continue;
532 #endif
533       return count;
534     }
535 }
536
537 _IO_pos_t
538 DEFUN(_IO_file_seek, (fp, offset, dir),
539       _IO_FILE *fp AND _IO_off_t offset AND int dir)
540 {
541   return _IO_lseek(fp->_fileno, offset, dir);
542 }
543
544 int
545 DEFUN(_IO_file_stat, (fp, st),
546       _IO_FILE *fp AND void* st)
547 {
548   return _IO_fstat(fp->_fileno, (struct stat*)st);
549 }
550
551 int
552 DEFUN(_IO_file_close, (fp),
553       _IO_FILE* fp)
554 {
555   return _IO_close(fp->_fileno);
556 }
557
558 _IO_ssize_t
559 DEFUN(_IO_file_write, (f, data, n),
560       register _IO_FILE* f AND const void* data AND _IO_ssize_t n)
561 {
562   _IO_ssize_t to_do = n;
563   while (to_do > 0)
564     {
565       _IO_ssize_t count = _IO_write(f->_fileno, data, to_do);
566       if (count == EOF)
567         {
568 #ifdef EINTR
569           if (errno == EINTR)
570             continue;
571           else
572 #endif
573             {
574               f->_flags |= _IO_ERR_SEEN;
575               break;
576             }
577         }
578       to_do -= count;
579       data = (void*)((char*)data + count);
580     }
581   n -= to_do;
582   if (f->_offset >= 0)
583     f->_offset += n;
584   return n;
585 }
586
587 _IO_size_t
588 DEFUN(_IO_file_xsputn, (f, data, n),
589       _IO_FILE *f AND const void *data AND _IO_size_t n)
590 {
591   register const char *s = (char*) data;
592   _IO_size_t to_do = n;
593   int must_flush = 0;
594   _IO_size_t count;
595
596   if (n <= 0)
597     return 0;
598   /* This is an optimized implementation.
599      If the amount to be written straddles a block boundary
600      (or the filebuf is unbuffered), use sys_write directly. */
601
602   /* First figure out how much space is available in the buffer. */
603   count = f->_IO_write_end - f->_IO_write_ptr; /* Space available. */
604   if ((f->_flags & _IO_LINE_BUF) && (f->_flags & _IO_CURRENTLY_PUTTING))
605     {
606       count = f->_IO_buf_end - f->_IO_write_ptr;
607       if (count >= n)
608         { register const char *p;
609           for (p = s + n; p > s; )
610             {
611               if (*--p == '\n') {
612                 count = p - s + 1;
613                 must_flush = 1;
614                 break;
615               }
616             }
617         }
618     }
619   /* Then fill the buffer. */
620   if (count > 0)
621     {
622       if (count > to_do)
623         count = to_do;
624       if (count > 20) {
625         memcpy(f->_IO_write_ptr, s, count);
626         s += count;
627       }
628       else
629         {
630           register char *p = f->_IO_write_ptr;
631           register int i = (int)count;
632           while (--i >= 0) *p++ = *s++;
633         }
634       f->_IO_write_ptr += count;
635       to_do -= count;
636     }
637   if (to_do + must_flush > 0)
638     { _IO_size_t block_size, dont_write;
639       /* Next flush the (full) buffer. */
640       if (__overflow(f, EOF) == EOF)
641         return n - to_do;
642
643       /* Try to maintain alignment: write a whole number of blocks.
644          dont_write is what gets left over. */
645       block_size = f->_IO_buf_end - f->_IO_buf_base;
646       dont_write = block_size >= 128 ? to_do % block_size : 0;
647
648       count = to_do - dont_write;
649       if (_IO_do_write(f, s, count) == EOF)
650         return n - to_do;
651       to_do = dont_write;
652
653       /* Now write out the remainder.  Normally, this will fit in the
654          buffer, but it's somewhat messier for line-buffered files,
655          so we let _IO_default_xsputn handle the general case. */
656       if (dont_write)
657         to_do -= _IO_default_xsputn(f, s+count, dont_write);
658     }
659   return n - to_do;
660 }
661
662 #if 0
663 /* Work in progress */
664 _IO_size_t
665 DEFUN(_IO_file_xsgetn, (fp, data, n),
666       _IO_FILE *fp AND void *data AND _IO_size_t n)
667 {
668   register _IO_size_t more = n;
669   register char *s = data;
670   for (;;)
671     {
672       _IO_ssize_t count = fp->_IO_read_end - fp->_IO_read_ptr; /* Data available. */
673       if (count > 0)
674         {
675           if (count > more)
676             count = more;
677           if (count > 20)
678             {
679               memcpy(s, fp->_IO_read_ptr, count);
680               s += count;
681               fp->_IO_read_ptr += count;
682             }
683           else if (count <= 0)
684             count = 0;
685           else
686             {
687               register char *p = fp->_IO_read_ptr;
688               register int i = (int)count;
689               while (--i >= 0) *s++ = *p++;
690               fp->_IO_read_ptr = p;
691             }
692             more -= count;
693         }
694 #if 0
695       if (! _IO_in put_mode (fp)
696           && ! _IO_have_markers (fp) && ! IO_have_backup (fp))
697         {
698           /* This is an optimization of _IO_file_underflow */
699           if (fp->_flags & _IO_NO_READS)
700             break;
701           /* If we're reading a lot of data, don't bother allocating
702              a buffer.  But if we're only reading a bit, perhaps we should ??*/
703           if (count <= 512 && fp->_IO_buf_base == NULL)
704             _IO_doallocbuf(fp);
705           if (fp->_flags & (_IO_LINE_BUF|_IO_UNBUFFERED))
706             _IO_flush_all_linebuffered();
707
708           _IO_switch_to_get_mode(fp); ???;
709           count = _IO_SYSREAD (fp, s, more);
710           if (count <= 0)
711              {
712                if (count == 0)
713                  fp->_flags |= _IO_EOF_SEEN;
714                else
715                  fp->_flags |= _IO_ERR_SEEN, count = 0;
716              }
717
718           s += count;
719           more -= count;
720         }
721 #endif
722       if (more == 0 || __underflow(fp) == EOF)
723         break;
724     }
725   return n - more;
726 }
727 #endif
728
729 struct _IO_jump_t _IO_file_jumps = {
730   JUMP_INIT_DUMMY,
731   JUMP_INIT(finish, _IO_file_finish),
732   JUMP_INIT(overflow, _IO_file_overflow),
733   JUMP_INIT(underflow, _IO_file_underflow),
734   JUMP_INIT(uflow, _IO_default_uflow),
735   JUMP_INIT(pbackfail, _IO_default_pbackfail),
736   JUMP_INIT(xsputn, _IO_file_xsputn),
737   JUMP_INIT(xsgetn, _IO_default_xsgetn),
738   JUMP_INIT(seekoff, _IO_file_seekoff),
739   JUMP_INIT(seekpos, _IO_default_seekpos),
740   JUMP_INIT(setbuf, _IO_file_setbuf),
741   JUMP_INIT(sync, _IO_file_sync),
742   JUMP_INIT(doallocate, _IO_file_doallocate),
743   JUMP_INIT(read, _IO_file_read),
744   JUMP_INIT(write, _IO_file_write),
745   JUMP_INIT(seek, _IO_file_seek),
746   JUMP_INIT(close, _IO_file_close),
747   JUMP_INIT(stat, _IO_file_stat)
748 };