![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to genops.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / libg++ / libio|
Return to genops.c CVS log | Up to [Apple XNU] / GNUtools / libg++ / libio |
1.1 root 1: /*
2: Copyright (C) 1993 Free Software Foundation
3:
4: This file is part of the GNU IO Library. This library is free
5: software; you can redistribute it and/or modify it under the
6: terms of the GNU General Public License as published by the
7: Free Software Foundation; either version 2, or (at your option)
8: any later version.
9:
10: This library is distributed in the hope that it will be useful,
11: but WITHOUT ANY WARRANTY; without even the implied warranty of
12: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13: GNU General Public License for more details.
14:
15: You should have received a copy of the GNU General Public License
16: along with GNU CC; see the file COPYING. If not, write to
17: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, 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 not cause
21: the resulting executable to be covered by the GNU General Public License.
22: This exception does not however invalidate any other reasons why
23: the executable file might be covered by the GNU General Public License. */
24:
25: /* Generic or default I/O operations. */
26:
27: #include "libioP.h"
28: #include <stdlib.h>
29: #include <string.h>
30:
31: void _IO_un_link(fp)
32: _IO_FILE *fp;
33: {
34: if (fp->_flags & _IO_LINKED) {
35: _IO_FILE **f;
36: for (f = &_IO_list_all; *f != NULL; f = &(*f)->_chain) {
37: if (*f == fp) {
38: *f = fp->_chain;
39: break;
40: }
41: }
42: fp->_flags &= ~_IO_LINKED;
43: }
44: }
45:
46: void _IO_link_in(fp)
47: _IO_FILE *fp;
48: {
49: if ((fp->_flags & _IO_LINKED) == 0) {
50: fp->_flags |= _IO_LINKED;
51: fp->_chain = _IO_list_all;
52: _IO_list_all = fp;
53: }
54: }
55:
56: /* Return minimum _pos markers
57: Assumes the current get area is the main get area. */
58:
59: _IO_size_t
60: _IO_least_marker(fp)
61: register _IO_FILE *fp;
62: {
63: _IO_ssize_t least_so_far = fp->_IO_read_end - fp->_IO_read_base;
64: register struct _IO_marker *mark;
65: for (mark = fp->_markers; mark != NULL; mark = mark->_next)
66: if (mark->_pos < least_so_far)
67: least_so_far = mark->_pos;
68: return least_so_far;
69: }
70:
71: /* Switch current get area from backup buffer to (start of) main get area. */
72:
73: void
74: _IO_switch_to_main_get_area(fp)
75: _IO_FILE *fp;
76: {
77: char *tmp;
78: fp->_flags &= ~_IO_IN_BACKUP;
79: /* Swap _IO_read_end and _IO_save_end. */
80: tmp = fp->_IO_read_end; fp->_IO_read_end= fp->_IO_save_end; fp->_IO_save_end= tmp;
81: /* Swap _IO_read_base and _IO_save_base. */
82: tmp = fp->_IO_read_base; fp->_IO_read_base = fp->_IO_save_base; fp->_IO_save_base = tmp;
83: fp->_IO_read_ptr = fp->_IO_read_base;
84: }
85:
86: /* Switch current get area from main get area to (end of) backup area. */
87:
88: void
89: _IO_switch_to_backup_area(fp)
90: register _IO_FILE *fp;
91: {
92: char *tmp;
93: fp->_flags |= _IO_IN_BACKUP;
94: /* Swap _IO_read_end and _IO_save_end. */
95: tmp = fp->_IO_read_end; fp->_IO_read_end = fp->_IO_save_end; fp->_IO_save_end = tmp;
96: /* Swap _gbase and _IO_save_base. */
97: tmp = fp->_IO_read_base; fp->_IO_read_base = fp->_IO_save_base; fp->_IO_save_base = tmp;
98: fp->_IO_read_ptr = fp->_IO_read_end;
99: }
100:
101: int
102: _IO_switch_to_get_mode(fp)
103: register _IO_FILE *fp;
104: {
105: if (fp->_IO_write_ptr > fp->_IO_write_base)
106: if (fp->_jumps->__overflow(fp, EOF) == EOF)
107: return EOF;
108: if (_IO_in_backup(fp))
109: fp->_IO_read_base = fp->_aux_limit;
110: else
111: {
112: fp->_IO_read_base = fp->_IO_buf_base;
113: if (fp->_IO_write_ptr > fp->_IO_read_end)
114: fp->_IO_read_end = fp->_IO_write_ptr;
115: }
116: fp->_IO_read_ptr = fp->_IO_write_ptr;
117:
118: fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end = fp->_IO_read_ptr;
119:
120: fp->_flags &= ~_IO_CURRENTLY_PUTTING;
121: return 0;
122: }
123:
124: void
125: _IO_free_backup_area(fp)
126: register _IO_FILE *fp;
127: {
128: if (_IO_in_backup (fp))
129: _IO_switch_to_main_get_area(fp); /* Just in case. */
130: free (fp->_IO_save_base);
131: fp->_IO_save_base = NULL;
132: fp->_IO_save_end = NULL;
133: fp->_aux_limit = NULL;
134: }
135:
136: #if 0
137: int
138: _IO_switch_to_put_mode(fp)
139: register _IO_FILE *fp;
140: {
141: fp->_IO_write_base = fp->_IO_read_ptr;
142: fp->_IO_write_ptr = fp->_IO_read_ptr;
143: /* Following is wrong if line- or un-buffered? */
144: fp->_IO_write_end = fp->_flags & _IO_IN_BACKUP ? fp->_IO_read_end : fp->_IO_buf_end;
145:
146: fp->_IO_read_ptr = fp->_IO_read_end;
147: fp->_IO_read_base = fp->_IO_read_end;
148:
149: fp->_flags |= _IO_CURRENTLY_PUTTING;
150: return 0;
151: }
152: #endif
153:
154: int __overflow(f, ch)
155: _IO_FILE *f;
156: int ch;
157: {
158: return f->_jumps->__overflow(f, ch);
159: }
160:
161: int
162: __underflow(fp)
163: _IO_FILE *fp;
164: {
165: if (_IO_in_put_mode(fp))
166: if (_IO_switch_to_get_mode(fp) == EOF) return EOF;
167: if (fp->_IO_read_ptr < fp->_IO_read_end)
168: return *(unsigned char*)fp->_IO_read_ptr;
169: if (_IO_in_backup(fp))
170: {
171: _IO_switch_to_main_get_area(fp);
172: if (fp->_IO_read_ptr < fp->_IO_read_end)
173: return *fp->_IO_read_ptr;
174: }
175: if (_IO_have_markers(fp))
176: {
177: /* Append [_gbase.._IO_read_end] to backup area. */
178: int least_mark = _IO_least_marker(fp);
179: /* needed_size is how much space we need in the backup area. */
180: int needed_size = (fp->_IO_read_end - fp->_IO_read_base) - least_mark;
181: int current_Bsize = fp->_IO_save_end - fp->_IO_save_base;
182: int avail; /* Extra space available for future expansion. */
183: int delta;
184: struct _IO_marker *mark;
185: if (needed_size > current_Bsize)
186: {
187: char *new_buffer;
188: avail = 100;
189: new_buffer = (char*)malloc(avail+needed_size);
190: if (new_buffer == NULL)
191: return EOF; /* FIXME */
192: if (least_mark < 0)
193: {
194: memcpy(new_buffer + avail,
195: fp->_IO_save_end + least_mark,
196: -least_mark);
197: memcpy(new_buffer +avail - least_mark,
198: fp->_IO_read_base,
199: fp->_IO_read_end - fp->_IO_read_base);
200: }
201: else
202: memcpy(new_buffer + avail,
203: fp->_IO_read_base + least_mark,
204: needed_size);
205: free (fp->_IO_save_base);
206: fp->_IO_save_base = new_buffer;
207: fp->_IO_save_end = new_buffer + avail + needed_size;
208: }
209: else
210: {
211: avail = current_Bsize - needed_size;
212: if (least_mark < 0)
213: {
214: memmove(fp->_IO_save_base + avail,
215: fp->_IO_save_end + least_mark,
216: -least_mark);
217: memcpy(fp->_IO_save_base + avail - least_mark,
218: fp->_IO_read_base,
219: fp->_IO_read_end - fp->_IO_read_base);
220: }
221: else if (needed_size > 0)
222: memcpy(fp->_IO_save_base + avail,
223: fp->_IO_read_base + least_mark,
224: needed_size);
225: }
226: /* FIXME: Dubious arithmetic if pointers are NULL */
227: fp->_aux_limit = fp->_IO_save_base + avail;
228: /* Adjust all the streammarkers. */
229: delta = fp->_IO_read_end - fp->_IO_read_base;
230: for (mark = fp->_markers; mark != NULL; mark = mark->_next)
231: mark->_pos -= delta;
232: }
233: else if (_IO_have_backup(fp))
234: _IO_free_backup_area(fp);
235: return fp->_jumps->__underflow(fp);
236: }
237:
238: void
239: _IO_setb(f, b, eb, a)
240: _IO_FILE *f;
241: char *b;
242: char *eb;
243: int a;
244: {
245: if (f->_IO_buf_base && !(f->_flags & _IO_USER_BUF))
246: FREE_BUF(f->_IO_buf_base);
247: f->_IO_buf_base = b;
248: f->_IO_buf_end = eb;
249: if (a)
250: f->_flags &= ~_IO_USER_BUF;
251: else
252: f->_flags |= _IO_USER_BUF;
253: }
254:
255: void
256: _IO_doallocbuf(fp)
257: register _IO_FILE *fp;
258: {
259: if (fp->_IO_buf_base)
260: return;
261: if (!(fp->_flags & _IO_UNBUFFERED))
262: if (fp->_jumps->__doallocate(fp) != EOF)
263: return;
264: _IO_setb(fp, fp->_shortbuf, fp->_shortbuf+1, 0);
265: }
266:
267: int
268: _IO_default_underflow (fp)
269: _IO_FILE *fp;
270: {
271: return EOF;
272: }
273:
274: _IO_size_t
275: _IO_default_xsputn(f, data, n)
276: register _IO_FILE *f;
277: const void *data;
278: _IO_size_t n;
279: {
280: register const char *s = data;
281: register _IO_size_t more = n;
282: if (more <= 0)
283: return 0;
284: for (;;)
285: {
286: _IO_size_t count = f->_IO_write_end - f->_IO_write_ptr; /* Space available. */
287: if (count > 0)
288: {
289: if (count > more)
290: count = more;
291: if (count > 20)
292: {
293: memcpy(f->_IO_write_ptr, s, count);
294: s += count;
295: f->_IO_write_ptr += count;
296: }
297: else if (count <= 0)
298: count = 0;
299: else
300: {
301: register char *p = f->_IO_write_ptr;
302: register _IO_ssize_t i;
303: for (i = count; --i >= 0; ) *p++ = *s++;
304: f->_IO_write_ptr = p;
305: }
306: more -= count;
307: }
308: if (more == 0 || __overflow(f, (unsigned char)*s++) == EOF)
309: break;
310: more--;
311: }
312: return n - more;
313: }
314:
315: _IO_size_t
316: _IO_sgetn(fp, data, n)
317: _IO_FILE *fp;
318: void *data;
319: _IO_size_t n;
320: {
321: /* FIXME handle putback buffer here! */
322: return fp->_jumps->__xsgetn(fp, data, n);
323: }
324:
325: _IO_size_t
326: _IO_default_xsgetn(fp, data, n)
327: _IO_FILE *fp;
328: void *data;
329: _IO_size_t n;
330: {
331: register _IO_size_t more = n;
332: register char *s = data;
333: for (;;)
334: {
335: _IO_size_t count = fp->_IO_read_end - fp->_IO_read_ptr; /* Data available. */
336: if (count > 0)
337: {
338: if (count > more)
339: count = more;
340: if (count > 20)
341: {
342: memcpy(s, fp->_IO_read_ptr, count);
343: s += count;
344: fp->_IO_read_ptr += count;
345: }
346: else if (count <= 0)
347: count = 0;
348: else
349: {
350: register char *p = fp->_IO_read_ptr;
351: register int i = (int)count;
352: while (--i >= 0) *s++ = *p++;
353: fp->_IO_read_ptr = p;
354: }
355: more -= count;
356: }
357: if (more == 0 || __underflow(fp) == EOF)
358: break;
359: }
360: return n - more;
361: }
362:
363: int
364: _IO_sync(fp)
365: register _IO_FILE *fp;
366: {
367: if (fp->_IO_read_ptr == fp->_IO_read_end && fp->_IO_write_ptr == fp->_IO_write_base)
368: return 0;
369: return EOF;
370: }
371:
372: int
373: _IO_default_setbuf(fp, p, len)
374: register _IO_FILE *fp;
375: char* p;
376: _IO_ssize_t len;
377: {
378: if (fp->_jumps->__sync(fp) == EOF)
379: return EOF;
380: if (p == NULL || len == 0)
381: {
382: fp->_flags |= _IO_UNBUFFERED;
383: _IO_setb(fp, fp->_shortbuf, fp->_shortbuf+1, 0);
384: }
385: else
386: {
387: fp->_flags &= ~_IO_UNBUFFERED;
388: _IO_setb(fp, p, p+len, 0);
389: }
390: fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end = 0;
391: fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_read_end = 0;
392: return 0;
393: }
394:
395: _IO_pos_t
396: _IO_default_seekpos(fp, pos, mode)
397: _IO_FILE *fp;
398: _IO_pos_t pos;
399: _IO_seekflags mode;
400: {
401: return fp->_jumps->__seekoff(fp, _IO_pos_as_off(pos), mode);
402: }
403:
404: int
405: _IO_default_doallocate(fp)
406: _IO_FILE *fp;
407: {
408: char *buf = ALLOC_BUF(_IO_BUFSIZ);
409: if (buf == NULL)
410: return EOF;
411: _IO_setb(fp, buf, buf+_IO_BUFSIZ, 1);
412: return 1;
413: }
414:
415: void
416: _IO_init(fp, flags)
417: register _IO_FILE *fp;
418: int flags;
419: {
420: fp->_flags = _IO_MAGIC|flags;
421: fp->_IO_buf_base = NULL;
422: fp->_IO_buf_end = NULL;
423: fp->_IO_read_base = NULL;
424: fp->_IO_read_ptr = NULL;
425: fp->_IO_read_end = NULL;
426: fp->_IO_write_base = NULL;
427: fp->_IO_write_ptr = NULL;
428: fp->_IO_write_end = NULL;
429: fp->_chain = NULL; /* Not necessary. */
430:
431: fp->_IO_save_base = NULL;
432: fp->_aux_limit = NULL;
433: fp->_IO_save_end = NULL;
434: fp->_markers = NULL;
435: fp->_cur_column = 0;
436: }
437:
438: int
439: _IO_default_sync (fp)
440: _IO_FILE *fp;
441: {
442: return 0;
443: }
444:
445: void _IO_default_finish (fp)
446: _IO_FILE *fp;
447: {
448: struct _IO_marker *mark;
449: if (fp->_IO_buf_base && !(fp->_flags & _IO_USER_BUF))
450: FREE_BUF(fp->_IO_buf_base);
451:
452: for (mark = fp->_markers; mark != NULL; mark = mark->_next)
453: mark->_sbuf = NULL;
454:
455: free (fp->_IO_save_base);
456:
457: _IO_un_link(fp);
458: }
459:
460: _IO_pos_t
461: _IO_default_seekoff(fp, offset, mode)
462: register _IO_FILE *fp;
463: _IO_off_t offset;
464: _IO_seekflags mode;
465: {
466: return _IO_pos_BAD;
467: }
468:
469: int
470: _IO_sputbackc(fp, c) /* ungetc(c, fp) */
471: register _IO_FILE *fp;
472: int c;
473: {
474: if (fp->_IO_read_ptr > fp->_IO_read_base
475: && (unsigned char)fp->_IO_read_ptr[-1] == (unsigned char)c)
476: {
477: fp->_IO_read_ptr--;
478: return (unsigned char)c;
479: }
480: return fp->_jumps->__pbackfail(fp, c);
481: }
482:
483: int
484: _IO_sungetc(fp)
485: register _IO_FILE *fp;
486: {
487: if (fp->_IO_read_ptr > fp->_IO_read_base)
488: {
489: fp->_IO_read_ptr--;
490: return (unsigned char)*fp->_IO_read_ptr;
491: }
492: else
493: return fp->_jumps->__pbackfail(fp, EOF);
494: }
495:
496: #if 0 /* Work in progress */
497: void
498: _IO_set_column(fp, c)
499: register _IO_FILE *fp;
500: int c;
501: {
502: if (c == -1)
503: fp->_collumn = -1;
504: else
505: fp->_collumn = c - (fp->_IO_write_ptr - fp->_IO_write_base);
506: }
507: #else
508: int
509: _IO_set_column(fp, i)
510: register _IO_FILE *fp;
511: int i;
512: {
513: fp->_cur_column = i+1;
514: return 0;
515: }
516: #endif
517:
518:
519: unsigned
520: _IO_adjust_column(start, line, count)
521: unsigned start;
522: const char *line;
523: int count;
524: {
525: register const char *ptr = line + count;
526: while (ptr > line)
527: if (*--ptr == '\n')
528: return line + count - ptr - 1;
529: return start + count;
530: }
531:
532: int
533: _IO_get_column(fp)
534: register _IO_FILE *fp;
535: {
536: if (fp->_cur_column)
537: return _IO_adjust_column(fp->_cur_column - 1,
538: fp->_IO_write_base,
539: fp->_IO_write_ptr - fp->_IO_write_base);
540: return -1;
541: }
542:
543: int
544: _IO_flush_all()
545: {
546: int result = 0;
547: _IO_FILE *fp;
548: for (fp = _IO_list_all; fp != NULL; fp = fp->_chain)
549: if (fp->_jumps->__overflow(fp, EOF) == EOF)
550: result = EOF;
551: return result;
552: }
553:
554: void
555: _IO_flush_all_linebuffered()
556: {
557: _IO_FILE *fp;
558: for (fp = _IO_list_all; fp != NULL; fp = fp->_chain)
559: if (fp->_flags & _IO_LINE_BUF)
560: fp->_jumps->__overflow(fp, EOF);
561: }
562:
563: void _IO_init_marker(marker, fp)
564: struct _IO_marker *marker;
565: _IO_FILE *fp;
566: {
567: marker->_sbuf = fp;
568: if (_IO_in_put_mode(fp))
569: _IO_switch_to_get_mode(fp);
570: if (_IO_in_backup(fp))
571: marker->_pos = fp->_IO_read_ptr - fp->_IO_read_end;
572: else
573: marker->_pos = fp->_IO_read_ptr - fp->_IO_read_base;
574:
575: /* Should perhaps sort the chain? */
576: marker->_next = fp->_markers;
577: fp->_markers = marker;
578: }
579:
580: void
581: _IO_remove_marker (marker)
582: register struct _IO_marker * marker;
583: {
584: /* Unlink from sb's chain. */
585: register struct _IO_marker **ptr = &marker->_sbuf->_markers;
586: for (; ; ptr = &(*ptr)->_next)
587: {
588: if (*ptr == NULL)
589: break;
590: else if (*ptr == marker)
591: {
592: *ptr = marker->_next;
593: return;
594: }
595: }
596: #if 0
597: if _sbuf has a backup area that is no longer needed, should we delete
598: it now, or wait until the next underflow?
599: #endif
600: }
601:
602: #define BAD_DELTA EOF
603:
604: int
605: _IO_marker_difference(mark1, mark2)
606: struct _IO_marker *mark1;
607: struct _IO_marker *mark2;
608: {
609: return mark1->_pos - mark2->_pos;
610: }
611:
612: /* Return difference between MARK and current posistion of MARK's stream. */
613: int
614: _IO_marker_delta(mark)
615: struct _IO_marker *mark;
616: {
617: int cur_pos;
618: if (mark->_sbuf == NULL)
619: return BAD_DELTA;
620: if (_IO_in_backup(mark->_sbuf))
621: cur_pos = mark->_sbuf->_IO_read_ptr - mark->_sbuf->_IO_read_end;
622: else
623: cur_pos = mark->_sbuf->_IO_read_ptr - mark->_sbuf->_IO_read_base;
624: return mark->_pos - cur_pos;
625: }
626:
627: int _IO_seekmark(fp, mark, delta)
628: _IO_FILE *fp;
629: struct _IO_marker *mark;
630: int delta;
631: {
632: if (mark->_sbuf != fp)
633: return EOF;
634: if (mark->_pos >= 0)
635: {
636: if (_IO_in_backup(fp))
637: _IO_switch_to_main_get_area(fp);
638: fp->_IO_read_ptr = fp->_IO_read_base + mark->_pos;
639: }
640: else
641: {
642: if (!_IO_in_backup(fp))
643: _IO_switch_to_backup_area(fp);
644: fp->_IO_read_ptr = fp->_IO_read_end + mark->_pos;
645: }
646: return 0;
647: }
648:
649: void _IO_unsave_markers(fp)
650: register _IO_FILE *fp;
651: {
652: register struct _IO_marker *mark = fp->_markers;
653: if (mark)
654: {
655: #ifdef TODO
656: streampos offset = seekoff(0, ios::cur, ios::in);
657: if (offset != EOF)
658: {
659: offset += eGptr() - Gbase();
660: for ( ; mark != NULL; mark = mark->_next)
661: mark->set_streampos(mark->_pos + offset);
662: }
663: else
664: {
665: for ( ; mark != NULL; mark = mark->_next)
666: mark->set_streampos(EOF);
667: }
668: #endif
669: fp->_markers = 0;
670: }
671:
672: _IO_free_backup_area(fp);
673: }
674:
675: int
676: _IO_nobackup_pbackfail(fp, c)
677: register _IO_FILE *fp;
678: int c;
679: {
680: if (fp->_IO_read_ptr > fp->_IO_read_base)
681: fp->_IO_read_ptr--;
682: if (c != EOF && *fp->_IO_read_ptr != c)
683: *fp->_IO_read_ptr = c;
684: return (unsigned char)c;
685: }
686:
687: int
688: _IO_default_pbackfail(fp, c)
689: register _IO_FILE *fp;
690: int c;
691: {
692: if (fp->_IO_read_ptr <= fp->_IO_read_base)
693: {
694: /* Need to handle a filebuf in write mode (switch to read mode). FIXME!*/
695: if (_IO_have_backup(fp) && !_IO_in_backup(fp))
696: _IO_switch_to_backup_area(fp);
697:
698: if (!_IO_have_backup(fp))
699: {
700: /* No backup buffer: allocate one. */
701: /* Use nshort buffer, if unused? (probably not) FIXME */
702: int backup_size = 128;
703: char *bbuf = (char*)malloc(backup_size);
704: if (bbuf == NULL)
705: return EOF;
706: fp->_IO_save_base = bbuf;
707: fp->_IO_save_end = fp->_IO_save_base + backup_size;
708: fp->_aux_limit = fp->_IO_save_end;
709: _IO_switch_to_backup_area(fp);
710: }
711: else if (fp->_IO_read_ptr <= fp->_IO_read_base)
712: {
713: /* Increase size of existing backup buffer. */
714: _IO_size_t new_size;
715: _IO_size_t old_size = fp->_IO_read_end - fp->_IO_read_base;
716: char *new_buf;
717: new_size = 2 * old_size;
718: new_buf = (char*)malloc(new_size);
719: if (new_buf == NULL)
720: return EOF;
721: memcpy(new_buf+(new_size-old_size), fp->_IO_read_base, old_size);
722: free (fp->_IO_read_base);
723: _IO_setg(fp,
724: new_buf, new_buf+(new_size-old_size), new_buf+new_size);
725: fp->_aux_limit = fp->_IO_read_ptr;
726: }
727: }
728: fp->_IO_read_ptr--;
729: if (c != EOF && *fp->_IO_read_ptr != c)
730: *fp->_IO_read_ptr = c;
731: return (unsigned char)*fp->_IO_read_ptr;
732: }
733:
734: _IO_pos_t
735: _IO_default_seek(fp, offset, dir)
736: _IO_FILE *fp;
737: _IO_off_t offset;
738: int dir;
739: {
740: return _IO_pos_BAD;
741: }
742:
743: int
744: _IO_default_stat(fp, st)
745: _IO_FILE *fp;
746: void* st;
747: {
748: return EOF;
749: }
750:
751: _IO_ssize_t
752: _IO_default_read(fp, data, n)
753: register _IO_FILE* fp;
754: void* data;
755: _IO_ssize_t n;
756: {
757: return -1;
758: }
759:
760: _IO_ssize_t
761: _IO_default_write(fp, data, n)
762: register _IO_FILE* fp;
763: const void* data;
764: _IO_ssize_t n;
765: {
766: return 0;
767: }
768:
769:
770: #ifdef TODO
771: #if defined(linux)
772: #define IO_CLEANUP ;
773: #endif
774:
775: #ifdef IO_CLEANUP
776: IO_CLEANUP
777: #else
778: struct __io_defs {
779: __io_defs() { }
780: ~__io_defs() { _IO_flush_all(); }
781: };
782: __io_defs io_defs__;
783: #endif
784:
785: #endif /* TODO */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.