Merge with libstdc++-v3.
[kopensolaris-gnu/glibc.git] / libio / genops.c
1 /* Copyright (C) 1993, 1995, 1997-1999, 2000 Free Software Foundation, Inc.
2    This file is part of the GNU IO Library.
3
4    This library is free software; you can redistribute it and/or
5    modify it under the terms of the GNU General Public License as
6    published by the Free Software Foundation; either version 2, or (at
7    your option) any later version.
8
9    This library is distributed in the hope that it will be useful, but
10    WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12    General Public License for more details.
13
14    You should have received a copy of the GNU General Public License
15    along with this library; see the file COPYING.  If not, write to
16    the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
17    MA 02111-1307, USA.
18
19    As a special exception, if you link this library with files
20    compiled with a GNU compiler to produce an executable, this does
21    not cause the resulting executable to be covered by the GNU General
22    Public License.  This exception does not however invalidate any
23    other reasons why the executable file might be covered by the GNU
24    General Public License.  */
25
26 /* Generic or default I/O operations. */
27
28 #include "libioP.h"
29 #ifdef __STDC__
30 #include <stdlib.h>
31 #endif
32 #include <string.h>
33
34 #ifdef _IO_MTSAFE_IO
35 static _IO_lock_t list_all_lock = _IO_lock_initializer;
36 #endif
37
38 void
39 _IO_un_link (fp)
40      struct _IO_FILE_plus *fp;
41 {
42   if (fp->file._flags & _IO_LINKED)
43     {
44       struct _IO_FILE_plus **f;
45 #ifdef _IO_MTSAFE_IO
46       _IO_lock_lock (list_all_lock);
47 #endif
48       for (f = &_IO_list_all; *f; f = (struct _IO_FILE_plus **) &(*f)->file._chain)
49         {
50           if (*f == fp)
51             {
52               *f = (struct _IO_FILE_plus *) fp->file._chain;
53               break;
54             }
55         }
56 #ifdef _IO_MTSAFE_IO
57       _IO_lock_unlock (list_all_lock);
58 #endif
59       fp->file._flags &= ~_IO_LINKED;
60     }
61 }
62
63 void
64 _IO_link_in (fp)
65      struct _IO_FILE_plus *fp;
66 {
67     if ((fp->file._flags & _IO_LINKED) == 0)
68       {
69         fp->file._flags |= _IO_LINKED;
70 #ifdef _IO_MTSAFE_IO
71         _IO_lock_lock (list_all_lock);
72 #endif
73         fp->file._chain = (_IO_FILE *) _IO_list_all;
74         _IO_list_all = fp;
75 #ifdef _IO_MTSAFE_IO
76         _IO_lock_unlock (list_all_lock);
77 #endif
78       }
79 }
80
81 /* Return minimum _pos markers
82    Assumes the current get area is the main get area. */
83 _IO_ssize_t _IO_least_marker __P ((_IO_FILE *fp, char *end_p));
84
85 _IO_ssize_t
86 _IO_least_marker (fp, end_p)
87      _IO_FILE *fp;
88      char *end_p;
89 {
90   _IO_ssize_t least_so_far = end_p - fp->_IO_read_base;
91   struct _IO_marker *mark;
92   for (mark = fp->_markers; mark != NULL; mark = mark->_next)
93     if (mark->_pos < least_so_far)
94       least_so_far = mark->_pos;
95   return least_so_far;
96 }
97
98 /* Switch current get area from backup buffer to (start of) main get area. */
99
100 void
101 _IO_switch_to_main_get_area (fp)
102      _IO_FILE *fp;
103 {
104   char *tmp;
105   fp->_flags &= ~_IO_IN_BACKUP;
106   /* Swap _IO_read_end and _IO_save_end. */
107   tmp = fp->_IO_read_end;
108   fp->_IO_read_end = fp->_IO_save_end;
109   fp->_IO_save_end= tmp;
110   /* Swap _IO_read_base and _IO_save_base. */
111   tmp = fp->_IO_read_base;
112   fp->_IO_read_base = fp->_IO_save_base;
113   fp->_IO_save_base = tmp;
114   /* Set _IO_read_ptr. */
115   fp->_IO_read_ptr = fp->_IO_read_base;
116 }
117
118 /* Switch current get area from main get area to (end of) backup area. */
119
120 void
121 _IO_switch_to_backup_area (fp)
122      _IO_FILE *fp;
123 {
124   char *tmp;
125   fp->_flags |= _IO_IN_BACKUP;
126   /* Swap _IO_read_end and _IO_save_end. */
127   tmp = fp->_IO_read_end;
128   fp->_IO_read_end = fp->_IO_save_end;
129   fp->_IO_save_end = tmp;
130   /* Swap _IO_read_base and _IO_save_base. */
131   tmp = fp->_IO_read_base;
132   fp->_IO_read_base = fp->_IO_save_base;
133   fp->_IO_save_base = tmp;
134   /* Set _IO_read_ptr.  */
135   fp->_IO_read_ptr = fp->_IO_read_end;
136 }
137
138 int
139 _IO_switch_to_get_mode (fp)
140      _IO_FILE *fp;
141 {
142   if (fp->_IO_write_ptr > fp->_IO_write_base)
143     if (_IO_OVERFLOW (fp, EOF) == EOF)
144       return EOF;
145   if (_IO_in_backup (fp))
146     fp->_IO_read_base = fp->_IO_backup_base;
147   else
148     {
149       fp->_IO_read_base = fp->_IO_buf_base;
150       if (fp->_IO_write_ptr > fp->_IO_read_end)
151         fp->_IO_read_end = fp->_IO_write_ptr;
152     }
153   fp->_IO_read_ptr = fp->_IO_write_ptr;
154
155   fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end = fp->_IO_read_ptr;
156
157   fp->_flags &= ~_IO_CURRENTLY_PUTTING;
158   return 0;
159 }
160
161 void
162 _IO_free_backup_area (fp)
163      _IO_FILE *fp;
164 {
165   if (_IO_in_backup (fp))
166     _IO_switch_to_main_get_area (fp);  /* Just in case. */
167   free (fp->_IO_save_base);
168   fp->_IO_save_base = NULL;
169   fp->_IO_save_end = NULL;
170   fp->_IO_backup_base = NULL;
171 }
172
173 #if 0
174 int
175 _IO_switch_to_put_mode (fp)
176      _IO_FILE *fp;
177 {
178   fp->_IO_write_base = fp->_IO_read_ptr;
179   fp->_IO_write_ptr = fp->_IO_read_ptr;
180   /* Following is wrong if line- or un-buffered? */
181   fp->_IO_write_end = (fp->_flags & _IO_IN_BACKUP
182                        ? fp->_IO_read_end : fp->_IO_buf_end);
183
184   fp->_IO_read_ptr = fp->_IO_read_end;
185   fp->_IO_read_base = fp->_IO_read_end;
186
187   fp->_flags |= _IO_CURRENTLY_PUTTING;
188   return 0;
189 }
190 #endif
191
192 int
193 __overflow (f, ch)
194      _IO_FILE *f;
195      int ch;
196 {
197   /* This is a single-byte stream.  */
198   if (f->_mode == 0)
199     _IO_fwide (f, -1);
200   return _IO_OVERFLOW (f, ch);
201 }
202
203 static int save_for_backup __P ((_IO_FILE *fp, char *end_p))
204 #ifdef _LIBC
205      internal_function
206 #endif
207      ;
208
209 static int
210 #ifdef _LIBC
211 internal_function
212 #endif
213 save_for_backup (fp, end_p)
214      _IO_FILE *fp;
215      char *end_p;
216 {
217   /* Append [_IO_read_base..end_p] to backup area. */
218   _IO_ssize_t least_mark = _IO_least_marker (fp, end_p);
219   /* needed_size is how much space we need in the backup area. */
220   _IO_size_t needed_size = (end_p - fp->_IO_read_base) - least_mark;
221   /* FIXME: Dubious arithmetic if pointers are NULL */
222   _IO_size_t current_Bsize = fp->_IO_save_end - fp->_IO_save_base;
223   _IO_size_t avail; /* Extra space available for future expansion. */
224   _IO_ssize_t delta;
225   struct _IO_marker *mark;
226   if (needed_size > current_Bsize)
227     {
228       char *new_buffer;
229       avail = 100;
230       new_buffer = (char *) malloc (avail + needed_size);
231       if (new_buffer == NULL)
232         return EOF;             /* FIXME */
233       if (least_mark < 0)
234         {
235 #ifdef _LIBC
236           __mempcpy (__mempcpy (new_buffer + avail,
237                                 fp->_IO_save_end + least_mark,
238                                 -least_mark),
239                      fp->_IO_read_base,
240                      end_p - fp->_IO_read_base);
241 #else
242           memcpy (new_buffer + avail,
243                   fp->_IO_save_end + least_mark,
244                   -least_mark);
245           memcpy (new_buffer + avail - least_mark,
246                   fp->_IO_read_base,
247                   end_p - fp->_IO_read_base);
248 #endif
249         }
250       else
251         memcpy (new_buffer + avail,
252                 fp->_IO_read_base + least_mark,
253                 needed_size);
254       if (fp->_IO_save_base)
255         free (fp->_IO_save_base);
256       fp->_IO_save_base = new_buffer;
257       fp->_IO_save_end = new_buffer + avail + needed_size;
258     }
259   else
260     {
261       avail = current_Bsize - needed_size;
262       if (least_mark < 0)
263         {
264           memmove (fp->_IO_save_base + avail,
265                    fp->_IO_save_end + least_mark,
266                    -least_mark);
267           memcpy (fp->_IO_save_base + avail - least_mark,
268                   fp->_IO_read_base,
269                   end_p - fp->_IO_read_base);
270         }
271       else if (needed_size > 0)
272         memcpy (fp->_IO_save_base + avail,
273                 fp->_IO_read_base + least_mark,
274                 needed_size);
275     }
276   fp->_IO_backup_base = fp->_IO_save_base + avail;
277   /* Adjust all the streammarkers. */
278   delta = end_p - fp->_IO_read_base;
279   for (mark = fp->_markers; mark != NULL; mark = mark->_next)
280     mark->_pos -= delta;
281   return 0;
282 }
283
284 int
285 __underflow (fp)
286      _IO_FILE *fp;
287 {
288 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
289   if (fp->_vtable_offset == 0 && _IO_fwide (fp, -1) != -1)
290     return EOF;
291 #endif
292
293   if (fp->_mode == 0)
294     _IO_fwide (fp, -1);
295   if (_IO_in_put_mode (fp))
296     if (_IO_switch_to_get_mode (fp) == EOF)
297       return EOF;
298   if (fp->_IO_read_ptr < fp->_IO_read_end)
299     return *(unsigned char *) fp->_IO_read_ptr;
300   if (_IO_in_backup (fp))
301     {
302       _IO_switch_to_main_get_area (fp);
303       if (fp->_IO_read_ptr < fp->_IO_read_end)
304         return *(unsigned char *) fp->_IO_read_ptr;
305     }
306   if (_IO_have_markers (fp))
307     {
308       if (save_for_backup (fp, fp->_IO_read_end))
309         return EOF;
310     }
311   else if (_IO_have_backup (fp))
312     _IO_free_backup_area (fp);
313   return _IO_UNDERFLOW (fp);
314 }
315
316 int
317 __uflow (fp)
318      _IO_FILE *fp;
319 {
320 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
321   if (fp->_vtable_offset == 0 && _IO_fwide (fp, -1) != -1)
322     return EOF;
323 #endif
324
325   if (fp->_mode == 0)
326     _IO_fwide (fp, -11);
327   if (_IO_in_put_mode (fp))
328     if (_IO_switch_to_get_mode (fp) == EOF)
329       return EOF;
330   if (fp->_IO_read_ptr < fp->_IO_read_end)
331     return *(unsigned char *) fp->_IO_read_ptr++;
332   if (_IO_in_backup (fp))
333     {
334       _IO_switch_to_main_get_area (fp);
335       if (fp->_IO_read_ptr < fp->_IO_read_end)
336         return *(unsigned char *) fp->_IO_read_ptr++;
337     }
338   if (_IO_have_markers (fp))
339     {
340       if (save_for_backup (fp, fp->_IO_read_end))
341         return EOF;
342     }
343   else if (_IO_have_backup (fp))
344     _IO_free_backup_area (fp);
345   return _IO_UFLOW (fp);
346 }
347
348 void
349 _IO_setb (f, b, eb, a)
350      _IO_FILE *f;
351       char *b;
352      char *eb;
353      int a;
354 {
355   if (f->_IO_buf_base && !(f->_flags & _IO_USER_BUF))
356     FREE_BUF (f->_IO_buf_base, _IO_blen (f));
357   f->_IO_buf_base = b;
358   f->_IO_buf_end = eb;
359   if (a)
360     f->_flags &= ~_IO_USER_BUF;
361   else
362     f->_flags |= _IO_USER_BUF;
363 }
364
365 void
366 _IO_doallocbuf (fp)
367      _IO_FILE *fp;
368 {
369   if (fp->_IO_buf_base)
370     return;
371   if (!(fp->_flags & _IO_UNBUFFERED))
372     if (_IO_DOALLOCATE (fp) != EOF)
373       return;
374   _IO_setb (fp, fp->_shortbuf, fp->_shortbuf+1, 0);
375 }
376
377 int
378 _IO_default_underflow (fp)
379      _IO_FILE *fp;
380 {
381   return EOF;
382 }
383
384 int
385 _IO_default_uflow (fp)
386      _IO_FILE *fp;
387 {
388   int ch = _IO_UNDERFLOW (fp);
389   if (ch == EOF)
390     return EOF;
391   return *(unsigned char *) fp->_IO_read_ptr++;
392 }
393
394 _IO_size_t
395 _IO_default_xsputn (f, data, n)
396      _IO_FILE *f;
397      const void *data;
398      _IO_size_t n;
399 {
400   const char *s = (char *) data;
401   _IO_size_t more = n;
402   if (more <= 0)
403     return 0;
404   for (;;)
405     {
406       /* Space available. */
407       _IO_ssize_t count = f->_IO_write_end - f->_IO_write_ptr;
408       if (count > 0)
409         {
410           if ((_IO_size_t) count > more)
411             count = more;
412           if (count > 20)
413             {
414 #ifdef _LIBC
415               f->_IO_write_ptr = __mempcpy (f->_IO_write_ptr, s, count);
416 #else
417               memcpy (f->_IO_write_ptr, s, count);
418               f->_IO_write_ptr += count;
419 #endif
420               s += count;
421             }
422           else if (count <= 0)
423             count = 0;
424           else
425             {
426               char *p = f->_IO_write_ptr;
427               _IO_ssize_t i;
428               for (i = count; --i >= 0; )
429                 *p++ = *s++;
430               f->_IO_write_ptr = p;
431             }
432           more -= count;
433         }
434       if (more == 0 || _IO_OVERFLOW (f, (unsigned char) *s++) == EOF)
435         break;
436       more--;
437     }
438   return n - more;
439 }
440
441 _IO_size_t
442 _IO_sgetn (fp, data, n)
443      _IO_FILE *fp;
444      void *data;
445      _IO_size_t n;
446 {
447   /* FIXME handle putback buffer here! */
448   return _IO_XSGETN (fp, data, n);
449 }
450
451 _IO_size_t
452 _IO_default_xsgetn (fp, data, n)
453      _IO_FILE *fp;
454      void *data;
455      _IO_size_t n;
456 {
457   _IO_size_t more = n;
458   char *s = (char*) data;
459   for (;;)
460     {
461       /* Data available. */
462       _IO_ssize_t count = fp->_IO_read_end - fp->_IO_read_ptr;
463       if (count > 0)
464         {
465           if ((_IO_size_t) count > more)
466             count = more;
467           if (count > 20)
468             {
469 #ifdef _LIBC
470               s = __mempcpy (s, fp->_IO_read_ptr, count);
471 #else
472               memcpy (s, fp->_IO_read_ptr, count);
473               s += count;
474 #endif
475               fp->_IO_read_ptr += count;
476             }
477           else if (count <= 0)
478             count = 0;
479           else
480             {
481               char *p = fp->_IO_read_ptr;
482               int i = (int) count;
483               while (--i >= 0)
484                 *s++ = *p++;
485               fp->_IO_read_ptr = p;
486             }
487             more -= count;
488         }
489       if (more == 0 || __underflow (fp) == EOF)
490         break;
491     }
492   return n - more;
493 }
494
495 #if 0
496 /* Seems not to be needed. --drepper */
497 int
498 _IO_sync (fp)
499      _IO_FILE *fp;
500 {
501   return 0;
502 }
503 #endif
504
505 _IO_FILE *
506 _IO_default_setbuf (fp, p, len)
507      _IO_FILE *fp;
508      char *p;
509      _IO_ssize_t len;
510 {
511     if (_IO_SYNC (fp) == EOF)
512         return NULL;
513     if (p == NULL || len == 0)
514       {
515         fp->_flags |= _IO_UNBUFFERED;
516         _IO_setb (fp, fp->_shortbuf, fp->_shortbuf+1, 0);
517       }
518     else
519       {
520         fp->_flags &= ~_IO_UNBUFFERED;
521         _IO_setb (fp, p, p+len, 0);
522       }
523     fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end = 0;
524     fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_read_end = 0;
525     return fp;
526 }
527
528 _IO_off64_t
529 _IO_default_seekpos (fp, pos, mode)
530      _IO_FILE *fp;
531      _IO_off64_t pos;
532      int mode;
533 {
534   return _IO_SEEKOFF (fp, pos, 0, mode);
535 }
536
537 int
538 _IO_default_doallocate (fp)
539      _IO_FILE *fp;
540 {
541   char *buf;
542
543   ALLOC_BUF (buf, _IO_BUFSIZ, EOF);
544   _IO_setb (fp, buf, buf+_IO_BUFSIZ, 1);
545   return 1;
546 }
547
548 void
549 _IO_init (fp, flags)
550      _IO_FILE *fp;
551      int flags;
552 {
553   _IO_no_init (fp, flags, -1, NULL, NULL);
554 }
555
556 void
557 _IO_no_init (fp, flags, orientation, wd, jmp)
558      _IO_FILE *fp;
559      int flags;
560      int orientation;
561      struct _IO_wide_data *wd;
562      struct _IO_jump_t *jmp;
563 {
564   fp->_flags = _IO_MAGIC|flags;
565   fp->_IO_buf_base = NULL;
566   fp->_IO_buf_end = NULL;
567   fp->_IO_read_base = NULL;
568   fp->_IO_read_ptr = NULL;
569   fp->_IO_read_end = NULL;
570   fp->_IO_write_base = NULL;
571   fp->_IO_write_ptr = NULL;
572   fp->_IO_write_end = NULL;
573   fp->_chain = NULL; /* Not necessary. */
574
575   fp->_IO_save_base = NULL;
576   fp->_IO_backup_base = NULL;
577   fp->_IO_save_end = NULL;
578   fp->_markers = NULL;
579   fp->_cur_column = 0;
580 #if _IO_JUMPS_OFFSET
581   fp->_vtable_offset = 0;
582 #endif
583 #ifdef _IO_MTSAFE_IO
584   _IO_lock_init (*fp->_lock);
585 #endif
586   fp->_mode = orientation;
587 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
588   if (orientation >= 0)
589     {
590       fp->_wide_data = wd;
591       fp->_wide_data->_IO_buf_base = NULL;
592       fp->_wide_data->_IO_buf_end = NULL;
593       fp->_wide_data->_IO_read_base = NULL;
594       fp->_wide_data->_IO_read_ptr = NULL;
595       fp->_wide_data->_IO_read_end = NULL;
596       fp->_wide_data->_IO_write_base = NULL;
597       fp->_wide_data->_IO_write_ptr = NULL;
598       fp->_wide_data->_IO_write_end = NULL;
599       fp->_wide_data->_IO_save_base = NULL;
600       fp->_wide_data->_IO_backup_base = NULL;
601       fp->_wide_data->_IO_save_end = NULL;
602
603       fp->_wide_data->_wide_vtable = jmp;
604     }
605 #endif
606 }
607
608 int
609 _IO_default_sync (fp)
610      _IO_FILE *fp;
611 {
612   return 0;
613 }
614
615 /* The way the C++ classes are mapped into the C functions in the
616    current implementation, this function can get called twice! */
617
618 void
619 _IO_default_finish (fp, dummy)
620      _IO_FILE *fp;
621      int dummy;
622 {
623   struct _IO_marker *mark;
624   if (fp->_IO_buf_base && !(fp->_flags & _IO_USER_BUF))
625     {
626       FREE_BUF (fp->_IO_buf_base, _IO_blen (fp));
627       fp->_IO_buf_base = fp->_IO_buf_end = NULL;
628     }
629
630   for (mark = fp->_markers; mark != NULL; mark = mark->_next)
631     mark->_sbuf = NULL;
632
633   if (fp->_IO_save_base)
634     {
635       free (fp->_IO_save_base);
636       fp->_IO_save_base = NULL;
637     }
638
639 #ifdef _IO_MTSAFE_IO
640   _IO_lock_fini (*fp->_lock);
641 #endif
642
643   _IO_un_link ((struct _IO_FILE_plus *) fp);
644 }
645
646 _IO_off64_t
647 _IO_default_seekoff (fp, offset, dir, mode)
648      _IO_FILE *fp;
649      _IO_off64_t offset;
650      int dir;
651      int mode;
652 {
653     return _IO_pos_BAD;
654 }
655
656 int
657 _IO_sputbackc (fp, c)
658      _IO_FILE *fp;
659      int c;
660 {
661   int result;
662
663   if (fp->_IO_read_ptr > fp->_IO_read_base
664       && (unsigned char)fp->_IO_read_ptr[-1] == (unsigned char)c)
665     {
666       fp->_IO_read_ptr--;
667       result = (unsigned char) c;
668     }
669   else
670     result = _IO_PBACKFAIL (fp, c);
671
672   if (result != EOF)
673     fp->_flags &= ~_IO_EOF_SEEN;
674
675   return result;
676 }
677
678 int
679 _IO_sungetc (fp)
680      _IO_FILE *fp;
681 {
682   int result;
683
684   if (fp->_IO_read_ptr > fp->_IO_read_base)
685     {
686       fp->_IO_read_ptr--;
687       result = (unsigned char) *fp->_IO_read_ptr;
688     }
689   else
690     result = _IO_PBACKFAIL (fp, EOF);
691
692   if (result != EOF)
693     fp->_flags &= ~_IO_EOF_SEEN;
694
695   return result;
696 }
697
698 #if 0 /* Work in progress */
699 /* Seems not to be needed.  */
700 #if 0
701 void
702 _IO_set_column (fp, c)
703      _IO_FILE *fp;
704      int c;
705 {
706   if (c == -1)
707     fp->_column = -1;
708   else
709     fp->_column = c - (fp->_IO_write_ptr - fp->_IO_write_base);
710 }
711 #else
712 int
713 _IO_set_column (fp, i)
714      _IO_FILE *fp;
715      int i;
716 {
717   fp->_cur_column = i + 1;
718   return 0;
719 }
720 #endif
721 #endif
722
723
724 unsigned
725 _IO_adjust_column (start, line, count)
726      unsigned start;
727      const char *line;
728      int count;
729 {
730   const char *ptr = line + count;
731   while (ptr > line)
732     if (*--ptr == '\n')
733       return line + count - ptr - 1;
734   return start + count;
735 }
736
737 #if 0
738 /* Seems not to be needed. --drepper */
739 int
740 _IO_get_column (fp)
741      _IO_FILE *fp;
742 {
743   if (fp->_cur_column)
744     return _IO_adjust_column (fp->_cur_column - 1,
745                               fp->_IO_write_base,
746                               fp->_IO_write_ptr - fp->_IO_write_base);
747   return -1;
748 }
749 #endif
750
751 int
752 _IO_flush_all ()
753 {
754   int result = 0;
755   struct _IO_FILE *fp;
756   for (fp = (_IO_FILE *) _IO_list_all; fp; fp = fp->_chain)
757     if (((fp->_mode < 0 && fp->_IO_write_ptr > fp->_IO_write_base)
758 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
759          || (fp->_vtable_offset == 0
760              && fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr
761                                   > fp->_wide_data->_IO_write_base))
762 #endif
763          )
764         && _IO_OVERFLOW (fp, EOF) == EOF)
765       result = EOF;
766   return result;
767 }
768
769 void
770 _IO_flush_all_linebuffered ()
771 {
772   struct _IO_FILE *fp;
773   for (fp = (_IO_FILE *) _IO_list_all; fp; fp = fp->_chain)
774     if ((fp->_flags & _IO_NO_WRITES) == 0 && fp->_flags & _IO_LINE_BUF)
775       _IO_OVERFLOW (fp, EOF);
776 }
777
778 static void _IO_unbuffer_write __P ((void));
779
780 static void
781 _IO_unbuffer_write ()
782 {
783   struct _IO_FILE *fp;
784   for (fp = (_IO_FILE *) _IO_list_all; fp; fp = fp->_chain)
785     if (! (fp->_flags & _IO_UNBUFFERED)
786         && (! (fp->_flags & _IO_NO_WRITES)
787             || (fp->_flags & _IO_IS_APPENDING))
788         /* Iff stream is un-orientated, it wasn't used. */
789         && fp->_mode != 0)
790       _IO_SETBUF (fp, NULL, 0);
791 }
792
793 int
794 _IO_cleanup ()
795 {
796   int result = _IO_flush_all ();
797
798   /* We currently don't have a reliable mechanism for making sure that
799      C++ static destructors are executed in the correct order.
800      So it is possible that other static destructors might want to
801      write to cout - and they're supposed to be able to do so.
802
803      The following will make the standard streambufs be unbuffered,
804      which forces any output from late destructors to be written out. */
805   _IO_unbuffer_write ();
806
807   return result;
808 }
809
810
811 void
812 _IO_init_marker (marker, fp)
813      struct _IO_marker *marker;
814      _IO_FILE *fp;
815 {
816   marker->_sbuf = fp;
817   if (_IO_in_put_mode (fp))
818     _IO_switch_to_get_mode (fp);
819   if (_IO_in_backup (fp))
820     marker->_pos = fp->_IO_read_ptr - fp->_IO_read_end;
821   else
822     marker->_pos = fp->_IO_read_ptr - fp->_IO_read_base;
823
824   /* Should perhaps sort the chain? */
825   marker->_next = fp->_markers;
826   fp->_markers = marker;
827 }
828
829 void
830 _IO_remove_marker (marker)
831      struct _IO_marker *marker;
832 {
833   /* Unlink from sb's chain. */
834   struct _IO_marker **ptr = &marker->_sbuf->_markers;
835   for (; ; ptr = &(*ptr)->_next)
836     {
837       if (*ptr == NULL)
838         break;
839       else if (*ptr == marker)
840         {
841           *ptr = marker->_next;
842           return;
843         }
844     }
845 #if 0
846     if _sbuf has a backup area that is no longer needed, should we delete
847     it now, or wait until the next underflow?
848 #endif
849 }
850
851 #define BAD_DELTA EOF
852
853 int
854 _IO_marker_difference (mark1, mark2)
855      struct _IO_marker *mark1;
856      struct _IO_marker *mark2;
857 {
858   return mark1->_pos - mark2->_pos;
859 }
860
861 /* Return difference between MARK and current position of MARK's stream. */
862 int
863 _IO_marker_delta (mark)
864      struct _IO_marker *mark;
865 {
866   int cur_pos;
867   if (mark->_sbuf == NULL)
868     return BAD_DELTA;
869   if (_IO_in_backup (mark->_sbuf))
870     cur_pos = mark->_sbuf->_IO_read_ptr - mark->_sbuf->_IO_read_end;
871   else
872     cur_pos = mark->_sbuf->_IO_read_ptr - mark->_sbuf->_IO_read_base;
873   return mark->_pos - cur_pos;
874 }
875
876 int
877 _IO_seekmark (fp, mark, delta)
878      _IO_FILE *fp;
879      struct _IO_marker *mark;
880      int delta;
881 {
882   if (mark->_sbuf != fp)
883     return EOF;
884  if (mark->_pos >= 0)
885     {
886       if (_IO_in_backup (fp))
887         _IO_switch_to_main_get_area (fp);
888       fp->_IO_read_ptr = fp->_IO_read_base + mark->_pos;
889     }
890   else
891     {
892       if (!_IO_in_backup (fp))
893         _IO_switch_to_backup_area (fp);
894       fp->_IO_read_ptr = fp->_IO_read_end + mark->_pos;
895     }
896   return 0;
897 }
898
899 void
900 _IO_unsave_markers (fp)
901      _IO_FILE *fp;
902 {
903   struct _IO_marker *mark = fp->_markers;
904   if (mark)
905     {
906 #ifdef TODO
907       streampos offset = seekoff (0, ios::cur, ios::in);
908       if (offset != EOF)
909         {
910           offset += eGptr () - Gbase ();
911           for ( ; mark != NULL; mark = mark->_next)
912             mark->set_streampos (mark->_pos + offset);
913         }
914     else
915       {
916         for ( ; mark != NULL; mark = mark->_next)
917           mark->set_streampos (EOF);
918       }
919 #endif
920       fp->_markers = 0;
921     }
922
923   if (_IO_have_backup (fp))
924     _IO_free_backup_area (fp);
925 }
926
927 #if 0
928 /* Seems not to be needed. --drepper */
929 int
930 _IO_nobackup_pbackfail (fp, c)
931      _IO_FILE *fp;
932      int c;
933 {
934   if (fp->_IO_read_ptr > fp->_IO_read_base)
935         fp->_IO_read_ptr--;
936   if (c != EOF && *fp->_IO_read_ptr != c)
937       *fp->_IO_read_ptr = c;
938   return (unsigned char) c;
939 }
940 #endif
941
942 int
943 _IO_default_pbackfail (fp, c)
944      _IO_FILE *fp;
945      int c;
946 {
947   if (fp->_IO_read_ptr > fp->_IO_read_base && !_IO_in_backup (fp)
948       && (unsigned char) fp->_IO_read_ptr[-1] == c)
949     --fp->_IO_read_ptr;
950   else
951     {
952       /* Need to handle a filebuf in write mode (switch to read mode). FIXME!*/
953       if (!_IO_in_backup (fp))
954         {
955           /* We need to keep the invariant that the main get area
956              logically follows the backup area.  */
957           if (fp->_IO_read_ptr > fp->_IO_read_base && _IO_have_backup (fp))
958             {
959               if (save_for_backup (fp, fp->_IO_read_ptr))
960                 return EOF;
961             }
962           else if (!_IO_have_backup (fp))
963             {
964               /* No backup buffer: allocate one. */
965               /* Use nshort buffer, if unused? (probably not)  FIXME */
966               int backup_size = 128;
967               char *bbuf = (char *) malloc (backup_size);
968               if (bbuf == NULL)
969                 return EOF;
970               fp->_IO_save_base = bbuf;
971               fp->_IO_save_end = fp->_IO_save_base + backup_size;
972               fp->_IO_backup_base = fp->_IO_save_end;
973             }
974           fp->_IO_read_base = fp->_IO_read_ptr;
975           _IO_switch_to_backup_area (fp);
976         }
977       else if (fp->_IO_read_ptr <= fp->_IO_read_base)
978         {
979           /* Increase size of existing backup buffer. */
980           _IO_size_t new_size;
981           _IO_size_t old_size = fp->_IO_read_end - fp->_IO_read_base;
982           char *new_buf;
983           new_size = 2 * old_size;
984           new_buf = (char *) malloc (new_size);
985           if (new_buf == NULL)
986             return EOF;
987           memcpy (new_buf + (new_size - old_size), fp->_IO_read_base,
988                   old_size);
989           free (fp->_IO_read_base);
990           _IO_setg (fp, new_buf, new_buf + (new_size - old_size),
991                     new_buf + new_size);
992           fp->_IO_backup_base = fp->_IO_read_ptr;
993         }
994
995       *--fp->_IO_read_ptr = c;
996     }
997   return (unsigned char) c;
998 }
999
1000 _IO_off64_t
1001 _IO_default_seek (fp, offset, dir)
1002      _IO_FILE *fp;
1003      _IO_off64_t offset;
1004      int dir;
1005 {
1006   return _IO_pos_BAD;
1007 }
1008
1009 int
1010 _IO_default_stat (fp, st)
1011      _IO_FILE *fp;
1012      void* st;
1013 {
1014   return EOF;
1015 }
1016
1017 _IO_ssize_t
1018 _IO_default_read (fp, data, n)
1019      _IO_FILE* fp;
1020      void *data;
1021      _IO_ssize_t n;
1022 {
1023   return -1;
1024 }
1025
1026 _IO_ssize_t
1027 _IO_default_write (fp, data, n)
1028      _IO_FILE *fp;
1029      const void *data;
1030      _IO_ssize_t n;
1031 {
1032   return 0;
1033 }
1034
1035 int
1036 _IO_default_showmanyc (fp)
1037      _IO_FILE *fp;
1038 {
1039   return -1;
1040 }
1041
1042 void
1043 _IO_default_imbue (fp, locale)
1044      _IO_FILE *fp;
1045      void *locale;
1046 {
1047 }
1048
1049 _IO_ITER
1050 _IO_iter_begin()
1051 {
1052   return (_IO_ITER) _IO_list_all;
1053 }
1054
1055 _IO_ITER
1056 _IO_iter_end()
1057 {
1058   return NULL;
1059 }
1060
1061 _IO_ITER
1062 _IO_iter_next(iter)
1063     _IO_ITER iter;
1064 {
1065   return iter->_chain;
1066 }
1067
1068 _IO_FILE *
1069 _IO_iter_file(iter)
1070     _IO_ITER iter;
1071 {
1072   return iter;
1073 }
1074
1075 void
1076 _IO_list_lock()
1077 {
1078 #ifdef _IO_MTSAFE_IO
1079   _IO_lock_lock (list_all_lock);
1080 #endif
1081 }
1082
1083 void
1084 _IO_list_unlock()
1085 {
1086 #ifdef _IO_MTSAFE_IO
1087   _IO_lock_unlock (list_all_lock);
1088 #endif
1089 }
1090
1091 void
1092 _IO_list_resetlock()
1093 {
1094 #ifdef _IO_MTSAFE_IO
1095   _IO_lock_init (list_all_lock);
1096 #endif
1097 }
1098
1099
1100 #ifdef TODO
1101 #if defined(linux)
1102 #define IO_CLEANUP ;
1103 #endif
1104
1105 #ifdef IO_CLEANUP
1106   IO_CLEANUP
1107 #else
1108 struct __io_defs {
1109     __io_defs() { }
1110     ~__io_defs() { _IO_cleanup (); }
1111 };
1112 __io_defs io_defs__;
1113 #endif
1114
1115 #endif /* TODO */
1116
1117 #ifdef weak_alias
1118 weak_alias (_IO_cleanup, _cleanup)
1119 #endif
1120
1121 #ifdef text_set_element
1122 text_set_element(__libc_atexit, _cleanup);
1123 #endif