/Modules/cjkcodecs/_codecs_jp.c

http://unladen-swallow.googlecode.com/ · C · 731 lines · 595 code · 95 blank · 41 comment · 229 complexity · c9dfdf08e178f8207d9b5fcac37582d4 MD5 · raw file

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