libio/wgenops.c

   1 /* Copyright (C) 1993-2015 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Written by Ulrich Drepper <drepper@cygnus.com>.
   4    Based on the single byte version by Per Bothner <bothner@cygnus.com>.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, see
  18    <http://www.gnu.org/licenses/>.
  19
  20    As a special exception, if you link the code in this file with
  21    files compiled with a GNU compiler to produce an executable,
  22    that does not cause the resulting executable to be covered by
  23    the GNU Lesser General Public License.  This exception does not
  24    however invalidate any other reasons why the executable file
  25    might be covered by the GNU Lesser General Public License.
  26    This exception applies to code released by its copyright holders
  27    in files containing the exception.  */
  28
  29 /* Generic or default I/O operations. */
  30
  31 #include "libioP.h"
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <wchar.h>
  35
  36
  37 #ifndef _LIBC
  38 # define __wmemcpy(dst, src, n) wmemcpy (dst, src, n)
  39 #endif
  40
  41
  42 static int save_for_wbackup (_IO_FILE *fp, wchar_t *end_p) __THROW
  43 #ifdef _LIBC
  44      internal_function
  45 #endif
  46      ;
  47
  48 /* Return minimum _pos markers
  49    Assumes the current get area is the main get area. */
  50 _IO_ssize_t
  51 _IO_least_wmarker (fp, end_p)
  52      _IO_FILE *fp;
  53      wchar_t *end_p;
  54 {
  55   _IO_ssize_t least_so_far = end_p - fp->_wide_data->_IO_read_base;
  56   struct _IO_marker *mark;
  57   for (mark = fp->_markers; mark != NULL; mark = mark->_next)
  58     if (mark->_pos < least_so_far)
  59       least_so_far = mark->_pos;
  60   return least_so_far;
  61 }
  62 libc_hidden_def (_IO_least_wmarker)
  63
  64 /* Switch current get area from backup buffer to (start of) main get area. */
  65 void
  66 _IO_switch_to_main_wget_area (fp)
  67      _IO_FILE *fp;
  68 {
  69   wchar_t *tmp;
  70   fp->_flags &= ~_IO_IN_BACKUP;
  71   /* Swap _IO_read_end and _IO_save_end. */
  72   tmp = fp->_wide_data->_IO_read_end;
  73   fp->_wide_data->_IO_read_end = fp->_wide_data->_IO_save_end;
  74   fp->_wide_data->_IO_save_end= tmp;
  75   /* Swap _IO_read_base and _IO_save_base. */
  76   tmp = fp->_wide_data->_IO_read_base;
  77   fp->_wide_data->_IO_read_base = fp->_wide_data->_IO_save_base;
  78   fp->_wide_data->_IO_save_base = tmp;
  79   /* Set _IO_read_ptr. */
  80   fp->_wide_data->_IO_read_ptr = fp->_wide_data->_IO_read_base;
  81 }
  82 libc_hidden_def (_IO_switch_to_main_wget_area)
  83
  84
  85 /* Switch current get area from main get area to (end of) backup area. */
  86 void
  87 _IO_switch_to_wbackup_area (fp)
  88      _IO_FILE *fp;
  89 {
  90   wchar_t *tmp;
  91   fp->_flags |= _IO_IN_BACKUP;
  92   /* Swap _IO_read_end and _IO_save_end. */
  93   tmp = fp->_wide_data->_IO_read_end;
  94   fp->_wide_data->_IO_read_end = fp->_wide_data->_IO_save_end;
  95   fp->_wide_data->_IO_save_end = tmp;
  96   /* Swap _IO_read_base and _IO_save_base. */
  97   tmp = fp->_wide_data->_IO_read_base;
  98   fp->_wide_data->_IO_read_base = fp->_wide_data->_IO_save_base;
  99   fp->_wide_data->_IO_save_base = tmp;
 100   /* Set _IO_read_ptr.  */
 101   fp->_wide_data->_IO_read_ptr = fp->_wide_data->_IO_read_end;
 102 }
 103 libc_hidden_def (_IO_switch_to_wbackup_area)
 104
 105
 106 void
 107 _IO_wsetb (f, b, eb, a)
 108      _IO_FILE *f;
 109      wchar_t *b;
 110      wchar_t *eb;
 111      int a;
 112 {
 113   if (f->_wide_data->_IO_buf_base && !(f->_flags2 & _IO_FLAGS2_USER_WBUF))
 114     free (f->_wide_data->_IO_buf_base);
 115   f->_wide_data->_IO_buf_base = b;
 116   f->_wide_data->_IO_buf_end = eb;
 117   if (a)
 118     f->_flags2 &= ~_IO_FLAGS2_USER_WBUF;
 119   else
 120     f->_flags2 |= _IO_FLAGS2_USER_WBUF;
 121 }
 122 libc_hidden_def (_IO_wsetb)
 123
 124
 125 wint_t
 126 _IO_wdefault_pbackfail (fp, c)
 127      _IO_FILE *fp;
 128      wint_t c;
 129 {
 130   if (fp->_wide_data->_IO_read_ptr > fp->_wide_data->_IO_read_base
 131       && !_IO_in_backup (fp)
 132       && (wint_t) fp->_IO_read_ptr[-1] == c)
 133     --fp->_IO_read_ptr;
 134   else
 135     {
 136       /* Need to handle a filebuf in write mode (switch to read mode). FIXME!*/
 137       if (!_IO_in_backup (fp))
 138         {
 139           /* We need to keep the invariant that the main get area
 140              logically follows the backup area.  */
 141           if (fp->_wide_data->_IO_read_ptr > fp->_wide_data->_IO_read_base
 142               && _IO_have_wbackup (fp))
 143             {
 144               if (save_for_wbackup (fp, fp->_wide_data->_IO_read_ptr))
 145                 return WEOF;
 146             }
 147           else if (!_IO_have_wbackup (fp))
 148             {
 149               /* No backup buffer: allocate one. */
 150               /* Use nshort buffer, if unused? (probably not)  FIXME */
 151               int backup_size = 128;
 152               wchar_t *bbuf = (wchar_t *) malloc (backup_size
 153                                                   * sizeof (wchar_t));
 154               if (bbuf == NULL)
 155                 return WEOF;
 156               fp->_wide_data->_IO_save_base = bbuf;
 157               fp->_wide_data->_IO_save_end = (fp->_wide_data->_IO_save_base
 158                                               + backup_size);
 159               fp->_wide_data->_IO_backup_base = fp->_wide_data->_IO_save_end;
 160             }
 161           fp->_wide_data->_IO_read_base = fp->_wide_data->_IO_read_ptr;
 162           _IO_switch_to_wbackup_area (fp);
 163         }
 164       else if (fp->_wide_data->_IO_read_ptr <= fp->_wide_data->_IO_read_base)
 165         {
 166           /* Increase size of existing backup buffer. */
 167           _IO_size_t new_size;
 168           _IO_size_t old_size = (fp->_wide_data->_IO_read_end
 169                                  - fp->_wide_data->_IO_read_base);
 170           wchar_t *new_buf;
 171           new_size = 2 * old_size;
 172           new_buf = (wchar_t *) malloc (new_size * sizeof (wchar_t));
 173           if (new_buf == NULL)
 174             return WEOF;
 175           __wmemcpy (new_buf + (new_size - old_size),
 176                      fp->_wide_data->_IO_read_base, old_size);
 177           free (fp->_wide_data->_IO_read_base);
 178           _IO_wsetg (fp, new_buf, new_buf + (new_size - old_size),
 179                      new_buf + new_size);
 180           fp->_wide_data->_IO_backup_base = fp->_wide_data->_IO_read_ptr;
 181         }
 182
 183       *--fp->_wide_data->_IO_read_ptr = c;
 184     }
 185   return c;
 186 }
 187 libc_hidden_def (_IO_wdefault_pbackfail)
 188
 189
 190 void
 191 _IO_wdefault_finish (fp, dummy)
 192      _IO_FILE *fp;
 193      int dummy;
 194 {
 195   struct _IO_marker *mark;
 196   if (fp->_wide_data->_IO_buf_base && !(fp->_flags2 & _IO_FLAGS2_USER_WBUF))
 197     {
 198       free (fp->_wide_data->_IO_buf_base);
 199       fp->_wide_data->_IO_buf_base = fp->_wide_data->_IO_buf_end = NULL;
 200     }
 201
 202   for (mark = fp->_markers; mark != NULL; mark = mark->_next)
 203     mark->_sbuf = NULL;
 204
 205   if (fp->_IO_save_base)
 206     {
 207       free (fp->_wide_data->_IO_save_base);
 208       fp->_IO_save_base = NULL;
 209     }
 210
 211 #ifdef _IO_MTSAFE_IO
 212   if (fp->_lock != NULL)
 213     _IO_lock_fini (*fp->_lock);
 214 #endif
 215
 216   _IO_un_link ((struct _IO_FILE_plus *) fp);
 217 }
 218 libc_hidden_def (_IO_wdefault_finish)
 219
 220
 221 wint_t
 222 _IO_wdefault_uflow (fp)
 223      _IO_FILE *fp;
 224 {
 225   wint_t wch;
 226   wch = _IO_UNDERFLOW (fp);
 227   if (wch == WEOF)
 228     return WEOF;
 229   return *fp->_wide_data->_IO_read_ptr++;
 230 }
 231 libc_hidden_def (_IO_wdefault_uflow)
 232
 233
 234 wint_t
 235 __woverflow (f, wch)
 236      _IO_FILE *f;
 237      wint_t wch;
 238 {
 239   if (f->_mode == 0)
 240     _IO_fwide (f, 1);
 241   return _IO_OVERFLOW (f, wch);
 242 }
 243 libc_hidden_def (__woverflow)
 244
 245
 246 wint_t
 247 __wuflow (fp)
 248      _IO_FILE *fp;
 249 {
 250   if (fp->_mode < 0 || (fp->_mode == 0 && _IO_fwide (fp, 1) != 1))
 251     return WEOF;
 252
 253   if (fp->_mode == 0)
 254     _IO_fwide (fp, 1);
 255   if (_IO_in_put_mode (fp))
 256     if (_IO_switch_to_wget_mode (fp) == EOF)
 257       return WEOF;
 258   if (fp->_wide_data->_IO_read_ptr < fp->_wide_data->_IO_read_end)
 259     return *fp->_wide_data->_IO_read_ptr++;
 260   if (_IO_in_backup (fp))
 261     {
 262       _IO_switch_to_main_wget_area (fp);
 263       if (fp->_wide_data->_IO_read_ptr < fp->_wide_data->_IO_read_end)
 264         return *fp->_wide_data->_IO_read_ptr++;
 265     }
 266   if (_IO_have_markers (fp))
 267     {
 268       if (save_for_wbackup (fp, fp->_wide_data->_IO_read_end))
 269         return WEOF;
 270     }
 271   else if (_IO_have_wbackup (fp))
 272     _IO_free_wbackup_area (fp);
 273   return _IO_UFLOW (fp);
 274 }
 275 libc_hidden_def (__wuflow)
 276
 277 wint_t
 278 __wunderflow (fp)
 279      _IO_FILE *fp;
 280 {
 281   if (fp->_mode < 0 || (fp->_mode == 0 && _IO_fwide (fp, 1) != 1))
 282     return WEOF;
 283
 284   if (fp->_mode == 0)
 285     _IO_fwide (fp, 1);
 286   if (_IO_in_put_mode (fp))
 287     if (_IO_switch_to_wget_mode (fp) == EOF)
 288       return WEOF;
 289   if (fp->_wide_data->_IO_read_ptr < fp->_wide_data->_IO_read_end)
 290     return *fp->_wide_data->_IO_read_ptr;
 291   if (_IO_in_backup (fp))
 292     {
 293       _IO_switch_to_main_wget_area (fp);
 294       if (fp->_wide_data->_IO_read_ptr < fp->_wide_data->_IO_read_end)
 295         return *fp->_wide_data->_IO_read_ptr;
 296     }
 297   if (_IO_have_markers (fp))
 298     {
 299       if (save_for_wbackup (fp, fp->_wide_data->_IO_read_end))
 300         return WEOF;
 301     }
 302   else if (_IO_have_backup (fp))
 303     _IO_free_wbackup_area (fp);
 304   return _IO_UNDERFLOW (fp);
 305 }
 306 libc_hidden_def (__wunderflow)
 307
 308
 309 _IO_size_t
 310 _IO_wdefault_xsputn (f, data, n)
 311      _IO_FILE *f;
 312      const void *data;
 313      _IO_size_t n;
 314 {
 315   const wchar_t *s = (const wchar_t *) data;
 316   _IO_size_t more = n;
 317   if (more <= 0)
 318     return 0;
 319   for (;;)
 320     {
 321       /* Space available. */
 322       _IO_ssize_t count = (f->_wide_data->_IO_write_end
 323                            - f->_wide_data->_IO_write_ptr);
 324       if (count > 0)
 325         {
 326           if ((_IO_size_t) count > more)
 327             count = more;
 328           if (count > 20)
 329             {
 330 #ifdef _LIBC
 331               f->_wide_data->_IO_write_ptr =
 332                 __wmempcpy (f->_wide_data->_IO_write_ptr, s, count);
 333 #else
 334               memcpy (f->_wide_data->_IO_write_ptr, s, count);
 335               f->_wide_data->_IO_write_ptr += count;
 336 #endif
 337               s += count;
 338             }
 339           else if (count <= 0)
 340             count = 0;
 341           else
 342             {
 343               wchar_t *p = f->_wide_data->_IO_write_ptr;
 344               _IO_ssize_t i;
 345               for (i = count; --i >= 0; )
 346                 *p++ = *s++;
 347               f->_wide_data->_IO_write_ptr = p;
 348             }
 349           more -= count;
 350         }
 351       if (more == 0 || __woverflow (f, *s++) == WEOF)
 352         break;
 353       more--;
 354     }
 355   return n - more;
 356 }
 357 libc_hidden_def (_IO_wdefault_xsputn)
 358
 359
 360 _IO_size_t
 361 _IO_wdefault_xsgetn (fp, data, n)
 362      _IO_FILE *fp;
 363      void *data;
 364      _IO_size_t n;
 365 {
 366   _IO_size_t more = n;
 367   wchar_t *s = (wchar_t*) data;
 368   for (;;)
 369     {
 370       /* Data available. */
 371       _IO_ssize_t count = (fp->_wide_data->_IO_read_end
 372                            - fp->_wide_data->_IO_read_ptr);
 373       if (count > 0)
 374         {
 375           if ((_IO_size_t) count > more)
 376             count = more;
 377           if (count > 20)
 378             {
 379 #ifdef _LIBC
 380               s = __wmempcpy (s, fp->_wide_data->_IO_read_ptr, count);
 381 #else
 382               memcpy (s, fp->_wide_data->_IO_read_ptr, count);
 383               s += count;
 384 #endif
 385               fp->_wide_data->_IO_read_ptr += count;
 386             }
 387           else if (count <= 0)
 388             count = 0;
 389           else
 390             {
 391               wchar_t *p = fp->_wide_data->_IO_read_ptr;
 392               int i = (int) count;
 393               while (--i >= 0)
 394                 *s++ = *p++;
 395               fp->_wide_data->_IO_read_ptr = p;
 396             }
 397             more -= count;
 398         }
 399       if (more == 0 || __wunderflow (fp) == WEOF)
 400         break;
 401     }
 402   return n - more;
 403 }
 404 libc_hidden_def (_IO_wdefault_xsgetn)
 405
 406
 407 void
 408 _IO_wdoallocbuf (fp)
 409      _IO_FILE *fp;
 410 {
 411   if (fp->_wide_data->_IO_buf_base)
 412     return;
 413   if (!(fp->_flags & _IO_UNBUFFERED))
 414     if ((wint_t)_IO_WDOALLOCATE (fp) != WEOF)
 415       return;
 416   _IO_wsetb (fp, fp->_wide_data->_shortbuf,
 417                      fp->_wide_data->_shortbuf + 1, 0);
 418 }
 419 libc_hidden_def (_IO_wdoallocbuf)
 420
 421
 422 int
 423 _IO_wdefault_doallocate (fp)
 424      _IO_FILE *fp;
 425 {
 426   wchar_t *buf;
 427
 428   buf = malloc (_IO_BUFSIZ);
 429   if (__glibc_unlikely (buf == NULL))
 430     return EOF;
 431   _IO_wsetb (fp, buf, buf + _IO_BUFSIZ, 1);
 432   return 1;
 433 }
 434 libc_hidden_def (_IO_wdefault_doallocate)
 435
 436
 437 int
 438 _IO_switch_to_wget_mode (fp)
 439      _IO_FILE *fp;
 440 {
 441   if (fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_write_base)
 442     if ((wint_t)_IO_WOVERFLOW (fp, WEOF) == WEOF)
 443       return EOF;
 444   if (_IO_in_backup (fp))
 445     fp->_wide_data->_IO_read_base = fp->_wide_data->_IO_backup_base;
 446   else
 447     {
 448       fp->_wide_data->_IO_read_base = fp->_wide_data->_IO_buf_base;
 449       if (fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_read_end)
 450         fp->_wide_data->_IO_read_end = fp->_wide_data->_IO_write_ptr;
 451     }
 452   fp->_wide_data->_IO_read_ptr = fp->_wide_data->_IO_write_ptr;
 453
 454   fp->_wide_data->_IO_write_base = fp->_wide_data->_IO_write_ptr
 455     = fp->_wide_data->_IO_write_end = fp->_wide_data->_IO_read_ptr;
 456
 457   fp->_flags &= ~_IO_CURRENTLY_PUTTING;
 458   return 0;
 459 }
 460 libc_hidden_def (_IO_switch_to_wget_mode)
 461
 462 void
 463 _IO_free_wbackup_area (fp)
 464      _IO_FILE *fp;
 465 {
 466   if (_IO_in_backup (fp))
 467     _IO_switch_to_main_wget_area (fp);  /* Just in case. */
 468   free (fp->_wide_data->_IO_save_base);
 469   fp->_wide_data->_IO_save_base = NULL;
 470   fp->_wide_data->_IO_save_end = NULL;
 471   fp->_wide_data->_IO_backup_base = NULL;
 472 }
 473 libc_hidden_def (_IO_free_wbackup_area)
 474
 475 #if 0
 476 int
 477 _IO_switch_to_wput_mode (fp)
 478      _IO_FILE *fp;
 479 {
 480   fp->_wide_data->_IO_write_base = fp->_wide_data->_IO_read_ptr;
 481   fp->_wide_data->_IO_write_ptr = fp->_wide_data->_IO_read_ptr;
 482   /* Following is wrong if line- or un-buffered? */
 483   fp->_wide_data->_IO_write_end = (fp->_flags & _IO_IN_BACKUP
 484                                    ? fp->_wide_data->_IO_read_end
 485                                    : fp->_wide_data->_IO_buf_end);
 486
 487   fp->_wide_data->_IO_read_ptr = fp->_wide_data->_IO_read_end;
 488   fp->_wide_data->_IO_read_base = fp->_wide_data->_IO_read_end;
 489
 490   fp->_flags |= _IO_CURRENTLY_PUTTING;
 491   return 0;
 492 }
 493 #endif
 494
 495
 496 static int
 497 #ifdef _LIBC
 498 internal_function
 499 #endif
 500 save_for_wbackup (fp, end_p)
 501      _IO_FILE *fp;
 502      wchar_t *end_p;
 503 {
 504   /* Append [_IO_read_base..end_p] to backup area. */
 505   _IO_ssize_t least_mark = _IO_least_wmarker (fp, end_p);
 506   /* needed_size is how much space we need in the backup area. */
 507   _IO_size_t needed_size = ((end_p - fp->_wide_data->_IO_read_base)
 508                             - least_mark);
 509   /* FIXME: Dubious arithmetic if pointers are NULL */
 510   _IO_size_t current_Bsize = (fp->_wide_data->_IO_save_end
 511                               - fp->_wide_data->_IO_save_base);
 512   _IO_size_t avail; /* Extra space available for future expansion. */
 513   _IO_ssize_t delta;
 514   struct _IO_marker *mark;
 515   if (needed_size > current_Bsize)
 516     {
 517       wchar_t *new_buffer;
 518       avail = 100;
 519       new_buffer = (wchar_t *) malloc ((avail + needed_size)
 520                                        * sizeof (wchar_t));
 521       if (new_buffer == NULL)
 522         return EOF;             /* FIXME */
 523       if (least_mark < 0)
 524         {
 525 #ifdef _LIBC
 526           __wmempcpy (__wmempcpy (new_buffer + avail,
 527                                   fp->_wide_data->_IO_save_end + least_mark,
 528                                   -least_mark),
 529                       fp->_wide_data->_IO_read_base,
 530                       end_p - fp->_wide_data->_IO_read_base);
 531 #else
 532           memcpy (new_buffer + avail,
 533                   fp->_wide_data->_IO_save_end + least_mark,
 534                   -least_mark * sizeof (wchar_t));
 535           memcpy (new_buffer + avail - least_mark,
 536                   fp->_wide_data->_IO_read_base,
 537                   (end_p - fp->_wide_data->_IO_read_base) * sizeof (wchar_t));
 538 #endif
 539         }
 540       else
 541         {
 542 #ifdef _LIBC
 543           __wmemcpy (new_buffer + avail,
 544                      fp->_wide_data->_IO_read_base + least_mark,
 545                      needed_size);
 546 #else
 547           memcpy (new_buffer + avail,
 548                   fp->_wide_data->_IO_read_base + least_mark,
 549                   needed_size * sizeof (wchar_t));
 550 #endif
 551         }
 552       free (fp->_wide_data->_IO_save_base);
 553       fp->_wide_data->_IO_save_base = new_buffer;
 554       fp->_wide_data->_IO_save_end = new_buffer + avail + needed_size;
 555     }
 556   else
 557     {
 558       avail = current_Bsize - needed_size;
 559       if (least_mark < 0)
 560         {
 561 #ifdef _LIBC
 562           __wmemmove (fp->_wide_data->_IO_save_base + avail,
 563                       fp->_wide_data->_IO_save_end + least_mark,
 564                       -least_mark);
 565           __wmemcpy (fp->_wide_data->_IO_save_base + avail - least_mark,
 566                      fp->_wide_data->_IO_read_base,
 567                      end_p - fp->_wide_data->_IO_read_base);
 568 #else
 569           memmove (fp->_wide_data->_IO_save_base + avail,
 570                    fp->_wide_data->_IO_save_end + least_mark,
 571                    -least_mark * sizeof (wchar_t));
 572           memcpy (fp->_wide_data->_IO_save_base + avail - least_mark,
 573                   fp->_wide_data->_IO_read_base,
 574                   (end_p - fp->_wide_data->_IO_read_base) * sizeof (wchar_t));
 575 #endif
 576         }
 577       else if (needed_size > 0)
 578 #ifdef _LIBC
 579         __wmemcpy (fp->_wide_data->_IO_save_base + avail,
 580                    fp->_wide_data->_IO_read_base + least_mark,
 581                    needed_size);
 582 #else
 583         memcpy (fp->_wide_data->_IO_save_base + avail,
 584                 fp->_wide_data->_IO_read_base + least_mark,
 585                 needed_size * sizeof (wchar_t));
 586 #endif
 587     }
 588   fp->_wide_data->_IO_backup_base = fp->_wide_data->_IO_save_base + avail;
 589   /* Adjust all the streammarkers. */
 590   delta = end_p - fp->_wide_data->_IO_read_base;
 591   for (mark = fp->_markers; mark != NULL; mark = mark->_next)
 592     mark->_pos -= delta;
 593   return 0;
 594 }
 595
 596 wint_t
 597 _IO_sputbackwc (fp, c)
 598      _IO_FILE *fp;
 599      wint_t c;
 600 {
 601   wint_t result;
 602
 603   if (fp->_wide_data->_IO_read_ptr > fp->_wide_data->_IO_read_base
 604       && (wchar_t)fp->_wide_data->_IO_read_ptr[-1] == (wchar_t) c)
 605     {
 606       fp->_wide_data->_IO_read_ptr--;
 607       result = c;
 608     }
 609   else
 610     result = _IO_PBACKFAIL (fp, c);
 611
 612   if (result != WEOF)
 613     fp->_flags &= ~_IO_EOF_SEEN;
 614
 615   return result;
 616 }
 617 libc_hidden_def (_IO_sputbackwc)
 618
 619 wint_t
 620 _IO_sungetwc (fp)
 621      _IO_FILE *fp;
 622 {
 623   wint_t result;
 624
 625   if (fp->_wide_data->_IO_read_ptr > fp->_wide_data->_IO_read_base)
 626     {
 627       fp->_wide_data->_IO_read_ptr--;
 628       result = *fp->_wide_data->_IO_read_ptr;
 629     }
 630   else
 631     result = _IO_PBACKFAIL (fp, EOF);
 632
 633   if (result != WEOF)
 634     fp->_flags &= ~_IO_EOF_SEEN;
 635
 636   return result;
 637 }
 638
 639
 640 unsigned
 641 _IO_adjust_wcolumn (start, line, count)
 642      unsigned start;
 643      const wchar_t *line;
 644      int count;
 645 {
 646   const wchar_t *ptr = line + count;
 647   while (ptr > line)
 648     if (*--ptr == L'\n')
 649       return line + count - ptr - 1;
 650   return start + count;
 651 }
 652
 653 void
 654 _IO_init_wmarker (marker, fp)
 655      struct _IO_marker *marker;
 656      _IO_FILE *fp;
 657 {
 658   marker->_sbuf = fp;
 659   if (_IO_in_put_mode (fp))
 660     _IO_switch_to_wget_mode (fp);
 661   if (_IO_in_backup (fp))
 662     marker->_pos = fp->_wide_data->_IO_read_ptr - fp->_wide_data->_IO_read_end;
 663   else
 664     marker->_pos = (fp->_wide_data->_IO_read_ptr
 665                     - fp->_wide_data->_IO_read_base);
 666
 667   /* Should perhaps sort the chain? */
 668   marker->_next = fp->_markers;
 669   fp->_markers = marker;
 670 }
 671
 672 #define BAD_DELTA EOF
 673
 674 /* Return difference between MARK and current position of MARK's stream. */
 675 int
 676 _IO_wmarker_delta (mark)
 677      struct _IO_marker *mark;
 678 {
 679   int cur_pos;
 680   if (mark->_sbuf == NULL)
 681     return BAD_DELTA;
 682   if (_IO_in_backup (mark->_sbuf))
 683     cur_pos = (mark->_sbuf->_wide_data->_IO_read_ptr
 684                - mark->_sbuf->_wide_data->_IO_read_end);
 685   else
 686     cur_pos = (mark->_sbuf->_wide_data->_IO_read_ptr
 687                - mark->_sbuf->_wide_data->_IO_read_base);
 688   return mark->_pos - cur_pos;
 689 }
 690
 691 int
 692 _IO_seekwmark (fp, mark, delta)
 693      _IO_FILE *fp;
 694      struct _IO_marker *mark;
 695      int delta;
 696 {
 697   if (mark->_sbuf != fp)
 698     return EOF;
 699  if (mark->_pos >= 0)
 700     {
 701       if (_IO_in_backup (fp))
 702         _IO_switch_to_main_wget_area (fp);
 703       fp->_wide_data->_IO_read_ptr = (fp->_wide_data->_IO_read_base
 704                                       + mark->_pos);
 705     }
 706   else
 707     {
 708       if (!_IO_in_backup (fp))
 709         _IO_switch_to_wbackup_area (fp);
 710       fp->_wide_data->_IO_read_ptr = fp->_wide_data->_IO_read_end + mark->_pos;
 711     }
 712   return 0;
 713 }
 714
 715 void
 716 _IO_unsave_wmarkers (fp)
 717      _IO_FILE *fp;
 718 {
 719   struct _IO_marker *mark = fp->_markers;
 720   if (mark)
 721     {
 722 #ifdef TODO
 723       streampos offset = seekoff (0, ios::cur, ios::in);
 724       if (offset != EOF)
 725         {
 726           offset += eGptr () - Gbase ();
 727           for ( ; mark != NULL; mark = mark->_next)
 728             mark->set_streampos (mark->_pos + offset);
 729         }
 730     else
 731       {
 732         for ( ; mark != NULL; mark = mark->_next)
 733           mark->set_streampos (EOF);
 734       }
 735 #endif
 736       fp->_markers = 0;
 737     }
 738
 739   if (_IO_have_backup (fp))
 740     _IO_free_wbackup_area (fp);
 741 }