1 /* Copyright (C) 1993, 1995, 1997, 1998, 1999 Free Software Foundation, Inc.
2 This file is part of the GNU IO Library.
3 Written by Per Bothner <bothner@cygnus.com>.
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.
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.
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,
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. */
27 /* This is a compatibility file. If we don't build the libc with
28 versioning don't compile this file. */
29 #if defined PIC && DO_VERSIONING
33 # define _POSIX_SOURCE
35 #define _IO_USE_OLD_IO_FILE
38 #include <sys/types.h>
49 # define __set_errno(Val) errno = (Val)
54 # define open(Name, Flags, Prot) __open (Name, Flags, Prot)
55 # define close(FD) __close (FD)
56 # define lseek(FD, Offset, Whence) __lseek (FD, Offset, Whence)
57 # define read(FD, Buf, NBytes) __read (FD, Buf, NBytes)
58 # define write(FD, Buf, NBytes) __write (FD, Buf, NBytes)
61 /* An fstream can be in at most one of put mode, get mode, or putback mode.
62 Putback mode is a variant of get mode.
64 In a filebuf, there is only one current position, instead of two
65 separate get and put pointers. In get mode, the current position
66 is that of gptr(); in put mode that of pptr().
68 The position in the buffer that corresponds to the position
69 in external file system is normally _IO_read_end, except in putback
70 mode, when it is _IO_save_end.
71 If the field _fb._offset is >= 0, it gives the offset in
72 the file as a whole corresponding to eGptr(). (?)
75 If a filebuf is in put mode, then all of _IO_read_ptr, _IO_read_end,
76 and _IO_read_base are equal to each other. These are usually equal
77 to _IO_buf_base, though not necessarily if we have switched from
78 get mode to put mode. (The reason is to maintain the invariant
79 that _IO_read_end corresponds to the external file position.)
80 _IO_write_base is non-NULL and usually equal to _IO_base_base.
81 We also have _IO_write_end == _IO_buf_end, but only in fully buffered mode.
82 The un-flushed character are those between _IO_write_base and _IO_write_ptr.
85 If a filebuf is in get or putback mode, eback() != egptr().
86 In get mode, the unread characters are between gptr() and egptr().
87 The OS file position corresponds to that of egptr().
90 Putback mode is used to remember "excess" characters that have
91 been sputbackc'd in a separate putback buffer.
92 In putback mode, the get buffer points to the special putback buffer.
93 The unread characters are the characters between gptr() and egptr()
94 in the putback buffer, as well as the area between save_gptr()
95 and save_egptr(), which point into the original reserve buffer.
96 (The pointers save_gptr() and save_egptr() are the values
97 of gptr() and egptr() at the time putback mode was entered.)
98 The OS position corresponds to that of save_egptr().
100 LINE BUFFERED OUTPUT:
101 During line buffered output, _IO_write_base==base() && epptr()==base().
102 However, ptr() may be anywhere between base() and ebuf().
103 This forces a call to filebuf::overflow(int C) on every put.
104 If there is more space in the buffer, and C is not a '\n',
105 then C is inserted, and pptr() incremented.
108 If a filebuf is unbuffered(), the _shortbuf[1] is used as the buffer.
111 #define CLOSED_FILEBUF_FLAGS \
112 (_IO_IS_FILEBUF+_IO_NO_READS+_IO_NO_WRITES+_IO_TIED_PUT_GET)
116 _IO_old_file_init (fp
)
119 /* POSIX.1 allows another file handle to be used to change the position
120 of our file descriptor. Hence we actually don't know the actual
121 position before we do the first fseek (and until a following fflush). */
122 fp
->_old_offset
= _IO_pos_BAD
;
123 fp
->_IO_file_flags
|= CLOSED_FILEBUF_FLAGS
;
126 fp
->_vtable_offset
= ((int) sizeof (struct _IO_FILE
)
127 - (int) sizeof (struct _IO_FILE_complete
));
132 _IO_old_file_close_it (fp
)
135 int write_status
, close_status
;
136 if (!_IO_file_is_open (fp
))
139 write_status
= _IO_old_do_flush (fp
);
141 _IO_unsave_markers(fp
);
143 close_status
= _IO_SYSCLOSE (fp
);
146 _IO_setb (fp
, NULL
, NULL
, 0);
147 _IO_setg (fp
, NULL
, NULL
, NULL
);
148 _IO_setp (fp
, NULL
, NULL
);
151 fp
->_flags
= _IO_MAGIC
|CLOSED_FILEBUF_FLAGS
;
153 fp
->_old_offset
= _IO_pos_BAD
;
155 return close_status
? close_status
: write_status
;
159 _IO_old_file_finish (fp
, dummy
)
163 if (_IO_file_is_open (fp
))
165 _IO_old_do_flush (fp
);
166 if (!(fp
->_flags
& _IO_DELETE_DONT_CLOSE
))
169 _IO_default_finish (fp
, 0);
173 _IO_old_file_fopen (fp
, filename
, mode
)
175 const char *filename
;
178 int oflags
= 0, omode
;
179 int read_write
, fdesc
;
181 if (_IO_file_is_open (fp
))
187 read_write
= _IO_NO_WRITES
;
191 oflags
= O_CREAT
|O_TRUNC
;
192 read_write
= _IO_NO_READS
;
196 oflags
= O_CREAT
|O_APPEND
;
197 read_write
= _IO_NO_READS
|_IO_IS_APPENDING
;
200 __set_errno (EINVAL
);
203 if (mode
[0] == '+' || (mode
[0] == 'b' && mode
[1] == '+'))
206 read_write
&= _IO_IS_APPENDING
;
208 fdesc
= open (filename
, omode
|oflags
, oprot
);
212 _IO_mask_flags (fp
, read_write
,_IO_NO_READS
+_IO_NO_WRITES
+_IO_IS_APPENDING
);
213 if (read_write
& _IO_IS_APPENDING
)
214 if (_IO_SEEKOFF (fp
, (_IO_off_t
)0, _IO_seek_end
, _IOS_INPUT
|_IOS_OUTPUT
)
215 == _IO_pos_BAD
&& errno
!= ESPIPE
)
222 _IO_old_file_attach (fp
, fd
)
226 if (_IO_file_is_open (fp
))
229 fp
->_flags
&= ~(_IO_NO_READS
+_IO_NO_WRITES
);
230 fp
->_flags
|= _IO_DELETE_DONT_CLOSE
;
231 /* Get the current position of the file. */
232 /* We have to do that since that may be junk. */
233 fp
->_old_offset
= _IO_pos_BAD
;
234 if (_IO_SEEKOFF (fp
, (_IO_off_t
)0, _IO_seek_cur
, _IOS_INPUT
|_IOS_OUTPUT
)
235 == _IO_pos_BAD
&& errno
!= ESPIPE
)
241 _IO_old_file_setbuf (fp
, p
, len
)
246 if (_IO_default_setbuf (fp
, p
, len
) == NULL
)
249 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_write_end
251 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
256 static int old_do_write
__P ((_IO_FILE
*, const char *, _IO_size_t
));
258 /* Write TO_DO bytes from DATA to FP.
259 Then mark FP as having empty buffers. */
262 _IO_old_do_write (fp
, data
, to_do
)
267 return (to_do
== 0 || old_do_write (fp
, data
, to_do
) == to_do
)
273 old_do_write (fp
, data
, to_do
)
279 if (fp
->_flags
& _IO_IS_APPENDING
)
280 /* On a system without a proper O_APPEND implementation,
281 you would need to sys_seek(0, SEEK_END) here, but is
282 is not needed nor desirable for Unix- or Posix-like systems.
283 Instead, just indicate that offset (before and after) is
285 fp
->_old_offset
= _IO_pos_BAD
;
286 else if (fp
->_IO_read_end
!= fp
->_IO_write_base
)
289 = _IO_SYSSEEK (fp
, fp
->_IO_write_base
- fp
->_IO_read_end
, 1);
290 if (new_pos
== _IO_pos_BAD
)
292 fp
->_old_offset
= new_pos
;
294 count
= _IO_SYSWRITE (fp
, data
, to_do
);
295 if (fp
->_cur_column
&& count
)
296 fp
->_cur_column
= _IO_adjust_column (fp
->_cur_column
- 1, data
, count
) + 1;
297 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
298 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_buf_base
;
299 fp
->_IO_write_end
= ((fp
->_flags
& (_IO_LINE_BUF
+_IO_UNBUFFERED
))
300 ? fp
->_IO_buf_base
: fp
->_IO_buf_end
);
305 _IO_old_file_underflow (fp
)
310 /* SysV does not make this test; take it out for compatibility */
311 if (fp
->_flags
& _IO_EOF_SEEN
)
315 if (fp
->_flags
& _IO_NO_READS
)
317 fp
->_flags
|= _IO_ERR_SEEN
;
321 if (fp
->_IO_read_ptr
< fp
->_IO_read_end
)
322 return *(unsigned char *) fp
->_IO_read_ptr
;
324 if (fp
->_IO_buf_base
== NULL
)
326 /* Maybe we already have a push back pointer. */
327 if (fp
->_IO_save_base
!= NULL
)
329 free (fp
->_IO_save_base
);
330 fp
->_flags
&= ~_IO_IN_BACKUP
;
335 /* Flush all line buffered files before reading. */
336 /* FIXME This can/should be moved to genops ?? */
337 if (fp
->_flags
& (_IO_LINE_BUF
|_IO_UNBUFFERED
))
338 _IO_flush_all_linebuffered ();
340 _IO_switch_to_get_mode (fp
);
342 /* This is very tricky. We have to adjust those
343 pointers before we call _IO_SYSREAD () since
344 we may longjump () out while waiting for
345 input. Those pointers may be screwed up. H.J. */
346 fp
->_IO_read_base
= fp
->_IO_read_ptr
= fp
->_IO_buf_base
;
347 fp
->_IO_read_end
= fp
->_IO_buf_base
;
348 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_write_end
351 count
= _IO_SYSREAD (fp
, fp
->_IO_buf_base
,
352 fp
->_IO_buf_end
- fp
->_IO_buf_base
);
356 fp
->_flags
|= _IO_EOF_SEEN
;
358 fp
->_flags
|= _IO_ERR_SEEN
, count
= 0;
360 fp
->_IO_read_end
+= count
;
363 if (fp
->_old_offset
!= _IO_pos_BAD
)
364 _IO_pos_adjust (fp
->_old_offset
, count
);
365 return *(unsigned char *) fp
->_IO_read_ptr
;
369 _IO_old_file_overflow (f
, ch
)
373 if (f
->_flags
& _IO_NO_WRITES
) /* SET ERROR */
375 f
->_flags
|= _IO_ERR_SEEN
;
379 /* If currently reading or no buffer allocated. */
380 if ((f
->_flags
& _IO_CURRENTLY_PUTTING
) == 0)
382 /* Allocate a buffer if needed. */
383 if (f
->_IO_write_base
== 0)
386 _IO_setg (f
, f
->_IO_buf_base
, f
->_IO_buf_base
, f
->_IO_buf_base
);
388 /* Otherwise must be currently reading.
389 If _IO_read_ptr (and hence also _IO_read_end) is at the buffer end,
390 logically slide the buffer forwards one block (by setting the
391 read pointers to all point at the beginning of the block). This
392 makes room for subsequent output.
393 Otherwise, set the read pointers to _IO_read_end (leaving that
394 alone, so it can continue to correspond to the external position). */
395 if (f
->_IO_read_ptr
== f
->_IO_buf_end
)
396 f
->_IO_read_end
= f
->_IO_read_ptr
= f
->_IO_buf_base
;
397 f
->_IO_write_ptr
= f
->_IO_read_ptr
;
398 f
->_IO_write_base
= f
->_IO_write_ptr
;
399 f
->_IO_write_end
= f
->_IO_buf_end
;
400 f
->_IO_read_base
= f
->_IO_read_ptr
= f
->_IO_read_end
;
402 if (f
->_flags
& (_IO_LINE_BUF
+_IO_UNBUFFERED
))
403 f
->_IO_write_end
= f
->_IO_write_ptr
;
404 f
->_flags
|= _IO_CURRENTLY_PUTTING
;
407 return _IO_old_do_flush (f
);
408 if (f
->_IO_write_ptr
== f
->_IO_buf_end
) /* Buffer is really full */
409 if (_IO_old_do_flush (f
) == EOF
)
411 *f
->_IO_write_ptr
++ = ch
;
412 if ((f
->_flags
& _IO_UNBUFFERED
)
413 || ((f
->_flags
& _IO_LINE_BUF
) && ch
== '\n'))
414 if (_IO_old_do_flush (f
) == EOF
)
416 return (unsigned char) ch
;
420 _IO_old_file_sync (fp
)
426 /* char* ptr = cur_ptr(); */
427 if (fp
->_IO_write_ptr
> fp
->_IO_write_base
)
428 if (_IO_old_do_flush(fp
)) return EOF
;
429 delta
= fp
->_IO_read_ptr
- fp
->_IO_read_end
;
433 if (_IO_in_backup (fp
))
434 delta
-= eGptr () - Gbase ();
436 _IO_off_t new_pos
= _IO_SYSSEEK (fp
, delta
, 1);
437 if (new_pos
!= (_IO_off_t
) EOF
)
438 fp
->_IO_read_end
= fp
->_IO_read_ptr
;
440 else if (errno
== ESPIPE
)
441 ; /* Ignore error from unseekable devices. */
447 fp
->_old_offset
= _IO_pos_BAD
;
448 /* FIXME: Cleanup - can this be shared? */
449 /* setg(base(), ptr, ptr); */
454 _IO_old_file_seekoff (fp
, offset
, dir
, mode
)
461 _IO_off64_t delta
, new_offset
;
463 /* POSIX.1 8.2.3.7 says that after a call the fflush() the file
464 offset of the underlying file must be exact. */
465 int must_be_exact
= (fp
->_IO_read_base
== fp
->_IO_read_end
466 && fp
->_IO_write_base
== fp
->_IO_write_ptr
);
469 dir
= _IO_seek_cur
, offset
= 0; /* Don't move any pointers. */
471 /* Flush unwritten characters.
472 (This may do an unneeded write if we seek within the buffer.
473 But to be able to switch to reading, we would need to set
474 egptr to ptr. That can't be done in the current design,
475 which assumes file_ptr() is eGptr. Anyway, since we probably
476 end up flushing when we close(), it doesn't make much difference.)
477 FIXME: simulate mem-papped files. */
479 if (fp
->_IO_write_ptr
> fp
->_IO_write_base
|| _IO_in_put_mode (fp
))
480 if (_IO_switch_to_get_mode (fp
))
483 if (fp
->_IO_buf_base
== NULL
)
485 /* It could be that we already have a pushback buffer. */
486 if (fp
->_IO_read_base
!= NULL
)
488 free (fp
->_IO_read_base
);
489 fp
->_flags
&= ~_IO_IN_BACKUP
;
492 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
493 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
499 /* Adjust for read-ahead (bytes is buffer). */
500 offset
-= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
501 if (fp
->_old_offset
== _IO_pos_BAD
)
503 /* Make offset absolute, assuming current pointer is file_ptr(). */
504 offset
+= fp
->_old_offset
;
513 if (_IO_SYSSTAT (fp
, &st
) == 0 && S_ISREG (st
.st_mode
))
515 offset
+= st
.st_size
;
522 /* At this point, dir==_IO_seek_set. */
524 /* If we are only interested in the current position we've found it now. */
528 /* If destination is within current buffer, optimize: */
529 if (fp
->_old_offset
!= _IO_pos_BAD
&& fp
->_IO_read_base
!= NULL
530 && !_IO_in_backup (fp
))
532 /* Offset relative to start of main get area. */
533 _IO_off_t rel_offset
= (offset
- fp
->_old_offset
534 + (fp
->_IO_read_end
- fp
->_IO_read_base
));
538 if (_IO_in_backup (fp
))
539 _IO_switch_to_main_get_area (fp
);
541 if (rel_offset
<= fp
->_IO_read_end
- fp
->_IO_read_base
)
543 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
+ rel_offset
,
545 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
547 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
552 /* If we have streammarkers, seek forward by reading ahead. */
553 if (_IO_have_markers (fp
))
555 int to_skip
= rel_offset
556 - (fp
->_IO_read_ptr
- fp
->_IO_read_base
);
557 if (ignore (to_skip
) != to_skip
)
559 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
565 if (rel_offset
< 0 && rel_offset
>= Bbase () - Bptr ())
567 if (!_IO_in_backup (fp
))
568 _IO_switch_to_backup_area (fp
);
569 gbump (fp
->_IO_read_end
+ rel_offset
- fp
->_IO_read_ptr
);
570 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
577 _IO_unsave_markers (fp
);
580 if (fp
->_flags
& _IO_NO_READS
)
583 /* Try to seek to a block boundary, to improve kernel page management. */
584 new_offset
= offset
& ~(fp
->_IO_buf_end
- fp
->_IO_buf_base
- 1);
585 delta
= offset
- new_offset
;
586 if (delta
> fp
->_IO_buf_end
- fp
->_IO_buf_base
)
591 result
= _IO_SYSSEEK (fp
, new_offset
, 0);
598 count
= _IO_SYSREAD (fp
, fp
->_IO_buf_base
,
600 ? delta
: fp
->_IO_buf_end
- fp
->_IO_buf_base
));
603 /* We weren't allowed to read, but try to seek the remainder. */
604 offset
= count
== EOF
? delta
: delta
-count
;
609 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
+ delta
,
610 fp
->_IO_buf_base
+ count
);
611 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
612 fp
->_old_offset
= result
+ count
;
613 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
617 _IO_unsave_markers (fp
);
618 result
= _IO_SYSSEEK (fp
, offset
, dir
);
621 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
622 fp
->_old_offset
= result
;
623 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
624 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
629 /* We need to do it since it is possible that the file offset in
630 the kernel may be changed behind our back. It may happen when
631 we fopen a file and then do a fork. One process may access the
632 the file and the kernel file offset will be changed. */
633 if (fp
->_old_offset
>= 0)
634 _IO_SYSSEEK (fp
, fp
->_old_offset
, 0);
640 _IO_old_file_write (f
, data
, n
)
645 _IO_ssize_t to_do
= n
;
648 _IO_ssize_t count
= write (f
->_fileno
, data
, to_do
);
651 f
->_flags
|= _IO_ERR_SEEN
;
655 data
= (void *) ((char *) data
+ count
);
658 if (f
->_old_offset
>= 0)
664 _IO_old_file_xsputn (f
, data
, n
)
669 register const char *s
= (char *) data
;
670 _IO_size_t to_do
= n
;
676 /* This is an optimized implementation.
677 If the amount to be written straddles a block boundary
678 (or the filebuf is unbuffered), use sys_write directly. */
680 /* First figure out how much space is available in the buffer. */
681 count
= f
->_IO_write_end
- f
->_IO_write_ptr
; /* Space available. */
682 if ((f
->_flags
& _IO_LINE_BUF
) && (f
->_flags
& _IO_CURRENTLY_PUTTING
))
684 count
= f
->_IO_buf_end
- f
->_IO_write_ptr
;
687 register const char *p
;
688 for (p
= s
+ n
; p
> s
; )
699 /* Then fill the buffer. */
707 f
->_IO_write_ptr
= __mempcpy (f
->_IO_write_ptr
, s
, count
);
709 memcpy (f
->_IO_write_ptr
, s
, count
);
710 f
->_IO_write_ptr
+= count
;
716 register char *p
= f
->_IO_write_ptr
;
717 register int i
= (int) count
;
720 f
->_IO_write_ptr
= p
;
724 if (to_do
+ must_flush
> 0)
726 _IO_size_t block_size
, do_write
;
727 /* Next flush the (full) buffer. */
728 if (__overflow (f
, EOF
) == EOF
)
731 /* Try to maintain alignment: write a whole number of blocks.
732 dont_write is what gets left over. */
733 block_size
= f
->_IO_buf_end
- f
->_IO_buf_base
;
734 do_write
= to_do
- (block_size
>= 128 ? to_do
% block_size
: 0);
738 count
= old_do_write (f
, s
, do_write
);
740 if (count
< do_write
)
744 /* Now write out the remainder. Normally, this will fit in the
745 buffer, but it's somewhat messier for line-buffered files,
746 so we let _IO_default_xsputn handle the general case. */
748 to_do
-= _IO_default_xsputn (f
, s
+do_write
, to_do
);
754 struct _IO_jump_t _IO_old_file_jumps
=
757 JUMP_INIT(finish
, _IO_old_file_finish
),
758 JUMP_INIT(overflow
, _IO_old_file_overflow
),
759 JUMP_INIT(underflow
, _IO_old_file_underflow
),
760 JUMP_INIT(uflow
, _IO_default_uflow
),
761 JUMP_INIT(pbackfail
, _IO_default_pbackfail
),
762 JUMP_INIT(xsputn
, _IO_old_file_xsputn
),
763 JUMP_INIT(xsgetn
, _IO_default_xsgetn
),
764 JUMP_INIT(seekoff
, _IO_old_file_seekoff
),
765 JUMP_INIT(seekpos
, _IO_default_seekpos
),
766 JUMP_INIT(setbuf
, _IO_old_file_setbuf
),
767 JUMP_INIT(sync
, _IO_old_file_sync
),
768 JUMP_INIT(doallocate
, _IO_file_doallocate
),
769 JUMP_INIT(read
, _IO_file_read
),
770 JUMP_INIT(write
, _IO_old_file_write
),
771 JUMP_INIT(seek
, _IO_file_seek
),
772 JUMP_INIT(close
, _IO_file_close
),
773 JUMP_INIT(stat
, _IO_file_stat
)
776 symbol_version (_IO_old_do_write
, _IO_do_write
, GLIBC_2
.0
);
777 symbol_version (_IO_old_file_attach
, _IO_file_attach
, GLIBC_2
.0
);
778 symbol_version (_IO_old_file_close_it
, _IO_file_close_it
, GLIBC_2
.0
);
779 symbol_version (_IO_old_file_finish
, _IO_file_finish
, GLIBC_2
.0
);
780 symbol_version (_IO_old_file_fopen
, _IO_file_fopen
, GLIBC_2
.0
);
781 symbol_version (_IO_old_file_init
, _IO_file_init
, GLIBC_2
.0
);
782 symbol_version (_IO_old_file_setbuf
, _IO_file_setbuf
, GLIBC_2
.0
);
783 symbol_version (_IO_old_file_sync
, _IO_file_sync
, GLIBC_2
.0
);
784 symbol_version (_IO_old_file_overflow
, _IO_file_overflow
, GLIBC_2
.0
);
785 symbol_version (_IO_old_file_seekoff
, _IO_file_seekoff
, GLIBC_2
.0
);
786 symbol_version (_IO_old_file_underflow
, _IO_file_underflow
, GLIBC_2
.0
);
787 symbol_version (_IO_old_file_write
, _IO_file_write
, GLIBC_2
.0
);
788 symbol_version (_IO_old_file_xsputn
, _IO_file_xsputn
, GLIBC_2
.0
);
790 #endif /* PIC && DO_VERSIONING */