libio/genops.c

   1 /* Copyright (C) 1993, 1995, 1997-1999, 2000 Free Software Foundation, Inc.
   2    This file is part of the GNU IO Library.
   3
   4    This library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU General Public License as
   6    published by the Free Software Foundation; either version 2, or (at
   7    your option) any later version.
   8
   9    This library is distributed in the hope that it will be useful, but
  10    WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this library; see the file COPYING.  If not, write to
  16    the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
  17    MA 02111-1307, USA.
  18
  19    As a special exception, if you link this library with files
  20    compiled with a GNU compiler to produce an executable, this does
  21    not cause the resulting executable to be covered by the GNU General
  22    Public License.  This exception does not however invalidate any
  23    other reasons why the executable file might be covered by the GNU
  24    General Public License.  */
  25
  26 /* Generic or default I/O operations. */
  27
  28 #include "libioP.h"
  29 #ifdef __STDC__
  30 #include <stdlib.h>
  31 #endif
  32 #include <string.h>
  33
  34 #ifdef _IO_MTSAFE_IO
  35 static _IO_lock_t list_all_lock = _IO_lock_initializer;
  36 #endif
  37
  38 void
  39 _IO_un_link (fp)
  40      struct _IO_FILE_plus *fp;
  41 {
  42   if (fp->file._flags & _IO_LINKED)
  43     {
  44       struct _IO_FILE_plus **f;
  45 #ifdef _IO_MTSAFE_IO
  46       _IO_lock_lock (list_all_lock);
  47 #endif
  48       for (f = &_IO_list_all; *f; f = (struct _IO_FILE_plus **) &(*f)->file._chain)
  49         {
  50           if (*f == fp)
  51             {
  52               *f = (struct _IO_FILE_plus *) fp->file._chain;
  53               break;
  54             }
  55         }
  56 #ifdef _IO_MTSAFE_IO
  57       _IO_lock_unlock (list_all_lock);
  58 #endif
  59       fp->file._flags &= ~_IO_LINKED;
  60     }
  61 }
  62
  63 void
  64 _IO_link_in (fp)
  65      struct _IO_FILE_plus *fp;
  66 {
  67     if ((fp->file._flags & _IO_LINKED) == 0)
  68       {
  69         fp->file._flags |= _IO_LINKED;
  70 #ifdef _IO_MTSAFE_IO
  71         _IO_lock_lock (list_all_lock);
  72 #endif
  73         fp->file._chain = (_IO_FILE *) _IO_list_all;
  74         _IO_list_all = fp;
  75 #ifdef _IO_MTSAFE_IO
  76         _IO_lock_unlock (list_all_lock);
  77 #endif
  78       }
  79 }
  80
  81 /* Return minimum _pos markers
  82    Assumes the current get area is the main get area. */
  83 _IO_ssize_t _IO_least_marker __P ((_IO_FILE *fp, char *end_p));
  84
  85 _IO_ssize_t
  86 _IO_least_marker (fp, end_p)
  87      _IO_FILE *fp;
  88      char *end_p;
  89 {
  90   _IO_ssize_t least_so_far = end_p - fp->_IO_read_base;
  91   struct _IO_marker *mark;
  92   for (mark = fp->_markers; mark != NULL; mark = mark->_next)
  93     if (mark->_pos < least_so_far)
  94       least_so_far = mark->_pos;
  95   return least_so_far;
  96 }
  97
  98 /* Switch current get area from backup buffer to (start of) main get area. */
  99
 100 void
 101 _IO_switch_to_main_get_area (fp)
 102      _IO_FILE *fp;
 103 {
 104   char *tmp;
 105   fp->_flags &= ~_IO_IN_BACKUP;
 106   /* Swap _IO_read_end and _IO_save_end. */
 107   tmp = fp->_IO_read_end;
 108   fp->_IO_read_end = fp->_IO_save_end;
 109   fp->_IO_save_end= tmp;
 110   /* Swap _IO_read_base and _IO_save_base. */
 111   tmp = fp->_IO_read_base;
 112   fp->_IO_read_base = fp->_IO_save_base;
 113   fp->_IO_save_base = tmp;
 114   /* Set _IO_read_ptr. */
 115   fp->_IO_read_ptr = fp->_IO_read_base;
 116 }
 117
 118 /* Switch current get area from main get area to (end of) backup area. */
 119
 120 void
 121 _IO_switch_to_backup_area (fp)
 122      _IO_FILE *fp;
 123 {
 124   char *tmp;
 125   fp->_flags |= _IO_IN_BACKUP;
 126   /* Swap _IO_read_end and _IO_save_end. */
 127   tmp = fp->_IO_read_end;
 128   fp->_IO_read_end = fp->_IO_save_end;
 129   fp->_IO_save_end = tmp;
 130   /* Swap _IO_read_base and _IO_save_base. */
 131   tmp = fp->_IO_read_base;
 132   fp->_IO_read_base = fp->_IO_save_base;
 133   fp->_IO_save_base = tmp;
 134   /* Set _IO_read_ptr.  */
 135   fp->_IO_read_ptr = fp->_IO_read_end;
 136 }
 137
 138 int
 139 _IO_switch_to_get_mode (fp)
 140      _IO_FILE *fp;
 141 {
 142   if (fp->_IO_write_ptr > fp->_IO_write_base)
 143     if (_IO_OVERFLOW (fp, EOF) == EOF)
 144       return EOF;
 145   if (_IO_in_backup (fp))
 146     fp->_IO_read_base = fp->_IO_backup_base;
 147   else
 148     {
 149       fp->_IO_read_base = fp->_IO_buf_base;
 150       if (fp->_IO_write_ptr > fp->_IO_read_end)
 151         fp->_IO_read_end = fp->_IO_write_ptr;
 152     }
 153   fp->_IO_read_ptr = fp->_IO_write_ptr;
 154
 155   fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end = fp->_IO_read_ptr;
 156
 157   fp->_flags &= ~_IO_CURRENTLY_PUTTING;
 158   return 0;
 159 }
 160
 161 void
 162 _IO_free_backup_area (fp)
 163      _IO_FILE *fp;
 164 {
 165   if (_IO_in_backup (fp))
 166     _IO_switch_to_main_get_area (fp);  /* Just in case. */
 167   free (fp->_IO_save_base);
 168   fp->_IO_save_base = NULL;
 169   fp->_IO_save_end = NULL;
 170   fp->_IO_backup_base = NULL;
 171 }
 172
 173 #if 0
 174 int
 175 _IO_switch_to_put_mode (fp)
 176      _IO_FILE *fp;
 177 {
 178   fp->_IO_write_base = fp->_IO_read_ptr;
 179   fp->_IO_write_ptr = fp->_IO_read_ptr;
 180   /* Following is wrong if line- or un-buffered? */
 181   fp->_IO_write_end = (fp->_flags & _IO_IN_BACKUP
 182                        ? fp->_IO_read_end : fp->_IO_buf_end);
 183
 184   fp->_IO_read_ptr = fp->_IO_read_end;
 185   fp->_IO_read_base = fp->_IO_read_end;
 186
 187   fp->_flags |= _IO_CURRENTLY_PUTTING;
 188   return 0;
 189 }
 190 #endif
 191
 192 int
 193 __overflow (f, ch)
 194      _IO_FILE *f;
 195      int ch;
 196 {
 197   /* This is a single-byte stream.  */
 198   if (f->_mode == 0)
 199     _IO_fwide (f, -1);
 200   return _IO_OVERFLOW (f, ch);
 201 }
 202
 203 static int save_for_backup __P ((_IO_FILE *fp, char *end_p))
 204 #ifdef _LIBC
 205      internal_function
 206 #endif
 207      ;
 208
 209 static int
 210 #ifdef _LIBC
 211 internal_function
 212 #endif
 213 save_for_backup (fp, end_p)
 214      _IO_FILE *fp;
 215      char *end_p;
 216 {
 217   /* Append [_IO_read_base..end_p] to backup area. */
 218   _IO_ssize_t least_mark = _IO_least_marker (fp, end_p);
 219   /* needed_size is how much space we need in the backup area. */
 220   _IO_size_t needed_size = (end_p - fp->_IO_read_base) - least_mark;
 221   /* FIXME: Dubious arithmetic if pointers are NULL */
 222   _IO_size_t current_Bsize = fp->_IO_save_end - fp->_IO_save_base;
 223   _IO_size_t avail; /* Extra space available for future expansion. */
 224   _IO_ssize_t delta;
 225   struct _IO_marker *mark;
 226   if (needed_size > current_Bsize)
 227     {
 228       char *new_buffer;
 229       avail = 100;
 230       new_buffer = (char *) malloc (avail + needed_size);
 231       if (new_buffer == NULL)
 232         return EOF;             /* FIXME */
 233       if (least_mark < 0)
 234         {
 235 #ifdef _LIBC
 236           __mempcpy (__mempcpy (new_buffer + avail,
 237                                 fp->_IO_save_end + least_mark,
 238                                 -least_mark),
 239                      fp->_IO_read_base,
 240                      end_p - fp->_IO_read_base);
 241 #else
 242           memcpy (new_buffer + avail,
 243                   fp->_IO_save_end + least_mark,
 244                   -least_mark);
 245           memcpy (new_buffer + avail - least_mark,
 246                   fp->_IO_read_base,
 247                   end_p - fp->_IO_read_base);
 248 #endif
 249         }
 250       else
 251         memcpy (new_buffer + avail,
 252                 fp->_IO_read_base + least_mark,
 253                 needed_size);
 254       if (fp->_IO_save_base)
 255         free (fp->_IO_save_base);
 256       fp->_IO_save_base = new_buffer;
 257       fp->_IO_save_end = new_buffer + avail + needed_size;
 258     }
 259   else
 260     {
 261       avail = current_Bsize - needed_size;
 262       if (least_mark < 0)
 263         {
 264           memmove (fp->_IO_save_base + avail,
 265                    fp->_IO_save_end + least_mark,
 266                    -least_mark);
 267           memcpy (fp->_IO_save_base + avail - least_mark,
 268                   fp->_IO_read_base,
 269                   end_p - fp->_IO_read_base);
 270         }
 271       else if (needed_size > 0)
 272         memcpy (fp->_IO_save_base + avail,
 273                 fp->_IO_read_base + least_mark,
 274                 needed_size);
 275     }
 276   fp->_IO_backup_base = fp->_IO_save_base + avail;
 277   /* Adjust all the streammarkers. */
 278   delta = end_p - fp->_IO_read_base;
 279   for (mark = fp->_markers; mark != NULL; mark = mark->_next)
 280     mark->_pos -= delta;
 281   return 0;
 282 }
 283
 284 int
 285 __underflow (fp)
 286      _IO_FILE *fp;
 287 {
 288 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
 289   if (fp->_vtable_offset == 0 && _IO_fwide (fp, -1) != -1)
 290     return EOF;
 291 #endif
 292
 293   if (fp->_mode == 0)
 294     _IO_fwide (fp, -1);
 295   if (_IO_in_put_mode (fp))
 296     if (_IO_switch_to_get_mode (fp) == EOF)
 297       return EOF;
 298   if (fp->_IO_read_ptr < fp->_IO_read_end)
 299     return *(unsigned char *) fp->_IO_read_ptr;
 300   if (_IO_in_backup (fp))
 301     {
 302       _IO_switch_to_main_get_area (fp);
 303       if (fp->_IO_read_ptr < fp->_IO_read_end)
 304         return *(unsigned char *) fp->_IO_read_ptr;
 305     }
 306   if (_IO_have_markers (fp))
 307     {
 308       if (save_for_backup (fp, fp->_IO_read_end))
 309         return EOF;
 310     }
 311   else if (_IO_have_backup (fp))
 312     _IO_free_backup_area (fp);
 313   return _IO_UNDERFLOW (fp);
 314 }
 315
 316 int
 317 __uflow (fp)
 318      _IO_FILE *fp;
 319 {
 320 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
 321   if (fp->_vtable_offset == 0 && _IO_fwide (fp, -1) != -1)
 322     return EOF;
 323 #endif
 324
 325   if (fp->_mode == 0)
 326     _IO_fwide (fp, -11);
 327   if (_IO_in_put_mode (fp))
 328     if (_IO_switch_to_get_mode (fp) == EOF)
 329       return EOF;
 330   if (fp->_IO_read_ptr < fp->_IO_read_end)
 331     return *(unsigned char *) fp->_IO_read_ptr++;
 332   if (_IO_in_backup (fp))
 333     {
 334       _IO_switch_to_main_get_area (fp);
 335       if (fp->_IO_read_ptr < fp->_IO_read_end)
 336         return *(unsigned char *) fp->_IO_read_ptr++;
 337     }
 338   if (_IO_have_markers (fp))
 339     {
 340       if (save_for_backup (fp, fp->_IO_read_end))
 341         return EOF;
 342     }
 343   else if (_IO_have_backup (fp))
 344     _IO_free_backup_area (fp);
 345   return _IO_UFLOW (fp);
 346 }
 347
 348 void
 349 _IO_setb (f, b, eb, a)
 350      _IO_FILE *f;
 351       char *b;
 352      char *eb;
 353      int a;
 354 {
 355   if (f->_IO_buf_base && !(f->_flags & _IO_USER_BUF))
 356     FREE_BUF (f->_IO_buf_base, _IO_blen (f));
 357   f->_IO_buf_base = b;
 358   f->_IO_buf_end = eb;
 359   if (a)
 360     f->_flags &= ~_IO_USER_BUF;
 361   else
 362     f->_flags |= _IO_USER_BUF;
 363 }
 364
 365 void
 366 _IO_doallocbuf (fp)
 367      _IO_FILE *fp;
 368 {
 369   if (fp->_IO_buf_base)
 370     return;
 371   if (!(fp->_flags & _IO_UNBUFFERED) || fp->_mode > 0)
 372     if (_IO_DOALLOCATE (fp) != EOF)
 373       return;
 374   _IO_setb (fp, fp->_shortbuf, fp->_shortbuf+1, 0);
 375 }
 376
 377 int
 378 _IO_default_underflow (fp)
 379      _IO_FILE *fp;
 380 {
 381   return EOF;
 382 }
 383
 384 int
 385 _IO_default_uflow (fp)
 386      _IO_FILE *fp;
 387 {
 388   int ch = _IO_UNDERFLOW (fp);
 389   if (ch == EOF)
 390     return EOF;
 391   return *(unsigned char *) fp->_IO_read_ptr++;
 392 }
 393
 394 _IO_size_t
 395 _IO_default_xsputn (f, data, n)
 396      _IO_FILE *f;
 397      const void *data;
 398      _IO_size_t n;
 399 {
 400   const char *s = (char *) data;
 401   _IO_size_t more = n;
 402   if (more <= 0)
 403     return 0;
 404   for (;;)
 405     {
 406       /* Space available. */
 407       _IO_ssize_t count = f->_IO_write_end - f->_IO_write_ptr;
 408       if (count > 0)
 409         {
 410           if ((_IO_size_t) count > more)
 411             count = more;
 412           if (count > 20)
 413             {
 414 #ifdef _LIBC
 415               f->_IO_write_ptr = __mempcpy (f->_IO_write_ptr, s, count);
 416 #else
 417               memcpy (f->_IO_write_ptr, s, count);
 418               f->_IO_write_ptr += count;
 419 #endif
 420               s += count;
 421             }
 422           else if (count <= 0)
 423             count = 0;
 424           else
 425             {
 426               char *p = f->_IO_write_ptr;
 427               _IO_ssize_t i;
 428               for (i = count; --i >= 0; )
 429                 *p++ = *s++;
 430               f->_IO_write_ptr = p;
 431             }
 432           more -= count;
 433         }
 434       if (more == 0 || _IO_OVERFLOW (f, (unsigned char) *s++) == EOF)
 435         break;
 436       more--;
 437     }
 438   return n - more;
 439 }
 440
 441 _IO_size_t
 442 _IO_sgetn (fp, data, n)
 443      _IO_FILE *fp;
 444      void *data;
 445      _IO_size_t n;
 446 {
 447   /* FIXME handle putback buffer here! */
 448   return _IO_XSGETN (fp, data, n);
 449 }
 450
 451 _IO_size_t
 452 _IO_default_xsgetn (fp, data, n)
 453      _IO_FILE *fp;
 454      void *data;
 455      _IO_size_t n;
 456 {
 457   _IO_size_t more = n;
 458   char *s = (char*) data;
 459   for (;;)
 460     {
 461       /* Data available. */
 462       _IO_ssize_t count = fp->_IO_read_end - fp->_IO_read_ptr;
 463       if (count > 0)
 464         {
 465           if ((_IO_size_t) count > more)
 466             count = more;
 467           if (count > 20)
 468             {
 469 #ifdef _LIBC
 470               s = __mempcpy (s, fp->_IO_read_ptr, count);
 471 #else
 472               memcpy (s, fp->_IO_read_ptr, count);
 473               s += count;
 474 #endif
 475               fp->_IO_read_ptr += count;
 476             }
 477           else if (count <= 0)
 478             count = 0;
 479           else
 480             {
 481               char *p = fp->_IO_read_ptr;
 482               int i = (int) count;
 483               while (--i >= 0)
 484                 *s++ = *p++;
 485               fp->_IO_read_ptr = p;
 486             }
 487             more -= count;
 488         }
 489       if (more == 0 || __underflow (fp) == EOF)
 490         break;
 491     }
 492   return n - more;
 493 }
 494
 495 #if 0
 496 /* Seems not to be needed. --drepper */
 497 int
 498 _IO_sync (fp)
 499      _IO_FILE *fp;
 500 {
 501   return 0;
 502 }
 503 #endif
 504
 505 _IO_FILE *
 506 _IO_default_setbuf (fp, p, len)
 507      _IO_FILE *fp;
 508      char *p;
 509      _IO_ssize_t len;
 510 {
 511     if (_IO_SYNC (fp) == EOF)
 512         return NULL;
 513     if (p == NULL || len == 0)
 514       {
 515         fp->_flags |= _IO_UNBUFFERED;
 516         _IO_setb (fp, fp->_shortbuf, fp->_shortbuf+1, 0);
 517       }
 518     else
 519       {
 520         fp->_flags &= ~_IO_UNBUFFERED;
 521         _IO_setb (fp, p, p+len, 0);
 522       }
 523     fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end = 0;
 524     fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_read_end = 0;
 525     return fp;
 526 }
 527
 528 _IO_off64_t
 529 _IO_default_seekpos (fp, pos, mode)
 530      _IO_FILE *fp;
 531      _IO_off64_t pos;
 532      int mode;
 533 {
 534   return _IO_SEEKOFF (fp, pos, 0, mode);
 535 }
 536
 537 int
 538 _IO_default_doallocate (fp)
 539      _IO_FILE *fp;
 540 {
 541   char *buf;
 542
 543   ALLOC_BUF (buf, _IO_BUFSIZ, EOF);
 544   _IO_setb (fp, buf, buf+_IO_BUFSIZ, 1);
 545   return 1;
 546 }
 547
 548 void
 549 _IO_init (fp, flags)
 550      _IO_FILE *fp;
 551      int flags;
 552 {
 553   _IO_no_init (fp, flags, -1, NULL, NULL);
 554 }
 555
 556 void
 557 _IO_no_init (fp, flags, orientation, wd, jmp)
 558      _IO_FILE *fp;
 559      int flags;
 560      int orientation;
 561      struct _IO_wide_data *wd;
 562      struct _IO_jump_t *jmp;
 563 {
 564   fp->_flags = _IO_MAGIC|flags;
 565   fp->_IO_buf_base = NULL;
 566   fp->_IO_buf_end = NULL;
 567   fp->_IO_read_base = NULL;
 568   fp->_IO_read_ptr = NULL;
 569   fp->_IO_read_end = NULL;
 570   fp->_IO_write_base = NULL;
 571   fp->_IO_write_ptr = NULL;
 572   fp->_IO_write_end = NULL;
 573   fp->_chain = NULL; /* Not necessary. */
 574
 575   fp->_IO_save_base = NULL;
 576   fp->_IO_backup_base = NULL;
 577   fp->_IO_save_end = NULL;
 578   fp->_markers = NULL;
 579   fp->_cur_column = 0;
 580 #if _IO_JUMPS_OFFSET
 581   fp->_vtable_offset = 0;
 582 #endif
 583 #ifdef _IO_MTSAFE_IO
 584   _IO_lock_init (*fp->_lock);
 585 #endif
 586   fp->_mode = orientation;
 587 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
 588   if (orientation >= 0)
 589     {
 590       fp->_wide_data = wd;
 591       fp->_wide_data->_IO_buf_base = NULL;
 592       fp->_wide_data->_IO_buf_end = NULL;
 593       fp->_wide_data->_IO_read_base = NULL;
 594       fp->_wide_data->_IO_read_ptr = NULL;
 595       fp->_wide_data->_IO_read_end = NULL;
 596       fp->_wide_data->_IO_write_base = NULL;
 597       fp->_wide_data->_IO_write_ptr = NULL;
 598       fp->_wide_data->_IO_write_end = NULL;
 599       fp->_wide_data->_IO_save_base = NULL;
 600       fp->_wide_data->_IO_backup_base = NULL;
 601       fp->_wide_data->_IO_save_end = NULL;
 602
 603       fp->_wide_data->_wide_vtable = jmp;
 604     }
 605 #endif
 606 }
 607
 608 int
 609 _IO_default_sync (fp)
 610      _IO_FILE *fp;
 611 {
 612   return 0;
 613 }
 614
 615 /* The way the C++ classes are mapped into the C functions in the
 616    current implementation, this function can get called twice! */
 617
 618 void
 619 _IO_default_finish (fp, dummy)
 620      _IO_FILE *fp;
 621      int dummy;
 622 {
 623   struct _IO_marker *mark;
 624   if (fp->_IO_buf_base && !(fp->_flags & _IO_USER_BUF))
 625     {
 626       FREE_BUF (fp->_IO_buf_base, _IO_blen (fp));
 627       fp->_IO_buf_base = fp->_IO_buf_end = NULL;
 628     }
 629
 630   for (mark = fp->_markers; mark != NULL; mark = mark->_next)
 631     mark->_sbuf = NULL;
 632
 633   if (fp->_IO_save_base)
 634     {
 635       free (fp->_IO_save_base);
 636       fp->_IO_save_base = NULL;
 637     }
 638
 639 #ifdef _IO_MTSAFE_IO
 640   _IO_lock_fini (*fp->_lock);
 641 #endif
 642
 643   _IO_un_link ((struct _IO_FILE_plus *) fp);
 644 }
 645
 646 _IO_off64_t
 647 _IO_default_seekoff (fp, offset, dir, mode)
 648      _IO_FILE *fp;
 649      _IO_off64_t offset;
 650      int dir;
 651      int mode;
 652 {
 653     return _IO_pos_BAD;
 654 }
 655
 656 int
 657 _IO_sputbackc (fp, c)
 658      _IO_FILE *fp;
 659      int c;
 660 {
 661   int result;
 662
 663   if (fp->_IO_read_ptr > fp->_IO_read_base
 664       && (unsigned char)fp->_IO_read_ptr[-1] == (unsigned char)c)
 665     {
 666       fp->_IO_read_ptr--;
 667       result = (unsigned char) c;
 668     }
 669   else
 670     result = _IO_PBACKFAIL (fp, c);
 671
 672   if (result != EOF)
 673     fp->_flags &= ~_IO_EOF_SEEN;
 674
 675   return result;
 676 }
 677
 678 int
 679 _IO_sungetc (fp)
 680      _IO_FILE *fp;
 681 {
 682   int result;
 683
 684   if (fp->_IO_read_ptr > fp->_IO_read_base)
 685     {
 686       fp->_IO_read_ptr--;
 687       result = (unsigned char) *fp->_IO_read_ptr;
 688     }
 689   else
 690     result = _IO_PBACKFAIL (fp, EOF);
 691
 692   if (result != EOF)
 693     fp->_flags &= ~_IO_EOF_SEEN;
 694
 695   return result;
 696 }
 697
 698 #if 0 /* Work in progress */
 699 /* Seems not to be needed.  */
 700 #if 0
 701 void
 702 _IO_set_column (fp, c)
 703      _IO_FILE *fp;
 704      int c;
 705 {
 706   if (c == -1)
 707     fp->_column = -1;
 708   else
 709     fp->_column = c - (fp->_IO_write_ptr - fp->_IO_write_base);
 710 }
 711 #else
 712 int
 713 _IO_set_column (fp, i)
 714      _IO_FILE *fp;
 715      int i;
 716 {
 717   fp->_cur_column = i + 1;
 718   return 0;
 719 }
 720 #endif
 721 #endif
 722
 723
 724 unsigned
 725 _IO_adjust_column (start, line, count)
 726      unsigned start;
 727      const char *line;
 728      int count;
 729 {
 730   const char *ptr = line + count;
 731   while (ptr > line)
 732     if (*--ptr == '\n')
 733       return line + count - ptr - 1;
 734   return start + count;
 735 }
 736
 737 #if 0
 738 /* Seems not to be needed. --drepper */
 739 int
 740 _IO_get_column (fp)
 741      _IO_FILE *fp;
 742 {
 743   if (fp->_cur_column)
 744     return _IO_adjust_column (fp->_cur_column - 1,
 745                               fp->_IO_write_base,
 746                               fp->_IO_write_ptr - fp->_IO_write_base);
 747   return -1;
 748 }
 749 #endif
 750
 751 int
 752 _IO_flush_all ()
 753 {
 754   int result = 0;
 755   struct _IO_FILE *fp;
 756   for (fp = (_IO_FILE *) _IO_list_all; fp; fp = fp->_chain)
 757     if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)
 758 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
 759          || (fp->_vtable_offset == 0
 760              && fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr
 761                                   > fp->_wide_data->_IO_write_base))
 762 #endif
 763          )
 764         && _IO_OVERFLOW (fp, EOF) == EOF)
 765       result = EOF;
 766   return result;
 767 }
 768
 769 void
 770 _IO_flush_all_linebuffered ()
 771 {
 772   struct _IO_FILE *fp;
 773   for (fp = (_IO_FILE *) _IO_list_all; fp; fp = fp->_chain)
 774     if ((fp->_flags & _IO_NO_WRITES) == 0 && fp->_flags & _IO_LINE_BUF)
 775       _IO_OVERFLOW (fp, EOF);
 776 }
 777 #ifdef _LIBC
 778 weak_alias (_IO_flush_all_linebuffered, _flushlbf)
 779 #endif
 780
 781 static void _IO_unbuffer_write __P ((void));
 782
 783 static void
 784 _IO_unbuffer_write ()
 785 {
 786   struct _IO_FILE *fp;
 787   for (fp = (_IO_FILE *) _IO_list_all; fp; fp = fp->_chain)
 788     if (! (fp->_flags & _IO_UNBUFFERED)
 789         && (! (fp->_flags & _IO_NO_WRITES)
 790             || (fp->_flags & _IO_IS_APPENDING))
 791         /* Iff stream is un-orientated, it wasn't used. */
 792         && fp->_mode != 0)
 793       _IO_SETBUF (fp, NULL, 0);
 794 }
 795
 796 int
 797 _IO_cleanup ()
 798 {
 799   int result = _IO_flush_all ();
 800
 801   /* We currently don't have a reliable mechanism for making sure that
 802      C++ static destructors are executed in the correct order.
 803      So it is possible that other static destructors might want to
 804      write to cout - and they're supposed to be able to do so.
 805
 806      The following will make the standard streambufs be unbuffered,
 807      which forces any output from late destructors to be written out. */
 808   _IO_unbuffer_write ();
 809
 810   return result;
 811 }
 812
 813
 814 void
 815 _IO_init_marker (marker, fp)
 816      struct _IO_marker *marker;
 817      _IO_FILE *fp;
 818 {
 819   marker->_sbuf = fp;
 820   if (_IO_in_put_mode (fp))
 821     _IO_switch_to_get_mode (fp);
 822   if (_IO_in_backup (fp))
 823     marker->_pos = fp->_IO_read_ptr - fp->_IO_read_end;
 824   else
 825     marker->_pos = fp->_IO_read_ptr - fp->_IO_read_base;
 826
 827   /* Should perhaps sort the chain? */
 828   marker->_next = fp->_markers;
 829   fp->_markers = marker;
 830 }
 831
 832 void
 833 _IO_remove_marker (marker)
 834      struct _IO_marker *marker;
 835 {
 836   /* Unlink from sb's chain. */
 837   struct _IO_marker **ptr = &marker->_sbuf->_markers;
 838   for (; ; ptr = &(*ptr)->_next)
 839     {
 840       if (*ptr == NULL)
 841         break;
 842       else if (*ptr == marker)
 843         {
 844           *ptr = marker->_next;
 845           return;
 846         }
 847     }
 848 #if 0
 849     if _sbuf has a backup area that is no longer needed, should we delete
 850     it now, or wait until the next underflow?
 851 #endif
 852 }
 853
 854 #define BAD_DELTA EOF
 855
 856 int
 857 _IO_marker_difference (mark1, mark2)
 858      struct _IO_marker *mark1;
 859      struct _IO_marker *mark2;
 860 {
 861   return mark1->_pos - mark2->_pos;
 862 }
 863
 864 /* Return difference between MARK and current position of MARK's stream. */
 865 int
 866 _IO_marker_delta (mark)
 867      struct _IO_marker *mark;
 868 {
 869   int cur_pos;
 870   if (mark->_sbuf == NULL)
 871     return BAD_DELTA;
 872   if (_IO_in_backup (mark->_sbuf))
 873     cur_pos = mark->_sbuf->_IO_read_ptr - mark->_sbuf->_IO_read_end;
 874   else
 875     cur_pos = mark->_sbuf->_IO_read_ptr - mark->_sbuf->_IO_read_base;
 876   return mark->_pos - cur_pos;
 877 }
 878
 879 int
 880 _IO_seekmark (fp, mark, delta)
 881      _IO_FILE *fp;
 882      struct _IO_marker *mark;
 883      int delta;
 884 {
 885   if (mark->_sbuf != fp)
 886     return EOF;
 887  if (mark->_pos >= 0)
 888     {
 889       if (_IO_in_backup (fp))
 890         _IO_switch_to_main_get_area (fp);
 891       fp->_IO_read_ptr = fp->_IO_read_base + mark->_pos;
 892     }
 893   else
 894     {
 895       if (!_IO_in_backup (fp))
 896         _IO_switch_to_backup_area (fp);
 897       fp->_IO_read_ptr = fp->_IO_read_end + mark->_pos;
 898     }
 899   return 0;
 900 }
 901
 902 void
 903 _IO_unsave_markers (fp)
 904      _IO_FILE *fp;
 905 {
 906   struct _IO_marker *mark = fp->_markers;
 907   if (mark)
 908     {
 909 #ifdef TODO
 910       streampos offset = seekoff (0, ios::cur, ios::in);
 911       if (offset != EOF)
 912         {
 913           offset += eGptr () - Gbase ();
 914           for ( ; mark != NULL; mark = mark->_next)
 915             mark->set_streampos (mark->_pos + offset);
 916         }
 917     else
 918       {
 919         for ( ; mark != NULL; mark = mark->_next)
 920           mark->set_streampos (EOF);
 921       }
 922 #endif
 923       fp->_markers = 0;
 924     }
 925
 926   if (_IO_have_backup (fp))
 927     _IO_free_backup_area (fp);
 928 }
 929
 930 #if 0
 931 /* Seems not to be needed. --drepper */
 932 int
 933 _IO_nobackup_pbackfail (fp, c)
 934      _IO_FILE *fp;
 935      int c;
 936 {
 937   if (fp->_IO_read_ptr > fp->_IO_read_base)
 938         fp->_IO_read_ptr--;
 939   if (c != EOF && *fp->_IO_read_ptr != c)
 940       *fp->_IO_read_ptr = c;
 941   return (unsigned char) c;
 942 }
 943 #endif
 944
 945 int
 946 _IO_default_pbackfail (fp, c)
 947      _IO_FILE *fp;
 948      int c;
 949 {
 950   if (fp->_IO_read_ptr > fp->_IO_read_base && !_IO_in_backup (fp)
 951       && (unsigned char) fp->_IO_read_ptr[-1] == c)
 952     --fp->_IO_read_ptr;
 953   else
 954     {
 955       /* Need to handle a filebuf in write mode (switch to read mode). FIXME!*/
 956       if (!_IO_in_backup (fp))
 957         {
 958           /* We need to keep the invariant that the main get area
 959              logically follows the backup area.  */
 960           if (fp->_IO_read_ptr > fp->_IO_read_base && _IO_have_backup (fp))
 961             {
 962               if (save_for_backup (fp, fp->_IO_read_ptr))
 963                 return EOF;
 964             }
 965           else if (!_IO_have_backup (fp))
 966             {
 967               /* No backup buffer: allocate one. */
 968               /* Use nshort buffer, if unused? (probably not)  FIXME */
 969               int backup_size = 128;
 970               char *bbuf = (char *) malloc (backup_size);
 971               if (bbuf == NULL)
 972                 return EOF;
 973               fp->_IO_save_base = bbuf;
 974               fp->_IO_save_end = fp->_IO_save_base + backup_size;
 975               fp->_IO_backup_base = fp->_IO_save_end;
 976             }
 977           fp->_IO_read_base = fp->_IO_read_ptr;
 978           _IO_switch_to_backup_area (fp);
 979         }
 980       else if (fp->_IO_read_ptr <= fp->_IO_read_base)
 981         {
 982           /* Increase size of existing backup buffer. */
 983           _IO_size_t new_size;
 984           _IO_size_t old_size = fp->_IO_read_end - fp->_IO_read_base;
 985           char *new_buf;
 986           new_size = 2 * old_size;
 987           new_buf = (char *) malloc (new_size);
 988           if (new_buf == NULL)
 989             return EOF;
 990           memcpy (new_buf + (new_size - old_size), fp->_IO_read_base,
 991                   old_size);
 992           free (fp->_IO_read_base);
 993           _IO_setg (fp, new_buf, new_buf + (new_size - old_size),
 994                     new_buf + new_size);
 995           fp->_IO_backup_base = fp->_IO_read_ptr;
 996         }
 997
 998       *--fp->_IO_read_ptr = c;
 999     }
1000   return (unsigned char) c;
1001 }
1002
1003 _IO_off64_t
1004 _IO_default_seek (fp, offset, dir)
1005      _IO_FILE *fp;
1006      _IO_off64_t offset;
1007      int dir;
1008 {
1009   return _IO_pos_BAD;
1010 }
1011
1012 int
1013 _IO_default_stat (fp, st)
1014      _IO_FILE *fp;
1015      void* st;
1016 {
1017   return EOF;
1018 }
1019
1020 _IO_ssize_t
1021 _IO_default_read (fp, data, n)
1022      _IO_FILE* fp;
1023      void *data;
1024      _IO_ssize_t n;
1025 {
1026   return -1;
1027 }
1028
1029 _IO_ssize_t
1030 _IO_default_write (fp, data, n)
1031      _IO_FILE *fp;
1032      const void *data;
1033      _IO_ssize_t n;
1034 {
1035   return 0;
1036 }
1037
1038 int
1039 _IO_default_showmanyc (fp)
1040      _IO_FILE *fp;
1041 {
1042   return -1;
1043 }
1044
1045 void
1046 _IO_default_imbue (fp, locale)
1047      _IO_FILE *fp;
1048      void *locale;
1049 {
1050 }
1051
1052 _IO_ITER
1053 _IO_iter_begin()
1054 {
1055   return (_IO_ITER) _IO_list_all;
1056 }
1057
1058 _IO_ITER
1059 _IO_iter_end()
1060 {
1061   return NULL;
1062 }
1063
1064 _IO_ITER
1065 _IO_iter_next(iter)
1066     _IO_ITER iter;
1067 {
1068   return iter->_chain;
1069 }
1070
1071 _IO_FILE *
1072 _IO_iter_file(iter)
1073     _IO_ITER iter;
1074 {
1075   return iter;
1076 }
1077
1078 void
1079 _IO_list_lock()
1080 {
1081 #ifdef _IO_MTSAFE_IO
1082   _IO_lock_lock (list_all_lock);
1083 #endif
1084 }
1085
1086 void
1087 _IO_list_unlock()
1088 {
1089 #ifdef _IO_MTSAFE_IO
1090   _IO_lock_unlock (list_all_lock);
1091 #endif
1092 }
1093
1094 void
1095 _IO_list_resetlock()
1096 {
1097 #ifdef _IO_MTSAFE_IO
1098   _IO_lock_init (list_all_lock);
1099 #endif
1100 }
1101
1102
1103 #ifdef TODO
1104 #if defined(linux)
1105 #define IO_CLEANUP ;
1106 #endif
1107
1108 #ifdef IO_CLEANUP
1109   IO_CLEANUP
1110 #else
1111 struct __io_defs {
1112     __io_defs() { }
1113     ~__io_defs() { _IO_cleanup (); }
1114 };
1115 __io_defs io_defs__;
1116 #endif
1117
1118 #endif /* TODO */
1119
1120 #ifdef weak_alias
1121 weak_alias (_IO_cleanup, _cleanup)
1122 #endif
1123
1124 #ifdef text_set_element
1125 text_set_element(__libc_atexit, _cleanup);
1126 #endif