libio/wgenops.c

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