src/system/libroot/posix/glibc/libio/wgenops.c

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