From fcbf63e62c627deae76c1b8cb8c0876c536ed811 Mon Sep 17 00:00:00 2001 From: Jari Vetoniemi Date: Mon, 16 Mar 2020 18:49:26 +0900 Subject: Fresh start --- jni/ruby/enc/trans/iso2022.trans | 567 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 567 insertions(+) create mode 100644 jni/ruby/enc/trans/iso2022.trans (limited to 'jni/ruby/enc/trans/iso2022.trans') diff --git a/jni/ruby/enc/trans/iso2022.trans b/jni/ruby/enc/trans/iso2022.trans new file mode 100644 index 0000000..a441f15 --- /dev/null +++ b/jni/ruby/enc/trans/iso2022.trans @@ -0,0 +1,567 @@ +#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 +}; + +TRANS_INIT(iso2022) +{ + 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); +} + -- cgit v1.2.3