1 /* Copyright (C) 1993, 1995, 1997, 1998 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. */
31 # define _POSIX_SOURCE
33 #define _IO_USE_OLD_IO_FILE
36 #include <sys/types.h>
44 # define __set_errno(Val) errno = (Val)
49 # define open(Name, Flags, Prot) __open (Name, Flags, Prot)
50 # define close(FD) __close (FD)
51 # define lseek(FD, Offset, Whence) __lseek (FD, Offset, Whence)
52 # define read(FD, Buf, NBytes) __read (FD, Buf, NBytes)
53 # define write(FD, Buf, NBytes) __write (FD, Buf, NBytes)
56 /* An fstream can be in at most one of put mode, get mode, or putback mode.
57 Putback mode is a variant of get mode.
59 In a filebuf, there is only one current position, instead of two
60 separate get and put pointers. In get mode, the current position
61 is that of gptr(); in put mode that of pptr().
63 The position in the buffer that corresponds to the position
64 in external file system is normally _IO_read_end, except in putback
65 mode, when it is _IO_save_end.
66 If the field _fb._offset is >= 0, it gives the offset in
67 the file as a whole corresponding to eGptr(). (?)
70 If a filebuf is in put mode, then all of _IO_read_ptr, _IO_read_end,
71 and _IO_read_base are equal to each other. These are usually equal
72 to _IO_buf_base, though not necessarily if we have switched from
73 get mode to put mode. (The reason is to maintain the invariant
74 that _IO_read_end corresponds to the external file position.)
75 _IO_write_base is non-NULL and usually equal to _IO_base_base.
76 We also have _IO_write_end == _IO_buf_end, but only in fully buffered mode.
77 The un-flushed character are those between _IO_write_base and _IO_write_ptr.
80 If a filebuf is in get or putback mode, eback() != egptr().
81 In get mode, the unread characters are between gptr() and egptr().
82 The OS file position corresponds to that of egptr().
85 Putback mode is used to remember "excess" characters that have
86 been sputbackc'd in a separate putback buffer.
87 In putback mode, the get buffer points to the special putback buffer.
88 The unread characters are the characters between gptr() and egptr()
89 in the putback buffer, as well as the area between save_gptr()
90 and save_egptr(), which point into the original reserve buffer.
91 (The pointers save_gptr() and save_egptr() are the values
92 of gptr() and egptr() at the time putback mode was entered.)
93 The OS position corresponds to that of save_egptr().
96 During line buffered output, _IO_write_base==base() && epptr()==base().
97 However, ptr() may be anywhere between base() and ebuf().
98 This forces a call to filebuf::overflow(int C) on every put.
99 If there is more space in the buffer, and C is not a '\n',
100 then C is inserted, and pptr() incremented.
103 If a filebuf is unbuffered(), the _shortbuf[1] is used as the buffer.
106 #define CLOSED_FILEBUF_FLAGS \
107 (_IO_IS_FILEBUF+_IO_NO_READS+_IO_NO_WRITES+_IO_TIED_PUT_GET)
111 _IO_old_file_init (fp
)
114 /* POSIX.1 allows another file handle to be used to change the position
115 of our file descriptor. Hence we actually don't know the actual
116 position before we do the first fseek (and until a following fflush). */
117 fp
->_old_offset
= _IO_pos_BAD
;
118 fp
->_IO_file_flags
|= CLOSED_FILEBUF_FLAGS
;
121 fp
->_vtable_offset
= ((int) sizeof (struct _IO_FILE
)
122 - (int) sizeof (struct _IO_FILE_complete
));
127 _IO_old_file_close_it (fp
)
130 int write_status
, close_status
;
131 if (!_IO_file_is_open (fp
))
134 write_status
= _IO_old_do_flush (fp
);
136 _IO_unsave_markers(fp
);
138 close_status
= _IO_SYSCLOSE (fp
);
141 _IO_setb (fp
, NULL
, NULL
, 0);
142 _IO_setg (fp
, NULL
, NULL
, NULL
);
143 _IO_setp (fp
, NULL
, NULL
);
146 fp
->_flags
= _IO_MAGIC
|CLOSED_FILEBUF_FLAGS
;
148 fp
->_old_offset
= _IO_pos_BAD
;
150 return close_status
? close_status
: write_status
;
154 _IO_old_file_finish (fp
, dummy
)
158 if (_IO_file_is_open (fp
))
160 _IO_old_do_flush (fp
);
161 if (!(fp
->_flags
& _IO_DELETE_DONT_CLOSE
))
164 _IO_default_finish (fp
, 0);
168 _IO_old_file_fopen (fp
, filename
, mode
)
170 const char *filename
;
173 int oflags
= 0, omode
;
174 int read_write
, fdesc
;
176 if (_IO_file_is_open (fp
))
182 read_write
= _IO_NO_WRITES
;
186 oflags
= O_CREAT
|O_TRUNC
;
187 read_write
= _IO_NO_READS
;
191 oflags
= O_CREAT
|O_APPEND
;
192 read_write
= _IO_NO_READS
|_IO_IS_APPENDING
;
195 __set_errno (EINVAL
);
198 if (mode
[0] == '+' || (mode
[0] == 'b' && mode
[1] == '+'))
201 read_write
&= _IO_IS_APPENDING
;
203 fdesc
= open (filename
, omode
|oflags
, oprot
);
207 _IO_mask_flags (fp
, read_write
,_IO_NO_READS
+_IO_NO_WRITES
+_IO_IS_APPENDING
);
208 if (read_write
& _IO_IS_APPENDING
)
209 if (_IO_SEEKOFF (fp
, (_IO_off_t
)0, _IO_seek_end
, _IOS_INPUT
|_IOS_OUTPUT
)
210 == _IO_pos_BAD
&& errno
!= ESPIPE
)
217 _IO_old_file_attach (fp
, fd
)
221 if (_IO_file_is_open (fp
))
224 fp
->_flags
&= ~(_IO_NO_READS
+_IO_NO_WRITES
);
225 fp
->_flags
|= _IO_DELETE_DONT_CLOSE
;
226 /* Get the current position of the file. */
227 /* We have to do that since that may be junk. */
228 fp
->_old_offset
= _IO_pos_BAD
;
229 if (_IO_SEEKOFF (fp
, (_IO_off_t
)0, _IO_seek_cur
, _IOS_INPUT
|_IOS_OUTPUT
)
230 == _IO_pos_BAD
&& errno
!= ESPIPE
)
236 _IO_old_file_setbuf (fp
, p
, len
)
241 if (_IO_default_setbuf (fp
, p
, len
) == NULL
)
244 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_write_end
246 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
251 static int old_do_write (_IO_FILE
*, const char *, _IO_size_t
) __THROW
;
253 /* Write TO_DO bytes from DATA to FP.
254 Then mark FP as having empty buffers. */
257 _IO_old_do_write (fp
, data
, to_do
)
262 return (to_do
== 0 || old_do_write (fp
, data
, to_do
) == to_do
)
268 old_do_write (fp
, data
, to_do
)
274 if (fp
->_flags
& _IO_IS_APPENDING
)
275 /* On a system without a proper O_APPEND implementation,
276 you would need to sys_seek(0, SEEK_END) here, but is
277 is not needed nor desirable for Unix- or Posix-like systems.
278 Instead, just indicate that offset (before and after) is
280 fp
->_old_offset
= _IO_pos_BAD
;
281 else if (fp
->_IO_read_end
!= fp
->_IO_write_base
)
284 = _IO_SYSSEEK (fp
, fp
->_IO_write_base
- fp
->_IO_read_end
, 1);
285 if (new_pos
== _IO_pos_BAD
)
287 fp
->_old_offset
= new_pos
;
289 count
= _IO_SYSWRITE (fp
, data
, to_do
);
290 if (fp
->_cur_column
&& count
)
291 fp
->_cur_column
= _IO_adjust_column (fp
->_cur_column
- 1, data
, count
) + 1;
292 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
293 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_buf_base
;
294 fp
->_IO_write_end
= ((fp
->_flags
& (_IO_LINE_BUF
+_IO_UNBUFFERED
))
295 ? fp
->_IO_buf_base
: fp
->_IO_buf_end
);
300 _IO_old_file_underflow (fp
)
305 /* SysV does not make this test; take it out for compatibility */
306 if (fp
->_flags
& _IO_EOF_SEEN
)
310 if (fp
->_flags
& _IO_NO_READS
)
315 if (fp
->_IO_read_ptr
< fp
->_IO_read_end
)
316 return *(unsigned char *) fp
->_IO_read_ptr
;
318 if (fp
->_IO_buf_base
== NULL
)
321 /* Flush all line buffered files before reading. */
322 /* FIXME This can/should be moved to genops ?? */
323 if (fp
->_flags
& (_IO_LINE_BUF
|_IO_UNBUFFERED
))
324 _IO_flush_all_linebuffered ();
326 _IO_switch_to_get_mode (fp
);
328 /* This is very tricky. We have to adjust those
329 pointers before we call _IO_SYSREAD () since
330 we may longjump () out while waiting for
331 input. Those pointers may be screwed up. H.J. */
332 fp
->_IO_read_base
= fp
->_IO_read_ptr
= fp
->_IO_buf_base
;
333 fp
->_IO_read_end
= fp
->_IO_buf_base
;
334 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_write_end
337 count
= _IO_SYSREAD (fp
, fp
->_IO_buf_base
,
338 fp
->_IO_buf_end
- fp
->_IO_buf_base
);
342 fp
->_flags
|= _IO_EOF_SEEN
;
344 fp
->_flags
|= _IO_ERR_SEEN
, count
= 0;
346 fp
->_IO_read_end
+= count
;
349 if (fp
->_old_offset
!= _IO_pos_BAD
)
350 _IO_pos_adjust (fp
->_old_offset
, count
);
351 return *(unsigned char *) fp
->_IO_read_ptr
;
355 _IO_old_file_overflow (f
, ch
)
359 if (f
->_flags
& _IO_NO_WRITES
) /* SET ERROR */
361 f
->_flags
|= _IO_ERR_SEEN
;
365 /* If currently reading or no buffer allocated. */
366 if ((f
->_flags
& _IO_CURRENTLY_PUTTING
) == 0)
368 /* Allocate a buffer if needed. */
369 if (f
->_IO_write_base
== 0)
372 _IO_setg (f
, f
->_IO_buf_base
, f
->_IO_buf_base
, f
->_IO_buf_base
);
374 /* Otherwise must be currently reading.
375 If _IO_read_ptr (and hence also _IO_read_end) is at the buffer end,
376 logically slide the buffer forwards one block (by setting the
377 read pointers to all point at the beginning of the block). This
378 makes room for subsequent output.
379 Otherwise, set the read pointers to _IO_read_end (leaving that
380 alone, so it can continue to correspond to the external position). */
381 if (f
->_IO_read_ptr
== f
->_IO_buf_end
)
382 f
->_IO_read_end
= f
->_IO_read_ptr
= f
->_IO_buf_base
;
383 f
->_IO_write_ptr
= f
->_IO_read_ptr
;
384 f
->_IO_write_base
= f
->_IO_write_ptr
;
385 f
->_IO_write_end
= f
->_IO_buf_end
;
386 f
->_IO_read_base
= f
->_IO_read_ptr
= f
->_IO_read_end
;
388 if (f
->_flags
& (_IO_LINE_BUF
+_IO_UNBUFFERED
))
389 f
->_IO_write_end
= f
->_IO_write_ptr
;
390 f
->_flags
|= _IO_CURRENTLY_PUTTING
;
393 return _IO_old_do_flush (f
);
394 if (f
->_IO_write_ptr
== f
->_IO_buf_end
) /* Buffer is really full */
395 if (_IO_old_do_flush (f
) == EOF
)
397 *f
->_IO_write_ptr
++ = ch
;
398 if ((f
->_flags
& _IO_UNBUFFERED
)
399 || ((f
->_flags
& _IO_LINE_BUF
) && ch
== '\n'))
400 if (_IO_old_do_flush (f
) == EOF
)
402 return (unsigned char) ch
;
406 _IO_old_file_sync (fp
)
412 _IO_cleanup_region_start ((void (*) (void *)) _IO_funlockfile
, fp
);
414 /* char* ptr = cur_ptr(); */
415 if (fp
->_IO_write_ptr
> fp
->_IO_write_base
)
416 if (_IO_old_do_flush(fp
)) return EOF
;
417 delta
= fp
->_IO_read_ptr
- fp
->_IO_read_end
;
421 if (_IO_in_backup (fp
))
422 delta
-= eGptr () - Gbase ();
424 _IO_off_t new_pos
= _IO_SYSSEEK (fp
, delta
, 1);
425 if (new_pos
!= (_IO_off_t
) EOF
)
426 fp
->_IO_read_end
= fp
->_IO_read_ptr
;
428 else if (errno
== ESPIPE
)
429 ; /* Ignore error from unseekable devices. */
435 fp
->_old_offset
= _IO_pos_BAD
;
436 /* FIXME: Cleanup - can this be shared? */
437 /* setg(base(), ptr, ptr); */
438 _IO_funlockfile (fp
);
439 _IO_cleanup_region_end (0);
444 _IO_old_file_seekoff (fp
, offset
, dir
, mode
)
451 _IO_off64_t delta
, new_offset
;
453 /* POSIX.1 8.2.3.7 says that after a call the fflush() the file
454 offset of the underlying file must be exact. */
455 int must_be_exact
= (fp
->_IO_read_base
== fp
->_IO_read_end
456 && fp
->_IO_write_base
== fp
->_IO_write_ptr
);
459 dir
= _IO_seek_cur
, offset
= 0; /* Don't move any pointers. */
461 /* Flush unwritten characters.
462 (This may do an unneeded write if we seek within the buffer.
463 But to be able to switch to reading, we would need to set
464 egptr to ptr. That can't be done in the current design,
465 which assumes file_ptr() is eGptr. Anyway, since we probably
466 end up flushing when we close(), it doesn't make much difference.)
467 FIXME: simulate mem-papped files. */
469 if (fp
->_IO_write_ptr
> fp
->_IO_write_base
|| _IO_in_put_mode (fp
))
470 if (_IO_switch_to_get_mode (fp
))
473 if (fp
->_IO_buf_base
== NULL
)
476 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
477 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
483 /* Adjust for read-ahead (bytes is buffer). */
484 offset
-= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
485 if (fp
->_old_offset
== _IO_pos_BAD
)
487 /* Make offset absolute, assuming current pointer is file_ptr(). */
488 offset
+= _IO_pos_as_off (fp
->_old_offset
);
497 if (_IO_SYSSTAT (fp
, &st
) == 0 && S_ISREG (st
.st_mode
))
499 offset
+= st
.st_size
;
506 /* At this point, dir==_IO_seek_set. */
508 /* If destination is within current buffer, optimize: */
509 if (fp
->_old_offset
!= _IO_pos_BAD
&& fp
->_IO_read_base
!= NULL
510 && !_IO_in_backup (fp
))
512 /* Offset relative to start of main get area. */
513 _IO_pos_t rel_offset
= (offset
- fp
->_old_offset
514 + (fp
->_IO_read_end
- fp
->_IO_read_base
));
518 if (_IO_in_backup (fp
))
519 _IO_switch_to_main_get_area (fp
);
521 if (rel_offset
<= fp
->_IO_read_end
- fp
->_IO_read_base
)
523 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
+ rel_offset
,
525 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
529 /* If we have streammarkers, seek forward by reading ahead. */
530 if (_IO_have_markers (fp
))
532 int to_skip
= rel_offset
533 - (fp
->_IO_read_ptr
- fp
->_IO_read_base
);
534 if (ignore (to_skip
) != to_skip
)
541 if (rel_offset
< 0 && rel_offset
>= Bbase () - Bptr ())
543 if (!_IO_in_backup (fp
))
544 _IO_switch_to_backup_area (fp
);
545 gbump (fp
->_IO_read_end
+ rel_offset
- fp
->_IO_read_ptr
);
552 _IO_unsave_markers (fp
);
555 if (fp
->_flags
& _IO_NO_READS
)
558 /* Try to seek to a block boundary, to improve kernel page management. */
559 new_offset
= offset
& ~(fp
->_IO_buf_end
- fp
->_IO_buf_base
- 1);
560 delta
= offset
- new_offset
;
561 if (delta
> fp
->_IO_buf_end
- fp
->_IO_buf_base
)
566 result
= _IO_SYSSEEK (fp
, new_offset
, 0);
573 count
= _IO_SYSREAD (fp
, fp
->_IO_buf_base
,
575 ? delta
: fp
->_IO_buf_end
- fp
->_IO_buf_base
));
578 /* We weren't allowed to read, but try to seek the remainder. */
579 offset
= count
== EOF
? delta
: delta
-count
;
584 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
+ delta
,
585 fp
->_IO_buf_base
+ count
);
586 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
587 fp
->_old_offset
= result
+ count
;
588 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
592 _IO_unsave_markers (fp
);
593 result
= _IO_SYSSEEK (fp
, offset
, dir
);
596 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
597 fp
->_old_offset
= result
;
598 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
599 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
604 /* We need to do it since it is possible that the file offset in
605 the kernel may be changed behind our back. It may happen when
606 we fopen a file and then do a fork. One process may access the
607 the file and the kernel file offset will be changed. */
608 if (fp
->_old_offset
>= 0)
609 _IO_SYSSEEK (fp
, fp
->_old_offset
, 0);
615 _IO_old_file_write (f
, data
, n
)
620 _IO_ssize_t to_do
= n
;
623 _IO_ssize_t count
= write (f
->_fileno
, data
, to_do
);
626 f
->_flags
|= _IO_ERR_SEEN
;
630 data
= (void *) ((char *) data
+ count
);
633 if (f
->_old_offset
>= 0)
639 _IO_old_file_xsputn (f
, data
, n
)
644 register const char *s
= (char *) data
;
645 _IO_size_t to_do
= n
;
651 /* This is an optimized implementation.
652 If the amount to be written straddles a block boundary
653 (or the filebuf is unbuffered), use sys_write directly. */
655 /* First figure out how much space is available in the buffer. */
656 count
= f
->_IO_write_end
- f
->_IO_write_ptr
; /* Space available. */
657 if ((f
->_flags
& _IO_LINE_BUF
) && (f
->_flags
& _IO_CURRENTLY_PUTTING
))
659 count
= f
->_IO_buf_end
- f
->_IO_write_ptr
;
662 register const char *p
;
663 for (p
= s
+ n
; p
> s
; )
674 /* Then fill the buffer. */
681 memcpy (f
->_IO_write_ptr
, s
, count
);
686 register char *p
= f
->_IO_write_ptr
;
687 register int i
= (int) count
;
691 f
->_IO_write_ptr
+= count
;
694 if (to_do
+ must_flush
> 0)
696 _IO_size_t block_size
, do_write
;
697 /* Next flush the (full) buffer. */
698 if (__overflow (f
, EOF
) == EOF
)
701 /* Try to maintain alignment: write a whole number of blocks.
702 dont_write is what gets left over. */
703 block_size
= f
->_IO_buf_end
- f
->_IO_buf_base
;
704 do_write
= to_do
- (block_size
>= 128 ? to_do
% block_size
: 0);
708 count
= old_do_write (f
, s
, do_write
);
710 if (count
< do_write
)
714 /* Now write out the remainder. Normally, this will fit in the
715 buffer, but it's somewhat messier for line-buffered files,
716 so we let _IO_default_xsputn handle the general case. */
718 to_do
-= _IO_default_xsputn (f
, s
+do_write
, to_do
);
724 struct _IO_jump_t _IO_old_file_jumps
=
727 JUMP_INIT(finish
, _IO_old_file_finish
),
728 JUMP_INIT(overflow
, _IO_old_file_overflow
),
729 JUMP_INIT(underflow
, _IO_old_file_underflow
),
730 JUMP_INIT(uflow
, _IO_default_uflow
),
731 JUMP_INIT(pbackfail
, _IO_default_pbackfail
),
732 JUMP_INIT(xsputn
, _IO_old_file_xsputn
),
733 JUMP_INIT(xsgetn
, _IO_default_xsgetn
),
734 JUMP_INIT(seekoff
, _IO_old_file_seekoff
),
735 JUMP_INIT(seekpos
, _IO_default_seekpos
),
736 JUMP_INIT(setbuf
, _IO_old_file_setbuf
),
737 JUMP_INIT(sync
, _IO_old_file_sync
),
738 JUMP_INIT(doallocate
, _IO_file_doallocate
),
739 JUMP_INIT(read
, _IO_file_read
),
740 JUMP_INIT(write
, _IO_old_file_write
),
741 JUMP_INIT(seek
, _IO_file_seek
),
742 JUMP_INIT(close
, _IO_file_close
),
743 JUMP_INIT(stat
, _IO_file_stat
)
747 symbol_version (_IO_old_do_write
, _IO_do_write
, GLIBC_2
.0
);
748 symbol_version (_IO_old_file_attach
, _IO_file_attach
, GLIBC_2
.0
);
749 symbol_version (_IO_old_file_close_it
, _IO_file_close_it
, GLIBC_2
.0
);
750 symbol_version (_IO_old_file_finish
, _IO_file_finish
, GLIBC_2
.0
);
751 symbol_version (_IO_old_file_fopen
, _IO_file_fopen
, GLIBC_2
.0
);
752 symbol_version (_IO_old_file_init
, _IO_file_init
, GLIBC_2
.0
);
753 symbol_version (_IO_old_file_setbuf
, _IO_file_setbuf
, GLIBC_2
.0
);
754 symbol_version (_IO_old_file_sync
, _IO_file_sync
, GLIBC_2
.0
);
755 symbol_version (_IO_old_file_overflow
, _IO_file_overflow
, GLIBC_2
.0
);
756 symbol_version (_IO_old_file_seekoff
, _IO_file_seekoff
, GLIBC_2
.0
);
757 symbol_version (_IO_old_file_underflow
, _IO_file_underflow
, GLIBC_2
.0
);
758 symbol_version (_IO_old_file_write
, _IO_file_write
, GLIBC_2
.0
);
759 symbol_version (_IO_old_file_xsputn
, _IO_file_xsputn
, GLIBC_2
.0
);
761 strong_alias (_IO_old_do_write
, _IO_do_write
);
762 strong_alias (_IO_old_file_attach
, _IO_file_attach
);
763 strong_alias (_IO_old_file_close_it
, _IO_file_close_it
);
764 strong_alias (_IO_old_file_finish
, _IO_file_finish
);
765 strong_alias (_IO_old_file_fopen
, _IO_file_fopen
);
766 strong_alias (_IO_old_file_init
, _IO_file_init
);
767 strong_alias (_IO_old_file_setbuf
, _IO_file_setbuf
);
768 strong_alias (_IO_old_file_sync
, _IO_file_sync
);
769 strong_alias (_IO_old_file_overflow
, _IO_file_overflow
);
770 strong_alias (_IO_old_file_seekoff
, _IO_file_seekoff
);
771 strong_alias (_IO_old_file_underflow
, _IO_file_underflow
);
772 strong_alias (_IO_old_file_write
, _IO_file_write
);
773 strong_alias (_IO_old_file_xsputn
, _IO_file_xsputn
);