ruby-changes:7100
From: akr <ko1@a...>
Date: Thu, 14 Aug 2008 20:31:41 +0900 (JST)
Subject: [ruby-changes:7100] Ruby:r18618 (trunk): * transcode_data.h (transcode_invalid_byte_sequence): renamed from
akr 2008-08-14 20:31:27 +0900 (Thu, 14 Aug 2008) New Revision: 18618 http://svn.ruby-lang.org/cgi-bin/viewvc.cgi?view=rev&revision=18618 Log: * transcode_data.h (transcode_invalid_byte_sequence): renamed from transcode_invalid_input. (transcode_destination_buffer_full): renamed from transcode_obuf_full. (transcode_source_buffer_empty): renamed from transcode_ibuf_empty. (rb_econv_result_t): renamed from rb_trans_result_t. (rb_econv_elem_t): renamed from rb_trans_elem_t. (rb_econv_t): renamed from rb_trans_t. * transcode.c (UNIVERSAL_NEWLINE_DECODER): renamed from UNIVERSAL_NEWLINE. (CRLF_NEWLINE_ENCODER): renamed from CRLF_NEWLINE. (CR_NEWLINE_ENCODER): renamed from CR_NEWLINE. (rb_econv_open): renamed from rb_trans_open. (rb_econv_close): renamed from rb_trans_close. Modified files: trunk/ChangeLog trunk/test/ruby/test_econv.rb trunk/transcode.c trunk/transcode_data.h Index: ChangeLog =================================================================== --- ChangeLog (revision 18617) +++ ChangeLog (revision 18618) @@ -1,3 +1,20 @@ +Thu Aug 14 20:25:52 2008 Tanaka Akira <akr@f...> + + * transcode_data.h (transcode_invalid_byte_sequence): renamed from + transcode_invalid_input. + (transcode_destination_buffer_full): renamed from transcode_obuf_full. + (transcode_source_buffer_empty): renamed from transcode_ibuf_empty. + (rb_econv_result_t): renamed from rb_trans_result_t. + (rb_econv_elem_t): renamed from rb_trans_elem_t. + (rb_econv_t): renamed from rb_trans_t. + + * transcode.c (UNIVERSAL_NEWLINE_DECODER): renamed from + UNIVERSAL_NEWLINE. + (CRLF_NEWLINE_ENCODER): renamed from CRLF_NEWLINE. + (CR_NEWLINE_ENCODER): renamed from CR_NEWLINE. + (rb_econv_open): renamed from rb_trans_open. + (rb_econv_close): renamed from rb_trans_close. + Thu Aug 14 19:41:42 2008 Tanaka Akira <akr@f...> * transcode.c (load_transcoder): unused function removed. Index: transcode_data.h =================================================================== --- transcode_data.h (revision 18617) +++ transcode_data.h (revision 18618) @@ -112,13 +112,13 @@ }; typedef enum { - transcode_invalid_input, + transcode_invalid_byte_sequence, transcode_undefined_conversion, - transcode_obuf_full, - transcode_ibuf_empty, + transcode_destination_buffer_full, + transcode_source_buffer_empty, transcode_finished, transcode_output_followed_by_input, -} rb_trans_result_t; +} rb_econv_result_t; typedef struct { const char *from; @@ -128,15 +128,15 @@ unsigned char *out_data_start; unsigned char *out_data_end; unsigned char *out_buf_end; - rb_trans_result_t last_result; -} rb_trans_elem_t; + rb_econv_result_t last_result; +} rb_econv_elem_t; typedef struct { - rb_trans_elem_t *elems; + rb_econv_elem_t *elems; int num_trans; int num_finished; rb_transcoding *last_tc; -} rb_trans_t; +} rb_econv_t; void rb_declare_transcoder(const char *enc1, const char *enc2, const char *lib); void rb_register_transcoder(const rb_transcoder *); Index: test/ruby/test_econv.rb =================================================================== --- test/ruby/test_econv.rb (revision 18617) +++ test/ruby/test_econv.rb (revision 18618) @@ -42,7 +42,7 @@ def test_partial_input ec = Encoding::Converter.new("UTF-8", "EUC-JP") ret = ec.primitive_convert(src="", dst="", nil, 10, Encoding::Converter::PARTIAL_INPUT) - assert_equal(:ibuf_empty, ret) + assert_equal(:source_buffer_empty, ret) ret = ec.primitive_convert(src="", dst="", nil, 10) assert_equal(:finished, ret) end @@ -50,22 +50,22 @@ def test_accumulate_dst1 ec = Encoding::Converter.new("UTF-8", "EUC-JP") a = ["", "abc\u{3042}def", ec, nil, 1] - check_ec("a", "c\u{3042}def", :obuf_full, *a) - check_ec("ab", "\u{3042}def", :obuf_full, *a) - check_ec("abc", "def", :obuf_full, *a) - check_ec("abc\xA4", "def", :obuf_full, *a) - check_ec("abc\xA4\xA2", "ef", :obuf_full, *a) - check_ec("abc\xA4\xA2d", "f", :obuf_full, *a) - check_ec("abc\xA4\xA2de", "", :obuf_full, *a) + check_ec("a", "c\u{3042}def", :destination_buffer_full, *a) + check_ec("ab", "\u{3042}def", :destination_buffer_full, *a) + check_ec("abc", "def", :destination_buffer_full, *a) + check_ec("abc\xA4", "def", :destination_buffer_full, *a) + check_ec("abc\xA4\xA2", "ef", :destination_buffer_full, *a) + check_ec("abc\xA4\xA2d", "f", :destination_buffer_full, *a) + check_ec("abc\xA4\xA2de", "", :destination_buffer_full, *a) check_ec("abc\xA4\xA2def", "", :finished, *a) end def test_accumulate_dst2 ec = Encoding::Converter.new("UTF-8", "EUC-JP") a = ["", "abc\u{3042}def", ec, nil, 2] - check_ec("ab", "\u{3042}def", :obuf_full, *a) - check_ec("abc\xA4", "def", :obuf_full, *a) - check_ec("abc\xA4\xA2d", "f", :obuf_full, *a) + check_ec("ab", "\u{3042}def", :destination_buffer_full, *a) + check_ec("abc\xA4", "def", :destination_buffer_full, *a) + check_ec("abc\xA4\xA2d", "f", :destination_buffer_full, *a) check_ec("abc\xA4\xA2def", "", :finished, *a) end @@ -81,40 +81,40 @@ def test_iso2022jp_outstream ec = Encoding::Converter.new("EUC-JP", "ISO-2022-JP") a = ["", src="", ec, nil, 50, Encoding::Converter::PARTIAL_INPUT] - src << "a"; check_ec("a", "", :ibuf_empty, *a) - src << "\xA2"; check_ec("a", "", :ibuf_empty, *a) - src << "\xA4"; check_ec("a\e$B\"$", "", :ibuf_empty, *a) - src << "\xA1"; check_ec("a\e$B\"$", "", :ibuf_empty, *a) - src << "\xA2"; check_ec("a\e$B\"$!\"", "", :ibuf_empty, *a) - src << "b"; check_ec("a\e$B\"$!\"\e(Bb", "", :ibuf_empty, *a) - src << "\xA2\xA6"; check_ec("a\e$B\"$!\"\e(Bb\e$B\"&", "", :ibuf_empty, *a) + src << "a"; check_ec("a", "", :source_buffer_empty, *a) + src << "\xA2"; check_ec("a", "", :source_buffer_empty, *a) + src << "\xA4"; check_ec("a\e$B\"$", "", :source_buffer_empty, *a) + src << "\xA1"; check_ec("a\e$B\"$", "", :source_buffer_empty, *a) + src << "\xA2"; check_ec("a\e$B\"$!\"", "", :source_buffer_empty, *a) + src << "b"; check_ec("a\e$B\"$!\"\e(Bb", "", :source_buffer_empty, *a) + src << "\xA2\xA6"; check_ec("a\e$B\"$!\"\e(Bb\e$B\"&", "", :source_buffer_empty, *a) a[-1] = 0; check_ec("a\e$B\"$!\"\e(Bb\e$B\"&\e(B", "", :finished, *a) end def test_invalid - assert_econv("", :invalid_input, 100, ["UTF-8", "EUC-JP"], "\x80", "") - assert_econv("a", :invalid_input, 100, ["UTF-8", "EUC-JP"], "a\x80", "") - assert_econv("a", :invalid_input, 100, ["UTF-8", "EUC-JP"], "a\x80", "\x80") - assert_econv("abc", :invalid_input, 100, ["UTF-8", "EUC-JP"], "abc\xFF", "def") - assert_econv("abc", :invalid_input, 100, ["Shift_JIS", "EUC-JP"], "abc\xFF", "def") - assert_econv("abc", :invalid_input, 100, ["ISO-2022-JP", "EUC-JP"], "abc\xFF", "def") + assert_econv("", :invalid_byte_sequence, 100, ["UTF-8", "EUC-JP"], "\x80", "") + assert_econv("a", :invalid_byte_sequence, 100, ["UTF-8", "EUC-JP"], "a\x80", "") + assert_econv("a", :invalid_byte_sequence, 100, ["UTF-8", "EUC-JP"], "a\x80", "\x80") + assert_econv("abc", :invalid_byte_sequence, 100, ["UTF-8", "EUC-JP"], "abc\xFF", "def") + assert_econv("abc", :invalid_byte_sequence, 100, ["Shift_JIS", "EUC-JP"], "abc\xFF", "def") + assert_econv("abc", :invalid_byte_sequence, 100, ["ISO-2022-JP", "EUC-JP"], "abc\xFF", "def") end def test_invalid2 ec = Encoding::Converter.new("Shift_JIS", "EUC-JP") a = ["", "abc\xFFdef", ec, nil, 1] - check_ec("a", "c\xFFdef", :obuf_full, *a) - check_ec("ab", "\xFFdef", :obuf_full, *a) - check_ec("abc", "def", :invalid_input, *a) - check_ec("abcd", "f", :obuf_full, *a) - check_ec("abcde", "", :obuf_full, *a) + check_ec("a", "c\xFFdef", :destination_buffer_full, *a) + check_ec("ab", "\xFFdef", :destination_buffer_full, *a) + check_ec("abc", "def", :invalid_byte_sequence, *a) + check_ec("abcd", "f", :destination_buffer_full, *a) + check_ec("abcde", "", :destination_buffer_full, *a) check_ec("abcdef", "", :finished, *a) end def test_invalid3 ec = Encoding::Converter.new("Shift_JIS", "EUC-JP") a = ["", "abc\xFFdef", ec, nil, 10] - check_ec("abc", "def", :invalid_input, *a) + check_ec("abc", "def", :invalid_byte_sequence, *a) check_ec("abcdef", "", :finished, *a) end @@ -124,7 +124,7 @@ check_ec("a", "bc\xFFdef", :output_followed_by_input, *a) check_ec("ab", "c\xFFdef", :output_followed_by_input, *a) check_ec("abc", "\xFFdef", :output_followed_by_input, *a) - check_ec("abc", "def", :invalid_input, *a) + check_ec("abc", "def", :invalid_byte_sequence, *a) check_ec("abcd", "ef", :output_followed_by_input, *a) check_ec("abcde", "f", :output_followed_by_input, *a) check_ec("abcdef", "", :output_followed_by_input, *a) @@ -135,7 +135,7 @@ ec = Encoding::Converter.new("UTF-16BE", "EUC-JP") a = ["", "\xFF\xFE\x00A\xDC\x00\x00B", ec, nil, 10] check_ec("", "\x00A\xDC\x00\x00B", :undefined_conversion, *a) - check_ec("A", "\x00B", :invalid_input, *a) # \xDC\x00 is invalid as UTF-16BE + check_ec("A", "\x00B", :invalid_byte_sequence, *a) # \xDC\x00 is invalid as UTF-16BE check_ec("AB", "", :finished, *a) end @@ -144,29 +144,29 @@ a = ["", "\xFF\xFE\x00A\xDC\x00\x00B", ec, nil, 10, Encoding::Converter::OUTPUT_FOLLOWED_BY_INPUT] check_ec("", "\x00A\xDC\x00\x00B", :undefined_conversion, *a) check_ec("A", "\xDC\x00\x00B", :output_followed_by_input, *a) - check_ec("A", "\x00B", :invalid_input, *a) + check_ec("A", "\x00B", :invalid_byte_sequence, *a) check_ec("AB", "", :output_followed_by_input, *a) check_ec("AB", "", :finished, *a) end def test_universal_newline - ec = Encoding::Converter.new("UTF-8", "EUC-JP", Encoding::Converter::UNIVERSAL_NEWLINE) + ec = Encoding::Converter.new("UTF-8", "EUC-JP", Encoding::Converter::UNIVERSAL_NEWLINE_DECODER) a = ["", src="", ec, nil, 50, Encoding::Converter::PARTIAL_INPUT] - src << "abc\r\ndef"; check_ec("abc\ndef", "", :ibuf_empty, *a) - src << "ghi\njkl"; check_ec("abc\ndefghi\njkl", "", :ibuf_empty, *a) - src << "mno\rpqr"; check_ec("abc\ndefghi\njklmno\npqr", "", :ibuf_empty, *a) - src << "stu\r"; check_ec("abc\ndefghi\njklmno\npqrstu\n", "", :ibuf_empty, *a) - src << "\nvwx"; check_ec("abc\ndefghi\njklmno\npqrstu\nvwx", "", :ibuf_empty, *a) - src << "\nyz"; check_ec("abc\ndefghi\njklmno\npqrstu\nvwx\nyz", "", :ibuf_empty, *a) + src << "abc\r\ndef"; check_ec("abc\ndef", "", :source_buffer_empty, *a) + src << "ghi\njkl"; check_ec("abc\ndefghi\njkl", "", :source_buffer_empty, *a) + src << "mno\rpqr"; check_ec("abc\ndefghi\njklmno\npqr", "", :source_buffer_empty, *a) + src << "stu\r"; check_ec("abc\ndefghi\njklmno\npqrstu\n", "", :source_buffer_empty, *a) + src << "\nvwx"; check_ec("abc\ndefghi\njklmno\npqrstu\nvwx", "", :source_buffer_empty, *a) + src << "\nyz"; check_ec("abc\ndefghi\njklmno\npqrstu\nvwx\nyz", "", :source_buffer_empty, *a) end def test_crlf_newline - ec = Encoding::Converter.new("UTF-8", "EUC-JP", Encoding::Converter::CRLF_NEWLINE) + ec = Encoding::Converter.new("UTF-8", "EUC-JP", Encoding::Converter::CRLF_NEWLINE_ENCODER) assert_econv("abc\r\ndef", :finished, 50, ec, "abc\ndef", "") end def test_cr_newline - ec = Encoding::Converter.new("UTF-8", "EUC-JP", Encoding::Converter::CR_NEWLINE) + ec = Encoding::Converter.new("UTF-8", "EUC-JP", Encoding::Converter::CR_NEWLINE_ENCODER) assert_econv("abc\rdef", :finished, 50, ec, "abc\ndef", "") end Index: transcode.c =================================================================== --- transcode.c (revision 18617) +++ transcode.c (revision 18618) @@ -21,15 +21,15 @@ VALUE rb_cEncodingConverter; static VALUE sym_invalid, sym_undef, sym_ignore, sym_replace; -#define INVALID_IGNORE 0x1 -#define INVALID_REPLACE 0x2 -#define UNDEF_IGNORE 0x10 -#define UNDEF_REPLACE 0x20 -#define PARTIAL_INPUT 0x100 -#define UNIVERSAL_NEWLINE 0x200 -#define CRLF_NEWLINE 0x400 -#define CR_NEWLINE 0x800 -#define OUTPUT_FOLLOWED_BY_INPUT 0x1000 +#define INVALID_IGNORE 0x1 +#define INVALID_REPLACE 0x2 +#define UNDEF_IGNORE 0x10 +#define UNDEF_REPLACE 0x20 +#define PARTIAL_INPUT 0x100 +#define UNIVERSAL_NEWLINE_DECODER 0x200 +#define CRLF_NEWLINE_ENCODER 0x400 +#define CR_NEWLINE_ENCODER 0x800 +#define OUTPUT_FOLLOWED_BY_INPUT 0x1000 /* * Dispatch data and logic @@ -331,7 +331,7 @@ return ptr; } -static rb_trans_result_t +static rb_econv_result_t transcode_restartable0(const unsigned char **in_pos, unsigned char **out_pos, const unsigned char *in_stop, unsigned char *out_stop, rb_transcoding *tc, @@ -382,7 +382,7 @@ } while (0) #define SUSPEND_OBUF(num) \ do { \ - while (out_stop - out_p < 1) { SUSPEND(transcode_obuf_full, num); } \ + while (out_stop - out_p < 1) { SUSPEND(transcode_destination_buffer_full, num); } \ } while (0) #define SUSPEND_OUTPUT_FOLLOWED_BY_INPUT(num) \ @@ -431,7 +431,7 @@ if (in_stop <= in_p) { if (!(opt & PARTIAL_INPUT)) break; - SUSPEND(transcode_ibuf_empty, 7); + SUSPEND(transcode_source_buffer_empty, 7); continue; } @@ -457,7 +457,7 @@ while (in_p >= in_stop) { if (!(opt & PARTIAL_INPUT)) goto invalid; - SUSPEND(transcode_ibuf_empty, 5); + SUSPEND(transcode_source_buffer_empty, 5); } next_byte = (unsigned char)*in_p++; next_table = (const BYTE_LOOKUP *)next_info; @@ -532,7 +532,7 @@ SUSPEND_OUTPUT_FOLLOWED_BY_INPUT(26); while ((opt & PARTIAL_INPUT) && tc->recognized_len + (in_stop - inchar_start) < unitlen) { in_p = in_stop; - SUSPEND(transcode_ibuf_empty, 8); + SUSPEND(transcode_source_buffer_empty, 8); } if (tc->recognized_len + (in_stop - inchar_start) <= unitlen) { in_p = in_stop; @@ -555,7 +555,7 @@ continue; invalid: - SUSPEND(transcode_invalid_input, 1); + SUSPEND(transcode_invalid_byte_sequence, 1); continue; undef: @@ -588,7 +588,7 @@ #undef writebuf_off } -static rb_trans_result_t +static rb_econv_result_t transcode_restartable(const unsigned char **in_pos, unsigned char **out_pos, const unsigned char *in_stop, unsigned char *out_stop, rb_transcoding *tc, @@ -598,13 +598,13 @@ unsigned char *readagain_buf = ALLOCA_N(unsigned char, tc->readagain_len); const unsigned char *readagain_pos = readagain_buf; const unsigned char *readagain_stop = readagain_buf + tc->readagain_len; - rb_trans_result_t res; + rb_econv_result_t res; MEMCPY(readagain_buf, TRANSCODING_READBUF(tc) + tc->recognized_len, unsigned char, tc->readagain_len); tc->readagain_len = 0; res = transcode_restartable0(&readagain_pos, out_pos, readagain_stop, out_stop, tc, opt|PARTIAL_INPUT); - if (res != transcode_ibuf_empty) { + if (res != transcode_source_buffer_empty) { MEMCPY(TRANSCODING_READBUF(tc) + tc->recognized_len + tc->readagain_len, readagain_pos, unsigned char, readagain_stop - readagain_pos); tc->readagain_len += readagain_stop - readagain_pos; @@ -637,7 +637,7 @@ return tc; } -static rb_trans_result_t +static rb_econv_result_t rb_transcoding_convert(rb_transcoding *tc, const unsigned char **input_ptr, const unsigned char *input_stop, unsigned char **output_ptr, unsigned char *output_stop, @@ -660,10 +660,10 @@ xfree(tc); } -static rb_trans_t * +static rb_econv_t * rb_trans_open_by_transcoder_entries(int n, transcoder_entry_t **entries) { - rb_trans_t *ts; + rb_econv_t *ts; int i; for (i = 0; i < n; i++) { @@ -673,9 +673,9 @@ return NULL; } - ts = ALLOC(rb_trans_t); + ts = ALLOC(rb_econv_t); ts->num_trans = n; - ts->elems = ALLOC_N(rb_trans_elem_t, ts->num_trans); + ts->elems = ALLOC_N(rb_econv_elem_t, ts->num_trans); ts->num_finished = 0; ts->last_tc = NULL; for (i = 0; i < ts->num_trans; i++) { @@ -687,7 +687,7 @@ ts->elems[i].out_data_start = NULL; ts->elems[i].out_data_end = NULL; ts->elems[i].out_buf_end = NULL; - ts->elems[i].last_result = transcode_ibuf_empty; + ts->elems[i].last_result = transcode_source_buffer_empty; } ts->last_tc = ts->elems[ts->num_trans-1].tc; @@ -720,20 +720,20 @@ entries[depth] = get_transcoder_entry(from, to); } -static rb_trans_t * -rb_trans_open(const char *from, const char *to, int flags) +static rb_econv_t * +rb_econv_open(const char *from, const char *to, int flags) { transcoder_entry_t **entries = NULL; int num_trans; - static rb_trans_t *ts; + static rb_econv_t *ts; num_trans = transcode_search_path(from, to, trans_open_i, (void *)&entries); if (num_trans < 0 || !entries) return NULL; - if (flags & (CRLF_NEWLINE|CR_NEWLINE)) { - const char *name = (flags & CRLF_NEWLINE) ? "crlf_newline" : "cr_newline"; + if (flags & (CRLF_NEWLINE_ENCODER|CR_NEWLINE_ENCODER)) { + const char *name = (flags & CRLF_NEWLINE_ENCODER) ? "crlf_newline" : "cr_newline"; transcoder_entry_t *e = get_transcoder_entry("", name); if (!e) return NULL; @@ -742,7 +742,7 @@ num_trans++; } - if (flags & UNIVERSAL_NEWLINE) { + if (flags & UNIVERSAL_NEWLINE_DECODER) { transcoder_entry_t *e = get_transcoder_entry("universal_newline", ""); if (!e) return NULL; @@ -751,7 +751,7 @@ ts = rb_trans_open_by_transcoder_entries(num_trans, entries); - if (flags & UNIVERSAL_NEWLINE) { + if (flags & UNIVERSAL_NEWLINE_DECODER) { ts->last_tc = ts->elems[ts->num_trans-2].tc; } @@ -759,7 +759,7 @@ } static int -trans_sweep(rb_trans_t *ts, +trans_sweep(rb_econv_t *ts, const unsigned char **input_ptr, const unsigned char *input_stop, unsigned char **output_ptr, unsigned char *output_stop, int flags, @@ -770,20 +770,20 @@ const unsigned char **ipp, *is, *iold; unsigned char **opp, *os, *oold; - rb_trans_result_t res; + rb_econv_result_t res; try = 1; while (try) { try = 0; for (i = start; i < ts->num_trans; i++) { - rb_trans_elem_t *te = &ts->elems[i]; + rb_econv_elem_t *te = &ts->elems[i]; if (i == 0) { ipp = input_ptr; is = input_stop; } else { - rb_trans_elem_t *prev_te = &ts->elems[i-1]; + rb_econv_elem_t *prev_te = &ts->elems[i-1]; ipp = (const unsigned char **)&prev_te->out_data_start; is = prev_te->out_data_end; } @@ -820,13 +820,13 @@ try = 1; switch (res) { - case transcode_invalid_input: + case transcode_invalid_byte_sequence: case transcode_undefined_conversion: case transcode_output_followed_by_input: return i; - case transcode_obuf_full: - case transcode_ibuf_empty: + case transcode_destination_buffer_full: + case transcode_source_buffer_empty: break; case transcode_finished: @@ -838,8 +838,8 @@ return -1; } -static rb_trans_result_t -rb_trans_conv(rb_trans_t *ts, +static rb_econv_result_t +rb_trans_conv(rb_econv_t *ts, const unsigned char **input_ptr, const unsigned char *input_stop, unsigned char **output_ptr, unsigned char *output_stop, int flags) @@ -862,12 +862,12 @@ } if (ts->elems[0].last_result == transcode_output_followed_by_input) - ts->elems[0].last_result = transcode_ibuf_empty; + ts->elems[0].last_result = transcode_source_buffer_empty; needreport_index = -1; for (i = ts->num_trans-1; 0 <= i; i--) { switch (ts->elems[i].last_result) { - case transcode_invalid_input: + case transcode_invalid_byte_sequence: case transcode_undefined_conversion: case transcode_output_followed_by_input: case transcode_finished: @@ -875,8 +875,8 @@ needreport_index = i; goto found_needreport; - case transcode_obuf_full: - case transcode_ibuf_empty: + case transcode_destination_buffer_full: + case transcode_source_buffer_empty: break; default: @@ -886,14 +886,14 @@ /* /^[io]+$/ is confirmed. but actually /^i*o*$/. */ - if (ts->elems[ts->num_trans-1].last_result == transcode_obuf_full && + if (ts->elems[ts->num_trans-1].last_result == transcode_destination_buffer_full && (flags & OUTPUT_FOLLOWED_BY_INPUT)) { - rb_trans_result_t res; + rb_econv_result_t res; res = rb_trans_conv(ts, NULL, NULL, output_ptr, output_stop, (flags & ~OUTPUT_FOLLOWED_BY_INPUT)|PARTIAL_INPUT); - if (res == transcode_ibuf_empty) + if (res == transcode_source_buffer_empty) return transcode_output_followed_by_input; return res; } @@ -908,26 +908,26 @@ } while (needreport_index != -1 && needreport_index != ts->num_trans-1); for (i = ts->num_trans-1; 0 <= i; i--) { - if (ts->elems[i].last_result != transcode_ibuf_empty) { - rb_trans_result_t res = ts->elems[i].last_result; - if (res == transcode_invalid_input || + if (ts->elems[i].last_result != transcode_source_buffer_empty) { + rb_econv_result_t res = ts->elems[i].last_result; + if (res == transcode_invalid_byte_sequence || res == transcode_undefined_conversion || res == transcode_output_followed_by_input) { - ts->elems[i].last_result = transcode_ibuf_empty; + ts->elems[i].last_result = transcode_source_buffer_empty; } return res; } } - return transcode_ibuf_empty; + return transcode_source_buffer_empty; } -static rb_trans_result_t -rb_econv_conv(rb_trans_t *ts, +static rb_econv_result_t +rb_econv_conv(rb_econv_t *ts, const unsigned char **input_ptr, const unsigned char *input_stop, unsigned char **output_ptr, unsigned char *output_stop, int flags) { - rb_trans_result_t res; + rb_econv_result_t res; if ((flags & OUTPUT_FOLLOWED_BY_INPUT) || ts->num_trans == 1) @@ -941,7 +941,7 @@ } static void -rb_trans_close(rb_trans_t *ts) +rb_econv_close(rb_econv_t *ts) { int i; @@ -1035,13 +1035,13 @@ const char *to_encoding, const int opt) { - rb_trans_t *ts; + rb_econv_t *ts; rb_transcoding *last_tc; - rb_trans_result_t ret; + rb_econv_result_t ret; unsigned char *out_start = *out_pos; int max_output; - ts = rb_trans_open(from_encoding, to_encoding, 0); + ts = rb_econv_open(from_encoding, to_encoding, 0); if (!ts) rb_raise(rb_eArgError, "transcoding not supported (from %s to %s)", from_encoding, to_encoding); @@ -1050,7 +1050,7 @@ resume: ret = rb_econv_conv(ts, in_pos, in_stop, out_pos, out_stop, opt); - if (ret == transcode_invalid_input) { + if (ret == transcode_invalid_byte_sequence) { /* deal with invalid byte sequence */ /* todo: add more alternative behaviors */ if (opt&INVALID_IGNORE) { @@ -1060,7 +1060,7 @@ output_replacement_character(destination, resize_destination, last_tc, &out_start, out_pos, &out_stop); goto resume; } - rb_trans_close(ts); + rb_econv_close(ts); rb_raise(rb_eInvalidByteSequence, "invalid byte sequence"); } if (ret == transcode_undefined_conversion) { @@ -1074,15 +1074,15 @@ output_replacement_character(destination, resize_destination, last_tc, &out_start, out_pos, &out_stop); goto resume; } - rb_trans_close(ts); + rb_econv_close(ts); rb_raise(rb_eConversionUndefined, "conversion undefined for byte sequence (maybe invalid byte sequence)"); } - if (ret == transcode_obuf_full) { + if (ret == transcode_destination_buffer_full) { more_output_buffer(destination, resize_destination, max_output, &out_start, out_pos, &out_stop); goto resume; } - rb_trans_close(ts); + rb_econv_close(ts); return; } #else @@ -1096,27 +1096,27 @@ const char *to_encoding, const int opt) { - rb_trans_t *ts; + rb_econv_t *ts; rb_transcoding *last_tc; - rb_trans_result_t ret; + rb_econv_result_t ret; unsigned char *out_start = *out_pos; const unsigned char *ptr; int max_output; - ts = rb_trans_open(from_encoding, to_encoding, 0); + ts = rb_econv_open(from_encoding, to_encoding, 0); if (!ts) rb_raise(rb_eArgError, "transcoding not supported (from %s to %s)", from_encoding, to_encoding); last_tc = ts->last_tc; max_output = ts->elems[ts->num_trans-1].tc->transcoder->max_output; - ret = transcode_ibuf_empty; + ret = transcode_source_buffer_empty; ptr = *in_pos; while (ret != transcode_finished) { unsigned char input_byte; const unsigned char *p = &input_byte; - if (ret == transcode_ibuf_empty) { + if (ret == transcode_source_buffer_empty) { if (ptr < in_stop) { input_byte = *ptr; ret = rb_econv_conv(ts, &p, p+1, out_pos, out_stop, PARTIAL_INPUT); @@ -1131,7 +1131,7 @@ if (&input_byte != p) ptr += p - &input_byte; switch (ret) { - case transcode_invalid_input: + case transcode_invalid_byte_sequence: /* deal with invalid byte sequence */ /* todo: add more alternative behaviors */ if (opt&INVALID_IGNORE) { @@ -1141,7 +1141,7 @@ output_replacement_character(destination, resize_destination, last_tc, &out_start, out_pos, &out_stop); break; } - rb_trans_close(ts); + rb_econv_close(ts); rb_raise(rb_eInvalidByteSequence, "invalid byte sequence"); break; @@ -1156,22 +1156,22 @@ output_replacement_character(destination, resize_destination, last_tc, &out_start, out_pos, &out_stop); break; } - rb_trans_close(ts); + rb_econv_close(ts); rb_raise(rb_eConversionUndefined, "conversion undefined for byte sequence (maybe invalid byte sequence)"); break; - case transcode_obuf_full: + case transcode_destination_buffer_full: more_output_buffer(destination, resize_destination, max_output, &out_start, out_pos, &out_stop); break; - case transcode_ibuf_empty: + case transcode_source_buffer_empty: break; case transcode_finished: break; } } - rb_trans_close(ts); + rb_econv_close(ts); *in_pos = in_stop; return; } @@ -1370,9 +1370,9 @@ } static void -econv_free(rb_trans_t *ts) +econv_free(rb_econv_t *ts) { - rb_trans_close(ts); + rb_econv_close(ts); } static VALUE @@ -1383,17 +1383,17 @@ /* * call-seq: - * Encoding::Converter.new(input_encoding, output_encoding) - * Encoding::Converter.new(input_encoding, output_encoding, flags) + * Encoding::Converter.new(source_encoding, destination_encoding) + * Encoding::Converter.new(source_encoding, destination_encoding, flags) * * possible flags: - * Encoding::Converter::UNIVERSAL_NEWLINE # convert CRLF and CR to LF at last - * Encoding::Converter::CRLF_NEWLINE # convert LF to CRLF at first - * Encoding::Converter::CR_NEWLINE # convert LF to CR at first + * Encoding::Converter::UNIVERSAL_NEWLINE_DECODER # convert CRLF and CR to LF at last + * Encoding::Converter::CRLF_NEWLINE_ENCODER # convert LF to CRLF at first + * Encoding::Converter::CR_NEWLINE_ENCODER # convert LF to CR at first * * Encoding::Converter.new creates an instance of Encoding::Converter. * - * input_encoding and output_encoding should be a string. + * source_encoding and destination_encoding should be a string. * flags should be an integer. * * example: @@ -1402,11 +1402,11 @@ * * # (1) convert UTF-16BE to UTF-8 * # (2) convert CRLF and CR to LF - * ec = Encoding::Converter.new("UTF-16BE", "UTF-8", Encoding::Converter::UNIVERSAL_NEWLINE) + * ec = Encoding::Converter.new("UTF-16BE", "UTF-8", Encoding::Converter::UNIVERSAL_NEWLINE_DECODER) * * # (1) convert LF to CRLF * # (2) convert UTF-8 to UTF-16BE - * ec = Encoding::Converter.new("UTF-8", "UTF-16BE", Encoding::Converter::CRLF_NEWLINE) + * ec = Encoding::Converter.new("UTF-8", "UTF-16BE", Encoding::Converter::CRLF_NEWLINE_ENCODER) * */ static VALUE @@ -1414,7 +1414,7 @@ { VALUE from_encoding, to_encoding, flags_v; const char *from_e, *to_e; - rb_trans_t *ts; + rb_econv_t *ts; int flags; rb_scan_args(argc, argv, "21", &from_encoding, &to_encoding, &flags_v); @@ -1433,7 +1433,7 @@ rb_raise(rb_eTypeError, "already initialized"); } - ts = rb_trans_open(from_e, to_e, flags); + ts = rb_econv_open(from_e, to_e, flags); if (!ts) { rb_raise(rb_eArgError, "encoding convewrter not supported (from %s to %s)", from_e, to_e); } @@ -1447,7 +1447,7 @@ econv_inspect(VALUE self) { const char *cname = rb_obj_classname(self); - rb_trans_t *ts = DATA_PTR(self); + rb_econv_t *ts = DATA_PTR(self); if (!ts) return rb_sprintf("#<%s: uninitialized>", cname); @@ -1459,7 +1459,7 @@ #define IS_ECONV(obj) (RDATA(obj)->dfree == (RUBY_DATA_FUNC)econv_free) -static rb_trans_t * +static rb_econv_t * check_econv(VALUE self) { Check_Type(self, T_DATA); @@ -1475,49 +1475,50 @@ /* * call-seq: - * primitive_convert(input_buffer, output_buffer, output_byteoffset, output_bytesize) -> symbol - * primitive_convert(input_buffer, output_buffer, output_byteoffset, output_bytesize, flags) -> symbol + * primitive_convert(source_buffer, destination_buffer, destination_byteoffset, destination_bytesize) -> symbol + * primitive_convert(source_buffer, destination_buffer, destination_byteoffset, destination_bytesize, flags) -> symbol * * possible flags: - * Encoding::Converter::PARTIAL_INPUT # input buffer may be part of larger input + * Encoding::Converter::PARTIAL_INPUT # source buffer may be part of larger source * Encoding::Converter::OUTPUT_FOLLOWED_BY_INPUT # stop conversion after output before input * * possible results: - * :invalid_input + * :invalid_byte_sequence * :undefined_conversion * :output_followed_by_input - * :obuf_full - * :ibuf_empty + * :destination_buffer_full + * :source_buffer_empty * :finished * - * primitive_convert converts input_buffer into output_buffer. + * primitive_convert converts source_buffer into destination_buffer. * - * input_buffer and output_buffer should be a string. - * output_byteoffset should be an integer or nil. - * output_bytesize and flags should be an integer. + * source_buffer and destination_buffer should be a string. + * destination_byteoffset should be an integer or nil. + * destination_bytesize and flags should be an integer. * - * primitive_convert convert the content of input_buffer from beginning - * and store the result into output_buffer. + * primitive_convert convert the content of source_buffer from beginning + * and store the result into destination_buffer. * - * output_byteoffset and output_bytesize specify the region which + * destination_byteoffset and destination_bytesize specify the region which * the converted result is stored. - * output_byteoffset specifies the start position in output_buffer in bytes. - * If output_byteoffset is nil, output_buffer.bytesize is assumed. - * output_bytesize specifies maximum number of bytes. - * After conversion, output_buffer is resized to - * output_byteoffset + actually converted number of bytes. + * destination_byteoffset specifies the start position in destination_buffer in bytes. + * If destination_byteoffset is nil, + * destination_buffer.bytesize is used for appending the result. + * destination_bytesize specifies maximum number of bytes. + * After conversion, destination_buffer is resized to + * destination_byteoffset + actually converted number of bytes. * - * primitive_convert drops the first part of input_buffer. - * the dropped part is converted in output_buffer or + * primitive_convert drops the first part of source_buffer. + * the dropped part is converted in destination_buffer or * buffered in Encoding::Converter object. * * primitive_convert stops conversion when one of following condition met. - * - invalid byte sequence found in input buffer (:invalid_input) + * - invalid byte sequence found in source buffer (:invalid_byte_sequence) * - character not representable in output encoding (:undefined_conversion) - * - after some output is generated, before any input is consumed (:output_followed_by_input) + * - after some output is generated, before input is done (:output_followed_by_input) * this occur only when OUTPUT_FOLLOWED_BY_INPUT is specified. - * - output buffer is full (:obuf_full) - * - input buffer is empty (:ibuf_empty) + * - destination buffer is full (:destination_buffer_full) + * - source buffer is empty (:source_buffer_empty) * this occur only when PARTIAL_INPUT is specified. * - conversion is finished (:finished) * @@ -1528,11 +1529,11 @@ * * ec = Encoding::Converter.new("UTF-8", "UTF-16BE") * ret = ec.primitive_convert(src="pi", dst="", 1) - * p [ret, src, dst] #=> [:obuf_full, "i", "\x00"] + * p [ret, src, dst] #=> [:destination_buffer_full, "i", "\x00"] * ret = ec.primitive_convert(src, dst="", 1) - * p [ret, src, dst] #=> [:obuf_full, "", "p"] + * p [ret, src, dst] #=> [:destination_buffer_full, "", "p"] * ret = ec.primitive_convert(src, dst="", 1) - * p [ret, src, dst] #=> [:obuf_full, "", "\x00"] + * p [ret, src, dst] #=> [:destination_buffer_full, "", "\x00"] * ret = ec.primitive_convert(src, dst="", 1) * p [ret, src, dst] #=> [:finished, "", "i"] * @@ -1541,8 +1542,8 @@ econv_primitive_convert(int argc, VALUE *argv, VALUE self) { VALUE input, output, output_byteoffset_v, output_bytesize_v, flags_v; - rb_trans_t *ts = check_econv(self); - rb_trans_result_t res; + rb_econv_t *ts = check_econv(self); + rb_econv_result_t res; const unsigned char *ip, *is; unsigned char *op, *os; long output_byteoffset, output_bytesize; @@ -1600,10 +1601,10 @@ rb_str_drop_bytes(input, ip - (unsigned char *)RSTRING_PTR(input)); switch (res) { - case transcode_invalid_input: return ID2SYM(rb_intern("invalid_input")); + case transcode_invalid_byte_sequence: return ID2SYM(rb_intern("invalid_byte_sequence")); case transcode_undefined_conversion: return ID2SYM(rb_intern("undefined_conversion")); - case transcode_obuf_full: return ID2SYM(rb_intern("obuf_full")); - case transcode_ibuf_empty: return ID2SYM(rb_intern("ibuf_empty")); + case transcode_destination_buffer_full: return ID2SYM(rb_intern("destination_buffer_full")); + case transcode_source_buffer_empty: return ID2SYM(rb_intern("source_buffer_empty")); case transcode_finished: return ID2SYM(rb_intern("finished")); case transcode_output_followed_by_input: return ID2SYM(rb_intern("output_followed_by_input")); default: return INT2NUM(res); /* should not be reached */ @@ -1619,7 +1620,7 @@ static VALUE econv_max_output(VALUE self) { - rb_trans_t *ts = check_econv(self); + rb_econv_t *ts = check_econv(self); int n; n = ts->elems[ts->num_trans-1].tc->transcoder->max_output; @@ -1650,7 +1651,7 @@ rb_define_method(rb_cEncodingConverter, "max_output", econv_max_output, 0); rb_define_const(rb_cEncodingConverter, "PARTIAL_INPUT", INT2FIX(PARTIAL_INPUT)); rb_define_const(rb_cEncodingConverter, "OUTPUT_FOLLOWED_BY_INPUT", INT2FIX(OUTPUT_FOLLOWED_BY_INPUT)); - rb_define_const(rb_cEncodingConverter, "UNIVERSAL_NEWLINE", INT2FIX(UNIVERSAL_NEWLINE)); - rb_define_const(rb_cEncodingConverter, "CRLF_NEWLINE", INT2FIX(CRLF_NEWLINE)); - rb_define_const(rb_cEncodingConverter, "CR_NEWLINE", INT2FIX(CR_NEWLINE)); + rb_define_const(rb_cEncodingConverter, "UNIVERSAL_NEWLINE_DECODER", INT2FIX(UNIVERSAL_NEWLINE_DECODER)); + rb_define_const(rb_cEncodingConverter, "CRLF_NEWLINE_ENCODER", INT2FIX(CRLF_NEWLINE_ENCODER)); + rb_define_const(rb_cEncodingConverter, "CR_NEWLINE_ENCODER", INT2FIX(CR_NEWLINE_ENCODER)); } -- ML: ruby-changes@q... Info: http://www.atdot.net/~ko1/quickml/