1 /* Copyright (C) 1993, 1995, 1997 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 # define __set_errno(Val) errno = (Val)
46 # define open(Name, Flags, Prot) __open (Name, Flags, Prot)
47 # define close(FD) __close (FD)
48 # define lseek(FD, Offset, Whence) __lseek (FD, Offset, Whence)
49 # define read(FD, Buf, NBytes) __read (FD, Buf, NBytes)
50 # define write(FD, Buf, NBytes) __write (FD, Buf, NBytes)
53 /* An fstream can be in at most one of put mode, get mode, or putback mode.
54 Putback mode is a variant of get mode.
56 In a filebuf, there is only one current position, instead of two
57 separate get and put pointers. In get mode, the current position
58 is that of gptr(); in put mode that of pptr().
60 The position in the buffer that corresponds to the position
61 in external file system is normally _IO_read_end, except in putback
62 mode, when it is _IO_save_end.
63 If the field _fb._offset is >= 0, it gives the offset in
64 the file as a whole corresponding to eGptr(). (?)
67 If a filebuf is in put mode, then all of _IO_read_ptr, _IO_read_end,
68 and _IO_read_base are equal to each other. These are usually equal
69 to _IO_buf_base, though not necessarily if we have switched from
70 get mode to put mode. (The reason is to maintain the invariant
71 that _IO_read_end corresponds to the external file position.)
72 _IO_write_base is non-NULL and usually equal to _IO_base_base.
73 We also have _IO_write_end == _IO_buf_end, but only in fully buffered mode.
74 The un-flushed character are those between _IO_write_base and _IO_write_ptr.
77 If a filebuf is in get or putback mode, eback() != egptr().
78 In get mode, the unread characters are between gptr() and egptr().
79 The OS file position corresponds to that of egptr().
82 Putback mode is used to remember "excess" characters that have
83 been sputbackc'd in a separate putback buffer.
84 In putback mode, the get buffer points to the special putback buffer.
85 The unread characters are the characters between gptr() and egptr()
86 in the putback buffer, as well as the area between save_gptr()
87 and save_egptr(), which point into the original reserve buffer.
88 (The pointers save_gptr() and save_egptr() are the values
89 of gptr() and egptr() at the time putback mode was entered.)
90 The OS position corresponds to that of save_egptr().
93 During line buffered output, _IO_write_base==base() && epptr()==base().
94 However, ptr() may be anywhere between base() and ebuf().
95 This forces a call to filebuf::overflow(int C) on every put.
96 If there is more space in the buffer, and C is not a '\n',
97 then C is inserted, and pptr() incremented.
100 If a filebuf is unbuffered(), the _shortbuf[1] is used as the buffer.
103 #define CLOSED_FILEBUF_FLAGS \
104 (_IO_IS_FILEBUF+_IO_NO_READS+_IO_NO_WRITES+_IO_TIED_PUT_GET)
111 /* POSIX.1 allows another file handle to be used to change the position
112 of our file descriptor. Hence we actually don't know the actual
113 position before we do the first fseek (and until a following fflush). */
114 fp
->_offset
= _IO_pos_BAD
;
115 fp
->_IO_file_flags
|= CLOSED_FILEBUF_FLAGS
;
122 _IO_file_close_it (fp
)
125 int write_status
, close_status
;
126 if (!_IO_file_is_open (fp
))
129 write_status
= _IO_do_flush (fp
);
131 _IO_unsave_markers(fp
);
133 close_status
= _IO_SYSCLOSE (fp
);
136 _IO_setb (fp
, NULL
, NULL
, 0);
137 _IO_setg (fp
, NULL
, NULL
, NULL
);
138 _IO_setp (fp
, NULL
, NULL
);
141 fp
->_flags
= _IO_MAGIC
|CLOSED_FILEBUF_FLAGS
;
143 fp
->_offset
= _IO_pos_BAD
;
145 return close_status
? close_status
: write_status
;
149 _IO_file_finish (fp
, dummy
)
153 if (_IO_file_is_open (fp
))
156 if (!(fp
->_flags
& _IO_DELETE_DONT_CLOSE
))
159 _IO_default_finish (fp
, 0);
162 #if defined __GNUC__ && __GNUC__ >= 2
166 _IO_file_open (fp
, filename
, posix_mode
, prot
, read_write
, is32not64
)
168 const char *filename
;
177 ? open (filename
, posix_mode
, prot
)
178 : _G_OPEN64 (filename
, posix_mode
, prot
));
180 fdesc
= open (filename
, posix_mode
, prot
);
185 _IO_mask_flags (fp
, read_write
,_IO_NO_READS
+_IO_NO_WRITES
+_IO_IS_APPENDING
);
186 if (read_write
& _IO_IS_APPENDING
)
187 if (_IO_SEEKOFF (fp
, (_IO_off64_t
)0, _IO_seek_end
, _IOS_INPUT
|_IOS_OUTPUT
)
188 == _IO_pos_BAD
&& errno
!= ESPIPE
)
195 _IO_file_fopen (fp
, filename
, mode
, is32not64
)
197 const char *filename
;
201 int oflags
= 0, omode
;
204 if (_IO_file_is_open (fp
))
210 read_write
= _IO_NO_WRITES
;
214 oflags
= O_CREAT
|O_TRUNC
;
215 read_write
= _IO_NO_READS
;
219 oflags
= O_CREAT
|O_APPEND
;
220 read_write
= _IO_NO_READS
|_IO_IS_APPENDING
;
223 __set_errno (EINVAL
);
226 if (mode
[0] == '+' || (mode
[0] == 'b' && mode
[1] == '+'))
229 read_write
&= _IO_IS_APPENDING
;
231 return _IO_file_open (fp
, filename
, omode
|oflags
, oprot
, read_write
,
236 _IO_file_attach (fp
, fd
)
240 if (_IO_file_is_open (fp
))
243 fp
->_flags
&= ~(_IO_NO_READS
+_IO_NO_WRITES
);
244 fp
->_flags
|= _IO_DELETE_DONT_CLOSE
;
245 /* Get the current position of the file. */
246 /* We have to do that since that may be junk. */
247 fp
->_offset
= _IO_pos_BAD
;
248 if (_IO_SEEKOFF (fp
, (_IO_off64_t
)0, _IO_seek_cur
, _IOS_INPUT
|_IOS_OUTPUT
)
249 == _IO_pos_BAD
&& errno
!= ESPIPE
)
255 _IO_file_setbuf (fp
, p
, len
)
260 if (_IO_default_setbuf (fp
, p
, len
) == NULL
)
263 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_write_end
265 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
270 /* Write TO_DO bytes from DATA to FP.
271 Then mark FP as having empty buffers. */
274 _IO_do_write (fp
, data
, to_do
)
282 if (fp
->_flags
& _IO_IS_APPENDING
)
283 /* On a system without a proper O_APPEND implementation,
284 you would need to sys_seek(0, SEEK_END) here, but is
285 is not needed nor desirable for Unix- or Posix-like systems.
286 Instead, just indicate that offset (before and after) is
288 fp
->_offset
= _IO_pos_BAD
;
289 else if (fp
->_IO_read_end
!= fp
->_IO_write_base
)
292 = _IO_SYSSEEK (fp
, fp
->_IO_write_base
- fp
->_IO_read_end
, 1);
293 if (new_pos
== _IO_pos_BAD
)
295 fp
->_offset
= new_pos
;
297 count
= _IO_SYSWRITE (fp
, data
, to_do
);
299 fp
->_cur_column
= _IO_adjust_column (fp
->_cur_column
- 1, data
, to_do
) + 1;
300 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
301 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_buf_base
;
302 fp
->_IO_write_end
= ((fp
->_flags
& (_IO_LINE_BUF
+_IO_UNBUFFERED
))
303 ? fp
->_IO_buf_base
: fp
->_IO_buf_end
);
304 return count
!= to_do
? EOF
: 0;
308 _IO_file_underflow (fp
)
313 /* SysV does not make this test; take it out for compatibility */
314 if (fp
->_flags
& _IO_EOF_SEEN
)
318 if (fp
->_flags
& _IO_NO_READS
)
323 if (fp
->_IO_read_ptr
< fp
->_IO_read_end
)
324 return *(unsigned char *) fp
->_IO_read_ptr
;
326 if (fp
->_IO_buf_base
== NULL
)
329 /* Flush all line buffered files before reading. */
330 /* FIXME This can/should be moved to genops ?? */
331 if (fp
->_flags
& (_IO_LINE_BUF
|_IO_UNBUFFERED
))
332 _IO_flush_all_linebuffered ();
334 _IO_switch_to_get_mode (fp
);
336 /* This is very tricky. We have to adjust those
337 pointers before we call _IO_SYSREAD () since
338 we may longjump () out while waiting for
339 input. Those pointers may be screwed up. H.J. */
340 fp
->_IO_read_base
= fp
->_IO_read_ptr
= fp
->_IO_buf_base
;
341 fp
->_IO_read_end
= fp
->_IO_buf_base
;
342 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_write_end
345 count
= _IO_SYSREAD (fp
, fp
->_IO_buf_base
,
346 fp
->_IO_buf_end
- fp
->_IO_buf_base
);
350 fp
->_flags
|= _IO_EOF_SEEN
;
352 fp
->_flags
|= _IO_ERR_SEEN
, count
= 0;
354 fp
->_IO_read_end
+= count
;
357 if (fp
->_offset
!= _IO_pos_BAD
)
358 _IO_pos_adjust (fp
->_offset
, count
);
359 return *(unsigned char *) fp
->_IO_read_ptr
;
363 _IO_file_overflow (f
, ch
)
367 if (f
->_flags
& _IO_NO_WRITES
) /* SET ERROR */
369 f
->_flags
|= _IO_ERR_SEEN
;
373 /* If currently reading or no buffer allocated. */
374 if ((f
->_flags
& _IO_CURRENTLY_PUTTING
) == 0)
376 /* Allocate a buffer if needed. */
377 if (f
->_IO_write_base
== 0)
380 _IO_setg (f
, f
->_IO_buf_base
, f
->_IO_buf_base
, f
->_IO_buf_base
);
382 /* Otherwise must be currently reading.
383 If _IO_read_ptr (and hence also _IO_read_end) is at the buffer end,
384 logically slide the buffer forwards one block (by setting the
385 read pointers to all point at the beginning of the block). This
386 makes room for subsequent output.
387 Otherwise, set the read pointers to _IO_read_end (leaving that
388 alone, so it can continue to correspond to the external position). */
389 if (f
->_IO_read_ptr
== f
->_IO_buf_end
)
390 f
->_IO_read_end
= f
->_IO_read_ptr
= f
->_IO_buf_base
;
391 f
->_IO_write_ptr
= f
->_IO_read_ptr
;
392 f
->_IO_write_base
= f
->_IO_write_ptr
;
393 f
->_IO_write_end
= f
->_IO_buf_end
;
394 f
->_IO_read_base
= f
->_IO_read_ptr
= f
->_IO_read_end
;
396 if (f
->_flags
& (_IO_LINE_BUF
+_IO_UNBUFFERED
))
397 f
->_IO_write_end
= f
->_IO_write_ptr
;
398 f
->_flags
|= _IO_CURRENTLY_PUTTING
;
401 return _IO_do_flush (f
);
402 if (f
->_IO_write_ptr
== f
->_IO_buf_end
) /* Buffer is really full */
403 if (_IO_do_flush (f
) == EOF
)
405 *f
->_IO_write_ptr
++ = ch
;
406 if ((f
->_flags
& _IO_UNBUFFERED
)
407 || ((f
->_flags
& _IO_LINE_BUF
) && ch
== '\n'))
408 if (_IO_do_flush (f
) == EOF
)
410 return (unsigned char) ch
;
420 _IO_cleanup_region_start ((void (*) __P ((void *))) _IO_funlockfile
, fp
);
422 /* char* ptr = cur_ptr(); */
423 if (fp
->_IO_write_ptr
> fp
->_IO_write_base
)
424 if (_IO_do_flush(fp
)) return EOF
;
425 delta
= fp
->_IO_read_ptr
- fp
->_IO_read_end
;
429 if (_IO_in_backup (fp
))
430 delta
-= eGptr () - Gbase ();
432 _IO_off64_t new_pos
= _IO_SYSSEEK (fp
, delta
, 1);
433 if (new_pos
!= (_IO_off64_t
) EOF
)
434 fp
->_IO_read_end
= fp
->_IO_read_ptr
;
436 else if (errno
== ESPIPE
)
437 ; /* Ignore error from unseekable devices. */
443 fp
->_offset
= _IO_pos_BAD
;
444 /* FIXME: Cleanup - can this be shared? */
445 /* setg(base(), ptr, ptr); */
446 _IO_cleanup_region_end (1);
451 _IO_file_seekoff (fp
, offset
, dir
, mode
)
458 _IO_off64_t delta
, new_offset
;
460 /* POSIX.1 8.2.3.7 says that after a call the fflush() the file
461 offset of the underlying file must be exact. */
462 int must_be_exact
= (fp
->_IO_read_base
== fp
->_IO_read_end
463 && fp
->_IO_write_base
== fp
->_IO_write_ptr
);
466 dir
= _IO_seek_cur
, offset
= 0; /* Don't move any pointers. */
468 /* Flush unwritten characters.
469 (This may do an unneeded write if we seek within the buffer.
470 But to be able to switch to reading, we would need to set
471 egptr to ptr. That can't be done in the current design,
472 which assumes file_ptr() is eGptr. Anyway, since we probably
473 end up flushing when we close(), it doesn't make much difference.)
474 FIXME: simulate mem-papped files. */
476 if (fp
->_IO_write_ptr
> fp
->_IO_write_base
|| _IO_in_put_mode (fp
))
477 if (_IO_switch_to_get_mode (fp
))
480 if (fp
->_IO_buf_base
== NULL
)
483 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
484 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
490 /* Adjust for read-ahead (bytes is buffer). */
491 offset
-= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
492 if (fp
->_offset
== _IO_pos_BAD
)
494 /* Make offset absolute, assuming current pointer is file_ptr(). */
495 offset
+= _IO_pos_as_off (fp
->_offset
);
504 if (_IO_SYSSTAT (fp
, &st
) == 0 && S_ISREG (st
.st_mode
))
506 offset
+= st
.st_size
;
513 /* At this point, dir==_IO_seek_set. */
515 /* If destination is within current buffer, optimize: */
516 if (fp
->_offset
!= _IO_pos_BAD
&& fp
->_IO_read_base
!= NULL
517 && !_IO_in_backup (fp
))
519 /* Offset relative to start of main get area. */
520 _IO_fpos64_t rel_offset
= (offset
- fp
->_offset
521 + (fp
->_IO_read_end
- fp
->_IO_read_base
));
525 if (_IO_in_backup (fp
))
526 _IO_switch_to_main_get_area (fp
);
528 if (rel_offset
<= fp
->_IO_read_end
- fp
->_IO_read_base
)
530 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
+ rel_offset
,
532 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
536 /* If we have streammarkers, seek forward by reading ahead. */
537 if (_IO_have_markers (fp
))
539 int to_skip
= rel_offset
540 - (fp
->_IO_read_ptr
- fp
->_IO_read_base
);
541 if (ignore (to_skip
) != to_skip
)
548 if (rel_offset
< 0 && rel_offset
>= Bbase () - Bptr ())
550 if (!_IO_in_backup (fp
))
551 _IO_switch_to_backup_area (fp
);
552 gbump (fp
->_IO_read_end
+ rel_offset
- fp
->_IO_read_ptr
);
559 _IO_unsave_markers (fp
);
562 if (fp
->_flags
& _IO_NO_READS
)
565 /* Try to seek to a block boundary, to improve kernel page management. */
566 new_offset
= offset
& ~(fp
->_IO_buf_end
- fp
->_IO_buf_base
- 1);
567 delta
= offset
- new_offset
;
568 if (delta
> fp
->_IO_buf_end
- fp
->_IO_buf_base
)
573 result
= _IO_SYSSEEK (fp
, new_offset
, 0);
580 count
= _IO_SYSREAD (fp
, fp
->_IO_buf_base
,
582 ? delta
: fp
->_IO_buf_end
- fp
->_IO_buf_base
));
585 /* We weren't allowed to read, but try to seek the remainder. */
586 offset
= count
== EOF
? delta
: delta
-count
;
591 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
+ delta
,
592 fp
->_IO_buf_base
+ count
);
593 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
594 fp
->_offset
= result
+ count
;
595 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
599 _IO_unsave_markers (fp
);
600 result
= _IO_SYSSEEK (fp
, offset
, dir
);
602 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
603 fp
->_offset
= result
;
604 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
605 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
610 _IO_file_read (fp
, buf
, size
)
615 return read (fp
->_fileno
, buf
, size
);
619 _IO_file_seek (fp
, offset
, dir
)
625 return _G_LSEEK64 (fp
->_fileno
, offset
, dir
);
627 return lseek (fp
->_fileno
, offset
, dir
);
632 _IO_file_stat (fp
, st
)
637 return _G_FSTAT64 (fp
->_fileno
, (struct _G_stat64
*) st
);
639 return fstat (fp
->_fileno
, (struct _G_stat64
*) st
);
647 return close (fp
->_fileno
);
651 _IO_file_write (f
, data
, n
)
656 _IO_ssize_t to_do
= n
;
659 _IO_ssize_t count
= write (f
->_fileno
, data
, to_do
);
662 f
->_flags
|= _IO_ERR_SEEN
;
666 data
= (void *) ((char *) data
+ count
);
675 _IO_file_xsputn (f
, data
, n
)
680 register const char *s
= (char *) data
;
681 _IO_size_t to_do
= n
;
687 /* This is an optimized implementation.
688 If the amount to be written straddles a block boundary
689 (or the filebuf is unbuffered), use sys_write directly. */
691 /* First figure out how much space is available in the buffer. */
692 count
= f
->_IO_write_end
- f
->_IO_write_ptr
; /* Space available. */
693 if ((f
->_flags
& _IO_LINE_BUF
) && (f
->_flags
& _IO_CURRENTLY_PUTTING
))
695 count
= f
->_IO_buf_end
- f
->_IO_write_ptr
;
698 register const char *p
;
699 for (p
= s
+ n
; p
> s
; )
710 /* Then fill the buffer. */
718 f
->_IO_write_ptr
= __mempcpy (f
->_IO_write_ptr
, s
, count
);
720 memcpy (f
->_IO_write_ptr
, s
, count
);
721 f
->_IO_write_ptr
+= count
;
727 register char *p
= f
->_IO_write_ptr
;
728 register int i
= (int) count
;
731 f
->_IO_write_ptr
= p
;
735 if (to_do
+ must_flush
> 0)
737 _IO_size_t block_size
, dont_write
;
738 /* Next flush the (full) buffer. */
739 if (__overflow (f
, EOF
) == EOF
)
742 /* Try to maintain alignment: write a whole number of blocks.
743 dont_write is what gets left over. */
744 block_size
= f
->_IO_buf_end
- f
->_IO_buf_base
;
745 dont_write
= block_size
>= 128 ? to_do
% block_size
: 0;
747 count
= to_do
- dont_write
;
748 if (_IO_do_write (f
, s
, count
) == EOF
)
752 /* Now write out the remainder. Normally, this will fit in the
753 buffer, but it's somewhat messier for line-buffered files,
754 so we let _IO_default_xsputn handle the general case. */
756 to_do
-= _IO_default_xsputn (f
, s
+count
, dont_write
);
762 /* Work in progress */
764 _IO_file_xsgetn (fp
, data
, n
)
769 register _IO_size_t more
= n
;
770 register char *s
= data
;
773 /* Data available. */
774 _IO_ssize_t count
= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
782 s
= __mempcpy (s
, fp
->_IO_read_ptr
, count
);
784 memcpy (s
, fp
->_IO_read_ptr
, count
);
787 fp
->_IO_read_ptr
+= count
;
793 register char *p
= fp
->_IO_read_ptr
;
794 register int i
= (int) count
;
797 fp
->_IO_read_ptr
= p
;
802 if (! _IO_in
put_mode (fp
)
803 && ! _IO_have_markers (fp
) && ! IO_have_backup (fp
))
805 /* This is an optimization of _IO_file_underflow */
806 if (fp
->_flags
& _IO_NO_READS
)
808 /* If we're reading a lot of data, don't bother allocating
809 a buffer. But if we're only reading a bit, perhaps we should ??*/
810 if (count
<= 512 && fp
->_IO_buf_base
== NULL
)
812 if (fp
->_flags
& (_IO_LINE_BUF
|_IO_UNBUFFERED
))
813 _IO_flush_all_linebuffered ();
815 _IO_switch_to_get_mode (fp
); ???;
816 count
= _IO_SYSREAD (fp
, s
, more
);
820 fp
->_flags
|= _IO_EOF_SEEN
;
822 fp
->_flags
|= _IO_ERR_SEEN
, count
= 0;
829 if (more
== 0 || __underflow (fp
) == EOF
)
836 struct _IO_jump_t _IO_file_jumps
=
839 JUMP_INIT(finish
, _IO_file_finish
),
840 JUMP_INIT(overflow
, _IO_file_overflow
),
841 JUMP_INIT(underflow
, _IO_file_underflow
),
842 JUMP_INIT(uflow
, _IO_default_uflow
),
843 JUMP_INIT(pbackfail
, _IO_default_pbackfail
),
844 JUMP_INIT(xsputn
, _IO_file_xsputn
),
845 JUMP_INIT(xsgetn
, _IO_default_xsgetn
),
846 JUMP_INIT(seekoff
, _IO_file_seekoff
),
847 JUMP_INIT(seekpos
, _IO_default_seekpos
),
848 JUMP_INIT(setbuf
, _IO_file_setbuf
),
849 JUMP_INIT(sync
, _IO_file_sync
),
850 JUMP_INIT(doallocate
, _IO_file_doallocate
),
851 JUMP_INIT(read
, _IO_file_read
),
852 JUMP_INIT(write
, _IO_file_write
),
853 JUMP_INIT(seek
, _IO_file_seek
),
854 JUMP_INIT(close
, _IO_file_close
),
855 JUMP_INIT(stat
, _IO_file_stat
),
856 JUMP_INIT(showmanyc
, _IO_default_showmanyc
),
857 JUMP_INIT(imbue
, _IO_default_imbue
)