iconv/skeleton.c

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