1 /* Copyright (C) 1993, 1995, 1997-1999, 2000 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. */
29 # define _POSIX_SOURCE
33 #include <sys/types.h>
41 # include "../wcsmbs/wcsmbsload.h"
42 # include <shlib-compat.h>
48 # define __set_errno(Val) errno = (Val)
53 # define open(Name, Flags, Prot) __open (Name, Flags, Prot)
54 # define close(FD) __close (FD)
55 # define lseek(FD, Offset, Whence) __lseek (FD, Offset, Whence)
56 # define read(FD, Buf, NBytes) __read (FD, Buf, NBytes)
57 # define write(FD, Buf, NBytes) __write (FD, Buf, NBytes)
60 /* An fstream can be in at most one of put mode, get mode, or putback mode.
61 Putback mode is a variant of get mode.
63 In a filebuf, there is only one current position, instead of two
64 separate get and put pointers. In get mode, the current position
65 is that of gptr(); in put mode that of pptr().
67 The position in the buffer that corresponds to the position
68 in external file system is normally _IO_read_end, except in putback
69 mode, when it is _IO_save_end.
70 If the field _fb._offset is >= 0, it gives the offset in
71 the file as a whole corresponding to eGptr(). (?)
74 If a filebuf is in put mode, then all of _IO_read_ptr, _IO_read_end,
75 and _IO_read_base are equal to each other. These are usually equal
76 to _IO_buf_base, though not necessarily if we have switched from
77 get mode to put mode. (The reason is to maintain the invariant
78 that _IO_read_end corresponds to the external file position.)
79 _IO_write_base is non-NULL and usually equal to _IO_base_base.
80 We also have _IO_write_end == _IO_buf_end, but only in fully buffered mode.
81 The un-flushed character are those between _IO_write_base and _IO_write_ptr.
84 If a filebuf is in get or putback mode, eback() != egptr().
85 In get mode, the unread characters are between gptr() and egptr().
86 The OS file position corresponds to that of egptr().
89 Putback mode is used to remember "excess" characters that have
90 been sputbackc'd in a separate putback buffer.
91 In putback mode, the get buffer points to the special putback buffer.
92 The unread characters are the characters between gptr() and egptr()
93 in the putback buffer, as well as the area between save_gptr()
94 and save_egptr(), which point into the original reserve buffer.
95 (The pointers save_gptr() and save_egptr() are the values
96 of gptr() and egptr() at the time putback mode was entered.)
97 The OS position corresponds to that of save_egptr().
100 During line buffered output, _IO_write_base==base() && epptr()==base().
101 However, ptr() may be anywhere between base() and ebuf().
102 This forces a call to filebuf::overflow(int C) on every put.
103 If there is more space in the buffer, and C is not a '\n',
104 then C is inserted, and pptr() incremented.
107 If a filebuf is unbuffered(), the _shortbuf[1] is used as the buffer.
110 #define CLOSED_FILEBUF_FLAGS \
111 (_IO_IS_FILEBUF+_IO_NO_READS+_IO_NO_WRITES+_IO_TIED_PUT_GET)
115 _IO_new_file_init (fp
)
118 /* POSIX.1 allows another file handle to be used to change the position
119 of our file descriptor. Hence we actually don't know the actual
120 position before we do the first fseek (and until a following fflush). */
121 fp
->_offset
= _IO_pos_BAD
;
122 fp
->_IO_file_flags
|= CLOSED_FILEBUF_FLAGS
;
129 _IO_new_file_close_it (fp
)
132 int write_status
, close_status
;
133 if (!_IO_file_is_open (fp
))
136 write_status
= _IO_do_flush (fp
);
138 _IO_unsave_markers(fp
);
140 close_status
= _IO_SYSCLOSE (fp
);
145 _IO_setb (fp
, NULL
, NULL
, 0);
146 _IO_setg (fp
, NULL
, NULL
, NULL
);
147 _IO_setp (fp
, NULL
, NULL
);
151 _IO_wsetb (fp
, NULL
, NULL
, 0);
152 _IO_wsetg (fp
, NULL
, NULL
, NULL
);
153 _IO_wsetp (fp
, NULL
, NULL
);
157 fp
->_flags
= _IO_MAGIC
|CLOSED_FILEBUF_FLAGS
;
159 fp
->_offset
= _IO_pos_BAD
;
161 return close_status
? close_status
: write_status
;
165 _IO_new_file_finish (fp
, dummy
)
169 if (_IO_file_is_open (fp
))
172 if (!(fp
->_flags
& _IO_DELETE_DONT_CLOSE
))
175 _IO_default_finish (fp
, 0);
178 #if defined __GNUC__ && __GNUC__ >= 2
182 _IO_file_open (fp
, filename
, posix_mode
, prot
, read_write
, is32not64
)
184 const char *filename
;
193 ? open (filename
, posix_mode
, prot
)
194 : _G_OPEN64 (filename
, posix_mode
, prot
));
196 fdesc
= open (filename
, posix_mode
, prot
);
201 _IO_mask_flags (fp
, read_write
,_IO_NO_READS
+_IO_NO_WRITES
+_IO_IS_APPENDING
);
202 if (read_write
& _IO_IS_APPENDING
)
203 if (_IO_SEEKOFF (fp
, (_IO_off64_t
)0, _IO_seek_end
, _IOS_INPUT
|_IOS_OUTPUT
)
204 == _IO_pos_BAD
&& errno
!= ESPIPE
)
211 _IO_new_file_fopen (fp
, filename
, mode
, is32not64
)
213 const char *filename
;
217 int oflags
= 0, omode
;
226 if (_IO_file_is_open (fp
))
232 read_write
= _IO_NO_WRITES
;
236 oflags
= O_CREAT
|O_TRUNC
;
237 read_write
= _IO_NO_READS
;
241 oflags
= O_CREAT
|O_APPEND
;
242 read_write
= _IO_NO_READS
|_IO_IS_APPENDING
;
245 __set_errno (EINVAL
);
248 for (i
= 1; i
< 4; ++i
)
256 read_write
&= _IO_IS_APPENDING
;
269 result
= _IO_file_open (fp
, filename
, omode
|oflags
, oprot
, read_write
,
274 /* Test whether the mode string specifies the conversion. */
275 cs
= strstr (mode
, ",ccs=");
278 /* Yep. Load the appropriate conversions and set the orientation
280 struct gconv_fcts fcts
;
281 struct _IO_codecvt
*cc
;
283 if (! _IO_CHECK_WIDE (fp
) || __wcsmbs_named_conv (&fcts
, cs
+ 5) != 0)
285 /* Something went wrong, we cannot load the conversion modules.
286 This means we cannot proceed since the user explicitly asked
288 _IO_new_fclose (result
);
292 cc
= &fp
->_wide_data
->_codecvt
;
294 /* The functions are always the same. */
295 *cc
= __libio_codecvt
;
297 cc
->__cd_in
.__cd
.__nsteps
= 1; /* Only one step allowed. */
298 cc
->__cd_in
.__cd
.__steps
= fcts
.towc
;
300 cc
->__cd_in
.__cd
.__data
[0].__invocation_counter
= 0;
301 cc
->__cd_in
.__cd
.__data
[0].__internal_use
= 1;
302 cc
->__cd_in
.__cd
.__data
[0].__flags
= __GCONV_IS_LAST
;
303 cc
->__cd_in
.__cd
.__data
[0].__statep
= &result
->_wide_data
->_IO_state
;
305 cc
->__cd_out
.__cd
.__nsteps
= 1; /* Only one step allowed. */
306 cc
->__cd_out
.__cd
.__steps
= fcts
.tomb
;
308 cc
->__cd_out
.__cd
.__data
[0].__invocation_counter
= 0;
309 cc
->__cd_out
.__cd
.__data
[0].__internal_use
= 1;
310 cc
->__cd_out
.__cd
.__data
[0].__flags
= __GCONV_IS_LAST
;
311 cc
->__cd_out
.__cd
.__data
[0].__statep
= &result
->_wide_data
->_IO_state
;
313 /* Set the mode now. */
316 #endif /* GNU libc */
322 _IO_new_file_attach (fp
, fd
)
326 if (_IO_file_is_open (fp
))
329 fp
->_flags
&= ~(_IO_NO_READS
+_IO_NO_WRITES
);
330 fp
->_flags
|= _IO_DELETE_DONT_CLOSE
;
331 /* Get the current position of the file. */
332 /* We have to do that since that may be junk. */
333 fp
->_offset
= _IO_pos_BAD
;
334 if (_IO_SEEKOFF (fp
, (_IO_off64_t
)0, _IO_seek_cur
, _IOS_INPUT
|_IOS_OUTPUT
)
335 == _IO_pos_BAD
&& errno
!= ESPIPE
)
341 _IO_new_file_setbuf (fp
, p
, len
)
346 if (_IO_default_setbuf (fp
, p
, len
) == NULL
)
349 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_write_end
351 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
356 static int new_do_write
__P ((_IO_FILE
*, const char *, _IO_size_t
));
358 /* Write TO_DO bytes from DATA to FP.
359 Then mark FP as having empty buffers. */
362 _IO_new_do_write (fp
, data
, to_do
)
367 return (to_do
== 0 || new_do_write (fp
, data
, to_do
) == to_do
)
373 new_do_write (fp
, data
, to_do
)
379 if (fp
->_flags
& _IO_IS_APPENDING
)
380 /* On a system without a proper O_APPEND implementation,
381 you would need to sys_seek(0, SEEK_END) here, but is
382 is not needed nor desirable for Unix- or Posix-like systems.
383 Instead, just indicate that offset (before and after) is
385 fp
->_offset
= _IO_pos_BAD
;
386 else if (fp
->_IO_read_end
!= fp
->_IO_write_base
)
389 = _IO_SYSSEEK (fp
, fp
->_IO_write_base
- fp
->_IO_read_end
, 1);
390 if (new_pos
== _IO_pos_BAD
)
392 fp
->_offset
= new_pos
;
394 count
= _IO_SYSWRITE (fp
, data
, to_do
);
395 if (fp
->_cur_column
&& count
)
396 fp
->_cur_column
= _IO_adjust_column (fp
->_cur_column
- 1, data
, count
) + 1;
397 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
398 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_buf_base
;
399 fp
->_IO_write_end
= (fp
->_mode
< 0
400 && (fp
->_flags
& (_IO_LINE_BUF
+_IO_UNBUFFERED
))
401 ? fp
->_IO_buf_base
: fp
->_IO_buf_end
);
406 _IO_new_file_underflow (fp
)
411 /* SysV does not make this test; take it out for compatibility */
412 if (fp
->_flags
& _IO_EOF_SEEN
)
416 if (fp
->_flags
& _IO_NO_READS
)
418 fp
->_flags
|= _IO_ERR_SEEN
;
422 if (fp
->_IO_read_ptr
< fp
->_IO_read_end
)
423 return *(unsigned char *) fp
->_IO_read_ptr
;
425 if (fp
->_IO_buf_base
== NULL
)
427 /* Maybe we already have a push back pointer. */
428 if (fp
->_IO_save_base
!= NULL
)
430 free (fp
->_IO_save_base
);
431 fp
->_flags
&= ~_IO_IN_BACKUP
;
436 /* Flush all line buffered files before reading. */
437 /* FIXME This can/should be moved to genops ?? */
438 if (fp
->_flags
& (_IO_LINE_BUF
|_IO_UNBUFFERED
))
439 _IO_flush_all_linebuffered ();
441 _IO_switch_to_get_mode (fp
);
443 /* This is very tricky. We have to adjust those
444 pointers before we call _IO_SYSREAD () since
445 we may longjump () out while waiting for
446 input. Those pointers may be screwed up. H.J. */
447 fp
->_IO_read_base
= fp
->_IO_read_ptr
= fp
->_IO_buf_base
;
448 fp
->_IO_read_end
= fp
->_IO_buf_base
;
449 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_write_end
452 count
= _IO_SYSREAD (fp
, fp
->_IO_buf_base
,
453 fp
->_IO_buf_end
- fp
->_IO_buf_base
);
457 fp
->_flags
|= _IO_EOF_SEEN
;
459 fp
->_flags
|= _IO_ERR_SEEN
, count
= 0;
461 fp
->_IO_read_end
+= count
;
464 if (fp
->_offset
!= _IO_pos_BAD
)
465 _IO_pos_adjust (fp
->_offset
, count
);
466 return *(unsigned char *) fp
->_IO_read_ptr
;
470 _IO_new_file_overflow (f
, ch
)
474 if (f
->_flags
& _IO_NO_WRITES
) /* SET ERROR */
476 f
->_flags
|= _IO_ERR_SEEN
;
480 /* If currently reading or no buffer allocated. */
481 if ((f
->_flags
& _IO_CURRENTLY_PUTTING
) == 0 || f
->_IO_write_base
== 0)
483 /* Allocate a buffer if needed. */
484 if (f
->_IO_write_base
== 0)
487 _IO_setg (f
, f
->_IO_buf_base
, f
->_IO_buf_base
, f
->_IO_buf_base
);
489 /* Otherwise must be currently reading.
490 If _IO_read_ptr (and hence also _IO_read_end) is at the buffer end,
491 logically slide the buffer forwards one block (by setting the
492 read pointers to all point at the beginning of the block). This
493 makes room for subsequent output.
494 Otherwise, set the read pointers to _IO_read_end (leaving that
495 alone, so it can continue to correspond to the external position). */
496 if (f
->_IO_read_ptr
== f
->_IO_buf_end
)
497 f
->_IO_read_end
= f
->_IO_read_ptr
= f
->_IO_buf_base
;
498 f
->_IO_write_ptr
= f
->_IO_read_ptr
;
499 f
->_IO_write_base
= f
->_IO_write_ptr
;
500 f
->_IO_write_end
= f
->_IO_buf_end
;
501 f
->_IO_read_base
= f
->_IO_read_ptr
= f
->_IO_read_end
;
503 f
->_flags
|= _IO_CURRENTLY_PUTTING
;
504 if (f
->_mode
< 0 && f
->_flags
& (_IO_LINE_BUF
+_IO_UNBUFFERED
))
505 f
->_IO_write_end
= f
->_IO_write_ptr
;
508 return _IO_new_do_write(f
, f
->_IO_write_base
,
509 f
->_IO_write_ptr
- f
->_IO_write_base
);
510 if (f
->_IO_write_ptr
== f
->_IO_buf_end
) /* Buffer is really full */
511 if (_IO_do_flush (f
) == EOF
)
513 *f
->_IO_write_ptr
++ = ch
;
514 if ((f
->_flags
& _IO_UNBUFFERED
)
515 || ((f
->_flags
& _IO_LINE_BUF
) && ch
== '\n'))
516 if (_IO_new_do_write(f
, f
->_IO_write_base
,
517 f
->_IO_write_ptr
- f
->_IO_write_base
) == EOF
)
519 return (unsigned char) ch
;
523 _IO_new_file_sync (fp
)
529 /* char* ptr = cur_ptr(); */
530 if (fp
->_IO_write_ptr
> fp
->_IO_write_base
)
531 if (_IO_do_flush(fp
)) return EOF
;
532 delta
= fp
->_IO_read_ptr
- fp
->_IO_read_end
;
536 if (_IO_in_backup (fp
))
537 delta
-= eGptr () - Gbase ();
539 _IO_off64_t new_pos
= _IO_SYSSEEK (fp
, delta
, 1);
540 if (new_pos
!= (_IO_off64_t
) EOF
)
541 fp
->_IO_read_end
= fp
->_IO_read_ptr
;
543 else if (errno
== ESPIPE
)
544 ; /* Ignore error from unseekable devices. */
550 fp
->_offset
= _IO_pos_BAD
;
551 /* FIXME: Cleanup - can this be shared? */
552 /* setg(base(), ptr, ptr); */
557 _IO_new_file_seekoff (fp
, offset
, dir
, mode
)
564 _IO_off64_t delta
, new_offset
;
566 /* POSIX.1 8.2.3.7 says that after a call the fflush() the file
567 offset of the underlying file must be exact. */
568 int must_be_exact
= (fp
->_IO_read_base
== fp
->_IO_read_end
569 && fp
->_IO_write_base
== fp
->_IO_write_ptr
);
572 dir
= _IO_seek_cur
, offset
= 0; /* Don't move any pointers. */
574 /* Flush unwritten characters.
575 (This may do an unneeded write if we seek within the buffer.
576 But to be able to switch to reading, we would need to set
577 egptr to ptr. That can't be done in the current design,
578 which assumes file_ptr() is eGptr. Anyway, since we probably
579 end up flushing when we close(), it doesn't make much difference.)
580 FIXME: simulate mem-papped files. */
582 if (fp
->_IO_write_ptr
> fp
->_IO_write_base
|| _IO_in_put_mode (fp
))
583 if (_IO_switch_to_get_mode (fp
))
586 if (fp
->_IO_buf_base
== NULL
)
588 /* It could be that we already have a pushback buffer. */
589 if (fp
->_IO_read_base
!= NULL
)
591 free (fp
->_IO_read_base
);
592 fp
->_flags
&= ~_IO_IN_BACKUP
;
595 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
596 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
602 /* Adjust for read-ahead (bytes is buffer). */
603 offset
-= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
604 if (fp
->_offset
== _IO_pos_BAD
)
606 /* Make offset absolute, assuming current pointer is file_ptr(). */
607 offset
+= fp
->_offset
;
616 if (_IO_SYSSTAT (fp
, &st
) == 0 && S_ISREG (st
.st_mode
))
618 offset
+= st
.st_size
;
625 /* At this point, dir==_IO_seek_set. */
627 /* If we are only interested in the current position we've found it now. */
631 /* If destination is within current buffer, optimize: */
632 if (fp
->_offset
!= _IO_pos_BAD
&& fp
->_IO_read_base
!= NULL
633 && !_IO_in_backup (fp
))
635 /* Offset relative to start of main get area. */
636 _IO_off64_t rel_offset
= (offset
- fp
->_offset
637 + (fp
->_IO_read_end
- fp
->_IO_read_base
));
641 if (_IO_in_backup (fp
))
642 _IO_switch_to_main_get_area (fp
);
644 if (rel_offset
<= fp
->_IO_read_end
- fp
->_IO_read_base
)
646 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
+ rel_offset
,
648 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
650 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
655 /* If we have streammarkers, seek forward by reading ahead. */
656 if (_IO_have_markers (fp
))
658 int to_skip
= rel_offset
659 - (fp
->_IO_read_ptr
- fp
->_IO_read_base
);
660 if (ignore (to_skip
) != to_skip
)
662 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
668 if (rel_offset
< 0 && rel_offset
>= Bbase () - Bptr ())
670 if (!_IO_in_backup (fp
))
671 _IO_switch_to_backup_area (fp
);
672 gbump (fp
->_IO_read_end
+ rel_offset
- fp
->_IO_read_ptr
);
673 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
680 _IO_unsave_markers (fp
);
683 if (fp
->_flags
& _IO_NO_READS
)
686 /* Try to seek to a block boundary, to improve kernel page management. */
687 new_offset
= offset
& ~(fp
->_IO_buf_end
- fp
->_IO_buf_base
- 1);
688 delta
= offset
- new_offset
;
689 if (delta
> fp
->_IO_buf_end
- fp
->_IO_buf_base
)
694 result
= _IO_SYSSEEK (fp
, new_offset
, 0);
701 count
= _IO_SYSREAD (fp
, fp
->_IO_buf_base
,
703 ? delta
: fp
->_IO_buf_end
- fp
->_IO_buf_base
));
706 /* We weren't allowed to read, but try to seek the remainder. */
707 offset
= count
== EOF
? delta
: delta
-count
;
712 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
+ delta
,
713 fp
->_IO_buf_base
+ count
);
714 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
715 fp
->_offset
= result
+ count
;
716 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
720 _IO_unsave_markers (fp
);
721 result
= _IO_SYSSEEK (fp
, offset
, dir
);
724 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
725 fp
->_offset
= result
;
726 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
727 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
732 /* We need to do it since it is possible that the file offset in
733 the kernel may be changed behind our back. It may happen when
734 we fopen a file and then do a fork. One process may access the
735 the file and the kernel file offset will be changed. */
736 if (fp
->_offset
>= 0)
737 _IO_SYSSEEK (fp
, fp
->_offset
, 0);
743 _IO_file_read (fp
, buf
, size
)
748 return read (fp
->_fileno
, buf
, size
);
752 _IO_file_seek (fp
, offset
, dir
)
758 return _G_LSEEK64 (fp
->_fileno
, offset
, dir
);
760 return lseek (fp
->_fileno
, offset
, dir
);
765 _IO_file_stat (fp
, st
)
770 return _G_FSTAT64 (fp
->_fileno
, (struct _G_stat64
*) st
);
772 return fstat (fp
->_fileno
, (struct _G_stat64
*) st
);
780 return close (fp
->_fileno
);
784 _IO_new_file_write (f
, data
, n
)
789 _IO_ssize_t to_do
= n
;
792 _IO_ssize_t count
= write (f
->_fileno
, data
, to_do
);
795 f
->_flags
|= _IO_ERR_SEEN
;
799 data
= (void *) ((char *) data
+ count
);
808 _IO_new_file_xsputn (f
, data
, n
)
813 register const char *s
= (const char *) data
;
814 _IO_size_t to_do
= n
;
820 /* This is an optimized implementation.
821 If the amount to be written straddles a block boundary
822 (or the filebuf is unbuffered), use sys_write directly. */
824 /* First figure out how much space is available in the buffer. */
825 count
= f
->_IO_write_end
- f
->_IO_write_ptr
; /* Space available. */
826 if ((f
->_flags
& _IO_LINE_BUF
) && (f
->_flags
& _IO_CURRENTLY_PUTTING
))
828 count
= f
->_IO_buf_end
- f
->_IO_write_ptr
;
831 register const char *p
;
832 for (p
= s
+ n
; p
> s
; )
843 /* Then fill the buffer. */
851 f
->_IO_write_ptr
= __mempcpy (f
->_IO_write_ptr
, s
, count
);
853 memcpy (f
->_IO_write_ptr
, s
, count
);
854 f
->_IO_write_ptr
+= count
;
860 register char *p
= f
->_IO_write_ptr
;
861 register int i
= (int) count
;
864 f
->_IO_write_ptr
= p
;
868 if (to_do
+ must_flush
> 0)
870 _IO_size_t block_size
, do_write
;
871 /* Next flush the (full) buffer. */
872 if (_IO_OVERFLOW (f
, EOF
) == EOF
)
875 /* Try to maintain alignment: write a whole number of blocks.
876 dont_write is what gets left over. */
877 block_size
= f
->_IO_buf_end
- f
->_IO_buf_base
;
878 do_write
= to_do
- (block_size
>= 128 ? to_do
% block_size
: 0);
882 count
= new_do_write (f
, s
, do_write
);
884 if (count
< do_write
)
888 /* Now write out the remainder. Normally, this will fit in the
889 buffer, but it's somewhat messier for line-buffered files,
890 so we let _IO_default_xsputn handle the general case. */
892 to_do
-= _IO_default_xsputn (f
, s
+do_write
, to_do
);
898 _IO_file_xsgetn (fp
, data
, n
)
903 register _IO_size_t want
, have
;
904 register _IO_ssize_t count
;
905 register char *s
= data
;
909 if (fp
->_IO_buf_base
== NULL
)
911 /* Maybe we already have a push back pointer. */
912 if (fp
->_IO_save_base
!= NULL
)
914 free (fp
->_IO_save_base
);
915 fp
->_flags
&= ~_IO_IN_BACKUP
;
922 have
= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
925 memcpy (s
, fp
->_IO_read_ptr
, want
);
926 fp
->_IO_read_ptr
+= want
;
934 s
= __mempcpy (s
, fp
->_IO_read_ptr
, have
);
936 memcpy (s
, fp
->_IO_read_ptr
, have
);
940 fp
->_IO_read_ptr
+= have
;
943 /* Check for backup and repeat */
944 if (_IO_in_backup (fp
))
946 _IO_switch_to_main_get_area (fp
);
950 /* If we now want less than a buffer, underflow and repeat
951 the copy. Otherwise, _IO_SYSREAD directly to
953 if (fp
->_IO_buf_base
&& want
< fp
->_IO_buf_end
- fp
->_IO_buf_base
)
955 if (__underflow (fp
) == EOF
)
961 /* These must be set before the sysread as we might longjmp out
962 waiting for input. */
963 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
964 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
966 /* Try to maintain alignment: read a whole number of blocks. */
968 if (fp
->_IO_buf_base
)
970 _IO_size_t block_size
= fp
->_IO_buf_end
- fp
->_IO_buf_base
;
971 if (block_size
>= 128)
972 count
-= want
% block_size
;
975 count
= _IO_SYSREAD (fp
, s
, count
);
979 fp
->_flags
|= _IO_EOF_SEEN
;
981 fp
->_flags
|= _IO_ERR_SEEN
;
988 if (fp
->_offset
!= _IO_pos_BAD
)
989 _IO_pos_adjust (fp
->_offset
, count
);
996 struct _IO_jump_t _IO_file_jumps
=
999 JUMP_INIT(finish
, _IO_new_file_finish
),
1000 JUMP_INIT(overflow
, _IO_new_file_overflow
),
1001 JUMP_INIT(underflow
, _IO_new_file_underflow
),
1002 JUMP_INIT(uflow
, _IO_default_uflow
),
1003 JUMP_INIT(pbackfail
, _IO_default_pbackfail
),
1004 JUMP_INIT(xsputn
, _IO_new_file_xsputn
),
1005 JUMP_INIT(xsgetn
, _IO_file_xsgetn
),
1006 JUMP_INIT(seekoff
, _IO_new_file_seekoff
),
1007 JUMP_INIT(seekpos
, _IO_default_seekpos
),
1008 JUMP_INIT(setbuf
, _IO_new_file_setbuf
),
1009 JUMP_INIT(sync
, _IO_new_file_sync
),
1010 JUMP_INIT(doallocate
, _IO_file_doallocate
),
1011 JUMP_INIT(read
, _IO_file_read
),
1012 JUMP_INIT(write
, _IO_new_file_write
),
1013 JUMP_INIT(seek
, _IO_file_seek
),
1014 JUMP_INIT(close
, _IO_file_close
),
1015 JUMP_INIT(stat
, _IO_file_stat
),
1016 JUMP_INIT(showmanyc
, _IO_default_showmanyc
),
1017 JUMP_INIT(imbue
, _IO_default_imbue
)
1020 versioned_symbol (libc
, _IO_new_do_write
, _IO_do_write
, GLIBC_2_1
);
1021 versioned_symbol (libc
, _IO_new_file_attach
, _IO_file_attach
, GLIBC_2_1
);
1022 versioned_symbol (libc
, _IO_new_file_close_it
, _IO_file_close_it
, GLIBC_2_1
);
1023 versioned_symbol (libc
, _IO_new_file_finish
, _IO_file_finish
, GLIBC_2_1
);
1024 versioned_symbol (libc
, _IO_new_file_fopen
, _IO_file_fopen
, GLIBC_2_1
);
1025 versioned_symbol (libc
, _IO_new_file_init
, _IO_file_init
, GLIBC_2_1
);
1026 versioned_symbol (libc
, _IO_new_file_setbuf
, _IO_file_setbuf
, GLIBC_2_1
);
1027 versioned_symbol (libc
, _IO_new_file_sync
, _IO_file_sync
, GLIBC_2_1
);
1028 versioned_symbol (libc
, _IO_new_file_overflow
, _IO_file_overflow
, GLIBC_2_1
);
1029 versioned_symbol (libc
, _IO_new_file_seekoff
, _IO_file_seekoff
, GLIBC_2_1
);
1030 versioned_symbol (libc
, _IO_new_file_underflow
, _IO_file_underflow
, GLIBC_2_1
);
1031 versioned_symbol (libc
, _IO_new_file_write
, _IO_file_write
, GLIBC_2_1
);
1032 versioned_symbol (libc
, _IO_new_file_xsputn
, _IO_file_xsputn
, GLIBC_2_1
);