1 /* Skeleton for a conversion module.
2 Copyright (C) 1998-2022 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <https://www.gnu.org/licenses/>. */
19 /* This file can be included to provide definitions of several things
20 many modules have in common. It can be customized using the following
23 DEFINE_INIT define the default initializer. This requires the
24 following symbol to be defined.
26 CHARSET_NAME string with official name of the coded character
29 DEFINE_FINI define the default destructor function.
31 MIN_NEEDED_FROM minimal number of bytes needed for the from-charset.
32 MIN_NEEDED_TO likewise for the to-charset.
34 MAX_NEEDED_FROM maximal number of bytes needed for the from-charset.
35 This macro is optional, it defaults to MIN_NEEDED_FROM.
36 MAX_NEEDED_TO likewise for the to-charset.
38 FROM_LOOP_MIN_NEEDED_FROM
39 FROM_LOOP_MAX_NEEDED_FROM
40 minimal/maximal number of bytes needed on input
41 of one round through the FROM_LOOP. Defaults
42 to MIN_NEEDED_FROM and MAX_NEEDED_FROM, respectively.
43 FROM_LOOP_MIN_NEEDED_TO
44 FROM_LOOP_MAX_NEEDED_TO
45 minimal/maximal number of bytes needed on output
46 of one round through the FROM_LOOP. Defaults
47 to MIN_NEEDED_TO and MAX_NEEDED_TO, respectively.
48 TO_LOOP_MIN_NEEDED_FROM
49 TO_LOOP_MAX_NEEDED_FROM
50 minimal/maximal number of bytes needed on input
51 of one round through the TO_LOOP. Defaults
52 to MIN_NEEDED_TO and MAX_NEEDED_TO, respectively.
55 minimal/maximal number of bytes needed on output
56 of one round through the TO_LOOP. Defaults
57 to MIN_NEEDED_FROM and MAX_NEEDED_FROM, respectively.
59 FROM_DIRECTION this macro is supposed to return a value != 0
60 if we convert from the current character set,
61 otherwise it return 0.
63 EMIT_SHIFT_TO_INIT this symbol is optional. If it is defined it
64 defines some code which writes out a sequence
65 of bytes which bring the current state into
68 FROM_LOOP name of the function implementing the conversion
69 from the current character set.
70 TO_LOOP likewise for the other direction
72 ONE_DIRECTION optional. If defined to 1, only one conversion
73 direction is defined instead of two. In this
74 case, FROM_DIRECTION should be defined to 1, and
75 FROM_LOOP and TO_LOOP should have the same value.
77 SAVE_RESET_STATE in case of an error we must reset the state for
78 the rerun so this macro must be defined for
79 stateful encodings. It takes an argument which
80 is nonzero when saving.
82 RESET_INPUT_BUFFER If the input character sets allow this the macro
83 can be defined to reset the input buffer pointers
84 to cover only those characters up to the error.
85 Note that if the conversion has skipped over
86 irreversible characters (due to
87 __GCONV_IGNORE_ERRORS) there is no longer a direct
88 correspondence between input and output pointers,
89 and this macro is not called.
91 FUNCTION_NAME if not set the conversion function is named `gconv'.
93 PREPARE_LOOP optional code preparing the conversion loop. Can
94 contain variable definitions.
95 END_LOOP also optional, may be used to store information
97 EXTRA_LOOP_ARGS optional macro specifying extra arguments passed
100 STORE_REST optional, needed only when MAX_NEEDED_FROM > 4.
101 This macro stores the seen but unconverted input bytes
104 FROM_ONEBYTE optional. If defined, should be the name of a
105 specialized conversion function for a single byte
106 from the current character set to INTERNAL. This
107 function has prototype
109 FROM_ONEBYTE (struct __gconv_step *, unsigned char);
110 and does a special conversion:
111 - The input is a single byte.
112 - The output is a single uint32_t.
113 - The state before the conversion is the initial state;
114 the state after the conversion is irrelevant.
115 - No transliteration.
116 - __invocation_counter = 0.
117 - __internal_use = 1.
120 Modules can use mbstate_t to store conversion state as follows:
122 * Bits 2..0 of '__count' contain the number of lookahead input bytes
123 stored in __value.__wchb. Always zero if the converter never
124 returns __GCONV_INCOMPLETE_INPUT.
126 * Bits 31..3 of '__count' are module dependent shift state.
128 * __value: When STORE_REST/UNPACK_BYTES aren't defined and when the
129 converter has returned __GCONV_INCOMPLETE_INPUT, this contains
130 at most 4 lookahead bytes. Converters with an mb_cur_max > 4
131 (currently only UTF-8) must find a way to store their state
132 in __value.__wch and define STORE_REST/UNPACK_BYTES appropriately.
134 When __value contains lookahead, __count must not be zero, because
135 the converter is not in the initial state then, and mbsinit() --
136 defined as a (__count == 0) test -- must reflect this.
140 #include <iconv/gconv_int.h>
142 #define __need_size_t
150 #include <pointer_guard.h>
154 # define DL_CALL_FCT(fct, args) fct args
157 /* The direction objects. */
159 # ifndef FROM_DIRECTION
160 # define FROM_DIRECTION_VAL NULL
161 # define TO_DIRECTION_VAL ((void *) ~((uintptr_t) 0))
162 # define FROM_DIRECTION (step->__data == FROM_DIRECTION_VAL)
165 # ifndef FROM_DIRECTION
166 # error "FROM_DIRECTION must be provided if non-default init is used"
170 /* How many bytes are needed at most for the from-charset. */
171 #ifndef MAX_NEEDED_FROM
172 # define MAX_NEEDED_FROM MIN_NEEDED_FROM
175 /* Same for the to-charset. */
176 #ifndef MAX_NEEDED_TO
177 # define MAX_NEEDED_TO MIN_NEEDED_TO
180 /* Defaults for the per-direction min/max constants. */
181 #ifndef FROM_LOOP_MIN_NEEDED_FROM
182 # define FROM_LOOP_MIN_NEEDED_FROM MIN_NEEDED_FROM
184 #ifndef FROM_LOOP_MAX_NEEDED_FROM
185 # define FROM_LOOP_MAX_NEEDED_FROM MAX_NEEDED_FROM
187 #ifndef FROM_LOOP_MIN_NEEDED_TO
188 # define FROM_LOOP_MIN_NEEDED_TO MIN_NEEDED_TO
190 #ifndef FROM_LOOP_MAX_NEEDED_TO
191 # define FROM_LOOP_MAX_NEEDED_TO MAX_NEEDED_TO
193 #ifndef TO_LOOP_MIN_NEEDED_FROM
194 # define TO_LOOP_MIN_NEEDED_FROM MIN_NEEDED_TO
196 #ifndef TO_LOOP_MAX_NEEDED_FROM
197 # define TO_LOOP_MAX_NEEDED_FROM MAX_NEEDED_TO
199 #ifndef TO_LOOP_MIN_NEEDED_TO
200 # define TO_LOOP_MIN_NEEDED_TO MIN_NEEDED_FROM
202 #ifndef TO_LOOP_MAX_NEEDED_TO
203 # define TO_LOOP_MAX_NEEDED_TO MAX_NEEDED_FROM
207 /* Define macros which can access unaligned buffers. These macros are
208 supposed to be used only in code outside the inner loops. For the inner
209 loops we have other definitions which allow optimized access. */
210 #if _STRING_ARCH_unaligned
211 /* We can handle unaligned memory access. */
212 # define get16u(addr) *((const uint16_t *) (addr))
213 # define get32u(addr) *((const uint32_t *) (addr))
215 /* We need no special support for writing values either. */
216 # define put16u(addr, val) *((uint16_t *) (addr)) = (val)
217 # define put32u(addr, val) *((uint32_t *) (addr)) = (val)
219 /* Distinguish between big endian and little endian. */
220 # if __BYTE_ORDER == __LITTLE_ENDIAN
221 # define get16u(addr) \
222 (((const unsigned char *) (addr))[1] << 8 \
223 | ((const unsigned char *) (addr))[0])
224 # define get32u(addr) \
225 (((((const unsigned char *) (addr))[3] << 8 \
226 | ((const unsigned char *) (addr))[2]) << 8 \
227 | ((const unsigned char *) (addr))[1]) << 8 \
228 | ((const unsigned char *) (addr))[0])
230 # define put16u(addr, val) \
231 ({ uint16_t __val = (val); \
232 ((unsigned char *) (addr))[0] = __val; \
233 ((unsigned char *) (addr))[1] = __val >> 8; \
235 # define put32u(addr, val) \
236 ({ uint32_t __val = (val); \
237 ((unsigned char *) (addr))[0] = __val; \
239 ((unsigned char *) (addr))[1] = __val; \
241 ((unsigned char *) (addr))[2] = __val; \
243 ((unsigned char *) (addr))[3] = __val; \
246 # define get16u(addr) \
247 (((const unsigned char *) (addr))[0] << 8 \
248 | ((const unsigned char *) (addr))[1])
249 # define get32u(addr) \
250 (((((const unsigned char *) (addr))[0] << 8 \
251 | ((const unsigned char *) (addr))[1]) << 8 \
252 | ((const unsigned char *) (addr))[2]) << 8 \
253 | ((const unsigned char *) (addr))[3])
255 # define put16u(addr, val) \
256 ({ uint16_t __val = (val); \
257 ((unsigned char *) (addr))[1] = __val; \
258 ((unsigned char *) (addr))[0] = __val >> 8; \
260 # define put32u(addr, val) \
261 ({ uint32_t __val = (val); \
262 ((unsigned char *) (addr))[3] = __val; \
264 ((unsigned char *) (addr))[2] = __val; \
266 ((unsigned char *) (addr))[1] = __val; \
268 ((unsigned char *) (addr))[0] = __val; \
274 /* For conversions from a fixed width character set to another fixed width
275 character set we can define RESET_INPUT_BUFFER in a very fast way. */
276 #if !defined RESET_INPUT_BUFFER && !defined SAVE_RESET_STATE
277 # if FROM_LOOP_MIN_NEEDED_FROM == FROM_LOOP_MAX_NEEDED_FROM \
278 && FROM_LOOP_MIN_NEEDED_TO == FROM_LOOP_MAX_NEEDED_TO \
279 && TO_LOOP_MIN_NEEDED_FROM == TO_LOOP_MAX_NEEDED_FROM \
280 && TO_LOOP_MIN_NEEDED_TO == TO_LOOP_MAX_NEEDED_TO
281 /* We have to use these `if's here since the compiler cannot know that
282 (outbuf - outerr) is always divisible by FROM/TO_LOOP_MIN_NEEDED_TO.
283 The ?:1 avoids division by zero warnings that gcc 3.2 emits even for
284 obviously unreachable code. */
285 # define RESET_INPUT_BUFFER \
286 if (FROM_DIRECTION) \
288 if (FROM_LOOP_MIN_NEEDED_FROM % FROM_LOOP_MIN_NEEDED_TO == 0) \
289 *inptrp -= (outbuf - outerr) \
290 * (FROM_LOOP_MIN_NEEDED_FROM / FROM_LOOP_MIN_NEEDED_TO); \
291 else if (FROM_LOOP_MIN_NEEDED_TO % FROM_LOOP_MIN_NEEDED_FROM == 0) \
292 *inptrp -= (outbuf - outerr) \
293 / (FROM_LOOP_MIN_NEEDED_TO / FROM_LOOP_MIN_NEEDED_FROM \
296 *inptrp -= ((outbuf - outerr) / FROM_LOOP_MIN_NEEDED_TO) \
297 * FROM_LOOP_MIN_NEEDED_FROM; \
301 if (TO_LOOP_MIN_NEEDED_FROM % TO_LOOP_MIN_NEEDED_TO == 0) \
302 *inptrp -= (outbuf - outerr) \
303 * (TO_LOOP_MIN_NEEDED_FROM / TO_LOOP_MIN_NEEDED_TO); \
304 else if (TO_LOOP_MIN_NEEDED_TO % TO_LOOP_MIN_NEEDED_FROM == 0) \
305 *inptrp -= (outbuf - outerr) \
306 / (TO_LOOP_MIN_NEEDED_TO / TO_LOOP_MIN_NEEDED_FROM ? : 1); \
308 *inptrp -= ((outbuf - outerr) / TO_LOOP_MIN_NEEDED_TO) \
309 * TO_LOOP_MIN_NEEDED_FROM; \
315 /* The default init function. It simply matches the name and initializes
316 the step data to point to one of the objects above. */
318 # ifndef CHARSET_NAME
319 # error "CHARSET_NAME not defined"
322 extern int gconv_init (struct __gconv_step
*step
);
324 gconv_init (struct __gconv_step
*step
)
326 /* Determine which direction. */
327 if (strcmp (step
->__from_name
, CHARSET_NAME
) == 0)
329 step
->__data
= FROM_DIRECTION_VAL
;
331 step
->__min_needed_from
= FROM_LOOP_MIN_NEEDED_FROM
;
332 step
->__max_needed_from
= FROM_LOOP_MAX_NEEDED_FROM
;
333 step
->__min_needed_to
= FROM_LOOP_MIN_NEEDED_TO
;
334 step
->__max_needed_to
= FROM_LOOP_MAX_NEEDED_TO
;
337 step
->__btowc_fct
= FROM_ONEBYTE
;
340 else if (__builtin_expect (strcmp (step
->__to_name
, CHARSET_NAME
), 0) == 0)
342 step
->__data
= TO_DIRECTION_VAL
;
344 step
->__min_needed_from
= TO_LOOP_MIN_NEEDED_FROM
;
345 step
->__max_needed_from
= TO_LOOP_MAX_NEEDED_FROM
;
346 step
->__min_needed_to
= TO_LOOP_MIN_NEEDED_TO
;
347 step
->__max_needed_to
= TO_LOOP_MAX_NEEDED_TO
;
350 return __GCONV_NOCONV
;
352 #ifdef SAVE_RESET_STATE
353 step
->__stateful
= 1;
355 step
->__stateful
= 0;
363 /* The default destructor function does nothing in the moment and so
364 we don't define it at all. But we still provide the macro just in
365 case we need it some day. */
370 /* If no arguments have to passed to the loop function define the macro
372 #ifndef EXTRA_LOOP_ARGS
373 # define EXTRA_LOOP_ARGS
377 /* This is the actual conversion function. */
378 #ifndef FUNCTION_NAME
379 # define FUNCTION_NAME gconv
382 /* The macros are used to access the function to convert single characters. */
383 #define SINGLE(fct) SINGLE2 (fct)
384 #define SINGLE2(fct) fct##_single
387 extern int FUNCTION_NAME (struct __gconv_step
*step
,
388 struct __gconv_step_data
*data
,
389 const unsigned char **inptrp
,
390 const unsigned char *inend
,
391 unsigned char **outbufstart
, size_t *irreversible
,
392 int do_flush
, int consume_incomplete
);
394 FUNCTION_NAME (struct __gconv_step
*step
, struct __gconv_step_data
*data
,
395 const unsigned char **inptrp
, const unsigned char *inend
,
396 unsigned char **outbufstart
, size_t *irreversible
, int do_flush
,
397 int consume_incomplete
)
399 struct __gconv_step
*next_step
= step
+ 1;
400 struct __gconv_step_data
*next_data
= data
+ 1;
401 __gconv_fct fct
= NULL
;
404 if ((data
->__flags
& __GCONV_IS_LAST
) == 0)
406 fct
= next_step
->__fct
;
407 if (next_step
->__shlib_handle
!= NULL
)
411 /* If the function is called with no input this means we have to reset
412 to the initial state. The possibly partly converted input is
414 if (__glibc_unlikely (do_flush
))
416 /* This should never happen during error handling. */
417 assert (outbufstart
== NULL
);
421 #ifdef EMIT_SHIFT_TO_INIT
424 /* We preserve the initial values of the pointer variables. */
425 unsigned char *outbuf
= data
->__outbuf
;
426 unsigned char *outstart
= outbuf
;
427 unsigned char *outend
= data
->__outbufend
;
433 # ifdef SAVE_RESET_STATE
434 SAVE_RESET_STATE (1);
437 /* Emit the escape sequence to reset the state. */
440 /* Call the steps down the chain if there are any but only if we
441 successfully emitted the escape sequence. This should only
442 fail if the output buffer is full. If the input is invalid
443 it should be discarded since the user wants to start from a
445 if (status
== __GCONV_OK
)
447 if (data
->__flags
& __GCONV_IS_LAST
)
448 /* Store information about how many bytes are available. */
449 data
->__outbuf
= outbuf
;
452 /* Write out all output which was produced. */
453 if (outbuf
> outstart
)
455 const unsigned char *outerr
= outstart
;
458 result
= DL_CALL_FCT (fct
, (next_step
, next_data
,
459 &outerr
, outbuf
, NULL
,
461 consume_incomplete
));
463 if (result
!= __GCONV_EMPTY_INPUT
)
465 if (__glibc_unlikely (outerr
!= outbuf
))
467 /* We have a problem. Undo the conversion. */
470 /* Restore the state. */
471 # ifdef SAVE_RESET_STATE
472 SAVE_RESET_STATE (0);
476 /* Change the status. */
481 if (status
== __GCONV_OK
)
482 /* Now flush the remaining steps. */
483 status
= DL_CALL_FCT (fct
, (next_step
, next_data
, NULL
,
484 NULL
, NULL
, irreversible
, 1,
485 consume_incomplete
));
492 /* Clear the state object. There might be bytes in there from
493 previous calls with CONSUME_INCOMPLETE == 1. But don't emit
495 memset (data
->__statep
, '\0', sizeof (*data
->__statep
));
497 if (! (data
->__flags
& __GCONV_IS_LAST
))
498 /* Now flush the remaining steps. */
499 status
= DL_CALL_FCT (fct
, (next_step
, next_data
, NULL
, NULL
,
500 NULL
, irreversible
, do_flush
,
501 consume_incomplete
));
506 /* We preserve the initial values of the pointer variables,
507 but only some conversion modules need it. */
508 const unsigned char *inptr
__attribute__ ((__unused__
)) = *inptrp
;
509 unsigned char *outbuf
= (__builtin_expect (outbufstart
== NULL
, 1)
510 ? data
->__outbuf
: *outbufstart
);
511 unsigned char *outend
= data
->__outbufend
;
512 unsigned char *outstart
;
513 /* This variable is used to count the number of characters we
514 actually converted. */
515 size_t lirreversible
= 0;
516 size_t *lirreversiblep
= irreversible
? &lirreversible
: NULL
;
518 /* The following assumes that encodings, which have a variable length
519 what might unalign a buffer even though it is an aligned in the
520 beginning, either don't have the minimal number of bytes as a divisor
521 of the maximum length or have a minimum length of 1. This is true
522 for all known and supported encodings.
523 We use && instead of || to combine the subexpression for the FROM
524 encoding and for the TO encoding, because usually one of them is
525 INTERNAL, for which the subexpression evaluates to 1, but INTERNAL
526 buffers are always aligned correctly. */
527 #define POSSIBLY_UNALIGNED \
528 (!_STRING_ARCH_unaligned \
529 && (((FROM_LOOP_MIN_NEEDED_FROM != 1 \
530 && FROM_LOOP_MAX_NEEDED_FROM % FROM_LOOP_MIN_NEEDED_FROM == 0) \
531 && (FROM_LOOP_MIN_NEEDED_TO != 1 \
532 && FROM_LOOP_MAX_NEEDED_TO % FROM_LOOP_MIN_NEEDED_TO == 0)) \
533 || ((TO_LOOP_MIN_NEEDED_FROM != 1 \
534 && TO_LOOP_MAX_NEEDED_FROM % TO_LOOP_MIN_NEEDED_FROM == 0) \
535 && (TO_LOOP_MIN_NEEDED_TO != 1 \
536 && TO_LOOP_MAX_NEEDED_TO % TO_LOOP_MIN_NEEDED_TO == 0))))
537 #if POSSIBLY_UNALIGNED
539 # define GEN_unaligned(name) GEN_unaligned2 (name)
540 # define GEN_unaligned2(name) name##_unaligned
549 #if FROM_LOOP_MAX_NEEDED_FROM > 1 || TO_LOOP_MAX_NEEDED_FROM > 1
550 /* If the function is used to implement the mb*towc*() or wc*tomb*()
551 functions we must test whether any bytes from the last call are
552 stored in the `state' object. */
553 if (((FROM_LOOP_MAX_NEEDED_FROM
> 1 && TO_LOOP_MAX_NEEDED_FROM
> 1)
554 || (FROM_LOOP_MAX_NEEDED_FROM
> 1 && FROM_DIRECTION
)
555 || (TO_LOOP_MAX_NEEDED_FROM
> 1 && !FROM_DIRECTION
))
556 && consume_incomplete
&& (data
->__statep
->__count
& 7) != 0)
558 /* Yep, we have some bytes left over. Process them now.
559 But this must not happen while we are called from an
561 assert (outbufstart
== NULL
);
563 # if FROM_LOOP_MAX_NEEDED_FROM > 1
564 if (TO_LOOP_MAX_NEEDED_FROM
== 1 || FROM_DIRECTION
)
565 status
= SINGLE(FROM_LOOP
) (step
, data
, inptrp
, inend
, &outbuf
,
566 outend
, lirreversiblep
570 # if FROM_LOOP_MAX_NEEDED_FROM > 1 && TO_LOOP_MAX_NEEDED_FROM > 1
573 # if TO_LOOP_MAX_NEEDED_FROM > 1
574 status
= SINGLE(TO_LOOP
) (step
, data
, inptrp
, inend
, &outbuf
,
575 outend
, lirreversiblep EXTRA_LOOP_ARGS
);
579 if (__builtin_expect (status
, __GCONV_OK
) != __GCONV_OK
)
584 #if POSSIBLY_UNALIGNED
587 && ((uintptr_t) inptr
% FROM_LOOP_MIN_NEEDED_FROM
!= 0
588 || ((data
->__flags
& __GCONV_IS_LAST
)
589 && (uintptr_t) outbuf
% FROM_LOOP_MIN_NEEDED_TO
!= 0)))
591 && (((data
->__flags
& __GCONV_IS_LAST
)
592 && (uintptr_t) outbuf
% TO_LOOP_MIN_NEEDED_TO
!= 0)
593 || (uintptr_t) inptr
% TO_LOOP_MIN_NEEDED_FROM
!= 0)));
598 /* Remember the start value for this round. */
600 /* The outbuf buffer is empty. */
602 #ifdef RESET_INPUT_BUFFER
603 /* Remember how many irreversible characters were skipped before
605 size_t loop_irreversible
606 = lirreversible
+ (irreversible
? *irreversible
: 0);
609 #ifdef SAVE_RESET_STATE
610 SAVE_RESET_STATE (1);
613 if (__glibc_likely (!unaligned
))
616 /* Run the conversion loop. */
617 status
= FROM_LOOP (step
, data
, inptrp
, inend
, &outbuf
, outend
,
618 lirreversiblep EXTRA_LOOP_ARGS
);
620 /* Run the conversion loop. */
621 status
= TO_LOOP (step
, data
, inptrp
, inend
, &outbuf
, outend
,
622 lirreversiblep EXTRA_LOOP_ARGS
);
624 #if POSSIBLY_UNALIGNED
628 /* Run the conversion loop. */
629 status
= GEN_unaligned (FROM_LOOP
) (step
, data
, inptrp
, inend
,
634 /* Run the conversion loop. */
635 status
= GEN_unaligned (TO_LOOP
) (step
, data
, inptrp
, inend
,
642 /* If we were called as part of an error handling module we
643 don't do anything else here. */
644 if (__glibc_unlikely (outbufstart
!= NULL
))
646 *outbufstart
= outbuf
;
650 /* We finished one use of the loops. */
651 ++data
->__invocation_counter
;
653 /* If this is the last step leave the loop, there is nothing
655 if (__glibc_unlikely (data
->__flags
& __GCONV_IS_LAST
))
657 /* Store information about how many bytes are available. */
658 data
->__outbuf
= outbuf
;
660 /* Remember how many non-identical characters we
661 converted in an irreversible way. */
662 *irreversible
+= lirreversible
;
667 /* Write out all output which was produced. */
668 if (__glibc_likely (outbuf
> outstart
))
670 const unsigned char *outerr
= data
->__outbuf
;
673 result
= DL_CALL_FCT (fct
, (next_step
, next_data
, &outerr
,
674 outbuf
, NULL
, irreversible
, 0,
675 consume_incomplete
));
677 if (result
!= __GCONV_EMPTY_INPUT
)
679 if (__glibc_unlikely (outerr
!= outbuf
))
681 #ifdef RESET_INPUT_BUFFER
682 /* RESET_INPUT_BUFFER can only work when there were
683 no new irreversible characters skipped during
685 if (loop_irreversible
686 == lirreversible
+ (irreversible
? *irreversible
: 0))
692 /* We have a problem in one of the functions below.
693 Undo the conversion upto the error point. */
694 size_t nstatus
__attribute__ ((unused
));
696 /* Reload the pointers. */
700 /* Restore the state. */
701 #ifdef SAVE_RESET_STATE
702 SAVE_RESET_STATE (0);
705 if (__glibc_likely (!unaligned
))
708 /* Run the conversion loop. */
709 nstatus
= FROM_LOOP (step
, data
, inptrp
, inend
,
714 /* Run the conversion loop. */
715 nstatus
= TO_LOOP (step
, data
, inptrp
, inend
,
720 #if POSSIBLY_UNALIGNED
724 /* Run the conversion loop. */
725 nstatus
= GEN_unaligned (FROM_LOOP
) (step
, data
,
732 /* Run the conversion loop. */
733 nstatus
= GEN_unaligned (TO_LOOP
) (step
, data
,
741 /* We must run out of output buffer space in this
743 assert (outbuf
== outerr
);
744 assert (nstatus
== __GCONV_FULL_OUTPUT
);
746 /* If we haven't consumed a single byte decrement
747 the invocation counter. */
748 if (__glibc_unlikely (outbuf
== outstart
))
749 --data
->__invocation_counter
;
752 #ifdef RESET_INPUT_BUFFER
755 /* Change the status. */
759 /* All the output is consumed, we can make another run
760 if everything was ok. */
761 if (status
== __GCONV_FULL_OUTPUT
)
764 outbuf
= data
->__outbuf
;
768 if (status
!= __GCONV_OK
)
771 /* Reset the output buffer pointer for the next round. */
772 outbuf
= data
->__outbuf
;
779 /* If we are supposed to consume all character store now all of the
780 remaining characters in the `state' object. */
781 #if FROM_LOOP_MAX_NEEDED_FROM > 1 || TO_LOOP_MAX_NEEDED_FROM > 1
782 if (((FROM_LOOP_MAX_NEEDED_FROM
> 1 && TO_LOOP_MAX_NEEDED_FROM
> 1)
783 || (FROM_LOOP_MAX_NEEDED_FROM
> 1 && FROM_DIRECTION
)
784 || (TO_LOOP_MAX_NEEDED_FROM
> 1 && !FROM_DIRECTION
))
785 && __builtin_expect (consume_incomplete
, 0)
786 && status
== __GCONV_INCOMPLETE_INPUT
)
789 mbstate_t *state
= data
->__statep
;
793 /* Make sure the remaining bytes fit into the state objects
795 size_t cnt_after
= inend
- *inptrp
;
796 assert (cnt_after
<= sizeof (data
->__statep
->__value
.__wchb
));
799 for (cnt
= 0; cnt
< cnt_after
; ++cnt
)
800 data
->__statep
->__value
.__wchb
[cnt
] = (*inptrp
)[cnt
];
802 data
->__statep
->__count
&= ~7;
803 data
->__statep
->__count
|= cnt
;
808 #undef POSSIBLY_UNALIGNED
817 #undef MIN_NEEDED_FROM
819 #undef MAX_NEEDED_FROM
821 #undef FROM_LOOP_MIN_NEEDED_FROM
822 #undef FROM_LOOP_MAX_NEEDED_FROM
823 #undef FROM_LOOP_MIN_NEEDED_TO
824 #undef FROM_LOOP_MAX_NEEDED_TO
825 #undef TO_LOOP_MIN_NEEDED_FROM
826 #undef TO_LOOP_MAX_NEEDED_FROM
827 #undef TO_LOOP_MIN_NEEDED_TO
828 #undef TO_LOOP_MAX_NEEDED_TO
829 #undef FROM_DIRECTION
830 #undef EMIT_SHIFT_TO_INIT
834 #undef SAVE_RESET_STATE
835 #undef RESET_INPUT_BUFFER
839 #undef EXTRA_LOOP_ARGS