libio/genops.c

   1 /*
   2 Copyright (C) 1993, 1995 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 this library; see the file COPYING.  If not, write to the Free
  17 Software Foundation, 59 Temple Place - Suite 330, Boston, 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 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 #ifdef __STDC__
  29 #include <stdlib.h>
  30 #endif
  31 #include <string.h>
  32
  33 void
  34 DEFUN(_IO_un_link, (fp),
  35       _IO_FILE *fp)
  36 {
  37   if (fp->_flags & _IO_LINKED) {
  38     _IO_FILE **f;
  39     for (f = &_IO_list_all; *f != NULL; f = &(*f)->_chain) {
  40       if (*f == fp) {
  41         *f = fp->_chain;
  42         break;
  43       }
  44     }
  45     fp->_flags &= ~_IO_LINKED;
  46   }
  47 }
  48
  49 void
  50 DEFUN(_IO_link_in, (fp),
  51       _IO_FILE *fp)
  52 {
  53     if ((fp->_flags & _IO_LINKED) == 0) {
  54         fp->_flags |= _IO_LINKED;
  55         fp->_chain = _IO_list_all;
  56         _IO_list_all = fp;
  57     }
  58 }
  59
  60 /* Return minimum _pos markers
  61    Assumes the current get area is the main get area. */
  62
  63 _IO_size_t
  64 DEFUN(_IO_least_marker, (fp),
  65       register _IO_FILE *fp)
  66 {
  67   _IO_ssize_t least_so_far = fp->_IO_read_end - fp->_IO_read_base;
  68   register struct _IO_marker *mark;
  69   for (mark = fp->_markers; mark != NULL; mark = mark->_next)
  70     if (mark->_pos < least_so_far)
  71       least_so_far = mark->_pos;
  72   return least_so_far;
  73 }
  74
  75 /* Switch current get area from backup buffer to (start of) main get area. */
  76
  77 void
  78 DEFUN(_IO_switch_to_main_get_area, (fp),
  79       _IO_FILE *fp)
  80 {
  81   char *tmp;
  82   fp->_flags &= ~_IO_IN_BACKUP;
  83   /* Swap _IO_read_end and _IO_save_end. */
  84   tmp = fp->_IO_read_end; fp->_IO_read_end= fp->_IO_save_end; fp->_IO_save_end= tmp;
  85   /* Swap _IO_read_base and _IO_save_base. */
  86   tmp = fp->_IO_read_base; fp->_IO_read_base = fp->_IO_save_base; fp->_IO_save_base = tmp;
  87   fp->_IO_read_ptr = fp->_IO_read_base;
  88 }
  89
  90 /* Switch current get area from main get area to (end of) backup area. */
  91
  92 void
  93 DEFUN(_IO_switch_to_backup_area, (fp),
  94      register _IO_FILE *fp)
  95 {
  96   char *tmp;
  97   fp->_flags |= _IO_IN_BACKUP;
  98   /* Swap _IO_read_end and _IO_save_end. */
  99   tmp = fp->_IO_read_end; fp->_IO_read_end = fp->_IO_save_end; fp->_IO_save_end = tmp;
 100   /* Swap _gbase and _IO_save_base. */
 101   tmp = fp->_IO_read_base; fp->_IO_read_base = fp->_IO_save_base; fp->_IO_save_base = tmp;
 102   fp->_IO_read_ptr = fp->_IO_read_end;
 103 }
 104
 105 int
 106 DEFUN(_IO_switch_to_get_mode, (fp),
 107      register _IO_FILE *fp)
 108 {
 109   if (fp->_IO_write_ptr > fp->_IO_write_base)
 110     if (_IO_OVERFLOW (fp, EOF) == EOF)
 111       return EOF;
 112   if (_IO_in_backup(fp))
 113     fp->_IO_read_base = fp->_IO_backup_base;
 114   else
 115     {
 116       fp->_IO_read_base = fp->_IO_buf_base;
 117       if (fp->_IO_write_ptr > fp->_IO_read_end)
 118         fp->_IO_read_end = fp->_IO_write_ptr;
 119     }
 120   fp->_IO_read_ptr = fp->_IO_write_ptr;
 121
 122   fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end = fp->_IO_read_ptr;
 123
 124   fp->_flags &= ~_IO_CURRENTLY_PUTTING;
 125   return 0;
 126 }
 127
 128 void
 129 DEFUN(_IO_free_backup_area, (fp),
 130      register _IO_FILE *fp)
 131 {
 132   if (_IO_in_backup (fp))
 133     _IO_switch_to_main_get_area(fp);  /* Just in case. */
 134   free (fp->_IO_save_base);
 135   fp->_IO_save_base = NULL;
 136   fp->_IO_save_end = NULL;
 137   fp->_IO_backup_base = NULL;
 138 }
 139
 140 #if 0
 141 int
 142 DEFUN(_IO_switch_to_put_mode, (fp),
 143       register _IO_FILE *fp)
 144 {
 145   fp->_IO_write_base = fp->_IO_read_ptr;
 146   fp->_IO_write_ptr = fp->_IO_read_ptr;
 147   /* Following is wrong if line- or un-buffered? */
 148   fp->_IO_write_end = fp->_flags & _IO_IN_BACKUP ? fp->_IO_read_end : fp->_IO_buf_end;
 149
 150   fp->_IO_read_ptr = fp->_IO_read_end;
 151   fp->_IO_read_base = fp->_IO_read_end;
 152
 153   fp->_flags |= _IO_CURRENTLY_PUTTING;
 154   return 0;
 155 }
 156 #endif
 157
 158 int
 159 DEFUN(__overflow, (f, ch),
 160       _IO_FILE *f AND int ch)
 161 {
 162   return _IO_OVERFLOW (f, ch);
 163 }
 164
 165 static int
 166 DEFUN(save_for_backup, (fp),
 167       _IO_FILE *fp)
 168 {
 169   /* Append [_IO_read_base.._IO_read_end] to backup area. */
 170   int least_mark = _IO_least_marker(fp);
 171   /* needed_size is how much space we need in the backup area. */
 172   int needed_size = (fp->_IO_read_end - fp->_IO_read_base) - least_mark;
 173   int current_Bsize = fp->_IO_save_end - fp->_IO_save_base;
 174   int avail; /* Extra space available for future expansion. */
 175   int delta;
 176   struct _IO_marker *mark;
 177   if (needed_size > current_Bsize)
 178     {
 179       char *new_buffer;
 180       avail = 100;
 181       new_buffer = (char*)malloc(avail+needed_size);
 182       if (new_buffer == NULL)
 183         return EOF;             /* FIXME */
 184       if (least_mark < 0)
 185         {
 186           memcpy(new_buffer + avail,
 187                  fp->_IO_save_end + least_mark,
 188                  -least_mark);
 189           memcpy(new_buffer +avail - least_mark,
 190                  fp->_IO_read_base,
 191                  fp->_IO_read_end - fp->_IO_read_base);
 192         }
 193       else
 194         memcpy(new_buffer + avail,
 195                fp->_IO_read_base + least_mark,
 196                needed_size);
 197       if (fp->_IO_save_base)
 198         free (fp->_IO_save_base);
 199       fp->_IO_save_base = new_buffer;
 200       fp->_IO_save_end = new_buffer + avail + needed_size;
 201     }
 202   else
 203     {
 204       avail = current_Bsize - needed_size;
 205       if (least_mark < 0)
 206         {
 207           memmove(fp->_IO_save_base + avail,
 208                   fp->_IO_save_end + least_mark,
 209                   -least_mark);
 210           memcpy(fp->_IO_save_base + avail - least_mark,
 211                  fp->_IO_read_base,
 212                  fp->_IO_read_end - fp->_IO_read_base);
 213         }
 214       else if (needed_size > 0)
 215         memcpy(fp->_IO_save_base + avail,
 216                fp->_IO_read_base + least_mark,
 217                needed_size);
 218     }
 219   /* FIXME: Dubious arithmetic if pointers are NULL */
 220   fp->_IO_backup_base = fp->_IO_save_base + avail;
 221   /* Adjust all the streammarkers. */
 222   delta = fp->_IO_read_end - fp->_IO_read_base;
 223   for (mark = fp->_markers; mark != NULL; mark = mark->_next)
 224     mark->_pos -= delta;
 225   return 0;
 226 }
 227
 228 int
 229 DEFUN(__underflow, (fp),
 230       _IO_FILE *fp)
 231 {
 232   if (_IO_in_put_mode(fp))
 233     if (_IO_switch_to_get_mode(fp) == EOF) return EOF;
 234   if (fp->_IO_read_ptr < fp->_IO_read_end)
 235     return *(unsigned char*)fp->_IO_read_ptr;
 236   if (_IO_in_backup(fp))
 237     {
 238       _IO_switch_to_main_get_area(fp);
 239       if (fp->_IO_read_ptr < fp->_IO_read_end)
 240         return *fp->_IO_read_ptr;
 241     }
 242   if (_IO_have_markers(fp))
 243     {
 244       if (save_for_backup (fp))
 245         return EOF;
 246     }
 247   else if (_IO_have_backup(fp))
 248     _IO_free_backup_area(fp);
 249   return _IO_UNDERFLOW (fp);
 250 }
 251
 252 int
 253 DEFUN(__uflow, (fp),
 254      _IO_FILE *fp)
 255 {
 256   if (_IO_in_put_mode(fp))
 257     if (_IO_switch_to_get_mode(fp) == EOF) return EOF;
 258   if (fp->_IO_read_ptr < fp->_IO_read_end)
 259     return *(unsigned char*)fp->_IO_read_ptr++;
 260   if (_IO_in_backup(fp))
 261     {
 262       _IO_switch_to_main_get_area(fp);
 263       if (fp->_IO_read_ptr < fp->_IO_read_end)
 264         return *fp->_IO_read_ptr++;
 265     }
 266   if (_IO_have_markers(fp))
 267     {
 268       if (save_for_backup (fp))
 269         return EOF;
 270     }
 271   else if (_IO_have_backup(fp))
 272     _IO_free_backup_area(fp);
 273   return _IO_UFLOW (fp);
 274 }
 275
 276 void
 277 DEFUN(_IO_setb, (f, b, eb, a),
 278       _IO_FILE *f AND char *b AND char *eb AND int a)
 279 {
 280   if (f->_IO_buf_base && !(f->_flags & _IO_USER_BUF))
 281     FREE_BUF(f->_IO_buf_base);
 282   f->_IO_buf_base = b;
 283   f->_IO_buf_end = eb;
 284   if (a)
 285     f->_flags &= ~_IO_USER_BUF;
 286   else
 287     f->_flags |= _IO_USER_BUF;
 288 }
 289
 290 void
 291 DEFUN(_IO_doallocbuf, (fp),
 292       register _IO_FILE *fp)
 293 {
 294   if (fp->_IO_buf_base)
 295     return;
 296   if (!(fp->_flags & _IO_UNBUFFERED))
 297     if (_IO_DOALLOCATE (fp) != EOF)
 298       return;
 299   _IO_setb(fp, fp->_shortbuf, fp->_shortbuf+1, 0);
 300 }
 301
 302 int
 303 DEFUN(_IO_default_underflow, (fp),
 304       _IO_FILE *fp)
 305 {
 306   return EOF;
 307 }
 308
 309 int
 310 DEFUN(_IO_default_uflow, (fp),
 311       _IO_FILE *fp)
 312 {
 313   int ch = _IO_UNDERFLOW (fp);
 314   if (ch == EOF)
 315     return EOF;
 316   return *(unsigned char*)fp->_IO_read_ptr++;
 317 }
 318
 319 _IO_size_t
 320 DEFUN(_IO_default_xsputn, (f, data, n),
 321       register _IO_FILE *f AND const void *data AND _IO_size_t n)
 322 {
 323   register const char *s = (char*) data;
 324   register _IO_size_t more = n;
 325   if (more <= 0)
 326     return 0;
 327   for (;;)
 328     {
 329       _IO_ssize_t count = f->_IO_write_end - f->_IO_write_ptr; /* Space available. */
 330       if (count > 0)
 331         {
 332           if (count > more)
 333             count = more;
 334           if (count > 20)
 335             {
 336               memcpy(f->_IO_write_ptr, s, count);
 337               s += count;
 338               f->_IO_write_ptr += count;
 339             }
 340           else if (count <= 0)
 341             count = 0;
 342           else
 343             {
 344               register char *p = f->_IO_write_ptr;
 345               register _IO_ssize_t i;
 346               for (i = count; --i >= 0; ) *p++ = *s++;
 347               f->_IO_write_ptr = p;
 348             }
 349           more -= count;
 350         }
 351       if (more == 0 || __overflow(f, (unsigned char)*s++) == EOF)
 352         break;
 353       more--;
 354     }
 355   return n - more;
 356 }
 357
 358 _IO_size_t
 359 DEFUN(_IO_sgetn, (fp, data, n),
 360       _IO_FILE *fp AND void *data AND _IO_size_t n)
 361 {
 362   /* FIXME handle putback buffer here! */
 363   return _IO_XSGETN (fp, data, n);
 364 }
 365
 366 _IO_size_t
 367 DEFUN(_IO_default_xsgetn, (fp, data, n),
 368       _IO_FILE *fp AND void *data AND _IO_size_t n)
 369 {
 370   register _IO_size_t more = n;
 371   register char *s = (char*) data;
 372   for (;;)
 373     {
 374       _IO_ssize_t count = fp->_IO_read_end - fp->_IO_read_ptr; /* Data available. */
 375       if (count > 0)
 376         {
 377           if (count > more)
 378             count = more;
 379           if (count > 20)
 380             {
 381               memcpy(s, fp->_IO_read_ptr, count);
 382               s += count;
 383               fp->_IO_read_ptr += count;
 384             }
 385           else if (count <= 0)
 386             count = 0;
 387           else
 388             {
 389               register char *p = fp->_IO_read_ptr;
 390               register int i = (int)count;
 391               while (--i >= 0) *s++ = *p++;
 392               fp->_IO_read_ptr = p;
 393             }
 394             more -= count;
 395         }
 396       if (more == 0 || __underflow(fp) == EOF)
 397         break;
 398     }
 399   return n - more;
 400 }
 401
 402 int
 403 DEFUN(_IO_sync, (fp),
 404       register _IO_FILE *fp)
 405 {
 406   return 0;
 407 }
 408
 409 _IO_FILE*
 410 DEFUN(_IO_default_setbuf, (fp, p, len),
 411       register _IO_FILE *fp AND char* p AND _IO_ssize_t len)
 412 {
 413     if (_IO_SYNC (fp) == EOF)
 414         return NULL;
 415     if (p == NULL || len == 0)
 416       {
 417         fp->_flags |= _IO_UNBUFFERED;
 418         _IO_setb(fp, fp->_shortbuf, fp->_shortbuf+1, 0);
 419       }
 420     else
 421       {
 422         fp->_flags &= ~_IO_UNBUFFERED;
 423         _IO_setb(fp, p, p+len, 0);
 424       }
 425     fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end = 0;
 426     fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_read_end = 0;
 427     return fp;
 428 }
 429
 430 _IO_pos_t
 431 DEFUN(_IO_default_seekpos, (fp, pos, mode),
 432       _IO_FILE *fp AND _IO_pos_t pos AND int mode)
 433 {
 434   return _IO_SEEKOFF (fp, _IO_pos_as_off(pos), 0, mode);
 435 }
 436
 437 int
 438 DEFUN(_IO_default_doallocate, (fp),
 439       _IO_FILE *fp)
 440 {
 441   char *buf = ALLOC_BUF(_IO_BUFSIZ);
 442   if (buf == NULL)
 443     return EOF;
 444   _IO_setb(fp, buf, buf+_IO_BUFSIZ, 1);
 445   return 1;
 446 }
 447
 448 void
 449 DEFUN(_IO_init, (fp, flags),
 450       register _IO_FILE *fp AND int flags)
 451 {
 452   fp->_flags = _IO_MAGIC|flags;
 453   fp->_IO_buf_base = NULL;
 454   fp->_IO_buf_end = NULL;
 455   fp->_IO_read_base = NULL;
 456   fp->_IO_read_ptr = NULL;
 457   fp->_IO_read_end = NULL;
 458   fp->_IO_write_base = NULL;
 459   fp->_IO_write_ptr = NULL;
 460   fp->_IO_write_end = NULL;
 461   fp->_chain = NULL; /* Not necessary. */
 462
 463   fp->_IO_save_base = NULL;
 464   fp->_IO_backup_base = NULL;
 465   fp->_IO_save_end = NULL;
 466   fp->_markers = NULL;
 467   fp->_cur_column = 0;
 468 }
 469
 470 int
 471 DEFUN(_IO_default_sync, (fp),
 472       _IO_FILE *fp)
 473 {
 474   return 0;
 475 }
 476
 477 /* The way the C++ classes are mapped into the C functions in the
 478    current implementation, this function can get called twice! */
 479
 480 void
 481 DEFUN(_IO_default_finish, (fp),
 482       _IO_FILE *fp)
 483 {
 484   struct _IO_marker *mark;
 485   if (fp->_IO_buf_base && !(fp->_flags & _IO_USER_BUF))
 486     {
 487       FREE_BUF(fp->_IO_buf_base);
 488       fp->_IO_buf_base = fp->_IO_buf_end = NULL;
 489     }
 490
 491   for (mark = fp->_markers; mark != NULL; mark = mark->_next)
 492     mark->_sbuf = NULL;
 493
 494   if (fp->_IO_save_base)
 495     {
 496       free (fp->_IO_save_base);
 497       fp->_IO_save_base = NULL;
 498     }
 499
 500   _IO_un_link(fp);
 501 }
 502
 503 _IO_pos_t
 504 DEFUN(_IO_default_seekoff, (fp, offset, dir, mode),
 505       register _IO_FILE *fp AND _IO_off_t offset AND int dir AND int mode)
 506 {
 507     return _IO_pos_BAD;
 508 }
 509
 510 int
 511 DEFUN(_IO_sputbackc, (fp, c),
 512       register _IO_FILE *fp AND int c)
 513 {
 514   int result;
 515
 516   if (fp->_IO_read_ptr > fp->_IO_read_base
 517       && (unsigned char)fp->_IO_read_ptr[-1] == (unsigned char)c)
 518     {
 519       fp->_IO_read_ptr--;
 520       result = (unsigned char)c;
 521     }
 522   else
 523     result = _IO_PBACKFAIL (fp, c);
 524
 525   if (result != EOF)
 526     fp->_flags &= ~_IO_EOF_SEEN;
 527
 528   return result;
 529 }
 530
 531 int
 532 DEFUN(_IO_sungetc, (fp),
 533       register _IO_FILE *fp)
 534 {
 535   int result;
 536
 537   if (fp->_IO_read_ptr > fp->_IO_read_base)
 538     {
 539       fp->_IO_read_ptr--;
 540       result = (unsigned char)*fp->_IO_read_ptr;
 541     }
 542   else
 543     result = _IO_PBACKFAIL (fp, EOF);
 544
 545   if (result != EOF)
 546     fp->_flags &= ~_IO_EOF_SEEN;
 547
 548   return result;
 549 }
 550
 551 #if 0 /* Work in progress */
 552 void
 553 DEFUN(_IO_set_column, (fp, c),
 554       register _IO_FILE *fp AND int c)
 555 {
 556   if (c == -1)
 557     fp->_column = -1;
 558   else
 559     fp->_column = c - (fp->_IO_write_ptr - fp->_IO_write_base);
 560 }
 561 #else
 562 int
 563 DEFUN(_IO_set_column, (fp, i),
 564       register _IO_FILE *fp AND int i)
 565 {
 566   fp->_cur_column = i+1;
 567   return 0;
 568 }
 569 #endif
 570
 571
 572 unsigned
 573 DEFUN(_IO_adjust_column, (start, line, count),
 574       unsigned start AND const char *line AND int count)
 575 {
 576   register const char *ptr = line + count;
 577   while (ptr > line)
 578     if (*--ptr == '\n')
 579       return line + count - ptr - 1;
 580   return start + count;
 581 }
 582
 583 int
 584 DEFUN(_IO_get_column, (fp),
 585       register _IO_FILE *fp)
 586 {
 587   if (fp->_cur_column)
 588     return _IO_adjust_column(fp->_cur_column - 1,
 589                               fp->_IO_write_base,
 590                               fp->_IO_write_ptr - fp->_IO_write_base);
 591   return -1;
 592 }
 593
 594 int
 595 DEFUN_VOID(_IO_flush_all)
 596 {
 597   int result = 0;
 598   _IO_FILE *fp;
 599   for (fp = _IO_list_all; fp != NULL; fp = fp->_chain)
 600     if (fp->_IO_write_ptr > fp->_IO_write_base
 601         && _IO_OVERFLOW (fp, EOF) == EOF)
 602       result = EOF;
 603   return result;
 604 }
 605
 606 void
 607 DEFUN_VOID(_IO_flush_all_linebuffered)
 608 {
 609   _IO_FILE *fp;
 610   for (fp = _IO_list_all; fp != NULL; fp = fp->_chain)
 611     if (fp->_flags & _IO_LINE_BUF)
 612       _IO_OVERFLOW (fp, EOF);
 613 }
 614
 615 void
 616 DEFUN_VOID(_IO_unbuffer_all)
 617 {
 618   _IO_FILE *fp;
 619   for (fp = _IO_list_all; fp != NULL; fp = fp->_chain)
 620     if (! (fp->_flags & _IO_UNBUFFERED))
 621       _IO_SETBUF (fp, NULL, 0);
 622 }
 623
 624 void
 625 DEFUN_VOID(_IO_cleanup)
 626 {
 627   _IO_flush_all ();
 628
 629   /* We currently don't have a reliable mechanism for making sure that
 630      C++ static destructors are executed in the correct order.
 631      So it is possible that other static destructord might want to
 632      write to cout - and they're supposed to be able to do so.
 633
 634      The following will make the standard streambufs be unbuffered,
 635      which forces any output from late destructors to be written out. */
 636   _IO_unbuffer_all ();
 637 }
 638
 639 void
 640 DEFUN(_IO_init_marker, (marker, fp),
 641       struct _IO_marker *marker AND _IO_FILE *fp)
 642 {
 643   marker->_sbuf = fp;
 644   if (_IO_in_put_mode(fp))
 645     _IO_switch_to_get_mode(fp);
 646   if (_IO_in_backup(fp))
 647     marker->_pos = fp->_IO_read_ptr - fp->_IO_read_end;
 648   else
 649     marker->_pos = fp->_IO_read_ptr - fp->_IO_read_base;
 650
 651   /* Should perhaps sort the chain? */
 652   marker->_next = fp->_markers;
 653   fp->_markers = marker;
 654 }
 655
 656 void
 657 DEFUN(_IO_remove_marker, (marker),
 658       register struct _IO_marker *marker)
 659 {
 660   /* Unlink from sb's chain. */
 661   register struct _IO_marker **ptr = &marker->_sbuf->_markers;
 662   for (; ; ptr = &(*ptr)->_next)
 663     {
 664       if (*ptr == NULL)
 665         break;
 666       else if (*ptr == marker)
 667         {
 668           *ptr = marker->_next;
 669           return;
 670         }
 671     }
 672 #if 0
 673     if _sbuf has a backup area that is no longer needed, should we delete
 674     it now, or wait until the next underflow?
 675 #endif
 676 }
 677
 678 #define BAD_DELTA EOF
 679
 680 int
 681 DEFUN(_IO_marker_difference, (mark1, mark2),
 682       struct _IO_marker *mark1 AND struct _IO_marker *mark2)
 683 {
 684   return mark1->_pos - mark2->_pos;
 685 }
 686
 687 /* Return difference between MARK and current posistion of MARK's stream. */
 688 int
 689 DEFUN(_IO_marker_delta, (mark),
 690       struct _IO_marker *mark)
 691 {
 692   int cur_pos;
 693   if (mark->_sbuf == NULL)
 694     return BAD_DELTA;
 695   if (_IO_in_backup(mark->_sbuf))
 696     cur_pos = mark->_sbuf->_IO_read_ptr - mark->_sbuf->_IO_read_end;
 697   else
 698     cur_pos = mark->_sbuf->_IO_read_ptr - mark->_sbuf->_IO_read_base;
 699   return mark->_pos - cur_pos;
 700 }
 701
 702 int
 703 DEFUN(_IO_seekmark, (fp, mark, delta),
 704       _IO_FILE *fp AND struct _IO_marker *mark AND int delta)
 705 {
 706   if (mark->_sbuf != fp)
 707     return EOF;
 708  if (mark->_pos >= 0)
 709     {
 710       if (_IO_in_backup(fp))
 711         _IO_switch_to_main_get_area(fp);
 712       fp->_IO_read_ptr = fp->_IO_read_base + mark->_pos;
 713     }
 714   else
 715     {
 716       if (!_IO_in_backup(fp))
 717         _IO_switch_to_backup_area(fp);
 718       fp->_IO_read_ptr = fp->_IO_read_end + mark->_pos;
 719     }
 720   return 0;
 721 }
 722
 723 void
 724 DEFUN(_IO_unsave_markers, (fp),
 725      register _IO_FILE *fp)
 726 {
 727   register struct _IO_marker *mark = fp->_markers;
 728   if (mark)
 729     {
 730 #ifdef TODO
 731       streampos offset = seekoff(0, ios::cur, ios::in);
 732       if (offset != EOF)
 733         {
 734           offset += eGptr() - Gbase();
 735           for ( ; mark != NULL; mark = mark->_next)
 736             mark->set_streampos(mark->_pos + offset);
 737         }
 738     else
 739       {
 740         for ( ; mark != NULL; mark = mark->_next)
 741           mark->set_streampos(EOF);
 742       }
 743 #endif
 744       fp->_markers = 0;
 745     }
 746
 747   if (_IO_have_backup(fp))
 748     _IO_free_backup_area(fp);
 749 }
 750
 751 int
 752 DEFUN(_IO_nobackup_pbackfail, (fp, c),
 753      register _IO_FILE *fp AND int c)
 754 {
 755   if (fp->_IO_read_ptr > fp->_IO_read_base)
 756         fp->_IO_read_ptr--;
 757   if (c != EOF && *fp->_IO_read_ptr != c)
 758       *fp->_IO_read_ptr = c;
 759   return (unsigned char)c;
 760 }
 761
 762 int
 763 DEFUN(_IO_default_pbackfail, (fp, c),
 764       register _IO_FILE *fp AND int c)
 765 {
 766   if (fp->_IO_read_ptr <= fp->_IO_read_base)
 767       {
 768         /* Need to handle a filebuf in write mode (switch to read mode). FIXME!*/
 769         if (_IO_have_backup(fp) && !_IO_in_backup(fp))
 770           _IO_switch_to_backup_area(fp);
 771
 772         if (!_IO_have_backup(fp))
 773           {
 774             /* No backup buffer: allocate one. */
 775             /* Use nshort buffer, if unused? (probably not)  FIXME */
 776             int backup_size = 128;
 777             char *bbuf = (char*)malloc(backup_size);
 778             if (bbuf == NULL)
 779               return EOF;
 780             fp->_IO_save_base = bbuf;
 781             fp->_IO_save_end = fp->_IO_save_base + backup_size;
 782             fp->_IO_backup_base = fp->_IO_save_end;
 783             _IO_switch_to_backup_area(fp);
 784           }
 785         else if (fp->_IO_read_ptr <= fp->_IO_read_base)
 786           {
 787             /* Increase size of existing backup buffer. */
 788             _IO_size_t new_size;
 789             _IO_size_t old_size = fp->_IO_read_end - fp->_IO_read_base;
 790             char *new_buf;
 791             new_size = 2 * old_size;
 792             new_buf = (char*)malloc(new_size);
 793             if (new_buf == NULL)
 794               return EOF;
 795             memcpy(new_buf+(new_size-old_size), fp->_IO_read_base, old_size);
 796             free (fp->_IO_read_base);
 797             _IO_setg(fp,
 798                      new_buf, new_buf+(new_size-old_size), new_buf+new_size);
 799             fp->_IO_backup_base = fp->_IO_read_ptr;
 800           }
 801       }
 802   fp->_IO_read_ptr--;
 803   if (c != EOF && *fp->_IO_read_ptr != c)
 804     *fp->_IO_read_ptr = c;
 805   return (unsigned char)*fp->_IO_read_ptr;
 806 }
 807
 808 _IO_pos_t
 809 DEFUN(_IO_default_seek, (fp, offset, dir),
 810       _IO_FILE *fp AND _IO_off_t offset AND int dir)
 811 {
 812   return _IO_pos_BAD;
 813 }
 814
 815 int
 816 DEFUN(_IO_default_stat, (fp, st),
 817       _IO_FILE *fp AND void* st)
 818 {
 819   return EOF;
 820 }
 821
 822 _IO_ssize_t
 823 DEFUN(_IO_default_read, (fp, data, n),
 824       register _IO_FILE* fp AND void* data AND _IO_ssize_t n)
 825 {
 826   return -1;
 827 }
 828
 829 _IO_ssize_t
 830 DEFUN(_IO_default_write, (fp, data, n),
 831       register _IO_FILE* fp AND const void* data AND _IO_ssize_t n)
 832 {
 833   return 0;
 834 }
 835
 836
 837 #ifdef TODO
 838 #if defined(linux)
 839 #define IO_CLEANUP ;
 840 #endif
 841
 842 #ifdef IO_CLEANUP
 843   IO_CLEANUP
 844 #else
 845 struct __io_defs {
 846     __io_defs() { }
 847     ~__io_defs() { _IO_cleanup(); }
 848 };
 849 __io_defs io_defs__;
 850 #endif
 851
 852 #endif /* TODO */