iconvdata/cp1255.c

   1 /* Conversion from and to CP1255.
   2    Copyright (C) 1998, 2001, 2002, 2004 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998,
   5    and Bruno Haible <haible@clisp.cons.org>, 2001.
   6
   7    The GNU C Library is free software; you can redistribute it and/or
   8    modify it under the terms of the GNU Lesser General Public
   9    License as published by the Free Software Foundation; either
  10    version 2.1 of the License, or (at your option) any later version.
  11
  12    The GNU C Library is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15    Lesser General Public License for more details.
  16
  17    You should have received a copy of the GNU Lesser General Public
  18    License along with the GNU C Library; if not, see
  19    <http://www.gnu.org/licenses/>.  */
  20
  21 #include <dlfcn.h>
  22 #include <stdint.h>
  23 #include <assert.h>
  24
  25 #define NELEMS(arr) (sizeof (arr) / sizeof (arr[0]))
  26
  27 /* Definitions used in the body of the `gconv' function.  */
  28 #define CHARSET_NAME            "CP1255//"
  29 #define FROM_LOOP               from_cp1255
  30 #define TO_LOOP                 to_cp1255
  31 #define DEFINE_INIT             1
  32 #define DEFINE_FINI             1
  33 #define FROM_LOOP_MIN_NEEDED_FROM       1
  34 #define FROM_LOOP_MAX_NEEDED_FROM       1
  35 #define FROM_LOOP_MIN_NEEDED_TO         4
  36 #define FROM_LOOP_MAX_NEEDED_TO         4
  37 #define TO_LOOP_MIN_NEEDED_FROM         4
  38 #define TO_LOOP_MAX_NEEDED_FROM         4
  39 #define TO_LOOP_MIN_NEEDED_TO           1
  40 #define TO_LOOP_MAX_NEEDED_TO           3
  41 #define PREPARE_LOOP \
  42   int saved_state;                                                            \
  43   int *statep = &data->__statep->__count;
  44 #define EXTRA_LOOP_ARGS         , statep
  45
  46
  47 /* Since we might have to reset input pointer we must be able to save
  48    and restore the state.  */
  49 #define SAVE_RESET_STATE(Save) \
  50   if (Save)                                                                   \
  51     saved_state = *statep;                                                    \
  52   else                                                                        \
  53     *statep = saved_state
  54
  55
  56 /* During CP1255 to UCS4 conversion, the COUNT element of the state
  57    contains the last UCS4 character, shifted by 3 bits.  */
  58
  59
  60 /* Since this is a stateful encoding we have to provide code which resets
  61    the output state to the initial state.  This has to be done during the
  62    flushing.  */
  63 #define EMIT_SHIFT_TO_INIT \
  64   if (data->__statep->__count != 0)                                           \
  65     {                                                                         \
  66       if (FROM_DIRECTION)                                                     \
  67         {                                                                     \
  68           if (__builtin_expect (outbuf + 4 <= outend, 1))                     \
  69             {                                                                 \
  70               /* Write out the last character.  */                            \
  71               *((uint32_t *) outbuf) = data->__statep->__count >> 3;          \
  72               outbuf += sizeof (uint32_t);                                    \
  73               data->__statep->__count = 0;                                    \
  74             }                                                                 \
  75           else                                                                \
  76             /* We don't have enough room in the output buffer.  */            \
  77             status = __GCONV_FULL_OUTPUT;                                     \
  78         }                                                                     \
  79       else                                                                    \
  80         /* We don't use shift states in the TO_DIRECTION.  */                 \
  81         data->__statep->__count = 0;                                          \
  82     }
  83
  84
  85 /* First define the conversion function from CP1255 to UCS4.  */
  86
  87 static const uint16_t to_ucs4[128] = {
  88   /* 0x80 */
  89   0x20AC,      0, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
  90   0x02C6, 0x2030,      0, 0x2039,      0,      0,      0,      0,
  91   /* 0x90 */
  92        0, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
  93   0x02DC, 0x2122,      0, 0x203A,      0,      0,      0,      0,
  94   /* 0xA0 */
  95   0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x20AA, 0x00A5, 0x00A6, 0x00A7,
  96   0x00A8, 0x00A9, 0x00D7, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
  97   /* 0xB0 */
  98   0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
  99   0x00B8, 0x00B9, 0x00F7, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
 100   /* 0xC0 */
 101   0x05B0, 0x05B1, 0x05B2, 0x05B3, 0x05B4, 0x05B5, 0x05B6, 0x05B7,
 102   0x05B8, 0x05B9,      0, 0x05BB, 0x05BC, 0x05BD, 0x05BE, 0x05BF,
 103   /* 0xD0 */
 104   0x05C0, 0x05C1, 0x05C2, 0x05C3, 0x05F0, 0x05F1, 0x05F2, 0x05F3,
 105   0x05F4,      0,      0,      0,      0,      0,      0,      0,
 106   /* 0xE0 */
 107   0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7,
 108   0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF,
 109   /* 0xF0 */
 110   0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5, 0x05E6, 0x05E7,
 111   0x05E8, 0x05E9, 0x05EA,      0,      0, 0x200E, 0x200F,      0,
 112 };
 113
 114 /* CP1255 contains eight combining characters:
 115    0x05b4, 0x05b7, 0x05b8, 0x05b9, 0x05bc, 0x05bf, 0x05c1, 0x05c2.  */
 116
 117 /* Composition tables for each of the relevant combining characters.  */
 118 static const struct {
 119   uint16_t base;
 120   uint16_t composed;
 121 } comp_table_data[] = {
 122 #define COMP_TABLE_IDX_05B4 0
 123 #define COMP_TABLE_LEN_05B4 1
 124   { 0x05D9, 0xFB1D },
 125 #define COMP_TABLE_IDX_05B7 (COMP_TABLE_IDX_05B4 + COMP_TABLE_LEN_05B4)
 126 #define COMP_TABLE_LEN_05B7 2
 127   { 0x05D0, 0xFB2E },
 128   { 0x05F2, 0xFB1F },
 129 #define COMP_TABLE_IDX_05B8 (COMP_TABLE_IDX_05B7 + COMP_TABLE_LEN_05B7)
 130 #define COMP_TABLE_LEN_05B8 1
 131   { 0x05D0, 0xFB2F },
 132 #define COMP_TABLE_IDX_05B9 (COMP_TABLE_IDX_05B8 + COMP_TABLE_LEN_05B8)
 133 #define COMP_TABLE_LEN_05B9 1
 134   { 0x05D5, 0xFB4B },
 135 #define COMP_TABLE_IDX_05BC (COMP_TABLE_IDX_05B9 + COMP_TABLE_LEN_05B9)
 136 #define COMP_TABLE_LEN_05BC 24
 137   { 0x05D0, 0xFB30 },
 138   { 0x05D1, 0xFB31 },
 139   { 0x05D2, 0xFB32 },
 140   { 0x05D3, 0xFB33 },
 141   { 0x05D4, 0xFB34 },
 142   { 0x05D5, 0xFB35 },
 143   { 0x05D6, 0xFB36 },
 144   { 0x05D8, 0xFB38 },
 145   { 0x05D9, 0xFB39 },
 146   { 0x05DA, 0xFB3A },
 147   { 0x05DB, 0xFB3B },
 148   { 0x05DC, 0xFB3C },
 149   { 0x05DE, 0xFB3E },
 150   { 0x05E0, 0xFB40 },
 151   { 0x05E1, 0xFB41 },
 152   { 0x05E3, 0xFB43 },
 153   { 0x05E4, 0xFB44 },
 154   { 0x05E6, 0xFB46 },
 155   { 0x05E7, 0xFB47 },
 156   { 0x05E8, 0xFB48 },
 157   { 0x05E9, 0xFB49 },
 158   { 0x05EA, 0xFB4A },
 159   { 0xFB2A, 0xFB2C },
 160   { 0xFB2B, 0xFB2D },
 161 #define COMP_TABLE_IDX_05BF (COMP_TABLE_IDX_05BC + COMP_TABLE_LEN_05BC)
 162 #define COMP_TABLE_LEN_05BF 3
 163   { 0x05D1, 0xFB4C },
 164   { 0x05DB, 0xFB4D },
 165   { 0x05E4, 0xFB4E },
 166 #define COMP_TABLE_IDX_05C1 (COMP_TABLE_IDX_05BF + COMP_TABLE_LEN_05BF)
 167 #define COMP_TABLE_LEN_05C1 2
 168   { 0x05E9, 0xFB2A },
 169   { 0xFB49, 0xFB2C },
 170 #define COMP_TABLE_IDX_05C2 (COMP_TABLE_IDX_05C1 + COMP_TABLE_LEN_05C1)
 171 #define COMP_TABLE_LEN_05C2 2
 172   { 0x05E9, 0xFB2B },
 173   { 0xFB49, 0xFB2D },
 174 #define COMP_TABLE_IDX_END (COMP_TABLE_IDX_05C2 + COMP_TABLE_LEN_05C2)
 175 };
 176 /* Compile-time verification of table size.  */
 177 typedef int verify1[(NELEMS (comp_table_data) == COMP_TABLE_IDX_END) - 1];
 178
 179 static const struct { unsigned int idx; unsigned int len; } comp_table[8] = {
 180   { COMP_TABLE_IDX_05B4, COMP_TABLE_LEN_05B4 },
 181   { COMP_TABLE_IDX_05B7, COMP_TABLE_LEN_05B7 },
 182   { COMP_TABLE_IDX_05B8, COMP_TABLE_LEN_05B8 },
 183   { COMP_TABLE_IDX_05B9, COMP_TABLE_LEN_05B9 },
 184   { COMP_TABLE_IDX_05BC, COMP_TABLE_LEN_05BC },
 185   { COMP_TABLE_IDX_05BF, COMP_TABLE_LEN_05BF },
 186   { COMP_TABLE_IDX_05C1, COMP_TABLE_LEN_05C1 },
 187   { COMP_TABLE_IDX_05C2, COMP_TABLE_LEN_05C2 },
 188 };
 189
 190 #define MIN_NEEDED_INPUT        FROM_LOOP_MIN_NEEDED_FROM
 191 #define MAX_NEEDED_INPUT        FROM_LOOP_MAX_NEEDED_FROM
 192 #define MIN_NEEDED_OUTPUT       FROM_LOOP_MIN_NEEDED_TO
 193 #define MAX_NEEDED_OUTPUT       FROM_LOOP_MAX_NEEDED_TO
 194 #define LOOPFCT                 FROM_LOOP
 195 #define BODY \
 196   {                                                                           \
 197     uint32_t ch = *inptr;                                                     \
 198     uint32_t last_ch;                                                         \
 199     int must_buffer_ch;                                                       \
 200                                                                               \
 201     if (ch >= 0x80)                                                           \
 202       {                                                                       \
 203         ch = to_ucs4[ch - 0x80];                                              \
 204         if (__builtin_expect (ch == L'\0', 0))                                \
 205           {                                                                   \
 206             /* This is an illegal character.  */                              \
 207             STANDARD_FROM_LOOP_ERR_HANDLER (1);                               \
 208           }                                                                   \
 209       }                                                                       \
 210                                                                               \
 211     /* Determine whether there is a buffered character pending.  */           \
 212     last_ch = *statep >> 3;                                                   \
 213                                                                               \
 214     /* We have to buffer ch if it is a possible match in comp_table_data.  */ \
 215     must_buffer_ch = (ch >= 0x05d0 && ch <= 0x05f2);                          \
 216                                                                               \
 217     if (last_ch)                                                              \
 218       {                                                                       \
 219         if (ch >= 0x05b0 && ch < 0x05c5)                                      \
 220           {                                                                   \
 221             /* See whether last_ch and ch can be combined.  */                \
 222             unsigned int i, i1, i2;                                           \
 223                                                                               \
 224             switch (ch)                                                       \
 225               {                                                               \
 226               case 0x05b4:                                                    \
 227                 i = 0;                                                        \
 228                 break;                                                        \
 229               case 0x05b7:                                                    \
 230                 i = 1;                                                        \
 231                 break;                                                        \
 232               case 0x05b8:                                                    \
 233                 i = 2;                                                        \
 234                 break;                                                        \
 235               case 0x05b9:                                                    \
 236                 i = 3;                                                        \
 237                 break;                                                        \
 238               case 0x05bc:                                                    \
 239                 i = 4;                                                        \
 240                 break;                                                        \
 241               case 0x05bf:                                                    \
 242                 i = 5;                                                        \
 243                 break;                                                        \
 244               case 0x05c1:                                                    \
 245                 i = 6;                                                        \
 246                 break;                                                        \
 247               case 0x05c2:                                                    \
 248                 i = 7;                                                        \
 249                 break;                                                        \
 250               default:                                                        \
 251                 goto not_combining;                                           \
 252               }                                                               \
 253                                                                               \
 254             i1 = comp_table[i].idx;                                           \
 255             i2 = i1 + comp_table[i].len - 1;                                  \
 256                                                                               \
 257             if (last_ch >= comp_table_data[i1].base                           \
 258                 && last_ch <= comp_table_data[i2].base)                       \
 259               {                                                               \
 260                 for (;;)                                                      \
 261                   {                                                           \
 262                     i = (i1 + i2) >> 1;                                       \
 263                     if (last_ch == comp_table_data[i].base)                   \
 264                       break;                                                  \
 265                     if (last_ch < comp_table_data[i].base)                    \
 266                       {                                                       \
 267                         if (i1 == i)                                          \
 268                           goto not_combining;                                 \
 269                         i2 = i;                                               \
 270                       }                                                       \
 271                     else                                                      \
 272                       {                                                       \
 273                         if (i1 != i)                                          \
 274                           i1 = i;                                             \
 275                         else                                                  \
 276                           {                                                   \
 277                             i = i2;                                           \
 278                             if (last_ch == comp_table_data[i].base)           \
 279                               break;                                          \
 280                             goto not_combining;                               \
 281                           }                                                   \
 282                       }                                                       \
 283                   }                                                           \
 284                 last_ch = comp_table_data[i].composed;                        \
 285                 if (last_ch == 0xfb2a || last_ch == 0xfb2b                    \
 286                     || last_ch == 0xfb49)                                     \
 287                   /* Buffer the combined character.  */                       \
 288                   *statep = last_ch << 3;                                     \
 289                 else                                                          \
 290                   {                                                           \
 291                     /* Output the combined character.  */                     \
 292                     put32 (outptr, last_ch);                                  \
 293                     outptr += 4;                                              \
 294                     *statep = 0;                                              \
 295                   }                                                           \
 296                 ++inptr;                                                      \
 297                 continue;                                                     \
 298               }                                                               \
 299           }                                                                   \
 300                                                                               \
 301       not_combining:                                                          \
 302         /* Output the buffered character.  */                                 \
 303         put32 (outptr, last_ch);                                              \
 304         outptr += 4;                                                          \
 305         *statep = 0;                                                          \
 306                                                                               \
 307         /* If we don't have enough room to output ch as well, then deal       \
 308            with it in another round.  */                                      \
 309         if (!must_buffer_ch && __builtin_expect (outptr + 4 > outend, 0))     \
 310           continue;                                                           \
 311       }                                                                       \
 312                                                                               \
 313     if (must_buffer_ch)                                                       \
 314       *statep = ch << 3;                                                      \
 315     else                                                                      \
 316       {                                                                       \
 317         put32 (outptr, ch);                                                   \
 318         outptr += 4;                                                          \
 319       }                                                                       \
 320     ++inptr;                                                                  \
 321   }
 322 #define LOOP_NEED_FLAGS
 323 #define EXTRA_LOOP_DECLS        , int *statep
 324 #define ONEBYTE_BODY \
 325   {                                                                           \
 326     if (c < 0x80)                                                             \
 327       return c;                                                               \
 328     uint32_t ch = to_ucs4[c - 0x80];                                          \
 329     if (ch == L'\0' || (ch >= 0x05d0 && ch <= 0x05f2))                        \
 330       return WEOF;                                                            \
 331     return ch;                                                                \
 332   }
 333 #include <iconv/loop.c>
 334
 335
 336 /* Next, define the conversion function from UCS4 to CP1255.  */
 337
 338 static const unsigned char from_ucs4[] = {
 339 #define FROM_IDX_00 0
 340   0xa0, 0xa1, 0xa2, 0xa3, 0x00, 0xa5, 0xa6, 0xa7, /* 0x00a0-0x00a7 */
 341   0xa8, 0xa9, 0x00, 0xab, 0xac, 0xad, 0xae, 0xaf, /* 0x00a8-0x00af */
 342   0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, /* 0x00b0-0x00b7 */
 343   0xb8, 0xb9, 0x00, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, /* 0x00b8-0x00bf */
 344   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x00c0-0x00c7 */
 345   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x00c8-0x00cf */
 346   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xaa, /* 0x00d0-0x00d7 */
 347   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x00d8-0x00df */
 348   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x00e0-0x00e7 */
 349   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x00e8-0x00ef */
 350   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xba, /* 0x00f0-0x00f7 */
 351 #define FROM_IDX_02 (FROM_IDX_00 + 88)
 352                                       0x88, 0x00, /* 0x02c6-0x02c7 */
 353   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x02c8-0x02cf */
 354   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x02d0-0x02d7 */
 355   0x00, 0x00, 0x00, 0x00, 0x98,                   /* 0x02d8-0x02dc */
 356 #define FROM_IDX_05 (FROM_IDX_02 + 23)
 357   0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, /* 0x05b0-0x05b7 */
 358   0xc8, 0xc9, 0x00, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, /* 0x05b8-0x05bf */
 359   0xd0, 0xd1, 0xd2, 0xd3, 0x00, 0x00, 0x00, 0x00, /* 0x05c0-0x05c7 */
 360   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x05c8-0x05cf */
 361   0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, /* 0x05d0-0x05d7 */
 362   0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, /* 0x05d8-0x05df */
 363   0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, /* 0x05e0-0x05e7 */
 364   0xf8, 0xf9, 0xfa, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x05e8-0x05ef */
 365   0xd4, 0xd5, 0xd6, 0xd7, 0xd8,                   /* 0x05f0-0x05f4 */
 366 #define FROM_IDX_20 (FROM_IDX_05 + 69)
 367                                       0xfd, 0xfe, /* 0x200e-0x200f */
 368   0x00, 0x00, 0x00, 0x96, 0x97, 0x00, 0x00, 0x00, /* 0x2010-0x2017 */
 369   0x91, 0x92, 0x82, 0x00, 0x93, 0x94, 0x84, 0x00, /* 0x2018-0x201f */
 370   0x86, 0x87, 0x95, 0x00, 0x00, 0x00, 0x85, 0x00, /* 0x2020-0x2027 */
 371   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x2028-0x202f */
 372   0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x2030-0x2037 */
 373   0x00, 0x8b, 0x9b,                               /* 0x2038-0x203a */
 374 #define FROM_IDX_FF (FROM_IDX_20 + 45)
 375 };
 376 /* Compile-time verification of table size.  */
 377 typedef int verify2[(NELEMS (from_ucs4) == FROM_IDX_FF) - 1];
 378
 379 static const unsigned char comb_table[8] = {
 380   0xc4, 0xc7, 0xc8, 0xc9, 0xcc, 0xcf, 0xd1, 0xd2,
 381 };
 382
 383 /* Decomposition table for the relevant Unicode characters. */
 384 static const struct {
 385   uint16_t composed;
 386   uint16_t base;
 387   uint32_t comb1 : 8;
 388   int32_t comb2 : 8;
 389 } decomp_table[] = {
 390   { 0xFB1D, 0x05D9, 0, -1 },
 391   { 0xFB1F, 0x05F2, 1, -1 },
 392   { 0xFB2A, 0x05E9, 6, -1 },
 393   { 0xFB2B, 0x05E9, 7, -1 },
 394   { 0xFB2C, 0x05E9, 4, 6 },
 395   { 0xFB2D, 0x05E9, 4, 7 },
 396   { 0xFB2E, 0x05D0, 1, -1 },
 397   { 0xFB2F, 0x05D0, 2, -1 },
 398   { 0xFB30, 0x05D0, 4, -1 },
 399   { 0xFB31, 0x05D1, 4, -1 },
 400   { 0xFB32, 0x05D2, 4, -1 },
 401   { 0xFB33, 0x05D3, 4, -1 },
 402   { 0xFB34, 0x05D4, 4, -1 },
 403   { 0xFB35, 0x05D5, 4, -1 },
 404   { 0xFB36, 0x05D6, 4, -1 },
 405   { 0xFB38, 0x05D8, 4, -1 },
 406   { 0xFB39, 0x05D9, 4, -1 },
 407   { 0xFB3A, 0x05DA, 4, -1 },
 408   { 0xFB3B, 0x05DB, 4, -1 },
 409   { 0xFB3C, 0x05DC, 4, -1 },
 410   { 0xFB3E, 0x05DE, 4, -1 },
 411   { 0xFB40, 0x05E0, 4, -1 },
 412   { 0xFB41, 0x05E1, 4, -1 },
 413   { 0xFB43, 0x05E3, 4, -1 },
 414   { 0xFB44, 0x05E4, 4, -1 },
 415   { 0xFB46, 0x05E6, 4, -1 },
 416   { 0xFB47, 0x05E7, 4, -1 },
 417   { 0xFB48, 0x05E8, 4, -1 },
 418   { 0xFB49, 0x05E9, 4, -1 },
 419   { 0xFB4A, 0x05EA, 4, -1 },
 420   { 0xFB4B, 0x05D5, 3, -1 },
 421   { 0xFB4C, 0x05D1, 5, -1 },
 422   { 0xFB4D, 0x05DB, 5, -1 },
 423   { 0xFB4E, 0x05E4, 5, -1 },
 424 };
 425
 426 #define MIN_NEEDED_INPUT        TO_LOOP_MIN_NEEDED_FROM
 427 #define MAX_NEEDED_INPUT        TO_LOOP_MAX_NEEDED_FROM
 428 #define MIN_NEEDED_OUTPUT       TO_LOOP_MIN_NEEDED_TO
 429 #define MAX_NEEDED_OUTPUT       TO_LOOP_MAX_NEEDED_TO
 430 #define LOOPFCT                 TO_LOOP
 431 #define BODY \
 432   {                                                                           \
 433     uint32_t ch = get32 (inptr);                                              \
 434                                                                               \
 435     if (ch < 0x0080)                                                          \
 436       {                                                                       \
 437         *outptr++ = ch;                                                       \
 438         inptr += 4;                                                           \
 439       }                                                                       \
 440     else                                                                      \
 441       {                                                                       \
 442         unsigned char res;                                                    \
 443                                                                               \
 444         if (ch >= 0x00a0 && ch < 0x00f8)                                      \
 445           res = from_ucs4[ch - 0x00a0 + FROM_IDX_00];                         \
 446         else if (ch == 0x0192)                                                \
 447           res = 0x83;                                                         \
 448         else if (ch >= 0x02c6 && ch < 0x02dd)                                 \
 449           res = from_ucs4[ch - 0x02c6 + FROM_IDX_02];                         \
 450         else if (ch >= 0x05b0 && ch < 0x05f5)                                 \
 451           res = from_ucs4[ch - 0x05b0 + FROM_IDX_05];                         \
 452         else if (ch >= 0x200e && ch < 0x203b)                                 \
 453           res = from_ucs4[ch - 0x200e + FROM_IDX_20];                         \
 454         else if (ch == 0x20aa)                                                \
 455           res = 0xa4;                                                         \
 456         else if (ch == 0x20ac)                                                \
 457           res = 0x80;                                                         \
 458         else if (ch == 0x2122)                                                \
 459           res = 0x99;                                                         \
 460         else                                                                  \
 461           {                                                                   \
 462             UNICODE_TAG_HANDLER (ch, 4);                                      \
 463             res = 0;                                                          \
 464           }                                                                   \
 465                                                                               \
 466         if (__builtin_expect (res != 0, 1))                                   \
 467           {                                                                   \
 468             *outptr++ = res;                                                  \
 469             inptr += 4;                                                       \
 470           }                                                                   \
 471         else                                                                  \
 472           {                                                                   \
 473             /* Try canonical decomposition.  */                               \
 474             unsigned int i1, i2;                                              \
 475                                                                               \
 476             i1 = 0;                                                           \
 477             i2 = sizeof (decomp_table) / sizeof (decomp_table[0]) - 1;        \
 478             if (ch >= decomp_table[i1].composed                               \
 479                 && ch <= decomp_table[i2].composed)                           \
 480               {                                                               \
 481                 unsigned int i;                                               \
 482                                                                               \
 483                 for (;;)                                                      \
 484                   {                                                           \
 485                     i = (i1 + i2) >> 1;                                       \
 486                     if (ch == decomp_table[i].composed)                       \
 487                       break;                                                  \
 488                     if (ch < decomp_table[i].composed)                        \
 489                       {                                                       \
 490                         if (i1 == i)                                          \
 491                           goto failed;                                        \
 492                         i2 = i;                                               \
 493                       }                                                       \
 494                     else                                                      \
 495                       {                                                       \
 496                         if (i1 != i)                                          \
 497                           i1 = i;                                             \
 498                         else                                                  \
 499                           {                                                   \
 500                             i = i2;                                           \
 501                             if (ch == decomp_table[i].composed)               \
 502                               break;                                          \
 503                             goto failed;                                      \
 504                           }                                                   \
 505                       }                                                       \
 506                   }                                                           \
 507                                                                               \
 508                 /* Found a canonical decomposition.  */                       \
 509                 ch = decomp_table[i].base;                                    \
 510                 /* ch is one of 0x05d0..0x05d6, 0x05d8..0x05dc, 0x05de,       \
 511                    0x05e0..0x05e1, 0x05e3..0x05e4, 0x05e6..0x05ea, 0x05f2. */ \
 512                 ch = from_ucs4[ch - 0x05b0 + FROM_IDX_05];                    \
 513                 assert (ch != 0);                                             \
 514                                                                               \
 515                 if (decomp_table[i].comb2 < 0)                                \
 516                   {                                                           \
 517                     /* See whether we have room for two bytes.  */            \
 518                     if (__builtin_expect (outptr + 1 >= outend, 0))           \
 519                       {                                                       \
 520                         result = __GCONV_FULL_OUTPUT;                         \
 521                         break;                                                \
 522                       }                                                       \
 523                                                                               \
 524                     *outptr++ = (unsigned char) ch;                           \
 525                     *outptr++ = comb_table[decomp_table[i].comb1];            \
 526                   }                                                           \
 527                 else                                                          \
 528                   {                                                           \
 529                     /* See whether we have room for three bytes.  */          \
 530                     if (__builtin_expect (outptr + 2 >= outend, 0))           \
 531                       {                                                       \
 532                         result = __GCONV_FULL_OUTPUT;                         \
 533                         break;                                                \
 534                       }                                                       \
 535                                                                               \
 536                     *outptr++ = (unsigned char) ch;                           \
 537                     *outptr++ = comb_table[decomp_table[i].comb1];            \
 538                     *outptr++ = comb_table[decomp_table[i].comb2];            \
 539                   }                                                           \
 540                                                                               \
 541                 inptr += 4;                                                   \
 542                 continue;                                                     \
 543               }                                                               \
 544                                                                               \
 545           failed:                                                             \
 546             /* This is an illegal character.  */                              \
 547             STANDARD_TO_LOOP_ERR_HANDLER (4);                                 \
 548           }                                                                   \
 549       }                                                                       \
 550   }
 551 #define LOOP_NEED_FLAGS
 552 #define EXTRA_LOOP_DECLS        , int *statep
 553 #include <iconv/loop.c>
 554
 555
 556 /* Now define the toplevel functions.  */
 557 #include <iconv/skeleton.c>