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