iconvdata/iso-2022-jp-3.c

   1 /* Conversion module for ISO-2022-JP-3.
   2    Copyright (C) 1998-2015 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 <bruno@clisp.org>, 2002.
   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 <assert.h>
  22 #include <dlfcn.h>
  23 #include <gconv.h>
  24 #include <stdint.h>
  25 #include <string.h>
  26
  27 #include "jis0201.h"
  28 #include "jis0208.h"
  29 #include "jisx0213.h"
  30
  31 /* This makes obvious what everybody knows: 0x1b is the Esc character.  */
  32 #define ESC 0x1b
  33
  34 /* Definitions used in the body of the `gconv' function.  */
  35 #define CHARSET_NAME            "ISO-2022-JP-3//"
  36 #define FROM_LOOP               from_iso2022jp3_loop
  37 #define TO_LOOP                 to_iso2022jp3_loop
  38 #define DEFINE_INIT             1
  39 #define DEFINE_FINI             1
  40 #define ONE_DIRECTION           0
  41 #define FROM_LOOP_MIN_NEEDED_FROM       1
  42 #define FROM_LOOP_MAX_NEEDED_FROM       4
  43 #define FROM_LOOP_MIN_NEEDED_TO         4
  44 #define FROM_LOOP_MAX_NEEDED_TO         8
  45 #define TO_LOOP_MIN_NEEDED_FROM         4
  46 #define TO_LOOP_MAX_NEEDED_FROM         4
  47 #define TO_LOOP_MIN_NEEDED_TO           1
  48 #define TO_LOOP_MAX_NEEDED_TO           6
  49 #define PREPARE_LOOP \
  50   int saved_state;                                                            \
  51   int *statep = &data->__statep->__count;
  52 #define EXTRA_LOOP_ARGS         , statep
  53
  54
  55 /* The COUNT element of the state keeps track of the currently selected
  56    character set.  The possible values are:  */
  57 enum
  58 {
  59   ASCII_set = 0,                /* Esc ( B */
  60   JISX0208_1978_set = 1 << 3,   /* Esc $ @ */
  61   JISX0208_1983_set = 2 << 3,   /* Esc $ B */
  62   JISX0201_Roman_set = 3 << 3,  /* Esc ( J */
  63   JISX0201_Kana_set = 4 << 3,   /* Esc ( I */
  64   JISX0213_1_2000_set = 5 << 3, /* Esc $ ( O */
  65   JISX0213_2_set = 6 << 3,      /* Esc $ ( P */
  66   JISX0213_1_2004_set = 7 << 3, /* Esc $ ( Q */
  67   CURRENT_SEL_MASK = 7 << 3
  68 };
  69
  70 /* During UCS-4 to ISO-2022-JP-3 conversion, the COUNT element of the state
  71    also contains the last two bytes to be output, shifted by 6 bits, and a
  72    one-bit indicator whether they must be preceded by the shift sequence,
  73    in bit 22.  */
  74
  75 /* Since this is a stateful encoding we have to provide code which resets
  76    the output state to the initial state.  This has to be done during the
  77    flushing.  */
  78 #define EMIT_SHIFT_TO_INIT \
  79   if ((data->__statep->__count & ~7) != ASCII_set)                            \
  80     {                                                                         \
  81       if (FROM_DIRECTION)                                                     \
  82         {                                                                     \
  83           /* It's easy, we don't have to emit anything, we just reset the     \
  84              state for the input.  */                                         \
  85           data->__statep->__count &= 7;                                       \
  86           data->__statep->__count |= ASCII_set;                               \
  87         }                                                                     \
  88       else                                                                    \
  89         {                                                                     \
  90           /* We are not in the initial state.  To switch back we have         \
  91              to write out the buffered character and/or emit the sequence     \
  92              `Esc ( B'.  */                                                   \
  93           size_t need =                                                       \
  94             (data->__statep->__count >> 6                                     \
  95              ? (data->__statep->__count >> 22 ? 3 : 0) + 2                    \
  96              : 0)                                                             \
  97             + ((data->__statep->__count & CURRENT_SEL_MASK) != ASCII_set      \
  98                ? 3 : 0);                                                      \
  99                                                                               \
 100           if (__glibc_unlikely (outbuf + need > outend))                      \
 101             /* We don't have enough room in the output buffer.  */            \
 102             status = __GCONV_FULL_OUTPUT;                                     \
 103           else                                                                \
 104             {                                                                 \
 105               if (data->__statep->__count >> 6)                               \
 106                 {                                                             \
 107                   uint32_t lasttwo = data->__statep->__count >> 6;            \
 108                                                                               \
 109                   if (lasttwo >> 16)                                          \
 110                     {                                                         \
 111                       /* Write out the shift sequence before the last         \
 112                          character.  */                                       \
 113                       assert ((data->__statep->__count & CURRENT_SEL_MASK)    \
 114                               == JISX0208_1983_set);                          \
 115                       *outbuf++ = ESC;                                        \
 116                       *outbuf++ = '$';                                        \
 117                       *outbuf++ = 'B';                                        \
 118                     }                                                         \
 119                   /* Write out the last character.  */                        \
 120                   *outbuf++ = (lasttwo >> 8) & 0xff;                          \
 121                   *outbuf++ = lasttwo & 0xff;                                 \
 122                 }                                                             \
 123               if ((data->__statep->__count & CURRENT_SEL_MASK) != ASCII_set)  \
 124                 {                                                             \
 125                   /* Write out the shift sequence.  */                        \
 126                   *outbuf++ = ESC;                                            \
 127                   *outbuf++ = '(';                                            \
 128                   *outbuf++ = 'B';                                            \
 129                 }                                                             \
 130               data->__statep->__count &= 7;                                   \
 131               data->__statep->__count |= ASCII_set;                           \
 132             }                                                                 \
 133         }                                                                     \
 134     }
 135
 136
 137 /* Since we might have to reset input pointer we must be able to save
 138    and retore the state.  */
 139 #define SAVE_RESET_STATE(Save) \
 140   if (Save)                                                                   \
 141     saved_state = *statep;                                                    \
 142   else                                                                        \
 143     *statep = saved_state
 144
 145
 146 /* First define the conversion function from ISO-2022-JP-3 to UCS-4.  */
 147 #define MIN_NEEDED_INPUT        FROM_LOOP_MIN_NEEDED_FROM
 148 #define MAX_NEEDED_INPUT        FROM_LOOP_MAX_NEEDED_FROM
 149 #define MIN_NEEDED_OUTPUT       FROM_LOOP_MIN_NEEDED_TO
 150 #define MAX_NEEDED_OUTPUT       FROM_LOOP_MAX_NEEDED_TO
 151 #define LOOPFCT                 FROM_LOOP
 152 #define BODY \
 153   {                                                                           \
 154     uint32_t ch = *inptr;                                                     \
 155                                                                               \
 156     /* Recognize escape sequences.  */                                        \
 157     if (__glibc_unlikely (ch == ESC))                                         \
 158       {                                                                       \
 159         /* We now must be prepared to read two to three more bytes.           \
 160            If we have a match in the first byte but then the input buffer     \
 161            ends we terminate with an error since we must not risk missing     \
 162            an escape sequence just because it is not entirely in the          \
 163            current input buffer.  */                                          \
 164         if (__builtin_expect (inptr + 2 >= inend, 0)                          \
 165             || (inptr[1] == '$' && inptr[2] == '('                            \
 166                 && __builtin_expect (inptr + 3 >= inend, 0)))                 \
 167           {                                                                   \
 168             /* Not enough input available.  */                                \
 169             result = __GCONV_INCOMPLETE_INPUT;                                \
 170             break;                                                            \
 171           }                                                                   \
 172                                                                               \
 173         if (inptr[1] == '(')                                                  \
 174           {                                                                   \
 175             if (inptr[2] == 'B')                                              \
 176               {                                                               \
 177                 /* ASCII selected.  */                                        \
 178                 set = ASCII_set;                                              \
 179                 inptr += 3;                                                   \
 180                 continue;                                                     \
 181               }                                                               \
 182             else if (inptr[2] == 'J')                                         \
 183               {                                                               \
 184                 /* JIS X 0201 selected.  */                                   \
 185                 set = JISX0201_Roman_set;                                     \
 186                 inptr += 3;                                                   \
 187                 continue;                                                     \
 188               }                                                               \
 189             else if (inptr[2] == 'I')                                         \
 190               {                                                               \
 191                 /* JIS X 0201 selected.  */                                   \
 192                 set = JISX0201_Kana_set;                                      \
 193                 inptr += 3;                                                   \
 194                 continue;                                                     \
 195               }                                                               \
 196           }                                                                   \
 197         else if (inptr[1] == '$')                                             \
 198           {                                                                   \
 199             if (inptr[2] == '@')                                              \
 200               {                                                               \
 201                 /* JIS X 0208-1978 selected.  */                              \
 202                 set = JISX0208_1978_set;                                      \
 203                 inptr += 3;                                                   \
 204                 continue;                                                     \
 205               }                                                               \
 206             else if (inptr[2] == 'B')                                         \
 207               {                                                               \
 208                 /* JIS X 0208-1983 selected.  */                              \
 209                 set = JISX0208_1983_set;                                      \
 210                 inptr += 3;                                                   \
 211                 continue;                                                     \
 212               }                                                               \
 213             else if (inptr[2] == '(')                                         \
 214               {                                                               \
 215                 if (inptr[3] == 'O' || inptr[3] == 'Q')                       \
 216                   {                                                           \
 217                     /* JIS X 0213 plane 1 selected.  */                       \
 218                     /* In this direction we don't need to distinguish the     \
 219                        versions from 2000 and 2004. */                        \
 220                     set = JISX0213_1_2004_set;                                \
 221                     inptr += 4;                                               \
 222                     continue;                                                 \
 223                   }                                                           \
 224                 else if (inptr[3] == 'P')                                     \
 225                   {                                                           \
 226                     /* JIS X 0213 plane 2 selected.  */                       \
 227                     set = JISX0213_2_set;                                     \
 228                     inptr += 4;                                               \
 229                     continue;                                                 \
 230                   }                                                           \
 231               }                                                               \
 232           }                                                                   \
 233       }                                                                       \
 234                                                                               \
 235     if (ch >= 0x80)                                                           \
 236       {                                                                       \
 237         STANDARD_FROM_LOOP_ERR_HANDLER (1);                                   \
 238       }                                                                       \
 239     else if (set == ASCII_set || (ch < 0x21 || ch == 0x7f))                   \
 240       /* Almost done, just advance the input pointer.  */                     \
 241       ++inptr;                                                                \
 242     else if (set == JISX0201_Roman_set)                                       \
 243       {                                                                       \
 244         /* Use the JIS X 0201 table.  */                                      \
 245         ch = jisx0201_to_ucs4 (ch);                                           \
 246         if (__glibc_unlikely (ch == __UNKNOWN_10646_CHAR))                    \
 247           {                                                                   \
 248             STANDARD_FROM_LOOP_ERR_HANDLER (1);                               \
 249           }                                                                   \
 250         ++inptr;                                                              \
 251       }                                                                       \
 252     else if (set == JISX0201_Kana_set)                                        \
 253       {                                                                       \
 254         /* Use the JIS X 0201 table.  */                                      \
 255         ch = jisx0201_to_ucs4 (ch + 0x80);                                    \
 256         if (__glibc_unlikely (ch == __UNKNOWN_10646_CHAR))                    \
 257           {                                                                   \
 258             STANDARD_FROM_LOOP_ERR_HANDLER (1);                               \
 259           }                                                                   \
 260         ++inptr;                                                              \
 261       }                                                                       \
 262     else if (set == JISX0208_1978_set || set == JISX0208_1983_set)            \
 263       {                                                                       \
 264         /* XXX I don't have the tables for these two old variants of          \
 265            JIS X 0208.  Therefore I'm using the tables for JIS X              \
 266            0208-1990.  If somebody has problems with this please              \
 267            provide the appropriate tables.  */                                \
 268         ch = jisx0208_to_ucs4 (&inptr, inend - inptr, 0);                     \
 269                                                                               \
 270         if (__glibc_unlikely (ch == 0))                                       \
 271           {                                                                   \
 272             result = __GCONV_INCOMPLETE_INPUT;                                \
 273             break;                                                            \
 274           }                                                                   \
 275         else if (__glibc_unlikely (ch == __UNKNOWN_10646_CHAR))               \
 276           {                                                                   \
 277             STANDARD_FROM_LOOP_ERR_HANDLER (1);                               \
 278           }                                                                   \
 279       }                                                                       \
 280     else /* (set == JISX0213_1_2004_set || set == JISX0213_2_set) */          \
 281       {                                                                       \
 282         if (__glibc_unlikely (inptr + 1 >= inend))                            \
 283           {                                                                   \
 284             result = __GCONV_INCOMPLETE_INPUT;                                \
 285             break;                                                            \
 286           }                                                                   \
 287                                                                               \
 288         ch = jisx0213_to_ucs4 (                                               \
 289                ((JISX0213_1_2004_set - set + (1 << 3)) << 5) + ch,            \
 290                inptr[1]);                                                     \
 291         if (ch == 0)                                                          \
 292           STANDARD_FROM_LOOP_ERR_HANDLER (1);                                 \
 293                                                                               \
 294         if (ch < 0x80)                                                        \
 295           {                                                                   \
 296             /* It's a combining character.  */                                \
 297             uint32_t u1 = __jisx0213_to_ucs_combining[ch - 1][0];             \
 298             uint32_t u2 = __jisx0213_to_ucs_combining[ch - 1][1];             \
 299                                                                               \
 300             /* See whether we have room for two characters.  */               \
 301             if (outptr + 8 <= outend)                                         \
 302               {                                                               \
 303                 inptr += 2;                                                   \
 304                 put32 (outptr, u1);                                           \
 305                 outptr += 4;                                                  \
 306                 put32 (outptr, u2);                                           \
 307                 outptr += 4;                                                  \
 308                 continue;                                                     \
 309               }                                                               \
 310             else                                                              \
 311               {                                                               \
 312                 result = __GCONV_FULL_OUTPUT;                                 \
 313                 break;                                                        \
 314               }                                                               \
 315           }                                                                   \
 316                                                                               \
 317         inptr += 2;                                                           \
 318       }                                                                       \
 319                                                                               \
 320     put32 (outptr, ch);                                                       \
 321     outptr += 4;                                                              \
 322   }
 323 #define LOOP_NEED_FLAGS
 324 #define EXTRA_LOOP_DECLS        , int *statep
 325 #define INIT_PARAMS             int set = *statep
 326 #define UPDATE_PARAMS           *statep = set
 327 #include <iconv/loop.c>
 328
 329
 330 /* Next, define the other direction, from UCS-4 to ISO-2022-JP-3.  */
 331
 332 /* Composition tables for each of the relevant combining characters.  */
 333 static const struct
 334 {
 335   uint16_t base;
 336   uint16_t composed;
 337 } comp_table_data[] =
 338 {
 339 #define COMP_TABLE_IDX_02E5 0
 340 #define COMP_TABLE_LEN_02E5 1
 341   { 0x2b64, 0x2b65 }, /* 0x12B65 = 0x12B64 U+02E5 */
 342 #define COMP_TABLE_IDX_02E9 (COMP_TABLE_IDX_02E5 + COMP_TABLE_LEN_02E5)
 343 #define COMP_TABLE_LEN_02E9 1
 344   { 0x2b60, 0x2b66 }, /* 0x12B66 = 0x12B60 U+02E9 */
 345 #define COMP_TABLE_IDX_0300 (COMP_TABLE_IDX_02E9 + COMP_TABLE_LEN_02E9)
 346 #define COMP_TABLE_LEN_0300 5
 347   { 0x295c, 0x2b44 }, /* 0x12B44 = 0x1295C U+0300 */
 348   { 0x2b38, 0x2b48 }, /* 0x12B48 = 0x12B38 U+0300 */
 349   { 0x2b37, 0x2b4a }, /* 0x12B4A = 0x12B37 U+0300 */
 350   { 0x2b30, 0x2b4c }, /* 0x12B4C = 0x12B30 U+0300 */
 351   { 0x2b43, 0x2b4e }, /* 0x12B4E = 0x12B43 U+0300 */
 352 #define COMP_TABLE_IDX_0301 (COMP_TABLE_IDX_0300 + COMP_TABLE_LEN_0300)
 353 #define COMP_TABLE_LEN_0301 4
 354   { 0x2b38, 0x2b49 }, /* 0x12B49 = 0x12B38 U+0301 */
 355   { 0x2b37, 0x2b4b }, /* 0x12B4B = 0x12B37 U+0301 */
 356   { 0x2b30, 0x2b4d }, /* 0x12B4D = 0x12B30 U+0301 */
 357   { 0x2b43, 0x2b4f }, /* 0x12B4F = 0x12B43 U+0301 */
 358 #define COMP_TABLE_IDX_309A (COMP_TABLE_IDX_0301 + COMP_TABLE_LEN_0301)
 359 #define COMP_TABLE_LEN_309A 14
 360   { 0x242b, 0x2477 }, /* 0x12477 = 0x1242B U+309A */
 361   { 0x242d, 0x2478 }, /* 0x12478 = 0x1242D U+309A */
 362   { 0x242f, 0x2479 }, /* 0x12479 = 0x1242F U+309A */
 363   { 0x2431, 0x247a }, /* 0x1247A = 0x12431 U+309A */
 364   { 0x2433, 0x247b }, /* 0x1247B = 0x12433 U+309A */
 365   { 0x252b, 0x2577 }, /* 0x12577 = 0x1252B U+309A */
 366   { 0x252d, 0x2578 }, /* 0x12578 = 0x1252D U+309A */
 367   { 0x252f, 0x2579 }, /* 0x12579 = 0x1252F U+309A */
 368   { 0x2531, 0x257a }, /* 0x1257A = 0x12531 U+309A */
 369   { 0x2533, 0x257b }, /* 0x1257B = 0x12533 U+309A */
 370   { 0x253b, 0x257c }, /* 0x1257C = 0x1253B U+309A */
 371   { 0x2544, 0x257d }, /* 0x1257D = 0x12544 U+309A */
 372   { 0x2548, 0x257e }, /* 0x1257E = 0x12548 U+309A */
 373   { 0x2675, 0x2678 }, /* 0x12678 = 0x12675 U+309A */
 374 };
 375
 376 #define MIN_NEEDED_INPUT        TO_LOOP_MIN_NEEDED_FROM
 377 #define MAX_NEEDED_INPUT        TO_LOOP_MAX_NEEDED_FROM
 378 #define MIN_NEEDED_OUTPUT       TO_LOOP_MIN_NEEDED_TO
 379 #define MAX_NEEDED_OUTPUT       TO_LOOP_MAX_NEEDED_TO
 380 #define LOOPFCT                 TO_LOOP
 381 #define BODY \
 382   {                                                                           \
 383     uint32_t ch = get32 (inptr);                                              \
 384                                                                               \
 385     if (lasttwo != 0)                                                         \
 386       {                                                                       \
 387         /* Attempt to combine the last character with this one.  */           \
 388         unsigned int idx;                                                     \
 389         unsigned int len;                                                     \
 390                                                                               \
 391         if (ch == 0x02e5)                                                     \
 392           idx = COMP_TABLE_IDX_02E5, len = COMP_TABLE_LEN_02E5;               \
 393         else if (ch == 0x02e9)                                                \
 394           idx = COMP_TABLE_IDX_02E9, len = COMP_TABLE_LEN_02E9;               \
 395         else if (ch == 0x0300)                                                \
 396           idx = COMP_TABLE_IDX_0300, len = COMP_TABLE_LEN_0300;               \
 397         else if (ch == 0x0301)                                                \
 398           idx = COMP_TABLE_IDX_0301, len = COMP_TABLE_LEN_0301;               \
 399         else if (ch == 0x309a)                                                \
 400           idx = COMP_TABLE_IDX_309A, len = COMP_TABLE_LEN_309A;               \
 401         else                                                                  \
 402           goto not_combining;                                                 \
 403                                                                               \
 404         do                                                                    \
 405           if (comp_table_data[idx].base == (uint16_t) lasttwo)                \
 406             break;                                                            \
 407         while (++idx, --len > 0);                                             \
 408                                                                               \
 409         if (len > 0)                                                          \
 410           {                                                                   \
 411             /* Output the combined character.  */                             \
 412             /* We know the combined character is in JISX0213 plane 1,         \
 413                but the buffered character may have been in JISX0208 or in     \
 414                JISX0213 plane 1.  */                                          \
 415             size_t need =                                                     \
 416               (lasttwo >> 16                                                  \
 417                || (set != JISX0213_1_2000_set && set != JISX0213_1_2004_set)  \
 418                ? 4 : 0);                                                      \
 419                                                                               \
 420             if (__glibc_unlikely (outptr + need + 2 > outend))                \
 421               {                                                               \
 422                 result = __GCONV_FULL_OUTPUT;                                 \
 423                 break;                                                        \
 424               }                                                               \
 425             if (need)                                                         \
 426               {                                                               \
 427                 /* But first, output the escape sequence.  */                 \
 428                 *outptr++ = ESC;                                              \
 429                 *outptr++ = '$';                                              \
 430                 *outptr++ = '(';                                              \
 431                 *outptr++ = 'O';                                              \
 432                 set = JISX0213_1_2000_set;                                    \
 433               }                                                               \
 434             lasttwo = comp_table_data[idx].composed;                          \
 435             *outptr++ = (lasttwo >> 8) & 0xff;                                \
 436             *outptr++ = lasttwo & 0xff;                                       \
 437             lasttwo = 0;                                                      \
 438             inptr += 4;                                                       \
 439             continue;                                                         \
 440           }                                                                   \
 441                                                                               \
 442       not_combining:                                                          \
 443         /* Output the buffered character.  */                                 \
 444         /* We know it is in JISX0208 or in JISX0213 plane 1.  */              \
 445         {                                                                     \
 446           size_t need = (lasttwo >> 16 ? 3 : 0);                              \
 447                                                                               \
 448           if (__glibc_unlikely (outptr + need + 2 > outend))                  \
 449             {                                                                 \
 450               result = __GCONV_FULL_OUTPUT;                                   \
 451               break;                                                          \
 452             }                                                                 \
 453           if (need)                                                           \
 454             {                                                                 \
 455               /* But first, output the escape sequence.  */                   \
 456               assert (set == JISX0208_1983_set);                              \
 457               *outptr++ = ESC;                                                \
 458               *outptr++ = '$';                                                \
 459               *outptr++ = 'B';                                                \
 460             }                                                                 \
 461           *outptr++ = (lasttwo >> 8) & 0xff;                                  \
 462           *outptr++ = lasttwo & 0xff;                                         \
 463           lasttwo = 0;                                                        \
 464           continue;                                                           \
 465         }                                                                     \
 466       }                                                                       \
 467                                                                               \
 468     /* First see whether we can write the character using the currently       \
 469        selected character set.  */                                            \
 470     if (set == ASCII_set)                                                     \
 471       {                                                                       \
 472         /* Please note that the NUL byte is *not* matched if we are not       \
 473            currently using the ASCII charset.  This is because we must        \
 474            switch to the initial state whenever a NUL byte is written.  */    \
 475         if (ch <= 0x7f)                                                       \
 476           {                                                                   \
 477             *outptr++ = ch;                                                   \
 478             inptr += 4;                                                       \
 479             continue;                                                         \
 480           }                                                                   \
 481       }                                                                       \
 482     /* ISO-2022-JP recommends to encode the newline character always in       \
 483        ASCII since this allows a context-free interpretation of the           \
 484        characters at the beginning of the next line.  Otherwise it would      \
 485        have to be known whether the last line ended using ASCII or            \
 486        JIS X 0201.  */                                                        \
 487     else if (set == JISX0201_Roman_set)                                       \
 488       {                                                                       \
 489         unsigned char buf[1];                                                 \
 490         if (ucs4_to_jisx0201 (ch, buf) != __UNKNOWN_10646_CHAR                \
 491             && buf[0] > 0x20 && buf[0] < 0x80)                                \
 492           {                                                                   \
 493             *outptr++ = buf[0];                                               \
 494             inptr += 4;                                                       \
 495             continue;                                                         \
 496           }                                                                   \
 497       }                                                                       \
 498     else if (set == JISX0201_Kana_set)                                        \
 499       {                                                                       \
 500         unsigned char buf[1];                                                 \
 501         if (ucs4_to_jisx0201 (ch, buf) != __UNKNOWN_10646_CHAR                \
 502             && buf[0] >= 0x80)                                                \
 503           {                                                                   \
 504             *outptr++ = buf[0] - 0x80;                                        \
 505             inptr += 4;                                                       \
 506             continue;                                                         \
 507           }                                                                   \
 508       }                                                                       \
 509     else if (/*set == JISX0208_1978_set || */ set == JISX0208_1983_set)       \
 510       {                                                                       \
 511         size_t written = ucs4_to_jisx0208 (ch, outptr, outend - outptr);      \
 512                                                                               \
 513         if (written != __UNKNOWN_10646_CHAR)                                  \
 514           {                                                                   \
 515             uint32_t jch = ucs4_to_jisx0213 (ch);                             \
 516                                                                               \
 517             if (jch & 0x0080)                                                 \
 518               {                                                               \
 519                 /* A possible match in comp_table_data.  Buffer it.  */       \
 520                 lasttwo = jch & 0x7f7f;                                       \
 521                 inptr += 4;                                                   \
 522                 continue;                                                     \
 523               }                                                               \
 524             if (__glibc_unlikely (written == 0))                              \
 525               {                                                               \
 526                 result = __GCONV_FULL_OUTPUT;                                 \
 527                 break;                                                        \
 528               }                                                               \
 529             else                                                              \
 530               {                                                               \
 531                 outptr += written;                                            \
 532                 inptr += 4;                                                   \
 533                 continue;                                                     \
 534              }                                                                \
 535           }                                                                   \
 536       }                                                                       \
 537     else                                                                      \
 538       {                                                                       \
 539         /* (set == JISX0213_1_2000_set || set == JISX0213_1_2004_set          \
 540             || set == JISX0213_2_set) */                                      \
 541         uint32_t jch = ucs4_to_jisx0213 (ch);                                 \
 542                                                                               \
 543         if (jch != 0                                                          \
 544             && (jch & 0x8000                                                  \
 545                 ? set == JISX0213_2_set                                       \
 546                 : (set == JISX0213_1_2004_set                                 \
 547                    || (set == JISX0213_1_2000_set                             \
 548                        && !jisx0213_added_in_2004_p (jch)))))                 \
 549           {                                                                   \
 550             if (jch & 0x0080)                                                 \
 551               {                                                               \
 552                 /* A possible match in comp_table_data.  Buffer it.  */       \
 553                                                                               \
 554                 /* We know it's a JISX 0213 plane 1 character.  */            \
 555                 assert ((jch & 0x8000) == 0);                                 \
 556                                                                               \
 557                 lasttwo = jch & 0x7f7f;                                       \
 558                 inptr += 4;                                                   \
 559                 continue;                                                     \
 560               }                                                               \
 561                                                                               \
 562             if (__glibc_unlikely (outptr + 1 >= outend))                      \
 563               {                                                               \
 564                 result = __GCONV_FULL_OUTPUT;                                 \
 565                 break;                                                        \
 566               }                                                               \
 567             *outptr++ = (jch >> 8) & 0x7f;                                    \
 568             *outptr++ = jch & 0x7f;                                           \
 569             inptr += 4;                                                       \
 570             continue;                                                         \
 571           }                                                                   \
 572       }                                                                       \
 573                                                                               \
 574     /* The attempts to use the currently selected character set failed,       \
 575        either because the character requires a different character set,       \
 576        or because the character is unknown.  */                               \
 577                                                                               \
 578     if (ch <= 0x7f)                                                           \
 579       {                                                                       \
 580         /* We must encode using ASCII.  First write out the escape            \
 581            sequence.  */                                                      \
 582         if (__glibc_unlikely (outptr + 3 > outend))                           \
 583           {                                                                   \
 584             result = __GCONV_FULL_OUTPUT;                                     \
 585             break;                                                            \
 586           }                                                                   \
 587                                                                               \
 588         *outptr++ = ESC;                                                      \
 589         *outptr++ = '(';                                                      \
 590         *outptr++ = 'B';                                                      \
 591         set = ASCII_set;                                                      \
 592                                                                               \
 593         if (__glibc_unlikely (outptr >= outend))                              \
 594           {                                                                   \
 595             result = __GCONV_FULL_OUTPUT;                                     \
 596             break;                                                            \
 597           }                                                                   \
 598         *outptr++ = ch;                                                       \
 599       }                                                                       \
 600     else                                                                      \
 601       {                                                                       \
 602         unsigned char buf[2];                                                 \
 603                                                                               \
 604         /* Try JIS X 0201 Roman.  */                                          \
 605         if (ucs4_to_jisx0201 (ch, buf) != __UNKNOWN_10646_CHAR                \
 606             && buf[0] > 0x20 && buf[0] < 0x80)                                \
 607           {                                                                   \
 608             if (set != JISX0201_Roman_set)                                    \
 609               {                                                               \
 610                 if (__glibc_unlikely (outptr + 3 > outend))                   \
 611                   {                                                           \
 612                     result = __GCONV_FULL_OUTPUT;                             \
 613                     break;                                                    \
 614                   }                                                           \
 615                 *outptr++ = ESC;                                              \
 616                 *outptr++ = '(';                                              \
 617                 *outptr++ = 'J';                                              \
 618                 set = JISX0201_Roman_set;                                     \
 619               }                                                               \
 620                                                                               \
 621             if (__glibc_unlikely (outptr >= outend))                          \
 622               {                                                               \
 623                 result = __GCONV_FULL_OUTPUT;                                 \
 624                 break;                                                        \
 625               }                                                               \
 626             *outptr++ = buf[0];                                               \
 627           }                                                                   \
 628         else                                                                  \
 629           {                                                                   \
 630             uint32_t jch = ucs4_to_jisx0213 (ch);                             \
 631                                                                               \
 632             /* Try JIS X 0208.  */                                            \
 633             size_t written = ucs4_to_jisx0208 (ch, buf, 2);                   \
 634             if (written != __UNKNOWN_10646_CHAR)                              \
 635               {                                                               \
 636                 if (jch & 0x0080)                                             \
 637                   {                                                           \
 638                     /* A possible match in comp_table_data.  Buffer it.  */   \
 639                     lasttwo = ((set != JISX0208_1983_set ? 1 : 0) << 16)      \
 640                               | (jch & 0x7f7f);                               \
 641                     set = JISX0208_1983_set;                                  \
 642                     inptr += 4;                                               \
 643                     continue;                                                 \
 644                   }                                                           \
 645                                                                               \
 646                 if (set != JISX0208_1983_set)                                 \
 647                   {                                                           \
 648                     if (__glibc_unlikely (outptr + 3 > outend))               \
 649                       {                                                       \
 650                         result = __GCONV_FULL_OUTPUT;                         \
 651                         break;                                                \
 652                       }                                                       \
 653                     *outptr++ = ESC;                                          \
 654                     *outptr++ = '$';                                          \
 655                     *outptr++ = 'B';                                          \
 656                     set = JISX0208_1983_set;                                  \
 657                   }                                                           \
 658                                                                               \
 659                 if (__glibc_unlikely (outptr + 2 > outend))                   \
 660                   {                                                           \
 661                     result = __GCONV_FULL_OUTPUT;                             \
 662                     break;                                                    \
 663                   }                                                           \
 664                 *outptr++ = buf[0];                                           \
 665                 *outptr++ = buf[1];                                           \
 666               }                                                               \
 667             else                                                              \
 668               {                                                               \
 669                 /* Try JIS X 0213.  */                                        \
 670                 if (jch != 0)                                                 \
 671                   {                                                           \
 672                     int new_set =                                             \
 673                       (jch & 0x8000                                           \
 674                        ? JISX0213_2_set                                       \
 675                        : jisx0213_added_in_2004_p (jch)                       \
 676                          ? JISX0213_1_2004_set                                \
 677                          : JISX0213_1_2000_set);                              \
 678                                                                               \
 679                     if (set != new_set)                                       \
 680                       {                                                       \
 681                         if (__glibc_unlikely (outptr + 4 > outend))           \
 682                           {                                                   \
 683                             result = __GCONV_FULL_OUTPUT;                     \
 684                             break;                                            \
 685                           }                                                   \
 686                         *outptr++ = ESC;                                      \
 687                         *outptr++ = '$';                                      \
 688                         *outptr++ = '(';                                      \
 689                         *outptr++ =                                           \
 690                           ((new_set - JISX0213_1_2000_set) >> 3) + 'O';       \
 691                         set = new_set;                                        \
 692                       }                                                       \
 693                                                                               \
 694                     if (jch & 0x0080)                                         \
 695                       {                                                       \
 696                         /* A possible match in comp_table_data.               \
 697                            Buffer it.  */                                     \
 698                                                                               \
 699                         /* We know it's a JIS X 0213 plane 1 character.  */   \
 700                         assert ((jch & 0x8000) == 0);                         \
 701                                                                               \
 702                         lasttwo = jch & 0x7f7f;                               \
 703                         inptr += 4;                                           \
 704                         continue;                                             \
 705                       }                                                       \
 706                                                                               \
 707                     if (__glibc_unlikely (outptr + 1 >= outend))              \
 708                       {                                                       \
 709                         result = __GCONV_FULL_OUTPUT;                         \
 710                         break;                                                \
 711                       }                                                       \
 712                     *outptr++ = (jch >> 8) & 0x7f;                            \
 713                     *outptr++ = jch & 0x7f;                                   \
 714                   }                                                           \
 715                 else                                                          \
 716                   {                                                           \
 717                     /* Try JIS X 0201 Katakana.  This is officially not part  \
 718                        of ISO-2022-JP-3.  Therefore we try it after all other \
 719                        attempts.  */                                          \
 720                     if (ucs4_to_jisx0201 (ch, buf) != __UNKNOWN_10646_CHAR    \
 721                         && buf[0] >= 0x80)                                    \
 722                       {                                                       \
 723                         if (set != JISX0201_Kana_set)                         \
 724                           {                                                   \
 725                             if (__builtin_expect (outptr + 3 > outend, 0))    \
 726                               {                                               \
 727                                 result = __GCONV_FULL_OUTPUT;                 \
 728                                 break;                                        \
 729                               }                                               \
 730                             *outptr++ = ESC;                                  \
 731                             *outptr++ = '(';                                  \
 732                             *outptr++ = 'I';                                  \
 733                             set = JISX0201_Kana_set;                          \
 734                           }                                                   \
 735                                                                               \
 736                         if (__glibc_unlikely (outptr >= outend))              \
 737                           {                                                   \
 738                             result = __GCONV_FULL_OUTPUT;                     \
 739                             break;                                            \
 740                           }                                                   \
 741                         *outptr++ = buf[0] - 0x80;                            \
 742                       }                                                       \
 743                     else                                                      \
 744                       {                                                       \
 745                         UNICODE_TAG_HANDLER (ch, 4);                          \
 746                                                                               \
 747                         /* Illegal character.  */                             \
 748                         STANDARD_TO_LOOP_ERR_HANDLER (4);                     \
 749                       }                                                       \
 750                   }                                                           \
 751               }                                                               \
 752           }                                                                   \
 753       }                                                                       \
 754                                                                               \
 755     /* Now that we wrote the output increment the input pointer.  */          \
 756     inptr += 4;                                                               \
 757   }
 758 #define LOOP_NEED_FLAGS
 759 #define EXTRA_LOOP_DECLS        , int *statep
 760 #define INIT_PARAMS             int set = *statep & CURRENT_SEL_MASK;         \
 761                                 uint32_t lasttwo = *statep >> 6
 762 #define REINIT_PARAMS           do                                            \
 763                                   {                                           \
 764                                     set = *statep & CURRENT_SEL_MASK;         \
 765                                     lasttwo = *statep >> 6;                   \
 766                                   }                                           \
 767                                 while (0)
 768 #define UPDATE_PARAMS           *statep = set | (lasttwo << 6)
 769 #include <iconv/loop.c>
 770
 771
 772 /* Now define the toplevel functions.  */
 773 #include <iconv/skeleton.c>