iconv/skeleton.c

   1 /* Skeleton for a conversion module.
   2    Copyright (C) 1998-2022 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 <sysdep.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 #ifdef PTR_DEMANGLE
 408       if (next_step->__shlib_handle != NULL)
 409         PTR_DEMANGLE (fct);
 410 #endif
 411     }
 412
 413   /* If the function is called with no input this means we have to reset
 414      to the initial state.  The possibly partly converted input is
 415      dropped.  */
 416   if (__glibc_unlikely (do_flush))
 417     {
 418       /* This should never happen during error handling.  */
 419       assert (outbufstart == NULL);
 420
 421       status = __GCONV_OK;
 422
 423 #ifdef EMIT_SHIFT_TO_INIT
 424       if (do_flush == 1)
 425         {
 426           /* We preserve the initial values of the pointer variables.  */
 427           unsigned char *outbuf = data->__outbuf;
 428           unsigned char *outstart = outbuf;
 429           unsigned char *outend = data->__outbufend;
 430
 431 # ifdef PREPARE_LOOP
 432           PREPARE_LOOP
 433 # endif
 434
 435 # ifdef SAVE_RESET_STATE
 436           SAVE_RESET_STATE (1);
 437 # endif
 438
 439           /* Emit the escape sequence to reset the state.  */
 440           EMIT_SHIFT_TO_INIT;
 441
 442           /* Call the steps down the chain if there are any but only if we
 443              successfully emitted the escape sequence.  This should only
 444              fail if the output buffer is full.  If the input is invalid
 445              it should be discarded since the user wants to start from a
 446              clean state.  */
 447           if (status == __GCONV_OK)
 448             {
 449               if (data->__flags & __GCONV_IS_LAST)
 450                 /* Store information about how many bytes are available.  */
 451                 data->__outbuf = outbuf;
 452               else
 453                 {
 454                   /* Write out all output which was produced.  */
 455                   if (outbuf > outstart)
 456                     {
 457                       const unsigned char *outerr = outstart;
 458                       int result;
 459
 460                       result = DL_CALL_FCT (fct, (next_step, next_data,
 461                                                   &outerr, outbuf, NULL,
 462                                                   irreversible, 0,
 463                                                   consume_incomplete));
 464
 465                       if (result != __GCONV_EMPTY_INPUT)
 466                         {
 467                           if (__glibc_unlikely (outerr != outbuf))
 468                             {
 469                               /* We have a problem.  Undo the conversion.  */
 470                               outbuf = outstart;
 471
 472                               /* Restore the state.  */
 473 # ifdef SAVE_RESET_STATE
 474                               SAVE_RESET_STATE (0);
 475 # endif
 476                             }
 477
 478                           /* Change the status.  */
 479                           status = result;
 480                         }
 481                     }
 482
 483                   if (status == __GCONV_OK)
 484                     /* Now flush the remaining steps.  */
 485                     status = DL_CALL_FCT (fct, (next_step, next_data, NULL,
 486                                                 NULL, NULL, irreversible, 1,
 487                                                 consume_incomplete));
 488                 }
 489             }
 490         }
 491       else
 492 #endif
 493         {
 494           /* Clear the state object.  There might be bytes in there from
 495              previous calls with CONSUME_INCOMPLETE == 1.  But don't emit
 496              escape sequences.  */
 497           memset (data->__statep, '\0', sizeof (*data->__statep));
 498
 499           if (! (data->__flags & __GCONV_IS_LAST))
 500             /* Now flush the remaining steps.  */
 501             status = DL_CALL_FCT (fct, (next_step, next_data, NULL, NULL,
 502                                         NULL, irreversible, do_flush,
 503                                         consume_incomplete));
 504         }
 505     }
 506   else
 507     {
 508       /* We preserve the initial values of the pointer variables,
 509          but only some conversion modules need it.  */
 510       const unsigned char *inptr __attribute__ ((__unused__)) = *inptrp;
 511       unsigned char *outbuf = (__builtin_expect (outbufstart == NULL, 1)
 512                                ? data->__outbuf : *outbufstart);
 513       unsigned char *outend = data->__outbufend;
 514       unsigned char *outstart;
 515       /* This variable is used to count the number of characters we
 516          actually converted.  */
 517       size_t lirreversible = 0;
 518       size_t *lirreversiblep = irreversible ? &lirreversible : NULL;
 519
 520       /* The following assumes that encodings, which have a variable length
 521          what might unalign a buffer even though it is an aligned in the
 522          beginning, either don't have the minimal number of bytes as a divisor
 523          of the maximum length or have a minimum length of 1.  This is true
 524          for all known and supported encodings.
 525          We use && instead of || to combine the subexpression for the FROM
 526          encoding and for the TO encoding, because usually one of them is
 527          INTERNAL, for which the subexpression evaluates to 1, but INTERNAL
 528          buffers are always aligned correctly.  */
 529 #define POSSIBLY_UNALIGNED \
 530   (!_STRING_ARCH_unaligned                                                    \
 531    && (((FROM_LOOP_MIN_NEEDED_FROM != 1                                       \
 532          && FROM_LOOP_MAX_NEEDED_FROM % FROM_LOOP_MIN_NEEDED_FROM == 0)       \
 533         && (FROM_LOOP_MIN_NEEDED_TO != 1                                      \
 534             && FROM_LOOP_MAX_NEEDED_TO % FROM_LOOP_MIN_NEEDED_TO == 0))       \
 535        || ((TO_LOOP_MIN_NEEDED_FROM != 1                                      \
 536             && TO_LOOP_MAX_NEEDED_FROM % TO_LOOP_MIN_NEEDED_FROM == 0)        \
 537            && (TO_LOOP_MIN_NEEDED_TO != 1                                     \
 538                && TO_LOOP_MAX_NEEDED_TO % TO_LOOP_MIN_NEEDED_TO == 0))))
 539 #if POSSIBLY_UNALIGNED
 540       int unaligned;
 541 # define GEN_unaligned(name) GEN_unaligned2 (name)
 542 # define GEN_unaligned2(name) name##_unaligned
 543 #else
 544 # define unaligned 0
 545 #endif
 546
 547 #ifdef PREPARE_LOOP
 548       PREPARE_LOOP
 549 #endif
 550
 551 #if FROM_LOOP_MAX_NEEDED_FROM > 1 || TO_LOOP_MAX_NEEDED_FROM > 1
 552       /* If the function is used to implement the mb*towc*() or wc*tomb*()
 553          functions we must test whether any bytes from the last call are
 554          stored in the `state' object.  */
 555       if (((FROM_LOOP_MAX_NEEDED_FROM > 1 && TO_LOOP_MAX_NEEDED_FROM > 1)
 556            || (FROM_LOOP_MAX_NEEDED_FROM > 1 && FROM_DIRECTION)
 557            || (TO_LOOP_MAX_NEEDED_FROM > 1 && !FROM_DIRECTION))
 558           && consume_incomplete && (data->__statep->__count & 7) != 0)
 559         {
 560           /* Yep, we have some bytes left over.  Process them now.
 561              But this must not happen while we are called from an
 562              error handler.  */
 563           assert (outbufstart == NULL);
 564
 565 # if FROM_LOOP_MAX_NEEDED_FROM > 1
 566           if (TO_LOOP_MAX_NEEDED_FROM == 1 || FROM_DIRECTION)
 567             status = SINGLE(FROM_LOOP) (step, data, inptrp, inend, &outbuf,
 568                                         outend, lirreversiblep
 569                                         EXTRA_LOOP_ARGS);
 570 # endif
 571 # if !ONE_DIRECTION
 572 #  if FROM_LOOP_MAX_NEEDED_FROM > 1 && TO_LOOP_MAX_NEEDED_FROM > 1
 573           else
 574 #  endif
 575 #  if TO_LOOP_MAX_NEEDED_FROM > 1
 576             status = SINGLE(TO_LOOP) (step, data, inptrp, inend, &outbuf,
 577                                       outend, lirreversiblep EXTRA_LOOP_ARGS);
 578 #  endif
 579 # endif
 580
 581           if (__builtin_expect (status, __GCONV_OK) != __GCONV_OK)
 582             return status;
 583         }
 584 #endif
 585
 586 #if POSSIBLY_UNALIGNED
 587       unaligned =
 588         ((FROM_DIRECTION
 589           && ((uintptr_t) inptr % FROM_LOOP_MIN_NEEDED_FROM != 0
 590               || ((data->__flags & __GCONV_IS_LAST)
 591                   && (uintptr_t) outbuf % FROM_LOOP_MIN_NEEDED_TO != 0)))
 592          || (!FROM_DIRECTION
 593              && (((data->__flags & __GCONV_IS_LAST)
 594                   && (uintptr_t) outbuf % TO_LOOP_MIN_NEEDED_TO != 0)
 595                  || (uintptr_t) inptr % TO_LOOP_MIN_NEEDED_FROM != 0)));
 596 #endif
 597
 598       while (1)
 599         {
 600           /* Remember the start value for this round.  */
 601           inptr = *inptrp;
 602           /* The outbuf buffer is empty.  */
 603           outstart = outbuf;
 604 #ifdef RESET_INPUT_BUFFER
 605           /* Remember how many irreversible characters were skipped before
 606              this round.  */
 607           size_t loop_irreversible
 608             = lirreversible + (irreversible ? *irreversible : 0);
 609 #endif
 610
 611 #ifdef SAVE_RESET_STATE
 612           SAVE_RESET_STATE (1);
 613 #endif
 614
 615           if (__glibc_likely (!unaligned))
 616             {
 617               if (FROM_DIRECTION)
 618                 /* Run the conversion loop.  */
 619                 status = FROM_LOOP (step, data, inptrp, inend, &outbuf, outend,
 620                                     lirreversiblep EXTRA_LOOP_ARGS);
 621               else
 622                 /* Run the conversion loop.  */
 623                 status = TO_LOOP (step, data, inptrp, inend, &outbuf, outend,
 624                                   lirreversiblep EXTRA_LOOP_ARGS);
 625             }
 626 #if POSSIBLY_UNALIGNED
 627           else
 628             {
 629               if (FROM_DIRECTION)
 630                 /* Run the conversion loop.  */
 631                 status = GEN_unaligned (FROM_LOOP) (step, data, inptrp, inend,
 632                                                     &outbuf, outend,
 633                                                     lirreversiblep
 634                                                     EXTRA_LOOP_ARGS);
 635               else
 636                 /* Run the conversion loop.  */
 637                 status = GEN_unaligned (TO_LOOP) (step, data, inptrp, inend,
 638                                                   &outbuf, outend,
 639                                                   lirreversiblep
 640                                                   EXTRA_LOOP_ARGS);
 641             }
 642 #endif
 643
 644           /* If we were called as part of an error handling module we
 645              don't do anything else here.  */
 646           if (__glibc_unlikely (outbufstart != NULL))
 647             {
 648               *outbufstart = outbuf;
 649               return status;
 650             }
 651
 652           /* We finished one use of the loops.  */
 653           ++data->__invocation_counter;
 654
 655           /* If this is the last step leave the loop, there is nothing
 656              we can do.  */
 657           if (__glibc_unlikely (data->__flags & __GCONV_IS_LAST))
 658             {
 659               /* Store information about how many bytes are available.  */
 660               data->__outbuf = outbuf;
 661
 662               /* Remember how many non-identical characters we
 663                  converted in an irreversible way.  */
 664               *irreversible += lirreversible;
 665
 666               break;
 667             }
 668
 669           /* Write out all output which was produced.  */
 670           if (__glibc_likely (outbuf > outstart))
 671             {
 672               const unsigned char *outerr = data->__outbuf;
 673               int result;
 674
 675               result = DL_CALL_FCT (fct, (next_step, next_data, &outerr,
 676                                           outbuf, NULL, irreversible, 0,
 677                                           consume_incomplete));
 678
 679               if (result != __GCONV_EMPTY_INPUT)
 680                 {
 681                   if (__glibc_unlikely (outerr != outbuf))
 682                     {
 683 #ifdef RESET_INPUT_BUFFER
 684                       /* RESET_INPUT_BUFFER can only work when there were
 685                          no new irreversible characters skipped during
 686                          this round.  */
 687                       if (loop_irreversible
 688                           == lirreversible + (irreversible ? *irreversible : 0))
 689                         {
 690                           RESET_INPUT_BUFFER;
 691                           goto done_reset;
 692                         }
 693 #endif
 694                       /* We have a problem in one of the functions below.
 695                          Undo the conversion upto the error point.  */
 696                       size_t nstatus __attribute__ ((unused));
 697
 698                       /* Reload the pointers.  */
 699                       *inptrp = inptr;
 700                       outbuf = outstart;
 701
 702                       /* Restore the state.  */
 703 #ifdef SAVE_RESET_STATE
 704                       SAVE_RESET_STATE (0);
 705 #endif
 706
 707                       if (__glibc_likely (!unaligned))
 708                         {
 709                           if (FROM_DIRECTION)
 710                             /* Run the conversion loop.  */
 711                             nstatus = FROM_LOOP (step, data, inptrp, inend,
 712                                                  &outbuf, outerr,
 713                                                  lirreversiblep
 714                                                  EXTRA_LOOP_ARGS);
 715                           else
 716                             /* Run the conversion loop.  */
 717                             nstatus = TO_LOOP (step, data, inptrp, inend,
 718                                                &outbuf, outerr,
 719                                                lirreversiblep
 720                                                EXTRA_LOOP_ARGS);
 721                         }
 722 #if POSSIBLY_UNALIGNED
 723                       else
 724                         {
 725                           if (FROM_DIRECTION)
 726                             /* Run the conversion loop.  */
 727                             nstatus = GEN_unaligned (FROM_LOOP) (step, data,
 728                                                                  inptrp, inend,
 729                                                                  &outbuf,
 730                                                                  outerr,
 731                                                                  lirreversiblep
 732                                                                  EXTRA_LOOP_ARGS);
 733                           else
 734                             /* Run the conversion loop.  */
 735                             nstatus = GEN_unaligned (TO_LOOP) (step, data,
 736                                                                inptrp, inend,
 737                                                                &outbuf, outerr,
 738                                                                lirreversiblep
 739                                                                EXTRA_LOOP_ARGS);
 740                         }
 741 #endif
 742
 743                       /* We must run out of output buffer space in this
 744                          rerun.  */
 745                       assert (outbuf == outerr);
 746                       assert (nstatus == __GCONV_FULL_OUTPUT);
 747
 748                       /* If we haven't consumed a single byte decrement
 749                          the invocation counter.  */
 750                       if (__glibc_unlikely (outbuf == outstart))
 751                         --data->__invocation_counter;
 752                     }
 753
 754 #ifdef RESET_INPUT_BUFFER
 755                 done_reset:
 756 #endif
 757                   /* Change the status.  */
 758                   status = result;
 759                 }
 760               else
 761                 /* All the output is consumed, we can make another run
 762                    if everything was ok.  */
 763                 if (status == __GCONV_FULL_OUTPUT)
 764                   {
 765                     status = __GCONV_OK;
 766                     outbuf = data->__outbuf;
 767                   }
 768             }
 769
 770           if (status != __GCONV_OK)
 771             break;
 772
 773           /* Reset the output buffer pointer for the next round.  */
 774           outbuf = data->__outbuf;
 775         }
 776
 777 #ifdef END_LOOP
 778       END_LOOP
 779 #endif
 780
 781       /* If we are supposed to consume all character store now all of the
 782          remaining characters in the `state' object.  */
 783 #if FROM_LOOP_MAX_NEEDED_FROM > 1 || TO_LOOP_MAX_NEEDED_FROM > 1
 784       if (((FROM_LOOP_MAX_NEEDED_FROM > 1 && TO_LOOP_MAX_NEEDED_FROM > 1)
 785            || (FROM_LOOP_MAX_NEEDED_FROM > 1 && FROM_DIRECTION)
 786            || (TO_LOOP_MAX_NEEDED_FROM > 1 && !FROM_DIRECTION))
 787           && __builtin_expect (consume_incomplete, 0)
 788           && status == __GCONV_INCOMPLETE_INPUT)
 789         {
 790 # ifdef STORE_REST
 791           mbstate_t *state = data->__statep;
 792
 793           STORE_REST
 794 # else
 795           /* Make sure the remaining bytes fit into the state objects
 796              buffer.  */
 797           size_t cnt_after = inend - *inptrp;
 798           assert (cnt_after <= sizeof (data->__statep->__value.__wchb));
 799
 800           size_t cnt;
 801           for (cnt = 0; cnt < cnt_after; ++cnt)
 802             data->__statep->__value.__wchb[cnt] = (*inptrp)[cnt];
 803           *inptrp = inend;
 804           data->__statep->__count &= ~7;
 805           data->__statep->__count |= cnt;
 806 # endif
 807         }
 808 #endif
 809 #undef unaligned
 810 #undef POSSIBLY_UNALIGNED
 811     }
 812
 813   return status;
 814 }
 815
 816 #undef DEFINE_INIT
 817 #undef CHARSET_NAME
 818 #undef DEFINE_FINI
 819 #undef MIN_NEEDED_FROM
 820 #undef MIN_NEEDED_TO
 821 #undef MAX_NEEDED_FROM
 822 #undef MAX_NEEDED_TO
 823 #undef FROM_LOOP_MIN_NEEDED_FROM
 824 #undef FROM_LOOP_MAX_NEEDED_FROM
 825 #undef FROM_LOOP_MIN_NEEDED_TO
 826 #undef FROM_LOOP_MAX_NEEDED_TO
 827 #undef TO_LOOP_MIN_NEEDED_FROM
 828 #undef TO_LOOP_MAX_NEEDED_FROM
 829 #undef TO_LOOP_MIN_NEEDED_TO
 830 #undef TO_LOOP_MAX_NEEDED_TO
 831 #undef FROM_DIRECTION
 832 #undef EMIT_SHIFT_TO_INIT
 833 #undef FROM_LOOP
 834 #undef TO_LOOP
 835 #undef ONE_DIRECTION
 836 #undef SAVE_RESET_STATE
 837 #undef RESET_INPUT_BUFFER
 838 #undef FUNCTION_NAME
 839 #undef PREPARE_LOOP
 840 #undef END_LOOP
 841 #undef EXTRA_LOOP_ARGS
 842 #undef STORE_REST
 843 #undef FROM_ONEBYTE