1 /* Skeleton for a conversion module.
2 Copyright (C) 1998-2020 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
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 /* This file can be included to provide definitions of several things
21 many modules have in common. It can be customized using the following
24 DEFINE_INIT define the default initializer. This requires the
25 following symbol to be defined.
27 CHARSET_NAME string with official name of the coded character
30 DEFINE_FINI define the default destructor function.
32 MIN_NEEDED_FROM minimal number of bytes needed for the from-charset.
33 MIN_NEEDED_TO likewise for the to-charset.
35 MAX_NEEDED_FROM maximal number of bytes needed for the from-charset.
36 This macro is optional, it defaults to MIN_NEEDED_FROM.
37 MAX_NEEDED_TO likewise for the to-charset.
39 FROM_LOOP_MIN_NEEDED_FROM
40 FROM_LOOP_MAX_NEEDED_FROM
41 minimal/maximal number of bytes needed on input
42 of one round through the FROM_LOOP. Defaults
43 to MIN_NEEDED_FROM and MAX_NEEDED_FROM, respectively.
44 FROM_LOOP_MIN_NEEDED_TO
45 FROM_LOOP_MAX_NEEDED_TO
46 minimal/maximal number of bytes needed on output
47 of one round through the FROM_LOOP. Defaults
48 to MIN_NEEDED_TO and MAX_NEEDED_TO, respectively.
49 TO_LOOP_MIN_NEEDED_FROM
50 TO_LOOP_MAX_NEEDED_FROM
51 minimal/maximal number of bytes needed on input
52 of one round through the TO_LOOP. Defaults
53 to MIN_NEEDED_TO and MAX_NEEDED_TO, respectively.
56 minimal/maximal number of bytes needed on output
57 of one round through the TO_LOOP. Defaults
58 to MIN_NEEDED_FROM and MAX_NEEDED_FROM, respectively.
60 FROM_DIRECTION this macro is supposed to return a value != 0
61 if we convert from the current character set,
62 otherwise it return 0.
64 EMIT_SHIFT_TO_INIT this symbol is optional. If it is defined it
65 defines some code which writes out a sequence
66 of bytes which bring the current state into
69 FROM_LOOP name of the function implementing the conversion
70 from the current character set.
71 TO_LOOP likewise for the other direction
73 ONE_DIRECTION optional. If defined to 1, only one conversion
74 direction is defined instead of two. In this
75 case, FROM_DIRECTION should be defined to 1, and
76 FROM_LOOP and TO_LOOP should have the same value.
78 SAVE_RESET_STATE in case of an error we must reset the state for
79 the rerun so this macro must be defined for
80 stateful encodings. It takes an argument which
81 is nonzero when saving.
83 RESET_INPUT_BUFFER If the input character sets allow this the macro
84 can be defined to reset the input buffer pointers
85 to cover only those characters up to the error.
86 Note that if the conversion has skipped over
87 irreversible characters (due to
88 __GCONV_IGNORE_ERRORS) there is no longer a direct
89 correspondence between input and output pointers,
90 and this macro is not called.
92 FUNCTION_NAME if not set the conversion function is named `gconv'.
94 PREPARE_LOOP optional code preparing the conversion loop. Can
95 contain variable definitions.
96 END_LOOP also optional, may be used to store information
98 EXTRA_LOOP_ARGS optional macro specifying extra arguments passed
101 STORE_REST optional, needed only when MAX_NEEDED_FROM > 4.
102 This macro stores the seen but unconverted input bytes
105 FROM_ONEBYTE optional. If defined, should be the name of a
106 specialized conversion function for a single byte
107 from the current character set to INTERNAL. This
108 function has prototype
110 FROM_ONEBYTE (struct __gconv_step *, unsigned char);
111 and does a special conversion:
112 - The input is a single byte.
113 - The output is a single uint32_t.
114 - The state before the conversion is the initial state;
115 the state after the conversion is irrelevant.
116 - No transliteration.
117 - __invocation_counter = 0.
118 - __internal_use = 1.
121 Modules can use mbstate_t to store conversion state as follows:
123 * Bits 2..0 of '__count' contain the number of lookahead input bytes
124 stored in __value.__wchb. Always zero if the converter never
125 returns __GCONV_INCOMPLETE_INPUT.
127 * Bits 31..3 of '__count' are module dependent shift state.
129 * __value: When STORE_REST/UNPACK_BYTES aren't defined and when the
130 converter has returned __GCONV_INCOMPLETE_INPUT, this contains
131 at most 4 lookahead bytes. Converters with an mb_cur_max > 4
132 (currently only UTF-8) must find a way to store their state
133 in __value.__wch and define STORE_REST/UNPACK_BYTES appropriately.
135 When __value contains lookahead, __count must not be zero, because
136 the converter is not in the initial state then, and mbsinit() --
137 defined as a (__count == 0) test -- must reflect this.
141 #include <iconv/gconv_int.h>
143 #define __need_size_t
155 # define DL_CALL_FCT(fct, args) fct args
158 /* The direction objects. */
160 # ifndef FROM_DIRECTION
161 # define FROM_DIRECTION_VAL NULL
162 # define TO_DIRECTION_VAL ((void *) ~((uintptr_t) 0))
163 # define FROM_DIRECTION (step->__data == FROM_DIRECTION_VAL)
166 # ifndef FROM_DIRECTION
167 # error "FROM_DIRECTION must be provided if non-default init is used"
171 /* How many bytes are needed at most for the from-charset. */
172 #ifndef MAX_NEEDED_FROM
173 # define MAX_NEEDED_FROM MIN_NEEDED_FROM
176 /* Same for the to-charset. */
177 #ifndef MAX_NEEDED_TO
178 # define MAX_NEEDED_TO MIN_NEEDED_TO
181 /* Defaults for the per-direction min/max constants. */
182 #ifndef FROM_LOOP_MIN_NEEDED_FROM
183 # define FROM_LOOP_MIN_NEEDED_FROM MIN_NEEDED_FROM
185 #ifndef FROM_LOOP_MAX_NEEDED_FROM
186 # define FROM_LOOP_MAX_NEEDED_FROM MAX_NEEDED_FROM
188 #ifndef FROM_LOOP_MIN_NEEDED_TO
189 # define FROM_LOOP_MIN_NEEDED_TO MIN_NEEDED_TO
191 #ifndef FROM_LOOP_MAX_NEEDED_TO
192 # define FROM_LOOP_MAX_NEEDED_TO MAX_NEEDED_TO
194 #ifndef TO_LOOP_MIN_NEEDED_FROM
195 # define TO_LOOP_MIN_NEEDED_FROM MIN_NEEDED_TO
197 #ifndef TO_LOOP_MAX_NEEDED_FROM
198 # define TO_LOOP_MAX_NEEDED_FROM MAX_NEEDED_TO
200 #ifndef TO_LOOP_MIN_NEEDED_TO
201 # define TO_LOOP_MIN_NEEDED_TO MIN_NEEDED_FROM
203 #ifndef TO_LOOP_MAX_NEEDED_TO
204 # define TO_LOOP_MAX_NEEDED_TO MAX_NEEDED_FROM
208 /* Define macros which can access unaligned buffers. These macros are
209 supposed to be used only in code outside the inner loops. For the inner
210 loops we have other definitions which allow optimized access. */
211 #if _STRING_ARCH_unaligned
212 /* We can handle unaligned memory access. */
213 # define get16u(addr) *((const uint16_t *) (addr))
214 # define get32u(addr) *((const uint32_t *) (addr))
216 /* We need no special support for writing values either. */
217 # define put16u(addr, val) *((uint16_t *) (addr)) = (val)
218 # define put32u(addr, val) *((uint32_t *) (addr)) = (val)
220 /* Distinguish between big endian and little endian. */
221 # if __BYTE_ORDER == __LITTLE_ENDIAN
222 # define get16u(addr) \
223 (((const unsigned char *) (addr))[1] << 8 \
224 | ((const unsigned char *) (addr))[0])
225 # define get32u(addr) \
226 (((((const unsigned char *) (addr))[3] << 8 \
227 | ((const unsigned char *) (addr))[2]) << 8 \
228 | ((const unsigned char *) (addr))[1]) << 8 \
229 | ((const unsigned char *) (addr))[0])
231 # define put16u(addr, val) \
232 ({ uint16_t __val = (val); \
233 ((unsigned char *) (addr))[0] = __val; \
234 ((unsigned char *) (addr))[1] = __val >> 8; \
236 # define put32u(addr, val) \
237 ({ uint32_t __val = (val); \
238 ((unsigned char *) (addr))[0] = __val; \
240 ((unsigned char *) (addr))[1] = __val; \
242 ((unsigned char *) (addr))[2] = __val; \
244 ((unsigned char *) (addr))[3] = __val; \
247 # define get16u(addr) \
248 (((const unsigned char *) (addr))[0] << 8 \
249 | ((const unsigned char *) (addr))[1])
250 # define get32u(addr) \
251 (((((const unsigned char *) (addr))[0] << 8 \
252 | ((const unsigned char *) (addr))[1]) << 8 \
253 | ((const unsigned char *) (addr))[2]) << 8 \
254 | ((const unsigned char *) (addr))[3])
256 # define put16u(addr, val) \
257 ({ uint16_t __val = (val); \
258 ((unsigned char *) (addr))[1] = __val; \
259 ((unsigned char *) (addr))[0] = __val >> 8; \
261 # define put32u(addr, val) \
262 ({ uint32_t __val = (val); \
263 ((unsigned char *) (addr))[3] = __val; \
265 ((unsigned char *) (addr))[2] = __val; \
267 ((unsigned char *) (addr))[1] = __val; \
269 ((unsigned char *) (addr))[0] = __val; \
275 /* For conversions from a fixed width character set to another fixed width
276 character set we can define RESET_INPUT_BUFFER in a very fast way. */
277 #if !defined RESET_INPUT_BUFFER && !defined SAVE_RESET_STATE
278 # if FROM_LOOP_MIN_NEEDED_FROM == FROM_LOOP_MAX_NEEDED_FROM \
279 && FROM_LOOP_MIN_NEEDED_TO == FROM_LOOP_MAX_NEEDED_TO \
280 && TO_LOOP_MIN_NEEDED_FROM == TO_LOOP_MAX_NEEDED_FROM \
281 && TO_LOOP_MIN_NEEDED_TO == TO_LOOP_MAX_NEEDED_TO
282 /* We have to use these `if's here since the compiler cannot know that
283 (outbuf - outerr) is always divisible by FROM/TO_LOOP_MIN_NEEDED_TO.
284 The ?:1 avoids division by zero warnings that gcc 3.2 emits even for
285 obviously unreachable code. */
286 # define RESET_INPUT_BUFFER \
287 if (FROM_DIRECTION) \
289 if (FROM_LOOP_MIN_NEEDED_FROM % FROM_LOOP_MIN_NEEDED_TO == 0) \
290 *inptrp -= (outbuf - outerr) \
291 * (FROM_LOOP_MIN_NEEDED_FROM / FROM_LOOP_MIN_NEEDED_TO); \
292 else if (FROM_LOOP_MIN_NEEDED_TO % FROM_LOOP_MIN_NEEDED_FROM == 0) \
293 *inptrp -= (outbuf - outerr) \
294 / (FROM_LOOP_MIN_NEEDED_TO / FROM_LOOP_MIN_NEEDED_FROM \
297 *inptrp -= ((outbuf - outerr) / FROM_LOOP_MIN_NEEDED_TO) \
298 * FROM_LOOP_MIN_NEEDED_FROM; \
302 if (TO_LOOP_MIN_NEEDED_FROM % TO_LOOP_MIN_NEEDED_TO == 0) \
303 *inptrp -= (outbuf - outerr) \
304 * (TO_LOOP_MIN_NEEDED_FROM / TO_LOOP_MIN_NEEDED_TO); \
305 else if (TO_LOOP_MIN_NEEDED_TO % TO_LOOP_MIN_NEEDED_FROM == 0) \
306 *inptrp -= (outbuf - outerr) \
307 / (TO_LOOP_MIN_NEEDED_TO / TO_LOOP_MIN_NEEDED_FROM ? : 1); \
309 *inptrp -= ((outbuf - outerr) / TO_LOOP_MIN_NEEDED_TO) \
310 * TO_LOOP_MIN_NEEDED_FROM; \
316 /* The default init function. It simply matches the name and initializes
317 the step data to point to one of the objects above. */
319 # ifndef CHARSET_NAME
320 # error "CHARSET_NAME not defined"
323 extern int gconv_init (struct __gconv_step
*step
);
325 gconv_init (struct __gconv_step
*step
)
327 /* Determine which direction. */
328 if (strcmp (step
->__from_name
, CHARSET_NAME
) == 0)
330 step
->__data
= FROM_DIRECTION_VAL
;
332 step
->__min_needed_from
= FROM_LOOP_MIN_NEEDED_FROM
;
333 step
->__max_needed_from
= FROM_LOOP_MAX_NEEDED_FROM
;
334 step
->__min_needed_to
= FROM_LOOP_MIN_NEEDED_TO
;
335 step
->__max_needed_to
= FROM_LOOP_MAX_NEEDED_TO
;
338 step
->__btowc_fct
= FROM_ONEBYTE
;
341 else if (__builtin_expect (strcmp (step
->__to_name
, CHARSET_NAME
), 0) == 0)
343 step
->__data
= TO_DIRECTION_VAL
;
345 step
->__min_needed_from
= TO_LOOP_MIN_NEEDED_FROM
;
346 step
->__max_needed_from
= TO_LOOP_MAX_NEEDED_FROM
;
347 step
->__min_needed_to
= TO_LOOP_MIN_NEEDED_TO
;
348 step
->__max_needed_to
= TO_LOOP_MAX_NEEDED_TO
;
351 return __GCONV_NOCONV
;
353 #ifdef SAVE_RESET_STATE
354 step
->__stateful
= 1;
356 step
->__stateful
= 0;
364 /* The default destructor function does nothing in the moment and so
365 we don't define it at all. But we still provide the macro just in
366 case we need it some day. */
371 /* If no arguments have to passed to the loop function define the macro
373 #ifndef EXTRA_LOOP_ARGS
374 # define EXTRA_LOOP_ARGS
378 /* This is the actual conversion function. */
379 #ifndef FUNCTION_NAME
380 # define FUNCTION_NAME gconv
383 /* The macros are used to access the function to convert single characters. */
384 #define SINGLE(fct) SINGLE2 (fct)
385 #define SINGLE2(fct) fct##_single
388 extern int FUNCTION_NAME (struct __gconv_step
*step
,
389 struct __gconv_step_data
*data
,
390 const unsigned char **inptrp
,
391 const unsigned char *inend
,
392 unsigned char **outbufstart
, size_t *irreversible
,
393 int do_flush
, int consume_incomplete
);
395 FUNCTION_NAME (struct __gconv_step
*step
, struct __gconv_step_data
*data
,
396 const unsigned char **inptrp
, const unsigned char *inend
,
397 unsigned char **outbufstart
, size_t *irreversible
, int do_flush
,
398 int consume_incomplete
)
400 struct __gconv_step
*next_step
= step
+ 1;
401 struct __gconv_step_data
*next_data
= data
+ 1;
402 __gconv_fct fct
= NULL
;
405 if ((data
->__flags
& __GCONV_IS_LAST
) == 0)
407 fct
= next_step
->__fct
;
409 if (next_step
->__shlib_handle
!= NULL
)
414 /* If the function is called with no input this means we have to reset
415 to the initial state. The possibly partly converted input is
417 if (__glibc_unlikely (do_flush
))
419 /* This should never happen during error handling. */
420 assert (outbufstart
== NULL
);
424 #ifdef EMIT_SHIFT_TO_INIT
427 /* We preserve the initial values of the pointer variables. */
428 unsigned char *outbuf
= data
->__outbuf
;
429 unsigned char *outstart
= outbuf
;
430 unsigned char *outend
= data
->__outbufend
;
436 # ifdef SAVE_RESET_STATE
437 SAVE_RESET_STATE (1);
440 /* Emit the escape sequence to reset the state. */
443 /* Call the steps down the chain if there are any but only if we
444 successfully emitted the escape sequence. This should only
445 fail if the output buffer is full. If the input is invalid
446 it should be discarded since the user wants to start from a
448 if (status
== __GCONV_OK
)
450 if (data
->__flags
& __GCONV_IS_LAST
)
451 /* Store information about how many bytes are available. */
452 data
->__outbuf
= outbuf
;
455 /* Write out all output which was produced. */
456 if (outbuf
> outstart
)
458 const unsigned char *outerr
= outstart
;
461 result
= DL_CALL_FCT (fct
, (next_step
, next_data
,
462 &outerr
, outbuf
, NULL
,
464 consume_incomplete
));
466 if (result
!= __GCONV_EMPTY_INPUT
)
468 if (__glibc_unlikely (outerr
!= outbuf
))
470 /* We have a problem. Undo the conversion. */
473 /* Restore the state. */
474 # ifdef SAVE_RESET_STATE
475 SAVE_RESET_STATE (0);
479 /* Change the status. */
484 if (status
== __GCONV_OK
)
485 /* Now flush the remaining steps. */
486 status
= DL_CALL_FCT (fct
, (next_step
, next_data
, NULL
,
487 NULL
, NULL
, irreversible
, 1,
488 consume_incomplete
));
495 /* Clear the state object. There might be bytes in there from
496 previous calls with CONSUME_INCOMPLETE == 1. But don't emit
498 memset (data
->__statep
, '\0', sizeof (*data
->__statep
));
500 if (! (data
->__flags
& __GCONV_IS_LAST
))
501 /* Now flush the remaining steps. */
502 status
= DL_CALL_FCT (fct
, (next_step
, next_data
, NULL
, NULL
,
503 NULL
, irreversible
, do_flush
,
504 consume_incomplete
));
509 /* We preserve the initial values of the pointer variables,
510 but only some conversion modules need it. */
511 const unsigned char *inptr
__attribute__ ((__unused__
)) = *inptrp
;
512 unsigned char *outbuf
= (__builtin_expect (outbufstart
== NULL
, 1)
513 ? data
->__outbuf
: *outbufstart
);
514 unsigned char *outend
= data
->__outbufend
;
515 unsigned char *outstart
;
516 /* This variable is used to count the number of characters we
517 actually converted. */
518 size_t lirreversible
= 0;
519 size_t *lirreversiblep
= irreversible
? &lirreversible
: NULL
;
521 /* The following assumes that encodings, which have a variable length
522 what might unalign a buffer even though it is an aligned in the
523 beginning, either don't have the minimal number of bytes as a divisor
524 of the maximum length or have a minimum length of 1. This is true
525 for all known and supported encodings.
526 We use && instead of || to combine the subexpression for the FROM
527 encoding and for the TO encoding, because usually one of them is
528 INTERNAL, for which the subexpression evaluates to 1, but INTERNAL
529 buffers are always aligned correctly. */
530 #define POSSIBLY_UNALIGNED \
531 (!_STRING_ARCH_unaligned \
532 && (((FROM_LOOP_MIN_NEEDED_FROM != 1 \
533 && FROM_LOOP_MAX_NEEDED_FROM % FROM_LOOP_MIN_NEEDED_FROM == 0) \
534 && (FROM_LOOP_MIN_NEEDED_TO != 1 \
535 && FROM_LOOP_MAX_NEEDED_TO % FROM_LOOP_MIN_NEEDED_TO == 0)) \
536 || ((TO_LOOP_MIN_NEEDED_FROM != 1 \
537 && TO_LOOP_MAX_NEEDED_FROM % TO_LOOP_MIN_NEEDED_FROM == 0) \
538 && (TO_LOOP_MIN_NEEDED_TO != 1 \
539 && TO_LOOP_MAX_NEEDED_TO % TO_LOOP_MIN_NEEDED_TO == 0))))
540 #if POSSIBLY_UNALIGNED
542 # define GEN_unaligned(name) GEN_unaligned2 (name)
543 # define GEN_unaligned2(name) name##_unaligned
552 #if FROM_LOOP_MAX_NEEDED_FROM > 1 || TO_LOOP_MAX_NEEDED_FROM > 1
553 /* If the function is used to implement the mb*towc*() or wc*tomb*()
554 functions we must test whether any bytes from the last call are
555 stored in the `state' object. */
556 if (((FROM_LOOP_MAX_NEEDED_FROM
> 1 && TO_LOOP_MAX_NEEDED_FROM
> 1)
557 || (FROM_LOOP_MAX_NEEDED_FROM
> 1 && FROM_DIRECTION
)
558 || (TO_LOOP_MAX_NEEDED_FROM
> 1 && !FROM_DIRECTION
))
559 && consume_incomplete
&& (data
->__statep
->__count
& 7) != 0)
561 /* Yep, we have some bytes left over. Process them now.
562 But this must not happen while we are called from an
564 assert (outbufstart
== NULL
);
566 # if FROM_LOOP_MAX_NEEDED_FROM > 1
567 if (TO_LOOP_MAX_NEEDED_FROM
== 1 || FROM_DIRECTION
)
568 status
= SINGLE(FROM_LOOP
) (step
, data
, inptrp
, inend
, &outbuf
,
569 outend
, lirreversiblep
573 # if FROM_LOOP_MAX_NEEDED_FROM > 1 && TO_LOOP_MAX_NEEDED_FROM > 1
576 # if TO_LOOP_MAX_NEEDED_FROM > 1
577 status
= SINGLE(TO_LOOP
) (step
, data
, inptrp
, inend
, &outbuf
,
578 outend
, lirreversiblep EXTRA_LOOP_ARGS
);
582 if (__builtin_expect (status
, __GCONV_OK
) != __GCONV_OK
)
587 #if POSSIBLY_UNALIGNED
590 && ((uintptr_t) inptr
% FROM_LOOP_MIN_NEEDED_FROM
!= 0
591 || ((data
->__flags
& __GCONV_IS_LAST
)
592 && (uintptr_t) outbuf
% FROM_LOOP_MIN_NEEDED_TO
!= 0)))
594 && (((data
->__flags
& __GCONV_IS_LAST
)
595 && (uintptr_t) outbuf
% TO_LOOP_MIN_NEEDED_TO
!= 0)
596 || (uintptr_t) inptr
% TO_LOOP_MIN_NEEDED_FROM
!= 0)));
601 /* Remember the start value for this round. */
603 /* The outbuf buffer is empty. */
605 #ifdef RESET_INPUT_BUFFER
606 /* Remember how many irreversible characters were skipped before
608 size_t loop_irreversible
609 = lirreversible
+ (irreversible
? *irreversible
: 0);
612 #ifdef SAVE_RESET_STATE
613 SAVE_RESET_STATE (1);
616 if (__glibc_likely (!unaligned
))
619 /* Run the conversion loop. */
620 status
= FROM_LOOP (step
, data
, inptrp
, inend
, &outbuf
, outend
,
621 lirreversiblep EXTRA_LOOP_ARGS
);
623 /* Run the conversion loop. */
624 status
= TO_LOOP (step
, data
, inptrp
, inend
, &outbuf
, outend
,
625 lirreversiblep EXTRA_LOOP_ARGS
);
627 #if POSSIBLY_UNALIGNED
631 /* Run the conversion loop. */
632 status
= GEN_unaligned (FROM_LOOP
) (step
, data
, inptrp
, inend
,
637 /* Run the conversion loop. */
638 status
= GEN_unaligned (TO_LOOP
) (step
, data
, inptrp
, inend
,
645 /* If we were called as part of an error handling module we
646 don't do anything else here. */
647 if (__glibc_unlikely (outbufstart
!= NULL
))
649 *outbufstart
= outbuf
;
653 /* We finished one use of the loops. */
654 ++data
->__invocation_counter
;
656 /* If this is the last step leave the loop, there is nothing
658 if (__glibc_unlikely (data
->__flags
& __GCONV_IS_LAST
))
660 /* Store information about how many bytes are available. */
661 data
->__outbuf
= outbuf
;
663 /* Remember how many non-identical characters we
664 converted in an irreversible way. */
665 *irreversible
+= lirreversible
;
670 /* Write out all output which was produced. */
671 if (__glibc_likely (outbuf
> outstart
))
673 const unsigned char *outerr
= data
->__outbuf
;
676 result
= DL_CALL_FCT (fct
, (next_step
, next_data
, &outerr
,
677 outbuf
, NULL
, irreversible
, 0,
678 consume_incomplete
));
680 if (result
!= __GCONV_EMPTY_INPUT
)
682 if (__glibc_unlikely (outerr
!= outbuf
))
684 #ifdef RESET_INPUT_BUFFER
685 /* RESET_INPUT_BUFFER can only work when there were
686 no new irreversible characters skipped during
688 if (loop_irreversible
689 == lirreversible
+ (irreversible
? *irreversible
: 0))
695 /* We have a problem in one of the functions below.
696 Undo the conversion upto the error point. */
697 size_t nstatus
__attribute__ ((unused
));
699 /* Reload the pointers. */
703 /* Restore the state. */
704 #ifdef SAVE_RESET_STATE
705 SAVE_RESET_STATE (0);
708 if (__glibc_likely (!unaligned
))
711 /* Run the conversion loop. */
712 nstatus
= FROM_LOOP (step
, data
, inptrp
, inend
,
717 /* Run the conversion loop. */
718 nstatus
= TO_LOOP (step
, data
, inptrp
, inend
,
723 #if POSSIBLY_UNALIGNED
727 /* Run the conversion loop. */
728 nstatus
= GEN_unaligned (FROM_LOOP
) (step
, data
,
735 /* Run the conversion loop. */
736 nstatus
= GEN_unaligned (TO_LOOP
) (step
, data
,
744 /* We must run out of output buffer space in this
746 assert (outbuf
== outerr
);
747 assert (nstatus
== __GCONV_FULL_OUTPUT
);
749 /* If we haven't consumed a single byte decrement
750 the invocation counter. */
751 if (__glibc_unlikely (outbuf
== outstart
))
752 --data
->__invocation_counter
;
755 #ifdef RESET_INPUT_BUFFER
758 /* Change the status. */
762 /* All the output is consumed, we can make another run
763 if everything was ok. */
764 if (status
== __GCONV_FULL_OUTPUT
)
767 outbuf
= data
->__outbuf
;
771 if (status
!= __GCONV_OK
)
774 /* Reset the output buffer pointer for the next round. */
775 outbuf
= data
->__outbuf
;
782 /* If we are supposed to consume all character store now all of the
783 remaining characters in the `state' object. */
784 #if FROM_LOOP_MAX_NEEDED_FROM > 1 || TO_LOOP_MAX_NEEDED_FROM > 1
785 if (((FROM_LOOP_MAX_NEEDED_FROM
> 1 && TO_LOOP_MAX_NEEDED_FROM
> 1)
786 || (FROM_LOOP_MAX_NEEDED_FROM
> 1 && FROM_DIRECTION
)
787 || (TO_LOOP_MAX_NEEDED_FROM
> 1 && !FROM_DIRECTION
))
788 && __builtin_expect (consume_incomplete
, 0)
789 && status
== __GCONV_INCOMPLETE_INPUT
)
792 mbstate_t *state
= data
->__statep
;
796 /* Make sure the remaining bytes fit into the state objects
798 assert (inend
- *inptrp
< 4);
801 for (cnt
= 0; *inptrp
< inend
; ++cnt
)
802 data
->__statep
->__value
.__wchb
[cnt
] = *(*inptrp
)++;
803 data
->__statep
->__count
&= ~7;
804 data
->__statep
->__count
|= cnt
;
809 #undef POSSIBLY_UNALIGNED
818 #undef MIN_NEEDED_FROM
820 #undef MAX_NEEDED_FROM
822 #undef FROM_LOOP_MIN_NEEDED_FROM
823 #undef FROM_LOOP_MAX_NEEDED_FROM
824 #undef FROM_LOOP_MIN_NEEDED_TO
825 #undef FROM_LOOP_MAX_NEEDED_TO
826 #undef TO_LOOP_MIN_NEEDED_FROM
827 #undef TO_LOOP_MAX_NEEDED_FROM
828 #undef TO_LOOP_MIN_NEEDED_TO
829 #undef TO_LOOP_MAX_NEEDED_TO
830 #undef FROM_DIRECTION
831 #undef EMIT_SHIFT_TO_INIT
835 #undef SAVE_RESET_STATE
836 #undef RESET_INPUT_BUFFER
840 #undef EXTRA_LOOP_ARGS