2 Copyright (C) 1993, 1995 Free Software Foundation
4 This file is part of the GNU IO Library. This library is free
5 software; you can redistribute it and/or modify it under the
6 terms of the GNU General Public License as published by the
7 Free Software Foundation; either version 2, or (at your option)
10 This 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
13 GNU 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 the Free
17 Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 As a special exception, if you link this library with files
20 compiled with a GNU compiler to produce an executable, this does not cause
21 the resulting executable to be covered by the GNU General Public License.
22 This exception does not however invalidate any other reasons why
23 the executable file might be covered by the GNU General Public License. */
25 /* written by Per Bothner (bothner@cygnus.com) */
28 # define _POSIX_SOURCE
32 #include <sys/types.h>
40 /* An fstream can be in at most one of put mode, get mode, or putback mode.
41 Putback mode is a variant of get mode.
43 In a filebuf, there is only one current position, instead of two
44 separate get and put pointers. In get mode, the current posistion
45 is that of gptr(); in put mode that of pptr().
47 The position in the buffer that corresponds to the position
48 in external file system is file_ptr().
49 This is normally _IO_read_end, except in putback mode,
50 when it is _IO_save_end.
51 If the field _fb._offset is >= 0, it gives the offset in
52 the file as a whole corresponding to eGptr(). (?)
55 If a filebuf is in put mode, pbase() is non-NULL and equal to base().
56 Also, epptr() == ebuf().
57 Also, eback() == gptr() && gptr() == egptr().
58 The un-flushed character are those between pbase() and pptr().
60 If a filebuf is in get or putback mode, eback() != egptr().
61 In get mode, the unread characters are between gptr() and egptr().
62 The OS file position corresponds to that of egptr().
64 Putback mode is used to remember "excess" characters that have
65 been sputbackc'd in a separate putback buffer.
66 In putback mode, the get buffer points to the special putback buffer.
67 The unread characters are the characters between gptr() and egptr()
68 in the putback buffer, as well as the area between save_gptr()
69 and save_egptr(), which point into the original reserve buffer.
70 (The pointers save_gptr() and save_egptr() are the values
71 of gptr() and egptr() at the time putback mode was entered.)
72 The OS position corresponds to that of save_egptr().
75 During line buffered output, pbase()==base() && epptr()==base().
76 However, ptr() may be anywhere between base() and ebuf().
77 This forces a call to filebuf::overflow(int C) on every put.
78 If there is more space in the buffer, and C is not a '\n',
79 then C is inserted, and pptr() incremented.
82 If a filebuf is unbuffered(), the _shortbuf[1] is used as the buffer.
85 #define CLOSED_FILEBUF_FLAGS \
86 (_IO_IS_FILEBUF+_IO_NO_READS+_IO_NO_WRITES+_IO_TIED_PUT_GET)
90 DEFUN(_IO_file_init
, (fp
),
91 register _IO_FILE
*fp
)
93 /* POSIX.1 allows another file handle to be used to change the position
94 of our file descriptor. Hence we actually don't know the actual
95 position before we do the first fseek (and until a following fflush). */
96 fp
->_offset
= _IO_pos_BAD
;
97 fp
->_IO_file_flags
|= CLOSED_FILEBUF_FLAGS
;
104 DEFUN(_IO_file_close_it
, (fp
),
105 register _IO_FILE
* fp
)
107 int write_status
, close_status
;
108 if (!_IO_file_is_open(fp
))
111 write_status
= _IO_do_flush (fp
);
113 _IO_unsave_markers(fp
);
115 close_status
= _IO_SYSCLOSE (fp
);
118 _IO_setb(fp
, NULL
, NULL
, 0);
119 _IO_setg(fp
, NULL
, NULL
, NULL
);
120 _IO_setp(fp
, NULL
, NULL
);
123 fp
->_flags
= _IO_MAGIC
|CLOSED_FILEBUF_FLAGS
;
125 fp
->_offset
= _IO_pos_BAD
;
127 return close_status
? close_status
: write_status
;
131 DEFUN(_IO_file_finish
, (fp
),
132 register _IO_FILE
* fp
)
134 if (_IO_file_is_open(fp
))
137 if (!(fp
->_flags
& _IO_DELETE_DONT_CLOSE
))
140 _IO_default_finish(fp
);
144 DEFUN(_IO_file_fopen
, (fp
, filename
, mode
),
145 register _IO_FILE
*fp AND
const char *filename AND
const char *mode
)
147 int oflags
= 0, omode
;
148 int read_write
, fdesc
;
150 if (_IO_file_is_open (fp
))
155 read_write
= _IO_NO_WRITES
;
159 oflags
= O_CREAT
|O_TRUNC
;
160 read_write
= _IO_NO_READS
;
164 oflags
= O_CREAT
|O_APPEND
;
165 read_write
= _IO_NO_READS
|_IO_IS_APPENDING
;
168 __set_errno (EINVAL
);
171 if (mode
[0] == '+' || (mode
[0] == 'b' && mode
[1] == '+')) {
173 read_write
&= _IO_IS_APPENDING
;
175 fdesc
= __open (filename
, omode
|oflags
, oprot
);
179 _IO_mask_flags(fp
, read_write
,_IO_NO_READS
+_IO_NO_WRITES
+_IO_IS_APPENDING
);
180 if (read_write
& _IO_IS_APPENDING
)
181 if (_IO_SEEKOFF (fp
, (_IO_off_t
)0, _IO_seek_end
, _IOS_INPUT
|_IOS_OUTPUT
)
189 DEFUN(_IO_file_attach
, (fp
, fd
),
190 _IO_FILE
*fp AND
int fd
)
192 if (_IO_file_is_open(fp
))
195 fp
->_flags
&= ~(_IO_NO_READS
+_IO_NO_WRITES
);
196 fp
->_flags
|= _IO_DELETE_DONT_CLOSE
;
197 fp
->_offset
= _IO_pos_BAD
;
202 DEFUN(_IO_file_setbuf
, (fp
, p
, len
),
203 register _IO_FILE
*fp AND
char* p AND _IO_ssize_t len
)
205 if (_IO_default_setbuf(fp
, p
, len
) == NULL
)
208 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_write_end
210 _IO_setg(fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
215 /* Write TO_DO bytes from DATA to FP.
216 Then mark FP has having empty buffers. */
219 DEFUN(_IO_do_write
, (fp
, data
, to_do
),
220 register _IO_FILE
*fp AND
const char* data AND _IO_size_t to_do
)
225 if (fp
->_flags
& _IO_IS_APPENDING
)
226 /* On a system without a proper O_APPEND implementation,
227 you would need to sys_seek(0, SEEK_END) here, but is
228 is not needed nor desirable for Unix- or Posix-like systems.
229 Instead, just indicate that offset (before and after) is
231 fp
->_offset
= _IO_pos_BAD
;
232 else if (fp
->_IO_read_end
!= fp
->_IO_write_base
)
235 = _IO_SYSSEEK(fp
, fp
->_IO_write_base
- fp
->_IO_read_end
, 1);
236 if (new_pos
== _IO_pos_BAD
)
238 fp
->_offset
= new_pos
;
240 count
= _IO_SYSWRITE (fp
, data
, to_do
);
242 fp
->_cur_column
= _IO_adjust_column(fp
->_cur_column
- 1, data
, to_do
) + 1;
243 _IO_setg(fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
244 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_buf_base
;
245 fp
->_IO_write_end
= (fp
->_flags
& (_IO_LINE_BUF
+_IO_UNBUFFERED
)) ? fp
->_IO_buf_base
247 return count
!= to_do
? EOF
: 0;
251 DEFUN(_IO_file_underflow
, (fp
),
252 register _IO_FILE
*fp
)
256 /* SysV does not make this test; take it out for compatibility */
257 if (fp
->_flags
& _IO_EOF_SEEN
)
261 if (fp
->_flags
& _IO_NO_READS
)
263 if (fp
->_IO_read_ptr
< fp
->_IO_read_end
)
264 return *(unsigned char*)fp
->_IO_read_ptr
;
266 if (fp
->_IO_buf_base
== NULL
)
269 /* Flush all line buffered files before reading. */
270 /* FIXME This can/should be moved to genops ?? */
271 if (fp
->_flags
& (_IO_LINE_BUF
|_IO_UNBUFFERED
))
272 _IO_flush_all_linebuffered();
274 _IO_switch_to_get_mode(fp
);
276 count
= _IO_SYSREAD (fp
, fp
->_IO_buf_base
,
277 fp
->_IO_buf_end
- fp
->_IO_buf_base
);
281 fp
->_flags
|= _IO_EOF_SEEN
;
283 fp
->_flags
|= _IO_ERR_SEEN
, count
= 0;
285 fp
->_IO_read_base
= fp
->_IO_read_ptr
= fp
->_IO_buf_base
;
286 fp
->_IO_read_end
= fp
->_IO_buf_base
+ count
;
287 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_write_end
291 if (fp
->_offset
!= _IO_pos_BAD
)
292 _IO_pos_adjust(fp
->_offset
, count
);
293 return *(unsigned char*)fp
->_IO_read_ptr
;
297 DEFUN(_IO_file_overflow
, (f
, ch
),
298 register _IO_FILE
* f AND
int ch
)
300 if (f
->_flags
& _IO_NO_WRITES
) /* SET ERROR */
302 /* If currently reading or no buffer allocated. */
303 if ((f
->_flags
& _IO_CURRENTLY_PUTTING
) == 0)
305 /* Allocate a buffer if needed. */
306 if (f
->_IO_write_base
== 0)
309 _IO_setg (f
, f
->_IO_buf_base
, f
->_IO_buf_base
, f
->_IO_buf_base
);
311 /* Otherwise must be currently reading. */
312 f
->_IO_write_ptr
= f
->_IO_read_ptr
;
313 f
->_IO_write_base
= f
->_IO_write_ptr
;
314 f
->_IO_write_end
= f
->_IO_buf_end
;
315 f
->_IO_read_base
= f
->_IO_read_ptr
= f
->_IO_read_end
;
317 if (f
->_flags
& (_IO_LINE_BUF
+_IO_UNBUFFERED
))
318 f
->_IO_write_end
= f
->_IO_write_ptr
;
319 f
->_flags
|= _IO_CURRENTLY_PUTTING
;
322 return _IO_do_flush(f
);
323 if (f
->_IO_write_ptr
== f
->_IO_buf_end
) /* Buffer is really full */
324 if (_IO_do_flush(f
) == EOF
)
326 *f
->_IO_write_ptr
++ = ch
;
327 if ((f
->_flags
& _IO_UNBUFFERED
)
328 || ((f
->_flags
& _IO_LINE_BUF
) && ch
== '\n'))
329 if (_IO_do_flush(f
) == EOF
)
331 return (unsigned char)ch
;
335 DEFUN(_IO_file_sync
, (fp
),
336 register _IO_FILE
* fp
)
339 /* char* ptr = cur_ptr(); */
340 if (fp
->_IO_write_ptr
> fp
->_IO_write_base
)
341 if (_IO_do_flush(fp
)) return EOF
;
342 delta
= fp
->_IO_read_ptr
- fp
->_IO_read_end
;
346 if (_IO_in_backup(fp
))
347 delta
-= eGptr() - Gbase();
349 _IO_off_t new_pos
= _IO_SYSSEEK (fp
, delta
, 1);
350 if (new_pos
!= (_IO_off_t
)EOF
)
351 fp
->_IO_read_end
= fp
->_IO_read_ptr
;
353 else if (errno
== ESPIPE
)
354 ; /* Ignore error from unseekable devices. */
359 fp
->_offset
= _IO_pos_BAD
;
360 /* FIXME: Cleanup - can this be shared? */
361 /* setg(base(), ptr, ptr); */
366 DEFUN(_IO_file_seekoff
, (fp
, offset
, dir
, mode
),
367 register _IO_FILE
*fp AND _IO_off_t offset AND
int dir AND
int mode
)
370 _IO_off_t delta
, new_offset
;
374 dir
= _IO_seek_cur
, offset
= 0; /* Don't move any pointers. */
376 /* Flush unwritten characters.
377 (This may do an unneeded write if we seek within the buffer.
378 But to be able to switch to reading, we would need to set
379 egptr to ptr. That can't be done in the current design,
380 which assumes file_ptr() is eGptr. Anyway, since we probably
381 end up flushing when we close(), it doesn't make much difference.)
382 FIXME: simulate mem-papped files. */
384 if (fp
->_IO_write_ptr
> fp
->_IO_write_base
|| _IO_in_put_mode(fp
))
385 if (_IO_switch_to_get_mode(fp
)) return EOF
;
387 if (fp
->_IO_buf_base
== NULL
)
390 _IO_setp(fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
391 _IO_setg(fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
397 /* Adjust for read-ahead (bytes is buffer). */
398 offset
-= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
399 if (fp
->_offset
== _IO_pos_BAD
)
401 /* Make offset absolute, assuming current pointer is file_ptr(). */
402 offset
+= _IO_pos_as_off(fp
->_offset
);
411 if (_IO_SYSSTAT (fp
, &st
) == 0 && S_ISREG(st
.st_mode
))
413 offset
+= st
.st_size
;
420 /* At this point, dir==_IO_seek_set. */
422 /* If destination is within current buffer, optimize: */
423 if (fp
->_offset
!= _IO_pos_BAD
&& fp
->_IO_read_base
!= NULL
424 && !_IO_in_backup (fp
))
426 /* Offset relative to start of main get area. */
427 _IO_pos_t rel_offset
= offset
- fp
->_offset
428 + (fp
->_IO_read_end
- fp
->_IO_read_base
);
432 if (_IO_in_backup(fp
))
433 _IO_switch_to_main_get_area(fp
);
435 if (rel_offset
<= fp
->_IO_read_end
- fp
->_IO_read_base
)
437 _IO_setg(fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
+ rel_offset
,
439 _IO_setp(fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
443 /* If we have streammarkers, seek forward by reading ahead. */
444 if (_IO_have_markers(fp
))
446 int to_skip
= rel_offset
447 - (fp
->_IO_read_ptr
- fp
->_IO_read_base
);
448 if (ignore(to_skip
) != to_skip
)
455 if (rel_offset
< 0 && rel_offset
>= Bbase() - Bptr())
457 if (!_IO_in_backup(fp
))
458 _IO_switch_to_backup_area(fp
);
459 gbump(fp
->_IO_read_end
+ rel_offset
- fp
->_IO_read_ptr
);
466 _IO_unsave_markers(fp
);
469 if (fp
->_flags
& _IO_NO_READS
)
472 /* Try to seek to a block boundary, to improve kernel page management. */
473 new_offset
= offset
& ~(fp
->_IO_buf_end
- fp
->_IO_buf_base
- 1);
474 delta
= offset
- new_offset
;
475 if (delta
> fp
->_IO_buf_end
- fp
->_IO_buf_base
)
480 result
= _IO_SYSSEEK (fp
, new_offset
, 0);
487 count
= _IO_SYSREAD (fp
, fp
->_IO_buf_base
,
488 fp
->_IO_buf_end
- fp
->_IO_buf_base
);
491 /* We weren't allowed to read, but try to seek the remainder. */
492 offset
= count
== EOF
? delta
: delta
-count
;
497 _IO_setg(fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
+delta
, fp
->_IO_buf_base
+count
);
498 _IO_setp(fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
499 fp
->_offset
= result
+ count
;
500 _IO_mask_flags(fp
, 0, _IO_EOF_SEEN
);
504 _IO_unsave_markers(fp
);
505 result
= _IO_SYSSEEK (fp
, offset
, dir
);
507 _IO_mask_flags(fp
, 0, _IO_EOF_SEEN
);
508 fp
->_offset
= result
;
509 _IO_setg(fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
510 _IO_setp(fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
515 DEFUN(_IO_file_read
, (fp
, buf
, size
),
516 register _IO_FILE
* fp AND
void* buf AND _IO_ssize_t size
)
520 _IO_ssize_t count
= _IO_read(fp
->_fileno
, buf
, size
);
522 if (count
== -1 && errno
== EINTR
)
530 DEFUN(_IO_file_seek
, (fp
, offset
, dir
),
531 _IO_FILE
*fp AND _IO_off_t offset AND
int dir
)
533 return _IO_lseek(fp
->_fileno
, offset
, dir
);
537 DEFUN(_IO_file_stat
, (fp
, st
),
538 _IO_FILE
*fp AND
void* st
)
540 return _IO_fstat(fp
->_fileno
, (struct stat
*)st
);
544 DEFUN(_IO_file_close
, (fp
),
547 return _IO_close(fp
->_fileno
);
551 DEFUN(_IO_file_write
, (f
, data
, n
),
552 register _IO_FILE
* f AND
const void* data AND _IO_ssize_t n
)
554 _IO_ssize_t to_do
= n
;
557 _IO_ssize_t count
= _IO_write(f
->_fileno
, data
, to_do
);
566 f
->_flags
|= _IO_ERR_SEEN
;
571 data
= (void*)((char*)data
+ count
);
580 DEFUN(_IO_file_xsputn
, (f
, data
, n
),
581 _IO_FILE
*f AND
const void *data AND _IO_size_t n
)
583 register const char *s
= (char*) data
;
584 _IO_size_t to_do
= n
;
590 /* This is an optimized implementation.
591 If the amount to be written straddles a block boundary
592 (or the filebuf is unbuffered), use sys_write directly. */
594 /* First figure out how much space is available in the buffer. */
595 count
= f
->_IO_write_end
- f
->_IO_write_ptr
; /* Space available. */
596 if ((f
->_flags
& _IO_LINE_BUF
) && (f
->_flags
& _IO_CURRENTLY_PUTTING
))
598 count
= f
->_IO_buf_end
- f
->_IO_write_ptr
;
600 { register const char *p
;
601 for (p
= s
+ n
; p
> s
; )
611 /* Then fill the buffer. */
617 memcpy(f
->_IO_write_ptr
, s
, count
);
622 register char *p
= f
->_IO_write_ptr
;
623 register int i
= (int)count
;
624 while (--i
>= 0) *p
++ = *s
++;
626 f
->_IO_write_ptr
+= count
;
629 if (to_do
+ must_flush
> 0)
630 { _IO_size_t block_size
, dont_write
;
631 /* Next flush the (full) buffer. */
632 if (__overflow(f
, EOF
) == EOF
)
635 /* Try to maintain alignment: write a whole number of blocks.
636 dont_write is what gets left over. */
637 block_size
= f
->_IO_buf_end
- f
->_IO_buf_base
;
638 dont_write
= block_size
>= 128 ? to_do
% block_size
: 0;
640 count
= to_do
- dont_write
;
641 if (_IO_do_write(f
, s
, count
) == EOF
)
645 /* Now write out the remainder. Normally, this will fit in the
646 buffer, but it's somewhat messier for line-buffered files,
647 so we let _IO_default_xsputn handle the general case. */
649 to_do
-= _IO_default_xsputn(f
, s
+count
, dont_write
);
655 /* Work in progress */
657 DEFUN(_IO_file_xsgetn
, (fp
, data
, n
),
658 _IO_FILE
*fp AND
void *data AND _IO_size_t n
)
660 register _IO_size_t more
= n
;
661 register char *s
= data
;
664 _IO_ssize_t count
= fp
->_IO_read_end
- fp
->_IO_read_ptr
; /* Data available. */
671 memcpy(s
, fp
->_IO_read_ptr
, count
);
673 fp
->_IO_read_ptr
+= count
;
679 register char *p
= fp
->_IO_read_ptr
;
680 register int i
= (int)count
;
681 while (--i
>= 0) *s
++ = *p
++;
682 fp
->_IO_read_ptr
= p
;
687 if (! _IO_in
put_mode (fp
)
688 && ! _IO_have_markers (fp
) && ! IO_have_backup (fp
))
690 /* This is an optimization of _IO_file_underflow */
691 if (fp
->_flags
& _IO_NO_READS
)
693 /* If we're reading a lot of data, don't bother allocating
694 a buffer. But if we're only reading a bit, perhaps we should ??*/
695 if (count
<= 512 && fp
->_IO_buf_base
== NULL
)
697 if (fp
->_flags
& (_IO_LINE_BUF
|_IO_UNBUFFERED
))
698 _IO_flush_all_linebuffered();
700 _IO_switch_to_get_mode(fp
); ???;
701 count
= _IO_SYSREAD (fp
, s
, more
);
705 fp
->_flags
|= _IO_EOF_SEEN
;
707 fp
->_flags
|= _IO_ERR_SEEN
, count
= 0;
714 if (more
== 0 || __underflow(fp
) == EOF
)
721 struct _IO_jump_t _IO_file_jumps
= {
723 JUMP_INIT(finish
, _IO_file_finish
),
724 JUMP_INIT(overflow
, _IO_file_overflow
),
725 JUMP_INIT(underflow
, _IO_file_underflow
),
726 JUMP_INIT(uflow
, _IO_default_uflow
),
727 JUMP_INIT(pbackfail
, _IO_default_pbackfail
),
728 JUMP_INIT(xsputn
, _IO_file_xsputn
),
729 JUMP_INIT(xsgetn
, _IO_default_xsgetn
),
730 JUMP_INIT(seekoff
, _IO_file_seekoff
),
731 JUMP_INIT(seekpos
, _IO_default_seekpos
),
732 JUMP_INIT(setbuf
, _IO_file_setbuf
),
733 JUMP_INIT(sync
, _IO_file_sync
),
734 JUMP_INIT(doallocate
, _IO_file_doallocate
),
735 JUMP_INIT(read
, _IO_file_read
),
736 JUMP_INIT(write
, _IO_file_write
),
737 JUMP_INIT(seek
, _IO_file_seek
),
738 JUMP_INIT(close
, _IO_file_close
),
739 JUMP_INIT(stat
, _IO_file_stat
)