1 /* Copyright (C) 1993-2019 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>.
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.
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.
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 <https://www.gnu.org/licenses/>.
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. */
36 /* Convert TO_DO wide character from DATA to FP.
37 Then mark FP as having empty buffers. */
39 _IO_wdo_write (FILE *fp
, const wchar_t *data
, size_t to_do
)
41 struct _IO_codecvt
*cc
= fp
->_codecvt
;
45 if (fp
->_IO_write_end
== fp
->_IO_write_ptr
46 && fp
->_IO_write_end
!= fp
->_IO_write_base
)
48 if (_IO_new_do_write (fp
, fp
->_IO_write_base
,
49 fp
->_IO_write_ptr
- fp
->_IO_write_base
) == EOF
)
55 enum __codecvt_result result
;
56 const wchar_t *new_data
;
57 char mb_buf
[MB_LEN_MAX
];
58 char *write_base
, *write_ptr
, *buf_end
;
60 if (fp
->_IO_write_ptr
- fp
->_IO_write_base
< sizeof (mb_buf
))
62 /* Make sure we have room for at least one multibyte
64 write_ptr
= write_base
= mb_buf
;
65 buf_end
= mb_buf
+ sizeof (mb_buf
);
69 write_ptr
= fp
->_IO_write_ptr
;
70 write_base
= fp
->_IO_write_base
;
71 buf_end
= fp
->_IO_buf_end
;
74 /* Now convert from the internal format into the external buffer. */
75 result
= __libio_codecvt_out (cc
, &fp
->_wide_data
->_IO_state
,
76 data
, data
+ to_do
, &new_data
,
81 /* Write out what we produced so far. */
82 if (_IO_new_do_write (fp
, write_base
, write_ptr
- write_base
) == EOF
)
83 /* Something went wrong. */
86 to_do
-= new_data
- data
;
88 /* Next see whether we had problems during the conversion. If yes,
90 if (result
!= __codecvt_ok
91 && (result
!= __codecvt_partial
|| new_data
- data
== 0))
99 _IO_wsetg (fp
, fp
->_wide_data
->_IO_buf_base
, fp
->_wide_data
->_IO_buf_base
,
100 fp
->_wide_data
->_IO_buf_base
);
101 fp
->_wide_data
->_IO_write_base
= fp
->_wide_data
->_IO_write_ptr
102 = fp
->_wide_data
->_IO_buf_base
;
103 fp
->_wide_data
->_IO_write_end
= ((fp
->_flags
& (_IO_LINE_BUF
| _IO_UNBUFFERED
))
104 ? fp
->_wide_data
->_IO_buf_base
105 : fp
->_wide_data
->_IO_buf_end
);
107 return to_do
== 0 ? 0 : WEOF
;
109 libc_hidden_def (_IO_wdo_write
)
113 _IO_wfile_underflow (FILE *fp
)
115 struct _IO_codecvt
*cd
;
116 enum __codecvt_result status
;
119 /* C99 requires EOF to be "sticky". */
120 if (fp
->_flags
& _IO_EOF_SEEN
)
123 if (__glibc_unlikely (fp
->_flags
& _IO_NO_READS
))
125 fp
->_flags
|= _IO_ERR_SEEN
;
129 if (fp
->_wide_data
->_IO_read_ptr
< fp
->_wide_data
->_IO_read_end
)
130 return *fp
->_wide_data
->_IO_read_ptr
;
134 /* Maybe there is something left in the external buffer. */
135 if (fp
->_IO_read_ptr
< fp
->_IO_read_end
)
137 /* There is more in the external. Convert it. */
138 const char *read_stop
= (const char *) fp
->_IO_read_ptr
;
140 fp
->_wide_data
->_IO_last_state
= fp
->_wide_data
->_IO_state
;
141 fp
->_wide_data
->_IO_read_base
= fp
->_wide_data
->_IO_read_ptr
=
142 fp
->_wide_data
->_IO_buf_base
;
143 status
= __libio_codecvt_in (cd
, &fp
->_wide_data
->_IO_state
,
144 fp
->_IO_read_ptr
, fp
->_IO_read_end
,
146 fp
->_wide_data
->_IO_read_ptr
,
147 fp
->_wide_data
->_IO_buf_end
,
148 &fp
->_wide_data
->_IO_read_end
);
150 fp
->_IO_read_base
= fp
->_IO_read_ptr
;
151 fp
->_IO_read_ptr
= (char *) read_stop
;
153 /* If we managed to generate some text return the next character. */
154 if (fp
->_wide_data
->_IO_read_ptr
< fp
->_wide_data
->_IO_read_end
)
155 return *fp
->_wide_data
->_IO_read_ptr
;
157 if (status
== __codecvt_error
)
159 __set_errno (EILSEQ
);
160 fp
->_flags
|= _IO_ERR_SEEN
;
164 /* Move the remaining content of the read buffer to the beginning. */
165 memmove (fp
->_IO_buf_base
, fp
->_IO_read_ptr
,
166 fp
->_IO_read_end
- fp
->_IO_read_ptr
);
167 fp
->_IO_read_end
= (fp
->_IO_buf_base
168 + (fp
->_IO_read_end
- fp
->_IO_read_ptr
));
169 fp
->_IO_read_base
= fp
->_IO_read_ptr
= fp
->_IO_buf_base
;
172 fp
->_IO_read_base
= fp
->_IO_read_ptr
= fp
->_IO_read_end
=
175 if (fp
->_IO_buf_base
== NULL
)
177 /* Maybe we already have a push back pointer. */
178 if (fp
->_IO_save_base
!= NULL
)
180 free (fp
->_IO_save_base
);
181 fp
->_flags
&= ~_IO_IN_BACKUP
;
185 fp
->_IO_read_base
= fp
->_IO_read_ptr
= fp
->_IO_read_end
=
189 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_write_end
=
192 if (fp
->_wide_data
->_IO_buf_base
== NULL
)
194 /* Maybe we already have a push back pointer. */
195 if (fp
->_wide_data
->_IO_save_base
!= NULL
)
197 free (fp
->_wide_data
->_IO_save_base
);
198 fp
->_flags
&= ~_IO_IN_BACKUP
;
200 _IO_wdoallocbuf (fp
);
203 /* FIXME This can/should be moved to genops ?? */
204 if (fp
->_flags
& (_IO_LINE_BUF
| _IO_UNBUFFERED
))
206 /* We used to flush all line-buffered stream. This really isn't
207 required by any standard. My recollection is that
208 traditional Unix systems did this for stdout. stderr better
209 not be line buffered. So we do just that here
210 explicitly. --drepper */
211 _IO_acquire_lock (stdout
);
213 if ((stdout
->_flags
& (_IO_LINKED
| _IO_NO_WRITES
| _IO_LINE_BUF
))
214 == (_IO_LINKED
| _IO_LINE_BUF
))
215 _IO_OVERFLOW (stdout
, EOF
);
217 _IO_release_lock (stdout
);
220 _IO_switch_to_get_mode (fp
);
222 fp
->_wide_data
->_IO_read_base
= fp
->_wide_data
->_IO_read_ptr
=
223 fp
->_wide_data
->_IO_buf_base
;
224 fp
->_wide_data
->_IO_read_end
= fp
->_wide_data
->_IO_buf_base
;
225 fp
->_wide_data
->_IO_write_base
= fp
->_wide_data
->_IO_write_ptr
=
226 fp
->_wide_data
->_IO_write_end
= fp
->_wide_data
->_IO_buf_base
;
228 const char *read_ptr_copy
;
229 char accbuf
[MB_LEN_MAX
];
232 count
= _IO_SYSREAD (fp
, fp
->_IO_read_end
,
233 fp
->_IO_buf_end
- fp
->_IO_read_end
);
236 if (count
== 0 && naccbuf
== 0)
238 fp
->_flags
|= _IO_EOF_SEEN
;
239 fp
->_offset
= _IO_pos_BAD
;
242 fp
->_flags
|= _IO_ERR_SEEN
, count
= 0;
244 fp
->_IO_read_end
+= count
;
248 /* There are some bytes in the external buffer but they don't
249 convert to anything. */
250 __set_errno (EILSEQ
);
253 if (fp
->_offset
!= _IO_pos_BAD
)
254 _IO_pos_adjust (fp
->_offset
, count
);
256 /* Now convert the read input. */
257 fp
->_wide_data
->_IO_last_state
= fp
->_wide_data
->_IO_state
;
258 fp
->_IO_read_base
= fp
->_IO_read_ptr
;
259 const char *from
= fp
->_IO_read_ptr
;
260 const char *to
= fp
->_IO_read_end
;
261 size_t to_copy
= count
;
262 if (__glibc_unlikely (naccbuf
!= 0))
264 to_copy
= MIN (sizeof (accbuf
) - naccbuf
, count
);
265 to
= __mempcpy (&accbuf
[naccbuf
], from
, to_copy
);
269 status
= __libio_codecvt_in (cd
, &fp
->_wide_data
->_IO_state
,
270 from
, to
, &read_ptr_copy
,
271 fp
->_wide_data
->_IO_read_end
,
272 fp
->_wide_data
->_IO_buf_end
,
273 &fp
->_wide_data
->_IO_read_end
);
275 if (__glibc_unlikely (naccbuf
!= 0))
276 fp
->_IO_read_ptr
+= MAX (0, read_ptr_copy
- &accbuf
[naccbuf
- to_copy
]);
278 fp
->_IO_read_ptr
= (char *) read_ptr_copy
;
279 if (fp
->_wide_data
->_IO_read_end
== fp
->_wide_data
->_IO_buf_base
)
281 if (status
== __codecvt_error
)
284 __set_errno (EILSEQ
);
285 fp
->_flags
|= _IO_ERR_SEEN
;
289 /* The read bytes make no complete character. Try reading again. */
290 assert (status
== __codecvt_partial
);
294 if (fp
->_IO_read_base
< fp
->_IO_read_ptr
)
296 /* Partially used the buffer for some input data that
297 produces no output. */
298 size_t avail
= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
299 memmove (fp
->_IO_read_base
, fp
->_IO_read_ptr
, avail
);
300 fp
->_IO_read_ptr
= fp
->_IO_read_base
;
301 fp
->_IO_read_end
-= avail
;
304 naccbuf
= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
305 if (naccbuf
>= sizeof (accbuf
))
308 memcpy (accbuf
, fp
->_IO_read_ptr
, naccbuf
);
312 size_t used
= read_ptr_copy
- accbuf
;
315 memmove (accbuf
, read_ptr_copy
, naccbuf
- used
);
319 if (naccbuf
== sizeof (accbuf
))
323 fp
->_IO_read_ptr
= fp
->_IO_read_end
= fp
->_IO_read_base
;
328 return *fp
->_wide_data
->_IO_read_ptr
;
330 libc_hidden_def (_IO_wfile_underflow
)
334 _IO_wfile_underflow_mmap (FILE *fp
)
336 struct _IO_codecvt
*cd
;
337 const char *read_stop
;
339 if (__glibc_unlikely (fp
->_flags
& _IO_NO_READS
))
341 fp
->_flags
|= _IO_ERR_SEEN
;
345 if (fp
->_wide_data
->_IO_read_ptr
< fp
->_wide_data
->_IO_read_end
)
346 return *fp
->_wide_data
->_IO_read_ptr
;
350 /* Maybe there is something left in the external buffer. */
351 if (fp
->_IO_read_ptr
>= fp
->_IO_read_end
352 /* No. But maybe the read buffer is not fully set up. */
353 && _IO_file_underflow_mmap (fp
) == EOF
)
354 /* Nothing available. _IO_file_underflow_mmap has set the EOF or error
355 flags as appropriate. */
358 /* There is more in the external. Convert it. */
359 read_stop
= (const char *) fp
->_IO_read_ptr
;
361 if (fp
->_wide_data
->_IO_buf_base
== NULL
)
363 /* Maybe we already have a push back pointer. */
364 if (fp
->_wide_data
->_IO_save_base
!= NULL
)
366 free (fp
->_wide_data
->_IO_save_base
);
367 fp
->_flags
&= ~_IO_IN_BACKUP
;
369 _IO_wdoallocbuf (fp
);
372 fp
->_wide_data
->_IO_last_state
= fp
->_wide_data
->_IO_state
;
373 fp
->_wide_data
->_IO_read_base
= fp
->_wide_data
->_IO_read_ptr
=
374 fp
->_wide_data
->_IO_buf_base
;
375 __libio_codecvt_in (cd
, &fp
->_wide_data
->_IO_state
,
376 fp
->_IO_read_ptr
, fp
->_IO_read_end
,
378 fp
->_wide_data
->_IO_read_ptr
,
379 fp
->_wide_data
->_IO_buf_end
,
380 &fp
->_wide_data
->_IO_read_end
);
382 fp
->_IO_read_ptr
= (char *) read_stop
;
384 /* If we managed to generate some text return the next character. */
385 if (fp
->_wide_data
->_IO_read_ptr
< fp
->_wide_data
->_IO_read_end
)
386 return *fp
->_wide_data
->_IO_read_ptr
;
388 /* There is some garbage at the end of the file. */
389 __set_errno (EILSEQ
);
390 fp
->_flags
|= _IO_ERR_SEEN
;
395 _IO_wfile_underflow_maybe_mmap (FILE *fp
)
397 /* This is the first read attempt. Doing the underflow will choose mmap
398 or vanilla operations and then punt to the chosen underflow routine.
399 Then we can punt to ours. */
400 if (_IO_file_underflow_maybe_mmap (fp
) == EOF
)
403 return _IO_WUNDERFLOW (fp
);
408 _IO_wfile_overflow (FILE *f
, wint_t wch
)
410 if (f
->_flags
& _IO_NO_WRITES
) /* SET ERROR */
412 f
->_flags
|= _IO_ERR_SEEN
;
416 /* If currently reading or no buffer allocated. */
417 if ((f
->_flags
& _IO_CURRENTLY_PUTTING
) == 0)
419 /* Allocate a buffer if needed. */
420 if (f
->_wide_data
->_IO_write_base
== 0)
423 _IO_free_wbackup_area (f
);
424 _IO_wsetg (f
, f
->_wide_data
->_IO_buf_base
,
425 f
->_wide_data
->_IO_buf_base
, f
->_wide_data
->_IO_buf_base
);
427 if (f
->_IO_write_base
== NULL
)
430 _IO_setg (f
, f
->_IO_buf_base
, f
->_IO_buf_base
, f
->_IO_buf_base
);
435 /* Otherwise must be currently reading. If _IO_read_ptr
436 (and hence also _IO_read_end) is at the buffer end,
437 logically slide the buffer forwards one block (by setting
438 the read pointers to all point at the beginning of the
439 block). This makes room for subsequent output.
440 Otherwise, set the read pointers to _IO_read_end (leaving
441 that alone, so it can continue to correspond to the
442 external position). */
443 if (f
->_wide_data
->_IO_read_ptr
== f
->_wide_data
->_IO_buf_end
)
445 f
->_IO_read_end
= f
->_IO_read_ptr
= f
->_IO_buf_base
;
446 f
->_wide_data
->_IO_read_end
= f
->_wide_data
->_IO_read_ptr
=
447 f
->_wide_data
->_IO_buf_base
;
450 f
->_wide_data
->_IO_write_ptr
= f
->_wide_data
->_IO_read_ptr
;
451 f
->_wide_data
->_IO_write_base
= f
->_wide_data
->_IO_write_ptr
;
452 f
->_wide_data
->_IO_write_end
= f
->_wide_data
->_IO_buf_end
;
453 f
->_wide_data
->_IO_read_base
= f
->_wide_data
->_IO_read_ptr
=
454 f
->_wide_data
->_IO_read_end
;
456 f
->_IO_write_ptr
= f
->_IO_read_ptr
;
457 f
->_IO_write_base
= f
->_IO_write_ptr
;
458 f
->_IO_write_end
= f
->_IO_buf_end
;
459 f
->_IO_read_base
= f
->_IO_read_ptr
= f
->_IO_read_end
;
461 f
->_flags
|= _IO_CURRENTLY_PUTTING
;
462 if (f
->_flags
& (_IO_LINE_BUF
| _IO_UNBUFFERED
))
463 f
->_wide_data
->_IO_write_end
= f
->_wide_data
->_IO_write_ptr
;
466 return _IO_do_flush (f
);
467 if (f
->_wide_data
->_IO_write_ptr
== f
->_wide_data
->_IO_buf_end
)
468 /* Buffer is really full */
469 if (_IO_do_flush (f
) == EOF
)
471 *f
->_wide_data
->_IO_write_ptr
++ = wch
;
472 if ((f
->_flags
& _IO_UNBUFFERED
)
473 || ((f
->_flags
& _IO_LINE_BUF
) && wch
== L
'\n'))
474 if (_IO_do_flush (f
) == EOF
)
478 libc_hidden_def (_IO_wfile_overflow
)
481 _IO_wfile_sync (FILE *fp
)
486 /* char* ptr = cur_ptr(); */
487 if (fp
->_wide_data
->_IO_write_ptr
> fp
->_wide_data
->_IO_write_base
)
488 if (_IO_do_flush (fp
))
490 delta
= fp
->_wide_data
->_IO_read_ptr
- fp
->_wide_data
->_IO_read_end
;
493 /* We have to find out how many bytes we have to go back in the
495 struct _IO_codecvt
*cv
= fp
->_codecvt
;
498 int clen
= __libio_codecvt_encoding (cv
);
501 /* It is easy, a fixed number of input bytes are used for each
506 /* We have to find out the hard way how much to back off.
507 To do this we determine how much input we needed to
508 generate the wide characters up to the current reading
511 size_t wnread
= (fp
->_wide_data
->_IO_read_ptr
512 - fp
->_wide_data
->_IO_read_base
);
513 fp
->_wide_data
->_IO_state
= fp
->_wide_data
->_IO_last_state
;
514 nread
= __libio_codecvt_length (cv
, &fp
->_wide_data
->_IO_state
,
516 fp
->_IO_read_end
, wnread
);
517 fp
->_IO_read_ptr
= fp
->_IO_read_base
+ nread
;
518 delta
= -(fp
->_IO_read_end
- fp
->_IO_read_base
- nread
);
521 new_pos
= _IO_SYSSEEK (fp
, delta
, 1);
522 if (new_pos
!= (off64_t
) EOF
)
524 fp
->_wide_data
->_IO_read_end
= fp
->_wide_data
->_IO_read_ptr
;
525 fp
->_IO_read_end
= fp
->_IO_read_ptr
;
527 else if (errno
== ESPIPE
)
528 ; /* Ignore error from unseekable devices. */
533 fp
->_offset
= _IO_pos_BAD
;
534 /* FIXME: Cleanup - can this be shared? */
535 /* setg(base(), ptr, ptr); */
538 libc_hidden_def (_IO_wfile_sync
)
540 /* Adjust the internal buffer pointers to reflect the state in the external
541 buffer. The content between fp->_IO_read_base and fp->_IO_read_ptr is
542 assumed to be converted and available in the range
543 fp->_wide_data->_IO_read_base and fp->_wide_data->_IO_read_end.
545 Returns 0 on success and -1 on error with the _IO_ERR_SEEN flag set. */
547 adjust_wide_data (FILE *fp
, bool do_convert
)
549 struct _IO_codecvt
*cv
= fp
->_codecvt
;
551 int clen
= __libio_codecvt_encoding (cv
);
553 /* Take the easy way out for constant length encodings if we don't need to
555 if (!do_convert
&& clen
> 0)
557 fp
->_wide_data
->_IO_read_end
+= ((fp
->_IO_read_ptr
- fp
->_IO_read_base
)
562 enum __codecvt_result status
;
563 const char *read_stop
= (const char *) fp
->_IO_read_base
;
567 fp
->_wide_data
->_IO_last_state
= fp
->_wide_data
->_IO_state
;
568 status
= __libio_codecvt_in (cv
, &fp
->_wide_data
->_IO_state
,
569 fp
->_IO_read_base
, fp
->_IO_read_ptr
,
571 fp
->_wide_data
->_IO_read_base
,
572 fp
->_wide_data
->_IO_buf_end
,
573 &fp
->_wide_data
->_IO_read_end
);
575 /* Should we return EILSEQ? */
576 if (__glibc_unlikely (status
== __codecvt_error
))
578 fp
->_flags
|= _IO_ERR_SEEN
;
582 while (__builtin_expect (status
== __codecvt_partial
, 0));
585 /* Now seek to _IO_read_end to behave as if we have read it all in. */
586 fp
->_wide_data
->_IO_read_ptr
= fp
->_wide_data
->_IO_read_end
;
591 /* ftell{,o} implementation for wide mode. Don't modify any state of the file
592 pointer while we try to get the current state of the stream except in one
593 case, which is when we have unflushed writes in append mode. */
595 do_ftell_wide (FILE *fp
)
597 off64_t result
, offset
= 0;
599 /* No point looking for offsets in the buffer if it hasn't even been
601 if (fp
->_wide_data
->_IO_buf_base
!= NULL
)
603 const wchar_t *wide_read_base
;
604 const wchar_t *wide_read_ptr
;
605 const wchar_t *wide_read_end
;
606 bool unflushed_writes
= (fp
->_wide_data
->_IO_write_ptr
607 > fp
->_wide_data
->_IO_write_base
);
609 bool append_mode
= (fp
->_flags
& _IO_IS_APPENDING
) == _IO_IS_APPENDING
;
611 /* When we have unflushed writes in append mode, seek to the end of the
612 file and record that offset. This is the only time we change the file
613 stream state and it is safe since the file handle is active. */
614 if (unflushed_writes
&& append_mode
)
616 result
= _IO_SYSSEEK (fp
, 0, _IO_seek_end
);
617 if (result
== _IO_pos_BAD
)
620 fp
->_offset
= result
;
623 /* XXX For wide stream with backup store it is not very
624 reasonable to determine the offset. The pushed-back
625 character might require a state change and we need not be
626 able to compute the initial state by reverse transformation
627 since there is no guarantee of symmetry. So we don't even
628 try and return an error. */
629 if (_IO_in_backup (fp
))
631 if (fp
->_wide_data
->_IO_read_ptr
< fp
->_wide_data
->_IO_read_end
)
633 __set_errno (EINVAL
);
637 /* Nothing in the backup store, so note the backed up pointers
638 without changing the state. */
639 wide_read_base
= fp
->_wide_data
->_IO_save_base
;
640 wide_read_ptr
= wide_read_base
;
641 wide_read_end
= fp
->_wide_data
->_IO_save_end
;
645 wide_read_base
= fp
->_wide_data
->_IO_read_base
;
646 wide_read_ptr
= fp
->_wide_data
->_IO_read_ptr
;
647 wide_read_end
= fp
->_wide_data
->_IO_read_end
;
650 struct _IO_codecvt
*cv
= fp
->_codecvt
;
651 int clen
= __libio_codecvt_encoding (cv
);
653 if (!unflushed_writes
)
657 offset
-= (wide_read_end
- wide_read_ptr
) * clen
;
658 offset
-= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
664 size_t delta
= wide_read_ptr
- wide_read_base
;
665 __mbstate_t state
= fp
->_wide_data
->_IO_last_state
;
666 nread
= __libio_codecvt_length (cv
, &state
,
668 fp
->_IO_read_end
, delta
);
669 offset
-= fp
->_IO_read_end
- fp
->_IO_read_base
- nread
;
675 offset
+= (fp
->_wide_data
->_IO_write_ptr
676 - fp
->_wide_data
->_IO_write_base
) * clen
;
679 size_t delta
= (fp
->_wide_data
->_IO_write_ptr
680 - fp
->_wide_data
->_IO_write_base
);
682 /* Allocate enough space for the conversion. */
683 size_t outsize
= delta
* sizeof (wchar_t);
684 char *out
= malloc (outsize
);
686 const wchar_t *in
= fp
->_wide_data
->_IO_write_base
;
688 enum __codecvt_result status
;
690 __mbstate_t state
= fp
->_wide_data
->_IO_last_state
;
691 status
= __libio_codecvt_out (cv
, &state
, in
, in
+ delta
, &in
,
692 out
, out
+ outsize
, &outstop
);
694 /* We don't check for __codecvt_partial because it can be
695 returned on one of two conditions: either the output
696 buffer is full or the input sequence is incomplete. We
697 take care to allocate enough buffer and our input
698 sequences must be complete since they are accepted as
699 wchar_t; if not, then that is an error. */
700 if (__glibc_unlikely (status
!= __codecvt_ok
))
706 offset
+= outstop
- out
;
710 /* We don't trust _IO_read_end to represent the current file offset
711 when writing in append mode because the value would have to be
712 shifted to the end of the file during a flush. Use the write base
713 instead, along with the new offset we got above when we did a seek
714 to the end of the file. */
716 offset
+= fp
->_IO_write_ptr
- fp
->_IO_write_base
;
717 /* For all other modes, _IO_read_end represents the file offset. */
719 offset
+= fp
->_IO_write_ptr
- fp
->_IO_read_end
;
723 if (fp
->_offset
!= _IO_pos_BAD
)
724 result
= fp
->_offset
;
726 result
= _IO_SYSSEEK (fp
, 0, _IO_seek_cur
);
735 __set_errno (EINVAL
);
743 _IO_wfile_seekoff (FILE *fp
, off64_t offset
, int dir
, int mode
)
746 off64_t delta
, new_offset
;
749 /* Short-circuit into a separate function. We don't want to mix any
750 functionality and we don't want to touch anything inside the FILE
753 return do_ftell_wide (fp
);
755 /* POSIX.1 8.2.3.7 says that after a call the fflush() the file
756 offset of the underlying file must be exact. */
757 int must_be_exact
= ((fp
->_wide_data
->_IO_read_base
758 == fp
->_wide_data
->_IO_read_end
)
759 && (fp
->_wide_data
->_IO_write_base
760 == fp
->_wide_data
->_IO_write_ptr
));
762 bool was_writing
= ((fp
->_wide_data
->_IO_write_ptr
763 > fp
->_wide_data
->_IO_write_base
)
764 || _IO_in_put_mode (fp
));
766 /* Flush unwritten characters.
767 (This may do an unneeded write if we seek within the buffer.
768 But to be able to switch to reading, we would need to set
769 egptr to pptr. That can't be done in the current design,
770 which assumes file_ptr() is eGptr. Anyway, since we probably
771 end up flushing when we close(), it doesn't make much difference.)
772 FIXME: simulate mem-mapped files. */
773 if (was_writing
&& _IO_switch_to_wget_mode (fp
))
776 if (fp
->_wide_data
->_IO_buf_base
== NULL
)
778 /* It could be that we already have a pushback buffer. */
779 if (fp
->_wide_data
->_IO_read_base
!= NULL
)
781 free (fp
->_wide_data
->_IO_read_base
);
782 fp
->_flags
&= ~_IO_IN_BACKUP
;
785 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
786 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
787 _IO_wsetp (fp
, fp
->_wide_data
->_IO_buf_base
,
788 fp
->_wide_data
->_IO_buf_base
);
789 _IO_wsetg (fp
, fp
->_wide_data
->_IO_buf_base
,
790 fp
->_wide_data
->_IO_buf_base
, fp
->_wide_data
->_IO_buf_base
);
795 struct _IO_codecvt
*cv
;
799 /* Adjust for read-ahead (bytes is buffer). To do this we must
800 find out which position in the external buffer corresponds to
801 the current position in the internal buffer. */
803 clen
= __libio_codecvt_encoding (cv
);
805 if (mode
!= 0 || !was_writing
)
809 offset
-= (fp
->_wide_data
->_IO_read_end
810 - fp
->_wide_data
->_IO_read_ptr
) * clen
;
811 /* Adjust by readahead in external buffer. */
812 offset
-= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
818 delta
= (fp
->_wide_data
->_IO_read_ptr
819 - fp
->_wide_data
->_IO_read_base
);
820 fp
->_wide_data
->_IO_state
= fp
->_wide_data
->_IO_last_state
;
821 nread
= __libio_codecvt_length (cv
,
822 &fp
->_wide_data
->_IO_state
,
824 fp
->_IO_read_end
, delta
);
825 fp
->_IO_read_ptr
= fp
->_IO_read_base
+ nread
;
826 fp
->_wide_data
->_IO_read_end
= fp
->_wide_data
->_IO_read_ptr
;
827 offset
-= fp
->_IO_read_end
- fp
->_IO_read_base
- nread
;
831 if (fp
->_offset
== _IO_pos_BAD
)
834 /* Make offset absolute, assuming current pointer is file_ptr(). */
835 offset
+= fp
->_offset
;
844 if (_IO_SYSSTAT (fp
, &st
) == 0 && S_ISREG (st
.st_mode
))
846 offset
+= st
.st_size
;
854 _IO_free_wbackup_area (fp
);
856 /* At this point, dir==_IO_seek_set. */
858 /* If destination is within current buffer, optimize: */
859 if (fp
->_offset
!= _IO_pos_BAD
&& fp
->_IO_read_base
!= NULL
860 && !_IO_in_backup (fp
))
862 off64_t start_offset
= (fp
->_offset
863 - (fp
->_IO_read_end
- fp
->_IO_buf_base
));
864 if (offset
>= start_offset
&& offset
< fp
->_offset
)
866 _IO_setg (fp
, fp
->_IO_buf_base
,
867 fp
->_IO_buf_base
+ (offset
- start_offset
),
869 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
870 _IO_wsetg (fp
, fp
->_wide_data
->_IO_buf_base
,
871 fp
->_wide_data
->_IO_buf_base
,
872 fp
->_wide_data
->_IO_buf_base
);
873 _IO_wsetp (fp
, fp
->_wide_data
->_IO_buf_base
,
874 fp
->_wide_data
->_IO_buf_base
);
876 if (adjust_wide_data (fp
, false))
879 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
884 if (fp
->_flags
& _IO_NO_READS
)
887 /* Try to seek to a block boundary, to improve kernel page management. */
888 new_offset
= offset
& ~(fp
->_IO_buf_end
- fp
->_IO_buf_base
- 1);
889 delta
= offset
- new_offset
;
890 if (delta
> fp
->_IO_buf_end
- fp
->_IO_buf_base
)
895 result
= _IO_SYSSEEK (fp
, new_offset
, 0);
902 count
= _IO_SYSREAD (fp
, fp
->_IO_buf_base
,
904 ? delta
: fp
->_IO_buf_end
- fp
->_IO_buf_base
));
907 /* We weren't allowed to read, but try to seek the remainder. */
908 offset
= count
== EOF
? delta
: delta
-count
;
913 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
+ delta
,
914 fp
->_IO_buf_base
+ count
);
915 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
916 _IO_wsetg (fp
, fp
->_wide_data
->_IO_buf_base
,
917 fp
->_wide_data
->_IO_buf_base
, fp
->_wide_data
->_IO_buf_base
);
918 _IO_wsetp (fp
, fp
->_wide_data
->_IO_buf_base
, fp
->_wide_data
->_IO_buf_base
);
920 if (adjust_wide_data (fp
, true))
923 fp
->_offset
= result
+ count
;
924 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
928 _IO_unsave_markers (fp
);
929 result
= _IO_SYSSEEK (fp
, offset
, dir
);
932 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
933 fp
->_offset
= result
;
934 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
935 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
936 _IO_wsetg (fp
, fp
->_wide_data
->_IO_buf_base
,
937 fp
->_wide_data
->_IO_buf_base
, fp
->_wide_data
->_IO_buf_base
);
938 _IO_wsetp (fp
, fp
->_wide_data
->_IO_buf_base
,
939 fp
->_wide_data
->_IO_buf_base
);
944 /* We need to do it since it is possible that the file offset in
945 the kernel may be changed behind our back. It may happen when
946 we fopen a file and then do a fork. One process may access the
947 file and the kernel file offset will be changed. */
948 if (fp
->_offset
>= 0)
949 _IO_SYSSEEK (fp
, fp
->_offset
, 0);
953 libc_hidden_def (_IO_wfile_seekoff
)
957 _IO_wfile_xsputn (FILE *f
, const void *data
, size_t n
)
959 const wchar_t *s
= (const wchar_t *) data
;
966 /* This is an optimized implementation.
967 If the amount to be written straddles a block boundary
968 (or the filebuf is unbuffered), use sys_write directly. */
970 /* First figure out how much space is available in the buffer. */
971 count
= f
->_wide_data
->_IO_write_end
- f
->_wide_data
->_IO_write_ptr
;
972 if ((f
->_flags
& _IO_LINE_BUF
) && (f
->_flags
& _IO_CURRENTLY_PUTTING
))
974 count
= f
->_wide_data
->_IO_buf_end
- f
->_wide_data
->_IO_write_ptr
;
978 for (p
= s
+ n
; p
> s
; )
989 /* Then fill the buffer. */
996 f
->_wide_data
->_IO_write_ptr
=
997 __wmempcpy (f
->_wide_data
->_IO_write_ptr
, s
, count
);
1002 wchar_t *p
= f
->_wide_data
->_IO_write_ptr
;
1003 int i
= (int) count
;
1006 f
->_wide_data
->_IO_write_ptr
= p
;
1011 to_do
-= _IO_wdefault_xsputn (f
, s
, to_do
);
1013 && f
->_wide_data
->_IO_write_ptr
!= f
->_wide_data
->_IO_write_base
)
1014 _IO_wdo_write (f
, f
->_wide_data
->_IO_write_base
,
1015 f
->_wide_data
->_IO_write_ptr
1016 - f
->_wide_data
->_IO_write_base
);
1020 libc_hidden_def (_IO_wfile_xsputn
)
1023 const struct _IO_jump_t _IO_wfile_jumps libio_vtable
=
1026 JUMP_INIT(finish
, _IO_new_file_finish
),
1027 JUMP_INIT(overflow
, (_IO_overflow_t
) _IO_wfile_overflow
),
1028 JUMP_INIT(underflow
, (_IO_underflow_t
) _IO_wfile_underflow
),
1029 JUMP_INIT(uflow
, (_IO_underflow_t
) _IO_wdefault_uflow
),
1030 JUMP_INIT(pbackfail
, (_IO_pbackfail_t
) _IO_wdefault_pbackfail
),
1031 JUMP_INIT(xsputn
, _IO_wfile_xsputn
),
1032 JUMP_INIT(xsgetn
, _IO_file_xsgetn
),
1033 JUMP_INIT(seekoff
, _IO_wfile_seekoff
),
1034 JUMP_INIT(seekpos
, _IO_default_seekpos
),
1035 JUMP_INIT(setbuf
, _IO_new_file_setbuf
),
1036 JUMP_INIT(sync
, (_IO_sync_t
) _IO_wfile_sync
),
1037 JUMP_INIT(doallocate
, _IO_wfile_doallocate
),
1038 JUMP_INIT(read
, _IO_file_read
),
1039 JUMP_INIT(write
, _IO_new_file_write
),
1040 JUMP_INIT(seek
, _IO_file_seek
),
1041 JUMP_INIT(close
, _IO_file_close
),
1042 JUMP_INIT(stat
, _IO_file_stat
),
1043 JUMP_INIT(showmanyc
, _IO_default_showmanyc
),
1044 JUMP_INIT(imbue
, _IO_default_imbue
)
1046 libc_hidden_data_def (_IO_wfile_jumps
)
1049 const struct _IO_jump_t _IO_wfile_jumps_mmap libio_vtable
=
1052 JUMP_INIT(finish
, _IO_new_file_finish
),
1053 JUMP_INIT(overflow
, (_IO_overflow_t
) _IO_wfile_overflow
),
1054 JUMP_INIT(underflow
, (_IO_underflow_t
) _IO_wfile_underflow_mmap
),
1055 JUMP_INIT(uflow
, (_IO_underflow_t
) _IO_wdefault_uflow
),
1056 JUMP_INIT(pbackfail
, (_IO_pbackfail_t
) _IO_wdefault_pbackfail
),
1057 JUMP_INIT(xsputn
, _IO_wfile_xsputn
),
1058 JUMP_INIT(xsgetn
, _IO_file_xsgetn
),
1059 JUMP_INIT(seekoff
, _IO_wfile_seekoff
),
1060 JUMP_INIT(seekpos
, _IO_default_seekpos
),
1061 JUMP_INIT(setbuf
, _IO_file_setbuf_mmap
),
1062 JUMP_INIT(sync
, (_IO_sync_t
) _IO_wfile_sync
),
1063 JUMP_INIT(doallocate
, _IO_wfile_doallocate
),
1064 JUMP_INIT(read
, _IO_file_read
),
1065 JUMP_INIT(write
, _IO_new_file_write
),
1066 JUMP_INIT(seek
, _IO_file_seek
),
1067 JUMP_INIT(close
, _IO_file_close_mmap
),
1068 JUMP_INIT(stat
, _IO_file_stat
),
1069 JUMP_INIT(showmanyc
, _IO_default_showmanyc
),
1070 JUMP_INIT(imbue
, _IO_default_imbue
)
1073 const struct _IO_jump_t _IO_wfile_jumps_maybe_mmap libio_vtable
=
1076 JUMP_INIT(finish
, _IO_new_file_finish
),
1077 JUMP_INIT(overflow
, (_IO_overflow_t
) _IO_wfile_overflow
),
1078 JUMP_INIT(underflow
, (_IO_underflow_t
) _IO_wfile_underflow_maybe_mmap
),
1079 JUMP_INIT(uflow
, (_IO_underflow_t
) _IO_wdefault_uflow
),
1080 JUMP_INIT(pbackfail
, (_IO_pbackfail_t
) _IO_wdefault_pbackfail
),
1081 JUMP_INIT(xsputn
, _IO_wfile_xsputn
),
1082 JUMP_INIT(xsgetn
, _IO_file_xsgetn
),
1083 JUMP_INIT(seekoff
, _IO_wfile_seekoff
),
1084 JUMP_INIT(seekpos
, _IO_default_seekpos
),
1085 JUMP_INIT(setbuf
, _IO_file_setbuf_mmap
),
1086 JUMP_INIT(sync
, (_IO_sync_t
) _IO_wfile_sync
),
1087 JUMP_INIT(doallocate
, _IO_wfile_doallocate
),
1088 JUMP_INIT(read
, _IO_file_read
),
1089 JUMP_INIT(write
, _IO_new_file_write
),
1090 JUMP_INIT(seek
, _IO_file_seek
),
1091 JUMP_INIT(close
, _IO_file_close
),
1092 JUMP_INIT(stat
, _IO_file_stat
),
1093 JUMP_INIT(showmanyc
, _IO_default_showmanyc
),
1094 JUMP_INIT(imbue
, _IO_default_imbue
)