![[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.