Update.
[glibc.git] / libio / fileops.c
bloba2017f23bc75308d60cde7fd42570e1b196d2635
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,
18 MA 02111-1307, USA.
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. */
28 #ifndef _POSIX_SOURCE
29 # define _POSIX_SOURCE
30 #endif
31 #include "libioP.h"
32 #include <fcntl.h>
33 #include <sys/types.h>
34 #include <sys/stat.h>
35 #include <string.h>
36 #include <errno.h>
37 #ifndef errno
38 extern int errno;
39 #endif
40 #ifndef __set_errno
41 # define __set_errno(Val) errno = (Val)
42 #endif
45 #ifdef _LIBC
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)
51 #endif
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(). (?)
66 PUT MODE:
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.
76 GET MODE:
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().
81 PUTBACK MODE:
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().
92 LINE BUFFERED OUTPUT:
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.
99 UNBUFFERED STREAMS:
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)
107 void
108 _IO_new_file_init (fp)
109 _IO_FILE *fp;
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;
117 _IO_link_in(fp);
118 fp->_fileno = -1;
122 _IO_new_file_close_it (fp)
123 _IO_FILE *fp;
125 int write_status, close_status;
126 if (!_IO_file_is_open (fp))
127 return EOF;
129 write_status = _IO_do_flush (fp);
131 _IO_unsave_markers(fp);
133 close_status = _IO_SYSCLOSE (fp);
135 /* Free buffer. */
136 _IO_setb (fp, NULL, NULL, 0);
137 _IO_setg (fp, NULL, NULL, NULL);
138 _IO_setp (fp, NULL, NULL);
140 _IO_un_link (fp);
141 fp->_flags = _IO_MAGIC|CLOSED_FILEBUF_FLAGS;
142 fp->_fileno = EOF;
143 fp->_offset = _IO_pos_BAD;
145 return close_status ? close_status : write_status;
148 void
149 _IO_new_file_finish (fp, dummy)
150 _IO_FILE *fp;
151 int dummy;
153 if (_IO_file_is_open (fp))
155 _IO_do_flush (fp);
156 if (!(fp->_flags & _IO_DELETE_DONT_CLOSE))
157 _IO_SYSCLOSE (fp);
159 _IO_default_finish (fp, 0);
162 #if defined __GNUC__ && __GNUC__ >= 2
163 __inline__
164 #endif
165 _IO_FILE *
166 _IO_file_open (fp, filename, posix_mode, prot, read_write, is32not64)
167 _IO_FILE *fp;
168 const char *filename;
169 int posix_mode;
170 int prot;
171 int read_write;
172 int is32not64;
174 int fdesc;
175 #ifdef _G_OPEN64
176 fdesc = (is32not64
177 ? open (filename, posix_mode, prot)
178 : _G_OPEN64 (filename, posix_mode, prot));
179 #else
180 fdesc = open (filename, posix_mode, prot);
181 #endif
182 if (fdesc < 0)
183 return NULL;
184 fp->_fileno = fdesc;
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)
189 return NULL;
190 _IO_link_in (fp);
191 return fp;
194 _IO_FILE *
195 _IO_new_file_fopen (fp, filename, mode, is32not64)
196 _IO_FILE *fp;
197 const char *filename;
198 const char *mode;
199 int is32not64;
201 int oflags = 0, omode;
202 int read_write;
203 int oprot = 0666;
204 int i;
205 if (_IO_file_is_open (fp))
206 return 0;
207 switch (*mode)
209 case 'r':
210 omode = O_RDONLY;
211 read_write = _IO_NO_WRITES;
212 break;
213 case 'w':
214 omode = O_WRONLY;
215 oflags = O_CREAT|O_TRUNC;
216 read_write = _IO_NO_READS;
217 break;
218 case 'a':
219 omode = O_WRONLY;
220 oflags = O_CREAT|O_APPEND;
221 read_write = _IO_NO_READS|_IO_IS_APPENDING;
222 break;
223 default:
224 __set_errno (EINVAL);
225 return NULL;
227 for (i = 1; i < 4; ++i)
229 switch (*++mode)
231 case '\0':
232 break;
233 case '+':
234 omode = O_RDWR;
235 read_write &= _IO_IS_APPENDING;
236 continue;
237 case 'x':
238 oflags |= O_EXCL;
239 continue;
240 case 'b':
241 default:
242 /* Ignore. */
243 continue;
245 break;
248 return _IO_file_open (fp, filename, omode|oflags, oprot, read_write,
249 is32not64);
252 _IO_FILE *
253 _IO_new_file_attach (fp, fd)
254 _IO_FILE *fp;
255 int fd;
257 if (_IO_file_is_open (fp))
258 return NULL;
259 fp->_fileno = fd;
260 fp->_flags &= ~(_IO_NO_READS+_IO_NO_WRITES);
261 fp->_flags |= _IO_DELETE_DONT_CLOSE;
262 /* Get the current position of the file. */
263 /* We have to do that since that may be junk. */
264 fp->_offset = _IO_pos_BAD;
265 if (_IO_SEEKOFF (fp, (_IO_off64_t)0, _IO_seek_cur, _IOS_INPUT|_IOS_OUTPUT)
266 == _IO_pos_BAD && errno != ESPIPE)
267 return NULL;
268 return fp;
271 _IO_FILE *
272 _IO_new_file_setbuf (fp, p, len)
273 _IO_FILE *fp;
274 char *p;
275 _IO_ssize_t len;
277 if (_IO_default_setbuf (fp, p, len) == NULL)
278 return NULL;
280 fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end
281 = fp->_IO_buf_base;
282 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
284 return fp;
287 /* Write TO_DO bytes from DATA to FP.
288 Then mark FP as having empty buffers. */
291 _IO_new_do_write (fp, data, to_do)
292 _IO_FILE *fp;
293 const char *data;
294 _IO_size_t to_do;
296 _IO_size_t count;
297 if (to_do == 0)
298 return 0;
299 if (fp->_flags & _IO_IS_APPENDING)
300 /* On a system without a proper O_APPEND implementation,
301 you would need to sys_seek(0, SEEK_END) here, but is
302 is not needed nor desirable for Unix- or Posix-like systems.
303 Instead, just indicate that offset (before and after) is
304 unpredictable. */
305 fp->_offset = _IO_pos_BAD;
306 else if (fp->_IO_read_end != fp->_IO_write_base)
308 _IO_fpos64_t new_pos
309 = _IO_SYSSEEK (fp, fp->_IO_write_base - fp->_IO_read_end, 1);
310 if (new_pos == _IO_pos_BAD)
311 return EOF;
312 fp->_offset = new_pos;
314 count = _IO_SYSWRITE (fp, data, to_do);
315 if (fp->_cur_column)
316 fp->_cur_column = _IO_adjust_column (fp->_cur_column - 1, data, to_do) + 1;
317 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
318 fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_buf_base;
319 fp->_IO_write_end = ((fp->_flags & (_IO_LINE_BUF+_IO_UNBUFFERED))
320 ? fp->_IO_buf_base : fp->_IO_buf_end);
321 return count != to_do ? EOF : 0;
325 _IO_new_file_underflow (fp)
326 _IO_FILE *fp;
328 _IO_ssize_t count;
329 #if 0
330 /* SysV does not make this test; take it out for compatibility */
331 if (fp->_flags & _IO_EOF_SEEN)
332 return (EOF);
333 #endif
335 if (fp->_flags & _IO_NO_READS)
337 __set_errno (EBADF);
338 return EOF;
340 if (fp->_IO_read_ptr < fp->_IO_read_end)
341 return *(unsigned char *) fp->_IO_read_ptr;
343 if (fp->_IO_buf_base == NULL)
344 _IO_doallocbuf (fp);
346 /* Flush all line buffered files before reading. */
347 /* FIXME This can/should be moved to genops ?? */
348 if (fp->_flags & (_IO_LINE_BUF|_IO_UNBUFFERED))
349 _IO_flush_all_linebuffered ();
351 _IO_switch_to_get_mode (fp);
353 /* This is very tricky. We have to adjust those
354 pointers before we call _IO_SYSREAD () since
355 we may longjump () out while waiting for
356 input. Those pointers may be screwed up. H.J. */
357 fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_buf_base;
358 fp->_IO_read_end = fp->_IO_buf_base;
359 fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end
360 = fp->_IO_buf_base;
362 count = _IO_SYSREAD (fp, fp->_IO_buf_base,
363 fp->_IO_buf_end - fp->_IO_buf_base);
364 if (count <= 0)
366 if (count == 0)
367 fp->_flags |= _IO_EOF_SEEN;
368 else
369 fp->_flags |= _IO_ERR_SEEN, count = 0;
371 fp->_IO_read_end += count;
372 if (count == 0)
373 return EOF;
374 if (fp->_offset != _IO_pos_BAD)
375 _IO_pos_adjust (fp->_offset, count);
376 return *(unsigned char *) fp->_IO_read_ptr;
380 _IO_new_file_overflow (f, ch)
381 _IO_FILE *f;
382 int ch;
384 if (f->_flags & _IO_NO_WRITES) /* SET ERROR */
386 f->_flags |= _IO_ERR_SEEN;
387 __set_errno (EBADF);
388 return EOF;
390 /* If currently reading or no buffer allocated. */
391 if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0)
393 /* Allocate a buffer if needed. */
394 if (f->_IO_write_base == 0)
396 _IO_doallocbuf (f);
397 _IO_setg (f, f->_IO_buf_base, f->_IO_buf_base, f->_IO_buf_base);
399 /* Otherwise must be currently reading.
400 If _IO_read_ptr (and hence also _IO_read_end) is at the buffer end,
401 logically slide the buffer forwards one block (by setting the
402 read pointers to all point at the beginning of the block). This
403 makes room for subsequent output.
404 Otherwise, set the read pointers to _IO_read_end (leaving that
405 alone, so it can continue to correspond to the external position). */
406 if (f->_IO_read_ptr == f->_IO_buf_end)
407 f->_IO_read_end = f->_IO_read_ptr = f->_IO_buf_base;
408 f->_IO_write_ptr = f->_IO_read_ptr;
409 f->_IO_write_base = f->_IO_write_ptr;
410 f->_IO_write_end = f->_IO_buf_end;
411 f->_IO_read_base = f->_IO_read_ptr = f->_IO_read_end;
413 f->_flags |= _IO_CURRENTLY_PUTTING;
414 if (f->_flags & (_IO_LINE_BUF+_IO_UNBUFFERED))
415 f->_IO_write_end = f->_IO_write_ptr;
417 if (ch == EOF)
418 return _IO_do_flush (f);
419 if (f->_IO_write_ptr == f->_IO_buf_end ) /* Buffer is really full */
420 if (_IO_do_flush (f) == EOF)
421 return EOF;
422 *f->_IO_write_ptr++ = ch;
423 if ((f->_flags & _IO_UNBUFFERED)
424 || ((f->_flags & _IO_LINE_BUF) && ch == '\n'))
425 if (_IO_do_flush (f) == EOF)
426 return EOF;
427 return (unsigned char) ch;
431 _IO_new_file_sync (fp)
432 _IO_FILE *fp;
434 _IO_ssize_t delta;
435 int retval = 0;
437 /* char* ptr = cur_ptr(); */
438 if (fp->_IO_write_ptr > fp->_IO_write_base)
439 if (_IO_do_flush(fp)) return EOF;
440 delta = fp->_IO_read_ptr - fp->_IO_read_end;
441 if (delta != 0)
443 #ifdef TODO
444 if (_IO_in_backup (fp))
445 delta -= eGptr () - Gbase ();
446 #endif
447 _IO_off64_t new_pos = _IO_SYSSEEK (fp, delta, 1);
448 if (new_pos != (_IO_off64_t) EOF)
449 fp->_IO_read_end = fp->_IO_read_ptr;
450 #ifdef ESPIPE
451 else if (errno == ESPIPE)
452 ; /* Ignore error from unseekable devices. */
453 #endif
454 else
455 retval = EOF;
457 if (retval != EOF)
458 fp->_offset = _IO_pos_BAD;
459 /* FIXME: Cleanup - can this be shared? */
460 /* setg(base(), ptr, ptr); */
461 return retval;
464 _IO_fpos64_t
465 _IO_new_file_seekoff (fp, offset, dir, mode)
466 _IO_FILE *fp;
467 _IO_off64_t offset;
468 int dir;
469 int mode;
471 _IO_fpos64_t result;
472 _IO_off64_t delta, new_offset;
473 long count;
474 /* POSIX.1 8.2.3.7 says that after a call the fflush() the file
475 offset of the underlying file must be exact. */
476 int must_be_exact = (fp->_IO_read_base == fp->_IO_read_end
477 && fp->_IO_write_base == fp->_IO_write_ptr);
479 if (mode == 0)
480 dir = _IO_seek_cur, offset = 0; /* Don't move any pointers. */
482 /* Flush unwritten characters.
483 (This may do an unneeded write if we seek within the buffer.
484 But to be able to switch to reading, we would need to set
485 egptr to ptr. That can't be done in the current design,
486 which assumes file_ptr() is eGptr. Anyway, since we probably
487 end up flushing when we close(), it doesn't make much difference.)
488 FIXME: simulate mem-papped files. */
490 if (fp->_IO_write_ptr > fp->_IO_write_base || _IO_in_put_mode (fp))
491 if (_IO_switch_to_get_mode (fp))
492 return EOF;
494 if (fp->_IO_buf_base == NULL)
496 _IO_doallocbuf (fp);
497 _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
498 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
501 switch (dir)
503 case _IO_seek_cur:
504 /* Adjust for read-ahead (bytes is buffer). */
505 offset -= fp->_IO_read_end - fp->_IO_read_ptr;
506 if (fp->_offset == _IO_pos_BAD)
507 goto dumb;
508 /* Make offset absolute, assuming current pointer is file_ptr(). */
509 offset += _IO_pos_as_off (fp->_offset);
511 dir = _IO_seek_set;
512 break;
513 case _IO_seek_set:
514 break;
515 case _IO_seek_end:
517 struct _G_stat64 st;
518 if (_IO_SYSSTAT (fp, &st) == 0 && S_ISREG (st.st_mode))
520 offset += st.st_size;
521 dir = _IO_seek_set;
523 else
524 goto dumb;
527 /* At this point, dir==_IO_seek_set. */
529 /* If destination is within current buffer, optimize: */
530 if (fp->_offset != _IO_pos_BAD && fp->_IO_read_base != NULL
531 && !_IO_in_backup (fp))
533 /* Offset relative to start of main get area. */
534 _IO_fpos64_t rel_offset = (offset - fp->_offset
535 + (fp->_IO_read_end - fp->_IO_read_base));
536 if (rel_offset >= 0)
538 #if 0
539 if (_IO_in_backup (fp))
540 _IO_switch_to_main_get_area (fp);
541 #endif
542 if (rel_offset <= fp->_IO_read_end - fp->_IO_read_base)
544 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base + rel_offset,
545 fp->_IO_read_end);
546 _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
547 return offset;
549 #ifdef TODO
550 /* If we have streammarkers, seek forward by reading ahead. */
551 if (_IO_have_markers (fp))
553 int to_skip = rel_offset
554 - (fp->_IO_read_ptr - fp->_IO_read_base);
555 if (ignore (to_skip) != to_skip)
556 goto dumb;
557 return offset;
559 #endif
561 #ifdef TODO
562 if (rel_offset < 0 && rel_offset >= Bbase () - Bptr ())
564 if (!_IO_in_backup (fp))
565 _IO_switch_to_backup_area (fp);
566 gbump (fp->_IO_read_end + rel_offset - fp->_IO_read_ptr);
567 return offset;
569 #endif
572 #ifdef TODO
573 _IO_unsave_markers (fp);
574 #endif
576 if (fp->_flags & _IO_NO_READS)
577 goto dumb;
579 /* Try to seek to a block boundary, to improve kernel page management. */
580 new_offset = offset & ~(fp->_IO_buf_end - fp->_IO_buf_base - 1);
581 delta = offset - new_offset;
582 if (delta > fp->_IO_buf_end - fp->_IO_buf_base)
584 new_offset = offset;
585 delta = 0;
587 result = _IO_SYSSEEK (fp, new_offset, 0);
588 if (result < 0)
589 return EOF;
590 if (delta == 0)
591 count = 0;
592 else
594 count = _IO_SYSREAD (fp, fp->_IO_buf_base,
595 (must_be_exact
596 ? delta : fp->_IO_buf_end - fp->_IO_buf_base));
597 if (count < delta)
599 /* We weren't allowed to read, but try to seek the remainder. */
600 offset = count == EOF ? delta : delta-count;
601 dir = _IO_seek_cur;
602 goto dumb;
605 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base + delta,
606 fp->_IO_buf_base + count);
607 _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
608 fp->_offset = result + count;
609 _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
610 return offset;
611 dumb:
613 _IO_unsave_markers (fp);
614 result = _IO_SYSSEEK (fp, offset, dir);
615 if (result != EOF)
617 _IO_mask_flags (fp, 0, _IO_EOF_SEEN);
618 fp->_offset = result;
619 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
620 _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
622 return result;
625 _IO_ssize_t
626 _IO_file_read (fp, buf, size)
627 _IO_FILE *fp;
628 void *buf;
629 _IO_ssize_t size;
631 return read (fp->_fileno, buf, size);
634 _IO_fpos64_t
635 _IO_file_seek (fp, offset, dir)
636 _IO_FILE *fp;
637 _IO_off64_t offset;
638 int dir;
640 #ifdef _G_LSEEK64
641 return _G_LSEEK64 (fp->_fileno, offset, dir);
642 #else
643 return lseek (fp->_fileno, offset, dir);
644 #endif
648 _IO_file_stat (fp, st)
649 _IO_FILE *fp;
650 void *st;
652 #ifdef _G_FSTAT64
653 return _G_FSTAT64 (fp->_fileno, (struct _G_stat64 *) st);
654 #else
655 return fstat (fp->_fileno, (struct _G_stat64 *) st);
656 #endif
660 _IO_file_close (fp)
661 _IO_FILE *fp;
663 return close (fp->_fileno);
666 _IO_ssize_t
667 _IO_new_file_write (f, data, n)
668 _IO_FILE *f;
669 const void *data;
670 _IO_ssize_t n;
672 _IO_ssize_t to_do = n;
673 while (to_do > 0)
675 _IO_ssize_t count = write (f->_fileno, data, to_do);
676 if (count == EOF)
678 f->_flags |= _IO_ERR_SEEN;
679 break;
681 to_do -= count;
682 data = (void *) ((char *) data + count);
684 n -= to_do;
685 if (f->_offset >= 0)
686 f->_offset += n;
687 return n;
690 _IO_size_t
691 _IO_new_file_xsputn (f, data, n)
692 _IO_FILE *f;
693 const void *data;
694 _IO_size_t n;
696 register const char *s = (char *) data;
697 _IO_size_t to_do = n;
698 int must_flush = 0;
699 _IO_size_t count;
701 if (n <= 0)
702 return 0;
703 /* This is an optimized implementation.
704 If the amount to be written straddles a block boundary
705 (or the filebuf is unbuffered), use sys_write directly. */
707 /* First figure out how much space is available in the buffer. */
708 count = f->_IO_write_end - f->_IO_write_ptr; /* Space available. */
709 if ((f->_flags & _IO_LINE_BUF) && (f->_flags & _IO_CURRENTLY_PUTTING))
711 count = f->_IO_buf_end - f->_IO_write_ptr;
712 if (count >= n)
714 register const char *p;
715 for (p = s + n; p > s; )
717 if (*--p == '\n')
719 count = p - s + 1;
720 must_flush = 1;
721 break;
726 /* Then fill the buffer. */
727 if (count > 0)
729 if (count > to_do)
730 count = to_do;
731 if (count > 20)
733 #ifdef _LIBC
734 f->_IO_write_ptr = __mempcpy (f->_IO_write_ptr, s, count);
735 #else
736 memcpy (f->_IO_write_ptr, s, count);
737 f->_IO_write_ptr += count;
738 #endif
739 s += count;
741 else
743 register char *p = f->_IO_write_ptr;
744 register int i = (int) count;
745 while (--i >= 0)
746 *p++ = *s++;
747 f->_IO_write_ptr = p;
749 to_do -= count;
751 if (to_do + must_flush > 0)
753 _IO_size_t block_size, dont_write;
754 /* Next flush the (full) buffer. */
755 if (__overflow (f, EOF) == EOF)
756 return n - to_do;
758 /* Try to maintain alignment: write a whole number of blocks.
759 dont_write is what gets left over. */
760 block_size = f->_IO_buf_end - f->_IO_buf_base;
761 dont_write = block_size >= 128 ? to_do % block_size : 0;
763 count = to_do - dont_write;
764 if (_IO_new_do_write (f, s, count) == EOF)
765 return n - to_do;
766 to_do = dont_write;
768 /* Now write out the remainder. Normally, this will fit in the
769 buffer, but it's somewhat messier for line-buffered files,
770 so we let _IO_default_xsputn handle the general case. */
771 if (dont_write)
772 to_do -= _IO_default_xsputn (f, s+count, dont_write);
774 return n - to_do;
777 _IO_size_t
778 _IO_file_xsgetn (fp, data, n)
779 _IO_FILE *fp;
780 void *data;
781 _IO_size_t n;
783 register _IO_size_t want, have;
784 register _IO_ssize_t count;
785 register char *s = data;
787 want = n;
789 while (want > 0)
791 have = fp->_IO_read_end - fp->_IO_read_ptr;
792 if (want <= have)
794 memcpy (s, fp->_IO_read_ptr, want);
795 fp->_IO_read_ptr += want;
796 want = 0;
798 else
800 if (have > 0)
802 #ifdef _LIBC
803 s = __mempcpy (s, fp->_IO_read_ptr, have);
804 #else
805 memcpy (s, fp->_IO_read_ptr, have);
806 s += have;
807 #endif
808 want -= have;
809 fp->_IO_read_ptr += have;
812 /* Check for backup and repeat */
813 if (_IO_in_backup (fp))
815 _IO_switch_to_main_get_area (fp);
816 continue;
819 /* If we now want less than a buffer, underflow and repeat
820 the copy. Otherwise, _IO_SYSREAD directly to
821 the user buffer. */
822 if (fp->_IO_buf_base && want < fp->_IO_buf_end - fp->_IO_buf_base)
824 if (__underflow (fp) == EOF)
825 break;
827 continue;
830 /* These must be set before the sysread as we might longjmp out
831 waiting for input. */
832 _IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
833 _IO_setp (fp, fp->_IO_buf_base, fp->_IO_buf_base);
835 /* Try to maintain alignment: read a whole number of blocks. */
836 count = want;
837 if (fp->_IO_buf_base)
839 _IO_size_t block_size = fp->_IO_buf_end - fp->_IO_buf_base;
840 if (block_size >= 128)
841 count -= want % block_size;
844 count = _IO_SYSREAD (fp, s, count);
845 if (count <= 0)
847 if (count == 0)
848 fp->_flags |= _IO_EOF_SEEN;
849 else
850 fp->_flags |= _IO_ERR_SEEN;
852 break;
855 s += count;
856 want -= count;
857 if (fp->_offset != _IO_pos_BAD)
858 _IO_pos_adjust (fp->_offset, count);
862 return n - want;
865 struct _IO_jump_t _IO_file_jumps =
867 JUMP_INIT_DUMMY,
868 JUMP_INIT(finish, _IO_new_file_finish),
869 JUMP_INIT(overflow, _IO_new_file_overflow),
870 JUMP_INIT(underflow, _IO_new_file_underflow),
871 JUMP_INIT(uflow, _IO_default_uflow),
872 JUMP_INIT(pbackfail, _IO_default_pbackfail),
873 JUMP_INIT(xsputn, _IO_new_file_xsputn),
874 JUMP_INIT(xsgetn, _IO_file_xsgetn),
875 JUMP_INIT(seekoff, _IO_new_file_seekoff),
876 JUMP_INIT(seekpos, _IO_default_seekpos),
877 JUMP_INIT(setbuf, _IO_new_file_setbuf),
878 JUMP_INIT(sync, _IO_new_file_sync),
879 JUMP_INIT(doallocate, _IO_file_doallocate),
880 JUMP_INIT(read, _IO_file_read),
881 JUMP_INIT(write, _IO_new_file_write),
882 JUMP_INIT(seek, _IO_file_seek),
883 JUMP_INIT(close, _IO_file_close),
884 JUMP_INIT(stat, _IO_file_stat),
885 JUMP_INIT(showmanyc, _IO_default_showmanyc),
886 JUMP_INIT(imbue, _IO_default_imbue)
890 #if defined PIC && DO_VERSIONING
891 default_symbol_version (_IO_new_do_write, _IO_do_write, GLIBC_2.1);
892 default_symbol_version (_IO_new_file_attach, _IO_file_attach, GLIBC_2.1);
893 default_symbol_version (_IO_new_file_close_it, _IO_file_close_it, GLIBC_2.1);
894 default_symbol_version (_IO_new_file_finish, _IO_file_finish, GLIBC_2.1);
895 default_symbol_version (_IO_new_file_fopen, _IO_file_fopen, GLIBC_2.1);
896 default_symbol_version (_IO_new_file_init, _IO_file_init, GLIBC_2.1);
897 default_symbol_version (_IO_new_file_setbuf, _IO_file_setbuf, GLIBC_2.1);
898 default_symbol_version (_IO_new_file_sync, _IO_file_sync, GLIBC_2.1);
899 default_symbol_version (_IO_new_file_overflow, _IO_file_overflow, GLIBC_2.1);
900 default_symbol_version (_IO_new_file_seekoff, _IO_file_seekoff, GLIBC_2.1);
901 default_symbol_version (_IO_new_file_underflow, _IO_file_underflow, GLIBC_2.1);
902 default_symbol_version (_IO_new_file_write, _IO_file_write, GLIBC_2.1);
903 default_symbol_version (_IO_new_file_xsputn, _IO_file_xsputn, GLIBC_2.1);
904 #else
905 # ifdef strong_alias
906 strong_alias (_IO_new_do_write, _IO_do_write);
907 strong_alias (_IO_new_file_attach, _IO_file_attach);
908 strong_alias (_IO_new_file_close_it, _IO_file_close_it);
909 strong_alias (_IO_new_file_finish, _IO_file_finish);
910 strong_alias (_IO_new_file_fopen, _IO_file_fopen);
911 strong_alias (_IO_new_file_init, _IO_file_init);
912 strong_alias (_IO_new_file_setbuf, _IO_file_setbuf);
913 strong_alias (_IO_new_file_sync, _IO_file_sync);
914 strong_alias (_IO_new_file_overflow, _IO_file_overflow);
915 strong_alias (_IO_new_file_seekoff, _IO_file_seekoff);
916 strong_alias (_IO_new_file_underflow, _IO_file_underflow);
917 strong_alias (_IO_new_file_write, _IO_file_write);
918 strong_alias (_IO_new_file_xsputn, _IO_file_xsputn);
919 # endif
920 #endif