add tag v1_9_3_426

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/tags/v1_9_3_426@40733 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

1 files changed, 568 insertions, 0 deletions

diff --git a/ruby_1_9_3/enc/trans/iso2022.trans b/ruby_1_9_3/enc/trans/iso2022.trans
new file mode 100644
index 0000000000..3f40cce3c8
--- /dev/null
+++ b/ruby_1_9_3/enc/trans/iso2022.trans
@@ -0,0 +1,568 @@
+#include "transcode_data.h"
+
+<%
+  map = {
+    "1b2842" => :func_so,       # designate US-ASCII to G0.             "ESC ( B"
+    "1b284a" => :func_so,       # designate JIS X 0201 latin to G0.     "ESC ( J"
+    "1b2440" => :func_so,       # designate JIS X 0208 1978 to G0.      "ESC $ @"
+    "1b2442" => :func_so,       # designate JIS X 0208 1983 to G0.      "ESC $ B"
+    "{00-0d,10-1a,1c-7f}" => :func_si,
+  }
+  transcode_generate_node(ActionMap.parse(map), "iso2022jp_decoder")
+
+  map_jisx0208_rest = {
+    "{21-7e}" => :func_so
+  }
+  transcode_generate_node(ActionMap.parse(map_jisx0208_rest), "iso2022jp_decoder_jisx0208_rest")
+
+  map = {
+    "{00-0d,10-1a,1c-7f}" => :func_so,
+    "90{a1-fe}{a1-fe}" => :func_so,
+    "92{a1-fe}{a1-fe}" => :func_so,
+  }
+  transcode_generate_node(ActionMap.parse(map), "iso2022jp_encoder")
+
+  map = {
+    "{00-0d,10-1a,1c-7f}" => :nomap,
+    "90{a1-fe}{a1-fe}" => :func_so,
+    "92{a1-fe}{a1-fe}" => :func_so,
+  }
+  transcode_generate_node(ActionMap.parse(map), "stateless_iso2022jp_to_eucjp")
+
+  map = {
+    "{0e,0f,1b}" => :undef,
+    "{00-0d,10-1a,1c-7f}" => :nomap,
+    "{a1-fe}{a1-fe}" => :func_so,
+    "8e{a1-fe}" => :undef,
+    "8f{a1-fe}{a1-fe}" => :undef,
+  }
+  transcode_generate_node(ActionMap.parse(map), "eucjp_to_stateless_iso2022jp")
+
+  map = {
+    "1b2842" => :func_so,       # designate US-ASCII to G0.             "ESC ( B"
+    "1b2849" => :func_so,       # designate JIS X 0201 katakana to G0.  "ESC ( I"
+    "1b284a" => :func_so,       # designate JIS X 0201 latin to G0.     "ESC ( J"
+    "1b2440" => :func_so,       # designate JIS X 0208 1978 to G0.      "ESC $ @"
+    "1b2442" => :func_so,       # designate JIS X 0208 1983 to G0.      "ESC $ B"
+    "0e"     => :func_so,       # designate JIS X 0201 katakana to G0.  "SO"
+    "0f"     => :func_so,       # designate US-ASCII to G0.             "SI"
+    "{00-0d,10-1a,1c-92,a1-df}" => :func_si,
+  }
+  transcode_generate_node(ActionMap.parse(map), "cp50221_decoder")
+
+  map = {
+    "{0e,0f,1b}" => :undef,
+    "{00-0d,10-1a,1c-7f}" => :func_so,
+    "{a1-fe}{a1-fe}" => :func_so,
+    "8e{a1-fe}" => :func_so,
+  }
+  transcode_generate_node(ActionMap.parse(map), "cp50221_encoder")
+
+%>
+
+<%= transcode_generated_code %>
+
+#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
+
+static int
+iso2022jp_init(void *statep)
+{
+    unsigned char *sp = statep;
+    *sp = G0_ASCII;
+    return 0;
+}
+
+static VALUE
+fun_si_iso2022jp_decoder(void *statep, const unsigned char *s, size_t l)
+{
+    unsigned char *sp = statep;
+    if (*sp == G0_ASCII)
+        return (VALUE)NOMAP;
+    else if (0x21 <= s[0] && s[0] <= 0x7e)
+        return (VALUE)iso2022jp_decoder_jisx0208_rest;
+    else
+        return (VALUE)INVALID;
+}
+
+static ssize_t
+fun_so_iso2022jp_decoder(void *statep, const unsigned char *s, size_t l, unsigned char* o, size_t osize)
+{
+    unsigned char *sp = statep;
+    if (s[0] == 0x1b) {
+        if (s[1] == '(') {
+            switch (s[l-1]) {
+              case 'B':
+              case 'J':
+                *sp = G0_ASCII;
+                break;
+            }
+        }
+        else {
+            switch (s[l-1]) {
+              case '@':
+                *sp = G0_JISX0208_1978;
+                break;
+
+              case 'B':
+                *sp = G0_JISX0208_1983;
+                break;
+            }
+        }
+        return 0;
+    }
+    else {
+        if (*sp == G0_JISX0208_1978)
+            o[0] = EMACS_MULE_LEADING_CODE_JISX0208_1978;
+        else
+            o[0] = EMACS_MULE_LEADING_CODE_JISX0208_1983;
+        o[1] = s[0] | 0x80;
+        o[2] = s[1] | 0x80;
+        return 3;
+    }
+}
+
+static const rb_transcoder
+rb_iso2022jp_decoder = {
+    "ISO-2022-JP", "stateless-ISO-2022-JP", iso2022jp_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_iso2022jp_decoder, NULL, fun_so_iso2022jp_decoder
+};
+
+static ssize_t
+fun_so_iso2022jp_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] == EMACS_MULE_LEADING_CODE_JISX0208_1978)
+        newstate = G0_JISX0208_1978;
+    else
+        newstate = G0_JISX0208_1983;
+
+    if (*sp != newstate) {
+        if (newstate == G0_ASCII) {
+            *o++ = 0x1b;
+            *o++ = '(';
+            *o++ = 'B';
+        }
+        else if (newstate == G0_JISX0208_1978) {
+            *o++ = 0x1b;
+            *o++ = '$';
+            *o++ = '@';
+        }
+        else {
+            *o++ = 0x1b;
+            *o++ = '$';
+            *o++ = 'B';
+        }
+        *sp = newstate;
+    }
+
+    if (l == 1) {
+        *o++ = s[0] & 0x7f;
+    }
+    else {
+        *o++ = s[1] & 0x7f;
+        *o++ = s[2] & 0x7f;
+    }
+
+    return o - output0;
+}
+
+static ssize_t
+iso2022jp_encoder_reset_sequence_size(void *statep)
+{
+    unsigned char *sp = statep;
+    if (*sp != G0_ASCII)
+        return 3;
+    return 0;
+}
+
+static ssize_t
+finish_iso2022jp_encoder(void *statep, unsigned char *o, size_t osize)
+{
+    unsigned char *sp = statep;
+    unsigned char *output0 = o;
+
+    if (*sp == G0_ASCII)
+        return 0;
+
+    *o++ = 0x1b;
+    *o++ = '(';
+    *o++ = 'B';
+    *sp = G0_ASCII;
+
+    return o - output0;
+}
+
+static const rb_transcoder
+rb_iso2022jp_encoder = {
+    "stateless-ISO-2022-JP", "ISO-2022-JP", iso2022jp_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_iso2022jp_encoder,
+    finish_iso2022jp_encoder,
+    iso2022jp_encoder_reset_sequence_size, finish_iso2022jp_encoder
+};
+
+static ssize_t
+fun_so_stateless_iso2022jp_to_eucjp(void *statep, const unsigned char *s, size_t l, unsigned char *o, size_t osize)
+{
+    o[0] = s[1];
+    o[1] = s[2];
+    return 2;
+}
+
+static const rb_transcoder
+rb_stateless_iso2022jp_to_eucjp = {
+    "stateless-ISO-2022-JP", "EUC-JP", stateless_iso2022jp_to_eucjp,
+    TRANSCODE_TABLE_INFO,
+    1, /* input_unit_length */
+    3, /* max_input */
+    2, /* max_output */
+    asciicompat_converter, /* asciicompat_type */
+    0, NULL, NULL, /* state_size, state_init, state_fini */
+    NULL, NULL, NULL, fun_so_stateless_iso2022jp_to_eucjp,
+};
+
+static ssize_t
+fun_so_eucjp_to_stateless_iso2022jp(void *statep, const unsigned char *s, size_t l, unsigned char *o, size_t osize)
+{
+    o[0] = EMACS_MULE_LEADING_CODE_JISX0208_1983;
+    o[1] = s[0];
+    o[2] = s[1];
+    return 3;
+}
+
+static const rb_transcoder
+rb_eucjp_to_stateless_iso2022jp = {
+    "EUC-JP", "stateless-ISO-2022-JP", eucjp_to_stateless_iso2022jp,
+    TRANSCODE_TABLE_INFO,
+    1, /* input_unit_length */
+    3, /* max_input */
+    3, /* max_output */
+    asciicompat_converter, /* asciicompat_type */
+    0, NULL, NULL, /* state_size, state_init, state_fini */
+    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)
+{
+    rb_register_transcoder(&rb_iso2022jp_decoder);
+    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);
+}
+