Modules/cjkcodecs/_codecs_jp.c

   1 /*
   2  * _codecs_jp.c: Codecs collection for Japanese encodings
   3  *
   4  * Written by Hye-Shik Chang <perky@FreeBSD.org>
   5  */
   6
   7 #define USING_BINARY_PAIR_SEARCH
   8 #define EMPBASE 0x20000
   9
  10 #include "cjkcodecs.h"
  11 #include "mappings_jp.h"
  12 #include "mappings_jisx0213_pair.h"
  13 #include "alg_jisx0201.h"
  14 #include "emu_jisx0213_2000.h"
  15
  16 /*
  17  * CP932 codec
  18  */
  19
  20 ENCODER(cp932)
  21 {
  22         while (inleft > 0) {
  23                 Py_UNICODE c = IN1;
  24                 DBCHAR code;
  25                 unsigned char c1, c2;
  26
  27                 if (c <= 0x80) {
  28                         WRITE1((unsigned char)c)
  29                         NEXT(1, 1)
  30                         continue;
  31                 }
  32                 else if (c >= 0xff61 && c <= 0xff9f) {
  33                         WRITE1(c - 0xfec0)
  34                         NEXT(1, 1)
  35                         continue;
  36                 }
  37                 else if (c >= 0xf8f0 && c <= 0xf8f3) {
  38                         /* Windows compatibility */
  39                         REQUIRE_OUTBUF(1)
  40                         if (c == 0xf8f0)
  41                                 OUT1(0xa0)
  42                         else
  43                                 OUT1(c - 0xfef1 + 0xfd)
  44                         NEXT(1, 1)
  45                         continue;
  46                 }
  47
  48                 UCS4INVALID(c)
  49                 REQUIRE_OUTBUF(2)
  50
  51                 TRYMAP_ENC(cp932ext, code, c) {
  52                         OUT1(code >> 8)
  53                         OUT2(code & 0xff)
  54                 }
  55                 else TRYMAP_ENC(jisxcommon, code, c) {
  56                         if (code & 0x8000) /* MSB set: JIS X 0212 */
  57                                 return 1;
  58
  59                         /* JIS X 0208 */
  60                         c1 = code >> 8;
  61                         c2 = code & 0xff;
  62                         c2 = (((c1 - 0x21) & 1) ? 0x5e : 0) + (c2 - 0x21);
  63                         c1 = (c1 - 0x21) >> 1;
  64                         OUT1(c1 < 0x1f ? c1 + 0x81 : c1 + 0xc1)
  65                         OUT2(c2 < 0x3f ? c2 + 0x40 : c2 + 0x41)
  66                 }
  67                 else if (c >= 0xe000 && c < 0xe758) {
  68                         /* User-defined area */
  69                         c1 = (Py_UNICODE)(c - 0xe000) / 188;
  70                         c2 = (Py_UNICODE)(c - 0xe000) % 188;
  71                         OUT1(c1 + 0xf0)
  72                         OUT2(c2 < 0x3f ? c2 + 0x40 : c2 + 0x41)
  73                 }
  74                 else
  75                         return 1;
  76
  77                 NEXT(1, 2)
  78         }
  79
  80         return 0;
  81 }
  82
  83 DECODER(cp932)
  84 {
  85         while (inleft > 0) {
  86                 unsigned char c = IN1, c2;
  87
  88                 REQUIRE_OUTBUF(1)
  89                 if (c <= 0x80) {
  90                         OUT1(c)
  91                         NEXT(1, 1)
  92                         continue;
  93                 }
  94                 else if (c >= 0xa0 && c <= 0xdf) {
  95                         if (c == 0xa0)
  96                                 OUT1(0xf8f0) /* half-width katakana */
  97                         else
  98                                 OUT1(0xfec0 + c)
  99                         NEXT(1, 1)
 100                         continue;
 101                 }
 102                 else if (c >= 0xfd/* && c <= 0xff*/) {
 103                         /* Windows compatibility */
 104                         OUT1(0xf8f1 - 0xfd + c)
 105                         NEXT(1, 1)
 106                         continue;
 107                 }
 108
 109                 REQUIRE_INBUF(2)
 110                 c2 = IN2;
 111
 112                 TRYMAP_DEC(cp932ext, **outbuf, c, c2);
 113                 else if ((c >= 0x81 && c <= 0x9f) || (c >= 0xe0 && c <= 0xea)){
 114                         if (c2 < 0x40 || (c2 > 0x7e && c2 < 0x80) || c2 > 0xfc)
 115                                 return 2;
 116
 117                         c = (c < 0xe0 ? c - 0x81 : c - 0xc1);
 118                         c2 = (c2 < 0x80 ? c2 - 0x40 : c2 - 0x41);
 119                         c = (2 * c + (c2 < 0x5e ? 0 : 1) + 0x21);
 120                         c2 = (c2 < 0x5e ? c2 : c2 - 0x5e) + 0x21;
 121
 122                         TRYMAP_DEC(jisx0208, **outbuf, c, c2);
 123                         else return 2;
 124                 }
 125                 else if (c >= 0xf0 && c <= 0xf9) {
 126                         if ((c2 >= 0x40 && c2 <= 0x7e) ||
 127                             (c2 >= 0x80 && c2 <= 0xfc))
 128                                 OUT1(0xe000 + 188 * (c - 0xf0) +
 129                                      (c2 < 0x80 ? c2 - 0x40 : c2 - 0x41))
 130                         else
 131                                 return 2;
 132                 }
 133                 else
 134                         return 2;
 135
 136                 NEXT(2, 1)
 137         }
 138
 139         return 0;
 140 }
 141
 142
 143 /*
 144  * EUC-JIS-2004 codec
 145  */
 146
 147 ENCODER(euc_jis_2004)
 148 {
 149         while (inleft > 0) {
 150                 ucs4_t c = IN1;
 151                 DBCHAR code;
 152                 Py_ssize_t insize;
 153
 154                 if (c < 0x80) {
 155                         WRITE1(c)
 156                         NEXT(1, 1)
 157                         continue;
 158                 }
 159
 160                 DECODE_SURROGATE(c)
 161                 insize = GET_INSIZE(c);
 162
 163                 if (c <= 0xFFFF) {
 164                         EMULATE_JISX0213_2000_ENCODE_BMP(code, c)
 165                         else TRYMAP_ENC(jisx0213_bmp, code, c) {
 166                                 if (code == MULTIC) {
 167                                         if (inleft < 2) {
 168                                                 if (flags & MBENC_FLUSH) {
 169                                                         code = find_pairencmap(
 170                                                             (ucs2_t)c, 0,
 171                                                           jisx0213_pair_encmap,
 172                                                             JISX0213_ENCPAIRS);
 173                                                         if (code == DBCINV)
 174                                                                 return 1;
 175                                                 }
 176                                                 else
 177                                                         return MBERR_TOOFEW;
 178                                         }
 179                                         else {
 180                                                 code = find_pairencmap(
 181                                                         (ucs2_t)c, (*inbuf)[1],
 182                                                         jisx0213_pair_encmap,
 183                                                         JISX0213_ENCPAIRS);
 184                                                 if (code == DBCINV) {
 185                                                         code = find_pairencmap(
 186                                                             (ucs2_t)c, 0,
 187                                                           jisx0213_pair_encmap,
 188                                                             JISX0213_ENCPAIRS);
 189                                                         if (code == DBCINV)
 190                                                                 return 1;
 191                                                 } else
 192                                                         insize = 2;
 193                                         }
 194                                 }
 195                         }
 196                         else TRYMAP_ENC(jisxcommon, code, c);
 197                         else if (c >= 0xff61 && c <= 0xff9f) {
 198                                 /* JIS X 0201 half-width katakana */
 199                                 WRITE2(0x8e, c - 0xfec0)
 200                                 NEXT(1, 2)
 201                                 continue;
 202                         }
 203                         else if (c == 0xff3c)
 204                                 /* F/W REVERSE SOLIDUS (see NOTES) */
 205                                 code = 0x2140;
 206                         else if (c == 0xff5e)
 207                                 /* F/W TILDE (see NOTES) */
 208                                 code = 0x2232;
 209                         else
 210                                 return 1;
 211                 }
 212                 else if (c >> 16 == EMPBASE >> 16) {
 213                         EMULATE_JISX0213_2000_ENCODE_EMP(code, c)
 214                         else TRYMAP_ENC(jisx0213_emp, code, c & 0xffff);
 215                         else return insize;
 216                 }
 217                 else
 218                         return insize;
 219
 220                 if (code & 0x8000) {
 221                         /* Codeset 2 */
 222                         WRITE3(0x8f, code >> 8, (code & 0xFF) | 0x80)
 223                         NEXT(insize, 3)
 224                 } else {
 225                         /* Codeset 1 */
 226                         WRITE2((code >> 8) | 0x80, (code & 0xFF) | 0x80)
 227                         NEXT(insize, 2)
 228                 }
 229         }
 230
 231         return 0;
 232 }
 233
 234 DECODER(euc_jis_2004)
 235 {
 236         while (inleft > 0) {
 237                 unsigned char c = IN1;
 238                 ucs4_t code;
 239
 240                 REQUIRE_OUTBUF(1)
 241
 242                 if (c < 0x80) {
 243                         OUT1(c)
 244                         NEXT(1, 1)
 245                         continue;
 246                 }
 247
 248                 if (c == 0x8e) {
 249                         /* JIS X 0201 half-width katakana */
 250                         unsigned char c2;
 251
 252                         REQUIRE_INBUF(2)
 253                         c2 = IN2;
 254                         if (c2 >= 0xa1 && c2 <= 0xdf) {
 255                                 OUT1(0xfec0 + c2)
 256                                 NEXT(2, 1)
 257                         }
 258                         else
 259                                 return 2;
 260                 }
 261                 else if (c == 0x8f) {
 262                         unsigned char c2, c3;
 263
 264                         REQUIRE_INBUF(3)
 265                         c2 = IN2 ^ 0x80;
 266                         c3 = IN3 ^ 0x80;
 267
 268                         /* JIS X 0213 Plane 2 or JIS X 0212 (see NOTES) */
 269                         EMULATE_JISX0213_2000_DECODE_PLANE2(**outbuf, c2, c3)
 270                         else TRYMAP_DEC(jisx0213_2_bmp, **outbuf, c2, c3) ;
 271                         else TRYMAP_DEC(jisx0213_2_emp, code, c2, c3) {
 272                                 WRITEUCS4(EMPBASE | code)
 273                                 NEXT_IN(3)
 274                                 continue;
 275                         }
 276                         else TRYMAP_DEC(jisx0212, **outbuf, c2, c3) ;
 277                         else return 3;
 278                         NEXT(3, 1)
 279                 }
 280                 else {
 281                         unsigned char c2;
 282
 283                         REQUIRE_INBUF(2)
 284                         c ^= 0x80;
 285                         c2 = IN2 ^ 0x80;
 286
 287                         /* JIS X 0213 Plane 1 */
 288                         EMULATE_JISX0213_2000_DECODE_PLANE1(**outbuf, c, c2)
 289                         else if (c == 0x21 && c2 == 0x40) **outbuf = 0xff3c;
 290                         else if (c == 0x22 && c2 == 0x32) **outbuf = 0xff5e;
 291                         else TRYMAP_DEC(jisx0208, **outbuf, c, c2);
 292                         else TRYMAP_DEC(jisx0213_1_bmp, **outbuf, c, c2);
 293                         else TRYMAP_DEC(jisx0213_1_emp, code, c, c2) {
 294                                 WRITEUCS4(EMPBASE | code)
 295                                 NEXT_IN(2)
 296                                 continue;
 297                         }
 298                         else TRYMAP_DEC(jisx0213_pair, code, c, c2) {
 299                                 WRITE2(code >> 16, code & 0xffff)
 300                                 NEXT(2, 2)
 301                                 continue;
 302                         }
 303                         else return 2;
 304                         NEXT(2, 1)
 305                 }
 306         }
 307
 308         return 0;
 309 }
 310
 311
 312 /*
 313  * EUC-JP codec
 314  */
 315
 316 ENCODER(euc_jp)
 317 {
 318         while (inleft > 0) {
 319                 Py_UNICODE c = IN1;
 320                 DBCHAR code;
 321
 322                 if (c < 0x80) {
 323                         WRITE1((unsigned char)c)
 324                         NEXT(1, 1)
 325                         continue;
 326                 }
 327
 328                 UCS4INVALID(c)
 329
 330                 TRYMAP_ENC(jisxcommon, code, c);
 331                 else if (c >= 0xff61 && c <= 0xff9f) {
 332                         /* JIS X 0201 half-width katakana */
 333                         WRITE2(0x8e, c - 0xfec0)
 334                         NEXT(1, 2)
 335                         continue;
 336                 }
 337 #ifndef STRICT_BUILD
 338                 else if (c == 0xff3c) /* FULL-WIDTH REVERSE SOLIDUS */
 339                         code = 0x2140;
 340                 else if (c == 0xa5) { /* YEN SIGN */
 341                         WRITE1(0x5c);
 342                         NEXT(1, 1)
 343                         continue;
 344                 } else if (c == 0x203e) { /* OVERLINE */
 345                         WRITE1(0x7e);
 346                         NEXT(1, 1)
 347                         continue;
 348                 }
 349 #endif
 350                 else
 351                         return 1;
 352
 353                 if (code & 0x8000) {
 354                         /* JIS X 0212 */
 355                         WRITE3(0x8f, code >> 8, (code & 0xFF) | 0x80)
 356                         NEXT(1, 3)
 357                 } else {
 358                         /* JIS X 0208 */
 359                         WRITE2((code >> 8) | 0x80, (code & 0xFF) | 0x80)
 360                         NEXT(1, 2)
 361                 }
 362         }
 363
 364         return 0;
 365 }
 366
 367 DECODER(euc_jp)
 368 {
 369         while (inleft > 0) {
 370                 unsigned char c = IN1;
 371
 372                 REQUIRE_OUTBUF(1)
 373
 374                         if (c < 0x80) {
 375                                 OUT1(c)
 376                                 NEXT(1, 1)
 377                                 continue;
 378                         }
 379
 380                 if (c == 0x8e) {
 381                         /* JIS X 0201 half-width katakana */
 382                         unsigned char c2;
 383
 384                         REQUIRE_INBUF(2)
 385                         c2 = IN2;
 386                         if (c2 >= 0xa1 && c2 <= 0xdf) {
 387                                 OUT1(0xfec0 + c2)
 388                                 NEXT(2, 1)
 389                         }
 390                         else
 391                                 return 2;
 392                 }
 393                 else if (c == 0x8f) {
 394                         unsigned char c2, c3;
 395
 396                         REQUIRE_INBUF(3)
 397                         c2 = IN2;
 398                         c3 = IN3;
 399                         /* JIS X 0212 */
 400                         TRYMAP_DEC(jisx0212, **outbuf, c2 ^ 0x80, c3 ^ 0x80) {
 401                                 NEXT(3, 1)
 402                         }
 403                         else
 404                                 return 3;
 405                 }
 406                 else {
 407                         unsigned char c2;
 408
 409                         REQUIRE_INBUF(2)
 410                         c2 = IN2;
 411                         /* JIS X 0208 */
 412 #ifndef STRICT_BUILD
 413                         if (c == 0xa1 && c2 == 0xc0)
 414                                 /* FULL-WIDTH REVERSE SOLIDUS */
 415                                 **outbuf = 0xff3c;
 416                         else
 417 #endif
 418                                 TRYMAP_DEC(jisx0208, **outbuf,
 419                                            c ^ 0x80, c2 ^ 0x80) ;
 420                         else return 2;
 421                         NEXT(2, 1)
 422                 }
 423         }
 424
 425         return 0;
 426 }
 427
 428
 429 /*
 430  * SHIFT_JIS codec
 431  */
 432
 433 ENCODER(shift_jis)
 434 {
 435         while (inleft > 0) {
 436                 Py_UNICODE c = IN1;
 437                 DBCHAR code;
 438                 unsigned char c1, c2;
 439
 440 #ifdef STRICT_BUILD
 441                 JISX0201_R_ENCODE(c, code)
 442 #else
 443                 if (c < 0x80) code = c;
 444                 else if (c == 0x00a5) code = 0x5c; /* YEN SIGN */
 445                 else if (c == 0x203e) code = 0x7e; /* OVERLINE */
 446 #endif
 447                 else JISX0201_K_ENCODE(c, code)
 448                 else UCS4INVALID(c)
 449                 else code = NOCHAR;
 450
 451                 if (code < 0x80 || (code >= 0xa1 && code <= 0xdf)) {
 452                         REQUIRE_OUTBUF(1)
 453
 454                         OUT1((unsigned char)code)
 455                         NEXT(1, 1)
 456                         continue;
 457                 }
 458
 459                 REQUIRE_OUTBUF(2)
 460
 461                 if (code == NOCHAR) {
 462                         TRYMAP_ENC(jisxcommon, code, c);
 463 #ifndef STRICT_BUILD
 464                         else if (c == 0xff3c)
 465                                 code = 0x2140; /* FULL-WIDTH REVERSE SOLIDUS */
 466 #endif
 467                         else
 468                                 return 1;
 469
 470                         if (code & 0x8000) /* MSB set: JIS X 0212 */
 471                                 return 1;
 472                 }
 473
 474                 c1 = code >> 8;
 475                 c2 = code & 0xff;
 476                 c2 = (((c1 - 0x21) & 1) ? 0x5e : 0) + (c2 - 0x21);
 477                 c1 = (c1 - 0x21) >> 1;
 478                 OUT1(c1 < 0x1f ? c1 + 0x81 : c1 + 0xc1)
 479                 OUT2(c2 < 0x3f ? c2 + 0x40 : c2 + 0x41)
 480                 NEXT(1, 2)
 481         }
 482
 483         return 0;
 484 }
 485
 486 DECODER(shift_jis)
 487 {
 488         while (inleft > 0) {
 489                 unsigned char c = IN1;
 490
 491                 REQUIRE_OUTBUF(1)
 492
 493 #ifdef STRICT_BUILD
 494                 JISX0201_R_DECODE(c, **outbuf)
 495 #else
 496                 if (c < 0x80) **outbuf = c;
 497 #endif
 498                 else JISX0201_K_DECODE(c, **outbuf)
 499                 else if ((c >= 0x81 && c <= 0x9f) || (c >= 0xe0 && c <= 0xea)){
 500                         unsigned char c1, c2;
 501
 502                         REQUIRE_INBUF(2)
 503                         c2 = IN2;
 504                         if (c2 < 0x40 || (c2 > 0x7e && c2 < 0x80) || c2 > 0xfc)
 505                                 return 2;
 506
 507                         c1 = (c < 0xe0 ? c - 0x81 : c - 0xc1);
 508                         c2 = (c2 < 0x80 ? c2 - 0x40 : c2 - 0x41);
 509                         c1 = (2 * c1 + (c2 < 0x5e ? 0 : 1) + 0x21);
 510                         c2 = (c2 < 0x5e ? c2 : c2 - 0x5e) + 0x21;
 511
 512 #ifndef STRICT_BUILD
 513                         if (c1 == 0x21 && c2 == 0x40) {
 514                                 /* FULL-WIDTH REVERSE SOLIDUS */
 515                                 OUT1(0xff3c)
 516                                 NEXT(2, 1)
 517                                 continue;
 518                         }
 519 #endif
 520                         TRYMAP_DEC(jisx0208, **outbuf, c1, c2) {
 521                                 NEXT(2, 1)
 522                                 continue;
 523                         }
 524                         else
 525                                 return 2;
 526                 }
 527                 else
 528                         return 2;
 529
 530                 NEXT(1, 1) /* JIS X 0201 */
 531         }
 532
 533         return 0;
 534 }
 535
 536
 537 /*
 538  * SHIFT_JIS-2004 codec
 539  */
 540
 541 ENCODER(shift_jis_2004)
 542 {
 543         while (inleft > 0) {
 544                 ucs4_t c = IN1;
 545                 DBCHAR code = NOCHAR;
 546                 int c1, c2;
 547                 Py_ssize_t insize;
 548
 549                 JISX0201_ENCODE(c, code)
 550                 else DECODE_SURROGATE(c)
 551
 552                 if (code < 0x80 || (code >= 0xa1 && code <= 0xdf)) {
 553                         WRITE1((unsigned char)code)
 554                         NEXT(1, 1)
 555                         continue;
 556                 }
 557
 558                 REQUIRE_OUTBUF(2)
 559                 insize = GET_INSIZE(c);
 560
 561                 if (code == NOCHAR) {
 562                         if (c <= 0xffff) {
 563                                 EMULATE_JISX0213_2000_ENCODE_BMP(code, c)
 564                                 else TRYMAP_ENC(jisx0213_bmp, code, c) {
 565                                         if (code == MULTIC) {
 566                                                 if (inleft < 2) {
 567                                                     if (flags & MBENC_FLUSH) {
 568                                                         code = find_pairencmap
 569                                                             ((ucs2_t)c, 0,
 570                                                           jisx0213_pair_encmap,
 571                                                             JISX0213_ENCPAIRS);
 572                                                         if (code == DBCINV)
 573                                                             return 1;
 574                                                     }
 575                                                     else
 576                                                             return MBERR_TOOFEW;
 577                                                 }
 578                                                 else {
 579                                                     code = find_pairencmap(
 580                                                             (ucs2_t)c, IN2,
 581                                                           jisx0213_pair_encmap,
 582                                                             JISX0213_ENCPAIRS);
 583                                                     if (code == DBCINV) {
 584                                                         code = find_pairencmap(
 585                                                             (ucs2_t)c, 0,
 586                                                           jisx0213_pair_encmap,
 587                                                             JISX0213_ENCPAIRS);
 588                                                         if (code == DBCINV)
 589                                                             return 1;
 590                                                         }
 591                                                         else
 592                                                             insize = 2;
 593                                                 }
 594                                         }
 595                                 }
 596                                 else TRYMAP_ENC(jisxcommon, code, c) {
 597                                         /* abandon JIS X 0212 codes */
 598                                         if (code & 0x8000)
 599                                                 return 1;
 600                                 }
 601                                 else return 1;
 602                         }
 603                         else if (c >> 16 == EMPBASE >> 16) {
 604                                 EMULATE_JISX0213_2000_ENCODE_EMP(code, c)
 605                                 else TRYMAP_ENC(jisx0213_emp, code, c&0xffff);
 606                                 else return insize;
 607                         }
 608                         else
 609                                 return insize;
 610                 }
 611
 612                 c1 = code >> 8;
 613                 c2 = (code & 0xff) - 0x21;
 614
 615                 if (c1 & 0x80) { /* Plane 2 */
 616                         if (c1 >= 0xee) c1 -= 0x87;
 617                         else if (c1 >= 0xac || c1 == 0xa8) c1 -= 0x49;
 618                         else c1 -= 0x43;
 619                 }
 620                 else /* Plane 1 */
 621                         c1 -= 0x21;
 622
 623                 if (c1 & 1) c2 += 0x5e;
 624                 c1 >>= 1;
 625                 OUT1(c1 + (c1 < 0x1f ? 0x81 : 0xc1))
 626                 OUT2(c2 + (c2 < 0x3f ? 0x40 : 0x41))
 627
 628                 NEXT(insize, 2)
 629         }
 630
 631         return 0;
 632 }
 633
 634 DECODER(shift_jis_2004)
 635 {
 636         while (inleft > 0) {
 637                 unsigned char c = IN1;
 638
 639                 REQUIRE_OUTBUF(1)
 640                 JISX0201_DECODE(c, **outbuf)
 641                 else if ((c >= 0x81 && c <= 0x9f) || (c >= 0xe0 && c <= 0xfc)){
 642                         unsigned char c1, c2;
 643                         ucs4_t code;
 644
 645                         REQUIRE_INBUF(2)
 646                         c2 = IN2;
 647                         if (c2 < 0x40 || (c2 > 0x7e && c2 < 0x80) || c2 > 0xfc)
 648                                 return 2;
 649
 650                         c1 = (c < 0xe0 ? c - 0x81 : c - 0xc1);
 651                         c2 = (c2 < 0x80 ? c2 - 0x40 : c2 - 0x41);
 652                         c1 = (2 * c1 + (c2 < 0x5e ? 0 : 1));
 653                         c2 = (c2 < 0x5e ? c2 : c2 - 0x5e) + 0x21;
 654
 655                         if (c1 < 0x5e) { /* Plane 1 */
 656                                 c1 += 0x21;
 657                                 EMULATE_JISX0213_2000_DECODE_PLANE1(**outbuf,
 658                                                 c1, c2)
 659                                 else TRYMAP_DEC(jisx0208, **outbuf, c1, c2) {
 660                                         NEXT_OUT(1)
 661                                 }
 662                                 else TRYMAP_DEC(jisx0213_1_bmp, **outbuf,
 663                                                 c1, c2) {
 664                                         NEXT_OUT(1)
 665                                 }
 666                                 else TRYMAP_DEC(jisx0213_1_emp, code, c1, c2) {
 667                                         WRITEUCS4(EMPBASE | code)
 668                                 }
 669                                 else TRYMAP_DEC(jisx0213_pair, code, c1, c2) {
 670                                         WRITE2(code >> 16, code & 0xffff)
 671                                         NEXT_OUT(2)
 672                                 }
 673                                 else
 674                                         return 2;
 675                                 NEXT_IN(2)
 676                         }
 677                         else { /* Plane 2 */
 678                                 if (c1 >= 0x67) c1 += 0x07;
 679                                 else if (c1 >= 0x63 || c1 == 0x5f) c1 -= 0x37;
 680                                 else c1 -= 0x3d;
 681
 682                                 EMULATE_JISX0213_2000_DECODE_PLANE2(**outbuf,
 683                                                 c1, c2)
 684                                 else TRYMAP_DEC(jisx0213_2_bmp, **outbuf,
 685                                                 c1, c2) ;
 686                                 else TRYMAP_DEC(jisx0213_2_emp, code, c1, c2) {
 687                                         WRITEUCS4(EMPBASE | code)
 688                                         NEXT_IN(2)
 689                                         continue;
 690                                 }
 691                                 else
 692                                         return 2;
 693                                 NEXT(2, 1)
 694                         }
 695                         continue;
 696                 }
 697                 else
 698                         return 2;
 699
 700                 NEXT(1, 1) /* JIS X 0201 */
 701         }
 702
 703         return 0;
 704 }
 705
 706
 707 BEGIN_MAPPINGS_LIST
 708   MAPPING_DECONLY(jisx0208)
 709   MAPPING_DECONLY(jisx0212)
 710   MAPPING_ENCONLY(jisxcommon)
 711   MAPPING_DECONLY(jisx0213_1_bmp)
 712   MAPPING_DECONLY(jisx0213_2_bmp)
 713   MAPPING_ENCONLY(jisx0213_bmp)
 714   MAPPING_DECONLY(jisx0213_1_emp)
 715   MAPPING_DECONLY(jisx0213_2_emp)
 716   MAPPING_ENCONLY(jisx0213_emp)
 717   MAPPING_ENCDEC(jisx0213_pair)
 718   MAPPING_ENCDEC(cp932ext)
 719 END_MAPPINGS_LIST
 720
 721 BEGIN_CODECS_LIST
 722   CODEC_STATELESS(shift_jis)
 723   CODEC_STATELESS(cp932)
 724   CODEC_STATELESS(euc_jp)
 725   CODEC_STATELESS(shift_jis_2004)
 726   CODEC_STATELESS(euc_jis_2004)
 727   { "euc_jisx0213", (void *)2000, NULL, _STATELESS_METHODS(euc_jis_2004) },
 728   { "shift_jisx0213", (void *)2000, NULL, _STATELESS_METHODS(shift_jis_2004) },
 729 END_CODECS_LIST
 730
 731 I_AM_A_MODULE_FOR(jp)