libio/genops.c

   1 /* Copyright (C) 1993-2013 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_BUF (f->_IO_buf_base, _IO_blen (f));
 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   ALLOC_BUF (buf, _IO_BUFSIZ, EOF);
 591   _IO_setb (fp, buf, buf+_IO_BUFSIZ, 1);
 592   return 1;
 593 }
 594 libc_hidden_def (_IO_default_doallocate)
 595
 596 void
 597 _IO_init (fp, flags)
 598      _IO_FILE *fp;
 599      int flags;
 600 {
 601   _IO_no_init (fp, flags, -1, NULL, NULL);
 602 }
 603 libc_hidden_def (_IO_init)
 604
 605 void
 606 _IO_old_init (fp, flags)
 607      _IO_FILE *fp;
 608      int flags;
 609 {
 610   fp->_flags = _IO_MAGIC|flags;
 611   fp->_flags2 = 0;
 612   fp->_IO_buf_base = NULL;
 613   fp->_IO_buf_end = NULL;
 614   fp->_IO_read_base = NULL;
 615   fp->_IO_read_ptr = NULL;
 616   fp->_IO_read_end = NULL;
 617   fp->_IO_write_base = NULL;
 618   fp->_IO_write_ptr = NULL;
 619   fp->_IO_write_end = NULL;
 620   fp->_chain = NULL; /* Not necessary. */
 621
 622   fp->_IO_save_base = NULL;
 623   fp->_IO_backup_base = NULL;
 624   fp->_IO_save_end = NULL;
 625   fp->_markers = NULL;
 626   fp->_cur_column = 0;
 627 #if _IO_JUMPS_OFFSET
 628   fp->_vtable_offset = 0;
 629 #endif
 630 #ifdef _IO_MTSAFE_IO
 631   if (fp->_lock != NULL)
 632     _IO_lock_init (*fp->_lock);
 633 #endif
 634 }
 635
 636 void
 637 _IO_no_init (fp, flags, orientation, wd, jmp)
 638      _IO_FILE *fp;
 639      int flags;
 640      int orientation;
 641      struct _IO_wide_data *wd;
 642      const struct _IO_jump_t *jmp;
 643 {
 644   _IO_old_init (fp, flags);
 645   fp->_mode = orientation;
 646 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
 647   if (orientation >= 0)
 648     {
 649       fp->_wide_data = wd;
 650       fp->_wide_data->_IO_buf_base = NULL;
 651       fp->_wide_data->_IO_buf_end = NULL;
 652       fp->_wide_data->_IO_read_base = NULL;
 653       fp->_wide_data->_IO_read_ptr = NULL;
 654       fp->_wide_data->_IO_read_end = NULL;
 655       fp->_wide_data->_IO_write_base = NULL;
 656       fp->_wide_data->_IO_write_ptr = NULL;
 657       fp->_wide_data->_IO_write_end = NULL;
 658       fp->_wide_data->_IO_save_base = NULL;
 659       fp->_wide_data->_IO_backup_base = NULL;
 660       fp->_wide_data->_IO_save_end = NULL;
 661
 662       fp->_wide_data->_wide_vtable = jmp;
 663     }
 664 #endif
 665   fp->_freeres_list = NULL;
 666 }
 667
 668 int
 669 _IO_default_sync (fp)
 670      _IO_FILE *fp;
 671 {
 672   return 0;
 673 }
 674
 675 /* The way the C++ classes are mapped into the C functions in the
 676    current implementation, this function can get called twice! */
 677
 678 void
 679 _IO_default_finish (fp, dummy)
 680      _IO_FILE *fp;
 681      int dummy;
 682 {
 683   struct _IO_marker *mark;
 684   if (fp->_IO_buf_base && !(fp->_flags & _IO_USER_BUF))
 685     {
 686       FREE_BUF (fp->_IO_buf_base, _IO_blen (fp));
 687       fp->_IO_buf_base = fp->_IO_buf_end = NULL;
 688     }
 689
 690   for (mark = fp->_markers; mark != NULL; mark = mark->_next)
 691     mark->_sbuf = NULL;
 692
 693   if (fp->_IO_save_base)
 694     {
 695       free (fp->_IO_save_base);
 696       fp->_IO_save_base = NULL;
 697     }
 698
 699   _IO_un_link ((struct _IO_FILE_plus *) fp);
 700
 701 #ifdef _IO_MTSAFE_IO
 702   if (fp->_lock != NULL)
 703     _IO_lock_fini (*fp->_lock);
 704 #endif
 705 }
 706 libc_hidden_def (_IO_default_finish)
 707
 708 _IO_off64_t
 709 _IO_default_seekoff (fp, offset, dir, mode)
 710      _IO_FILE *fp;
 711      _IO_off64_t offset;
 712      int dir;
 713      int mode;
 714 {
 715   return _IO_pos_BAD;
 716 }
 717
 718 int
 719 _IO_sputbackc (fp, c)
 720      _IO_FILE *fp;
 721      int c;
 722 {
 723   int result;
 724
 725   if (fp->_IO_read_ptr > fp->_IO_read_base
 726       && (unsigned char)fp->_IO_read_ptr[-1] == (unsigned char)c)
 727     {
 728       fp->_IO_read_ptr--;
 729       result = (unsigned char) c;
 730     }
 731   else
 732     result = _IO_PBACKFAIL (fp, c);
 733
 734   if (result != EOF)
 735     fp->_flags &= ~_IO_EOF_SEEN;
 736
 737   return result;
 738 }
 739 libc_hidden_def (_IO_sputbackc)
 740
 741 int
 742 _IO_sungetc (fp)
 743      _IO_FILE *fp;
 744 {
 745   int result;
 746
 747   if (fp->_IO_read_ptr > fp->_IO_read_base)
 748     {
 749       fp->_IO_read_ptr--;
 750       result = (unsigned char) *fp->_IO_read_ptr;
 751     }
 752   else
 753     result = _IO_PBACKFAIL (fp, EOF);
 754
 755   if (result != EOF)
 756     fp->_flags &= ~_IO_EOF_SEEN;
 757
 758   return result;
 759 }
 760
 761 #if 0 /* Work in progress */
 762 /* Seems not to be needed.  */
 763 #if 0
 764 void
 765 _IO_set_column (fp, c)
 766      _IO_FILE *fp;
 767      int c;
 768 {
 769   if (c == -1)
 770     fp->_column = -1;
 771   else
 772     fp->_column = c - (fp->_IO_write_ptr - fp->_IO_write_base);
 773 }
 774 #else
 775 int
 776 _IO_set_column (fp, i)
 777      _IO_FILE *fp;
 778      int i;
 779 {
 780   fp->_cur_column = i + 1;
 781   return 0;
 782 }
 783 #endif
 784 #endif
 785
 786
 787 unsigned
 788 _IO_adjust_column (start, line, count)
 789      unsigned start;
 790      const char *line;
 791      int count;
 792 {
 793   const char *ptr = line + count;
 794   while (ptr > line)
 795     if (*--ptr == '\n')
 796       return line + count - ptr - 1;
 797   return start + count;
 798 }
 799 libc_hidden_def (_IO_adjust_column)
 800
 801 #if 0
 802 /* Seems not to be needed. --drepper */
 803 int
 804 _IO_get_column (fp)
 805      _IO_FILE *fp;
 806 {
 807   if (fp->_cur_column)
 808     return _IO_adjust_column (fp->_cur_column - 1,
 809                               fp->_IO_write_base,
 810                               fp->_IO_write_ptr - fp->_IO_write_base);
 811   return -1;
 812 }
 813 #endif
 814
 815
 816 int
 817 _IO_flush_all_lockp (int do_lock)
 818 {
 819   int result = 0;
 820   struct _IO_FILE *fp;
 821   int last_stamp;
 822
 823 #ifdef _IO_MTSAFE_IO
 824   __libc_cleanup_region_start (do_lock, flush_cleanup, NULL);
 825   if (do_lock)
 826     _IO_lock_lock (list_all_lock);
 827 #endif
 828
 829   last_stamp = _IO_list_all_stamp;
 830   fp = (_IO_FILE *) _IO_list_all;
 831   while (fp != NULL)
 832     {
 833       run_fp = fp;
 834       if (do_lock)
 835         _IO_flockfile (fp);
 836
 837       if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)
 838 #if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T
 839            || (_IO_vtable_offset (fp) == 0
 840                && fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr
 841                                     > fp->_wide_data->_IO_write_base))
 842 #endif
 843            )
 844           && _IO_OVERFLOW (fp, EOF) == EOF)
 845         result = EOF;
 846
 847       if (do_lock)
 848         _IO_funlockfile (fp);
 849       run_fp = NULL;
 850
 851       if (last_stamp != _IO_list_all_stamp)
 852         {
 853           /* Something was added to the list.  Start all over again.  */
 854           fp = (_IO_FILE *) _IO_list_all;
 855           last_stamp = _IO_list_all_stamp;
 856         }
 857       else
 858         fp = fp->_chain;
 859     }
 860
 861 #ifdef _IO_MTSAFE_IO
 862   if (do_lock)
 863     _IO_lock_unlock (list_all_lock);
 864   __libc_cleanup_region_end (0);
 865 #endif
 866
 867   return result;
 868 }
 869
 870
 871 int
 872 _IO_flush_all ()
 873 {
 874   /* We want locking.  */
 875   return _IO_flush_all_lockp (1);
 876 }
 877 libc_hidden_def (_IO_flush_all)
 878
 879 void
 880 _IO_flush_all_linebuffered ()
 881 {
 882   struct _IO_FILE *fp;
 883   int last_stamp;
 884
 885 #ifdef _IO_MTSAFE_IO
 886   _IO_cleanup_region_start_noarg (flush_cleanup);
 887   _IO_lock_lock (list_all_lock);
 888 #endif
 889
 890   last_stamp = _IO_list_all_stamp;
 891   fp = (_IO_FILE *) _IO_list_all;
 892   while (fp != NULL)
 893     {
 894       run_fp = fp;
 895       _IO_flockfile (fp);
 896
 897       if ((fp->_flags & _IO_NO_WRITES) == 0 && fp->_flags & _IO_LINE_BUF)
 898         _IO_OVERFLOW (fp, EOF);
 899
 900       _IO_funlockfile (fp);
 901       run_fp = NULL;
 902
 903       if (last_stamp != _IO_list_all_stamp)
 904         {
 905           /* Something was added to the list.  Start all over again.  */
 906           fp = (_IO_FILE *) _IO_list_all;
 907           last_stamp = _IO_list_all_stamp;
 908         }
 909       else
 910         fp = fp->_chain;
 911     }
 912
 913 #ifdef _IO_MTSAFE_IO
 914   _IO_lock_unlock (list_all_lock);
 915   _IO_cleanup_region_end (0);
 916 #endif
 917 }
 918 libc_hidden_def (_IO_flush_all_linebuffered)
 919 #ifdef _LIBC
 920 weak_alias (_IO_flush_all_linebuffered, _flushlbf)
 921 #endif
 922
 923
 924 /* The following is a bit tricky.  In general, we want to unbuffer the
 925    streams so that all output which follows is seen.  If we are not
 926    looking for memory leaks it does not make much sense to free the
 927    actual buffer because this will happen anyway once the program
 928    terminated.  If we do want to look for memory leaks we have to free
 929    the buffers.  Whether something is freed is determined by the
 930    function sin the libc_freeres section.  Those are called as part of
 931    the atexit routine, just like _IO_cleanup.  The problem is we do
 932    not know whether the freeres code is called first or _IO_cleanup.
 933    if the former is the case, we set the DEALLOC_BUFFER variable to
 934    true and _IO_unbuffer_write will take care of the rest.  If
 935    _IO_unbuffer_write is called first we add the streams to a list
 936    which the freeres function later can walk through.  */
 937 static void _IO_unbuffer_write (void);
 938
 939 static bool dealloc_buffers;
 940 static _IO_FILE *freeres_list;
 941
 942 static void
 943 _IO_unbuffer_write (void)
 944 {
 945   struct _IO_FILE *fp;
 946   for (fp = (_IO_FILE *) _IO_list_all; fp; fp = fp->_chain)
 947     {
 948       if (! (fp->_flags & _IO_UNBUFFERED)
 949           && (! (fp->_flags & _IO_NO_WRITES)
 950               || (fp->_flags & _IO_IS_APPENDING))
 951           /* Iff stream is un-orientated, it wasn't used. */
 952           && fp->_mode != 0)
 953         {
 954 #ifdef _IO_MTSAFE_IO
 955           int cnt;
 956 #define MAXTRIES 2
 957           for (cnt = 0; cnt < MAXTRIES; ++cnt)
 958             if (fp->_lock == NULL || _IO_lock_trylock (*fp->_lock) == 0)
 959               break;
 960             else
 961               /* Give the other thread time to finish up its use of the
 962                  stream.  */
 963               __sched_yield ();
 964 #endif
 965
 966           if (! dealloc_buffers && !(fp->_flags & _IO_USER_BUF))
 967             {
 968               fp->_flags |= _IO_USER_BUF;
 969
 970               fp->_freeres_list = freeres_list;
 971               freeres_list = fp;
 972               fp->_freeres_buf = fp->_IO_buf_base;
 973               fp->_freeres_size = _IO_blen (fp);
 974             }
 975
 976           _IO_SETBUF (fp, NULL, 0);
 977
 978 #ifdef _IO_MTSAFE_IO
 979           if (cnt < MAXTRIES && fp->_lock != NULL)
 980             _IO_lock_unlock (*fp->_lock);
 981 #endif
 982         }
 983
 984       /* Make sure that never again the wide char functions can be
 985          used.  */
 986       fp->_mode = -1;
 987     }
 988 }
 989
 990
 991 libc_freeres_fn (buffer_free)
 992 {
 993   dealloc_buffers = true;
 994
 995   while (freeres_list != NULL)
 996     {
 997       FREE_BUF (freeres_list->_freeres_buf, freeres_list->_freeres_size);
 998
 999       freeres_list = freeres_list->_freeres_list;
1000     }
1001 }
1002
1003
1004 int
1005 _IO_cleanup ()
1006 {
1007   /* We do *not* want locking.  Some threads might use streams but
1008      that is their problem, we flush them underneath them.  */
1009   int result = _IO_flush_all_lockp (0);
1010
1011   /* We currently don't have a reliable mechanism for making sure that
1012      C++ static destructors are executed in the correct order.
1013      So it is possible that other static destructors might want to
1014      write to cout - and they're supposed to be able to do so.
1015
1016      The following will make the standard streambufs be unbuffered,
1017      which forces any output from late destructors to be written out. */
1018   _IO_unbuffer_write ();
1019
1020   return result;
1021 }
1022
1023
1024 void
1025 _IO_init_marker (marker, fp)
1026      struct _IO_marker *marker;
1027      _IO_FILE *fp;
1028 {
1029   marker->_sbuf = fp;
1030   if (_IO_in_put_mode (fp))
1031     _IO_switch_to_get_mode (fp);
1032   if (_IO_in_backup (fp))
1033     marker->_pos = fp->_IO_read_ptr - fp->_IO_read_end;
1034   else
1035     marker->_pos = fp->_IO_read_ptr - fp->_IO_read_base;
1036
1037   /* Should perhaps sort the chain? */
1038   marker->_next = fp->_markers;
1039   fp->_markers = marker;
1040 }
1041
1042 void
1043 _IO_remove_marker (marker)
1044      struct _IO_marker *marker;
1045 {
1046   /* Unlink from sb's chain. */
1047   struct _IO_marker **ptr = &marker->_sbuf->_markers;
1048   for (; ; ptr = &(*ptr)->_next)
1049     {
1050       if (*ptr == NULL)
1051         break;
1052       else if (*ptr == marker)
1053         {
1054           *ptr = marker->_next;
1055           return;
1056         }
1057     }
1058 #if 0
1059     if _sbuf has a backup area that is no longer needed, should we delete
1060     it now, or wait until the next underflow?
1061 #endif
1062 }
1063
1064 #define BAD_DELTA EOF
1065
1066 int
1067 _IO_marker_difference (mark1, mark2)
1068      struct _IO_marker *mark1;
1069      struct _IO_marker *mark2;
1070 {
1071   return mark1->_pos - mark2->_pos;
1072 }
1073
1074 /* Return difference between MARK and current position of MARK's stream. */
1075 int
1076 _IO_marker_delta (mark)
1077      struct _IO_marker *mark;
1078 {
1079   int cur_pos;
1080   if (mark->_sbuf == NULL)
1081     return BAD_DELTA;
1082   if (_IO_in_backup (mark->_sbuf))
1083     cur_pos = mark->_sbuf->_IO_read_ptr - mark->_sbuf->_IO_read_end;
1084   else
1085     cur_pos = mark->_sbuf->_IO_read_ptr - mark->_sbuf->_IO_read_base;
1086   return mark->_pos - cur_pos;
1087 }
1088
1089 int
1090 _IO_seekmark (fp, mark, delta)
1091      _IO_FILE *fp;
1092      struct _IO_marker *mark;
1093      int delta;
1094 {
1095   if (mark->_sbuf != fp)
1096     return EOF;
1097  if (mark->_pos >= 0)
1098     {
1099       if (_IO_in_backup (fp))
1100         _IO_switch_to_main_get_area (fp);
1101       fp->_IO_read_ptr = fp->_IO_read_base + mark->_pos;
1102     }
1103   else
1104     {
1105       if (!_IO_in_backup (fp))
1106         _IO_switch_to_backup_area (fp);
1107       fp->_IO_read_ptr = fp->_IO_read_end + mark->_pos;
1108     }
1109   return 0;
1110 }
1111
1112 void
1113 _IO_unsave_markers (fp)
1114      _IO_FILE *fp;
1115 {
1116   struct _IO_marker *mark = fp->_markers;
1117   if (mark)
1118     {
1119 #ifdef TODO
1120       streampos offset = seekoff (0, ios::cur, ios::in);
1121       if (offset != EOF)
1122         {
1123           offset += eGptr () - Gbase ();
1124           for ( ; mark != NULL; mark = mark->_next)
1125             mark->set_streampos (mark->_pos + offset);
1126         }
1127     else
1128       {
1129         for ( ; mark != NULL; mark = mark->_next)
1130           mark->set_streampos (EOF);
1131       }
1132 #endif
1133       fp->_markers = 0;
1134     }
1135
1136   if (_IO_have_backup (fp))
1137     _IO_free_backup_area (fp);
1138 }
1139 libc_hidden_def (_IO_unsave_markers)
1140
1141 #if 0
1142 /* Seems not to be needed. --drepper */
1143 int
1144 _IO_nobackup_pbackfail (fp, c)
1145      _IO_FILE *fp;
1146      int c;
1147 {
1148   if (fp->_IO_read_ptr > fp->_IO_read_base)
1149         fp->_IO_read_ptr--;
1150   if (c != EOF && *fp->_IO_read_ptr != c)
1151       *fp->_IO_read_ptr = c;
1152   return (unsigned char) c;
1153 }
1154 #endif
1155
1156 int
1157 _IO_default_pbackfail (fp, c)
1158      _IO_FILE *fp;
1159      int c;
1160 {
1161   if (fp->_IO_read_ptr > fp->_IO_read_base && !_IO_in_backup (fp)
1162       && (unsigned char) fp->_IO_read_ptr[-1] == c)
1163     --fp->_IO_read_ptr;
1164   else
1165     {
1166       /* Need to handle a filebuf in write mode (switch to read mode). FIXME!*/
1167       if (!_IO_in_backup (fp))
1168         {
1169           /* We need to keep the invariant that the main get area
1170              logically follows the backup area.  */
1171           if (fp->_IO_read_ptr > fp->_IO_read_base && _IO_have_backup (fp))
1172             {
1173               if (save_for_backup (fp, fp->_IO_read_ptr))
1174                 return EOF;
1175             }
1176           else if (!_IO_have_backup (fp))
1177             {
1178               /* No backup buffer: allocate one. */
1179               /* Use nshort buffer, if unused? (probably not)  FIXME */
1180               int backup_size = 128;
1181               char *bbuf = (char *) malloc (backup_size);
1182               if (bbuf == NULL)
1183                 return EOF;
1184               fp->_IO_save_base = bbuf;
1185               fp->_IO_save_end = fp->_IO_save_base + backup_size;
1186               fp->_IO_backup_base = fp->_IO_save_end;
1187             }
1188           fp->_IO_read_base = fp->_IO_read_ptr;
1189           _IO_switch_to_backup_area (fp);
1190         }
1191       else if (fp->_IO_read_ptr <= fp->_IO_read_base)
1192         {
1193           /* Increase size of existing backup buffer. */
1194           _IO_size_t new_size;
1195           _IO_size_t old_size = fp->_IO_read_end - fp->_IO_read_base;
1196           char *new_buf;
1197           new_size = 2 * old_size;
1198           new_buf = (char *) malloc (new_size);
1199           if (new_buf == NULL)
1200             return EOF;
1201           memcpy (new_buf + (new_size - old_size), fp->_IO_read_base,
1202                   old_size);
1203           free (fp->_IO_read_base);
1204           _IO_setg (fp, new_buf, new_buf + (new_size - old_size),
1205                     new_buf + new_size);
1206           fp->_IO_backup_base = fp->_IO_read_ptr;
1207         }
1208
1209       *--fp->_IO_read_ptr = c;
1210     }
1211   return (unsigned char) c;
1212 }
1213 libc_hidden_def (_IO_default_pbackfail)
1214
1215 _IO_off64_t
1216 _IO_default_seek (fp, offset, dir)
1217      _IO_FILE *fp;
1218      _IO_off64_t offset;
1219      int dir;
1220 {
1221   return _IO_pos_BAD;
1222 }
1223
1224 int
1225 _IO_default_stat (fp, st)
1226      _IO_FILE *fp;
1227      void* st;
1228 {
1229   return EOF;
1230 }
1231
1232 _IO_ssize_t
1233 _IO_default_read (fp, data, n)
1234      _IO_FILE* fp;
1235      void *data;
1236      _IO_ssize_t n;
1237 {
1238   return -1;
1239 }
1240
1241 _IO_ssize_t
1242 _IO_default_write (fp, data, n)
1243      _IO_FILE *fp;
1244      const void *data;
1245      _IO_ssize_t n;
1246 {
1247   return 0;
1248 }
1249
1250 int
1251 _IO_default_showmanyc (fp)
1252      _IO_FILE *fp;
1253 {
1254   return -1;
1255 }
1256
1257 void
1258 _IO_default_imbue (fp, locale)
1259      _IO_FILE *fp;
1260      void *locale;
1261 {
1262 }
1263
1264 _IO_ITER
1265 _IO_iter_begin()
1266 {
1267   return (_IO_ITER) _IO_list_all;
1268 }
1269 libc_hidden_def (_IO_iter_begin)
1270
1271 _IO_ITER
1272 _IO_iter_end()
1273 {
1274   return NULL;
1275 }
1276 libc_hidden_def (_IO_iter_end)
1277
1278 _IO_ITER
1279 _IO_iter_next(iter)
1280     _IO_ITER iter;
1281 {
1282   return iter->_chain;
1283 }
1284 libc_hidden_def (_IO_iter_next)
1285
1286 _IO_FILE *
1287 _IO_iter_file(iter)
1288     _IO_ITER iter;
1289 {
1290   return iter;
1291 }
1292 libc_hidden_def (_IO_iter_file)
1293
1294 void
1295 _IO_list_lock()
1296 {
1297 #ifdef _IO_MTSAFE_IO
1298   _IO_lock_lock (list_all_lock);
1299 #endif
1300 }
1301 libc_hidden_def (_IO_list_lock)
1302
1303 void
1304 _IO_list_unlock()
1305 {
1306 #ifdef _IO_MTSAFE_IO
1307   _IO_lock_unlock (list_all_lock);
1308 #endif
1309 }
1310 libc_hidden_def (_IO_list_unlock)
1311
1312 void
1313 _IO_list_resetlock()
1314 {
1315 #ifdef _IO_MTSAFE_IO
1316   _IO_lock_init (list_all_lock);
1317 #endif
1318 }
1319 libc_hidden_def (_IO_list_resetlock)
1320
1321
1322 #ifdef TODO
1323 #if defined(linux)
1324 #define IO_CLEANUP ;
1325 #endif
1326
1327 #ifdef IO_CLEANUP
1328   IO_CLEANUP
1329 #else
1330 struct __io_defs {
1331     __io_defs() { }
1332     ~__io_defs() { _IO_cleanup (); }
1333 };
1334 __io_defs io_defs__;
1335 #endif
1336
1337 #endif /* TODO */
1338
1339 #ifdef text_set_element
1340 text_set_element(__libc_atexit, _IO_cleanup);
1341 #endif