1 /* Copyright (C) 1993, 1995, 1997-2001, 2002 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3 Written by Per Bothner <bothner@cygnus.com>.
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
10 The GNU C 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 GNU
13 Lesser General Public License for more details.
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, write to the Free
17 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
20 As a special exception, if you link the code in this file with
21 files compiled with a GNU compiler to produce an executable,
22 that does not cause the resulting executable to be covered by
23 the GNU Lesser General Public License. This exception does not
24 however invalidate any other reasons why the executable file
25 might be covered by the GNU Lesser General Public License.
26 This exception applies to code released by its copyright holders
27 in files containing the exception. */
31 # define _POSIX_SOURCE
36 #include <sys/param.h>
37 #include <sys/types.h>
46 # include "../wcsmbs/wcsmbsload.h"
47 # include "../iconv/gconv_charset.h"
48 # include "../iconv/gconv_int.h"
49 # include <shlib-compat.h>
55 # define __set_errno(Val) errno = (Val)
60 # define open(Name, Flags, Prot) __open (Name, Flags, Prot)
61 # define close(FD) __close (FD)
62 # define lseek(FD, Offset, Whence) __lseek (FD, Offset, Whence)
63 # define read(FD, Buf, NBytes) __read (FD, Buf, NBytes)
64 # define write(FD, Buf, NBytes) __write (FD, Buf, NBytes)
66 # define _IO_new_do_write _IO_do_write
67 # define _IO_new_file_attach _IO_file_attach
68 # define _IO_new_file_close_it _IO_file_close_it
69 # define _IO_new_file_finish _IO_file_finish
70 # define _IO_new_file_fopen _IO_file_fopen
71 # define _IO_new_file_init _IO_file_init
72 # define _IO_new_file_setbuf _IO_file_setbuf
73 # define _IO_new_file_sync _IO_file_sync
74 # define _IO_new_file_overflow _IO_file_overflow
75 # define _IO_new_file_seekoff _IO_file_seekoff
76 # define _IO_new_file_underflow _IO_file_underflow
77 # define _IO_new_file_write _IO_file_write
78 # define _IO_new_file_xsputn _IO_file_xsputn
83 extern struct __gconv_trans_data __libio_translit attribute_hidden
;
87 /* An fstream can be in at most one of put mode, get mode, or putback mode.
88 Putback mode is a variant of get mode.
90 In a filebuf, there is only one current position, instead of two
91 separate get and put pointers. In get mode, the current position
92 is that of gptr(); in put mode that of pptr().
94 The position in the buffer that corresponds to the position
95 in external file system is normally _IO_read_end, except in putback
96 mode, when it is _IO_save_end.
97 If the field _fb._offset is >= 0, it gives the offset in
98 the file as a whole corresponding to eGptr(). (?)
101 If a filebuf is in put mode, then all of _IO_read_ptr, _IO_read_end,
102 and _IO_read_base are equal to each other. These are usually equal
103 to _IO_buf_base, though not necessarily if we have switched from
104 get mode to put mode. (The reason is to maintain the invariant
105 that _IO_read_end corresponds to the external file position.)
106 _IO_write_base is non-NULL and usually equal to _IO_base_base.
107 We also have _IO_write_end == _IO_buf_end, but only in fully buffered mode.
108 The un-flushed character are those between _IO_write_base and _IO_write_ptr.
111 If a filebuf is in get or putback mode, eback() != egptr().
112 In get mode, the unread characters are between gptr() and egptr().
113 The OS file position corresponds to that of egptr().
116 Putback mode is used to remember "excess" characters that have
117 been sputbackc'd in a separate putback buffer.
118 In putback mode, the get buffer points to the special putback buffer.
119 The unread characters are the characters between gptr() and egptr()
120 in the putback buffer, as well as the area between save_gptr()
121 and save_egptr(), which point into the original reserve buffer.
122 (The pointers save_gptr() and save_egptr() are the values
123 of gptr() and egptr() at the time putback mode was entered.)
124 The OS position corresponds to that of save_egptr().
126 LINE BUFFERED OUTPUT:
127 During line buffered output, _IO_write_base==base() && epptr()==base().
128 However, ptr() may be anywhere between base() and ebuf().
129 This forces a call to filebuf::overflow(int C) on every put.
130 If there is more space in the buffer, and C is not a '\n',
131 then C is inserted, and pptr() incremented.
134 If a filebuf is unbuffered(), the _shortbuf[1] is used as the buffer.
137 #define CLOSED_FILEBUF_FLAGS \
138 (_IO_IS_FILEBUF+_IO_NO_READS+_IO_NO_WRITES+_IO_TIED_PUT_GET)
142 _IO_new_file_init (fp
)
143 struct _IO_FILE_plus
*fp
;
145 /* POSIX.1 allows another file handle to be used to change the position
146 of our file descriptor. Hence we actually don't know the actual
147 position before we do the first fseek (and until a following fflush). */
148 fp
->file
._offset
= _IO_pos_BAD
;
149 fp
->file
._IO_file_flags
|= CLOSED_FILEBUF_FLAGS
;
151 INTUSE(_IO_link_in
) (fp
);
152 fp
->file
._fileno
= -1;
154 INTDEF2(_IO_new_file_init
, _IO_file_init
)
157 _IO_new_file_close_it (fp
)
160 int write_status
, close_status
;
161 if (!_IO_file_is_open (fp
))
164 if ((fp
->_flags
& _IO_NO_WRITES
) == 0
165 && (fp
->_flags
& _IO_CURRENTLY_PUTTING
) != 0)
166 write_status
= _IO_do_flush (fp
);
170 INTUSE(_IO_unsave_markers
) (fp
);
172 close_status
= _IO_SYSCLOSE (fp
);
177 INTUSE(_IO_setb
) (fp
, NULL
, NULL
, 0);
178 _IO_setg (fp
, NULL
, NULL
, NULL
);
179 _IO_setp (fp
, NULL
, NULL
);
181 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
184 if (_IO_have_wbackup (fp
))
185 INTUSE(_IO_free_wbackup_area
) (fp
);
186 INTUSE(_IO_wsetb
) (fp
, NULL
, NULL
, 0);
187 _IO_wsetg (fp
, NULL
, NULL
, NULL
);
188 _IO_wsetp (fp
, NULL
, NULL
);
192 INTUSE(_IO_un_link
) ((struct _IO_FILE_plus
*) fp
);
193 fp
->_flags
= _IO_MAGIC
|CLOSED_FILEBUF_FLAGS
;
195 fp
->_offset
= _IO_pos_BAD
;
197 return close_status
? close_status
: write_status
;
199 INTDEF2(_IO_new_file_close_it
, _IO_file_close_it
)
202 _IO_new_file_finish (fp
, dummy
)
206 if (_IO_file_is_open (fp
))
209 if (!(fp
->_flags
& _IO_DELETE_DONT_CLOSE
))
212 INTUSE(_IO_default_finish
) (fp
, 0);
214 INTDEF2(_IO_new_file_finish
, _IO_file_finish
)
216 #if defined __GNUC__ && __GNUC__ >= 2
220 _IO_file_open (fp
, filename
, posix_mode
, prot
, read_write
, is32not64
)
222 const char *filename
;
231 ? open (filename
, posix_mode
, prot
)
232 : _G_OPEN64 (filename
, posix_mode
, prot
));
234 fdesc
= open (filename
, posix_mode
, prot
);
239 _IO_mask_flags (fp
, read_write
,_IO_NO_READS
+_IO_NO_WRITES
+_IO_IS_APPENDING
);
240 if (read_write
& _IO_IS_APPENDING
)
241 if (_IO_SEEKOFF (fp
, (_IO_off64_t
)0, _IO_seek_end
, _IOS_INPUT
|_IOS_OUTPUT
)
242 == _IO_pos_BAD
&& errno
!= ESPIPE
)
247 INTUSE(_IO_link_in
) ((struct _IO_FILE_plus
*) fp
);
252 _IO_new_file_fopen (fp
, filename
, mode
, is32not64
)
254 const char *filename
;
258 int oflags
= 0, omode
;
265 const char *last_recognized
;
268 if (_IO_file_is_open (fp
))
274 read_write
= _IO_NO_WRITES
;
278 oflags
= O_CREAT
|O_TRUNC
;
279 read_write
= _IO_NO_READS
;
283 oflags
= O_CREAT
|O_APPEND
;
284 read_write
= _IO_NO_READS
|_IO_IS_APPENDING
;
287 __set_errno (EINVAL
);
291 last_recognized
= mode
;
293 for (i
= 1; i
< 4; ++i
)
301 read_write
&= _IO_IS_APPENDING
;
303 last_recognized
= mode
;
309 last_recognized
= mode
;
314 last_recognized
= mode
;
323 result
= _IO_file_open (fp
, filename
, omode
|oflags
, oprot
, read_write
,
330 /* Test whether the mode string specifies the conversion. */
331 cs
= strstr (last_recognized
+ 1, ",ccs=");
334 /* Yep. Load the appropriate conversions and set the orientation
336 struct gconv_fcts fcts
;
337 struct _IO_codecvt
*cc
;
338 char *endp
= __strchrnul (cs
+ 5, ',');
339 char ccs
[endp
- (cs
+ 5) + 3];
341 *((char *) __mempcpy (ccs
, cs
+ 5, endp
- (cs
+ 5))) = '\0';
344 if (__wcsmbs_named_conv (&fcts
, ccs
[2] == '\0'
345 ? upstr (ccs
, cs
+ 5) : ccs
) != 0)
347 /* Something went wrong, we cannot load the conversion modules.
348 This means we cannot proceed since the user explicitly asked
350 __set_errno (EINVAL
);
354 assert (fcts
.towc_nsteps
== 1);
355 assert (fcts
.tomb_nsteps
== 1);
357 fp
->_wide_data
->_IO_read_ptr
= fp
->_wide_data
->_IO_read_end
;
358 fp
->_wide_data
->_IO_write_ptr
= fp
->_wide_data
->_IO_write_base
;
360 /* Clear the state. We start all over again. */
361 memset (&fp
->_wide_data
->_IO_state
, '\0', sizeof (__mbstate_t
));
362 memset (&fp
->_wide_data
->_IO_last_state
, '\0', sizeof (__mbstate_t
));
364 cc
= fp
->_codecvt
= &fp
->_wide_data
->_codecvt
;
366 /* The functions are always the same. */
367 *cc
= __libio_codecvt
;
369 cc
->__cd_in
.__cd
.__nsteps
= fcts
.towc_nsteps
;
370 cc
->__cd_in
.__cd
.__steps
= fcts
.towc
;
372 cc
->__cd_in
.__cd
.__data
[0].__invocation_counter
= 0;
373 cc
->__cd_in
.__cd
.__data
[0].__internal_use
= 1;
374 cc
->__cd_in
.__cd
.__data
[0].__flags
= __GCONV_IS_LAST
;
375 cc
->__cd_in
.__cd
.__data
[0].__statep
= &result
->_wide_data
->_IO_state
;
377 /* XXX For now no transliteration. */
378 cc
->__cd_in
.__cd
.__data
[0].__trans
= NULL
;
380 cc
->__cd_out
.__cd
.__nsteps
= fcts
.tomb_nsteps
;
381 cc
->__cd_out
.__cd
.__steps
= fcts
.tomb
;
383 cc
->__cd_out
.__cd
.__data
[0].__invocation_counter
= 0;
384 cc
->__cd_out
.__cd
.__data
[0].__internal_use
= 1;
385 cc
->__cd_out
.__cd
.__data
[0].__flags
= __GCONV_IS_LAST
;
386 cc
->__cd_out
.__cd
.__data
[0].__statep
=
387 &result
->_wide_data
->_IO_state
;
389 /* And now the transliteration. */
390 cc
->__cd_out
.__cd
.__data
[0].__trans
= &__libio_translit
;
392 /* Set the mode now. */
395 /* We don't need the step data structure anymore. */
396 __gconv_release_cache (fcts
.towc
, fcts
.towc_nsteps
);
397 __gconv_release_cache (fcts
.tomb
, fcts
.tomb_nsteps
);
400 #endif /* GNU libc */
404 INTDEF2(_IO_new_file_fopen
, _IO_file_fopen
)
407 _IO_new_file_attach (fp
, fd
)
411 if (_IO_file_is_open (fp
))
414 fp
->_flags
&= ~(_IO_NO_READS
+_IO_NO_WRITES
);
415 fp
->_flags
|= _IO_DELETE_DONT_CLOSE
;
416 /* Get the current position of the file. */
417 /* We have to do that since that may be junk. */
418 fp
->_offset
= _IO_pos_BAD
;
419 if (_IO_SEEKOFF (fp
, (_IO_off64_t
)0, _IO_seek_cur
, _IOS_INPUT
|_IOS_OUTPUT
)
420 == _IO_pos_BAD
&& errno
!= ESPIPE
)
424 INTDEF2(_IO_new_file_attach
, _IO_file_attach
)
427 _IO_new_file_setbuf (fp
, p
, len
)
432 if (_IO_default_setbuf (fp
, p
, len
) == NULL
)
435 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_write_end
437 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
441 INTDEF2(_IO_new_file_setbuf
, _IO_file_setbuf
)
443 static int new_do_write
__P ((_IO_FILE
*, const char *, _IO_size_t
));
445 /* Write TO_DO bytes from DATA to FP.
446 Then mark FP as having empty buffers. */
449 _IO_new_do_write (fp
, data
, to_do
)
454 return (to_do
== 0 || new_do_write (fp
, data
, to_do
) == to_do
) ? 0 : EOF
;
456 INTDEF2(_IO_new_do_write
, _IO_do_write
)
460 new_do_write (fp
, data
, to_do
)
466 if (fp
->_flags
& _IO_IS_APPENDING
)
467 /* On a system without a proper O_APPEND implementation,
468 you would need to sys_seek(0, SEEK_END) here, but is
469 is not needed nor desirable for Unix- or Posix-like systems.
470 Instead, just indicate that offset (before and after) is
472 fp
->_offset
= _IO_pos_BAD
;
473 else if (fp
->_IO_read_end
!= fp
->_IO_write_base
)
476 = _IO_SYSSEEK (fp
, fp
->_IO_write_base
- fp
->_IO_read_end
, 1);
477 if (new_pos
== _IO_pos_BAD
)
479 fp
->_offset
= new_pos
;
481 count
= _IO_SYSWRITE (fp
, data
, to_do
);
482 if (fp
->_cur_column
&& count
)
483 fp
->_cur_column
= INTUSE(_IO_adjust_column
) (fp
->_cur_column
- 1, data
,
485 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
486 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_buf_base
;
487 fp
->_IO_write_end
= (fp
->_mode
<= 0
488 && (fp
->_flags
& (_IO_LINE_BUF
+_IO_UNBUFFERED
))
489 ? fp
->_IO_buf_base
: fp
->_IO_buf_end
);
494 _IO_new_file_underflow (fp
)
499 /* SysV does not make this test; take it out for compatibility */
500 if (fp
->_flags
& _IO_EOF_SEEN
)
504 if (fp
->_flags
& _IO_NO_READS
)
506 fp
->_flags
|= _IO_ERR_SEEN
;
510 if (fp
->_IO_read_ptr
< fp
->_IO_read_end
)
511 return *(unsigned char *) fp
->_IO_read_ptr
;
513 if (fp
->_IO_buf_base
== NULL
)
515 /* Maybe we already have a push back pointer. */
516 if (fp
->_IO_save_base
!= NULL
)
518 free (fp
->_IO_save_base
);
519 fp
->_flags
&= ~_IO_IN_BACKUP
;
521 INTUSE(_IO_doallocbuf
) (fp
);
524 /* Flush all line buffered files before reading. */
525 /* FIXME This can/should be moved to genops ?? */
526 if (fp
->_flags
& (_IO_LINE_BUF
|_IO_UNBUFFERED
))
529 INTUSE(_IO_flush_all_linebuffered
) ();
531 /* We used to flush all line-buffered stream. This really isn't
532 required by any standard. My recollection is that
533 traditional Unix systems did this for stdout. stderr better
534 not be line buffered. So we do just that here
535 explicitly. --drepper */
536 _IO_cleanup_region_start ((void (*) __P ((void *))) _IO_funlockfile
,
538 _IO_flockfile (_IO_stdout
);
540 if ((_IO_stdout
->_flags
& (_IO_LINKED
| _IO_NO_WRITES
| _IO_LINE_BUF
))
541 == (_IO_LINKED
| _IO_LINE_BUF
))
542 _IO_OVERFLOW (_IO_stdout
, EOF
);
544 _IO_funlockfile (_IO_stdout
);
545 _IO_cleanup_region_end (0);
549 INTUSE(_IO_switch_to_get_mode
) (fp
);
551 /* This is very tricky. We have to adjust those
552 pointers before we call _IO_SYSREAD () since
553 we may longjump () out while waiting for
554 input. Those pointers may be screwed up. H.J. */
555 fp
->_IO_read_base
= fp
->_IO_read_ptr
= fp
->_IO_buf_base
;
556 fp
->_IO_read_end
= fp
->_IO_buf_base
;
557 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_write_end
560 count
= _IO_SYSREAD (fp
, fp
->_IO_buf_base
,
561 fp
->_IO_buf_end
- fp
->_IO_buf_base
);
565 fp
->_flags
|= _IO_EOF_SEEN
;
567 fp
->_flags
|= _IO_ERR_SEEN
, count
= 0;
569 fp
->_IO_read_end
+= count
;
572 if (fp
->_offset
!= _IO_pos_BAD
)
573 _IO_pos_adjust (fp
->_offset
, count
);
574 return *(unsigned char *) fp
->_IO_read_ptr
;
576 INTDEF2(_IO_new_file_underflow
, _IO_file_underflow
)
578 /* Special callback replacing the underflow callbacks if we mmap the
581 _IO_file_underflow_mmap (_IO_FILE
*fp
)
583 if (fp
->_IO_read_end
< fp
->_IO_buf_end
)
587 _G_LSEEK64 (fp
->_fileno
, fp
->_IO_buf_end
- fp
->_IO_buf_base
,
590 __lseek (fp
->_fileno
, fp
->_IO_buf_end
- fp
->_IO_buf_base
, SEEK_SET
)
592 != fp
->_IO_buf_end
- fp
->_IO_buf_base
)
594 fp
->_flags
|= _IO_ERR_SEEN
;
598 fp
->_offset
= fp
->_IO_buf_end
- fp
->_IO_buf_base
;
599 fp
->_IO_read_end
= fp
->_IO_buf_end
;
600 return *(unsigned char *) fp
->_IO_read_ptr
;
603 fp
->_flags
|= _IO_EOF_SEEN
;
608 _IO_new_file_overflow (f
, ch
)
612 if (f
->_flags
& _IO_NO_WRITES
) /* SET ERROR */
614 f
->_flags
|= _IO_ERR_SEEN
;
618 /* If currently reading or no buffer allocated. */
619 if ((f
->_flags
& _IO_CURRENTLY_PUTTING
) == 0 || f
->_IO_write_base
== 0)
621 /* Allocate a buffer if needed. */
622 if (f
->_IO_write_base
== 0)
624 INTUSE(_IO_doallocbuf
) (f
);
625 _IO_setg (f
, f
->_IO_buf_base
, f
->_IO_buf_base
, f
->_IO_buf_base
);
627 /* Otherwise must be currently reading.
628 If _IO_read_ptr (and hence also _IO_read_end) is at the buffer end,
629 logically slide the buffer forwards one block (by setting the
630 read pointers to all point at the beginning of the block). This
631 makes room for subsequent output.
632 Otherwise, set the read pointers to _IO_read_end (leaving that
633 alone, so it can continue to correspond to the external position). */
634 if (f
->_IO_read_ptr
== f
->_IO_buf_end
)
635 f
->_IO_read_end
= f
->_IO_read_ptr
= f
->_IO_buf_base
;
636 f
->_IO_write_ptr
= f
->_IO_read_ptr
;
637 f
->_IO_write_base
= f
->_IO_write_ptr
;
638 f
->_IO_write_end
= f
->_IO_buf_end
;
639 f
->_IO_read_base
= f
->_IO_read_ptr
= f
->_IO_read_end
;
641 f
->_flags
|= _IO_CURRENTLY_PUTTING
;
642 if (f
->_mode
<= 0 && f
->_flags
& (_IO_LINE_BUF
+_IO_UNBUFFERED
))
643 f
->_IO_write_end
= f
->_IO_write_ptr
;
646 return _IO_new_do_write(f
, f
->_IO_write_base
,
647 f
->_IO_write_ptr
- f
->_IO_write_base
);
648 if (f
->_IO_write_ptr
== f
->_IO_buf_end
) /* Buffer is really full */
649 if (_IO_do_flush (f
) == EOF
)
651 *f
->_IO_write_ptr
++ = ch
;
652 if ((f
->_flags
& _IO_UNBUFFERED
)
653 || ((f
->_flags
& _IO_LINE_BUF
) && ch
== '\n'))
654 if (_IO_new_do_write(f
, f
->_IO_write_base
,
655 f
->_IO_write_ptr
- f
->_IO_write_base
) == EOF
)
657 return (unsigned char) ch
;
659 INTDEF2(_IO_new_file_overflow
, _IO_file_overflow
)
662 _IO_new_file_sync (fp
)
668 /* char* ptr = cur_ptr(); */
669 if (fp
->_IO_write_ptr
> fp
->_IO_write_base
)
670 if (_IO_do_flush(fp
)) return EOF
;
671 delta
= fp
->_IO_read_ptr
- fp
->_IO_read_end
;
675 if (_IO_in_backup (fp
))
676 delta
-= eGptr () - Gbase ();
678 _IO_off64_t new_pos
= _IO_SYSSEEK (fp
, delta
, 1);
679 if (new_pos
!= (_IO_off64_t
) EOF
)
680 fp
->_IO_read_end
= fp
->_IO_read_ptr
;
682 else if (errno
== ESPIPE
)
683 ; /* Ignore error from unseekable devices. */
689 fp
->_offset
= _IO_pos_BAD
;
690 /* FIXME: Cleanup - can this be shared? */
691 /* setg(base(), ptr, ptr); */
694 INTDEF2(_IO_new_file_sync
, _IO_file_sync
)
697 _IO_new_file_seekoff (fp
, offset
, dir
, mode
)
704 _IO_off64_t delta
, new_offset
;
706 /* POSIX.1 8.2.3.7 says that after a call the fflush() the file
707 offset of the underlying file must be exact. */
708 int must_be_exact
= (fp
->_IO_read_base
== fp
->_IO_read_end
709 && fp
->_IO_write_base
== fp
->_IO_write_ptr
);
712 dir
= _IO_seek_cur
, offset
= 0; /* Don't move any pointers. */
714 /* Flush unwritten characters.
715 (This may do an unneeded write if we seek within the buffer.
716 But to be able to switch to reading, we would need to set
717 egptr to ptr. That can't be done in the current design,
718 which assumes file_ptr() is eGptr. Anyway, since we probably
719 end up flushing when we close(), it doesn't make much difference.)
720 FIXME: simulate mem-papped files. */
722 if (fp
->_IO_write_ptr
> fp
->_IO_write_base
|| _IO_in_put_mode (fp
))
723 if (INTUSE(_IO_switch_to_get_mode
) (fp
))
726 if (fp
->_IO_buf_base
== NULL
)
728 /* It could be that we already have a pushback buffer. */
729 if (fp
->_IO_read_base
!= NULL
)
731 free (fp
->_IO_read_base
);
732 fp
->_flags
&= ~_IO_IN_BACKUP
;
734 INTUSE(_IO_doallocbuf
) (fp
);
735 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
736 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
742 /* Adjust for read-ahead (bytes is buffer). */
743 offset
-= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
744 if (fp
->_offset
== _IO_pos_BAD
)
746 /* Make offset absolute, assuming current pointer is file_ptr(). */
747 offset
+= fp
->_offset
;
756 if (_IO_SYSSTAT (fp
, &st
) == 0 && S_ISREG (st
.st_mode
))
758 offset
+= st
.st_size
;
765 /* At this point, dir==_IO_seek_set. */
767 /* If we are only interested in the current position we've found it now. */
771 /* If destination is within current buffer, optimize: */
772 if (fp
->_offset
!= _IO_pos_BAD
&& fp
->_IO_read_base
!= NULL
773 && !_IO_in_backup (fp
))
775 /* Offset relative to start of main get area. */
776 _IO_off64_t rel_offset
= (offset
- fp
->_offset
777 + (fp
->_IO_read_end
- fp
->_IO_read_base
));
781 if (_IO_in_backup (fp
))
782 _IO_switch_to_main_get_area (fp
);
784 if (rel_offset
<= fp
->_IO_read_end
- fp
->_IO_read_base
)
786 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
+ rel_offset
,
788 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
790 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
795 /* If we have streammarkers, seek forward by reading ahead. */
796 if (_IO_have_markers (fp
))
798 int to_skip
= rel_offset
799 - (fp
->_IO_read_ptr
- fp
->_IO_read_base
);
800 if (ignore (to_skip
) != to_skip
)
802 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
808 if (rel_offset
< 0 && rel_offset
>= Bbase () - Bptr ())
810 if (!_IO_in_backup (fp
))
811 _IO_switch_to_backup_area (fp
);
812 gbump (fp
->_IO_read_end
+ rel_offset
- fp
->_IO_read_ptr
);
813 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
820 INTUSE(_IO_unsave_markers
) (fp
);
823 if (fp
->_flags
& _IO_NO_READS
)
826 /* Try to seek to a block boundary, to improve kernel page management. */
827 new_offset
= offset
& ~(fp
->_IO_buf_end
- fp
->_IO_buf_base
- 1);
828 delta
= offset
- new_offset
;
829 if (delta
> fp
->_IO_buf_end
- fp
->_IO_buf_base
)
834 result
= _IO_SYSSEEK (fp
, new_offset
, 0);
841 count
= _IO_SYSREAD (fp
, fp
->_IO_buf_base
,
843 ? delta
: fp
->_IO_buf_end
- fp
->_IO_buf_base
));
846 /* We weren't allowed to read, but try to seek the remainder. */
847 offset
= count
== EOF
? delta
: delta
-count
;
852 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
+ delta
,
853 fp
->_IO_buf_base
+ count
);
854 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
855 fp
->_offset
= result
+ count
;
856 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
860 INTUSE(_IO_unsave_markers
) (fp
);
861 result
= _IO_SYSSEEK (fp
, offset
, dir
);
864 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
865 fp
->_offset
= result
;
866 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
867 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
872 /* We need to do it since it is possible that the file offset in
873 the kernel may be changed behind our back. It may happen when
874 we fopen a file and then do a fork. One process may access the
875 the file and the kernel file offset will be changed. */
876 if (fp
->_offset
>= 0)
877 _IO_SYSSEEK (fp
, fp
->_offset
, 0);
881 INTDEF2(_IO_new_file_seekoff
, _IO_file_seekoff
)
884 _IO_file_seekoff_mmap (fp
, offset
, dir
, mode
)
893 dir
= _IO_seek_cur
, offset
= 0; /* Don't move any pointers. */
898 /* Adjust for read-ahead (bytes is buffer). */
899 offset
+= fp
->_IO_read_ptr
- fp
->_IO_read_base
;
904 offset
+= fp
->_IO_buf_end
- fp
->_IO_buf_base
;
907 /* At this point, dir==_IO_seek_set. */
910 /* No negative offsets are valid. */
913 /* If we are only interested in the current position we've found it now. */
917 result
= _IO_SYSSEEK (fp
, offset
, 0);
921 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
+ offset
,
922 fp
->_IO_buf_base
+ offset
);
924 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
930 _IO_file_read (fp
, buf
, size
)
935 return read (fp
->_fileno
, buf
, size
);
937 INTDEF(_IO_file_read
)
940 _IO_file_seek (fp
, offset
, dir
)
946 return _G_LSEEK64 (fp
->_fileno
, offset
, dir
);
948 return lseek (fp
->_fileno
, offset
, dir
);
951 INTDEF(_IO_file_seek
)
954 _IO_file_stat (fp
, st
)
959 return _G_FSTAT64 (fp
->_fileno
, (struct _G_stat64
*) st
);
961 return fstat (fp
->_fileno
, (struct stat
*) st
);
964 INTDEF(_IO_file_stat
)
967 _IO_file_close_mmap (fp
)
970 /* In addition to closing the file descriptor we have to unmap the
972 (void) munmap (fp
->_IO_buf_base
, fp
->_IO_buf_end
- fp
->_IO_buf_base
);
973 fp
->_IO_buf_base
= fp
->_IO_buf_end
= NULL
;
974 return close (fp
->_fileno
);
981 return close (fp
->_fileno
);
983 INTDEF(_IO_file_close
)
986 _IO_new_file_write (f
, data
, n
)
991 _IO_ssize_t to_do
= n
;
994 _IO_ssize_t count
= write (f
->_fileno
, data
, to_do
);
997 f
->_flags
|= _IO_ERR_SEEN
;
1001 data
= (void *) ((char *) data
+ count
);
1004 if (f
->_offset
>= 0)
1010 _IO_new_file_xsputn (f
, data
, n
)
1015 register const char *s
= (const char *) data
;
1016 _IO_size_t to_do
= n
;
1022 /* This is an optimized implementation.
1023 If the amount to be written straddles a block boundary
1024 (or the filebuf is unbuffered), use sys_write directly. */
1026 /* First figure out how much space is available in the buffer. */
1027 count
= f
->_IO_write_end
- f
->_IO_write_ptr
; /* Space available. */
1028 if ((f
->_flags
& _IO_LINE_BUF
) && (f
->_flags
& _IO_CURRENTLY_PUTTING
))
1030 count
= f
->_IO_buf_end
- f
->_IO_write_ptr
;
1033 register const char *p
;
1034 for (p
= s
+ n
; p
> s
; )
1045 /* Then fill the buffer. */
1053 f
->_IO_write_ptr
= __mempcpy (f
->_IO_write_ptr
, s
, count
);
1055 memcpy (f
->_IO_write_ptr
, s
, count
);
1056 f
->_IO_write_ptr
+= count
;
1062 register char *p
= f
->_IO_write_ptr
;
1063 register int i
= (int) count
;
1066 f
->_IO_write_ptr
= p
;
1070 if (to_do
+ must_flush
> 0)
1072 _IO_size_t block_size
, do_write
;
1073 /* Next flush the (full) buffer. */
1074 if (_IO_OVERFLOW (f
, EOF
) == EOF
)
1077 /* Try to maintain alignment: write a whole number of blocks.
1078 dont_write is what gets left over. */
1079 block_size
= f
->_IO_buf_end
- f
->_IO_buf_base
;
1080 do_write
= to_do
- (block_size
>= 128 ? to_do
% block_size
: 0);
1084 count
= new_do_write (f
, s
, do_write
);
1086 if (count
< do_write
)
1090 /* Now write out the remainder. Normally, this will fit in the
1091 buffer, but it's somewhat messier for line-buffered files,
1092 so we let _IO_default_xsputn handle the general case. */
1094 to_do
-= INTUSE(_IO_default_xsputn
) (f
, s
+do_write
, to_do
);
1098 INTDEF2(_IO_new_file_xsputn
, _IO_file_xsputn
)
1101 _IO_file_xsgetn (fp
, data
, n
)
1106 register _IO_size_t want
, have
;
1107 register _IO_ssize_t count
;
1108 register char *s
= data
;
1112 if (fp
->_IO_buf_base
== NULL
)
1114 /* Maybe we already have a push back pointer. */
1115 if (fp
->_IO_save_base
!= NULL
)
1117 free (fp
->_IO_save_base
);
1118 fp
->_flags
&= ~_IO_IN_BACKUP
;
1120 INTUSE(_IO_doallocbuf
) (fp
);
1125 have
= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
1128 memcpy (s
, fp
->_IO_read_ptr
, want
);
1129 fp
->_IO_read_ptr
+= want
;
1137 s
= __mempcpy (s
, fp
->_IO_read_ptr
, have
);
1139 memcpy (s
, fp
->_IO_read_ptr
, have
);
1143 fp
->_IO_read_ptr
+= have
;
1146 /* Check for backup and repeat */
1147 if (_IO_in_backup (fp
))
1149 _IO_switch_to_main_get_area (fp
);
1153 /* If we now want less than a buffer, underflow and repeat
1154 the copy. Otherwise, _IO_SYSREAD directly to
1156 if (fp
->_IO_buf_base
&& want
< fp
->_IO_buf_end
- fp
->_IO_buf_base
)
1158 if (__underflow (fp
) == EOF
)
1164 /* These must be set before the sysread as we might longjmp out
1165 waiting for input. */
1166 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
1167 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
1169 /* Try to maintain alignment: read a whole number of blocks. */
1171 if (fp
->_IO_buf_base
)
1173 _IO_size_t block_size
= fp
->_IO_buf_end
- fp
->_IO_buf_base
;
1174 if (block_size
>= 128)
1175 count
-= want
% block_size
;
1178 count
= _IO_SYSREAD (fp
, s
, count
);
1182 fp
->_flags
|= _IO_EOF_SEEN
;
1184 fp
->_flags
|= _IO_ERR_SEEN
;
1191 if (fp
->_offset
!= _IO_pos_BAD
)
1192 _IO_pos_adjust (fp
->_offset
, count
);
1198 INTDEF(_IO_file_xsgetn
)
1200 static _IO_size_t _IO_file_xsgetn_mmap
__P ((_IO_FILE
*, void *, _IO_size_t
));
1202 _IO_file_xsgetn_mmap (fp
, data
, n
)
1207 register _IO_size_t have
;
1208 char *read_ptr
= fp
->_IO_read_ptr
;
1209 register char *s
= (char *) data
;
1211 have
= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
1215 if (__builtin_expect (_IO_in_backup (fp
), 0))
1218 s
= __mempcpy (s
, read_ptr
, have
);
1220 memcpy (s
, read_ptr
, have
);
1224 _IO_switch_to_main_get_area (fp
);
1225 read_ptr
= fp
->_IO_read_ptr
;
1226 have
= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
1231 /* Maybe the read buffer is not yet fully set up. */
1232 fp
->_IO_read_ptr
= fp
->_IO_read_end
;
1233 if (fp
->_IO_read_end
< fp
->_IO_buf_end
1234 && _IO_file_underflow_mmap (fp
) != EOF
)
1235 have
= fp
->_IO_read_end
- read_ptr
;
1241 if (s
== (char *) data
)
1242 fp
->_flags
|= _IO_EOF_SEEN
;
1246 have
= MIN (have
, n
);
1248 s
= __mempcpy (s
, read_ptr
, have
);
1250 memcpy (s
, read_ptr
, have
);
1253 fp
->_IO_read_ptr
= read_ptr
+ have
;
1256 return s
- (char *) data
;
1259 struct _IO_jump_t _IO_file_jumps
=
1262 JUMP_INIT(finish
, INTUSE(_IO_file_finish
)),
1263 JUMP_INIT(overflow
, INTUSE(_IO_file_overflow
)),
1264 JUMP_INIT(underflow
, INTUSE(_IO_file_underflow
)),
1265 JUMP_INIT(uflow
, INTUSE(_IO_default_uflow
)),
1266 JUMP_INIT(pbackfail
, INTUSE(_IO_default_pbackfail
)),
1267 JUMP_INIT(xsputn
, INTUSE(_IO_file_xsputn
)),
1268 JUMP_INIT(xsgetn
, INTUSE(_IO_file_xsgetn
)),
1269 JUMP_INIT(seekoff
, _IO_new_file_seekoff
),
1270 JUMP_INIT(seekpos
, _IO_default_seekpos
),
1271 JUMP_INIT(setbuf
, _IO_new_file_setbuf
),
1272 JUMP_INIT(sync
, _IO_new_file_sync
),
1273 JUMP_INIT(doallocate
, INTUSE(_IO_file_doallocate
)),
1274 JUMP_INIT(read
, INTUSE(_IO_file_read
)),
1275 JUMP_INIT(write
, _IO_new_file_write
),
1276 JUMP_INIT(seek
, INTUSE(_IO_file_seek
)),
1277 JUMP_INIT(close
, INTUSE(_IO_file_close
)),
1278 JUMP_INIT(stat
, INTUSE(_IO_file_stat
)),
1279 JUMP_INIT(showmanyc
, _IO_default_showmanyc
),
1280 JUMP_INIT(imbue
, _IO_default_imbue
)
1282 INTVARDEF(_IO_file_jumps
)
1284 struct _IO_jump_t _IO_file_jumps_mmap
=
1287 JUMP_INIT(finish
, INTUSE(_IO_file_finish
)),
1288 JUMP_INIT(overflow
, INTUSE(_IO_file_overflow
)),
1289 JUMP_INIT(underflow
, _IO_file_underflow_mmap
),
1290 JUMP_INIT(uflow
, INTUSE(_IO_default_uflow
)),
1291 JUMP_INIT(pbackfail
, INTUSE(_IO_default_pbackfail
)),
1292 JUMP_INIT(xsputn
, _IO_new_file_xsputn
),
1293 JUMP_INIT(xsgetn
, _IO_file_xsgetn_mmap
),
1294 JUMP_INIT(seekoff
, _IO_file_seekoff_mmap
),
1295 JUMP_INIT(seekpos
, _IO_default_seekpos
),
1296 JUMP_INIT(setbuf
, _IO_new_file_setbuf
),
1297 JUMP_INIT(sync
, _IO_new_file_sync
),
1298 JUMP_INIT(doallocate
, INTUSE(_IO_file_doallocate
)),
1299 JUMP_INIT(read
, INTUSE(_IO_file_read
)),
1300 JUMP_INIT(write
, _IO_new_file_write
),
1301 JUMP_INIT(seek
, INTUSE(_IO_file_seek
)),
1302 JUMP_INIT(close
, _IO_file_close_mmap
),
1303 JUMP_INIT(stat
, INTUSE(_IO_file_stat
)),
1304 JUMP_INIT(showmanyc
, _IO_default_showmanyc
),
1305 JUMP_INIT(imbue
, _IO_default_imbue
)
1309 versioned_symbol (libc
, _IO_new_do_write
, _IO_do_write
, GLIBC_2_1
);
1310 versioned_symbol (libc
, _IO_new_file_attach
, _IO_file_attach
, GLIBC_2_1
);
1311 versioned_symbol (libc
, _IO_new_file_close_it
, _IO_file_close_it
, GLIBC_2_1
);
1312 versioned_symbol (libc
, _IO_new_file_finish
, _IO_file_finish
, GLIBC_2_1
);
1313 versioned_symbol (libc
, _IO_new_file_fopen
, _IO_file_fopen
, GLIBC_2_1
);
1314 versioned_symbol (libc
, _IO_new_file_init
, _IO_file_init
, GLIBC_2_1
);
1315 versioned_symbol (libc
, _IO_new_file_setbuf
, _IO_file_setbuf
, GLIBC_2_1
);
1316 versioned_symbol (libc
, _IO_new_file_sync
, _IO_file_sync
, GLIBC_2_1
);
1317 versioned_symbol (libc
, _IO_new_file_overflow
, _IO_file_overflow
, GLIBC_2_1
);
1318 versioned_symbol (libc
, _IO_new_file_seekoff
, _IO_file_seekoff
, GLIBC_2_1
);
1319 versioned_symbol (libc
, _IO_new_file_underflow
, _IO_file_underflow
, GLIBC_2_1
);
1320 versioned_symbol (libc
, _IO_new_file_write
, _IO_file_write
, GLIBC_2_1
);
1321 versioned_symbol (libc
, _IO_new_file_xsputn
, _IO_file_xsputn
, GLIBC_2_1
);