rhodes 3.1.1 → 3.2.0.beta.1

data/platform/shared/ruby/enc/trans/gb18030.trans

@@ -2,16 +2,64 @@
 
 <%
   require "gb18030-tbl"
+  
+  def linear(code)
+    bytes = [code].pack('H8').unpack 'C4' 
+    ((bytes[0]*10+bytes[1])*126+bytes[2])*10+bytes[3]
+  end
+
+  def calculate_differences_gb_utf(table)
+    table.collect do |code|
+      code = code.dup
+      if code[0].length == 4
+        if code[1] < 0x800 # GB-18030: 2 bytes, UTF-8: 2 bytes
+          # do nothing
+        else # GB-18030: 2 bytes, UTF-8: 3 bytes
+          gb_linear2b = code[0].to_i(16)
+          diff2b = gb_linear2b - code[1] + 24055
+          code[1] = "funsio(#{diff2b})"
+        end
+      else
+        if code[1] < 0x800 # GB-18030: 4 bytes, UTF-8: 2 bytes
+          # do nothing
+        else # GB-18030: 4 bytes, UTF-8: 3 bytes
+          gb_linear4b = linear(code[0])
+          diff4b = gb_linear4b - code[1] - 0x170000
+          code[1] = "funsio(#{diff4b})"
+        end
+      end
+      code
+    end
+  end
+  
+  def calculate_differences_utf_gb(table)
+    table_rev = table.map{|a,b| [b,a]}
+    table_rev.collect do |code|
+      code = code.dup
+      if code[0] >= 0x800
+        if code[1].length == 4 #GB18030 2byte UTF-8 3byte
+          gb_linear2b = code[1].to_i(16)
+          diff2b = gb_linear2b - code[0] + 24055
+          code[1] = "funsio(#{diff2b})"
+        else # GB-18030: 4 bytes, UTF-8: 3 bytes
+          gb_linear4b = linear(code[1])
+          diff4b = gb_linear4b - code[0] - 0x170000
+          code[1] = "funsio(#{diff4b})"
+        end
+      end
+      code
+    end
+  end
 
   transcode_tbl_only "GB18030", "UTF-8", [["{00-7f}", :nomap]] +
-                                         GB18030_TO_UCS_TBL + [
+                                         calculate_differences_gb_utf(GB18030_TO_UCS_TBL) + [
                                         ["{90-e2}{30-39}{81-fe}{30-39}", :func_so],
                                         ["e3{30-31}{81-fe}{30-39}", :func_so],
                                         ["e332{81-99}{30-39}", :func_so],
                                         ["e3329a{30-35}", :func_so],   #  "E3329A35" is U+10FFFF
                                        ]
   transcode_tbl_only "UTF-8", "GB18030", [["{00-7f}", :nomap]] +
-                                         GB18030_TO_UCS_TBL.map {|a,b| [b,a] } + [
+                                        calculate_differences_utf_gb(GB18030_TO_UCS_TBL) + [
                                         ["f0{90-bf}{80-bf}{80-bf}", :func_so],
                                         ["{f1-f3}{80-bf}{80-bf}{80-bf}", :func_so],
                                         ["f4{80-8f}{80-bf}{80-bf}", :func_so]
@@ -20,6 +68,7 @@
 
 <%= transcode_generated_code %>
 
+/* GB18030 4byte, UTF-8 4byte*/
 static ssize_t
 fun_so_from_gb18030(void *statep, const unsigned char *s, size_t l, unsigned char *o, size_t osize)
 {
@@ -33,6 +82,7 @@ fun_so_from_gb18030(void *statep, const unsigned char *s, size_t l, unsigned cha
     return 4;
 }
 
+/* GB18030 4byte, UTF-8 4byte*/
 static ssize_t
 fun_so_to_gb18030(void *statep, const unsigned char *s, size_t l, unsigned char *o, size_t osize)
 {
@@ -49,6 +99,56 @@ fun_so_to_gb18030(void *statep, const unsigned char *s, size_t l, unsigned char
     return 4;
 }
 
+/* GB18030 2byte, UTF-8 3byte and GB18030 4byte, UTF-8 3byte*/
+static ssize_t
+fun_sio_from_gb18030(void *statep, const unsigned char *s, size_t l, VALUE info, unsigned char *o, size_t osize)
+{
+    unsigned int diff = (unsigned int)(info >> 8);
+    unsigned int u;    /* Unicode Scalar Value */
+    if (diff & 0x20000) { /* GB18030 4 bytes */
+        u = ((s[0]*10+s[1])*126+s[2])*10+s[3] - diff - 0x170000;
+    }
+    else { /* GB18030 2 bytes */
+        u = s[0]*256 + s[1] + 24055 - diff;
+    }
+    o[0] = 0xE0 | (u>>12);
+    o[1] = 0x80 | ((u>>6)&0x3F);
+    o[2] = 0x80 | (u&0x3F);
+    return 3;
+}
+
+/* GB18030 2byte, UTF-8 3byte and GB18030 4byte, UTF-8 3byte*/
+static ssize_t
+fun_sio_to_gb18030(void *statep, const unsigned char *s, size_t l, VALUE info, unsigned char *o, size_t osize)
+{
+    unsigned int diff = (unsigned int)(info >> 8);
+    unsigned int u;    /* Unicode Scalar Value */
+    
+    u = ((s[0]&0x0F)<<12) | ((s[1]&0x3F)<<6) | (s[2]&0x3F);
+
+    if (diff & 0x20000) { /* GB18030 4 bytes */
+        u += (diff + 0x170000);
+	u -= 1688980;
+	u += 0x2;
+        o[3] = 0x30 + u%10;
+        u /= 10;
+        u += 0x32;
+        o[2] = 0x81 + u%126;
+        u /= 126;
+        u += 0x1;
+        o[1] = 0x30 + u%10;
+        u /= 10;
+        o[0] = 0x81 + u;
+	return 4;
+    }
+    else { /* GB18030 2 bytes */
+        u += (diff - 24055);
+	o[1] = u%256;
+	o[0] = u/256;
+	return 2;
+    }
+}
+
 
 static const rb_transcoder
 rb_from_GB18030 = {
@@ -56,11 +156,11 @@ rb_from_GB18030 = {
     TRANSCODE_TABLE_INFO,
     1, /* input_unit_length */
     4, /* max_input */
-    3, /* max_output */
+    4, /* max_output */
     asciicompat_converter, /* asciicompat_type */
     0, NULL, NULL, /* state_size, state_init, state_fini */
     NULL, NULL, NULL, fun_so_from_gb18030,
-    NULL, NULL, NULL
+    NULL, NULL, NULL, fun_sio_from_gb18030
 };
 static const rb_transcoder
 rb_to_GB18030 = {
@@ -72,7 +172,7 @@ rb_to_GB18030 = {
     asciicompat_converter, /* asciicompat_type */
     0, NULL, NULL, /* state_size, state_init, state_fini */
     NULL, NULL, NULL, fun_so_to_gb18030,
-    NULL, NULL, NULL
+    NULL, NULL, NULL, fun_sio_to_gb18030
 };
 
 

data/platform/shared/ruby/enc/trans/gbk.c

@@ -1,5 +1,5 @@
 /* autogenerated. */
-/* src="transcode-tblgen.rb", len=21189, checksum=1144 */
+/* src="transcode-tblgen.rb", len=27499, checksum=52340 */
 /* src="gbk.trans", len=312, checksum=24705 */
 /* src="gbk-tbl.rb", len=413871, checksum=51914 */
 
@@ -20634,7 +20634,7 @@ gbk_word_array[45724] = {
     to_GBK_F0_offsets,
     to_GBK_F0_infos,
 
-#define to_GBK_F1 WORDINDEX2INFO(45689)
+#define to_GBK_F1toF3 WORDINDEX2INFO(45689)
     to_GBK_C6_offsets,
     to_GBK_F0_infos,
 
@@ -20643,28 +20643,28 @@ gbk_word_array[45724] = {
     to_GBK_F0_infos,
 
 #define to_GBK_infos WORDINDEX2INFO(45693)
-         NOMAP,   INVALID, to_GBK_C2, to_GBK_C3,
-     to_GBK_C4, to_GBK_C5, to_GBK_C6, to_GBK_C7,
-     to_GBK_C9, to_GBK_CB, to_GBK_CE, to_GBK_CF,
-     to_GBK_D0, to_GBK_D1, to_GBK_E0, to_GBK_E1,
-     to_GBK_E2, to_GBK_E3, to_GBK_E4, to_GBK_E5,
-     to_GBK_E6, to_GBK_E7, to_GBK_E8, to_GBK_E9,
-     to_GBK_ED, to_GBK_EF, to_GBK_F0, to_GBK_F1,
-     to_GBK_F4,
+             NOMAP,       INVALID,     to_GBK_C2,     to_GBK_C3,
+         to_GBK_C4,     to_GBK_C5,     to_GBK_C6,     to_GBK_C7,
+         to_GBK_C9,     to_GBK_CB,     to_GBK_CE,     to_GBK_CF,
+         to_GBK_D0,     to_GBK_D1,     to_GBK_E0,     to_GBK_E1,
+         to_GBK_E2,     to_GBK_E3,     to_GBK_E4,     to_GBK_E5,
+         to_GBK_E6,     to_GBK_E7,     to_GBK_E8,     to_GBK_E9,
+         to_GBK_ED,     to_GBK_EF,     to_GBK_F0, to_GBK_F1toF3,
+         to_GBK_F4,
 
 #define to_GBK WORDINDEX2INFO(45722)
     to_GBK_offsets,
     to_GBK_infos,
 
 };
-#define TRANSCODE_TABLE_INFO gbk_byte_array, 6256, gbk_word_array, 45724, sizeof(unsigned int)
+#define TRANSCODE_TABLE_INFO gbk_byte_array, 6256, gbk_word_array, 45724, ((int)sizeof(unsigned int))
 static const rb_transcoder
 rb_from_GBK = {
     "GBK", "UTF-8", from_GBK,
     TRANSCODE_TABLE_INFO,
     1, /* input_unit_length */
     2, /* max_input */
-    3, /* max_output */
+    1, /* max_output */
     asciicompat_converter, /* asciicompat_type */
     0, NULL, NULL, /* state_size, state_init, state_fini */
     NULL, NULL, NULL, NULL,
@@ -20675,7 +20675,7 @@ rb_to_GBK = {
     "UTF-8", "GBK", to_GBK,
     TRANSCODE_TABLE_INFO,
     1, /* input_unit_length */
-    3, /* max_input */
+    4, /* max_input */
     2, /* max_output */
     asciicompat_converter, /* asciicompat_type */
     0, NULL, NULL, /* state_size, state_init, state_fini */

data/platform/shared/ruby/enc/trans/iso2022.c

@@ -1,13 +1,13 @@
 /* autogenerated. */
-/* src="transcode-tblgen.rb", len=21189, checksum=1144 */
-/* src="iso2022.trans", len=6668, checksum=25414 */
+/* src="transcode-tblgen.rb", len=27499, checksum=52340 */
+/* src="iso2022.trans", len=15906, checksum=38089 */
 
 #include "transcode_data.h"
 
 
 
 static const unsigned char
-iso2022_byte_array[751] = {
+iso2022_byte_array[1245] = {
 #define iso2022jp_decoder_1B_24_offsets 0
 64, 66,
       1,  0,  1,
@@ -40,7 +40,7 @@ iso2022_byte_array[751] = {
       1,  1,  1,  1,  1,  1,  1,  1,    1,  1,  1,  1,  1,  1,  1,  1,
       1,  1,  1,  1,  1,  1,  1,  1,    1,  1,  1,  1,  1,  1,
 
-#define iso2022jp_encoder_90_A1_offsets 249
+#define iso2022jp_encoder_90_A1toFE_offsets 249
 161, 254,
       1,  1,  1,  1,  1,  1,  1,  1,    1,  1,  1,  1,  1,  1,  1,  1,
       1,  1,  1,  1,  1,  1,  1,  1,    1,  1,  1,  1,  1,  1,  1,  1,
@@ -81,9 +81,49 @@ iso2022_byte_array[751] = {
       5,  5,  5,  5,  5,  5,  5,  5,    5,  5,  5,  5,  5,  5,  5,  5,
       5,  5,  5,  5,  5,  5,  5,  5,    5,  5,  5,  5,  5,  5,  5,
 
+#define cp50221_decoder_1B_28_offsets 751
+66, 74,
+      1,  0,  0,  0,  0,  0,  0,  1,    1,
+
+#define cp50221_decoder_offsets 762
+0, 223,
+      0,  0,  0,  0,  0,  0,  0,  0,    0,  0,  0,  0,  0,  0,  1,  1,
+      0,  0,  0,  0,  0,  0,  0,  0,    0,  0,  0,  2,  0,  0,  0,  0,
+      0,  0,  0,  0,  0,  0,  0,  0,    0,  0,  0,  0,  0,  0,  0,  0,
+      0,  0,  0,  0,  0,  0,  0,  0,    0,  0,  0,  0,  0,  0,  0,  0,
+      0,  0,  0,  0,  0,  0,  0,  0,    0,  0,  0,  0,  0,  0,  0,  0,
+      0,  0,  0,  0,  0,  0,  0,  0,    0,  0,  0,  0,  0,  0,  0,  0,
+      0,  0,  0,  0,  0,  0,  0,  0,    0,  0,  0,  0,  0,  0,  0,  0,
+      0,  0,  0,  0,  0,  0,  0,  0,    0,  0,  0,  0,  0,  0,  0,  0,
+      0,  0,  0,  0,  0,  0,  0,  0,    0,  0,  0,  0,  0,  0,  0,  0,
+      0,  0,  0,  3,  3,  3,  3,  3,    3,  3,  3,  3,  3,  3,  3,  3,
+      3,  0,  0,  0,  0,  0,  0,  0,    0,  0,  0,  0,  0,  0,  0,  0,
+      0,  0,  0,  0,  0,  0,  0,  0,    0,  0,  0,  0,  0,  0,  0,  0,
+      0,  0,  0,  0,  0,  0,  0,  0,    0,  0,  0,  0,  0,  0,  0,  0,
+      0,  0,  0,  0,  0,  0,  0,  0,    0,  0,  0,  0,  0,  0,  0,  0,
+
+#define cp50221_encoder_offsets 988
+0, 254,
+      0,  0,  0,  0,  0,  0,  0,  0,    0,  0,  0,  0,  0,  0,  1,  1,
+      0,  0,  0,  0,  0,  0,  0,  0,    0,  0,  0,  1,  0,  0,  0,  0,
+      0,  0,  0,  0,  0,  0,  0,  0,    0,  0,  0,  0,  0,  0,  0,  0,
+      0,  0,  0,  0,  0,  0,  0,  0,    0,  0,  0,  0,  0,  0,  0,  0,
+      0,  0,  0,  0,  0,  0,  0,  0,    0,  0,  0,  0,  0,  0,  0,  0,
+      0,  0,  0,  0,  0,  0,  0,  0,    0,  0,  0,  0,  0,  0,  0,  0,
+      0,  0,  0,  0,  0,  0,  0,  0,    0,  0,  0,  0,  0,  0,  0,  0,
+      0,  0,  0,  0,  0,  0,  0,  0,    0,  0,  0,  0,  0,  0,  0,  0,
+      2,  2,  2,  2,  2,  2,  2,  2,    2,  2,  2,  2,  2,  2,  3,  2,
+      2,  2,  2,  2,  2,  2,  2,  2,    2,  2,  2,  2,  2,  2,  2,  2,
+      2,  3,  3,  3,  3,  3,  3,  3,    3,  3,  3,  3,  3,  3,  3,  3,
+      3,  3,  3,  3,  3,  3,  3,  3,    3,  3,  3,  3,  3,  3,  3,  3,
+      3,  3,  3,  3,  3,  3,  3,  3,    3,  3,  3,  3,  3,  3,  3,  3,
+      3,  3,  3,  3,  3,  3,  3,  3,    3,  3,  3,  3,  3,  3,  3,  3,
+      3,  3,  3,  3,  3,  3,  3,  3,    3,  3,  3,  3,  3,  3,  3,  3,
+      3,  3,  3,  3,  3,  3,  3,  3,    3,  3,  3,  3,  3,  3,  3,
+
 };
 static const unsigned int
-iso2022_word_array[50] = {
+iso2022_word_array[69] = {
 #define iso2022jp_decoder_1B_24_infos WORDINDEX2INFO(0)
      INVALID,   FUNso,
 
@@ -115,15 +155,15 @@ iso2022_word_array[50] = {
     iso2022jp_decoder_jisx0208_rest_offsets,
     iso2022jp_decoder_1B_24_infos,
 
-#define iso2022jp_encoder_90_A1 WORDINDEX2INFO(18)
-    iso2022jp_encoder_90_A1_offsets,
+#define iso2022jp_encoder_90_A1toFE WORDINDEX2INFO(18)
+    iso2022jp_encoder_90_A1toFE_offsets,
     iso2022jp_decoder_1B_24_infos,
 
 #define iso2022jp_encoder_90_infos WORDINDEX2INFO(20)
-                     INVALID, iso2022jp_encoder_90_A1,
+                         INVALID, iso2022jp_encoder_90_A1toFE,
 
 #define iso2022jp_encoder_90 WORDINDEX2INFO(22)
-    iso2022jp_encoder_90_A1_offsets,
+    iso2022jp_encoder_90_A1toFE_offsets,
     iso2022jp_encoder_90_infos,
 
 #define iso2022jp_encoder_infos WORDINDEX2INFO(24)
@@ -146,33 +186,62 @@ iso2022_word_array[50] = {
      INVALID,   UNDEF,
 
 #define eucjp_to_stateless_iso2022jp_8E WORDINDEX2INFO(36)
-    iso2022jp_encoder_90_A1_offsets,
+    iso2022jp_encoder_90_A1toFE_offsets,
     eucjp_to_stateless_iso2022jp_8E_infos,
 
 #define eucjp_to_stateless_iso2022jp_8F_infos WORDINDEX2INFO(38)
                              INVALID, eucjp_to_stateless_iso2022jp_8E,
 
 #define eucjp_to_stateless_iso2022jp_8F WORDINDEX2INFO(40)
-    iso2022jp_encoder_90_A1_offsets,
+    iso2022jp_encoder_90_A1toFE_offsets,
     eucjp_to_stateless_iso2022jp_8F_infos,
 
 #define eucjp_to_stateless_iso2022jp_infos WORDINDEX2INFO(42)
                                NOMAP,                           UNDEF,
                              INVALID, eucjp_to_stateless_iso2022jp_8E,
-     eucjp_to_stateless_iso2022jp_8F,         iso2022jp_encoder_90_A1,
+     eucjp_to_stateless_iso2022jp_8F,     iso2022jp_encoder_90_A1toFE,
 
 #define eucjp_to_stateless_iso2022jp WORDINDEX2INFO(48)
     eucjp_to_stateless_iso2022jp_offsets,
     eucjp_to_stateless_iso2022jp_infos,
 
+#define cp50221_decoder_1B_28 WORDINDEX2INFO(50)
+    cp50221_decoder_1B_28_offsets,
+    iso2022jp_decoder_1B_24_infos,
+
+#define cp50221_decoder_1B_infos WORDINDEX2INFO(52)
+                     INVALID, iso2022jp_decoder_1B_24,
+       cp50221_decoder_1B_28,
+
+#define cp50221_decoder_1B WORDINDEX2INFO(55)
+    iso2022jp_decoder_1B_offsets,
+    cp50221_decoder_1B_infos,
+
+#define cp50221_decoder_infos WORDINDEX2INFO(57)
+                  FUNsi,              FUNso,
+     cp50221_decoder_1B,            INVALID,
+
+#define cp50221_decoder WORDINDEX2INFO(61)
+    cp50221_decoder_offsets,
+    cp50221_decoder_infos,
+
+#define cp50221_encoder_infos WORDINDEX2INFO(63)
+                           FUNso,                       UNDEF,
+                         INVALID, iso2022jp_encoder_90_A1toFE,
+
+#define cp50221_encoder WORDINDEX2INFO(67)
+    cp50221_encoder_offsets,
+    cp50221_encoder_infos,
+
 };
-#define TRANSCODE_TABLE_INFO iso2022_byte_array, 751, iso2022_word_array, 50, sizeof(unsigned int)
+#define TRANSCODE_TABLE_INFO iso2022_byte_array, 1245, iso2022_word_array, 69, ((int)sizeof(unsigned int))
 
 
 #define G0_ASCII 0
 /* ignore JIS X 0201 latin */
 #define G0_JISX0208_1978 1
 #define G0_JISX0208_1983 2
+#define G0_JISX0201_KATAKANA 3
 
 #define EMACS_MULE_LEADING_CODE_JISX0208_1978   0220
 #define EMACS_MULE_LEADING_CODE_JISX0208_1983   0222
@@ -371,6 +440,294 @@ rb_eucjp_to_stateless_iso2022jp = {
     NULL, NULL, NULL, fun_so_eucjp_to_stateless_iso2022jp,
 };
 
+static VALUE
+fun_si_cp50221_decoder(void *statep, const unsigned char *s, size_t l)
+{
+    unsigned char *sp = statep;
+    int c;
+    switch (*sp) {
+      case G0_ASCII:
+        if (0xA1 <= s[0] && s[0] <= 0xDF)
+            return (VALUE)FUNso;
+        return (VALUE)NOMAP;
+      case G0_JISX0201_KATAKANA:
+        c = s[0] & 0x7F;
+        if (0x21 <= c && c <= 0x5f)
+            return (VALUE)FUNso;
+        break;
+      case G0_JISX0208_1978:
+        if ((0x21 <= s[0] && s[0] <= 0x28) || (0x30 <= s[0] && s[0] <= 0x74))
+            return (VALUE)iso2022jp_decoder_jisx0208_rest;
+        break;
+      case G0_JISX0208_1983:
+        if ((0x21 <= s[0] && s[0] <= 0x28) ||
+                s[0] == 0x2D ||
+                (0x30 <= s[0] && s[0] <= 0x74) ||
+                (0x79 <= s[0] && s[0] <= 0x7C))
+                /* 0x7F <= s[0] && s[0] <= 0x92) */
+            return (VALUE)iso2022jp_decoder_jisx0208_rest;
+        break;
+    }
+    return (VALUE)INVALID;
+}
+
+static ssize_t
+fun_so_cp50221_decoder(void *statep, const unsigned char *s, size_t l, unsigned char* o, size_t osize)
+{
+    unsigned char *sp = statep;
+    switch (s[0]) {
+      case 0x1b:
+        if (s[1] == '(') {
+            switch (s[l-1]) {
+              case 'B':
+              case 'J':
+                *sp = G0_ASCII;
+                break;
+              case 'I':
+                *sp = G0_JISX0201_KATAKANA;
+                break;
+            }
+        }
+        else {
+            switch (s[l-1]) {
+              case '@':
+                *sp = G0_JISX0208_1978;
+                break;
+              case 'B':
+                *sp = G0_JISX0208_1983;
+                break;
+            }
+        }
+        return 0;
+      case 0x0E:
+        *sp = G0_JISX0201_KATAKANA;
+        return 0;
+      case 0x0F:
+        *sp = G0_ASCII;
+        return 0;
+      default:
+        if (*sp == G0_JISX0201_KATAKANA ||
+            (0xA1 <= s[0] && s[0] <= 0xDF && *sp == G0_ASCII)) {
+            o[0] = 0x8E;
+            o[1] = s[0] | 0x80;
+        }
+        /* else if (0x7F == s[0] && s[0] <= 0x88) { */
+            /* User Defined Characters */
+            /* o[n++] = s[0] | 0xE0; */
+            /* o[n++] = s[1] | 0x80; */
+        /* else if (0x89 <= s[0] && s[0] <= 0x92) { */
+            /* User Defined Characters 2 */
+            /* o[n++] = 0x8f; */
+            /* o[n++] = s[0] + 0x6C; */
+            /* o[n++] = s[1] | 0x80; */
+        /* } */
+        else {
+            /* JIS X 0208 */
+            /* NEC Special Characters */
+            /* NEC-selected IBM extended Characters */
+            o[0] = s[0] | 0x80;
+            o[1] = s[1] | 0x80;
+        }
+        return 2;
+    }
+}
+
+static const rb_transcoder
+rb_cp50220_decoder = {
+    "CP50220", "cp51932", cp50221_decoder,
+    TRANSCODE_TABLE_INFO,
+    1, /* input_unit_length */
+    3, /* max_input */
+    3, /* max_output */
+    asciicompat_decoder, /* asciicompat_type */
+    1, iso2022jp_init, iso2022jp_init, /* state_size, state_init, state_fini */
+    NULL, fun_si_cp50221_decoder, NULL, fun_so_cp50221_decoder
+};
+
+static const rb_transcoder
+rb_cp50221_decoder = {
+    "CP50221", "cp51932", cp50221_decoder,
+    TRANSCODE_TABLE_INFO,
+    1, /* input_unit_length */
+    3, /* max_input */
+    3, /* max_output */
+    asciicompat_decoder, /* asciicompat_type */
+    1, iso2022jp_init, iso2022jp_init, /* state_size, state_init, state_fini */
+    NULL, fun_si_cp50221_decoder, NULL, fun_so_cp50221_decoder
+};
+
+static ssize_t
+fun_so_cp5022x_encoder(void *statep, const unsigned char *s, size_t l,
+        unsigned char *o, size_t osize)
+{
+    unsigned char *sp = statep;
+    unsigned char *output0 = o;
+    int newstate;
+
+    if (l == 1)
+        newstate = G0_ASCII;
+    else if (s[0] == 0x8E) {
+        s++;
+        l = 1;
+        newstate = G0_JISX0201_KATAKANA;
+    }
+    else
+        newstate = G0_JISX0208_1983;
+
+    if (*sp != newstate) {
+        if (newstate == G0_ASCII) {
+            *o++ = 0x1b;
+            *o++ = '(';
+            *o++ = 'B';
+        }
+        else if (newstate == G0_JISX0201_KATAKANA) {
+            *o++ = 0x1b;
+            *o++ = '(';
+            *o++ = 'I';
+        }
+        else {
+            *o++ = 0x1b;
+            *o++ = '$';
+            *o++ = 'B';
+        }
+        *sp = newstate;
+    }
+
+    if (l == 1) {
+        *o++ = s[0] & 0x7f;
+    }
+    else {
+        *o++ = s[0] & 0x7f;
+        *o++ = s[1] & 0x7f;
+    }
+
+    return o - output0;
+}
+
+static const rb_transcoder
+rb_cp50221_encoder = {
+    "CP51932", "CP50221", cp50221_encoder,
+    TRANSCODE_TABLE_INFO,
+    1, /* input_unit_length */
+    3, /* max_input */
+    5, /* max_output */
+    asciicompat_encoder, /* asciicompat_type */
+    1, iso2022jp_init, iso2022jp_init, /* state_size, state_init, state_fini */
+    NULL, NULL, NULL, fun_so_cp5022x_encoder,
+    finish_iso2022jp_encoder,
+    iso2022jp_encoder_reset_sequence_size, finish_iso2022jp_encoder
+};
+
+static const char *tbl0208 =
+    "\x21\x23\x21\x56\x21\x57\x21\x22\x21\x26\x25\x72\x25\x21\x25\x23" \
+    "\x25\x25\x25\x27\x25\x29\x25\x63\x25\x65\x25\x67\x25\x43\x21\x3C" \
+    "\x25\x22\x25\x24\x25\x26\x25\x28\x25\x2A\x25\x2B\x25\x2D\x25\x2F" \
+    "\x25\x31\x25\x33\x25\x35\x25\x37\x25\x39\x25\x3B\x25\x3D\x25\x3F" \
+    "\x25\x41\x25\x44\x25\x46\x25\x48\x25\x4A\x25\x4B\x25\x4C\x25\x4D" \
+    "\x25\x4E\x25\x4F\x25\x52\x25\x55\x25\x58\x25\x5B\x25\x5E\x25\x5F" \
+    "\x25\x60\x25\x61\x25\x62\x25\x64\x25\x66\x25\x68\x25\x69\x25\x6A" \
+    "\x25\x6B\x25\x6C\x25\x6D\x25\x6F\x25\x73\x21\x2B\x21\x2C";
+
+static ssize_t
+fun_so_cp50220_encoder(void *statep, const unsigned char *s, size_t l,
+                unsigned char *o, size_t osize)
+{
+    unsigned char *output0 = o;
+    unsigned char *sp = statep;
+
+    if (sp[0] == G0_JISX0201_KATAKANA) {
+        int c = sp[2] & 0x7F;
+        const char *p = tbl0208 + (c - 0x21) * 2;
+        if (sp[1] != G0_JISX0208_1983) {
+            *o++ = 0x1b;
+            *o++ = '$';
+            *o++ = 'B';
+        }
+        sp[0] = G0_JISX0208_1983;
+        *o++ = *p++;
+        if (l == 2 && s[0] == 0x8E) {
+            if (s[1] == 0xDE) {
+                *o++ = *p + 1;
+                return o - output0;
+            }
+            else if (s[1] == 0xDF && (0x4A <= c && c <= 0x4E)) {
+                *o++ = *p + 2;
+                return o - output0;
+            }
+        }
+        *o++ = *p;
+    }
+
+    if (l == 2 && s[0] == 0x8E) {
+        const char *p = tbl0208 + (s[1] - 0xA1) * 2;
+        if ((0xA1 <= s[1] && s[1] <= 0xB5) ||
+            (0xC5 <= s[1] && s[1] <= 0xC9) ||
+            (0xCF <= s[1] && s[1] <= 0xDF)) {
+            if (*sp != G0_JISX0208_1983) {
+                *o++ = 0x1b;
+                *o++ = '$';
+                *o++ = 'B';
+                *sp = G0_JISX0208_1983;
+            }
+            *o++ = *p++;
+            *o++ = *p;
+            return o - output0;
+        }
+
+        sp[2] = s[1];
+        sp[1] = sp[0];
+        sp[0] = G0_JISX0201_KATAKANA;
+        return o - output0;
+    }
+
+    o += fun_so_cp5022x_encoder(statep, s, l, o, osize);
+    return o - output0;
+}
+
+static ssize_t
+finish_cp50220_encoder(void *statep, unsigned char *o, size_t osize)
+{
+    unsigned char *sp = statep;
+    unsigned char *output0 = o;
+
+    if (*sp == G0_ASCII)
+        return 0;
+
+    if (sp[0] == G0_JISX0201_KATAKANA) {
+        int c = sp[2] & 0x7F;
+        const char *p = tbl0208 + (c - 0x21) * 2;
+        if (sp[1] != G0_JISX0208_1983) {
+            *o++ = 0x1b;
+            *o++ = '$';
+            *o++ = 'B';
+        }
+        sp[0] = G0_JISX0208_1983;
+        *o++ = *p++;
+        *o++ = *p;
+    }
+
+    *o++ = 0x1b;
+    *o++ = '(';
+    *o++ = 'B';
+    *sp = G0_ASCII;
+
+    return o - output0;
+}
+
+static const rb_transcoder
+rb_cp50220_encoder = {
+    "CP51932", "CP50220", cp50221_encoder,
+    TRANSCODE_TABLE_INFO,
+    1, /* input_unit_length */
+    3, /* max_input */
+    5, /* max_output */
+    asciicompat_encoder, /* asciicompat_type */
+    3, iso2022jp_init, iso2022jp_init, /* state_size, state_init, state_fini */
+    NULL, NULL, NULL, fun_so_cp50220_encoder,
+    finish_cp50220_encoder,
+    iso2022jp_encoder_reset_sequence_size, finish_cp50220_encoder
+};
+
 void
 Init_iso2022(void)
 {
@@ -378,6 +735,10 @@ Init_iso2022(void)
     rb_register_transcoder(&rb_iso2022jp_encoder);
     rb_register_transcoder(&rb_stateless_iso2022jp_to_eucjp);
     rb_register_transcoder(&rb_eucjp_to_stateless_iso2022jp);
+    rb_register_transcoder(&rb_cp50220_decoder);
+    rb_register_transcoder(&rb_cp50221_decoder);
+    rb_register_transcoder(&rb_cp50220_encoder);
+    rb_register_transcoder(&rb_cp50221_encoder);
 }