1 /* Copyright (C) 1993-2014 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 <http://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. */
38 # define _IO_new_do_write _IO_do_write
39 # define _IO_new_file_attach _IO_file_attach
40 # define _IO_new_file_close_it _IO_file_close_it
41 # define _IO_new_file_finish _IO_file_finish
42 # define _IO_new_file_fopen _IO_file_fopen
43 # define _IO_new_file_init _IO_file_init
44 # define _IO_new_file_setbuf _IO_file_setbuf
45 # define _IO_new_file_sync _IO_file_sync
46 # define _IO_new_file_overflow _IO_file_overflow
47 # define _IO_new_file_seekoff _IO_file_seekoff
48 # define _IO_new_file_underflow _IO_file_underflow
49 # define _IO_new_file_write _IO_file_write
50 # define _IO_new_file_xsputn _IO_file_xsputn
54 /* Convert TO_DO wide character from DATA to FP.
55 Then mark FP as having empty buffers. */
57 _IO_wdo_write (fp
, data
, to_do
)
62 struct _IO_codecvt
*cc
= fp
->_codecvt
;
66 if (fp
->_IO_write_end
== fp
->_IO_write_ptr
67 && fp
->_IO_write_end
!= fp
->_IO_write_base
)
69 if (_IO_new_do_write (fp
, fp
->_IO_write_base
,
70 fp
->_IO_write_ptr
- fp
->_IO_write_base
) == EOF
)
76 enum __codecvt_result result
;
77 const wchar_t *new_data
;
79 /* Now convert from the internal format into the external buffer. */
80 result
= (*cc
->__codecvt_do_out
) (cc
, &fp
->_wide_data
->_IO_state
,
81 data
, data
+ to_do
, &new_data
,
86 /* Write out what we produced so far. */
87 if (_IO_new_do_write (fp
, fp
->_IO_write_base
,
88 fp
->_IO_write_ptr
- fp
->_IO_write_base
) == EOF
)
89 /* Something went wrong. */
92 to_do
-= new_data
- data
;
94 /* Next see whether we had problems during the conversion. If yes,
96 if (result
!= __codecvt_ok
97 && (result
!= __codecvt_partial
|| new_data
- data
== 0))
105 _IO_wsetg (fp
, fp
->_wide_data
->_IO_buf_base
, fp
->_wide_data
->_IO_buf_base
,
106 fp
->_wide_data
->_IO_buf_base
);
107 fp
->_wide_data
->_IO_write_base
= fp
->_wide_data
->_IO_write_ptr
108 = fp
->_wide_data
->_IO_buf_base
;
109 fp
->_wide_data
->_IO_write_end
= ((fp
->_flags
& (_IO_LINE_BUF
+_IO_UNBUFFERED
))
110 ? fp
->_wide_data
->_IO_buf_base
111 : fp
->_wide_data
->_IO_buf_end
);
113 return to_do
== 0 ? 0 : WEOF
;
115 libc_hidden_def (_IO_wdo_write
)
119 _IO_wfile_underflow (fp
)
122 struct _IO_codecvt
*cd
;
123 enum __codecvt_result status
;
126 if (__glibc_unlikely (fp
->_flags
& _IO_NO_READS
))
128 fp
->_flags
|= _IO_ERR_SEEN
;
132 if (fp
->_wide_data
->_IO_read_ptr
< fp
->_wide_data
->_IO_read_end
)
133 return *fp
->_wide_data
->_IO_read_ptr
;
137 /* Maybe there is something left in the external buffer. */
138 if (fp
->_IO_read_ptr
< fp
->_IO_read_end
)
140 /* There is more in the external. Convert it. */
141 const char *read_stop
= (const char *) fp
->_IO_read_ptr
;
143 fp
->_wide_data
->_IO_last_state
= fp
->_wide_data
->_IO_state
;
144 fp
->_wide_data
->_IO_read_base
= fp
->_wide_data
->_IO_read_ptr
=
145 fp
->_wide_data
->_IO_buf_base
;
146 status
= (*cd
->__codecvt_do_in
) (cd
, &fp
->_wide_data
->_IO_state
,
147 fp
->_IO_read_ptr
, fp
->_IO_read_end
,
149 fp
->_wide_data
->_IO_read_ptr
,
150 fp
->_wide_data
->_IO_buf_end
,
151 &fp
->_wide_data
->_IO_read_end
);
153 fp
->_IO_read_base
= fp
->_IO_read_ptr
;
154 fp
->_IO_read_ptr
= (char *) read_stop
;
156 /* If we managed to generate some text return the next character. */
157 if (fp
->_wide_data
->_IO_read_ptr
< fp
->_wide_data
->_IO_read_end
)
158 return *fp
->_wide_data
->_IO_read_ptr
;
160 if (status
== __codecvt_error
)
162 __set_errno (EILSEQ
);
163 fp
->_flags
|= _IO_ERR_SEEN
;
167 /* Move the remaining content of the read buffer to the beginning. */
168 memmove (fp
->_IO_buf_base
, fp
->_IO_read_ptr
,
169 fp
->_IO_read_end
- fp
->_IO_read_ptr
);
170 fp
->_IO_read_end
= (fp
->_IO_buf_base
171 + (fp
->_IO_read_end
- fp
->_IO_read_ptr
));
172 fp
->_IO_read_base
= fp
->_IO_read_ptr
= fp
->_IO_buf_base
;
175 fp
->_IO_read_base
= fp
->_IO_read_ptr
= fp
->_IO_read_end
=
178 if (fp
->_IO_buf_base
== NULL
)
180 /* Maybe we already have a push back pointer. */
181 if (fp
->_IO_save_base
!= NULL
)
183 free (fp
->_IO_save_base
);
184 fp
->_flags
&= ~_IO_IN_BACKUP
;
188 fp
->_IO_read_base
= fp
->_IO_read_ptr
= fp
->_IO_read_end
=
192 fp
->_IO_write_base
= fp
->_IO_write_ptr
= fp
->_IO_write_end
=
195 if (fp
->_wide_data
->_IO_buf_base
== NULL
)
197 /* Maybe we already have a push back pointer. */
198 if (fp
->_wide_data
->_IO_save_base
!= NULL
)
200 free (fp
->_wide_data
->_IO_save_base
);
201 fp
->_flags
&= ~_IO_IN_BACKUP
;
203 _IO_wdoallocbuf (fp
);
206 /* Flush all line buffered files before reading. */
207 /* FIXME This can/should be moved to genops ?? */
208 if (fp
->_flags
& (_IO_LINE_BUF
|_IO_UNBUFFERED
))
211 _IO_flush_all_linebuffered ();
213 /* We used to flush all line-buffered stream. This really isn't
214 required by any standard. My recollection is that
215 traditional Unix systems did this for stdout. stderr better
216 not be line buffered. So we do just that here
217 explicitly. --drepper */
218 _IO_acquire_lock (_IO_stdout
);
220 if ((_IO_stdout
->_flags
& (_IO_LINKED
| _IO_NO_WRITES
| _IO_LINE_BUF
))
221 == (_IO_LINKED
| _IO_LINE_BUF
))
222 _IO_OVERFLOW (_IO_stdout
, EOF
);
224 _IO_release_lock (_IO_stdout
);
228 _IO_switch_to_get_mode (fp
);
230 fp
->_wide_data
->_IO_read_base
= fp
->_wide_data
->_IO_read_ptr
=
231 fp
->_wide_data
->_IO_buf_base
;
232 fp
->_wide_data
->_IO_read_end
= fp
->_wide_data
->_IO_buf_base
;
233 fp
->_wide_data
->_IO_write_base
= fp
->_wide_data
->_IO_write_ptr
=
234 fp
->_wide_data
->_IO_write_end
= fp
->_wide_data
->_IO_buf_base
;
236 const char *read_ptr_copy
;
237 char accbuf
[MB_LEN_MAX
];
240 count
= _IO_SYSREAD (fp
, fp
->_IO_read_end
,
241 fp
->_IO_buf_end
- fp
->_IO_read_end
);
244 if (count
== 0 && naccbuf
== 0)
245 fp
->_flags
|= _IO_EOF_SEEN
;
247 fp
->_flags
|= _IO_ERR_SEEN
, count
= 0;
249 fp
->_IO_read_end
+= count
;
253 /* There are some bytes in the external buffer but they don't
254 convert to anything. */
255 __set_errno (EILSEQ
);
258 if (fp
->_offset
!= _IO_pos_BAD
)
259 _IO_pos_adjust (fp
->_offset
, count
);
261 /* Now convert the read input. */
262 fp
->_wide_data
->_IO_last_state
= fp
->_wide_data
->_IO_state
;
263 fp
->_IO_read_base
= fp
->_IO_read_ptr
;
264 const char *from
= fp
->_IO_read_ptr
;
265 const char *to
= fp
->_IO_read_end
;
266 size_t to_copy
= count
;
267 if (__glibc_unlikely (naccbuf
!= 0))
269 to_copy
= MIN (sizeof (accbuf
) - naccbuf
, count
);
270 to
= __mempcpy (&accbuf
[naccbuf
], from
, to_copy
);
274 status
= (*cd
->__codecvt_do_in
) (cd
, &fp
->_wide_data
->_IO_state
,
275 from
, to
, &read_ptr_copy
,
276 fp
->_wide_data
->_IO_read_end
,
277 fp
->_wide_data
->_IO_buf_end
,
278 &fp
->_wide_data
->_IO_read_end
);
280 if (__glibc_unlikely (naccbuf
!= 0))
281 fp
->_IO_read_ptr
+= MAX (0, read_ptr_copy
- &accbuf
[naccbuf
- to_copy
]);
283 fp
->_IO_read_ptr
= (char *) read_ptr_copy
;
284 if (fp
->_wide_data
->_IO_read_end
== fp
->_wide_data
->_IO_buf_base
)
286 if (status
== __codecvt_error
)
289 __set_errno (EILSEQ
);
290 fp
->_flags
|= _IO_ERR_SEEN
;
294 /* The read bytes make no complete character. Try reading again. */
295 assert (status
== __codecvt_partial
);
299 if (fp
->_IO_read_base
< fp
->_IO_read_ptr
)
301 /* Partially used the buffer for some input data that
302 produces no output. */
303 size_t avail
= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
304 memmove (fp
->_IO_read_base
, fp
->_IO_read_ptr
, avail
);
305 fp
->_IO_read_ptr
= fp
->_IO_read_base
;
306 fp
->_IO_read_end
-= avail
;
309 naccbuf
= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
310 if (naccbuf
>= sizeof (accbuf
))
313 memcpy (accbuf
, fp
->_IO_read_ptr
, naccbuf
);
317 size_t used
= read_ptr_copy
- accbuf
;
320 memmove (accbuf
, read_ptr_copy
, naccbuf
- used
);
324 if (naccbuf
== sizeof (accbuf
))
328 fp
->_IO_read_ptr
= fp
->_IO_read_end
= fp
->_IO_read_base
;
333 return *fp
->_wide_data
->_IO_read_ptr
;
335 libc_hidden_def (_IO_wfile_underflow
)
339 _IO_wfile_underflow_mmap (_IO_FILE
*fp
)
341 struct _IO_codecvt
*cd
;
342 const char *read_stop
;
344 if (__glibc_unlikely (fp
->_flags
& _IO_NO_READS
))
346 fp
->_flags
|= _IO_ERR_SEEN
;
350 if (fp
->_wide_data
->_IO_read_ptr
< fp
->_wide_data
->_IO_read_end
)
351 return *fp
->_wide_data
->_IO_read_ptr
;
355 /* Maybe there is something left in the external buffer. */
356 if (fp
->_IO_read_ptr
>= fp
->_IO_read_end
357 /* No. But maybe the read buffer is not fully set up. */
358 && _IO_file_underflow_mmap (fp
) == EOF
)
359 /* Nothing available. _IO_file_underflow_mmap has set the EOF or error
360 flags as appropriate. */
363 /* There is more in the external. Convert it. */
364 read_stop
= (const char *) fp
->_IO_read_ptr
;
366 if (fp
->_wide_data
->_IO_buf_base
== NULL
)
368 /* Maybe we already have a push back pointer. */
369 if (fp
->_wide_data
->_IO_save_base
!= NULL
)
371 free (fp
->_wide_data
->_IO_save_base
);
372 fp
->_flags
&= ~_IO_IN_BACKUP
;
374 _IO_wdoallocbuf (fp
);
377 fp
->_wide_data
->_IO_last_state
= fp
->_wide_data
->_IO_state
;
378 fp
->_wide_data
->_IO_read_base
= fp
->_wide_data
->_IO_read_ptr
=
379 fp
->_wide_data
->_IO_buf_base
;
380 (*cd
->__codecvt_do_in
) (cd
, &fp
->_wide_data
->_IO_state
,
381 fp
->_IO_read_ptr
, fp
->_IO_read_end
,
383 fp
->_wide_data
->_IO_read_ptr
,
384 fp
->_wide_data
->_IO_buf_end
,
385 &fp
->_wide_data
->_IO_read_end
);
387 fp
->_IO_read_ptr
= (char *) read_stop
;
389 /* If we managed to generate some text return the next character. */
390 if (fp
->_wide_data
->_IO_read_ptr
< fp
->_wide_data
->_IO_read_end
)
391 return *fp
->_wide_data
->_IO_read_ptr
;
393 /* There is some garbage at the end of the file. */
394 __set_errno (EILSEQ
);
395 fp
->_flags
|= _IO_ERR_SEEN
;
400 _IO_wfile_underflow_maybe_mmap (_IO_FILE
*fp
)
402 /* This is the first read attempt. Doing the underflow will choose mmap
403 or vanilla operations and then punt to the chosen underflow routine.
404 Then we can punt to ours. */
405 if (_IO_file_underflow_maybe_mmap (fp
) == EOF
)
408 return _IO_WUNDERFLOW (fp
);
413 _IO_wfile_overflow (f
, wch
)
417 if (f
->_flags
& _IO_NO_WRITES
) /* SET ERROR */
419 f
->_flags
|= _IO_ERR_SEEN
;
423 /* If currently reading or no buffer allocated. */
424 if ((f
->_flags
& _IO_CURRENTLY_PUTTING
) == 0)
426 /* Allocate a buffer if needed. */
427 if (f
->_wide_data
->_IO_write_base
== 0)
430 _IO_wsetg (f
, f
->_wide_data
->_IO_buf_base
,
431 f
->_wide_data
->_IO_buf_base
, f
->_wide_data
->_IO_buf_base
);
433 if (f
->_IO_write_base
== NULL
)
436 _IO_setg (f
, f
->_IO_buf_base
, f
->_IO_buf_base
, f
->_IO_buf_base
);
441 /* Otherwise must be currently reading. If _IO_read_ptr
442 (and hence also _IO_read_end) is at the buffer end,
443 logically slide the buffer forwards one block (by setting
444 the read pointers to all point at the beginning of the
445 block). This makes room for subsequent output.
446 Otherwise, set the read pointers to _IO_read_end (leaving
447 that alone, so it can continue to correspond to the
448 external position). */
449 if (f
->_wide_data
->_IO_read_ptr
== f
->_wide_data
->_IO_buf_end
)
451 f
->_IO_read_end
= f
->_IO_read_ptr
= f
->_IO_buf_base
;
452 f
->_wide_data
->_IO_read_end
= f
->_wide_data
->_IO_read_ptr
=
453 f
->_wide_data
->_IO_buf_base
;
456 f
->_wide_data
->_IO_write_ptr
= f
->_wide_data
->_IO_read_ptr
;
457 f
->_wide_data
->_IO_write_base
= f
->_wide_data
->_IO_write_ptr
;
458 f
->_wide_data
->_IO_write_end
= f
->_wide_data
->_IO_buf_end
;
459 f
->_wide_data
->_IO_read_base
= f
->_wide_data
->_IO_read_ptr
=
460 f
->_wide_data
->_IO_read_end
;
462 f
->_IO_write_ptr
= f
->_IO_read_ptr
;
463 f
->_IO_write_base
= f
->_IO_write_ptr
;
464 f
->_IO_write_end
= f
->_IO_buf_end
;
465 f
->_IO_read_base
= f
->_IO_read_ptr
= f
->_IO_read_end
;
467 f
->_flags
|= _IO_CURRENTLY_PUTTING
;
468 if (f
->_flags
& (_IO_LINE_BUF
+_IO_UNBUFFERED
))
469 f
->_wide_data
->_IO_write_end
= f
->_wide_data
->_IO_write_ptr
;
472 return _IO_do_flush (f
);
473 if (f
->_wide_data
->_IO_write_ptr
== f
->_wide_data
->_IO_buf_end
)
474 /* Buffer is really full */
475 if (_IO_do_flush (f
) == EOF
)
477 *f
->_wide_data
->_IO_write_ptr
++ = wch
;
478 if ((f
->_flags
& _IO_UNBUFFERED
)
479 || ((f
->_flags
& _IO_LINE_BUF
) && wch
== L
'\n'))
480 if (_IO_do_flush (f
) == EOF
)
484 libc_hidden_def (_IO_wfile_overflow
)
493 /* char* ptr = cur_ptr(); */
494 if (fp
->_wide_data
->_IO_write_ptr
> fp
->_wide_data
->_IO_write_base
)
495 if (_IO_do_flush (fp
))
497 delta
= fp
->_wide_data
->_IO_read_ptr
- fp
->_wide_data
->_IO_read_end
;
500 /* We have to find out how many bytes we have to go back in the
502 struct _IO_codecvt
*cv
= fp
->_codecvt
;
505 int clen
= (*cv
->__codecvt_do_encoding
) (cv
);
508 /* It is easy, a fixed number of input bytes are used for each
513 /* We have to find out the hard way how much to back off.
514 To do this we determine how much input we needed to
515 generate the wide characters up to the current reading
519 fp
->_wide_data
->_IO_state
= fp
->_wide_data
->_IO_last_state
;
520 nread
= (*cv
->__codecvt_do_length
) (cv
, &fp
->_wide_data
->_IO_state
,
522 fp
->_IO_read_end
, delta
);
523 fp
->_IO_read_ptr
= fp
->_IO_read_base
+ nread
;
524 delta
= -(fp
->_IO_read_end
- fp
->_IO_read_base
- nread
);
527 new_pos
= _IO_SYSSEEK (fp
, delta
, 1);
528 if (new_pos
!= (_IO_off64_t
) EOF
)
530 fp
->_wide_data
->_IO_read_end
= fp
->_wide_data
->_IO_read_ptr
;
531 fp
->_IO_read_end
= fp
->_IO_read_ptr
;
534 else if (errno
== ESPIPE
)
535 ; /* Ignore error from unseekable devices. */
541 fp
->_offset
= _IO_pos_BAD
;
542 /* FIXME: Cleanup - can this be shared? */
543 /* setg(base(), ptr, ptr); */
546 libc_hidden_def (_IO_wfile_sync
)
548 /* Adjust the internal buffer pointers to reflect the state in the external
549 buffer. The content between fp->_IO_read_base and fp->_IO_read_ptr is
550 assumed to be converted and available in the range
551 fp->_wide_data->_IO_read_base and fp->_wide_data->_IO_read_end.
553 Returns 0 on success and -1 on error with the _IO_ERR_SEEN flag set. */
555 adjust_wide_data (_IO_FILE
*fp
, bool do_convert
)
557 struct _IO_codecvt
*cv
= fp
->_codecvt
;
559 int clen
= (*cv
->__codecvt_do_encoding
) (cv
);
561 /* Take the easy way out for constant length encodings if we don't need to
563 if (!do_convert
&& clen
> 0)
565 fp
->_wide_data
->_IO_read_end
+= ((fp
->_IO_read_ptr
- fp
->_IO_read_base
)
570 enum __codecvt_result status
;
571 const char *read_stop
= (const char *) fp
->_IO_read_base
;
575 fp
->_wide_data
->_IO_last_state
= fp
->_wide_data
->_IO_state
;
576 status
= (*cv
->__codecvt_do_in
) (cv
, &fp
->_wide_data
->_IO_state
,
577 fp
->_IO_read_base
, fp
->_IO_read_ptr
,
579 fp
->_wide_data
->_IO_read_base
,
580 fp
->_wide_data
->_IO_buf_end
,
581 &fp
->_wide_data
->_IO_read_end
);
583 /* Should we return EILSEQ? */
584 if (__glibc_unlikely (status
== __codecvt_error
))
586 fp
->_flags
|= _IO_ERR_SEEN
;
590 while (__builtin_expect (status
== __codecvt_partial
, 0));
593 /* Now seek to _IO_read_end to behave as if we have read it all in. */
594 fp
->_wide_data
->_IO_read_ptr
= fp
->_wide_data
->_IO_read_end
;
599 /* ftell{,o} implementation for wide mode. Don't modify any state of the file
600 pointer while we try to get the current state of the stream except in one
601 case, which is when we have unflushed writes in append mode. */
603 do_ftell_wide (_IO_FILE
*fp
)
605 _IO_off64_t result
, offset
= 0;
607 /* No point looking for offsets in the buffer if it hasn't even been
609 if (fp
->_wide_data
->_IO_buf_base
!= NULL
)
611 const wchar_t *wide_read_base
;
612 const wchar_t *wide_read_ptr
;
613 const wchar_t *wide_read_end
;
614 bool was_writing
= ((fp
->_wide_data
->_IO_write_ptr
615 > fp
->_wide_data
->_IO_write_base
)
616 || _IO_in_put_mode (fp
));
618 bool append_mode
= (fp
->_flags
& _IO_IS_APPENDING
) == _IO_IS_APPENDING
;
620 /* When we have unflushed writes in append mode, seek to the end of the
621 file and record that offset. This is the only time we change the file
622 stream state and it is safe since the file handle is active. */
623 if (was_writing
&& append_mode
)
625 result
= _IO_SYSSEEK (fp
, 0, _IO_seek_end
);
626 if (result
== _IO_pos_BAD
)
629 fp
->_offset
= result
;
632 /* XXX For wide stream with backup store it is not very
633 reasonable to determine the offset. The pushed-back
634 character might require a state change and we need not be
635 able to compute the initial state by reverse transformation
636 since there is no guarantee of symmetry. So we don't even
637 try and return an error. */
638 if (_IO_in_backup (fp
))
640 if (fp
->_wide_data
->_IO_read_ptr
< fp
->_wide_data
->_IO_read_end
)
642 __set_errno (EINVAL
);
646 /* Nothing in the backup store, so note the backed up pointers
647 without changing the state. */
648 wide_read_base
= fp
->_wide_data
->_IO_save_base
;
649 wide_read_ptr
= wide_read_base
;
650 wide_read_end
= fp
->_wide_data
->_IO_save_end
;
654 wide_read_base
= fp
->_wide_data
->_IO_read_base
;
655 wide_read_ptr
= fp
->_wide_data
->_IO_read_ptr
;
656 wide_read_end
= fp
->_wide_data
->_IO_read_end
;
659 struct _IO_codecvt
*cv
= fp
->_codecvt
;
660 int clen
= (*cv
->__codecvt_do_encoding
) (cv
);
666 offset
-= (wide_read_end
- wide_read_ptr
) * clen
;
667 offset
-= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
673 size_t delta
= wide_read_ptr
- wide_read_base
;
674 __mbstate_t state
= fp
->_wide_data
->_IO_last_state
;
675 nread
= (*cv
->__codecvt_do_length
) (cv
, &state
,
677 fp
->_IO_read_end
, delta
);
678 offset
-= fp
->_IO_read_end
- fp
->_IO_read_base
- nread
;
684 offset
+= (fp
->_wide_data
->_IO_write_ptr
685 - fp
->_wide_data
->_IO_write_base
) * clen
;
688 size_t delta
= (fp
->_wide_data
->_IO_write_ptr
689 - fp
->_wide_data
->_IO_write_base
);
691 /* Allocate enough space for the conversion. */
692 size_t outsize
= delta
* sizeof (wchar_t);
693 char *out
= malloc (outsize
);
695 const wchar_t *in
= fp
->_wide_data
->_IO_write_base
;
697 enum __codecvt_result status
;
699 __mbstate_t state
= fp
->_wide_data
->_IO_last_state
;
700 status
= (*cv
->__codecvt_do_out
) (cv
, &state
,
702 out
, out
+ outsize
, &outstop
);
704 /* We don't check for __codecvt_partial because it can be
705 returned on one of two conditions: either the output
706 buffer is full or the input sequence is incomplete. We
707 take care to allocate enough buffer and our input
708 sequences must be complete since they are accepted as
709 wchar_t; if not, then that is an error. */
710 if (__glibc_unlikely (status
!= __codecvt_ok
))
713 offset
+= outstop
- out
;
717 /* We don't trust _IO_read_end to represent the current file offset
718 when writing in append mode because the value would have to be
719 shifted to the end of the file during a flush. Use the write base
720 instead, along with the new offset we got above when we did a seek
721 to the end of the file. */
723 offset
+= fp
->_IO_write_ptr
- fp
->_IO_write_base
;
724 /* For all other modes, _IO_read_end represents the file offset. */
726 offset
+= fp
->_IO_write_ptr
- fp
->_IO_read_end
;
730 if (fp
->_offset
!= _IO_pos_BAD
)
731 result
= fp
->_offset
;
733 result
= _IO_SYSSEEK (fp
, 0, _IO_seek_cur
);
742 __set_errno (EINVAL
);
750 _IO_wfile_seekoff (fp
, offset
, dir
, mode
)
757 _IO_off64_t delta
, new_offset
;
760 /* Short-circuit into a separate function. We don't want to mix any
761 functionality and we don't want to touch anything inside the FILE
764 return do_ftell_wide (fp
);
766 /* POSIX.1 8.2.3.7 says that after a call the fflush() the file
767 offset of the underlying file must be exact. */
768 int must_be_exact
= ((fp
->_wide_data
->_IO_read_base
769 == fp
->_wide_data
->_IO_read_end
)
770 && (fp
->_wide_data
->_IO_write_base
771 == fp
->_wide_data
->_IO_write_ptr
));
773 bool was_writing
= ((fp
->_wide_data
->_IO_write_ptr
774 > fp
->_wide_data
->_IO_write_base
)
775 || _IO_in_put_mode (fp
));
777 /* Flush unwritten characters.
778 (This may do an unneeded write if we seek within the buffer.
779 But to be able to switch to reading, we would need to set
780 egptr to pptr. That can't be done in the current design,
781 which assumes file_ptr() is eGptr. Anyway, since we probably
782 end up flushing when we close(), it doesn't make much difference.)
783 FIXME: simulate mem-mapped files. */
784 if (was_writing
&& _IO_switch_to_wget_mode (fp
))
787 if (fp
->_wide_data
->_IO_buf_base
== NULL
)
789 /* It could be that we already have a pushback buffer. */
790 if (fp
->_wide_data
->_IO_read_base
!= NULL
)
792 free (fp
->_wide_data
->_IO_read_base
);
793 fp
->_flags
&= ~_IO_IN_BACKUP
;
796 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
797 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
798 _IO_wsetp (fp
, fp
->_wide_data
->_IO_buf_base
,
799 fp
->_wide_data
->_IO_buf_base
);
800 _IO_wsetg (fp
, fp
->_wide_data
->_IO_buf_base
,
801 fp
->_wide_data
->_IO_buf_base
, fp
->_wide_data
->_IO_buf_base
);
806 struct _IO_codecvt
*cv
;
810 /* Adjust for read-ahead (bytes is buffer). To do this we must
811 find out which position in the external buffer corresponds to
812 the current position in the internal buffer. */
814 clen
= (*cv
->__codecvt_do_encoding
) (cv
);
816 if (mode
!= 0 || !was_writing
)
820 offset
-= (fp
->_wide_data
->_IO_read_end
821 - fp
->_wide_data
->_IO_read_ptr
) * clen
;
822 /* Adjust by readahead in external buffer. */
823 offset
-= fp
->_IO_read_end
- fp
->_IO_read_ptr
;
829 delta
= (fp
->_wide_data
->_IO_read_ptr
830 - fp
->_wide_data
->_IO_read_base
);
831 fp
->_wide_data
->_IO_state
= fp
->_wide_data
->_IO_last_state
;
832 nread
= (*cv
->__codecvt_do_length
) (cv
,
833 &fp
->_wide_data
->_IO_state
,
835 fp
->_IO_read_end
, delta
);
836 fp
->_IO_read_ptr
= fp
->_IO_read_base
+ nread
;
837 fp
->_wide_data
->_IO_read_end
= fp
->_wide_data
->_IO_read_ptr
;
838 offset
-= fp
->_IO_read_end
- fp
->_IO_read_base
- nread
;
842 if (fp
->_offset
== _IO_pos_BAD
)
845 /* Make offset absolute, assuming current pointer is file_ptr(). */
846 offset
+= fp
->_offset
;
855 if (_IO_SYSSTAT (fp
, &st
) == 0 && S_ISREG (st
.st_mode
))
857 offset
+= st
.st_size
;
864 /* At this point, dir==_IO_seek_set. */
866 /* If destination is within current buffer, optimize: */
867 if (fp
->_offset
!= _IO_pos_BAD
&& fp
->_IO_read_base
!= NULL
868 && !_IO_in_backup (fp
))
870 _IO_off64_t start_offset
= (fp
->_offset
871 - (fp
->_IO_read_end
- fp
->_IO_buf_base
));
872 if (offset
>= start_offset
&& offset
< fp
->_offset
)
874 _IO_setg (fp
, fp
->_IO_buf_base
,
875 fp
->_IO_buf_base
+ (offset
- start_offset
),
877 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
878 _IO_wsetg (fp
, fp
->_wide_data
->_IO_buf_base
,
879 fp
->_wide_data
->_IO_buf_base
,
880 fp
->_wide_data
->_IO_buf_base
);
881 _IO_wsetp (fp
, fp
->_wide_data
->_IO_buf_base
,
882 fp
->_wide_data
->_IO_buf_base
);
884 if (adjust_wide_data (fp
, false))
887 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
892 if (fp
->_flags
& _IO_NO_READS
)
895 /* Try to seek to a block boundary, to improve kernel page management. */
896 new_offset
= offset
& ~(fp
->_IO_buf_end
- fp
->_IO_buf_base
- 1);
897 delta
= offset
- new_offset
;
898 if (delta
> fp
->_IO_buf_end
- fp
->_IO_buf_base
)
903 result
= _IO_SYSSEEK (fp
, new_offset
, 0);
910 count
= _IO_SYSREAD (fp
, fp
->_IO_buf_base
,
912 ? delta
: fp
->_IO_buf_end
- fp
->_IO_buf_base
));
915 /* We weren't allowed to read, but try to seek the remainder. */
916 offset
= count
== EOF
? delta
: delta
-count
;
921 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
+ delta
,
922 fp
->_IO_buf_base
+ count
);
923 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
924 _IO_wsetg (fp
, fp
->_wide_data
->_IO_buf_base
,
925 fp
->_wide_data
->_IO_buf_base
, fp
->_wide_data
->_IO_buf_base
);
926 _IO_wsetp (fp
, fp
->_wide_data
->_IO_buf_base
, fp
->_wide_data
->_IO_buf_base
);
928 if (adjust_wide_data (fp
, true))
931 fp
->_offset
= result
+ count
;
932 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
936 _IO_unsave_markers (fp
);
937 result
= _IO_SYSSEEK (fp
, offset
, dir
);
940 _IO_mask_flags (fp
, 0, _IO_EOF_SEEN
);
941 fp
->_offset
= result
;
942 _IO_setg (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
943 _IO_setp (fp
, fp
->_IO_buf_base
, fp
->_IO_buf_base
);
944 _IO_wsetg (fp
, fp
->_wide_data
->_IO_buf_base
,
945 fp
->_wide_data
->_IO_buf_base
, fp
->_wide_data
->_IO_buf_base
);
946 _IO_wsetp (fp
, fp
->_wide_data
->_IO_buf_base
,
947 fp
->_wide_data
->_IO_buf_base
);
952 /* We need to do it since it is possible that the file offset in
953 the kernel may be changed behind our back. It may happen when
954 we fopen a file and then do a fork. One process may access the
955 file and the kernel file offset will be changed. */
956 if (fp
->_offset
>= 0)
957 _IO_SYSSEEK (fp
, fp
->_offset
, 0);
961 libc_hidden_def (_IO_wfile_seekoff
)
965 _IO_wfile_xsputn (f
, data
, n
)
970 const wchar_t *s
= (const wchar_t *) data
;
971 _IO_size_t to_do
= n
;
977 /* This is an optimized implementation.
978 If the amount to be written straddles a block boundary
979 (or the filebuf is unbuffered), use sys_write directly. */
981 /* First figure out how much space is available in the buffer. */
982 count
= f
->_wide_data
->_IO_write_end
- f
->_wide_data
->_IO_write_ptr
;
983 if ((f
->_flags
& _IO_LINE_BUF
) && (f
->_flags
& _IO_CURRENTLY_PUTTING
))
985 count
= f
->_wide_data
->_IO_buf_end
- f
->_wide_data
->_IO_write_ptr
;
989 for (p
= s
+ n
; p
> s
; )
1000 /* Then fill the buffer. */
1008 f
->_wide_data
->_IO_write_ptr
=
1009 __wmempcpy (f
->_wide_data
->_IO_write_ptr
, s
, count
);
1011 wmemcpy (f
->_wide_data
->_IO_write_ptr
, s
, count
);
1012 f
->_wide_data
->_IO_write_ptr
+= count
;
1018 wchar_t *p
= f
->_wide_data
->_IO_write_ptr
;
1019 int i
= (int) count
;
1022 f
->_wide_data
->_IO_write_ptr
= p
;
1027 to_do
-= _IO_wdefault_xsputn (f
, s
, to_do
);
1029 && f
->_wide_data
->_IO_write_ptr
!= f
->_wide_data
->_IO_write_base
)
1030 _IO_wdo_write (f
, f
->_wide_data
->_IO_write_base
,
1031 f
->_wide_data
->_IO_write_ptr
1032 - f
->_wide_data
->_IO_write_base
);
1036 libc_hidden_def (_IO_wfile_xsputn
)
1039 const struct _IO_jump_t _IO_wfile_jumps
=
1042 JUMP_INIT(finish
, _IO_new_file_finish
),
1043 JUMP_INIT(overflow
, (_IO_overflow_t
) _IO_wfile_overflow
),
1044 JUMP_INIT(underflow
, (_IO_underflow_t
) _IO_wfile_underflow
),
1045 JUMP_INIT(uflow
, (_IO_underflow_t
) _IO_wdefault_uflow
),
1046 JUMP_INIT(pbackfail
, (_IO_pbackfail_t
) _IO_wdefault_pbackfail
),
1047 JUMP_INIT(xsputn
, _IO_wfile_xsputn
),
1048 JUMP_INIT(xsgetn
, _IO_file_xsgetn
),
1049 JUMP_INIT(seekoff
, _IO_wfile_seekoff
),
1050 JUMP_INIT(seekpos
, _IO_default_seekpos
),
1051 JUMP_INIT(setbuf
, _IO_new_file_setbuf
),
1052 JUMP_INIT(sync
, (_IO_sync_t
) _IO_wfile_sync
),
1053 JUMP_INIT(doallocate
, _IO_wfile_doallocate
),
1054 JUMP_INIT(read
, _IO_file_read
),
1055 JUMP_INIT(write
, _IO_new_file_write
),
1056 JUMP_INIT(seek
, _IO_file_seek
),
1057 JUMP_INIT(close
, _IO_file_close
),
1058 JUMP_INIT(stat
, _IO_file_stat
),
1059 JUMP_INIT(showmanyc
, _IO_default_showmanyc
),
1060 JUMP_INIT(imbue
, _IO_default_imbue
)
1062 libc_hidden_data_def (_IO_wfile_jumps
)
1065 const struct _IO_jump_t _IO_wfile_jumps_mmap
=
1068 JUMP_INIT(finish
, _IO_new_file_finish
),
1069 JUMP_INIT(overflow
, (_IO_overflow_t
) _IO_wfile_overflow
),
1070 JUMP_INIT(underflow
, (_IO_underflow_t
) _IO_wfile_underflow_mmap
),
1071 JUMP_INIT(uflow
, (_IO_underflow_t
) _IO_wdefault_uflow
),
1072 JUMP_INIT(pbackfail
, (_IO_pbackfail_t
) _IO_wdefault_pbackfail
),
1073 JUMP_INIT(xsputn
, _IO_wfile_xsputn
),
1074 JUMP_INIT(xsgetn
, _IO_file_xsgetn
),
1075 JUMP_INIT(seekoff
, _IO_wfile_seekoff
),
1076 JUMP_INIT(seekpos
, _IO_default_seekpos
),
1077 JUMP_INIT(setbuf
, _IO_file_setbuf_mmap
),
1078 JUMP_INIT(sync
, (_IO_sync_t
) _IO_wfile_sync
),
1079 JUMP_INIT(doallocate
, _IO_wfile_doallocate
),
1080 JUMP_INIT(read
, _IO_file_read
),
1081 JUMP_INIT(write
, _IO_new_file_write
),
1082 JUMP_INIT(seek
, _IO_file_seek
),
1083 JUMP_INIT(close
, _IO_file_close_mmap
),
1084 JUMP_INIT(stat
, _IO_file_stat
),
1085 JUMP_INIT(showmanyc
, _IO_default_showmanyc
),
1086 JUMP_INIT(imbue
, _IO_default_imbue
)
1089 const struct _IO_jump_t _IO_wfile_jumps_maybe_mmap
=
1092 JUMP_INIT(finish
, _IO_new_file_finish
),
1093 JUMP_INIT(overflow
, (_IO_overflow_t
) _IO_wfile_overflow
),
1094 JUMP_INIT(underflow
, (_IO_underflow_t
) _IO_wfile_underflow_maybe_mmap
),
1095 JUMP_INIT(uflow
, (_IO_underflow_t
) _IO_wdefault_uflow
),
1096 JUMP_INIT(pbackfail
, (_IO_pbackfail_t
) _IO_wdefault_pbackfail
),
1097 JUMP_INIT(xsputn
, _IO_wfile_xsputn
),
1098 JUMP_INIT(xsgetn
, _IO_file_xsgetn
),
1099 JUMP_INIT(seekoff
, _IO_wfile_seekoff
),
1100 JUMP_INIT(seekpos
, _IO_default_seekpos
),
1101 JUMP_INIT(setbuf
, _IO_file_setbuf_mmap
),
1102 JUMP_INIT(sync
, (_IO_sync_t
) _IO_wfile_sync
),
1103 JUMP_INIT(doallocate
, _IO_wfile_doallocate
),
1104 JUMP_INIT(read
, _IO_file_read
),
1105 JUMP_INIT(write
, _IO_new_file_write
),
1106 JUMP_INIT(seek
, _IO_file_seek
),
1107 JUMP_INIT(close
, _IO_file_close
),
1108 JUMP_INIT(stat
, _IO_file_stat
),
1109 JUMP_INIT(showmanyc
, _IO_default_showmanyc
),
1110 JUMP_INIT(imbue
, _IO_default_imbue
)