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
_IO_un_link(fp)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
_IO_link_in(fp)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
_IO_least_marker(fp,end_p)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
_IO_switch_to_main_get_area(fp)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
_IO_switch_to_backup_area(fp)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
_IO_switch_to_get_mode(fp)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
_IO_free_backup_area(fp)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
__overflow(f,ch)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
save_for_backup(fp,end_p)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
__underflow(fp)285 __underflow (fp)
286 _IO_FILE *fp;
287 {
288 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T || defined(_GLIBCPP_USE_TYPE_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
__uflow(fp)317 __uflow (fp)
318 _IO_FILE *fp;
319 {
320 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T || defined(_GLIBCPP_USE_TYPE_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
_IO_setb(f,b,eb,a)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
_IO_doallocbuf(fp)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
_IO_default_underflow(fp)378 _IO_default_underflow (fp)
379 _IO_FILE *fp;
380 {
381 return EOF;
382 }
383
384 int
_IO_default_uflow(fp)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
_IO_default_xsputn(f,data,n)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
_IO_sgetn(fp,data,n)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
_IO_default_xsgetn(fp,data,n)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 *
_IO_default_setbuf(fp,p,len)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
_IO_default_seekpos(fp,pos,mode)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
_IO_default_doallocate(fp)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
_IO_init(fp,flags)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
_IO_no_init(fp,flags,orientation,wd,jmp)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 || defined(_GLIBCPP_USE_TYPE_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
_IO_default_sync(fp)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
_IO_default_finish(fp,dummy)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
_IO_default_seekoff(fp,offset,dir,mode)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
_IO_sputbackc(fp,c)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
_IO_sungetc(fp)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
_IO_adjust_column(start,line,count)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
_IO_flush_all()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 || defined(_GLIBCPP_USE_TYPE_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
_IO_flush_all_linebuffered()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
_IO_unbuffer_write()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
_IO_cleanup()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
_IO_init_marker(marker,fp)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
_IO_remove_marker(marker)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
_IO_marker_difference(mark1,mark2)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
_IO_marker_delta(mark)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
_IO_seekmark(fp,mark,delta)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
_IO_unsave_markers(fp)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
_IO_default_pbackfail(fp,c)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
_IO_default_seek(fp,offset,dir)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
_IO_default_stat(fp,st)1010 _IO_default_stat (fp, st)
1011 _IO_FILE *fp;
1012 void* st;
1013 {
1014 return EOF;
1015 }
1016
1017 _IO_ssize_t
_IO_default_read(fp,data,n)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
_IO_default_write(fp,data,n)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
_IO_default_showmanyc(fp)1036 _IO_default_showmanyc (fp)
1037 _IO_FILE *fp;
1038 {
1039 return -1;
1040 }
1041
1042 void
_IO_default_imbue(fp,locale)1043 _IO_default_imbue (fp, locale)
1044 _IO_FILE *fp;
1045 void *locale;
1046 {
1047 }
1048
1049 _IO_ITER
_IO_iter_begin()1050 _IO_iter_begin()
1051 {
1052 return (_IO_ITER) _IO_list_all;
1053 }
1054
1055 _IO_ITER
_IO_iter_end()1056 _IO_iter_end()
1057 {
1058 return NULL;
1059 }
1060
1061 _IO_ITER
_IO_iter_next(iter)1062 _IO_iter_next(iter)
1063 _IO_ITER iter;
1064 {
1065 return iter->_chain;
1066 }
1067
1068 _IO_FILE *
_IO_iter_file(iter)1069 _IO_iter_file(iter)
1070 _IO_ITER iter;
1071 {
1072 return iter;
1073 }
1074
1075 void
_IO_list_lock()1076 _IO_list_lock()
1077 {
1078 #ifdef _IO_MTSAFE_IO
1079 _IO_lock_lock (list_all_lock);
1080 #endif
1081 }
1082
1083 void
_IO_list_unlock()1084 _IO_list_unlock()
1085 {
1086 #ifdef _IO_MTSAFE_IO
1087 _IO_lock_unlock (list_all_lock);
1088 #endif
1089 }
1090
1091 void
_IO_list_resetlock()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
1124