iconv/gconv_simple.c

   1 /* Simple transformations functions.
   2    Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, write to the Free
  18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19    02111-1307 USA.  */
  20
  21 #include <byteswap.h>
  22 #include <dlfcn.h>
  23 #include <endian.h>
  24 #include <errno.h>
  25 #include <gconv.h>
  26 #include <stdint.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <wchar.h>
  30 #include <sys/param.h>
  31
  32 #define BUILTIN_ALIAS(s1, s2) /* nothing */
  33 #define BUILTIN_TRANSFORMATION(From, To, Cost, Name, Fct, MinF, MaxF, \
  34                                MinT, MaxT) \
  35   extern int Fct (struct __gconv_step *, struct __gconv_step_data *,          \
  36                   __const unsigned char **, __const unsigned char *,          \
  37                   unsigned char **, size_t *, int, int);
  38 #include "gconv_builtin.h"
  39
  40
  41 #ifndef EILSEQ
  42 # define EILSEQ EINVAL
  43 #endif
  44
  45
  46 /* Transform from the internal, UCS4-like format, to UCS4.  The
  47    difference between the internal ucs4 format and the real UCS4
  48    format is, if any, the endianess.  The Unicode/ISO 10646 says that
  49    unless some higher protocol specifies it differently, the byte
  50    order is big endian.*/
  51 #define DEFINE_INIT             0
  52 #define DEFINE_FINI             0
  53 #define MIN_NEEDED_FROM         4
  54 #define MIN_NEEDED_TO           4
  55 #define FROM_DIRECTION          1
  56 #define FROM_LOOP               internal_ucs4_loop
  57 #define TO_LOOP                 internal_ucs4_loop /* This is not used.  */
  58 #define FUNCTION_NAME           __gconv_transform_internal_ucs4
  59
  60
  61 static inline int
  62 internal_ucs4_loop (struct __gconv_step *step,
  63                     struct __gconv_step_data *step_data,
  64                     const unsigned char **inptrp, const unsigned char *inend,
  65                     unsigned char **outptrp, unsigned char *outend,
  66                     size_t *irreversible)
  67 {
  68   const unsigned char *inptr = *inptrp;
  69   unsigned char *outptr = *outptrp;
  70   size_t n_convert = MIN (inend - inptr, outend - outptr) / 4;
  71   int result;
  72
  73 #if __BYTE_ORDER == __LITTLE_ENDIAN
  74   /* Sigh, we have to do some real work.  */
  75   size_t cnt;
  76
  77   for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4)
  78     *((uint32_t *) outptr)++ = bswap_32 (*(const uint32_t *) inptr);
  79
  80   *inptrp = inptr;
  81   *outptrp = outptr;
  82 #elif __BYTE_ORDER == __BIG_ENDIAN
  83   /* Simply copy the data.  */
  84   *inptrp = inptr + n_convert * 4;
  85   *outptrp = __mempcpy (outptr, inptr, n_convert * 4);
  86 #else
  87 # error "This endianess is not supported."
  88 #endif
  89
  90   /* Determine the status.  */
  91   if (*inptrp == inend)
  92     result = __GCONV_EMPTY_INPUT;
  93   else if (*outptrp + 4 > outend)
  94     result = __GCONV_FULL_OUTPUT;
  95   else
  96     result = __GCONV_INCOMPLETE_INPUT;
  97
  98   return result;
  99 }
 100
 101 #ifndef _STRING_ARCH_unaligned
 102 static inline int
 103 internal_ucs4_loop_unaligned (struct __gconv_step *step,
 104                               struct __gconv_step_data *step_data,
 105                               const unsigned char **inptrp,
 106                               const unsigned char *inend,
 107                               unsigned char **outptrp, unsigned char *outend,
 108                               size_t *irreversible)
 109 {
 110   const unsigned char *inptr = *inptrp;
 111   unsigned char *outptr = *outptrp;
 112   size_t n_convert = MIN (inend - inptr, outend - outptr) / 4;
 113   int result;
 114
 115 # if __BYTE_ORDER == __LITTLE_ENDIAN
 116   /* Sigh, we have to do some real work.  */
 117   size_t cnt;
 118
 119   for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4, outptr += 4)
 120     {
 121       outptr[0] = inptr[3];
 122       outptr[1] = inptr[2];
 123       outptr[2] = inptr[1];
 124       outptr[3] = inptr[0];
 125     }
 126
 127   *inptrp = inptr;
 128   *outptrp = outptr;
 129 # elif __BYTE_ORDER == __BIG_ENDIAN
 130   /* Simply copy the data.  */
 131   *inptrp = inptr + n_convert * 4;
 132   *outptrp = __mempcpy (outptr, inptr, n_convert * 4);
 133 # else
 134 #  error "This endianess is not supported."
 135 # endif
 136
 137   /* Determine the status.  */
 138   if (*inptrp == inend)
 139     result = __GCONV_EMPTY_INPUT;
 140   else if (*outptrp + 4 > outend)
 141     result = __GCONV_FULL_OUTPUT;
 142   else
 143     result = __GCONV_INCOMPLETE_INPUT;
 144
 145   return result;
 146 }
 147 #endif
 148
 149
 150 static inline int
 151 internal_ucs4_loop_single (struct __gconv_step *step,
 152                            struct __gconv_step_data *step_data,
 153                            const unsigned char **inptrp,
 154                            const unsigned char *inend,
 155                            unsigned char **outptrp, unsigned char *outend,
 156                            size_t *irreversible)
 157 {
 158   mbstate_t *state = step_data->__statep;
 159   size_t cnt = state->__count & 7;
 160
 161   while (*inptrp < inend && cnt < 4)
 162     state->__value.__wchb[cnt++] = *(*inptrp)++;
 163
 164   if (__builtin_expect (cnt < 4, 0))
 165     {
 166       /* Still not enough bytes.  Store the ones in the input buffer.  */
 167       state->__count &= ~7;
 168       state->__count |= cnt;
 169
 170       return __GCONV_INCOMPLETE_INPUT;
 171     }
 172
 173 #if __BYTE_ORDER == __LITTLE_ENDIAN
 174   (*outptrp)[0] = state->__value.__wchb[3];
 175   (*outptrp)[1] = state->__value.__wchb[2];
 176   (*outptrp)[2] = state->__value.__wchb[1];
 177   (*outptrp)[3] = state->__value.__wchb[0];
 178
 179   *outptrp += 4;
 180 #elif __BYTE_ORDER == __BIG_ENDIAN
 181   /* XXX unaligned */
 182   *(*((uint32_t **) outptrp)++) = state->__value.__wch;
 183 #else
 184 # error "This endianess is not supported."
 185 #endif
 186
 187   /* Clear the state buffer.  */
 188   state->__count &= ~7;
 189
 190   return __GCONV_OK;
 191 }
 192
 193 #include <iconv/skeleton.c>
 194
 195
 196 /* Transform from UCS4 to the internal, UCS4-like format.  Unlike
 197    for the other direction we have to check for correct values here.  */
 198 #define DEFINE_INIT             0
 199 #define DEFINE_FINI             0
 200 #define MIN_NEEDED_FROM         4
 201 #define MIN_NEEDED_TO           4
 202 #define FROM_DIRECTION          1
 203 #define FROM_LOOP               ucs4_internal_loop
 204 #define TO_LOOP                 ucs4_internal_loop /* This is not used.  */
 205 #define FUNCTION_NAME           __gconv_transform_ucs4_internal
 206
 207
 208 static inline int
 209 ucs4_internal_loop (struct __gconv_step *step,
 210                     struct __gconv_step_data *step_data,
 211                     const unsigned char **inptrp, const unsigned char *inend,
 212                     unsigned char **outptrp, unsigned char *outend,
 213                     size_t *irreversible)
 214 {
 215   int flags = step_data->__flags;
 216   const unsigned char *inptr = *inptrp;
 217   unsigned char *outptr = *outptrp;
 218   size_t n_convert = MIN (inend - inptr, outend - outptr) / 4;
 219   int result;
 220   size_t cnt;
 221
 222   for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4)
 223     {
 224       uint32_t inval;
 225
 226 #if __BYTE_ORDER == __LITTLE_ENDIAN
 227       inval = bswap_32 (*(const uint32_t *) inptr);
 228 #else
 229       inval = *(const uint32_t *) inptr;
 230 #endif
 231
 232       if (__builtin_expect (inval > 0x7fffffff, 0))
 233         {
 234           /* The value is too large.  We don't try transliteration here since
 235              this is not an error because of the lack of possibilities to
 236              represent the result.  This is a genuine bug in the input since
 237              UCS4 does not allow such values.  */
 238           if (irreversible == NULL)
 239             /* We are transliterating, don't try to correct anything.  */
 240             return __GCONV_ILLEGAL_INPUT;
 241
 242           if (flags & __GCONV_IGNORE_ERRORS)
 243             {
 244               /* Just ignore this character.  */
 245               ++*irreversible;
 246               continue;
 247             }
 248
 249           *inptrp = inptr;
 250           *outptrp = outptr;
 251           return __GCONV_ILLEGAL_INPUT;
 252         }
 253
 254       *((uint32_t *) outptr)++ = inval;
 255     }
 256
 257   *inptrp = inptr;
 258   *outptrp = outptr;
 259
 260   /* Determine the status.  */
 261   if (*inptrp == inend)
 262     result = __GCONV_EMPTY_INPUT;
 263   else if (*outptrp + 4 > outend)
 264     result = __GCONV_FULL_OUTPUT;
 265   else
 266     result = __GCONV_INCOMPLETE_INPUT;
 267
 268   return result;
 269 }
 270
 271 #ifndef _STRING_ARCH_unaligned
 272 static inline int
 273 ucs4_internal_loop_unaligned (struct __gconv_step *step,
 274                               struct __gconv_step_data *step_data,
 275                               const unsigned char **inptrp,
 276                               const unsigned char *inend,
 277                               unsigned char **outptrp, unsigned char *outend,
 278                               size_t *irreversible)
 279 {
 280   int flags = step_data->__flags;
 281   const unsigned char *inptr = *inptrp;
 282   unsigned char *outptr = *outptrp;
 283   size_t n_convert = MIN (inend - inptr, outend - outptr) / 4;
 284   int result;
 285   size_t cnt;
 286
 287   for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4)
 288     {
 289       if (__builtin_expect (inptr[0] > 0x80, 0))
 290         {
 291           /* The value is too large.  We don't try transliteration here since
 292              this is not an error because of the lack of possibilities to
 293              represent the result.  This is a genuine bug in the input since
 294              UCS4 does not allow such values.  */
 295           if (irreversible == NULL)
 296             /* We are transliterating, don't try to correct anything.  */
 297             return __GCONV_ILLEGAL_INPUT;
 298
 299           if (flags & __GCONV_IGNORE_ERRORS)
 300             {
 301               /* Just ignore this character.  */
 302               ++*irreversible;
 303               continue;
 304             }
 305
 306           *inptrp = inptr;
 307           *outptrp = outptr;
 308           return __GCONV_ILLEGAL_INPUT;
 309         }
 310
 311 # if __BYTE_ORDER == __LITTLE_ENDIAN
 312       outptr[3] = inptr[0];
 313       outptr[2] = inptr[1];
 314       outptr[1] = inptr[2];
 315       outptr[0] = inptr[3];
 316 # else
 317       outptr[0] = inptr[0];
 318       outptr[1] = inptr[1];
 319       outptr[2] = inptr[2];
 320       outptr[3] = inptr[3];
 321 # endif
 322       outptr += 4;
 323     }
 324
 325   *inptrp = inptr;
 326   *outptrp = outptr;
 327
 328   /* Determine the status.  */
 329   if (*inptrp == inend)
 330     result = __GCONV_EMPTY_INPUT;
 331   else if (*outptrp + 4 > outend)
 332     result = __GCONV_FULL_OUTPUT;
 333   else
 334     result = __GCONV_INCOMPLETE_INPUT;
 335
 336   return result;
 337 }
 338 #endif
 339
 340
 341 static inline int
 342 ucs4_internal_loop_single (struct __gconv_step *step,
 343                            struct __gconv_step_data *step_data,
 344                            const unsigned char **inptrp,
 345                            const unsigned char *inend,
 346                            unsigned char **outptrp, unsigned char *outend,
 347                            size_t *irreversible)
 348 {
 349   mbstate_t *state = step_data->__statep;
 350   int flags = step_data->__flags;
 351   size_t cnt = state->__count & 7;
 352
 353   while (*inptrp < inend && cnt < 4)
 354     state->__value.__wchb[cnt++] = *(*inptrp)++;
 355
 356   if (__builtin_expect (cnt < 4, 0))
 357     {
 358       /* Still not enough bytes.  Store the ones in the input buffer.  */
 359       state->__count &= ~7;
 360       state->__count |= cnt;
 361
 362       return __GCONV_INCOMPLETE_INPUT;
 363     }
 364
 365   if (__builtin_expect (((unsigned char *) state->__value.__wchb)[0] > 0x80,
 366                         0))
 367     {
 368       /* The value is too large.  We don't try transliteration here since
 369          this is not an error because of the lack of possibilities to
 370          represent the result.  This is a genuine bug in the input since
 371          UCS4 does not allow such values.  */
 372       if (!(flags & __GCONV_IGNORE_ERRORS))
 373         {
 374           *inptrp -= cnt - (state->__count & 7);
 375           return __GCONV_ILLEGAL_INPUT;
 376         }
 377     }
 378   else
 379     {
 380 #if __BYTE_ORDER == __LITTLE_ENDIAN
 381       (*outptrp)[0] = state->__value.__wchb[3];
 382       (*outptrp)[1] = state->__value.__wchb[2];
 383       (*outptrp)[2] = state->__value.__wchb[1];
 384       (*outptrp)[3] = state->__value.__wchb[0];
 385 #elif __BYTE_ORDER == __BIG_ENDIAN
 386       (*outptrp)[0] = state->__value.__wchb[0];
 387       (*outptrp)[1] = state->__value.__wchb[1];
 388       (*outptrp)[2] = state->__value.__wchb[2];
 389       (*outptrp)[3] = state->__value.__wchb[3];
 390 #endif
 391
 392       *outptrp += 4;
 393     }
 394
 395   /* Clear the state buffer.  */
 396   state->__count &= ~7;
 397
 398   return __GCONV_OK;
 399 }
 400
 401 #include <iconv/skeleton.c>
 402
 403
 404 /* Similarly for the little endian form.  */
 405 #define DEFINE_INIT             0
 406 #define DEFINE_FINI             0
 407 #define MIN_NEEDED_FROM         4
 408 #define MIN_NEEDED_TO           4
 409 #define FROM_DIRECTION          1
 410 #define FROM_LOOP               internal_ucs4le_loop
 411 #define TO_LOOP                 internal_ucs4le_loop /* This is not used.  */
 412 #define FUNCTION_NAME           __gconv_transform_internal_ucs4le
 413
 414
 415 static inline int
 416 internal_ucs4le_loop (struct __gconv_step *step,
 417                       struct __gconv_step_data *step_data,
 418                       const unsigned char **inptrp, const unsigned char *inend,
 419                       unsigned char **outptrp, unsigned char *outend,
 420                       size_t *irreversible)
 421 {
 422   const unsigned char *inptr = *inptrp;
 423   unsigned char *outptr = *outptrp;
 424   size_t n_convert = MIN (inend - inptr, outend - outptr) / 4;
 425   int result;
 426
 427 #if __BYTE_ORDER == __BIG_ENDIAN
 428   /* Sigh, we have to do some real work.  */
 429   size_t cnt;
 430
 431   for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4)
 432     *((uint32_t *) outptr)++ = bswap_32 (*(const uint32_t *) inptr);
 433
 434   *inptrp = inptr;
 435   *outptrp = outptr;
 436 #elif __BYTE_ORDER == __LITTLE_ENDIAN
 437   /* Simply copy the data.  */
 438   *inptrp = inptr + n_convert * 4;
 439   *outptrp = __mempcpy (outptr, inptr, n_convert * 4);
 440 #else
 441 # error "This endianess is not supported."
 442 #endif
 443
 444   /* Determine the status.  */
 445   if (*inptrp == inend)
 446     result = __GCONV_EMPTY_INPUT;
 447   else if (*outptrp + 4 > outend)
 448     result = __GCONV_FULL_OUTPUT;
 449   else
 450     result = __GCONV_INCOMPLETE_INPUT;
 451
 452   return result;
 453 }
 454
 455 #ifndef _STRING_ARCH_unaligned
 456 static inline int
 457 internal_ucs4le_loop_unaligned (struct __gconv_step *step,
 458                                 struct __gconv_step_data *step_data,
 459                                 const unsigned char **inptrp,
 460                                 const unsigned char *inend,
 461                                 unsigned char **outptrp, unsigned char *outend,
 462                                 size_t *irreversible)
 463 {
 464   const unsigned char *inptr = *inptrp;
 465   unsigned char *outptr = *outptrp;
 466   size_t n_convert = MIN (inend - inptr, outend - outptr) / 4;
 467   int result;
 468
 469 # if __BYTE_ORDER == __BIG_ENDIAN
 470   /* Sigh, we have to do some real work.  */
 471   size_t cnt;
 472
 473   for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4, outptr += 4)
 474     {
 475       outptr[0] = inptr[3];
 476       outptr[1] = inptr[2];
 477       outptr[2] = inptr[1];
 478       outptr[3] = inptr[0];
 479     }
 480
 481   *inptrp = inptr;
 482   *outptrp = outptr;
 483 # elif __BYTE_ORDER == __LITTLE_ENDIAN
 484   /* Simply copy the data.  */
 485   *inptrp = inptr + n_convert * 4;
 486   *outptrp = __mempcpy (outptr, inptr, n_convert * 4);
 487 # else
 488 #  error "This endianess is not supported."
 489 # endif
 490
 491   /* Determine the status.  */
 492   if (*inptrp + 4 > inend)
 493     result = __GCONV_EMPTY_INPUT;
 494   else if (*outptrp + 4 > outend)
 495     result = __GCONV_FULL_OUTPUT;
 496   else
 497     result = __GCONV_INCOMPLETE_INPUT;
 498
 499   return result;
 500 }
 501 #endif
 502
 503
 504 static inline int
 505 internal_ucs4le_loop_single (struct __gconv_step *step,
 506                              struct __gconv_step_data *step_data,
 507                              const unsigned char **inptrp,
 508                              const unsigned char *inend,
 509                              unsigned char **outptrp, unsigned char *outend,
 510                              size_t *irreversible)
 511 {
 512   mbstate_t *state = step_data->__statep;
 513   size_t cnt = state->__count & 7;
 514
 515   while (*inptrp < inend && cnt < 4)
 516     state->__value.__wchb[cnt++] = *(*inptrp)++;
 517
 518   if (__builtin_expect (cnt < 4, 0))
 519     {
 520       /* Still not enough bytes.  Store the ones in the input buffer.  */
 521       state->__count &= ~7;
 522       state->__count |= cnt;
 523
 524       return __GCONV_INCOMPLETE_INPUT;
 525     }
 526
 527 #if __BYTE_ORDER == __BIG_ENDIAN
 528   (*outptrp)[0] = state->__value.__wchb[3];
 529   (*outptrp)[1] = state->__value.__wchb[2];
 530   (*outptrp)[2] = state->__value.__wchb[1];
 531   (*outptrp)[3] = state->__value.__wchb[0];
 532
 533   *outptrp += 4;
 534 #else
 535   /* XXX unaligned */
 536   *(*((uint32_t **) outptrp)++) = state->__value.__wch;
 537 #endif
 538
 539   /* Clear the state buffer.  */
 540   state->__count &= ~7;
 541
 542   return __GCONV_OK;
 543 }
 544
 545 #include <iconv/skeleton.c>
 546
 547
 548 /* And finally from UCS4-LE to the internal encoding.  */
 549 #define DEFINE_INIT             0
 550 #define DEFINE_FINI             0
 551 #define MIN_NEEDED_FROM         4
 552 #define MIN_NEEDED_TO           4
 553 #define FROM_DIRECTION          1
 554 #define FROM_LOOP               ucs4le_internal_loop
 555 #define TO_LOOP                 ucs4le_internal_loop /* This is not used.  */
 556 #define FUNCTION_NAME           __gconv_transform_ucs4le_internal
 557
 558
 559 static inline int
 560 ucs4le_internal_loop (struct __gconv_step *step,
 561                       struct __gconv_step_data *step_data,
 562                       const unsigned char **inptrp, const unsigned char *inend,
 563                       unsigned char **outptrp, unsigned char *outend,
 564                       size_t *irreversible)
 565 {
 566   int flags = step_data->__flags;
 567   const unsigned char *inptr = *inptrp;
 568   unsigned char *outptr = *outptrp;
 569   size_t n_convert = MIN (inend - inptr, outend - outptr) / 4;
 570   int result;
 571   size_t cnt;
 572
 573   for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4)
 574     {
 575       uint32_t inval;
 576
 577 #if __BYTE_ORDER == __BIG_ENDIAN
 578       inval = bswap_32 (*(const uint32_t *) inptr);
 579 #else
 580       inval = *(const uint32_t *) inptr;
 581 #endif
 582
 583       if (__builtin_expect (inval > 0x7fffffff, 0))
 584         {
 585           /* The value is too large.  We don't try transliteration here since
 586              this is not an error because of the lack of possibilities to
 587              represent the result.  This is a genuine bug in the input since
 588              UCS4 does not allow such values.  */
 589           if (irreversible == NULL)
 590             /* We are transliterating, don't try to correct anything.  */
 591             return __GCONV_ILLEGAL_INPUT;
 592
 593           if (flags & __GCONV_IGNORE_ERRORS)
 594             {
 595               /* Just ignore this character.  */
 596               ++*irreversible;
 597               continue;
 598             }
 599
 600           return __GCONV_ILLEGAL_INPUT;
 601         }
 602
 603       *((uint32_t *) outptr)++ = inval;
 604     }
 605
 606   *inptrp = inptr;
 607   *outptrp = outptr;
 608
 609   /* Determine the status.  */
 610   if (*inptrp == inend)
 611     result = __GCONV_EMPTY_INPUT;
 612   else if (*outptrp + 4 > outend)
 613     result = __GCONV_FULL_OUTPUT;
 614   else
 615     result = __GCONV_INCOMPLETE_INPUT;
 616
 617   return result;
 618 }
 619
 620 #ifndef _STRING_ARCH_unaligned
 621 static inline int
 622 ucs4le_internal_loop_unaligned (struct __gconv_step *step,
 623                                 struct __gconv_step_data *step_data,
 624                                 const unsigned char **inptrp,
 625                                 const unsigned char *inend,
 626                                 unsigned char **outptrp, unsigned char *outend,
 627                                 size_t *irreversible)
 628 {
 629   int flags = step_data->__flags;
 630   const unsigned char *inptr = *inptrp;
 631   unsigned char *outptr = *outptrp;
 632   size_t n_convert = MIN (inend - inptr, outend - outptr) / 4;
 633   int result;
 634   size_t cnt;
 635
 636   for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4)
 637     {
 638       if (__builtin_expect (inptr[3] > 0x80, 0))
 639         {
 640           /* The value is too large.  We don't try transliteration here since
 641              this is not an error because of the lack of possibilities to
 642              represent the result.  This is a genuine bug in the input since
 643              UCS4 does not allow such values.  */
 644           if (irreversible == NULL)
 645             /* We are transliterating, don't try to correct anything.  */
 646             return __GCONV_ILLEGAL_INPUT;
 647
 648           if (flags & __GCONV_IGNORE_ERRORS)
 649             {
 650               /* Just ignore this character.  */
 651               ++*irreversible;
 652               continue;
 653             }
 654
 655           *inptrp = inptr;
 656           *outptrp = outptr;
 657           return __GCONV_ILLEGAL_INPUT;
 658         }
 659
 660 # if __BYTE_ORDER == __BIG_ENDIAN
 661       outptr[3] = inptr[0];
 662       outptr[2] = inptr[1];
 663       outptr[1] = inptr[2];
 664       outptr[0] = inptr[3];
 665 # else
 666       outptr[0] = inptr[0];
 667       outptr[1] = inptr[1];
 668       outptr[2] = inptr[2];
 669       outptr[3] = inptr[3];
 670 # endif
 671
 672       outptr += 4;
 673     }
 674
 675   *inptrp = inptr;
 676   *outptrp = outptr;
 677
 678   /* Determine the status.  */
 679   if (*inptrp == inend)
 680     result = __GCONV_EMPTY_INPUT;
 681   else if (*outptrp + 4 > outend)
 682     result = __GCONV_FULL_OUTPUT;
 683   else
 684     result = __GCONV_INCOMPLETE_INPUT;
 685
 686   return result;
 687 }
 688 #endif
 689
 690
 691 static inline int
 692 ucs4le_internal_loop_single (struct __gconv_step *step,
 693                              struct __gconv_step_data *step_data,
 694                              const unsigned char **inptrp,
 695                              const unsigned char *inend,
 696                              unsigned char **outptrp, unsigned char *outend,
 697                              size_t *irreversible)
 698 {
 699   mbstate_t *state = step_data->__statep;
 700   int flags = step_data->__flags;
 701   size_t cnt = state->__count & 7;
 702
 703   while (*inptrp < inend && cnt < 4)
 704     state->__value.__wchb[cnt++] = *(*inptrp)++;
 705
 706   if (__builtin_expect (cnt < 4, 0))
 707     {
 708       /* Still not enough bytes.  Store the ones in the input buffer.  */
 709       state->__count &= ~7;
 710       state->__count |= cnt;
 711
 712       return __GCONV_INCOMPLETE_INPUT;
 713     }
 714
 715   if (__builtin_expect (((unsigned char *) state->__value.__wchb)[3] > 0x80,
 716                         0))
 717     {
 718       /* The value is too large.  We don't try transliteration here since
 719          this is not an error because of the lack of possibilities to
 720          represent the result.  This is a genuine bug in the input since
 721          UCS4 does not allow such values.  */
 722       if (!(flags & __GCONV_IGNORE_ERRORS))
 723         return __GCONV_ILLEGAL_INPUT;
 724     }
 725   else
 726     {
 727 #if __BYTE_ORDER == __BIG_ENDIAN
 728       (*outptrp)[0] = state->__value.__wchb[3];
 729       (*outptrp)[1] = state->__value.__wchb[2];
 730       (*outptrp)[2] = state->__value.__wchb[1];
 731       (*outptrp)[3] = state->__value.__wchb[0];
 732 #elif __BYTE_ORDER == __BIG_ENDIAN
 733       (*outptrp)[0] = state->__value.__wchb[0];
 734       (*outptrp)[1] = state->__value.__wchb[1];
 735       (*outptrp)[2] = state->__value.__wchb[2];
 736       (*outptrp)[3] = state->__value.__wchb[3];
 737 #endif
 738
 739       *outptrp += 4;
 740     }
 741
 742   /* Clear the state buffer.  */
 743   state->__count &= ~7;
 744
 745   return __GCONV_OK;
 746 }
 747
 748 #include <iconv/skeleton.c>
 749
 750
 751 /* Convert from ISO 646-IRV to the internal (UCS4-like) format.  */
 752 #define DEFINE_INIT             0
 753 #define DEFINE_FINI             0
 754 #define MIN_NEEDED_FROM         1
 755 #define MIN_NEEDED_TO           4
 756 #define FROM_DIRECTION          1
 757 #define FROM_LOOP               ascii_internal_loop
 758 #define TO_LOOP                 ascii_internal_loop /* This is not used.  */
 759 #define FUNCTION_NAME           __gconv_transform_ascii_internal
 760 #define ONE_DIRECTION           1
 761
 762 #define MIN_NEEDED_INPUT        MIN_NEEDED_FROM
 763 #define MIN_NEEDED_OUTPUT       MIN_NEEDED_TO
 764 #define LOOPFCT                 FROM_LOOP
 765 #define BODY \
 766   {                                                                           \
 767     if (__builtin_expect (*inptr > '\x7f', 0))                                \
 768       {                                                                       \
 769         /* The value is too large.  We don't try transliteration here since   \
 770            this is not an error because of the lack of possibilities to       \
 771            represent the result.  This is a genuine bug in the input since    \
 772            ASCII does not allow such values.  */                              \
 773         if (! ignore_errors_p ())                                             \
 774           {                                                                   \
 775             /* This is no correct ANSI_X3.4-1968 character.  */               \
 776             result = __GCONV_ILLEGAL_INPUT;                                   \
 777             break;                                                            \
 778           }                                                                   \
 779                                                                               \
 780         ++*irreversible;                                                      \
 781         ++inptr;                                                              \
 782       }                                                                       \
 783     else                                                                      \
 784       /* It's an one byte sequence.  */                                       \
 785       *((uint32_t *) outptr)++ = *inptr++;                                    \
 786   }
 787 #define LOOP_NEED_FLAGS
 788 #include <iconv/loop.c>
 789 #include <iconv/skeleton.c>
 790
 791
 792 /* Convert from the internal (UCS4-like) format to ISO 646-IRV.  */
 793 #define DEFINE_INIT             0
 794 #define DEFINE_FINI             0
 795 #define MIN_NEEDED_FROM         4
 796 #define MIN_NEEDED_TO           1
 797 #define FROM_DIRECTION          1
 798 #define FROM_LOOP               internal_ascii_loop
 799 #define TO_LOOP                 internal_ascii_loop /* This is not used.  */
 800 #define FUNCTION_NAME           __gconv_transform_internal_ascii
 801 #define ONE_DIRECTION           1
 802
 803 #define MIN_NEEDED_INPUT        MIN_NEEDED_FROM
 804 #define MIN_NEEDED_OUTPUT       MIN_NEEDED_TO
 805 #define LOOPFCT                 FROM_LOOP
 806 #define BODY \
 807   {                                                                           \
 808     if (__builtin_expect (*((const uint32_t *) inptr) > 0x7f, 0))             \
 809       {                                                                       \
 810         UNICODE_TAG_HANDLER (*((const uint32_t *) inptr), 4);                 \
 811         STANDARD_ERR_HANDLER (4);                                             \
 812       }                                                                       \
 813     else                                                                      \
 814       /* It's an one byte sequence.  */                                       \
 815       *outptr++ = *((const uint32_t *) inptr)++;                              \
 816   }
 817 #define LOOP_NEED_FLAGS
 818 #include <iconv/loop.c>
 819 #include <iconv/skeleton.c>
 820
 821
 822 /* Convert from the internal (UCS4-like) format to UTF-8.  */
 823 #define DEFINE_INIT             0
 824 #define DEFINE_FINI             0
 825 #define MIN_NEEDED_FROM         4
 826 #define MIN_NEEDED_TO           1
 827 #define MAX_NEEDED_TO           6
 828 #define FROM_DIRECTION          1
 829 #define FROM_LOOP               internal_utf8_loop
 830 #define TO_LOOP                 internal_utf8_loop /* This is not used.  */
 831 #define FUNCTION_NAME           __gconv_transform_internal_utf8
 832 #define ONE_DIRECTION           1
 833
 834 #define MIN_NEEDED_INPUT        MIN_NEEDED_FROM
 835 #define MIN_NEEDED_OUTPUT       MIN_NEEDED_TO
 836 #define MAX_NEEDED_OUTPUT       MAX_NEEDED_TO
 837 #define LOOPFCT                 FROM_LOOP
 838 #define BODY \
 839   {                                                                           \
 840     uint32_t wc = *((const uint32_t *) inptr);                                \
 841                                                                               \
 842     if (wc < 0x80)                                                            \
 843       /* It's an one byte sequence.  */                                       \
 844       *outptr++ = (unsigned char) wc;                                         \
 845     else if (__builtin_expect (wc <= 0x7fffffff, 1))                          \
 846       {                                                                       \
 847         size_t step;                                                          \
 848         char *start;                                                          \
 849                                                                               \
 850         for (step = 2; step < 6; ++step)                                      \
 851           if ((wc & (~(uint32_t)0 << (5 * step + 1))) == 0)                   \
 852             break;                                                            \
 853                                                                               \
 854         if (__builtin_expect (outptr + step > outend, 0))                     \
 855           {                                                                   \
 856             /* Too long.  */                                                  \
 857             result = __GCONV_FULL_OUTPUT;                                     \
 858             break;                                                            \
 859           }                                                                   \
 860                                                                               \
 861         start = outptr;                                                       \
 862         *outptr = (unsigned char) (~0xff >> step);                            \
 863         outptr += step;                                                       \
 864         --step;                                                               \
 865         do                                                                    \
 866           {                                                                   \
 867             start[step] = 0x80 | (wc & 0x3f);                                 \
 868             wc >>= 6;                                                         \
 869           }                                                                   \
 870         while (--step > 0);                                                   \
 871         start[0] |= wc;                                                       \
 872       }                                                                       \
 873     else                                                                      \
 874       {                                                                       \
 875         STANDARD_ERR_HANDLER (4);                                             \
 876       }                                                                       \
 877                                                                               \
 878     inptr += 4;                                                               \
 879   }
 880 #define LOOP_NEED_FLAGS
 881 #include <iconv/loop.c>
 882 #include <iconv/skeleton.c>
 883
 884
 885 /* Convert from UTF-8 to the internal (UCS4-like) format.  */
 886 #define DEFINE_INIT             0
 887 #define DEFINE_FINI             0
 888 #define MIN_NEEDED_FROM         1
 889 #define MAX_NEEDED_FROM         6
 890 #define MIN_NEEDED_TO           4
 891 #define FROM_DIRECTION          1
 892 #define FROM_LOOP               utf8_internal_loop
 893 #define TO_LOOP                 utf8_internal_loop /* This is not used.  */
 894 #define FUNCTION_NAME           __gconv_transform_utf8_internal
 895 #define ONE_DIRECTION           1
 896
 897 #define MIN_NEEDED_INPUT        MIN_NEEDED_FROM
 898 #define MAX_NEEDED_INPUT        MAX_NEEDED_FROM
 899 #define MIN_NEEDED_OUTPUT       MIN_NEEDED_TO
 900 #define LOOPFCT                 FROM_LOOP
 901 #define BODY \
 902   {                                                                           \
 903     uint32_t ch;                                                              \
 904     uint_fast32_t cnt;                                                        \
 905     uint_fast32_t i;                                                          \
 906                                                                               \
 907     /* Next input byte.  */                                                   \
 908     ch = *inptr;                                                              \
 909                                                                               \
 910     if (ch < 0x80)                                                            \
 911       {                                                                       \
 912         /* One byte sequence.  */                                             \
 913         cnt = 1;                                                              \
 914         ++inptr;                                                              \
 915       }                                                                       \
 916     else                                                                      \
 917       {                                                                       \
 918         if (ch >= 0xc2 && ch < 0xe0)                                          \
 919           {                                                                   \
 920             /* We expect two bytes.  The first byte cannot be 0xc0 or 0xc1,   \
 921                otherwise the wide character could have been represented       \
 922                using a single byte.  */                                       \
 923             cnt = 2;                                                          \
 924             ch &= 0x1f;                                                       \
 925           }                                                                   \
 926         else if (__builtin_expect ((ch & 0xf0) == 0xe0, 1))                   \
 927           {                                                                   \
 928             /* We expect three bytes.  */                                     \
 929             cnt = 3;                                                          \
 930             ch &= 0x0f;                                                       \
 931           }                                                                   \
 932         else if (__builtin_expect ((ch & 0xf8) == 0xf0, 1))                   \
 933           {                                                                   \
 934             /* We expect four bytes.  */                                      \
 935             cnt = 4;                                                          \
 936             ch &= 0x07;                                                       \
 937           }                                                                   \
 938         else if (__builtin_expect ((ch & 0xfc) == 0xf8, 1))                   \
 939           {                                                                   \
 940             /* We expect five bytes.  */                                      \
 941             cnt = 5;                                                          \
 942             ch &= 0x03;                                                       \
 943           }                                                                   \
 944         else if (__builtin_expect ((ch & 0xfe) == 0xfc, 1))                   \
 945           {                                                                   \
 946             /* We expect six bytes.  */                                       \
 947             cnt = 6;                                                          \
 948             ch &= 0x01;                                                       \
 949           }                                                                   \
 950         else                                                                  \
 951           {                                                                   \
 952             int skipped;                                                      \
 953                                                                               \
 954             if (! ignore_errors_p ())                                         \
 955               {                                                               \
 956                 /* This is an illegal encoding.  */                           \
 957                 result = __GCONV_ILLEGAL_INPUT;                               \
 958                 break;                                                        \
 959               }                                                               \
 960                                                                               \
 961             /* Search the end of this ill-formed UTF-8 character.  This       \
 962                is the next byte with (x & 0xc0) != 0x80.  */                  \
 963              skipped = 0;                                                     \
 964              do                                                               \
 965                {                                                              \
 966                  ++inptr;                                                     \
 967                  ++skipped;                                                   \
 968                }                                                              \
 969              while (inptr < inend && (*inptr & 0xc0) == 0x80 && skipped < 5); \
 970                                                                               \
 971              continue;                                                        \
 972           }                                                                   \
 973                                                                               \
 974         if (__builtin_expect (inptr + cnt > inend, 0))                        \
 975           {                                                                   \
 976             /* We don't have enough input.  But before we report that check   \
 977                that all the bytes are correct.  */                            \
 978             for (i = 1; inptr + i < inend; ++i)                               \
 979               if ((inptr[i] & 0xc0) != 0x80)                                  \
 980                 break;                                                        \
 981                                                                               \
 982             if (__builtin_expect (inptr + i == inend, 1))                     \
 983               {                                                               \
 984                 result = __GCONV_INCOMPLETE_INPUT;                            \
 985                 break;                                                        \
 986               }                                                               \
 987                                                                               \
 988             if (ignore_errors_p ())                                           \
 989               {                                                               \
 990                 /* Ignore it.  */                                             \
 991                 inptr += i;                                                   \
 992                 ++*irreversible;                                              \
 993                 continue;                                                     \
 994               }                                                               \
 995                                                                               \
 996             result = __GCONV_ILLEGAL_INPUT;                                   \
 997             break;                                                            \
 998           }                                                                   \
 999                                                                               \
1000         /* Read the possible remaining bytes.  */                             \
1001         for (i = 1; i < cnt; ++i)                                             \
1002           {                                                                   \
1003             uint32_t byte = inptr[i];                                         \
1004                                                                               \
1005             if ((byte & 0xc0) != 0x80)                                        \
1006               /* This is an illegal encoding.  */                             \
1007               break;                                                          \
1008                                                                               \
1009             ch <<= 6;                                                         \
1010             ch |= byte & 0x3f;                                                \
1011           }                                                                   \
1012                                                                               \
1013         /* If i < cnt, some trail byte was not >= 0x80, < 0xc0.               \
1014            If cnt > 2 and ch < 2^(5*cnt-4), the wide character ch could       \
1015            have been represented with fewer than cnt bytes.  */               \
1016         if (i < cnt || (cnt > 2 && (ch >> (5 * cnt - 4)) == 0))               \
1017           {                                                                   \
1018             /* This is an illegal encoding.  */                               \
1019             if (ignore_errors_p ())                                           \
1020               {                                                               \
1021                 inptr += i;                                                   \
1022                 ++*irreversible;                                              \
1023                 continue;                                                     \
1024               }                                                               \
1025                                                                               \
1026             result = __GCONV_ILLEGAL_INPUT;                                   \
1027             break;                                                            \
1028           }                                                                   \
1029                                                                               \
1030         inptr += cnt;                                                         \
1031       }                                                                       \
1032                                                                               \
1033     /* Now adjust the pointers and store the result.  */                      \
1034     *((uint32_t *) outptr)++ = ch;                                            \
1035   }
1036 #define LOOP_NEED_FLAGS
1037
1038 #define STORE_REST \
1039   {                                                                           \
1040     /* We store the remaining bytes while converting them into the UCS4       \
1041        format.  We can assume that the first byte in the buffer is            \
1042        correct and that it requires a larger number of bytes than there       \
1043        are in the input buffer.  */                                           \
1044     wint_t ch = **inptrp;                                                     \
1045     size_t cnt;                                                               \
1046                                                                               \
1047     state->__count = inend - *inptrp;                                         \
1048                                                                               \
1049     if (ch >= 0xc2 && ch < 0xe0)                                              \
1050       {                                                                       \
1051         /* We expect two bytes.  The first byte cannot be 0xc0 or             \
1052            0xc1, otherwise the wide character could have been                 \
1053            represented using a single byte.  */                               \
1054         cnt = 2;                                                              \
1055         ch &= 0x1f;                                                           \
1056       }                                                                       \
1057     else if (__builtin_expect ((ch & 0xf0) == 0xe0, 1))                       \
1058       {                                                                       \
1059         /* We expect three bytes.  */                                         \
1060         cnt = 3;                                                              \
1061         ch &= 0x0f;                                                           \
1062       }                                                                       \
1063     else if (__builtin_expect ((ch & 0xf8) == 0xf0, 1))                       \
1064       {                                                                       \
1065         /* We expect four bytes.  */                                          \
1066         cnt = 4;                                                              \
1067         ch &= 0x07;                                                           \
1068       }                                                                       \
1069     else if (__builtin_expect ((ch & 0xfc) == 0xf8, 1))                       \
1070       {                                                                       \
1071         /* We expect five bytes.  */                                          \
1072         cnt = 5;                                                              \
1073         ch &= 0x03;                                                           \
1074       }                                                                       \
1075     else                                                                      \
1076       {                                                                       \
1077         /* We expect six bytes.  */                                           \
1078         cnt = 6;                                                              \
1079         ch &= 0x01;                                                           \
1080       }                                                                       \
1081                                                                               \
1082     /* The first byte is already consumed.  */                                \
1083     --cnt;                                                                    \
1084     while (++(*inptrp) < inend)                                               \
1085       {                                                                       \
1086         ch <<= 6;                                                             \
1087         ch |= **inptrp & 0x3f;                                                \
1088         --cnt;                                                                \
1089       }                                                                       \
1090                                                                               \
1091     /* Shift for the so far missing bytes.  */                                \
1092     ch <<= cnt * 6;                                                           \
1093                                                                               \
1094     /* Store the value.  */                                                   \
1095     state->__value.__wch = ch;                                                \
1096   }
1097
1098 #define UNPACK_BYTES \
1099   {                                                                           \
1100     wint_t wch = state->__value.__wch;                                        \
1101     size_t ntotal;                                                            \
1102     inlen = state->__count;                                                   \
1103                                                                               \
1104     if (state->__value.__wch <= 0x7ff)                                        \
1105       {                                                                       \
1106         bytebuf[0] = 0xc0;                                                    \
1107         ntotal = 2;                                                           \
1108       }                                                                       \
1109     else if (__builtin_expect (state->__value.__wch <= 0xffff, 1))            \
1110       {                                                                       \
1111         bytebuf[0] = 0xe0;                                                    \
1112         ntotal = 3;                                                           \
1113       }                                                                       \
1114     else if (__builtin_expect (state->__value.__wch < 0x1fffff, 1))           \
1115       {                                                                       \
1116         bytebuf[0] = 0xf0;                                                    \
1117         ntotal = 4;                                                           \
1118       }                                                                       \
1119     else if (__builtin_expect (state->__value.__wch < 0x3ffffff, 1))          \
1120       {                                                                       \
1121         bytebuf[0] = 0xf8;                                                    \
1122         ntotal = 5;                                                           \
1123       }                                                                       \
1124     else                                                                      \
1125       {                                                                       \
1126         bytebuf[0] = 0xfc;                                                    \
1127         ntotal = 6;                                                           \
1128       }                                                                       \
1129                                                                               \
1130     do                                                                        \
1131       {                                                                       \
1132         if (--ntotal < inlen)                                                 \
1133           bytebuf[ntotal] = 0x80 | (wch & 0x3f);                              \
1134         wch >>= 6;                                                            \
1135       }                                                                       \
1136     while (ntotal > 1);                                                       \
1137                                                                               \
1138     bytebuf[0] |= wch;                                                        \
1139   }
1140
1141 #include <iconv/loop.c>
1142 #include <iconv/skeleton.c>
1143
1144
1145 /* Convert from UCS2 to the internal (UCS4-like) format.  */
1146 #define DEFINE_INIT             0
1147 #define DEFINE_FINI             0
1148 #define MIN_NEEDED_FROM         2
1149 #define MIN_NEEDED_TO           4
1150 #define FROM_DIRECTION          1
1151 #define FROM_LOOP               ucs2_internal_loop
1152 #define TO_LOOP                 ucs2_internal_loop /* This is not used.  */
1153 #define FUNCTION_NAME           __gconv_transform_ucs2_internal
1154 #define ONE_DIRECTION           1
1155
1156 #define MIN_NEEDED_INPUT        MIN_NEEDED_FROM
1157 #define MIN_NEEDED_OUTPUT       MIN_NEEDED_TO
1158 #define LOOPFCT                 FROM_LOOP
1159 #define BODY \
1160   {                                                                           \
1161     uint16_t u1 = *((const uint16_t *) inptr);                                \
1162                                                                               \
1163     if (__builtin_expect (u1 >= 0xd800 && u1 < 0xe000, 0))                    \
1164       {                                                                       \
1165         /* Surrogate characters in UCS-2 input are not valid.  Reject         \
1166            them.  (Catching this here is not security relevant.)  */          \
1167         if (! ignore_errors_p ())                                             \
1168           {                                                                   \
1169             result = __GCONV_ILLEGAL_INPUT;                                   \
1170             break;                                                            \
1171           }                                                                   \
1172         inptr += 2;                                                           \
1173         ++*irreversible;                                                      \
1174         continue;                                                             \
1175       }                                                                       \
1176                                                                               \
1177     *((uint32_t *) outptr)++ = u1;                                            \
1178     inptr += 2;                                                               \
1179   }
1180 #define LOOP_NEED_FLAGS
1181 #include <iconv/loop.c>
1182 #include <iconv/skeleton.c>
1183
1184
1185 /* Convert from the internal (UCS4-like) format to UCS2.  */
1186 #define DEFINE_INIT             0
1187 #define DEFINE_FINI             0
1188 #define MIN_NEEDED_FROM         4
1189 #define MIN_NEEDED_TO           2
1190 #define FROM_DIRECTION          1
1191 #define FROM_LOOP               internal_ucs2_loop
1192 #define TO_LOOP                 internal_ucs2_loop /* This is not used.  */
1193 #define FUNCTION_NAME           __gconv_transform_internal_ucs2
1194 #define ONE_DIRECTION           1
1195
1196 #define MIN_NEEDED_INPUT        MIN_NEEDED_FROM
1197 #define MIN_NEEDED_OUTPUT       MIN_NEEDED_TO
1198 #define LOOPFCT                 FROM_LOOP
1199 #define BODY \
1200   {                                                                           \
1201     uint32_t val = *((const uint32_t *) inptr);                               \
1202                                                                               \
1203     if (__builtin_expect (val >= 0x10000, 0))                                 \
1204       {                                                                       \
1205         UNICODE_TAG_HANDLER (val, 4);                                         \
1206         STANDARD_ERR_HANDLER (4);                                             \
1207       }                                                                       \
1208     else if (__builtin_expect (val >= 0xd800 && val < 0xe000, 0))             \
1209       {                                                                       \
1210         /* Surrogate characters in UCS-4 input are not valid.                 \
1211            We must catch this, because the UCS-2 output might be              \
1212            interpreted as UTF-16 by other programs.  If we let                \
1213            surrogates pass through, attackers could make a security           \
1214            hole exploit by synthesizing any desired plane 1-16                \
1215            character.  */                                                     \
1216         if (! ignore_errors_p ())                                             \
1217           {                                                                   \
1218             result = __GCONV_ILLEGAL_INPUT;                                   \
1219             break;                                                            \
1220           }                                                                   \
1221         inptr += 4;                                                           \
1222         ++*irreversible;                                                      \
1223         continue;                                                             \
1224       }                                                                       \
1225     else                                                                      \
1226       {                                                                       \
1227         *((uint16_t *) outptr)++ = val;                                       \
1228         inptr += 4;                                                           \
1229       }                                                                       \
1230   }
1231 #define LOOP_NEED_FLAGS
1232 #include <iconv/loop.c>
1233 #include <iconv/skeleton.c>
1234
1235
1236 /* Convert from UCS2 in other endianness to the internal (UCS4-like) format. */
1237 #define DEFINE_INIT             0
1238 #define DEFINE_FINI             0
1239 #define MIN_NEEDED_FROM         2
1240 #define MIN_NEEDED_TO           4
1241 #define FROM_DIRECTION          1
1242 #define FROM_LOOP               ucs2reverse_internal_loop
1243 #define TO_LOOP                 ucs2reverse_internal_loop/* This is not used.*/
1244 #define FUNCTION_NAME           __gconv_transform_ucs2reverse_internal
1245 #define ONE_DIRECTION           1
1246
1247 #define MIN_NEEDED_INPUT        MIN_NEEDED_FROM
1248 #define MIN_NEEDED_OUTPUT       MIN_NEEDED_TO
1249 #define LOOPFCT                 FROM_LOOP
1250 #define BODY \
1251   {                                                                           \
1252     uint16_t u1 = bswap_16 (*((const uint16_t *) inptr));                     \
1253                                                                               \
1254     if (__builtin_expect (u1 >= 0xd800 && u1 < 0xe000, 0))                    \
1255       {                                                                       \
1256         /* Surrogate characters in UCS-2 input are not valid.  Reject         \
1257            them.  (Catching this here is not security relevant.)  */          \
1258         if (! ignore_errors_p ())                                             \
1259           {                                                                   \
1260             result = __GCONV_ILLEGAL_INPUT;                                   \
1261             break;                                                            \
1262           }                                                                   \
1263         inptr += 2;                                                           \
1264         ++*irreversible;                                                      \
1265         continue;                                                             \
1266       }                                                                       \
1267                                                                               \
1268     *((uint32_t *) outptr)++ = u1;                                            \
1269     inptr += 2;                                                               \
1270   }
1271 #define LOOP_NEED_FLAGS
1272 #include <iconv/loop.c>
1273 #include <iconv/skeleton.c>
1274
1275
1276 /* Convert from the internal (UCS4-like) format to UCS2 in other endianness. */
1277 #define DEFINE_INIT             0
1278 #define DEFINE_FINI             0
1279 #define MIN_NEEDED_FROM         4
1280 #define MIN_NEEDED_TO           2
1281 #define FROM_DIRECTION          1
1282 #define FROM_LOOP               internal_ucs2reverse_loop
1283 #define TO_LOOP                 internal_ucs2reverse_loop/* This is not used.*/
1284 #define FUNCTION_NAME           __gconv_transform_internal_ucs2reverse
1285 #define ONE_DIRECTION           1
1286
1287 #define MIN_NEEDED_INPUT        MIN_NEEDED_FROM
1288 #define MIN_NEEDED_OUTPUT       MIN_NEEDED_TO
1289 #define LOOPFCT                 FROM_LOOP
1290 #define BODY \
1291   {                                                                           \
1292     uint32_t val = *((const uint32_t *) inptr);                               \
1293     if (__builtin_expect (val >= 0x10000, 0))                                 \
1294       {                                                                       \
1295         UNICODE_TAG_HANDLER (val, 4);                                         \
1296         STANDARD_ERR_HANDLER (4);                                             \
1297       }                                                                       \
1298     else if (__builtin_expect (val >= 0xd800 && val < 0xe000, 0))             \
1299       {                                                                       \
1300         /* Surrogate characters in UCS-4 input are not valid.                 \
1301            We must catch this, because the UCS-2 output might be              \
1302            interpreted as UTF-16 by other programs.  If we let                \
1303            surrogates pass through, attackers could make a security           \
1304            hole exploit by synthesizing any desired plane 1-16                \
1305            character.  */                                                     \
1306         if (! ignore_errors_p ())                                             \
1307           {                                                                   \
1308             result = __GCONV_ILLEGAL_INPUT;                                   \
1309             break;                                                            \
1310           }                                                                   \
1311         inptr += 4;                                                           \
1312         ++*irreversible;                                                      \
1313         continue;                                                             \
1314       }                                                                       \
1315     else                                                                      \
1316       {                                                                       \
1317         *((uint16_t *) outptr)++ = bswap_16 (val);                            \
1318         inptr += 4;                                                           \
1319       }                                                                       \
1320   }
1321 #define LOOP_NEED_FLAGS
1322 #include <iconv/loop.c>
1323 #include <iconv/skeleton.c>