iconv/skeleton.c

   1 /* Skeleton for a conversion module.
   2    Copyright (C) 1998-2021 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
 323 extern int gconv_init (struct __gconv_step *step);
 324 int
 325 gconv_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
 388 extern int FUNCTION_NAME (struct __gconv_step *step,
 389                           struct __gconv_step_data *data,
 390                           const unsigned char **inptrp,
 391                           const unsigned char *inend,
 392                           unsigned char **outbufstart, size_t *irreversible,
 393                           int do_flush, int consume_incomplete);
 394 int
 395 FUNCTION_NAME (struct __gconv_step *step, struct __gconv_step_data *data,
 396                const unsigned char **inptrp, const unsigned char *inend,
 397                unsigned char **outbufstart, size_t *irreversible, int do_flush,
 398                int consume_incomplete)
 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