2 Copyright (C) 1993, 1995 Free Software Foundation
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)
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.
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.
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. */
25 /* written by Per Bothner (bothner@cygnus.com) */
28 # define _POSIX_SOURCE
32 #include <sys/types.h>
42 # define open(Name, Flags, Prot) __open ((Name), (Flags), (Prot))
45 /* An fstream can be in at most one of put mode, get mode, or putback mode.
46 Putback mode is a variant of get mode.
48 In a filebuf, there is only one current position, instead of two
49 separate get and put pointers. In get mode, the current position
50 is that of gptr(); in put mode that of pptr().
52 The position in the buffer that corresponds to the position
53 in external file system is normally _IO_read_end, except in putback
54 mode, when it is _IO_save_end.
55 If the field _fb._offset is >= 0, it gives the offset in
56 the file as a whole corresponding to eGptr(). (?)
59 If a filebuf is in put mode, then all of _IO_read_ptr, _IO_read_end,
60 and _IO_read_base are equal to each other. These are usually equal
61 to _IO_buf_base, though not necessarily if we have switched from
62 get mode to put mode. (The reason is to maintain the invariant
63 that _IO_read_end corresponds to the external file position.)
64 _IO_write_base is non-NULL and usually equal to _IO_base_base.
65 We also have _IO_write_end == _IO_buf_end, but only in fully buffered mode.
66 The un-flushed character are those between _IO_write_base and _IO_write_ptr.
69 If a filebuf is in get or putback mode, eback() != egptr().
70 In get mode, the unread characters are between gptr() and egptr().
71 The OS file position corresponds to that of egptr().
74 Putback mode is used to remember "excess" characters that have
75 been sputbackc'd in a separate putback buffer.
76 In putback mode, the get buffer points to the special putback buffer.
77 The unread characters are the characters between gptr() and egptr()
78 in the putback buffer, as well as the area between save_gptr()
79 and save_egptr(), which point into the original reserve buffer.
80 (The pointers save_gptr() and save_egptr() are the values
81 of gptr() and egptr() at the time putback mode was entered.)
82 The OS position corresponds to that of save_egptr().
85 During line buffered output, _IO_write_base==base() && epptr()==base().
86 However, ptr() may be anywhere between base() and ebuf().
87 This forces a call to filebuf::overflow(int C) on every put.
88 If there is more space in the buffer, and C is not a '\n',
89 then C is inserted, and pptr() incremented.
92 If a filebuf is unbuffered(), the _shortbuf[1] is used as the buffer.
95 #define CLOSED_FILEBUF_FLAGS \
96 (_IO_IS_FILEBUF+_IO_NO_READS+_IO_NO_WRITES+_IO_TIED_PUT_GET)
100 DEFUN(_IO_file_init
, (fp
),
101 register _IO_FILE
*fp
)
103 /* POSIX.1 allows another file handle to be used to change the position
104 of our file descriptor. Hence we actually don't know the actual
105 position before we do the first fseek (and until a following fflush). */
106 fp
->_offset
= _IO_pos_BAD
;
107 fp
->_IO_file_flags
|= CLOSED_FILEBUF_FLAGS
;
114 DEFUN(_IO_file_close_it
, (fp
),
115 register _IO_FILE
* fp
)
117 int write_status
, close_status
;
118 if (!_IO_file_is_open(fp
))
121 write_status
= _IO_do_flush (fp
);
123 _IO_unsave_markers(fp
);
125 close_status
= _IO_SYSCLOSE (fp
);
128 _IO_setb(fp
, NULL
, NULL
, 0);
129 _IO_setg(fp
, NULL
, NULL
, NULL
);
130 _IO_setp(fp
, NULL
, NULL
);
133 fp
->_flags
= _IO_MAGIC
|CLOSED_FILEBUF_FLAGS
;
135 fp
->_offset
= _IO_pos_BAD
;
137 return close_status
? close_status
: write_status
;
141 DEFUN(_IO_file_finish
, (fp
, dummy
),
142 register _IO_FILE
* fp AND
int dummy
)
144 if (_IO_file_is_open(fp
))
147 if (!(fp
->_flags
& _IO_DELETE_DONT_CLOSE
))
150 _IO_default_finish(fp
, 0);
154 DEFUN(_IO_file_fopen
, (fp
, filename
, mode
),
155 register _IO_FILE
*fp AND
const char *filename AND
const char *mode
)
157 int oflags
= 0, omode
;
158 int read_write
, fdesc
;
160 if (_IO_file_is_open (fp
))
165 read_write
= _IO_NO_WRITES
;
169 oflags
= O_CREAT
|O_TRUNC
;
170 read_write
= _IO_NO_READS
;
174 oflags
= O_CREAT
|O_APPEND
;
175 read_write
= _IO_NO_READS
|_IO_IS_APPENDING
;
178 __set_errno (EINVAL
);
181 if (mode
[0] == '+' || (mode
[0] == 'b' && mode
[1] == '+')) {
183 read_write
&= _IO_IS_APPENDING
;
185 fdesc
= open(filename
, omode
|oflags
, oprot
);
189 _IO_mask_flags(fp
, read_write
,_IO_NO_READS
+_IO_NO_WRITES
+_IO_IS_APPENDING
);
190 if (read_write
& _IO_IS_APPENDING
)
191 if (_IO_SEEKOFF (fp
, (_IO_off_t
)0, _IO_seek_end
, _IOS_INPUT
|_IOS_OUTPUT
)
192 == _IO_pos_BAD
&& errno
!= ESPIPE
)
199 DEFUN(_IO_file_attach
, (fp
, fd
),
200 _IO_FILE
*fp AND
int fd
)
202 if (_IO_file_is_open(fp
))
205 fp
->_flags
&= ~(_IO_NO_READS
+_IO_NO_WRITES
);
206 fp
->_flags
|= _IO_DELETE_DONT_CLOSE
;
207 /* Get the current position of the file. */
208 /* We have to do that since that may be junk. */
209 fp
->_offset
= _IO_pos_BAD
;
210 if (_IO_SEEKOFF (fp
, (_IO_off_t
)0, _IO_seek_cur
, _IOS_INPUT
|_IOS_OUTPUT
)
211 == _IO_pos_BAD
&& errno
!= ESPIPE
)
217 DEFUN(_IO_file_setbuf
, (fp
, p
, len
),
218 register _IO_FILE
*fp AND
char* p AND _IO_ssize_t len
)
220 if (_IO_default_setbuf(fp
, p
, len
) == NULL
)
223 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_write_end
225 _IO_setg(fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
230 /* Write TO_DO bytes from DATA to FP.
231 Then mark FP as having empty buffers. */
234 DEFUN(_IO_do_write
, (fp
, data
, to_do
),
235 register _IO_FILE
*fp AND
const char* data AND _IO_size_t to_do
)
240 if (fp
->_flags
& _IO_IS_APPENDING
)
241 /* On a system without a proper O_APPEND implementation,
242 you would need to sys_seek(0, SEEK_END) here, but is
243 is not needed nor desirable for Unix- or Posix-like systems.
244 Instead, just indicate that offset (before and after) is
246 fp
->_offset
= _IO_pos_BAD
;
247 else if (fp
->_IO_read_end
!= fp
->_IO_write_base
)
250 = _IO_SYSSEEK(fp
, fp
->_IO_write_base
- fp
->_IO_read_end
, 1);
251 if (new_pos
== _IO_pos_BAD
)
253 fp
->_offset
= new_pos
;
255 count
= _IO_SYSWRITE (fp
, data
, to_do
);
257 fp
->_cur_column
= _IO_adjust_column(fp
->_cur_column
- 1, data
, to_do
) + 1;
258 _IO_setg(fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
259 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_buf_base
;
260 fp
->_IO_write_end
= (fp
->_flags
& (_IO_LINE_BUF
+_IO_UNBUFFERED
)) ? fp
->_IO_buf_base
262 return count
!= to_do
? EOF
: 0;
266 DEFUN(_IO_file_underflow
, (fp
),
267 register _IO_FILE
*fp
)
271 /* SysV does not make this test; take it out for compatibility */
272 if (fp
->_flags
& _IO_EOF_SEEN
)
276 if (fp
->_flags
& _IO_NO_READS
)
281 if (fp
->_IO_read_ptr
< fp
->_IO_read_end
)
282 return *(unsigned char*)fp
->_IO_read_ptr
;
284 if (fp
->_IO_buf_base
== NULL
)
287 /* Flush all line buffered files before reading. */
288 /* FIXME This can/should be moved to genops ?? */
289 if (fp
->_flags
& (_IO_LINE_BUF
|_IO_UNBUFFERED
))
290 _IO_flush_all_linebuffered();
292 _IO_switch_to_get_mode(fp
);
294 count
= _IO_SYSREAD (fp
, fp
->_IO_buf_base
,
295 fp
->_IO_buf_end
- fp
->_IO_buf_base
);
299 fp
->_flags
|= _IO_EOF_SEEN
;
301 fp
->_flags
|= _IO_ERR_SEEN
, count
= 0;
303 fp
->_IO_read_base
= fp
->_IO_read_ptr
= fp
->_IO_buf_base
;
304 fp
->_IO_read_end
= fp
->_IO_buf_base
+ count
;
305 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_write_end
309 if (fp
->_offset
!= _IO_pos_BAD
)
310 _IO_pos_adjust(fp
->_offset
, count
);
311 return *(unsigned char*)fp
->_IO_read_ptr
;
315 DEFUN(_IO_file_overflow
, (f
, ch
),
316 register _IO_FILE
* f AND
int ch
)
318 if (f
->_flags
& _IO_NO_WRITES
) /* SET ERROR */
323 /* If currently reading or no buffer allocated. */
324 if ((f
->_flags
& _IO_CURRENTLY_PUTTING
) == 0)
326 /* Allocate a buffer if needed. */
327 if (f
->_IO_write_base
== 0)
330 _IO_setg (f
, f
->_IO_buf_base
, f
->_IO_buf_base
, f
->_IO_buf_base
);
332 /* Otherwise must be currently reading.
333 If _IO_read_ptr (and hence also _IO_read_end) is at the buffer end,
334 logically slide the buffer forwards one block (by setting the
335 read pointers to all point at the beginning of the block). This
336 makes room for subsequent output.
337 Otherwise, set the read pointers to _IO_read_end (leaving that
338 alone, so it can continue to correspond to the external position). */
339 if (f
->_IO_read_ptr
== f
->_IO_buf_end
)
340 f
->_IO_read_end
= f
->_IO_read_ptr
= f
->_IO_buf_base
;
341 f
->_IO_write_ptr
= f
->_IO_read_ptr
;
342 f
->_IO_write_base
= f
->_IO_write_ptr
;
343 f
->_IO_write_end
= f
->_IO_buf_end
;
344 f
->_IO_read_base
= f
->_IO_read_ptr
= f
->_IO_read_end
;
346 if (f
->_flags
& (_IO_LINE_BUF
+_IO_UNBUFFERED
))
347 f
->_IO_write_end
= f
->_IO_write_ptr
;
348 f
->_flags
|= _IO_CURRENTLY_PUTTING
;
351 return _IO_do_flush(f
);
352 if (f
->_IO_write_ptr
== f
->_IO_buf_end
) /* Buffer is really full */
353 if (_IO_do_flush(f
) == EOF
)
355 *f
->_IO_write_ptr
++ = ch
;
356 if ((f
->_flags
& _IO_UNBUFFERED
)
357 || ((f
->_flags
& _IO_LINE_BUF
) && ch
== '\n'))
358 if (_IO_do_flush(f
) == EOF
)
360 return (unsigned char)ch
;
364 DEFUN(_IO_file_sync
, (fp
),
365 register _IO_FILE
* fp
)
368 /* char* ptr = cur_ptr(); */
369 if (fp
->_IO_write_ptr
> fp
->_IO_write_base
)
370 if (_IO_do_flush(fp
)) return EOF
;
371 delta
= fp
->_IO_read_ptr
- fp
->_IO_read_end
;
375 if (_IO_in_backup(fp
))
376 delta
-= eGptr() - Gbase();
378 _IO_off_t new_pos
= _IO_SYSSEEK (fp
, delta
, 1);
379 if (new_pos
!= (_IO_off_t
)EOF
)
380 fp
->_IO_read_end
= fp
->_IO_read_ptr
;
382 else if (errno
== ESPIPE
)
383 ; /* Ignore error from unseekable devices. */
388 fp
->_offset
= _IO_pos_BAD
;
389 /* FIXME: Cleanup - can this be shared? */
390 /* setg(base(), ptr, ptr); */
395 DEFUN(_IO_file_seekoff
, (fp
, offset
, dir
, mode
),
396 register _IO_FILE
*fp AND _IO_off_t offset AND
int dir AND
int mode
)
399 _IO_off_t delta
, new_offset
;
401 /* POSIX.1 8.2.3.7 says that after a call the fflush() the file
402 offset of the underlying file must be exact. */
403 int must_be_exact
= (fp
->_IO_read_base
== fp
->_IO_read_end
404 && fp
->_IO_write_base
== fp
->_IO_write_ptr
);
407 dir
= _IO_seek_cur
, offset
= 0; /* Don't move any pointers. */
409 /* Flush unwritten characters.
410 (This may do an unneeded write if we seek within the buffer.
411 But to be able to switch to reading, we would need to set
412 egptr to ptr. That can't be done in the current design,
413 which assumes file_ptr() is eGptr. Anyway, since we probably
414 end up flushing when we close(), it doesn't make much difference.)
415 FIXME: simulate mem-papped files. */
417 if (fp
->_IO_write_ptr
> fp
->_IO_write_base
|| _IO_in_put_mode(fp
))
418 if (_IO_switch_to_get_mode(fp
)) return EOF
;
420 if (fp
->_IO_buf_base
== NULL
)
423 _IO_setp(fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
424 _IO_setg(fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
430 /* Adjust for read-ahead (bytes is buffer). */
431 offset
-= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
432 if (fp
->_offset
== _IO_pos_BAD
)
434 /* Make offset absolute, assuming current pointer is file_ptr(). */
435 offset
+= _IO_pos_as_off(fp
->_offset
);
444 if (_IO_SYSSTAT (fp
, &st
) == 0 && S_ISREG(st
.st_mode
))
446 offset
+= st
.st_size
;
453 /* At this point, dir==_IO_seek_set. */
455 /* If destination is within current buffer, optimize: */
456 if (fp
->_offset
!= _IO_pos_BAD
&& fp
->_IO_read_base
!= NULL
457 && !_IO_in_backup (fp
))
459 /* Offset relative to start of main get area. */
460 _IO_pos_t rel_offset
= offset
- fp
->_offset
461 + (fp
->_IO_read_end
- fp
->_IO_read_base
);
465 if (_IO_in_backup(fp
))
466 _IO_switch_to_main_get_area(fp
);
468 if (rel_offset
<= fp
->_IO_read_end
- fp
->_IO_read_base
)
470 _IO_setg(fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
+ rel_offset
,
472 _IO_setp(fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
476 /* If we have streammarkers, seek forward by reading ahead. */
477 if (_IO_have_markers(fp
))
479 int to_skip
= rel_offset
480 - (fp
->_IO_read_ptr
- fp
->_IO_read_base
);
481 if (ignore(to_skip
) != to_skip
)
488 if (rel_offset
< 0 && rel_offset
>= Bbase() - Bptr())
490 if (!_IO_in_backup(fp
))
491 _IO_switch_to_backup_area(fp
);
492 gbump(fp
->_IO_read_end
+ rel_offset
- fp
->_IO_read_ptr
);
499 _IO_unsave_markers(fp
);
502 if (fp
->_flags
& _IO_NO_READS
)
505 /* Try to seek to a block boundary, to improve kernel page management. */
506 new_offset
= offset
& ~(fp
->_IO_buf_end
- fp
->_IO_buf_base
- 1);
507 delta
= offset
- new_offset
;
508 if (delta
> fp
->_IO_buf_end
- fp
->_IO_buf_base
)
513 result
= _IO_SYSSEEK (fp
, new_offset
, 0);
520 count
= _IO_SYSREAD (fp
, fp
->_IO_buf_base
,
522 ? delta
: fp
->_IO_buf_end
- fp
->_IO_buf_base
));
525 /* We weren't allowed to read, but try to seek the remainder. */
526 offset
= count
== EOF
? delta
: delta
-count
;
531 _IO_setg(fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
+delta
, fp
->_IO_buf_base
+count
);
532 _IO_setp(fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
533 fp
->_offset
= result
+ count
;
534 _IO_mask_flags(fp
, 0, _IO_EOF_SEEN
);
538 _IO_unsave_markers(fp
);
539 result
= _IO_SYSSEEK (fp
, offset
, dir
);
541 _IO_mask_flags(fp
, 0, _IO_EOF_SEEN
);
542 fp
->_offset
= result
;
543 _IO_setg(fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
544 _IO_setp(fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
549 DEFUN(_IO_file_read
, (fp
, buf
, size
),
550 register _IO_FILE
* fp AND
void* buf AND _IO_ssize_t size
)
554 _IO_ssize_t count
= _IO_read(fp
->_fileno
, buf
, size
);
555 #if 0 && defined EINTR
556 /* We must not do this optimization since POSIX.1 explicitly
557 requests that the stream operations must return with the
558 error EINTR if this happens. There must be the possibility
559 that stream operations time out. --drepper */
560 if (count
== -1 && errno
== EINTR
)
568 DEFUN(_IO_file_seek
, (fp
, offset
, dir
),
569 _IO_FILE
*fp AND _IO_off_t offset AND
int dir
)
571 return _IO_lseek(fp
->_fileno
, offset
, dir
);
575 DEFUN(_IO_file_stat
, (fp
, st
),
576 _IO_FILE
*fp AND
void* st
)
578 return _IO_fstat(fp
->_fileno
, (struct stat
*)st
);
582 DEFUN(_IO_file_close
, (fp
),
585 return _IO_close(fp
->_fileno
);
589 DEFUN(_IO_file_write
, (f
, data
, n
),
590 register _IO_FILE
* f AND
const void* data AND _IO_ssize_t n
)
592 _IO_ssize_t to_do
= n
;
595 _IO_ssize_t count
= _IO_write(f
->_fileno
, data
, to_do
);
598 #if 0 && defined EINTR
599 /* We must not do this optimization since POSIX.1 explicitly
600 requests that the stream operations must return with the
601 error EINTR if this happens. There must be the
602 possibility that stream operations time out. --drepper */
608 f
->_flags
|= _IO_ERR_SEEN
;
613 data
= (void*)((char*)data
+ count
);
622 DEFUN(_IO_file_xsputn
, (f
, data
, n
),
623 _IO_FILE
*f AND
const void *data AND _IO_size_t n
)
625 register const char *s
= (char*) data
;
626 _IO_size_t to_do
= n
;
632 /* This is an optimized implementation.
633 If the amount to be written straddles a block boundary
634 (or the filebuf is unbuffered), use sys_write directly. */
636 /* First figure out how much space is available in the buffer. */
637 count
= f
->_IO_write_end
- f
->_IO_write_ptr
; /* Space available. */
638 if ((f
->_flags
& _IO_LINE_BUF
) && (f
->_flags
& _IO_CURRENTLY_PUTTING
))
640 count
= f
->_IO_buf_end
- f
->_IO_write_ptr
;
642 { register const char *p
;
643 for (p
= s
+ n
; p
> s
; )
653 /* Then fill the buffer. */
659 memcpy(f
->_IO_write_ptr
, s
, count
);
664 register char *p
= f
->_IO_write_ptr
;
665 register int i
= (int)count
;
666 while (--i
>= 0) *p
++ = *s
++;
668 f
->_IO_write_ptr
+= count
;
671 if (to_do
+ must_flush
> 0)
672 { _IO_size_t block_size
, dont_write
;
673 /* Next flush the (full) buffer. */
674 if (__overflow(f
, EOF
) == EOF
)
677 /* Try to maintain alignment: write a whole number of blocks.
678 dont_write is what gets left over. */
679 block_size
= f
->_IO_buf_end
- f
->_IO_buf_base
;
680 dont_write
= block_size
>= 128 ? to_do
% block_size
: 0;
682 count
= to_do
- dont_write
;
683 if (_IO_do_write(f
, s
, count
) == EOF
)
687 /* Now write out the remainder. Normally, this will fit in the
688 buffer, but it's somewhat messier for line-buffered files,
689 so we let _IO_default_xsputn handle the general case. */
691 to_do
-= _IO_default_xsputn(f
, s
+count
, dont_write
);
697 /* Work in progress */
699 DEFUN(_IO_file_xsgetn
, (fp
, data
, n
),
700 _IO_FILE
*fp AND
void *data AND _IO_size_t n
)
702 register _IO_size_t more
= n
;
703 register char *s
= data
;
706 _IO_ssize_t count
= fp
->_IO_read_end
- fp
->_IO_read_ptr
; /* Data available. */
713 memcpy(s
, fp
->_IO_read_ptr
, count
);
715 fp
->_IO_read_ptr
+= count
;
721 register char *p
= fp
->_IO_read_ptr
;
722 register int i
= (int)count
;
723 while (--i
>= 0) *s
++ = *p
++;
724 fp
->_IO_read_ptr
= p
;
729 if (! _IO_in
put_mode (fp
)
730 && ! _IO_have_markers (fp
) && ! IO_have_backup (fp
))
732 /* This is an optimization of _IO_file_underflow */
733 if (fp
->_flags
& _IO_NO_READS
)
735 /* If we're reading a lot of data, don't bother allocating
736 a buffer. But if we're only reading a bit, perhaps we should ??*/
737 if (count
<= 512 && fp
->_IO_buf_base
== NULL
)
739 if (fp
->_flags
& (_IO_LINE_BUF
|_IO_UNBUFFERED
))
740 _IO_flush_all_linebuffered();
742 _IO_switch_to_get_mode(fp
); ???;
743 count
= _IO_SYSREAD (fp
, s
, more
);
747 fp
->_flags
|= _IO_EOF_SEEN
;
749 fp
->_flags
|= _IO_ERR_SEEN
, count
= 0;
756 if (more
== 0 || __underflow(fp
) == EOF
)
763 struct _IO_jump_t _IO_file_jumps
= {
765 JUMP_INIT(finish
, _IO_file_finish
),
766 JUMP_INIT(overflow
, _IO_file_overflow
),
767 JUMP_INIT(underflow
, _IO_file_underflow
),
768 JUMP_INIT(uflow
, _IO_default_uflow
),
769 JUMP_INIT(pbackfail
, _IO_default_pbackfail
),
770 JUMP_INIT(xsputn
, _IO_file_xsputn
),
771 JUMP_INIT(xsgetn
, _IO_default_xsgetn
),
772 JUMP_INIT(seekoff
, _IO_file_seekoff
),
773 JUMP_INIT(seekpos
, _IO_default_seekpos
),
774 JUMP_INIT(setbuf
, _IO_file_setbuf
),
775 JUMP_INIT(sync
, _IO_file_sync
),
776 JUMP_INIT(doallocate
, _IO_file_doallocate
),
777 JUMP_INIT(read
, _IO_file_read
),
778 JUMP_INIT(write
, _IO_file_write
),
779 JUMP_INIT(seek
, _IO_file_seek
),
780 JUMP_INIT(close
, _IO_file_close
),
781 JUMP_INIT(stat
, _IO_file_stat
)