Return to genops.c CVS log

Up to [Apple XNU] / GNUtools / libg++ / libio

Annotation of GNUtools/libg++/libio/genops.c, revision 1.1

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.