libio/wgenops.c

   1 /* Copyright (C) 1993-2018 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 static int save_for_wbackup (FILE *fp, wchar_t *end_p) __THROW;
  38
  39 /* Return minimum _pos markers
  40    Assumes the current get area is the main get area. */
  41 ssize_t
  42 _IO_least_wmarker (FILE *fp, wchar_t *end_p)
  43 {
  44   ssize_t least_so_far = end_p - fp->_wide_data->_IO_read_base;
  45   struct _IO_marker *mark;
  46   for (mark = fp->_markers; mark != NULL; mark = mark->_next)
  47     if (mark->_pos < least_so_far)
  48       least_so_far = mark->_pos;
  49   return least_so_far;
  50 }
  51 libc_hidden_def (_IO_least_wmarker)
  52
  53 /* Switch current get area from backup buffer to (start of) main get area. */
  54 void
  55 _IO_switch_to_main_wget_area (FILE *fp)
  56 {
  57   wchar_t *tmp;
  58   fp->_flags &= ~_IO_IN_BACKUP;
  59   /* Swap _IO_read_end and _IO_save_end. */
  60   tmp = fp->_wide_data->_IO_read_end;
  61   fp->_wide_data->_IO_read_end = fp->_wide_data->_IO_save_end;
  62   fp->_wide_data->_IO_save_end= tmp;
  63   /* Swap _IO_read_base and _IO_save_base. */
  64   tmp = fp->_wide_data->_IO_read_base;
  65   fp->_wide_data->_IO_read_base = fp->_wide_data->_IO_save_base;
  66   fp->_wide_data->_IO_save_base = tmp;
  67   /* Set _IO_read_ptr. */
  68   fp->_wide_data->_IO_read_ptr = fp->_wide_data->_IO_read_base;
  69 }
  70 libc_hidden_def (_IO_switch_to_main_wget_area)
  71
  72
  73 /* Switch current get area from main get area to (end of) backup area. */
  74 void
  75 _IO_switch_to_wbackup_area (FILE *fp)
  76 {
  77   wchar_t *tmp;
  78   fp->_flags |= _IO_IN_BACKUP;
  79   /* Swap _IO_read_end and _IO_save_end. */
  80   tmp = fp->_wide_data->_IO_read_end;
  81   fp->_wide_data->_IO_read_end = fp->_wide_data->_IO_save_end;
  82   fp->_wide_data->_IO_save_end = tmp;
  83   /* Swap _IO_read_base and _IO_save_base. */
  84   tmp = fp->_wide_data->_IO_read_base;
  85   fp->_wide_data->_IO_read_base = fp->_wide_data->_IO_save_base;
  86   fp->_wide_data->_IO_save_base = tmp;
  87   /* Set _IO_read_ptr.  */
  88   fp->_wide_data->_IO_read_ptr = fp->_wide_data->_IO_read_end;
  89 }
  90 libc_hidden_def (_IO_switch_to_wbackup_area)
  91
  92
  93 void
  94 _IO_wsetb (FILE *f, wchar_t *b, wchar_t *eb, int a)
  95 {
  96   if (f->_wide_data->_IO_buf_base && !(f->_flags2 & _IO_FLAGS2_USER_WBUF))
  97     free (f->_wide_data->_IO_buf_base);
  98   f->_wide_data->_IO_buf_base = b;
  99   f->_wide_data->_IO_buf_end = eb;
 100   if (a)
 101     f->_flags2 &= ~_IO_FLAGS2_USER_WBUF;
 102   else
 103     f->_flags2 |= _IO_FLAGS2_USER_WBUF;
 104 }
 105 libc_hidden_def (_IO_wsetb)
 106
 107
 108 wint_t
 109 _IO_wdefault_pbackfail (FILE *fp, wint_t c)
 110 {
 111   if (fp->_wide_data->_IO_read_ptr > fp->_wide_data->_IO_read_base
 112       && !_IO_in_backup (fp)
 113       && (wint_t) fp->_IO_read_ptr[-1] == c)
 114     --fp->_IO_read_ptr;
 115   else
 116     {
 117       /* Need to handle a filebuf in write mode (switch to read mode). FIXME!*/
 118       if (!_IO_in_backup (fp))
 119         {
 120           /* We need to keep the invariant that the main get area
 121              logically follows the backup area.  */
 122           if (fp->_wide_data->_IO_read_ptr > fp->_wide_data->_IO_read_base
 123               && _IO_have_wbackup (fp))
 124             {
 125               if (save_for_wbackup (fp, fp->_wide_data->_IO_read_ptr))
 126                 return WEOF;
 127             }
 128           else if (!_IO_have_wbackup (fp))
 129             {
 130               /* No backup buffer: allocate one. */
 131               /* Use nshort buffer, if unused? (probably not)  FIXME */
 132               int backup_size = 128;
 133               wchar_t *bbuf = (wchar_t *) malloc (backup_size
 134                                                   * sizeof (wchar_t));
 135               if (bbuf == NULL)
 136                 return WEOF;
 137               fp->_wide_data->_IO_save_base = bbuf;
 138               fp->_wide_data->_IO_save_end = (fp->_wide_data->_IO_save_base
 139                                               + backup_size);
 140               fp->_wide_data->_IO_backup_base = fp->_wide_data->_IO_save_end;
 141             }
 142           fp->_wide_data->_IO_read_base = fp->_wide_data->_IO_read_ptr;
 143           _IO_switch_to_wbackup_area (fp);
 144         }
 145       else if (fp->_wide_data->_IO_read_ptr <= fp->_wide_data->_IO_read_base)
 146         {
 147           /* Increase size of existing backup buffer. */
 148           size_t new_size;
 149           size_t old_size = (fp->_wide_data->_IO_read_end
 150                              - fp->_wide_data->_IO_read_base);
 151           wchar_t *new_buf;
 152           new_size = 2 * old_size;
 153           new_buf = (wchar_t *) malloc (new_size * sizeof (wchar_t));
 154           if (new_buf == NULL)
 155             return WEOF;
 156           __wmemcpy (new_buf + (new_size - old_size),
 157                      fp->_wide_data->_IO_read_base, old_size);
 158           free (fp->_wide_data->_IO_read_base);
 159           _IO_wsetg (fp, new_buf, new_buf + (new_size - old_size),
 160                      new_buf + new_size);
 161           fp->_wide_data->_IO_backup_base = fp->_wide_data->_IO_read_ptr;
 162         }
 163
 164       *--fp->_wide_data->_IO_read_ptr = c;
 165     }
 166   return c;
 167 }
 168 libc_hidden_def (_IO_wdefault_pbackfail)
 169
 170
 171 void
 172 _IO_wdefault_finish (FILE *fp, int dummy)
 173 {
 174   struct _IO_marker *mark;
 175   if (fp->_wide_data->_IO_buf_base && !(fp->_flags2 & _IO_FLAGS2_USER_WBUF))
 176     {
 177       free (fp->_wide_data->_IO_buf_base);
 178       fp->_wide_data->_IO_buf_base = fp->_wide_data->_IO_buf_end = NULL;
 179     }
 180
 181   for (mark = fp->_markers; mark != NULL; mark = mark->_next)
 182     mark->_sbuf = NULL;
 183
 184   if (fp->_IO_save_base)
 185     {
 186       free (fp->_wide_data->_IO_save_base);
 187       fp->_IO_save_base = NULL;
 188     }
 189
 190 #ifdef _IO_MTSAFE_IO
 191   if (fp->_lock != NULL)
 192     _IO_lock_fini (*fp->_lock);
 193 #endif
 194
 195   _IO_un_link ((struct _IO_FILE_plus *) fp);
 196 }
 197 libc_hidden_def (_IO_wdefault_finish)
 198
 199
 200 wint_t
 201 _IO_wdefault_uflow (FILE *fp)
 202 {
 203   wint_t wch;
 204   wch = _IO_UNDERFLOW (fp);
 205   if (wch == WEOF)
 206     return WEOF;
 207   return *fp->_wide_data->_IO_read_ptr++;
 208 }
 209 libc_hidden_def (_IO_wdefault_uflow)
 210
 211
 212 wint_t
 213 __woverflow (FILE *f, wint_t wch)
 214 {
 215   if (f->_mode == 0)
 216     _IO_fwide (f, 1);
 217   return _IO_OVERFLOW (f, wch);
 218 }
 219 libc_hidden_def (__woverflow)
 220
 221
 222 wint_t
 223 __wuflow (FILE *fp)
 224 {
 225   if (fp->_mode < 0 || (fp->_mode == 0 && _IO_fwide (fp, 1) != 1))
 226     return WEOF;
 227
 228   if (fp->_mode == 0)
 229     _IO_fwide (fp, 1);
 230   if (_IO_in_put_mode (fp))
 231     if (_IO_switch_to_wget_mode (fp) == EOF)
 232       return WEOF;
 233   if (fp->_wide_data->_IO_read_ptr < fp->_wide_data->_IO_read_end)
 234     return *fp->_wide_data->_IO_read_ptr++;
 235   if (_IO_in_backup (fp))
 236     {
 237       _IO_switch_to_main_wget_area (fp);
 238       if (fp->_wide_data->_IO_read_ptr < fp->_wide_data->_IO_read_end)
 239         return *fp->_wide_data->_IO_read_ptr++;
 240     }
 241   if (_IO_have_markers (fp))
 242     {
 243       if (save_for_wbackup (fp, fp->_wide_data->_IO_read_end))
 244         return WEOF;
 245     }
 246   else if (_IO_have_wbackup (fp))
 247     _IO_free_wbackup_area (fp);
 248   return _IO_UFLOW (fp);
 249 }
 250 libc_hidden_def (__wuflow)
 251
 252 wint_t
 253 __wunderflow (FILE *fp)
 254 {
 255   if (fp->_mode < 0 || (fp->_mode == 0 && _IO_fwide (fp, 1) != 1))
 256     return WEOF;
 257
 258   if (fp->_mode == 0)
 259     _IO_fwide (fp, 1);
 260   if (_IO_in_put_mode (fp))
 261     if (_IO_switch_to_wget_mode (fp) == EOF)
 262       return WEOF;
 263   if (fp->_wide_data->_IO_read_ptr < fp->_wide_data->_IO_read_end)
 264     return *fp->_wide_data->_IO_read_ptr;
 265   if (_IO_in_backup (fp))
 266     {
 267       _IO_switch_to_main_wget_area (fp);
 268       if (fp->_wide_data->_IO_read_ptr < fp->_wide_data->_IO_read_end)
 269         return *fp->_wide_data->_IO_read_ptr;
 270     }
 271   if (_IO_have_markers (fp))
 272     {
 273       if (save_for_wbackup (fp, fp->_wide_data->_IO_read_end))
 274         return WEOF;
 275     }
 276   else if (_IO_have_backup (fp))
 277     _IO_free_wbackup_area (fp);
 278   return _IO_UNDERFLOW (fp);
 279 }
 280 libc_hidden_def (__wunderflow)
 281
 282
 283 size_t
 284 _IO_wdefault_xsputn (FILE *f, const void *data, size_t n)
 285 {
 286   const wchar_t *s = (const wchar_t *) data;
 287   size_t more = n;
 288   if (more <= 0)
 289     return 0;
 290   for (;;)
 291     {
 292       /* Space available. */
 293       ssize_t count = (f->_wide_data->_IO_write_end
 294                        - f->_wide_data->_IO_write_ptr);
 295       if (count > 0)
 296         {
 297           if ((size_t) count > more)
 298             count = more;
 299           if (count > 20)
 300             {
 301               f->_wide_data->_IO_write_ptr =
 302                 __wmempcpy (f->_wide_data->_IO_write_ptr, s, count);
 303               s += count;
 304             }
 305           else if (count <= 0)
 306             count = 0;
 307           else
 308             {
 309               wchar_t *p = f->_wide_data->_IO_write_ptr;
 310               ssize_t i;
 311               for (i = count; --i >= 0; )
 312                 *p++ = *s++;
 313               f->_wide_data->_IO_write_ptr = p;
 314             }
 315           more -= count;
 316         }
 317       if (more == 0 || __woverflow (f, *s++) == WEOF)
 318         break;
 319       more--;
 320     }
 321   return n - more;
 322 }
 323 libc_hidden_def (_IO_wdefault_xsputn)
 324
 325
 326 size_t
 327 _IO_wdefault_xsgetn (FILE *fp, void *data, size_t n)
 328 {
 329   size_t more = n;
 330   wchar_t *s = (wchar_t*) data;
 331   for (;;)
 332     {
 333       /* Data available. */
 334       ssize_t count = (fp->_wide_data->_IO_read_end
 335                        - fp->_wide_data->_IO_read_ptr);
 336       if (count > 0)
 337         {
 338           if ((size_t) count > more)
 339             count = more;
 340           if (count > 20)
 341             {
 342               s = __wmempcpy (s, fp->_wide_data->_IO_read_ptr, count);
 343               fp->_wide_data->_IO_read_ptr += count;
 344             }
 345           else if (count <= 0)
 346             count = 0;
 347           else
 348             {
 349               wchar_t *p = fp->_wide_data->_IO_read_ptr;
 350               int i = (int) count;
 351               while (--i >= 0)
 352                 *s++ = *p++;
 353               fp->_wide_data->_IO_read_ptr = p;
 354             }
 355             more -= count;
 356         }
 357       if (more == 0 || __wunderflow (fp) == WEOF)
 358         break;
 359     }
 360   return n - more;
 361 }
 362 libc_hidden_def (_IO_wdefault_xsgetn)
 363
 364
 365 void
 366 _IO_wdoallocbuf (FILE *fp)
 367 {
 368   if (fp->_wide_data->_IO_buf_base)
 369     return;
 370   if (!(fp->_flags & _IO_UNBUFFERED))
 371     if ((wint_t)_IO_WDOALLOCATE (fp) != WEOF)
 372       return;
 373   _IO_wsetb (fp, fp->_wide_data->_shortbuf,
 374                      fp->_wide_data->_shortbuf + 1, 0);
 375 }
 376 libc_hidden_def (_IO_wdoallocbuf)
 377
 378
 379 int
 380 _IO_wdefault_doallocate (FILE *fp)
 381 {
 382   wchar_t *buf;
 383
 384   buf = malloc (BUFSIZ);
 385   if (__glibc_unlikely (buf == NULL))
 386     return EOF;
 387   _IO_wsetb (fp, buf, buf + BUFSIZ, 1);
 388   return 1;
 389 }
 390 libc_hidden_def (_IO_wdefault_doallocate)
 391
 392
 393 int
 394 _IO_switch_to_wget_mode (FILE *fp)
 395 {
 396   if (fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_write_base)
 397     if ((wint_t)_IO_WOVERFLOW (fp, WEOF) == WEOF)
 398       return EOF;
 399   if (_IO_in_backup (fp))
 400     fp->_wide_data->_IO_read_base = fp->_wide_data->_IO_backup_base;
 401   else
 402     {
 403       fp->_wide_data->_IO_read_base = fp->_wide_data->_IO_buf_base;
 404       if (fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_read_end)
 405         fp->_wide_data->_IO_read_end = fp->_wide_data->_IO_write_ptr;
 406     }
 407   fp->_wide_data->_IO_read_ptr = fp->_wide_data->_IO_write_ptr;
 408
 409   fp->_wide_data->_IO_write_base = fp->_wide_data->_IO_write_ptr
 410     = fp->_wide_data->_IO_write_end = fp->_wide_data->_IO_read_ptr;
 411
 412   fp->_flags &= ~_IO_CURRENTLY_PUTTING;
 413   return 0;
 414 }
 415 libc_hidden_def (_IO_switch_to_wget_mode)
 416
 417 void
 418 _IO_free_wbackup_area (FILE *fp)
 419 {
 420   if (_IO_in_backup (fp))
 421     _IO_switch_to_main_wget_area (fp);  /* Just in case. */
 422   free (fp->_wide_data->_IO_save_base);
 423   fp->_wide_data->_IO_save_base = NULL;
 424   fp->_wide_data->_IO_save_end = NULL;
 425   fp->_wide_data->_IO_backup_base = NULL;
 426 }
 427 libc_hidden_def (_IO_free_wbackup_area)
 428
 429 static int
 430 save_for_wbackup (FILE *fp, wchar_t *end_p)
 431 {
 432   /* Append [_IO_read_base..end_p] to backup area. */
 433   ssize_t least_mark = _IO_least_wmarker (fp, end_p);
 434   /* needed_size is how much space we need in the backup area. */
 435   size_t needed_size = ((end_p - fp->_wide_data->_IO_read_base)
 436                         - least_mark);
 437   /* FIXME: Dubious arithmetic if pointers are NULL */
 438   size_t current_Bsize = (fp->_wide_data->_IO_save_end
 439                           - fp->_wide_data->_IO_save_base);
 440   size_t avail; /* Extra space available for future expansion. */
 441   ssize_t delta;
 442   struct _IO_marker *mark;
 443   if (needed_size > current_Bsize)
 444     {
 445       wchar_t *new_buffer;
 446       avail = 100;
 447       new_buffer = (wchar_t *) malloc ((avail + needed_size)
 448                                        * sizeof (wchar_t));
 449       if (new_buffer == NULL)
 450         return EOF;             /* FIXME */
 451       if (least_mark < 0)
 452         {
 453           __wmempcpy (__wmempcpy (new_buffer + avail,
 454                                   fp->_wide_data->_IO_save_end + least_mark,
 455                                   -least_mark),
 456                       fp->_wide_data->_IO_read_base,
 457                       end_p - fp->_wide_data->_IO_read_base);
 458         }
 459       else
 460         {
 461           __wmemcpy (new_buffer + avail,
 462                      fp->_wide_data->_IO_read_base + least_mark,
 463                      needed_size);
 464         }
 465       free (fp->_wide_data->_IO_save_base);
 466       fp->_wide_data->_IO_save_base = new_buffer;
 467       fp->_wide_data->_IO_save_end = new_buffer + avail + needed_size;
 468     }
 469   else
 470     {
 471       avail = current_Bsize - needed_size;
 472       if (least_mark < 0)
 473         {
 474           __wmemmove (fp->_wide_data->_IO_save_base + avail,
 475                       fp->_wide_data->_IO_save_end + least_mark,
 476                       -least_mark);
 477           __wmemcpy (fp->_wide_data->_IO_save_base + avail - least_mark,
 478                      fp->_wide_data->_IO_read_base,
 479                      end_p - fp->_wide_data->_IO_read_base);
 480         }
 481       else if (needed_size > 0)
 482         __wmemcpy (fp->_wide_data->_IO_save_base + avail,
 483                    fp->_wide_data->_IO_read_base + least_mark,
 484                    needed_size);
 485     }
 486   fp->_wide_data->_IO_backup_base = fp->_wide_data->_IO_save_base + avail;
 487   /* Adjust all the streammarkers. */
 488   delta = end_p - fp->_wide_data->_IO_read_base;
 489   for (mark = fp->_markers; mark != NULL; mark = mark->_next)
 490     mark->_pos -= delta;
 491   return 0;
 492 }
 493
 494 wint_t
 495 _IO_sputbackwc (FILE *fp, wint_t c)
 496 {
 497   wint_t result;
 498
 499   if (fp->_wide_data->_IO_read_ptr > fp->_wide_data->_IO_read_base
 500       && (wchar_t)fp->_wide_data->_IO_read_ptr[-1] == (wchar_t) c)
 501     {
 502       fp->_wide_data->_IO_read_ptr--;
 503       result = c;
 504     }
 505   else
 506     result = _IO_PBACKFAIL (fp, c);
 507
 508   if (result != WEOF)
 509     fp->_flags &= ~_IO_EOF_SEEN;
 510
 511   return result;
 512 }
 513 libc_hidden_def (_IO_sputbackwc)
 514
 515 wint_t
 516 _IO_sungetwc (FILE *fp)
 517 {
 518   wint_t result;
 519
 520   if (fp->_wide_data->_IO_read_ptr > fp->_wide_data->_IO_read_base)
 521     {
 522       fp->_wide_data->_IO_read_ptr--;
 523       result = *fp->_wide_data->_IO_read_ptr;
 524     }
 525   else
 526     result = _IO_PBACKFAIL (fp, EOF);
 527
 528   if (result != WEOF)
 529     fp->_flags &= ~_IO_EOF_SEEN;
 530
 531   return result;
 532 }
 533
 534
 535 unsigned
 536 _IO_adjust_wcolumn (unsigned start, const wchar_t *line, int count)
 537 {
 538   const wchar_t *ptr = line + count;
 539   while (ptr > line)
 540     if (*--ptr == L'\n')
 541       return line + count - ptr - 1;
 542   return start + count;
 543 }
 544
 545 void
 546 _IO_init_wmarker (struct _IO_marker *marker, FILE *fp)
 547 {
 548   marker->_sbuf = fp;
 549   if (_IO_in_put_mode (fp))
 550     _IO_switch_to_wget_mode (fp);
 551   if (_IO_in_backup (fp))
 552     marker->_pos = fp->_wide_data->_IO_read_ptr - fp->_wide_data->_IO_read_end;
 553   else
 554     marker->_pos = (fp->_wide_data->_IO_read_ptr
 555                     - fp->_wide_data->_IO_read_base);
 556
 557   /* Should perhaps sort the chain? */
 558   marker->_next = fp->_markers;
 559   fp->_markers = marker;
 560 }
 561
 562 #define BAD_DELTA EOF
 563
 564 /* Return difference between MARK and current position of MARK's stream. */
 565 int
 566 _IO_wmarker_delta (struct _IO_marker *mark)
 567 {
 568   int cur_pos;
 569   if (mark->_sbuf == NULL)
 570     return BAD_DELTA;
 571   if (_IO_in_backup (mark->_sbuf))
 572     cur_pos = (mark->_sbuf->_wide_data->_IO_read_ptr
 573                - mark->_sbuf->_wide_data->_IO_read_end);
 574   else
 575     cur_pos = (mark->_sbuf->_wide_data->_IO_read_ptr
 576                - mark->_sbuf->_wide_data->_IO_read_base);
 577   return mark->_pos - cur_pos;
 578 }
 579
 580 int
 581 _IO_seekwmark (FILE *fp, struct _IO_marker *mark, int delta)
 582 {
 583   if (mark->_sbuf != fp)
 584     return EOF;
 585  if (mark->_pos >= 0)
 586     {
 587       if (_IO_in_backup (fp))
 588         _IO_switch_to_main_wget_area (fp);
 589       fp->_wide_data->_IO_read_ptr = (fp->_wide_data->_IO_read_base
 590                                       + mark->_pos);
 591     }
 592   else
 593     {
 594       if (!_IO_in_backup (fp))
 595         _IO_switch_to_wbackup_area (fp);
 596       fp->_wide_data->_IO_read_ptr = fp->_wide_data->_IO_read_end + mark->_pos;
 597     }
 598   return 0;
 599 }
 600
 601 void
 602 _IO_unsave_wmarkers (FILE *fp)
 603 {
 604   struct _IO_marker *mark = fp->_markers;
 605   if (mark)
 606     {
 607       fp->_markers = 0;
 608     }
 609
 610   if (_IO_have_backup (fp))
 611     _IO_free_wbackup_area (fp);
 612 }