libio/genops.c

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