1/* Skeleton for a conversion module.
2 Copyright (C) 1998-2023 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
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.
9
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.
14
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/>. */
18
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
21 macros:
22
23 DEFINE_INIT define the default initializer. This requires the
24 following symbol to be defined.
25
26 CHARSET_NAME string with official name of the coded character
27 set (in all-caps)
28
29 DEFINE_FINI define the default destructor function.
30
31 MIN_NEEDED_FROM minimal number of bytes needed for the from-charset.
32 MIN_NEEDED_TO likewise for the to-charset.
33
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.
37
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.
53 TO_LOOP_MIN_NEEDED_TO
54 TO_LOOP_MAX_NEEDED_TO
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.
58
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.
62
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
66 the initial state.
67
68 FROM_LOOP name of the function implementing the conversion
69 from the current character set.
70 TO_LOOP likewise for the other direction
71
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.
76
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.
81
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.
90
91 FUNCTION_NAME if not set the conversion function is named `gconv'.
92
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
96
97 EXTRA_LOOP_ARGS optional macro specifying extra arguments passed
98 to loop function.
99
100 STORE_REST optional, needed only when MAX_NEEDED_FROM > 4.
101 This macro stores the seen but unconverted input bytes
102 in the state.
103
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
108 wint_t
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.
118 - do_flush = 0.
119
120 Modules can use mbstate_t to store conversion state as follows:
121
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.
125
126 * Bits 31..3 of '__count' are module dependent shift state.
127
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.
133
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.
137 */
138
139#include <assert.h>
140#include <iconv/gconv_int.h>
141#include <string.h>
142#define __need_size_t
143#define __need_NULL
144#include <stddef.h>
145
146#ifndef STATIC_GCONV
147# include <dlfcn.h>
148#endif
149
150#include <pointer_guard.h>
151#include <stdint.h>
152
153#ifndef DL_CALL_FCT
154# define DL_CALL_FCT(fct, args) fct args
155#endif
156
157/* The direction objects. */
158#if DEFINE_INIT
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)
163# endif
164#else
165# ifndef FROM_DIRECTION
166# error "FROM_DIRECTION must be provided if non-default init is used"
167# endif
168#endif
169
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
173#endif
174
175/* Same for the to-charset. */
176#ifndef MAX_NEEDED_TO
177# define MAX_NEEDED_TO MIN_NEEDED_TO
178#endif
179
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
183#endif
184#ifndef FROM_LOOP_MAX_NEEDED_FROM
185# define FROM_LOOP_MAX_NEEDED_FROM MAX_NEEDED_FROM
186#endif
187#ifndef FROM_LOOP_MIN_NEEDED_TO
188# define FROM_LOOP_MIN_NEEDED_TO MIN_NEEDED_TO
189#endif
190#ifndef FROM_LOOP_MAX_NEEDED_TO
191# define FROM_LOOP_MAX_NEEDED_TO MAX_NEEDED_TO
192#endif
193#ifndef TO_LOOP_MIN_NEEDED_FROM
194# define TO_LOOP_MIN_NEEDED_FROM MIN_NEEDED_TO
195#endif
196#ifndef TO_LOOP_MAX_NEEDED_FROM
197# define TO_LOOP_MAX_NEEDED_FROM MAX_NEEDED_TO
198#endif
199#ifndef TO_LOOP_MIN_NEEDED_TO
200# define TO_LOOP_MIN_NEEDED_TO MIN_NEEDED_FROM
201#endif
202#ifndef TO_LOOP_MAX_NEEDED_TO
203# define TO_LOOP_MAX_NEEDED_TO MAX_NEEDED_FROM
204#endif
205
206
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))
214
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)
218#else
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])
229
230# define put16u(addr, val) \
231 ({ uint16_t __val = (val); \
232 ((unsigned char *) (addr))[0] = __val; \
233 ((unsigned char *) (addr))[1] = __val >> 8; \
234 (void) 0; })
235# define put32u(addr, val) \
236 ({ uint32_t __val = (val); \
237 ((unsigned char *) (addr))[0] = __val; \
238 __val >>= 8; \
239 ((unsigned char *) (addr))[1] = __val; \
240 __val >>= 8; \
241 ((unsigned char *) (addr))[2] = __val; \
242 __val >>= 8; \
243 ((unsigned char *) (addr))[3] = __val; \
244 (void) 0; })
245# else
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])
254
255# define put16u(addr, val) \
256 ({ uint16_t __val = (val); \
257 ((unsigned char *) (addr))[1] = __val; \
258 ((unsigned char *) (addr))[0] = __val >> 8; \
259 (void) 0; })
260# define put32u(addr, val) \
261 ({ uint32_t __val = (val); \
262 ((unsigned char *) (addr))[3] = __val; \
263 __val >>= 8; \
264 ((unsigned char *) (addr))[2] = __val; \
265 __val >>= 8; \
266 ((unsigned char *) (addr))[1] = __val; \
267 __val >>= 8; \
268 ((unsigned char *) (addr))[0] = __val; \
269 (void) 0; })
270# endif
271#endif
272
273
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) \
287 { \
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 \
294 ? : 1); \
295 else \
296 *inptrp -= ((outbuf - outerr) / FROM_LOOP_MIN_NEEDED_TO) \
297 * FROM_LOOP_MIN_NEEDED_FROM; \
298 } \
299 else \
300 { \
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); \
307 else \
308 *inptrp -= ((outbuf - outerr) / TO_LOOP_MIN_NEEDED_TO) \
309 * TO_LOOP_MIN_NEEDED_FROM; \
310 }
311# endif
312#endif
313
314
315/* The default init function. It simply matches the name and initializes
316 the step data to point to one of the objects above. */
317#if DEFINE_INIT
318# ifndef CHARSET_NAME
319# error "CHARSET_NAME not defined"
320# endif
321
322extern int gconv_init (struct __gconv_step *step);
323int
324gconv_init (struct __gconv_step *step)
325{
326 /* Determine which direction. */
327 if (strcmp (step->__from_name, CHARSET_NAME) == 0)
328 {
329 step->__data = FROM_DIRECTION_VAL;
330
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;
335
336#ifdef FROM_ONEBYTE
337 step->__btowc_fct = FROM_ONEBYTE;
338#endif
339 }
340 else if (__builtin_expect (strcmp (step->__to_name, CHARSET_NAME), 0) == 0)
341 {
342 step->__data = TO_DIRECTION_VAL;
343
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;
348 }
349 else
350 return __GCONV_NOCONV;
351
352#ifdef SAVE_RESET_STATE
353 step->__stateful = 1;
354#else
355 step->__stateful = 0;
356#endif
357
358 return __GCONV_OK;
359}
360#endif
361
362
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. */
366#if DEFINE_FINI
367#endif
368
369
370/* If no arguments have to passed to the loop function define the macro
371 as empty. */
372#ifndef EXTRA_LOOP_ARGS
373# define EXTRA_LOOP_ARGS
374#endif
375
376
377/* This is the actual conversion function. */
378#ifndef FUNCTION_NAME
379# define FUNCTION_NAME gconv
380#endif
381
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
385
386
387extern 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);
393int
394FUNCTION_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)
398{
399 struct __gconv_step *next_step = step + 1;
400 struct __gconv_step_data *next_data = data + 1;
401 __gconv_fct fct = NULL;
402 int status;
403
404 if ((data->__flags & __GCONV_IS_LAST) == 0)
405 {
406 fct = next_step->__fct;
407 if (next_step->__shlib_handle != NULL)
408 PTR_DEMANGLE (fct);
409 }
410
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
413 dropped. */
414 if (__glibc_unlikely (do_flush))
415 {
416 /* This should never happen during error handling. */
417 assert (outbufstart == NULL);
418
419 status = __GCONV_OK;
420
421#ifdef EMIT_SHIFT_TO_INIT
422 if (do_flush == 1)
423 {
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;
428
429# ifdef PREPARE_LOOP
430 PREPARE_LOOP
431# endif
432
433# ifdef SAVE_RESET_STATE
434 SAVE_RESET_STATE (1);
435# endif
436
437 /* Emit the escape sequence to reset the state. */
438 EMIT_SHIFT_TO_INIT;
439
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
444 clean state. */
445 if (status == __GCONV_OK)
446 {
447 if (data->__flags & __GCONV_IS_LAST)
448 /* Store information about how many bytes are available. */
449 data->__outbuf = outbuf;
450 else
451 {
452 /* Write out all output which was produced. */
453 if (outbuf > outstart)
454 {
455 const unsigned char *outerr = outstart;
456 int result;
457
458 result = DL_CALL_FCT (fct, (next_step, next_data,
459 &outerr, outbuf, NULL,
460 irreversible, 0,
461 consume_incomplete));
462
463 if (result != __GCONV_EMPTY_INPUT)
464 {
465 if (__glibc_unlikely (outerr != outbuf))
466 {
467 /* We have a problem. Undo the conversion. */
468 outbuf = outstart;
469
470 /* Restore the state. */
471# ifdef SAVE_RESET_STATE
472 SAVE_RESET_STATE (0);
473# endif
474 }
475
476 /* Change the status. */
477 status = result;
478 }
479 }
480
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));
486 }
487 }
488 }
489 else
490#endif
491 {
492 /* Clear the state object. There might be bytes in there from
493 previous calls with CONSUME_INCOMPLETE == 1. But don't emit
494 escape sequences. */
495 memset (data->__statep, '\0', sizeof (*data->__statep));
496
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));
502 }
503 }
504 else
505 {
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;
517
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
538 int unaligned;
539# define GEN_unaligned(name) GEN_unaligned2 (name)
540# define GEN_unaligned2(name) name##_unaligned
541#else
542# define unaligned 0
543#endif
544
545#ifdef PREPARE_LOOP
546 PREPARE_LOOP
547#endif
548
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)
557 {
558 /* Yep, we have some bytes left over. Process them now.
559 But this must not happen while we are called from an
560 error handler. */
561 assert (outbufstart == NULL);
562
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
567 EXTRA_LOOP_ARGS);
568# endif
569# if !ONE_DIRECTION
570# if FROM_LOOP_MAX_NEEDED_FROM > 1 && TO_LOOP_MAX_NEEDED_FROM > 1
571 else
572# endif
573# if TO_LOOP_MAX_NEEDED_FROM > 1
574 status = SINGLE(TO_LOOP) (step, data, inptrp, inend, &outbuf,
575 outend, lirreversiblep EXTRA_LOOP_ARGS);
576# endif
577# endif
578
579 if (__builtin_expect (status, __GCONV_OK) != __GCONV_OK)
580 return status;
581 }
582#endif
583
584#if POSSIBLY_UNALIGNED
585 unaligned =
586 ((FROM_DIRECTION
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)))
590 || (!FROM_DIRECTION
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)));
594#endif
595
596 while (1)
597 {
598 /* Remember the start value for this round. */
599 inptr = *inptrp;
600 /* The outbuf buffer is empty. */
601 outstart = outbuf;
602#ifdef RESET_INPUT_BUFFER
603 /* Remember how many irreversible characters were skipped before
604 this round. */
605 size_t loop_irreversible
606 = lirreversible + (irreversible ? *irreversible : 0);
607#endif
608
609#ifdef SAVE_RESET_STATE
610 SAVE_RESET_STATE (1);
611#endif
612
613 if (__glibc_likely (!unaligned))
614 {
615 if (FROM_DIRECTION)
616 /* Run the conversion loop. */
617 status = FROM_LOOP (step, data, inptrp, inend, &outbuf, outend,
618 lirreversiblep EXTRA_LOOP_ARGS);
619 else
620 /* Run the conversion loop. */
621 status = TO_LOOP (step, data, inptrp, inend, &outbuf, outend,
622 lirreversiblep EXTRA_LOOP_ARGS);
623 }
624#if POSSIBLY_UNALIGNED
625 else
626 {
627 if (FROM_DIRECTION)
628 /* Run the conversion loop. */
629 status = GEN_unaligned (FROM_LOOP) (step, data, inptrp, inend,
630 &outbuf, outend,
631 lirreversiblep
632 EXTRA_LOOP_ARGS);
633 else
634 /* Run the conversion loop. */
635 status = GEN_unaligned (TO_LOOP) (step, data, inptrp, inend,
636 &outbuf, outend,
637 lirreversiblep
638 EXTRA_LOOP_ARGS);
639 }
640#endif
641
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))
645 {
646 *outbufstart = outbuf;
647 return status;
648 }
649
650 /* We finished one use of the loops. */
651 ++data->__invocation_counter;
652
653 /* If this is the last step leave the loop, there is nothing
654 we can do. */
655 if (__glibc_unlikely (data->__flags & __GCONV_IS_LAST))
656 {
657 /* Store information about how many bytes are available. */
658 data->__outbuf = outbuf;
659
660 /* Remember how many non-identical characters we
661 converted in an irreversible way. */
662 *irreversible += lirreversible;
663
664 break;
665 }
666
667 /* Write out all output which was produced. */
668 if (__glibc_likely (outbuf > outstart))
669 {
670 const unsigned char *outerr = data->__outbuf;
671 int result;
672
673 result = DL_CALL_FCT (fct, (next_step, next_data, &outerr,
674 outbuf, NULL, irreversible, 0,
675 consume_incomplete));
676
677 if (result != __GCONV_EMPTY_INPUT)
678 {
679 if (__glibc_unlikely (outerr != outbuf))
680 {
681#ifdef RESET_INPUT_BUFFER
682 /* RESET_INPUT_BUFFER can only work when there were
683 no new irreversible characters skipped during
684 this round. */
685 if (loop_irreversible
686 == lirreversible + (irreversible ? *irreversible : 0))
687 {
688 RESET_INPUT_BUFFER;
689 goto done_reset;
690 }
691#endif
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));
695
696 /* Reload the pointers. */
697 *inptrp = inptr;
698 outbuf = outstart;
699
700 /* Restore the state. */
701#ifdef SAVE_RESET_STATE
702 SAVE_RESET_STATE (0);
703#endif
704
705 if (__glibc_likely (!unaligned))
706 {
707 if (FROM_DIRECTION)
708 /* Run the conversion loop. */
709 nstatus = FROM_LOOP (step, data, inptrp, inend,
710 &outbuf, outerr,
711 lirreversiblep
712 EXTRA_LOOP_ARGS);
713 else
714 /* Run the conversion loop. */
715 nstatus = TO_LOOP (step, data, inptrp, inend,
716 &outbuf, outerr,
717 lirreversiblep
718 EXTRA_LOOP_ARGS);
719 }
720#if POSSIBLY_UNALIGNED
721 else
722 {
723 if (FROM_DIRECTION)
724 /* Run the conversion loop. */
725 nstatus = GEN_unaligned (FROM_LOOP) (step, data,
726 inptrp, inend,
727 &outbuf,
728 outerr,
729 lirreversiblep
730 EXTRA_LOOP_ARGS);
731 else
732 /* Run the conversion loop. */
733 nstatus = GEN_unaligned (TO_LOOP) (step, data,
734 inptrp, inend,
735 &outbuf, outerr,
736 lirreversiblep
737 EXTRA_LOOP_ARGS);
738 }
739#endif
740
741 /* We must run out of output buffer space in this
742 rerun. */
743 assert (outbuf == outerr);
744 assert (nstatus == __GCONV_FULL_OUTPUT);
745
746 /* If we haven't consumed a single byte decrement
747 the invocation counter. */
748 if (__glibc_unlikely (outbuf == outstart))
749 --data->__invocation_counter;
750 }
751
752#ifdef RESET_INPUT_BUFFER
753 done_reset:
754#endif
755 /* Change the status. */
756 status = result;
757 }
758 else
759 /* All the output is consumed, we can make another run
760 if everything was ok. */
761 if (status == __GCONV_FULL_OUTPUT)
762 {
763 status = __GCONV_OK;
764 outbuf = data->__outbuf;
765 }
766 }
767
768 if (status != __GCONV_OK)
769 break;
770
771 /* Reset the output buffer pointer for the next round. */
772 outbuf = data->__outbuf;
773 }
774
775#ifdef END_LOOP
776 END_LOOP
777#endif
778
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)
787 {
788# ifdef STORE_REST
789 mbstate_t *state = data->__statep;
790
791 STORE_REST
792# else
793 /* Make sure the remaining bytes fit into the state objects
794 buffer. */
795 size_t cnt_after = inend - *inptrp;
796 assert (cnt_after <= sizeof (data->__statep->__value.__wchb));
797
798 size_t cnt;
799 for (cnt = 0; cnt < cnt_after; ++cnt)
800 data->__statep->__value.__wchb[cnt] = (*inptrp)[cnt];
801 *inptrp = inend;
802 data->__statep->__count &= ~7;
803 data->__statep->__count |= cnt;
804# endif
805 }
806#endif
807#undef unaligned
808#undef POSSIBLY_UNALIGNED
809 }
810
811 return status;
812}
813
814#undef DEFINE_INIT
815#undef CHARSET_NAME
816#undef DEFINE_FINI
817#undef MIN_NEEDED_FROM
818#undef MIN_NEEDED_TO
819#undef MAX_NEEDED_FROM
820#undef MAX_NEEDED_TO
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
831#undef FROM_LOOP
832#undef TO_LOOP
833#undef ONE_DIRECTION
834#undef SAVE_RESET_STATE
835#undef RESET_INPUT_BUFFER
836#undef FUNCTION_NAME
837#undef PREPARE_LOOP
838#undef END_LOOP
839#undef EXTRA_LOOP_ARGS
840#undef STORE_REST
841#undef FROM_ONEBYTE
842