Debian Codegraph @

Modules/cjkcodecs/_codecs_jp.c

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