iconv/skeleton.c

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