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