fdwalk should return 0 on an empty directory
[kopensolaris-gnu/glibc.git] / iconv / skeleton.c
1 /* Skeleton for a conversion module.
2    Copyright (C) 1998-2002, 2005 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, write to the Free
18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19    02111-1307 USA.  */
20
21 /* This file can be included to provide definitions of several things
22    many modules have in common.  It can be customized using the following
23    macros:
24
25      DEFINE_INIT        define the default initializer.  This requires the
26                         following symbol to be defined.
27
28      CHARSET_NAME       string with official name of the coded character
29                         set (in all-caps)
30
31      DEFINE_FINI        define the default destructor function.
32
33      MIN_NEEDED_FROM    minimal number of bytes needed for the from-charset.
34      MIN_NEEDED_TO      likewise for the to-charset.
35
36      MAX_NEEDED_FROM    maximal number of bytes needed for the from-charset.
37                         This macro is optional, it defaults to MIN_NEEDED_FROM.
38      MAX_NEEDED_TO      likewise for the to-charset.
39
40      FROM_LOOP_MIN_NEEDED_FROM
41      FROM_LOOP_MAX_NEEDED_FROM
42                         minimal/maximal number of bytes needed on input
43                         of one round through the FROM_LOOP.  Defaults
44                         to MIN_NEEDED_FROM and MAX_NEEDED_FROM, respectively.
45      FROM_LOOP_MIN_NEEDED_TO
46      FROM_LOOP_MAX_NEEDED_TO
47                         minimal/maximal number of bytes needed on output
48                         of one round through the FROM_LOOP.  Defaults
49                         to MIN_NEEDED_TO and MAX_NEEDED_TO, respectively.
50      TO_LOOP_MIN_NEEDED_FROM
51      TO_LOOP_MAX_NEEDED_FROM
52                         minimal/maximal number of bytes needed on input
53                         of one round through the TO_LOOP.  Defaults
54                         to MIN_NEEDED_TO and MAX_NEEDED_TO, respectively.
55      TO_LOOP_MIN_NEEDED_TO
56      TO_LOOP_MAX_NEEDED_TO
57                         minimal/maximal number of bytes needed on output
58                         of one round through the TO_LOOP.  Defaults
59                         to MIN_NEEDED_FROM and MAX_NEEDED_FROM, respectively.
60
61      FROM_DIRECTION     this macro is supposed to return a value != 0
62                         if we convert from the current character set,
63                         otherwise it return 0.
64
65      EMIT_SHIFT_TO_INIT this symbol is optional.  If it is defined it
66                         defines some code which writes out a sequence
67                         of bytes which bring the current state into
68                         the initial state.
69
70      FROM_LOOP          name of the function implementing the conversion
71                         from the current character set.
72      TO_LOOP            likewise for the other direction
73
74      ONE_DIRECTION      optional.  If defined to 1, only one conversion
75                         direction is defined instead of two.  In this
76                         case, FROM_DIRECTION should be defined to 1, and
77                         FROM_LOOP and TO_LOOP should have the same value.
78
79      SAVE_RESET_STATE   in case of an error we must reset the state for
80                         the rerun so this macro must be defined for
81                         stateful encodings.  It takes an argument which
82                         is nonzero when saving.
83
84      RESET_INPUT_BUFFER If the input character sets allow this the macro
85                         can be defined to reset the input buffer pointers
86                         to cover only those characters up to the error.
87
88      FUNCTION_NAME      if not set the conversion function is named `gconv'.
89
90      PREPARE_LOOP       optional code preparing the conversion loop.  Can
91                         contain variable definitions.
92      END_LOOP           also optional, may be used to store information
93
94      EXTRA_LOOP_ARGS    optional macro specifying extra arguments passed
95                         to loop function.
96
97      STORE_REST         optional, needed only when MAX_NEEDED_FROM > 4.
98                         This macro stores the seen but unconverted input bytes
99                         in the state.
100
101      FROM_ONEBYTE       optional.  If defined, should be the name of a
102                         specialized conversion function for a single byte
103                         from the current character set to INTERNAL.  This
104                         function has prototype
105                            wint_t
106                            FROM_ONEBYTE (struct __gconv_step *, unsigned char);
107                         and does a special conversion:
108                         - The input is a single byte.
109                         - The output is a single uint32_t.
110                         - The state before the conversion is the initial state;
111                           the state after the conversion is irrelevant.
112                         - No transliteration.
113                         - __invocation_counter = 0.
114                         - __internal_use = 1.
115                         - do_flush = 0.
116
117    Modules can use mbstate_t to store conversion state as follows:
118
119    * Bits 2..0 of '__count' contain the number of lookahead input bytes
120      stored in __value.__wchb.  Always zero if the converter never
121      returns __GCONV_INCOMPLETE_INPUT.
122
123    * Bits 31..3 of '__count' are module dependent shift state.
124
125    * __value: When STORE_REST/UNPACK_BYTES aren't defined and when the
126      converter has returned __GCONV_INCOMPLETE_INPUT, this contains
127      at most 4 lookahead bytes. Converters with an mb_cur_max > 4
128      (currently only UTF-8) must find a way to store their state
129      in __value.__wch and define STORE_REST/UNPACK_BYTES appropriately.
130
131    When __value contains lookahead, __count must not be zero, because
132    the converter is not in the initial state then, and mbsinit() --
133    defined as a (__count == 0) test -- must reflect this.
134  */
135
136 #include <assert.h>
137 #include <gconv.h>
138 #include <string.h>
139 #define __need_size_t
140 #define __need_NULL
141 #include <stddef.h>
142
143 #ifndef STATIC_GCONV
144 # include <dlfcn.h>
145 #endif
146
147 #include <sysdep.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
167 /* How many bytes are needed at most for the from-charset.  */
168 #ifndef MAX_NEEDED_FROM
169 # define MAX_NEEDED_FROM        MIN_NEEDED_FROM
170 #endif
171
172 /* Same for the to-charset.  */
173 #ifndef MAX_NEEDED_TO
174 # define MAX_NEEDED_TO          MIN_NEEDED_TO
175 #endif
176
177 /* Defaults for the per-direction min/max constants.  */
178 #ifndef FROM_LOOP_MIN_NEEDED_FROM
179 # define FROM_LOOP_MIN_NEEDED_FROM      MIN_NEEDED_FROM
180 #endif
181 #ifndef FROM_LOOP_MAX_NEEDED_FROM
182 # define FROM_LOOP_MAX_NEEDED_FROM      MAX_NEEDED_FROM
183 #endif
184 #ifndef FROM_LOOP_MIN_NEEDED_TO
185 # define FROM_LOOP_MIN_NEEDED_TO        MIN_NEEDED_TO
186 #endif
187 #ifndef FROM_LOOP_MAX_NEEDED_TO
188 # define FROM_LOOP_MAX_NEEDED_TO        MAX_NEEDED_TO
189 #endif
190 #ifndef TO_LOOP_MIN_NEEDED_FROM
191 # define TO_LOOP_MIN_NEEDED_FROM        MIN_NEEDED_TO
192 #endif
193 #ifndef TO_LOOP_MAX_NEEDED_FROM
194 # define TO_LOOP_MAX_NEEDED_FROM        MAX_NEEDED_TO
195 #endif
196 #ifndef TO_LOOP_MIN_NEEDED_TO
197 # define TO_LOOP_MIN_NEEDED_TO          MIN_NEEDED_FROM
198 #endif
199 #ifndef TO_LOOP_MAX_NEEDED_TO
200 # define TO_LOOP_MAX_NEEDED_TO          MAX_NEEDED_FROM
201 #endif
202
203
204 /* Define macros which can access unaligned buffers.  These macros are
205    supposed to be used only in code outside the inner loops.  For the inner
206    loops we have other definitions which allow optimized access.  */
207 #ifdef _STRING_ARCH_unaligned
208 /* We can handle unaligned memory access.  */
209 # define get16u(addr) *((__const uint16_t *) (addr))
210 # define get32u(addr) *((__const uint32_t *) (addr))
211
212 /* We need no special support for writing values either.  */
213 # define put16u(addr, val) *((uint16_t *) (addr)) = (val)
214 # define put32u(addr, val) *((uint32_t *) (addr)) = (val)
215 #else
216 /* Distinguish between big endian and little endian.  */
217 # if __BYTE_ORDER == __LITTLE_ENDIAN
218 #  define get16u(addr) \
219      (((__const unsigned char *) (addr))[1] << 8                              \
220       | ((__const unsigned char *) (addr))[0])
221 #  define get32u(addr) \
222      (((((__const unsigned char *) (addr))[3] << 8                            \
223         | ((__const unsigned char *) (addr))[2]) << 8                         \
224        | ((__const unsigned char *) (addr))[1]) << 8                          \
225       | ((__const unsigned char *) (addr))[0])
226
227 #  define put16u(addr, val) \
228      ({ uint16_t __val = (val);                                               \
229         ((unsigned char *) (addr))[0] = __val;                                \
230         ((unsigned char *) (addr))[1] = __val >> 8;                           \
231         (void) 0; })
232 #  define put32u(addr, val) \
233      ({ uint32_t __val = (val);                                               \
234         ((unsigned char *) (addr))[0] = __val;                                \
235         __val >>= 8;                                                          \
236         ((unsigned char *) (addr))[1] = __val;                                \
237         __val >>= 8;                                                          \
238         ((unsigned char *) (addr))[2] = __val;                                \
239         __val >>= 8;                                                          \
240         ((unsigned char *) (addr))[3] = __val;                                \
241         (void) 0; })
242 # else
243 #  define get16u(addr) \
244      (((__const unsigned char *) (addr))[0] << 8                              \
245       | ((__const unsigned char *) (addr))[1])
246 #  define get32u(addr) \
247      (((((__const unsigned char *) (addr))[0] << 8                            \
248         | ((__const unsigned char *) (addr))[1]) << 8                         \
249        | ((__const unsigned char *) (addr))[2]) << 8                          \
250       | ((__const unsigned char *) (addr))[3])
251
252 #  define put16u(addr, val) \
253      ({ uint16_t __val = (val);                                               \
254         ((unsigned char *) (addr))[1] = __val;                                \
255         ((unsigned char *) (addr))[0] = __val >> 8;                           \
256         (void) 0; })
257 #  define put32u(addr, val) \
258      ({ uint32_t __val = (val);                                               \
259         ((unsigned char *) (addr))[3] = __val;                                \
260         __val >>= 8;                                                          \
261         ((unsigned char *) (addr))[2] = __val;                                \
262         __val >>= 8;                                                          \
263         ((unsigned char *) (addr))[1] = __val;                                \
264         __val >>= 8;                                                          \
265         ((unsigned char *) (addr))[0] = __val;                                \
266         (void) 0; })
267 # endif
268 #endif
269
270
271 /* For conversions from a fixed width character set to another fixed width
272    character set we can define RESET_INPUT_BUFFER in a very fast way.  */
273 #if !defined RESET_INPUT_BUFFER && !defined SAVE_RESET_STATE
274 # if FROM_LOOP_MIN_NEEDED_FROM == FROM_LOOP_MAX_NEEDED_FROM \
275      && FROM_LOOP_MIN_NEEDED_TO == FROM_LOOP_MAX_NEEDED_TO \
276      && TO_LOOP_MIN_NEEDED_FROM == TO_LOOP_MAX_NEEDED_FROM \
277      && TO_LOOP_MIN_NEEDED_TO == TO_LOOP_MAX_NEEDED_TO
278 /* We have to use these `if's here since the compiler cannot know that
279    (outbuf - outerr) is always divisible by FROM/TO_LOOP_MIN_NEEDED_TO.
280    The ?:1 avoids division by zero warnings that gcc 3.2 emits even for
281    obviously unreachable code.  */
282 #  define RESET_INPUT_BUFFER \
283   if (FROM_DIRECTION)                                                         \
284     {                                                                         \
285       if (FROM_LOOP_MIN_NEEDED_FROM % FROM_LOOP_MIN_NEEDED_TO == 0)           \
286         *inptrp -= (outbuf - outerr)                                          \
287                    * (FROM_LOOP_MIN_NEEDED_FROM / FROM_LOOP_MIN_NEEDED_TO);   \
288       else if (FROM_LOOP_MIN_NEEDED_TO % FROM_LOOP_MIN_NEEDED_FROM == 0)      \
289         *inptrp -= (outbuf - outerr)                                          \
290                    / (FROM_LOOP_MIN_NEEDED_TO / FROM_LOOP_MIN_NEEDED_FROM     \
291                       ? : 1);                                                 \
292       else                                                                    \
293         *inptrp -= ((outbuf - outerr) / FROM_LOOP_MIN_NEEDED_TO)              \
294                    * FROM_LOOP_MIN_NEEDED_FROM;                               \
295     }                                                                         \
296   else                                                                        \
297     {                                                                         \
298       if (TO_LOOP_MIN_NEEDED_FROM % TO_LOOP_MIN_NEEDED_TO == 0)               \
299         *inptrp -= (outbuf - outerr)                                          \
300                    * (TO_LOOP_MIN_NEEDED_FROM / TO_LOOP_MIN_NEEDED_TO);       \
301       else if (TO_LOOP_MIN_NEEDED_TO % TO_LOOP_MIN_NEEDED_FROM == 0)          \
302         *inptrp -= (outbuf - outerr)                                          \
303                    / (TO_LOOP_MIN_NEEDED_TO / TO_LOOP_MIN_NEEDED_FROM ? : 1); \
304       else                                                                    \
305         *inptrp -= ((outbuf - outerr) / TO_LOOP_MIN_NEEDED_TO)                \
306                    * TO_LOOP_MIN_NEEDED_FROM;                                 \
307     }
308 # endif
309 #endif
310
311
312 /* The default init function.  It simply matches the name and initializes
313    the step data to point to one of the objects above.  */
314 #if DEFINE_INIT
315 # ifndef CHARSET_NAME
316 #  error "CHARSET_NAME not defined"
317 # endif
318
319 extern int gconv_init (struct __gconv_step *step);
320 int
321 gconv_init (struct __gconv_step *step)
322 {
323   /* Determine which direction.  */
324   if (strcmp (step->__from_name, CHARSET_NAME) == 0)
325     {
326       step->__data = FROM_DIRECTION_VAL;
327
328       step->__min_needed_from = FROM_LOOP_MIN_NEEDED_FROM;
329       step->__max_needed_from = FROM_LOOP_MAX_NEEDED_FROM;
330       step->__min_needed_to = FROM_LOOP_MIN_NEEDED_TO;
331       step->__max_needed_to = FROM_LOOP_MAX_NEEDED_TO;
332
333 #ifdef FROM_ONEBYTE
334       step->__btowc_fct = FROM_ONEBYTE;
335 #endif
336     }
337   else if (__builtin_expect (strcmp (step->__to_name, CHARSET_NAME), 0) == 0)
338     {
339       step->__data = TO_DIRECTION_VAL;
340
341       step->__min_needed_from = TO_LOOP_MIN_NEEDED_FROM;
342       step->__max_needed_from = TO_LOOP_MAX_NEEDED_FROM;
343       step->__min_needed_to = TO_LOOP_MIN_NEEDED_TO;
344       step->__max_needed_to = TO_LOOP_MAX_NEEDED_TO;
345     }
346   else
347     return __GCONV_NOCONV;
348
349 #ifdef SAVE_RESET_STATE
350   step->__stateful = 1;
351 #else
352   step->__stateful = 0;
353 #endif
354
355   return __GCONV_OK;
356 }
357 #endif
358
359
360 /* The default destructor function does nothing in the moment and so
361    we don't define it at all.  But we still provide the macro just in
362    case we need it some day.  */
363 #if DEFINE_FINI
364 #endif
365
366
367 /* If no arguments have to passed to the loop function define the macro
368    as empty.  */
369 #ifndef EXTRA_LOOP_ARGS
370 # define EXTRA_LOOP_ARGS
371 #endif
372
373
374 /* This is the actual conversion function.  */
375 #ifndef FUNCTION_NAME
376 # define FUNCTION_NAME  gconv
377 #endif
378
379 /* The macros are used to access the function to convert single characters.  */
380 #define SINGLE(fct) SINGLE2 (fct)
381 #define SINGLE2(fct) fct##_single
382
383
384 extern int FUNCTION_NAME (struct __gconv_step *step,
385                           struct __gconv_step_data *data,
386                           const unsigned char **inptrp,
387                           const unsigned char *inend,
388                           unsigned char **outbufstart, size_t *irreversible,
389                           int do_flush, int consume_incomplete);
390 int
391 FUNCTION_NAME (struct __gconv_step *step, struct __gconv_step_data *data,
392                const unsigned char **inptrp, const unsigned char *inend,
393                unsigned char **outbufstart, size_t *irreversible, int do_flush,
394                int consume_incomplete)
395 {
396   struct __gconv_step *next_step = step + 1;
397   struct __gconv_step_data *next_data = data + 1;
398   __gconv_fct fct = NULL;
399   int status;
400
401   if ((data->__flags & __GCONV_IS_LAST) == 0)
402     {
403       fct = next_step->__fct;
404 #ifdef PTR_DEMANGLE
405       if (next_step->__shlib_handle != NULL)
406         PTR_DEMANGLE (fct);
407 #endif
408     }
409
410   /* If the function is called with no input this means we have to reset
411      to the initial state.  The possibly partly converted input is
412      dropped.  */
413   if (__builtin_expect (do_flush, 0))
414     {
415       /* This should never happen during error handling.  */
416       assert (outbufstart == NULL);
417
418       status = __GCONV_OK;
419
420 #ifdef EMIT_SHIFT_TO_INIT
421       if (do_flush == 1)
422         {
423           /* We preserve the initial values of the pointer variables.  */
424           unsigned char *outbuf = data->__outbuf;
425           unsigned char *outstart = outbuf;
426           unsigned char *outend = data->__outbufend;
427
428 # ifdef PREPARE_LOOP
429           PREPARE_LOOP
430 # endif
431
432 # ifdef SAVE_RESET_STATE
433           SAVE_RESET_STATE (1);
434 # endif
435
436           /* Emit the escape sequence to reset the state.  */
437           EMIT_SHIFT_TO_INIT;
438
439           /* Call the steps down the chain if there are any but only if we
440              successfully emitted the escape sequence.  This should only
441              fail if the output buffer is full.  If the input is invalid
442              it should be discarded since the user wants to start from a
443              clean state.  */
444           if (status == __GCONV_OK)
445             {
446               if (data->__flags & __GCONV_IS_LAST)
447                 /* Store information about how many bytes are available.  */
448                 data->__outbuf = outbuf;
449               else
450                 {
451                   /* Write out all output which was produced.  */
452                   if (outbuf > outstart)
453                     {
454                       const unsigned char *outerr = outstart;
455                       int result;
456
457                       result = DL_CALL_FCT (fct, (next_step, next_data,
458                                                   &outerr, outbuf, NULL,
459                                                   irreversible, 0,
460                                                   consume_incomplete));
461
462                       if (result != __GCONV_EMPTY_INPUT)
463                         {
464                           if (__builtin_expect (outerr != outbuf, 0))
465                             {
466                               /* We have a problem.  Undo the conversion.  */
467                               outbuf = outstart;
468
469                               /* Restore the state.  */
470 # ifdef SAVE_RESET_STATE
471                               SAVE_RESET_STATE (0);
472 # endif
473                             }
474
475                           /* Change the status.  */
476                           status = result;
477                         }
478                     }
479
480                   if (status == __GCONV_OK)
481                     /* Now flush the remaining steps.  */
482                     status = DL_CALL_FCT (fct, (next_step, next_data, NULL,
483                                                 NULL, NULL, irreversible, 1,
484                                                 consume_incomplete));
485                 }
486             }
487         }
488       else
489 #endif
490         {
491           /* Clear the state object.  There might be bytes in there from
492              previous calls with CONSUME_INCOMPLETE == 1.  But don't emit
493              escape sequences.  */
494           memset (data->__statep, '\0', sizeof (*data->__statep));
495
496           if (! (data->__flags & __GCONV_IS_LAST))
497             /* Now flush the remaining steps.  */
498             status = DL_CALL_FCT (fct, (next_step, next_data, NULL, NULL,
499                                         NULL, irreversible, do_flush,
500                                         consume_incomplete));
501         }
502     }
503   else
504     {
505       /* We preserve the initial values of the pointer variables.  */
506       const unsigned char *inptr = *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 a 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   (!defined _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           struct __gconv_trans_data *trans;
597
598           /* Remember the start value for this round.  */
599           inptr = *inptrp;
600           /* The outbuf buffer is empty.  */
601           outstart = outbuf;
602
603 #ifdef SAVE_RESET_STATE
604           SAVE_RESET_STATE (1);
605 #endif
606
607           if (__builtin_expect (!unaligned, 1))
608             {
609               if (FROM_DIRECTION)
610                 /* Run the conversion loop.  */
611                 status = FROM_LOOP (step, data, inptrp, inend, &outbuf, outend,
612                                     lirreversiblep EXTRA_LOOP_ARGS);
613               else
614                 /* Run the conversion loop.  */
615                 status = TO_LOOP (step, data, inptrp, inend, &outbuf, outend,
616                                   lirreversiblep EXTRA_LOOP_ARGS);
617             }
618 #if POSSIBLY_UNALIGNED
619           else
620             {
621               if (FROM_DIRECTION)
622                 /* Run the conversion loop.  */
623                 status = GEN_unaligned (FROM_LOOP) (step, data, inptrp, inend,
624                                                     &outbuf, outend,
625                                                     lirreversiblep
626                                                     EXTRA_LOOP_ARGS);
627               else
628                 /* Run the conversion loop.  */
629                 status = GEN_unaligned (TO_LOOP) (step, data, inptrp, inend,
630                                                   &outbuf, outend,
631                                                   lirreversiblep
632                                                   EXTRA_LOOP_ARGS);
633             }
634 #endif
635
636           /* If we were called as part of an error handling module we
637              don't do anything else here.  */
638           if (__builtin_expect (outbufstart != NULL, 0))
639             {
640               *outbufstart = outbuf;
641               return status;
642             }
643
644           /* Give the transliteration module the chance to store the
645              original text and the result in case it needs a context.  */
646           for (trans = data->__trans; trans != NULL; trans = trans->__next)
647             if (trans->__trans_context_fct != NULL)
648               DL_CALL_FCT (trans->__trans_context_fct,
649                            (trans->__data, inptr, *inptrp, outstart, outbuf));
650
651           /* We finished one use of the loops.  */
652           ++data->__invocation_counter;
653
654           /* If this is the last step leave the loop, there is nothing
655              we can do.  */
656           if (__builtin_expect (data->__flags & __GCONV_IS_LAST, 0))
657             {
658               /* Store information about how many bytes are available.  */
659               data->__outbuf = outbuf;
660
661               /* Remember how many non-identical characters we
662                  converted in a irreversible way.  */
663               *irreversible += lirreversible;
664
665               break;
666             }
667
668           /* Write out all output which was produced.  */
669           if (__builtin_expect (outbuf > outstart, 1))
670             {
671               const unsigned char *outerr = data->__outbuf;
672               int result;
673
674               result = DL_CALL_FCT (fct, (next_step, next_data, &outerr,
675                                           outbuf, NULL, irreversible, 0,
676                                           consume_incomplete));
677
678               if (result != __GCONV_EMPTY_INPUT)
679                 {
680                   if (__builtin_expect (outerr != outbuf, 0))
681                     {
682 #ifdef RESET_INPUT_BUFFER
683                       RESET_INPUT_BUFFER;
684 #else
685                       /* We have a problem in one of the functions below.
686                          Undo the conversion upto the error point.  */
687                       size_t nstatus;
688
689                       /* Reload the pointers.  */
690                       *inptrp = inptr;
691                       outbuf = outstart;
692
693                       /* Restore the state.  */
694 # ifdef SAVE_RESET_STATE
695                       SAVE_RESET_STATE (0);
696 # endif
697
698                       if (__builtin_expect (!unaligned, 1))
699                         {
700                           if (FROM_DIRECTION)
701                             /* Run the conversion loop.  */
702                             nstatus = FROM_LOOP (step, data, inptrp, inend,
703                                                  &outbuf, outerr,
704                                                  lirreversiblep
705                                                  EXTRA_LOOP_ARGS);
706                           else
707                             /* Run the conversion loop.  */
708                             nstatus = TO_LOOP (step, data, inptrp, inend,
709                                                &outbuf, outerr,
710                                                lirreversiblep
711                                                EXTRA_LOOP_ARGS);
712                         }
713 # if POSSIBLY_UNALIGNED
714                       else
715                         {
716                           if (FROM_DIRECTION)
717                             /* Run the conversion loop.  */
718                             nstatus = GEN_unaligned (FROM_LOOP) (step, data,
719                                                                  inptrp, inend,
720                                                                  &outbuf,
721                                                                  outerr,
722                                                                  lirreversiblep
723                                                                  EXTRA_LOOP_ARGS);
724                           else
725                             /* Run the conversion loop.  */
726                             nstatus = GEN_unaligned (TO_LOOP) (step, data,
727                                                                inptrp, inend,
728                                                                &outbuf, outerr,
729                                                                lirreversiblep
730                                                                EXTRA_LOOP_ARGS);
731                         }
732 # endif
733
734                       /* We must run out of output buffer space in this
735                          rerun.  */
736                       assert (outbuf == outerr);
737                       assert (nstatus == __GCONV_FULL_OUTPUT);
738
739                       /* If we haven't consumed a single byte decrement
740                          the invocation counter.  */
741                       if (__builtin_expect (outbuf == outstart, 0))
742                         --data->__invocation_counter;
743 #endif  /* reset input buffer */
744                     }
745
746                   /* Change the status.  */
747                   status = result;
748                 }
749               else
750                 /* All the output is consumed, we can make another run
751                    if everything was ok.  */
752                 if (status == __GCONV_FULL_OUTPUT)
753                   {
754                     status = __GCONV_OK;
755                     outbuf = data->__outbuf;
756                   }
757             }
758
759           if (status != __GCONV_OK)
760             break;
761
762           /* Reset the output buffer pointer for the next round.  */
763           outbuf = data->__outbuf;
764         }
765
766 #ifdef END_LOOP
767       END_LOOP
768 #endif
769
770       /* If we are supposed to consume all character store now all of the
771          remaining characters in the `state' object.  */
772 #if FROM_LOOP_MAX_NEEDED_FROM > 1 || TO_LOOP_MAX_NEEDED_FROM > 1
773       if (((FROM_LOOP_MAX_NEEDED_FROM > 1 && TO_LOOP_MAX_NEEDED_FROM > 1)
774            || (FROM_LOOP_MAX_NEEDED_FROM > 1 && FROM_DIRECTION)
775            || (TO_LOOP_MAX_NEEDED_FROM > 1 && !FROM_DIRECTION))
776           && __builtin_expect (consume_incomplete, 0)
777           && status == __GCONV_INCOMPLETE_INPUT)
778         {
779 # ifdef STORE_REST
780           mbstate_t *state = data->__statep;
781
782           STORE_REST
783 # else
784           /* Make sure the remaining bytes fit into the state objects
785              buffer.  */
786           assert (inend - *inptrp < 4);
787
788           size_t cnt;
789           for (cnt = 0; *inptrp < inend; ++cnt)
790             data->__statep->__value.__wchb[cnt] = *(*inptrp)++;
791           data->__statep->__count &= ~7;
792           data->__statep->__count |= cnt;
793 # endif
794         }
795 #endif
796 #undef unaligned
797 #undef POSSIBLY_UNALIGNED
798     }
799
800   return status;
801 }
802
803 #undef DEFINE_INIT
804 #undef CHARSET_NAME
805 #undef DEFINE_FINI
806 #undef MIN_NEEDED_FROM
807 #undef MIN_NEEDED_TO
808 #undef MAX_NEEDED_FROM
809 #undef MAX_NEEDED_TO
810 #undef FROM_LOOP_MIN_NEEDED_FROM
811 #undef FROM_LOOP_MAX_NEEDED_FROM
812 #undef FROM_LOOP_MIN_NEEDED_TO
813 #undef FROM_LOOP_MAX_NEEDED_TO
814 #undef TO_LOOP_MIN_NEEDED_FROM
815 #undef TO_LOOP_MAX_NEEDED_FROM
816 #undef TO_LOOP_MIN_NEEDED_TO
817 #undef TO_LOOP_MAX_NEEDED_TO
818 #undef FROM_DIRECTION
819 #undef EMIT_SHIFT_TO_INIT
820 #undef FROM_LOOP
821 #undef TO_LOOP
822 #undef ONE_DIRECTION
823 #undef SAVE_RESET_STATE
824 #undef RESET_INPUT_BUFFER
825 #undef FUNCTION_NAME
826 #undef PREPARE_LOOP
827 #undef END_LOOP
828 #undef EXTRA_LOOP_ARGS
829 #undef STORE_REST
830 #undef FROM_ONEBYTE