1/* Skeleton for a conversion module.
2 Copyright (C) 1998-2019 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 <http://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
87 FUNCTION_NAME if not set the conversion function is named `gconv'.
88
89 PREPARE_LOOP optional code preparing the conversion loop. Can
90 contain variable definitions.
91 END_LOOP also optional, may be used to store information
92
93 EXTRA_LOOP_ARGS optional macro specifying extra arguments passed
94 to loop function.
95
96 STORE_REST optional, needed only when MAX_NEEDED_FROM > 4.
97 This macro stores the seen but unconverted input bytes
98 in the state.
99
100 FROM_ONEBYTE optional. If defined, should be the name of a
101 specialized conversion function for a single byte
102 from the current character set to INTERNAL. This
103 function has prototype
104 wint_t
105 FROM_ONEBYTE (struct __gconv_step *, unsigned char);
106 and does a special conversion:
107 - The input is a single byte.
108 - The output is a single uint32_t.
109 - The state before the conversion is the initial state;
110 the state after the conversion is irrelevant.
111 - No transliteration.
112 - __invocation_counter = 0.
113 - __internal_use = 1.
114 - do_flush = 0.
115
116 Modules can use mbstate_t to store conversion state as follows:
117
118 * Bits 2..0 of '__count' contain the number of lookahead input bytes
119 stored in __value.__wchb. Always zero if the converter never
120 returns __GCONV_INCOMPLETE_INPUT.
121
122 * Bits 31..3 of '__count' are module dependent shift state.
123
124 * __value: When STORE_REST/UNPACK_BYTES aren't defined and when the
125 converter has returned __GCONV_INCOMPLETE_INPUT, this contains
126 at most 4 lookahead bytes. Converters with an mb_cur_max > 4
127 (currently only UTF-8) must find a way to store their state
128 in __value.__wch and define STORE_REST/UNPACK_BYTES appropriately.
129
130 When __value contains lookahead, __count must not be zero, because
131 the converter is not in the initial state then, and mbsinit() --
132 defined as a (__count == 0) test -- must reflect this.
133 */
134
135#include <assert.h>
136#include <gconv.h>
137#include <string.h>
138#define __need_size_t
139#define __need_NULL
140#include <stddef.h>
141
142#ifndef STATIC_GCONV
143# include <dlfcn.h>
144#endif
145
146#include <sysdep.h>
147#include <stdint.h>
148
149#ifndef DL_CALL_FCT
150# define DL_CALL_FCT(fct, args) fct args
151#endif
152
153/* The direction objects. */
154#if DEFINE_INIT
155# ifndef FROM_DIRECTION
156# define FROM_DIRECTION_VAL NULL
157# define TO_DIRECTION_VAL ((void *) ~((uintptr_t) 0))
158# define FROM_DIRECTION (step->__data == FROM_DIRECTION_VAL)
159# endif
160#else
161# ifndef FROM_DIRECTION
162# error "FROM_DIRECTION must be provided if non-default init is used"
163# endif
164#endif
165
166/* How many bytes are needed at most for the from-charset. */
167#ifndef MAX_NEEDED_FROM
168# define MAX_NEEDED_FROM MIN_NEEDED_FROM
169#endif
170
171/* Same for the to-charset. */
172#ifndef MAX_NEEDED_TO
173# define MAX_NEEDED_TO MIN_NEEDED_TO
174#endif
175
176/* Defaults for the per-direction min/max constants. */
177#ifndef FROM_LOOP_MIN_NEEDED_FROM
178# define FROM_LOOP_MIN_NEEDED_FROM MIN_NEEDED_FROM
179#endif
180#ifndef FROM_LOOP_MAX_NEEDED_FROM
181# define FROM_LOOP_MAX_NEEDED_FROM MAX_NEEDED_FROM
182#endif
183#ifndef FROM_LOOP_MIN_NEEDED_TO
184# define FROM_LOOP_MIN_NEEDED_TO MIN_NEEDED_TO
185#endif
186#ifndef FROM_LOOP_MAX_NEEDED_TO
187# define FROM_LOOP_MAX_NEEDED_TO MAX_NEEDED_TO
188#endif
189#ifndef TO_LOOP_MIN_NEEDED_FROM
190# define TO_LOOP_MIN_NEEDED_FROM MIN_NEEDED_TO
191#endif
192#ifndef TO_LOOP_MAX_NEEDED_FROM
193# define TO_LOOP_MAX_NEEDED_FROM MAX_NEEDED_TO
194#endif
195#ifndef TO_LOOP_MIN_NEEDED_TO
196# define TO_LOOP_MIN_NEEDED_TO MIN_NEEDED_FROM
197#endif
198#ifndef TO_LOOP_MAX_NEEDED_TO
199# define TO_LOOP_MAX_NEEDED_TO MAX_NEEDED_FROM
200#endif
201
202
203/* Define macros which can access unaligned buffers. These macros are
204 supposed to be used only in code outside the inner loops. For the inner
205 loops we have other definitions which allow optimized access. */
206#if _STRING_ARCH_unaligned
207/* We can handle unaligned memory access. */
208# define get16u(addr) *((const uint16_t *) (addr))
209# define get32u(addr) *((const uint32_t *) (addr))
210
211/* We need no special support for writing values either. */
212# define put16u(addr, val) *((uint16_t *) (addr)) = (val)
213# define put32u(addr, val) *((uint32_t *) (addr)) = (val)
214#else
215/* Distinguish between big endian and little endian. */
216# if __BYTE_ORDER == __LITTLE_ENDIAN
217# define get16u(addr) \
218 (((const unsigned char *) (addr))[1] << 8 \
219 | ((const unsigned char *) (addr))[0])
220# define get32u(addr) \
221 (((((const unsigned char *) (addr))[3] << 8 \
222 | ((const unsigned char *) (addr))[2]) << 8 \
223 | ((const unsigned char *) (addr))[1]) << 8 \
224 | ((const unsigned char *) (addr))[0])
225
226# define put16u(addr, val) \
227 ({ uint16_t __val = (val); \
228 ((unsigned char *) (addr))[0] = __val; \
229 ((unsigned char *) (addr))[1] = __val >> 8; \
230 (void) 0; })
231# define put32u(addr, val) \
232 ({ uint32_t __val = (val); \
233 ((unsigned char *) (addr))[0] = __val; \
234 __val >>= 8; \
235 ((unsigned char *) (addr))[1] = __val; \
236 __val >>= 8; \
237 ((unsigned char *) (addr))[2] = __val; \
238 __val >>= 8; \
239 ((unsigned char *) (addr))[3] = __val; \
240 (void) 0; })
241# else
242# define get16u(addr) \
243 (((const unsigned char *) (addr))[0] << 8 \
244 | ((const unsigned char *) (addr))[1])
245# define get32u(addr) \
246 (((((const unsigned char *) (addr))[0] << 8 \
247 | ((const unsigned char *) (addr))[1]) << 8 \
248 | ((const unsigned char *) (addr))[2]) << 8 \
249 | ((const unsigned char *) (addr))[3])
250
251# define put16u(addr, val) \
252 ({ uint16_t __val = (val); \
253 ((unsigned char *) (addr))[1] = __val; \
254 ((unsigned char *) (addr))[0] = __val >> 8; \
255 (void) 0; })
256# define put32u(addr, val) \
257 ({ uint32_t __val = (val); \
258 ((unsigned char *) (addr))[3] = __val; \
259 __val >>= 8; \
260 ((unsigned char *) (addr))[2] = __val; \
261 __val >>= 8; \
262 ((unsigned char *) (addr))[1] = __val; \
263 __val >>= 8; \
264 ((unsigned char *) (addr))[0] = __val; \
265 (void) 0; })
266# endif
267#endif
268
269
270/* For conversions from a fixed width character set to another fixed width
271 character set we can define RESET_INPUT_BUFFER in a very fast way. */
272#if !defined RESET_INPUT_BUFFER && !defined SAVE_RESET_STATE
273# if FROM_LOOP_MIN_NEEDED_FROM == FROM_LOOP_MAX_NEEDED_FROM \
274 && FROM_LOOP_MIN_NEEDED_TO == FROM_LOOP_MAX_NEEDED_TO \
275 && TO_LOOP_MIN_NEEDED_FROM == TO_LOOP_MAX_NEEDED_FROM \
276 && TO_LOOP_MIN_NEEDED_TO == TO_LOOP_MAX_NEEDED_TO
277/* We have to use these `if's here since the compiler cannot know that
278 (outbuf - outerr) is always divisible by FROM/TO_LOOP_MIN_NEEDED_TO.
279 The ?:1 avoids division by zero warnings that gcc 3.2 emits even for
280 obviously unreachable code. */
281# define RESET_INPUT_BUFFER \
282 if (FROM_DIRECTION) \
283 { \
284 if (FROM_LOOP_MIN_NEEDED_FROM % FROM_LOOP_MIN_NEEDED_TO == 0) \
285 *inptrp -= (outbuf - outerr) \
286 * (FROM_LOOP_MIN_NEEDED_FROM / FROM_LOOP_MIN_NEEDED_TO); \
287 else if (FROM_LOOP_MIN_NEEDED_TO % FROM_LOOP_MIN_NEEDED_FROM == 0) \
288 *inptrp -= (outbuf - outerr) \
289 / (FROM_LOOP_MIN_NEEDED_TO / FROM_LOOP_MIN_NEEDED_FROM \
290 ? : 1); \
291 else \
292 *inptrp -= ((outbuf - outerr) / FROM_LOOP_MIN_NEEDED_TO) \
293 * FROM_LOOP_MIN_NEEDED_FROM; \
294 } \
295 else \
296 { \
297 if (TO_LOOP_MIN_NEEDED_FROM % TO_LOOP_MIN_NEEDED_TO == 0) \
298 *inptrp -= (outbuf - outerr) \
299 * (TO_LOOP_MIN_NEEDED_FROM / TO_LOOP_MIN_NEEDED_TO); \
300 else if (TO_LOOP_MIN_NEEDED_TO % TO_LOOP_MIN_NEEDED_FROM == 0) \
301 *inptrp -= (outbuf - outerr) \
302 / (TO_LOOP_MIN_NEEDED_TO / TO_LOOP_MIN_NEEDED_FROM ? : 1); \
303 else \
304 *inptrp -= ((outbuf - outerr) / TO_LOOP_MIN_NEEDED_TO) \
305 * TO_LOOP_MIN_NEEDED_FROM; \
306 }
307# endif
308#endif
309
310
311/* The default init function. It simply matches the name and initializes
312 the step data to point to one of the objects above. */
313#if DEFINE_INIT
314# ifndef CHARSET_NAME
315# error "CHARSET_NAME not defined"
316# endif
317
318extern int gconv_init (struct __gconv_step *step);
319int
320gconv_init (struct __gconv_step *step)
321{
322 /* Determine which direction. */
323 if (strcmp (step->__from_name, CHARSET_NAME) == 0)
324 {
325 step->__data = FROM_DIRECTION_VAL;
326
327 step->__min_needed_from = FROM_LOOP_MIN_NEEDED_FROM;
328 step->__max_needed_from = FROM_LOOP_MAX_NEEDED_FROM;
329 step->__min_needed_to = FROM_LOOP_MIN_NEEDED_TO;
330 step->__max_needed_to = FROM_LOOP_MAX_NEEDED_TO;
331
332#ifdef FROM_ONEBYTE
333 step->__btowc_fct = FROM_ONEBYTE;
334#endif
335 }
336 else if (__builtin_expect (strcmp (step->__to_name, CHARSET_NAME), 0) == 0)
337 {
338 step->__data = TO_DIRECTION_VAL;
339
340 step->__min_needed_from = TO_LOOP_MIN_NEEDED_FROM;
341 step->__max_needed_from = TO_LOOP_MAX_NEEDED_FROM;
342 step->__min_needed_to = TO_LOOP_MIN_NEEDED_TO;
343 step->__max_needed_to = TO_LOOP_MAX_NEEDED_TO;
344 }
345 else
346 return __GCONV_NOCONV;
347
348#ifdef SAVE_RESET_STATE
349 step->__stateful = 1;
350#else
351 step->__stateful = 0;
352#endif
353
354 return __GCONV_OK;
355}
356#endif
357
358
359/* The default destructor function does nothing in the moment and so
360 we don't define it at all. But we still provide the macro just in
361 case we need it some day. */
362#if DEFINE_FINI
363#endif
364
365
366/* If no arguments have to passed to the loop function define the macro
367 as empty. */
368#ifndef EXTRA_LOOP_ARGS
369# define EXTRA_LOOP_ARGS
370#endif
371
372
373/* This is the actual conversion function. */
374#ifndef FUNCTION_NAME
375# define FUNCTION_NAME gconv
376#endif
377
378/* The macros are used to access the function to convert single characters. */
379#define SINGLE(fct) SINGLE2 (fct)
380#define SINGLE2(fct) fct##_single
381
382
383extern int FUNCTION_NAME (struct __gconv_step *step,
384 struct __gconv_step_data *data,
385 const unsigned char **inptrp,
386 const unsigned char *inend,
387 unsigned char **outbufstart, size_t *irreversible,
388 int do_flush, int consume_incomplete);
389int
390FUNCTION_NAME (struct __gconv_step *step, struct __gconv_step_data *data,
391 const unsigned char **inptrp, const unsigned char *inend,
392 unsigned char **outbufstart, size_t *irreversible, int do_flush,
393 int consume_incomplete)
394{
395 struct __gconv_step *next_step = step + 1;
396 struct __gconv_step_data *next_data = data + 1;
397 __gconv_fct fct = NULL;
398 int status;
399
400 if ((data->__flags & __GCONV_IS_LAST) == 0)
401 {
402 fct = next_step->__fct;
403#ifdef PTR_DEMANGLE
404 if (next_step->__shlib_handle != NULL)
405 PTR_DEMANGLE (fct);
406#endif
407 }
408
409 /* If the function is called with no input this means we have to reset
410 to the initial state. The possibly partly converted input is
411 dropped. */
412 if (__glibc_unlikely (do_flush))
413 {
414 /* This should never happen during error handling. */
415 assert (outbufstart == NULL);
416
417 status = __GCONV_OK;
418
419#ifdef EMIT_SHIFT_TO_INIT
420 if (do_flush == 1)
421 {
422 /* We preserve the initial values of the pointer variables. */
423 unsigned char *outbuf = data->__outbuf;
424 unsigned char *outstart = outbuf;
425 unsigned char *outend = data->__outbufend;
426
427# ifdef PREPARE_LOOP
428 PREPARE_LOOP
429# endif
430
431# ifdef SAVE_RESET_STATE
432 SAVE_RESET_STATE (1);
433# endif
434
435 /* Emit the escape sequence to reset the state. */
436 EMIT_SHIFT_TO_INIT;
437
438 /* Call the steps down the chain if there are any but only if we
439 successfully emitted the escape sequence. This should only
440 fail if the output buffer is full. If the input is invalid
441 it should be discarded since the user wants to start from a
442 clean state. */
443 if (status == __GCONV_OK)
444 {
445 if (data->__flags & __GCONV_IS_LAST)
446 /* Store information about how many bytes are available. */
447 data->__outbuf = outbuf;
448 else
449 {
450 /* Write out all output which was produced. */
451 if (outbuf > outstart)
452 {
453 const unsigned char *outerr = outstart;
454 int result;
455
456 result = DL_CALL_FCT (fct, (next_step, next_data,
457 &outerr, outbuf, NULL,
458 irreversible, 0,
459 consume_incomplete));
460
461 if (result != __GCONV_EMPTY_INPUT)
462 {
463 if (__glibc_unlikely (outerr != outbuf))
464 {
465 /* We have a problem. Undo the conversion. */
466 outbuf = outstart;
467
468 /* Restore the state. */
469# ifdef SAVE_RESET_STATE
470 SAVE_RESET_STATE (0);
471# endif
472 }
473
474 /* Change the status. */
475 status = result;
476 }
477 }
478
479 if (status == __GCONV_OK)
480 /* Now flush the remaining steps. */
481 status = DL_CALL_FCT (fct, (next_step, next_data, NULL,
482 NULL, NULL, irreversible, 1,
483 consume_incomplete));
484 }
485 }
486 }
487 else
488#endif
489 {
490 /* Clear the state object. There might be bytes in there from
491 previous calls with CONSUME_INCOMPLETE == 1. But don't emit
492 escape sequences. */
493 memset (data->__statep, '\0', sizeof (*data->__statep));
494
495 if (! (data->__flags & __GCONV_IS_LAST))
496 /* Now flush the remaining steps. */
497 status = DL_CALL_FCT (fct, (next_step, next_data, NULL, NULL,
498 NULL, irreversible, do_flush,
499 consume_incomplete));
500 }
501 }
502 else
503 {
504 /* We preserve the initial values of the pointer variables,
505 but only some conversion modules need it. */
506 const unsigned char *inptr __attribute__ ((__unused__)) = *inptrp;
507 unsigned char *outbuf = (__builtin_expect (outbufstart == NULL, 1)
508 ? data->__outbuf : *outbufstart);
509 unsigned char *outend = data->__outbufend;
510 unsigned char *outstart;
511 /* This variable is used to count the number of characters we
512 actually converted. */
513 size_t lirreversible = 0;
514 size_t *lirreversiblep = irreversible ? &lirreversible : NULL;
515
516 /* The following assumes that encodings, which have a variable length
517 what might unalign a buffer even though it is an aligned in the
518 beginning, either don't have the minimal number of bytes as a divisor
519 of the maximum length or have a minimum length of 1. This is true
520 for all known and supported encodings.
521 We use && instead of || to combine the subexpression for the FROM
522 encoding and for the TO encoding, because usually one of them is
523 INTERNAL, for which the subexpression evaluates to 1, but INTERNAL
524 buffers are always aligned correctly. */
525#define POSSIBLY_UNALIGNED \
526 (!_STRING_ARCH_unaligned \
527 && (((FROM_LOOP_MIN_NEEDED_FROM != 1 \
528 && FROM_LOOP_MAX_NEEDED_FROM % FROM_LOOP_MIN_NEEDED_FROM == 0) \
529 && (FROM_LOOP_MIN_NEEDED_TO != 1 \
530 && FROM_LOOP_MAX_NEEDED_TO % FROM_LOOP_MIN_NEEDED_TO == 0)) \
531 || ((TO_LOOP_MIN_NEEDED_FROM != 1 \
532 && TO_LOOP_MAX_NEEDED_FROM % TO_LOOP_MIN_NEEDED_FROM == 0) \
533 && (TO_LOOP_MIN_NEEDED_TO != 1 \
534 && TO_LOOP_MAX_NEEDED_TO % TO_LOOP_MIN_NEEDED_TO == 0))))
535#if POSSIBLY_UNALIGNED
536 int unaligned;
537# define GEN_unaligned(name) GEN_unaligned2 (name)
538# define GEN_unaligned2(name) name##_unaligned
539#else
540# define unaligned 0
541#endif
542
543#ifdef PREPARE_LOOP
544 PREPARE_LOOP
545#endif
546
547#if FROM_LOOP_MAX_NEEDED_FROM > 1 || TO_LOOP_MAX_NEEDED_FROM > 1
548 /* If the function is used to implement the mb*towc*() or wc*tomb*()
549 functions we must test whether any bytes from the last call are
550 stored in the `state' object. */
551 if (((FROM_LOOP_MAX_NEEDED_FROM > 1 && TO_LOOP_MAX_NEEDED_FROM > 1)
552 || (FROM_LOOP_MAX_NEEDED_FROM > 1 && FROM_DIRECTION)
553 || (TO_LOOP_MAX_NEEDED_FROM > 1 && !FROM_DIRECTION))
554 && consume_incomplete && (data->__statep->__count & 7) != 0)
555 {
556 /* Yep, we have some bytes left over. Process them now.
557 But this must not happen while we are called from an
558 error handler. */
559 assert (outbufstart == NULL);
560
561# if FROM_LOOP_MAX_NEEDED_FROM > 1
562 if (TO_LOOP_MAX_NEEDED_FROM == 1 || FROM_DIRECTION)
563 status = SINGLE(FROM_LOOP) (step, data, inptrp, inend, &outbuf,
564 outend, lirreversiblep
565 EXTRA_LOOP_ARGS);
566# endif
567# if !ONE_DIRECTION
568# if FROM_LOOP_MAX_NEEDED_FROM > 1 && TO_LOOP_MAX_NEEDED_FROM > 1
569 else
570# endif
571# if TO_LOOP_MAX_NEEDED_FROM > 1
572 status = SINGLE(TO_LOOP) (step, data, inptrp, inend, &outbuf,
573 outend, lirreversiblep EXTRA_LOOP_ARGS);
574# endif
575# endif
576
577 if (__builtin_expect (status, __GCONV_OK) != __GCONV_OK)
578 return status;
579 }
580#endif
581
582#if POSSIBLY_UNALIGNED
583 unaligned =
584 ((FROM_DIRECTION
585 && ((uintptr_t) inptr % FROM_LOOP_MIN_NEEDED_FROM != 0
586 || ((data->__flags & __GCONV_IS_LAST)
587 && (uintptr_t) outbuf % FROM_LOOP_MIN_NEEDED_TO != 0)))
588 || (!FROM_DIRECTION
589 && (((data->__flags & __GCONV_IS_LAST)
590 && (uintptr_t) outbuf % TO_LOOP_MIN_NEEDED_TO != 0)
591 || (uintptr_t) inptr % TO_LOOP_MIN_NEEDED_FROM != 0)));
592#endif
593
594 while (1)
595 {
596 /* Remember the start value for this round. */
597 inptr = *inptrp;
598 /* The outbuf buffer is empty. */
599 outstart = outbuf;
600
601#ifdef SAVE_RESET_STATE
602 SAVE_RESET_STATE (1);
603#endif
604
605 if (__glibc_likely (!unaligned))
606 {
607 if (FROM_DIRECTION)
608 /* Run the conversion loop. */
609 status = FROM_LOOP (step, data, inptrp, inend, &outbuf, outend,
610 lirreversiblep EXTRA_LOOP_ARGS);
611 else
612 /* Run the conversion loop. */
613 status = TO_LOOP (step, data, inptrp, inend, &outbuf, outend,
614 lirreversiblep EXTRA_LOOP_ARGS);
615 }
616#if POSSIBLY_UNALIGNED
617 else
618 {
619 if (FROM_DIRECTION)
620 /* Run the conversion loop. */
621 status = GEN_unaligned (FROM_LOOP) (step, data, inptrp, inend,
622 &outbuf, outend,
623 lirreversiblep
624 EXTRA_LOOP_ARGS);
625 else
626 /* Run the conversion loop. */
627 status = GEN_unaligned (TO_LOOP) (step, data, inptrp, inend,
628 &outbuf, outend,
629 lirreversiblep
630 EXTRA_LOOP_ARGS);
631 }
632#endif
633
634 /* If we were called as part of an error handling module we
635 don't do anything else here. */
636 if (__glibc_unlikely (outbufstart != NULL))
637 {
638 *outbufstart = outbuf;
639 return status;
640 }
641
642 /* We finished one use of the loops. */
643 ++data->__invocation_counter;
644
645 /* If this is the last step leave the loop, there is nothing
646 we can do. */
647 if (__glibc_unlikely (data->__flags & __GCONV_IS_LAST))
648 {
649 /* Store information about how many bytes are available. */
650 data->__outbuf = outbuf;
651
652 /* Remember how many non-identical characters we
653 converted in an irreversible way. */
654 *irreversible += lirreversible;
655
656 break;
657 }
658
659 /* Write out all output which was produced. */
660 if (__glibc_likely (outbuf > outstart))
661 {
662 const unsigned char *outerr = data->__outbuf;
663 int result;
664
665 result = DL_CALL_FCT (fct, (next_step, next_data, &outerr,
666 outbuf, NULL, irreversible, 0,
667 consume_incomplete));
668
669 if (result != __GCONV_EMPTY_INPUT)
670 {
671 if (__glibc_unlikely (outerr != outbuf))
672 {
673#ifdef RESET_INPUT_BUFFER
674 RESET_INPUT_BUFFER;
675#else
676 /* We have a problem in one of the functions below.
677 Undo the conversion upto the error point. */
678 size_t nstatus __attribute__ ((unused));
679
680 /* Reload the pointers. */
681 *inptrp = inptr;
682 outbuf = outstart;
683
684 /* Restore the state. */
685# ifdef SAVE_RESET_STATE
686 SAVE_RESET_STATE (0);
687# endif
688
689 if (__glibc_likely (!unaligned))
690 {
691 if (FROM_DIRECTION)
692 /* Run the conversion loop. */
693 nstatus = FROM_LOOP (step, data, inptrp, inend,
694 &outbuf, outerr,
695 lirreversiblep
696 EXTRA_LOOP_ARGS);
697 else
698 /* Run the conversion loop. */
699 nstatus = TO_LOOP (step, data, inptrp, inend,
700 &outbuf, outerr,
701 lirreversiblep
702 EXTRA_LOOP_ARGS);
703 }
704# if POSSIBLY_UNALIGNED
705 else
706 {
707 if (FROM_DIRECTION)
708 /* Run the conversion loop. */
709 nstatus = GEN_unaligned (FROM_LOOP) (step, data,
710 inptrp, inend,
711 &outbuf,
712 outerr,
713 lirreversiblep
714 EXTRA_LOOP_ARGS);
715 else
716 /* Run the conversion loop. */
717 nstatus = GEN_unaligned (TO_LOOP) (step, data,
718 inptrp, inend,
719 &outbuf, outerr,
720 lirreversiblep
721 EXTRA_LOOP_ARGS);
722 }
723# endif
724
725 /* We must run out of output buffer space in this
726 rerun. */
727 assert (outbuf == outerr);
728 assert (nstatus == __GCONV_FULL_OUTPUT);
729
730 /* If we haven't consumed a single byte decrement
731 the invocation counter. */
732 if (__glibc_unlikely (outbuf == outstart))
733 --data->__invocation_counter;
734#endif /* reset input buffer */
735 }
736
737 /* Change the status. */
738 status = result;
739 }
740 else
741 /* All the output is consumed, we can make another run
742 if everything was ok. */
743 if (status == __GCONV_FULL_OUTPUT)
744 {
745 status = __GCONV_OK;
746 outbuf = data->__outbuf;
747 }
748 }
749
750 if (status != __GCONV_OK)
751 break;
752
753 /* Reset the output buffer pointer for the next round. */
754 outbuf = data->__outbuf;
755 }
756
757#ifdef END_LOOP
758 END_LOOP
759#endif
760
761 /* If we are supposed to consume all character store now all of the
762 remaining characters in the `state' object. */
763#if FROM_LOOP_MAX_NEEDED_FROM > 1 || TO_LOOP_MAX_NEEDED_FROM > 1
764 if (((FROM_LOOP_MAX_NEEDED_FROM > 1 && TO_LOOP_MAX_NEEDED_FROM > 1)
765 || (FROM_LOOP_MAX_NEEDED_FROM > 1 && FROM_DIRECTION)
766 || (TO_LOOP_MAX_NEEDED_FROM > 1 && !FROM_DIRECTION))
767 && __builtin_expect (consume_incomplete, 0)
768 && status == __GCONV_INCOMPLETE_INPUT)
769 {
770# ifdef STORE_REST
771 mbstate_t *state = data->__statep;
772
773 STORE_REST
774# else
775 /* Make sure the remaining bytes fit into the state objects
776 buffer. */
777 assert (inend - *inptrp < 4);
778
779 size_t cnt;
780 for (cnt = 0; *inptrp < inend; ++cnt)
781 data->__statep->__value.__wchb[cnt] = *(*inptrp)++;
782 data->__statep->__count &= ~7;
783 data->__statep->__count |= cnt;
784# endif
785 }
786#endif
787#undef unaligned
788#undef POSSIBLY_UNALIGNED
789 }
790
791 return status;
792}
793
794#undef DEFINE_INIT
795#undef CHARSET_NAME
796#undef DEFINE_FINI
797#undef MIN_NEEDED_FROM
798#undef MIN_NEEDED_TO
799#undef MAX_NEEDED_FROM
800#undef MAX_NEEDED_TO
801#undef FROM_LOOP_MIN_NEEDED_FROM
802#undef FROM_LOOP_MAX_NEEDED_FROM
803#undef FROM_LOOP_MIN_NEEDED_TO
804#undef FROM_LOOP_MAX_NEEDED_TO
805#undef TO_LOOP_MIN_NEEDED_FROM
806#undef TO_LOOP_MAX_NEEDED_FROM
807#undef TO_LOOP_MIN_NEEDED_TO
808#undef TO_LOOP_MAX_NEEDED_TO
809#undef FROM_DIRECTION
810#undef EMIT_SHIFT_TO_INIT
811#undef FROM_LOOP
812#undef TO_LOOP
813#undef ONE_DIRECTION
814#undef SAVE_RESET_STATE
815#undef RESET_INPUT_BUFFER
816#undef FUNCTION_NAME
817#undef PREPARE_LOOP
818#undef END_LOOP
819#undef EXTRA_LOOP_ARGS
820#undef STORE_REST
821#undef FROM_ONEBYTE
822