Fix aio_* pread namespace (bug 18519).
[glibc.git] / libio / genops.c
blob0f5e80064e0f9053ecd08ba7cb8f1fc1d1f6a441
1 /* Copyright (C) 1993-2015 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Lesser General Public
6 License as published by the Free Software Foundation; either
7 version 2.1 of the License, or (at your option) any later version.
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Lesser General Public License for more details.
14 You should have received a copy of the GNU Lesser General Public
15 License along with the GNU C Library; if not, see
16 <http://www.gnu.org/licenses/>.
18 As a special exception, if you link the code in this file with
19 files compiled with a GNU compiler to produce an executable,
20 that does not cause the resulting executable to be covered by
21 the GNU Lesser General Public License. This exception does not
22 however invalidate any other reasons why the executable file
23 might be covered by the GNU Lesser General Public License.
24 This exception applies to code released by its copyright holders
25 in files containing the exception. */
27 /* Generic or default I/O operations. */
29 #include "libioP.h"
30 #include <stdlib.h>
31 #include <string.h>
32 #include <stdbool.h>
33 #ifdef _LIBC
34 #include <sched.h>
35 #endif
37 #ifdef _IO_MTSAFE_IO
38 static _IO_lock_t list_all_lock = _IO_lock_initializer;
39 #endif
41 /* Used to signal modifications to the list of FILE decriptors. */
42 static int _IO_list_all_stamp;
45 static _IO_FILE *run_fp;
47 #ifdef _IO_MTSAFE_IO
48 static void
49 flush_cleanup (void *not_used)
51 if (run_fp != NULL)
52 _IO_funlockfile (run_fp);
53 _IO_lock_unlock (list_all_lock);
55 #endif
57 void
58 _IO_un_link (fp)
59 struct _IO_FILE_plus *fp;
61 if (fp->file._flags & _IO_LINKED)
63 struct _IO_FILE **f;
64 #ifdef _IO_MTSAFE_IO
65 _IO_cleanup_region_start_noarg (flush_cleanup);
66 _IO_lock_lock (list_all_lock);
67 run_fp = (_IO_FILE *) fp;
68 _IO_flockfile ((_IO_FILE *) fp);
69 #endif
70 if (_IO_list_all == NULL)
72 else if (fp == _IO_list_all)
74 _IO_list_all = (struct _IO_FILE_plus *) _IO_list_all->file._chain;
75 ++_IO_list_all_stamp;
77 else
78 for (f = &_IO_list_all->file._chain; *f; f = &(*f)->_chain)
79 if (*f == (_IO_FILE *) fp)
81 *f = fp->file._chain;
82 ++_IO_list_all_stamp;
83 break;
85 fp->file._flags &= ~_IO_LINKED;
86 #ifdef _IO_MTSAFE_IO
87 _IO_funlockfile ((_IO_FILE *) fp);
88 run_fp = NULL;
89 _IO_lock_unlock (list_all_lock);
90 _IO_cleanup_region_end (0);
91 #endif
94 libc_hidden_def (_IO_un_link)
96 void
97 _IO_link_in (fp)
98 struct _IO_FILE_plus *fp;
100 if ((fp->file._flags & _IO_LINKED) == 0)
102 fp->file._flags |= _IO_LINKED;
103 #ifdef _IO_MTSAFE_IO
104 _IO_cleanup_region_start_noarg (flush_cleanup);
105 _IO_lock_lock (list_all_lock);
106 run_fp = (_IO_FILE *) fp;
107 _IO_flockfile ((_IO_FILE *) fp);
108 #endif
109 fp->file._chain = (_IO_FILE *) _IO_list_all;
110 _IO_list_all = fp;
111 ++_IO_list_all_stamp;
112 #ifdef _IO_MTSAFE_IO
113 _IO_funlockfile ((_IO_FILE *) fp);
114 run_fp = NULL;
115 _IO_lock_unlock (list_all_lock);
116 _IO_cleanup_region_end (0);
117 #endif
120 libc_hidden_def (_IO_link_in)
122 /* Return minimum _pos markers
123 Assumes the current get area is the main get area. */
124 _IO_ssize_t _IO_least_marker (_IO_FILE *fp, char *end_p);
126 _IO_ssize_t
127 _IO_least_marker (fp, end_p)
128 _IO_FILE *fp;
129 char *end_p;
131 _IO_ssize_t least_so_far = end_p - fp->_IO_read_base;
132 struct _IO_marker *mark;
133 for (mark = fp->_markers; mark != NULL; mark = mark->_next)
134 if (mark->_pos < least_so_far)
135 least_so_far = mark->_pos;
136 return least_so_far;
139 /* Switch current get area from backup buffer to (start of) main get area. */
141 void
142 _IO_switch_to_main_get_area (fp)
143 _IO_FILE *fp;
145 char *tmp;
146 fp->_flags &= ~_IO_IN_BACKUP;
147 /* Swap _IO_read_end and _IO_save_end. */
148 tmp = fp->_IO_read_end;
149 fp->_IO_read_end = fp->_IO_save_end;
150 fp->_IO_save_end= tmp;
151 /* Swap _IO_read_base and _IO_save_base. */
152 tmp = fp->_IO_read_base;
153 fp->_IO_read_base = fp->_IO_save_base;
154 fp->_IO_save_base = tmp;
155 /* Set _IO_read_ptr. */
156 fp->_IO_read_ptr = fp->_IO_read_base;
159 /* Switch current get area from main get area to (end of) backup area. */
161 void
162 _IO_switch_to_backup_area (fp)
163 _IO_FILE *fp;
165 char *tmp;
166 fp->_flags |= _IO_IN_BACKUP;
167 /* Swap _IO_read_end and _IO_save_end. */
168 tmp = fp->_IO_read_end;
169 fp->_IO_read_end = fp->_IO_save_end;
170 fp->_IO_save_end = tmp;
171 /* Swap _IO_read_base and _IO_save_base. */
172 tmp = fp->_IO_read_base;
173 fp->_IO_read_base = fp->_IO_save_base;
174 fp->_IO_save_base = tmp;
175 /* Set _IO_read_ptr. */
176 fp->_IO_read_ptr = fp->_IO_read_end;
180 _IO_switch_to_get_mode (fp)
181 _IO_FILE *fp;
183 if (fp->_IO_write_ptr > fp->_IO_write_base)
184 if (_IO_OVERFLOW (fp, EOF) == EOF)
185 return EOF;
186 if (_IO_in_backup (fp))
187 fp->_IO_read_base = fp->_IO_backup_base;
188 else
190 fp->_IO_read_base = fp->_IO_buf_base;
191 if (fp->_IO_write_ptr > fp->_IO_read_end)
192 fp->_IO_read_end = fp->_IO_write_ptr;
194 fp->_IO_read_ptr = fp->_IO_write_ptr;
196 fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end = fp->_IO_read_ptr;
198 fp->_flags &= ~_IO_CURRENTLY_PUTTING;
199 return 0;
201 libc_hidden_def (_IO_switch_to_get_mode)
203 void
204 _IO_free_backup_area (fp)
205 _IO_FILE *fp;
207 if (_IO_in_backup (fp))
208 _IO_switch_to_main_get_area (fp); /* Just in case. */
209 free (fp->_IO_save_base);
210 fp->_IO_save_base = NULL;
211 fp->_IO_save_end = NULL;
212 fp->_IO_backup_base = NULL;
214 libc_hidden_def (_IO_free_backup_area)
216 #if 0
218 _IO_switch_to_put_mode (fp)
219 _IO_FILE *fp;
221 fp->_IO_write_base = fp->_IO_read_ptr;
222 fp->_IO_write_ptr = fp->_IO_read_ptr;
223 /* Following is wrong if line- or un-buffered? */
224 fp->_IO_write_end = (fp->_flags & _IO_IN_BACKUP
225 ? fp->_IO_read_end : fp->_IO_buf_end);
227 fp->_IO_read_ptr = fp->_IO_read_end;
228 fp->_IO_read_base = fp->_IO_read_end;
230 fp->_flags |= _IO_CURRENTLY_PUTTING;
231 return 0;
233 #endif
236 __overflow (f, ch)
237 _IO_FILE *f;
238 int ch;
240 /* This is a single-byte stream. */
241 if (f->_mode == 0)
242 _IO_fwide (f, -1);
243 return _IO_OVERFLOW (f, ch);
245 libc_hidden_def (__overflow)
247 static int save_for_backup (_IO_FILE *fp, char *end_p)
248 #ifdef _LIBC
249 internal_function
250 #endif
253 static int
254 #ifdef _LIBC
255 internal_function
256 #endif
257 save_for_backup (fp, end_p)
258 _IO_FILE *fp;
259 char *end_p;
261 /* Append [_IO_read_base..end_p] to backup area. */
262 _IO_ssize_t least_mark = _IO_least_marker (fp, end_p);
263 /* needed_size is how much space we need in the backup area. */
264 _IO_size_t needed_size = (end_p - fp->_IO_read_base) - least_mark;
265 /* FIXME: Dubious arithmetic if pointers are NULL */
266 _IO_size_t current_Bsize = fp->_IO_save_end - fp->_IO_save_base;
267 _IO_size_t avail; /* Extra space available for future expansion. */
268 _IO_ssize_t delta;
269 struct _IO_marker *mark;
270 if (needed_size > current_Bsize)
272 char *new_buffer;
273 avail = 100;
274 new_buffer = (char *) malloc (avail + needed_size);
275 if (new_buffer == NULL)
276 return EOF; /* FIXME */
277 if (least_mark < 0)
279 #ifdef _LIBC
280 __mempcpy (__mempcpy (new_buffer + avail,
281 fp->_IO_save_end + least_mark,
282 -least_mark),
283 fp->_IO_read_base,
284 end_p - fp->_IO_read_base);
285 #else
286 memcpy (new_buffer + avail,
287 fp->_IO_save_end + least_mark,
288 -least_mark);
289 memcpy (new_buffer + avail - least_mark,
290 fp->_IO_read_base,
291 end_p - fp->_IO_read_base);
292 #endif
294 else
295 memcpy (new_buffer + avail,
296 fp->_IO_read_base + least_mark,
297 needed_size);
298 free (fp->_IO_save_base);
299 fp->_IO_save_base = new_buffer;
300 fp->_IO_save_end = new_buffer + avail + needed_size;
302 else
304 avail = current_Bsize - needed_size;
305 if (least_mark < 0)
307 memmove (fp->_IO_save_base + avail,
308 fp->_IO_save_end + least_mark,
309 -least_mark);
310 memcpy (fp->_IO_save_base + avail - least_mark,
311 fp->_IO_read_base,
312 end_p - fp->_IO_read_base);
314 else if (needed_size > 0)
315 memcpy (fp->_IO_save_base + avail,
316 fp->_IO_read_base + least_mark,
317 needed_size);
319 fp->_IO_backup_base = fp->_IO_save_base + avail;
320 /* Adjust all the streammarkers. */
321 delta = end_p - fp->_IO_read_base;
322 for (mark = fp->_markers; mark != NULL; mark = mark->_next)
323 mark->_pos -= delta;
324 return 0;
328 __underflow (fp)
329 _IO_FILE *fp;
331 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
332 if (_IO_vtable_offset (fp) == 0 && _IO_fwide (fp, -1) != -1)
333 return EOF;
334 #endif
336 if (fp->_mode == 0)
337 _IO_fwide (fp, -1);
338 if (_IO_in_put_mode (fp))
339 if (_IO_switch_to_get_mode (fp) == EOF)
340 return EOF;
341 if (fp->_IO_read_ptr < fp->_IO_read_end)
342 return *(unsigned char *) fp->_IO_read_ptr;
343 if (_IO_in_backup (fp))
345 _IO_switch_to_main_get_area (fp);
346 if (fp->_IO_read_ptr < fp->_IO_read_end)
347 return *(unsigned char *) fp->_IO_read_ptr;
349 if (_IO_have_markers (fp))
351 if (save_for_backup (fp, fp->_IO_read_end))
352 return EOF;
354 else if (_IO_have_backup (fp))
355 _IO_free_backup_area (fp);
356 return _IO_UNDERFLOW (fp);
358 libc_hidden_def (__underflow)
361 __uflow (fp)
362 _IO_FILE *fp;
364 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
365 if (_IO_vtable_offset (fp) == 0 && _IO_fwide (fp, -1) != -1)
366 return EOF;
367 #endif
369 if (fp->_mode == 0)
370 _IO_fwide (fp, -1);
371 if (_IO_in_put_mode (fp))
372 if (_IO_switch_to_get_mode (fp) == EOF)
373 return EOF;
374 if (fp->_IO_read_ptr < fp->_IO_read_end)
375 return *(unsigned char *) fp->_IO_read_ptr++;
376 if (_IO_in_backup (fp))
378 _IO_switch_to_main_get_area (fp);
379 if (fp->_IO_read_ptr < fp->_IO_read_end)
380 return *(unsigned char *) fp->_IO_read_ptr++;
382 if (_IO_have_markers (fp))
384 if (save_for_backup (fp, fp->_IO_read_end))
385 return EOF;
387 else if (_IO_have_backup (fp))
388 _IO_free_backup_area (fp);
389 return _IO_UFLOW (fp);
391 libc_hidden_def (__uflow)
393 void
394 _IO_setb (f, b, eb, a)
395 _IO_FILE *f;
396 char *b;
397 char *eb;
398 int a;
400 if (f->_IO_buf_base && !(f->_flags & _IO_USER_BUF))
401 FREE_BUF (f->_IO_buf_base, _IO_blen (f));
402 f->_IO_buf_base = b;
403 f->_IO_buf_end = eb;
404 if (a)
405 f->_flags &= ~_IO_USER_BUF;
406 else
407 f->_flags |= _IO_USER_BUF;
409 libc_hidden_def (_IO_setb)
411 void
412 _IO_doallocbuf (fp)
413 _IO_FILE *fp;
415 if (fp->_IO_buf_base)
416 return;
417 if (!(fp->_flags & _IO_UNBUFFERED) || fp->_mode > 0)
418 if (_IO_DOALLOCATE (fp) != EOF)
419 return;
420 _IO_setb (fp, fp->_shortbuf, fp->_shortbuf+1, 0);
422 libc_hidden_def (_IO_doallocbuf)
425 _IO_default_underflow (fp)
426 _IO_FILE *fp;
428 return EOF;
432 _IO_default_uflow (fp)
433 _IO_FILE *fp;
435 int ch = _IO_UNDERFLOW (fp);
436 if (ch == EOF)
437 return EOF;
438 return *(unsigned char *) fp->_IO_read_ptr++;
440 libc_hidden_def (_IO_default_uflow)
442 _IO_size_t
443 _IO_default_xsputn (f, data, n)
444 _IO_FILE *f;
445 const void *data;
446 _IO_size_t n;
448 const char *s = (char *) data;
449 _IO_size_t more = n;
450 if (more <= 0)
451 return 0;
452 for (;;)
454 /* Space available. */
455 if (f->_IO_write_ptr < f->_IO_write_end)
457 _IO_size_t count = f->_IO_write_end - f->_IO_write_ptr;
458 if (count > more)
459 count = more;
460 if (count > 20)
462 #ifdef _LIBC
463 f->_IO_write_ptr = __mempcpy (f->_IO_write_ptr, s, count);
464 #else
465 memcpy (f->_IO_write_ptr, s, count);
466 f->_IO_write_ptr += count;
467 #endif
468 s += count;
470 else if (count)
472 char *p = f->_IO_write_ptr;
473 _IO_ssize_t i;
474 for (i = count; --i >= 0; )
475 *p++ = *s++;
476 f->_IO_write_ptr = p;
478 more -= count;
480 if (more == 0 || _IO_OVERFLOW (f, (unsigned char) *s++) == EOF)
481 break;
482 more--;
484 return n - more;
486 libc_hidden_def (_IO_default_xsputn)
488 _IO_size_t
489 _IO_sgetn (fp, data, n)
490 _IO_FILE *fp;
491 void *data;
492 _IO_size_t n;
494 /* FIXME handle putback buffer here! */
495 return _IO_XSGETN (fp, data, n);
497 libc_hidden_def (_IO_sgetn)
499 _IO_size_t
500 _IO_default_xsgetn (fp, data, n)
501 _IO_FILE *fp;
502 void *data;
503 _IO_size_t n;
505 _IO_size_t more = n;
506 char *s = (char*) data;
507 for (;;)
509 /* Data available. */
510 if (fp->_IO_read_ptr < fp->_IO_read_end)
512 _IO_size_t count = fp->_IO_read_end - fp->_IO_read_ptr;
513 if (count > more)
514 count = more;
515 if (count > 20)
517 #ifdef _LIBC
518 s = __mempcpy (s, fp->_IO_read_ptr, count);
519 #else
520 memcpy (s, fp->_IO_read_ptr, count);
521 s += count;
522 #endif
523 fp->_IO_read_ptr += count;
525 else if (count)
527 char *p = fp->_IO_read_ptr;
528 int i = (int) count;
529 while (--i >= 0)
530 *s++ = *p++;
531 fp->_IO_read_ptr = p;
533 more -= count;
535 if (more == 0 || __underflow (fp) == EOF)
536 break;
538 return n - more;
540 libc_hidden_def (_IO_default_xsgetn)
542 #if 0
543 /* Seems not to be needed. --drepper */
545 _IO_sync (fp)
546 _IO_FILE *fp;
548 return 0;
550 #endif
552 _IO_FILE *
553 _IO_default_setbuf (fp, p, len)
554 _IO_FILE *fp;
555 char *p;
556 _IO_ssize_t len;
558 if (_IO_SYNC (fp) == EOF)
559 return NULL;
560 if (p == NULL || len == 0)
562 fp->_flags |= _IO_UNBUFFERED;
563 _IO_setb (fp, fp->_shortbuf, fp->_shortbuf+1, 0);
565 else
567 fp->_flags &= ~_IO_UNBUFFERED;
568 _IO_setb (fp, p, p+len, 0);
570 fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end = 0;
571 fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_read_end = 0;
572 return fp;
575 _IO_off64_t
576 _IO_default_seekpos (fp, pos, mode)
577 _IO_FILE *fp;
578 _IO_off64_t pos;
579 int mode;
581 return _IO_SEEKOFF (fp, pos, 0, mode);
585 _IO_default_doallocate (fp)
586 _IO_FILE *fp;
588 char *buf;
590 ALLOC_BUF (buf, _IO_BUFSIZ, EOF);
591 _IO_setb (fp, buf, buf+_IO_BUFSIZ, 1);
592 return 1;
594 libc_hidden_def (_IO_default_doallocate)
596 void
597 _IO_init (fp, flags)
598 _IO_FILE *fp;
599 int flags;
601 _IO_no_init (fp, flags, -1, NULL, NULL);
603 libc_hidden_def (_IO_init)
605 void
606 _IO_old_init (fp, flags)
607 _IO_FILE *fp;
608 int flags;
610 fp->_flags = _IO_MAGIC|flags;
611 fp->_flags2 = 0;
612 fp->_IO_buf_base = NULL;
613 fp->_IO_buf_end = NULL;
614 fp->_IO_read_base = NULL;
615 fp->_IO_read_ptr = NULL;
616 fp->_IO_read_end = NULL;
617 fp->_IO_write_base = NULL;
618 fp->_IO_write_ptr = NULL;
619 fp->_IO_write_end = NULL;
620 fp->_chain = NULL; /* Not necessary. */
622 fp->_IO_save_base = NULL;
623 fp->_IO_backup_base = NULL;
624 fp->_IO_save_end = NULL;
625 fp->_markers = NULL;
626 fp->_cur_column = 0;
627 #if _IO_JUMPS_OFFSET
628 fp->_vtable_offset = 0;
629 #endif
630 #ifdef _IO_MTSAFE_IO
631 if (fp->_lock != NULL)
632 _IO_lock_init (*fp->_lock);
633 #endif
636 void
637 _IO_no_init (fp, flags, orientation, wd, jmp)
638 _IO_FILE *fp;
639 int flags;
640 int orientation;
641 struct _IO_wide_data *wd;
642 const struct _IO_jump_t *jmp;
644 _IO_old_init (fp, flags);
645 fp->_mode = orientation;
646 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
647 if (orientation >= 0)
649 fp->_wide_data = wd;
650 fp->_wide_data->_IO_buf_base = NULL;
651 fp->_wide_data->_IO_buf_end = NULL;
652 fp->_wide_data->_IO_read_base = NULL;
653 fp->_wide_data->_IO_read_ptr = NULL;
654 fp->_wide_data->_IO_read_end = NULL;
655 fp->_wide_data->_IO_write_base = NULL;
656 fp->_wide_data->_IO_write_ptr = NULL;
657 fp->_wide_data->_IO_write_end = NULL;
658 fp->_wide_data->_IO_save_base = NULL;
659 fp->_wide_data->_IO_backup_base = NULL;
660 fp->_wide_data->_IO_save_end = NULL;
662 fp->_wide_data->_wide_vtable = jmp;
664 else
665 /* Cause predictable crash when a wide function is called on a byte
666 stream. */
667 fp->_wide_data = (struct _IO_wide_data *) -1L;
668 #endif
669 fp->_freeres_list = NULL;
673 _IO_default_sync (fp)
674 _IO_FILE *fp;
676 return 0;
679 /* The way the C++ classes are mapped into the C functions in the
680 current implementation, this function can get called twice! */
682 void
683 _IO_default_finish (fp, dummy)
684 _IO_FILE *fp;
685 int dummy;
687 struct _IO_marker *mark;
688 if (fp->_IO_buf_base && !(fp->_flags & _IO_USER_BUF))
690 FREE_BUF (fp->_IO_buf_base, _IO_blen (fp));
691 fp->_IO_buf_base = fp->_IO_buf_end = NULL;
694 for (mark = fp->_markers; mark != NULL; mark = mark->_next)
695 mark->_sbuf = NULL;
697 if (fp->_IO_save_base)
699 free (fp->_IO_save_base);
700 fp->_IO_save_base = NULL;
703 _IO_un_link ((struct _IO_FILE_plus *) fp);
705 #ifdef _IO_MTSAFE_IO
706 if (fp->_lock != NULL)
707 _IO_lock_fini (*fp->_lock);
708 #endif
710 libc_hidden_def (_IO_default_finish)
712 _IO_off64_t
713 _IO_default_seekoff (fp, offset, dir, mode)
714 _IO_FILE *fp;
715 _IO_off64_t offset;
716 int dir;
717 int mode;
719 return _IO_pos_BAD;
723 _IO_sputbackc (fp, c)
724 _IO_FILE *fp;
725 int c;
727 int result;
729 if (fp->_IO_read_ptr > fp->_IO_read_base
730 && (unsigned char)fp->_IO_read_ptr[-1] == (unsigned char)c)
732 fp->_IO_read_ptr--;
733 result = (unsigned char) c;
735 else
736 result = _IO_PBACKFAIL (fp, c);
738 if (result != EOF)
739 fp->_flags &= ~_IO_EOF_SEEN;
741 return result;
743 libc_hidden_def (_IO_sputbackc)
746 _IO_sungetc (fp)
747 _IO_FILE *fp;
749 int result;
751 if (fp->_IO_read_ptr > fp->_IO_read_base)
753 fp->_IO_read_ptr--;
754 result = (unsigned char) *fp->_IO_read_ptr;
756 else
757 result = _IO_PBACKFAIL (fp, EOF);
759 if (result != EOF)
760 fp->_flags &= ~_IO_EOF_SEEN;
762 return result;
765 #if 0 /* Work in progress */
766 /* Seems not to be needed. */
767 #if 0
768 void
769 _IO_set_column (fp, c)
770 _IO_FILE *fp;
771 int c;
773 if (c == -1)
774 fp->_column = -1;
775 else
776 fp->_column = c - (fp->_IO_write_ptr - fp->_IO_write_base);
778 #else
780 _IO_set_column (fp, i)
781 _IO_FILE *fp;
782 int i;
784 fp->_cur_column = i + 1;
785 return 0;
787 #endif
788 #endif
791 unsigned
792 _IO_adjust_column (start, line, count)
793 unsigned start;
794 const char *line;
795 int count;
797 const char *ptr = line + count;
798 while (ptr > line)
799 if (*--ptr == '\n')
800 return line + count - ptr - 1;
801 return start + count;
803 libc_hidden_def (_IO_adjust_column)
805 #if 0
806 /* Seems not to be needed. --drepper */
808 _IO_get_column (fp)
809 _IO_FILE *fp;
811 if (fp->_cur_column)
812 return _IO_adjust_column (fp->_cur_column - 1,
813 fp->_IO_write_base,
814 fp->_IO_write_ptr - fp->_IO_write_base);
815 return -1;
817 #endif
821 _IO_flush_all_lockp (int do_lock)
823 int result = 0;
824 struct _IO_FILE *fp;
825 int last_stamp;
827 #ifdef _IO_MTSAFE_IO
828 __libc_cleanup_region_start (do_lock, flush_cleanup, NULL);
829 if (do_lock)
830 _IO_lock_lock (list_all_lock);
831 #endif
833 last_stamp = _IO_list_all_stamp;
834 fp = (_IO_FILE *) _IO_list_all;
835 while (fp != NULL)
837 run_fp = fp;
838 if (do_lock)
839 _IO_flockfile (fp);
841 if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)
842 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
843 || (_IO_vtable_offset (fp) == 0
844 && fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr
845 > fp->_wide_data->_IO_write_base))
846 #endif
848 && _IO_OVERFLOW (fp, EOF) == EOF)
849 result = EOF;
851 if (do_lock)
852 _IO_funlockfile (fp);
853 run_fp = NULL;
855 if (last_stamp != _IO_list_all_stamp)
857 /* Something was added to the list. Start all over again. */
858 fp = (_IO_FILE *) _IO_list_all;
859 last_stamp = _IO_list_all_stamp;
861 else
862 fp = fp->_chain;
865 #ifdef _IO_MTSAFE_IO
866 if (do_lock)
867 _IO_lock_unlock (list_all_lock);
868 __libc_cleanup_region_end (0);
869 #endif
871 return result;
876 _IO_flush_all (void)
878 /* We want locking. */
879 return _IO_flush_all_lockp (1);
881 libc_hidden_def (_IO_flush_all)
883 void
884 _IO_flush_all_linebuffered (void)
886 struct _IO_FILE *fp;
887 int last_stamp;
889 #ifdef _IO_MTSAFE_IO
890 _IO_cleanup_region_start_noarg (flush_cleanup);
891 _IO_lock_lock (list_all_lock);
892 #endif
894 last_stamp = _IO_list_all_stamp;
895 fp = (_IO_FILE *) _IO_list_all;
896 while (fp != NULL)
898 run_fp = fp;
899 _IO_flockfile (fp);
901 if ((fp->_flags & _IO_NO_WRITES) == 0 && fp->_flags & _IO_LINE_BUF)
902 _IO_OVERFLOW (fp, EOF);
904 _IO_funlockfile (fp);
905 run_fp = NULL;
907 if (last_stamp != _IO_list_all_stamp)
909 /* Something was added to the list. Start all over again. */
910 fp = (_IO_FILE *) _IO_list_all;
911 last_stamp = _IO_list_all_stamp;
913 else
914 fp = fp->_chain;
917 #ifdef _IO_MTSAFE_IO
918 _IO_lock_unlock (list_all_lock);
919 _IO_cleanup_region_end (0);
920 #endif
922 libc_hidden_def (_IO_flush_all_linebuffered)
923 #ifdef _LIBC
924 weak_alias (_IO_flush_all_linebuffered, _flushlbf)
925 #endif
928 /* The following is a bit tricky. In general, we want to unbuffer the
929 streams so that all output which follows is seen. If we are not
930 looking for memory leaks it does not make much sense to free the
931 actual buffer because this will happen anyway once the program
932 terminated. If we do want to look for memory leaks we have to free
933 the buffers. Whether something is freed is determined by the
934 function sin the libc_freeres section. Those are called as part of
935 the atexit routine, just like _IO_cleanup. The problem is we do
936 not know whether the freeres code is called first or _IO_cleanup.
937 if the former is the case, we set the DEALLOC_BUFFER variable to
938 true and _IO_unbuffer_all will take care of the rest. If
939 _IO_unbuffer_all is called first we add the streams to a list
940 which the freeres function later can walk through. */
941 static void _IO_unbuffer_all (void);
943 static bool dealloc_buffers;
944 static _IO_FILE *freeres_list;
946 static void
947 _IO_unbuffer_all (void)
949 struct _IO_FILE *fp;
950 for (fp = (_IO_FILE *) _IO_list_all; fp; fp = fp->_chain)
952 if (! (fp->_flags & _IO_UNBUFFERED)
953 /* Iff stream is un-orientated, it wasn't used. */
954 && fp->_mode != 0)
956 #ifdef _IO_MTSAFE_IO
957 int cnt;
958 #define MAXTRIES 2
959 for (cnt = 0; cnt < MAXTRIES; ++cnt)
960 if (fp->_lock == NULL || _IO_lock_trylock (*fp->_lock) == 0)
961 break;
962 else
963 /* Give the other thread time to finish up its use of the
964 stream. */
965 __sched_yield ();
966 #endif
968 if (! dealloc_buffers && !(fp->_flags & _IO_USER_BUF))
970 fp->_flags |= _IO_USER_BUF;
972 fp->_freeres_list = freeres_list;
973 freeres_list = fp;
974 fp->_freeres_buf = fp->_IO_buf_base;
975 fp->_freeres_size = _IO_blen (fp);
978 _IO_SETBUF (fp, NULL, 0);
980 #ifdef _IO_MTSAFE_IO
981 if (cnt < MAXTRIES && fp->_lock != NULL)
982 _IO_lock_unlock (*fp->_lock);
983 #endif
986 /* Make sure that never again the wide char functions can be
987 used. */
988 fp->_mode = -1;
993 libc_freeres_fn (buffer_free)
995 dealloc_buffers = true;
997 while (freeres_list != NULL)
999 FREE_BUF (freeres_list->_freeres_buf, freeres_list->_freeres_size);
1001 freeres_list = freeres_list->_freeres_list;
1007 _IO_cleanup (void)
1009 /* We do *not* want locking. Some threads might use streams but
1010 that is their problem, we flush them underneath them. */
1011 int result = _IO_flush_all_lockp (0);
1013 /* We currently don't have a reliable mechanism for making sure that
1014 C++ static destructors are executed in the correct order.
1015 So it is possible that other static destructors might want to
1016 write to cout - and they're supposed to be able to do so.
1018 The following will make the standard streambufs be unbuffered,
1019 which forces any output from late destructors to be written out. */
1020 _IO_unbuffer_all ();
1022 return result;
1026 void
1027 _IO_init_marker (marker, fp)
1028 struct _IO_marker *marker;
1029 _IO_FILE *fp;
1031 marker->_sbuf = fp;
1032 if (_IO_in_put_mode (fp))
1033 _IO_switch_to_get_mode (fp);
1034 if (_IO_in_backup (fp))
1035 marker->_pos = fp->_IO_read_ptr - fp->_IO_read_end;
1036 else
1037 marker->_pos = fp->_IO_read_ptr - fp->_IO_read_base;
1039 /* Should perhaps sort the chain? */
1040 marker->_next = fp->_markers;
1041 fp->_markers = marker;
1044 void
1045 _IO_remove_marker (marker)
1046 struct _IO_marker *marker;
1048 /* Unlink from sb's chain. */
1049 struct _IO_marker **ptr = &marker->_sbuf->_markers;
1050 for (; ; ptr = &(*ptr)->_next)
1052 if (*ptr == NULL)
1053 break;
1054 else if (*ptr == marker)
1056 *ptr = marker->_next;
1057 return;
1060 #if 0
1061 if _sbuf has a backup area that is no longer needed, should we delete
1062 it now, or wait until the next underflow?
1063 #endif
1066 #define BAD_DELTA EOF
1069 _IO_marker_difference (mark1, mark2)
1070 struct _IO_marker *mark1;
1071 struct _IO_marker *mark2;
1073 return mark1->_pos - mark2->_pos;
1076 /* Return difference between MARK and current position of MARK's stream. */
1078 _IO_marker_delta (mark)
1079 struct _IO_marker *mark;
1081 int cur_pos;
1082 if (mark->_sbuf == NULL)
1083 return BAD_DELTA;
1084 if (_IO_in_backup (mark->_sbuf))
1085 cur_pos = mark->_sbuf->_IO_read_ptr - mark->_sbuf->_IO_read_end;
1086 else
1087 cur_pos = mark->_sbuf->_IO_read_ptr - mark->_sbuf->_IO_read_base;
1088 return mark->_pos - cur_pos;
1092 _IO_seekmark (fp, mark, delta)
1093 _IO_FILE *fp;
1094 struct _IO_marker *mark;
1095 int delta;
1097 if (mark->_sbuf != fp)
1098 return EOF;
1099 if (mark->_pos >= 0)
1101 if (_IO_in_backup (fp))
1102 _IO_switch_to_main_get_area (fp);
1103 fp->_IO_read_ptr = fp->_IO_read_base + mark->_pos;
1105 else
1107 if (!_IO_in_backup (fp))
1108 _IO_switch_to_backup_area (fp);
1109 fp->_IO_read_ptr = fp->_IO_read_end + mark->_pos;
1111 return 0;
1114 void
1115 _IO_unsave_markers (fp)
1116 _IO_FILE *fp;
1118 struct _IO_marker *mark = fp->_markers;
1119 if (mark)
1121 #ifdef TODO
1122 streampos offset = seekoff (0, ios::cur, ios::in);
1123 if (offset != EOF)
1125 offset += eGptr () - Gbase ();
1126 for ( ; mark != NULL; mark = mark->_next)
1127 mark->set_streampos (mark->_pos + offset);
1129 else
1131 for ( ; mark != NULL; mark = mark->_next)
1132 mark->set_streampos (EOF);
1134 #endif
1135 fp->_markers = 0;
1138 if (_IO_have_backup (fp))
1139 _IO_free_backup_area (fp);
1141 libc_hidden_def (_IO_unsave_markers)
1143 #if 0
1144 /* Seems not to be needed. --drepper */
1146 _IO_nobackup_pbackfail (fp, c)
1147 _IO_FILE *fp;
1148 int c;
1150 if (fp->_IO_read_ptr > fp->_IO_read_base)
1151 fp->_IO_read_ptr--;
1152 if (c != EOF && *fp->_IO_read_ptr != c)
1153 *fp->_IO_read_ptr = c;
1154 return (unsigned char) c;
1156 #endif
1159 _IO_default_pbackfail (fp, c)
1160 _IO_FILE *fp;
1161 int c;
1163 if (fp->_IO_read_ptr > fp->_IO_read_base && !_IO_in_backup (fp)
1164 && (unsigned char) fp->_IO_read_ptr[-1] == c)
1165 --fp->_IO_read_ptr;
1166 else
1168 /* Need to handle a filebuf in write mode (switch to read mode). FIXME!*/
1169 if (!_IO_in_backup (fp))
1171 /* We need to keep the invariant that the main get area
1172 logically follows the backup area. */
1173 if (fp->_IO_read_ptr > fp->_IO_read_base && _IO_have_backup (fp))
1175 if (save_for_backup (fp, fp->_IO_read_ptr))
1176 return EOF;
1178 else if (!_IO_have_backup (fp))
1180 /* No backup buffer: allocate one. */
1181 /* Use nshort buffer, if unused? (probably not) FIXME */
1182 int backup_size = 128;
1183 char *bbuf = (char *) malloc (backup_size);
1184 if (bbuf == NULL)
1185 return EOF;
1186 fp->_IO_save_base = bbuf;
1187 fp->_IO_save_end = fp->_IO_save_base + backup_size;
1188 fp->_IO_backup_base = fp->_IO_save_end;
1190 fp->_IO_read_base = fp->_IO_read_ptr;
1191 _IO_switch_to_backup_area (fp);
1193 else if (fp->_IO_read_ptr <= fp->_IO_read_base)
1195 /* Increase size of existing backup buffer. */
1196 _IO_size_t new_size;
1197 _IO_size_t old_size = fp->_IO_read_end - fp->_IO_read_base;
1198 char *new_buf;
1199 new_size = 2 * old_size;
1200 new_buf = (char *) malloc (new_size);
1201 if (new_buf == NULL)
1202 return EOF;
1203 memcpy (new_buf + (new_size - old_size), fp->_IO_read_base,
1204 old_size);
1205 free (fp->_IO_read_base);
1206 _IO_setg (fp, new_buf, new_buf + (new_size - old_size),
1207 new_buf + new_size);
1208 fp->_IO_backup_base = fp->_IO_read_ptr;
1211 *--fp->_IO_read_ptr = c;
1213 return (unsigned char) c;
1215 libc_hidden_def (_IO_default_pbackfail)
1217 _IO_off64_t
1218 _IO_default_seek (fp, offset, dir)
1219 _IO_FILE *fp;
1220 _IO_off64_t offset;
1221 int dir;
1223 return _IO_pos_BAD;
1227 _IO_default_stat (fp, st)
1228 _IO_FILE *fp;
1229 void* st;
1231 return EOF;
1234 _IO_ssize_t
1235 _IO_default_read (fp, data, n)
1236 _IO_FILE* fp;
1237 void *data;
1238 _IO_ssize_t n;
1240 return -1;
1243 _IO_ssize_t
1244 _IO_default_write (fp, data, n)
1245 _IO_FILE *fp;
1246 const void *data;
1247 _IO_ssize_t n;
1249 return 0;
1253 _IO_default_showmanyc (fp)
1254 _IO_FILE *fp;
1256 return -1;
1259 void
1260 _IO_default_imbue (fp, locale)
1261 _IO_FILE *fp;
1262 void *locale;
1266 _IO_ITER
1267 _IO_iter_begin (void)
1269 return (_IO_ITER) _IO_list_all;
1271 libc_hidden_def (_IO_iter_begin)
1273 _IO_ITER
1274 _IO_iter_end (void)
1276 return NULL;
1278 libc_hidden_def (_IO_iter_end)
1280 _IO_ITER
1281 _IO_iter_next(iter)
1282 _IO_ITER iter;
1284 return iter->_chain;
1286 libc_hidden_def (_IO_iter_next)
1288 _IO_FILE *
1289 _IO_iter_file(iter)
1290 _IO_ITER iter;
1292 return iter;
1294 libc_hidden_def (_IO_iter_file)
1296 void
1297 _IO_list_lock (void)
1299 #ifdef _IO_MTSAFE_IO
1300 _IO_lock_lock (list_all_lock);
1301 #endif
1303 libc_hidden_def (_IO_list_lock)
1305 void
1306 _IO_list_unlock (void)
1308 #ifdef _IO_MTSAFE_IO
1309 _IO_lock_unlock (list_all_lock);
1310 #endif
1312 libc_hidden_def (_IO_list_unlock)
1314 void
1315 _IO_list_resetlock (void)
1317 #ifdef _IO_MTSAFE_IO
1318 _IO_lock_init (list_all_lock);
1319 #endif
1321 libc_hidden_def (_IO_list_resetlock)
1324 #ifdef TODO
1325 #if defined(linux)
1326 #define IO_CLEANUP ;
1327 #endif
1329 #ifdef IO_CLEANUP
1330 IO_CLEANUP
1331 #else
1332 struct __io_defs {
1333 __io_defs() { }
1334 ~__io_defs() { _IO_cleanup (); }
1336 __io_defs io_defs__;
1337 #endif
1339 #endif /* TODO */
1341 #ifdef text_set_element
1342 text_set_element(__libc_atexit, _IO_cleanup);
1343 #endif