1berry/ruby
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

* include/ruby/encoding.h (ECONV_DECORATOR_MASK): merge

Browse Source 
ECONV_ENCODER_MASK and ECONV_DECORATOR_MASK.
  (ECONV_UNIVERSAL_NEWLINE_DECORATOR): renamed from
  ECONV_UNIVERSAL_NEWLINE_DECODER.
  (ECONV_CRLF_NEWLINE_DECORATOR): renamed from
  ECONV_CRLF_NEWLINE_ENCODER.
  (ECONV_CR_NEWLINE_DECORATOR): renamed from ECONV_CR_NEWLINE_ENCODER.
  (ECONV_XML_TEXT_DECORATOR): renamed from ECONV_XML_TEXT_ENCODER.
  (ECONV_XML_ATTR_CONTENT_DECORATOR): renamed from
  ECONV_XML_ATTR_CONTENT_ENCODER.
  (ECONV_STATEFUL_DECORATOR_MASK): renamed from
  ECONV_STATEFUL_ENCODER_MASK.
  (ECONV_XML_ATTR_QUOTE_DECORATOR): renamed from
  ECONV_XML_ATTR_CONTENT_DECORATOR.

* io.c: follow the renaming.

* transcode.c: ditto.



git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@19271 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
akr 2008-09-09 12:22:43 +00:00
parent a729be8433
commit d456f7e357
5 changed files with 123 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
ChangeLog
View File

@ -1,3 +1,24 @@
Tue Sep 9 21:17:00 2008 Tanaka Akira <akr@fsij.org>
* include/ruby/encoding.h (ECONV_DECORATOR_MASK): merge
ECONV_ENCODER_MASK and ECONV_DECORATOR_MASK.
(ECONV_UNIVERSAL_NEWLINE_DECORATOR): renamed from
ECONV_UNIVERSAL_NEWLINE_DECODER.
(ECONV_CRLF_NEWLINE_DECORATOR): renamed from
ECONV_CRLF_NEWLINE_ENCODER.
(ECONV_CR_NEWLINE_DECORATOR): renamed from ECONV_CR_NEWLINE_ENCODER.
(ECONV_XML_TEXT_DECORATOR): renamed from ECONV_XML_TEXT_ENCODER.
(ECONV_XML_ATTR_CONTENT_DECORATOR): renamed from
ECONV_XML_ATTR_CONTENT_ENCODER.
(ECONV_STATEFUL_DECORATOR_MASK): renamed from
ECONV_STATEFUL_ENCODER_MASK.
(ECONV_XML_ATTR_QUOTE_DECORATOR): renamed from
ECONV_XML_ATTR_CONTENT_DECORATOR.
* io.c: follow the renaming.
* transcode.c: ditto.
Tue Sep 9 20:55:55 2008 Tanaka Akira <akr@fsij.org> Tue Sep 9 20:55:55 2008 Tanaka Akira <akr@fsij.org>
* transcode.c (rb_econv_open0): make it static. * transcode.c (rb_econv_open0): make it static.

19
include/ruby/encoding.h
View File

@ -265,19 +265,16 @@ void rb_econv_binmode(rb_econv_t *ec);
#define ECONV_UNDEF_REPLACE 0x00000020 #define ECONV_UNDEF_REPLACE 0x00000020
#define ECONV_UNDEF_HEX_CHARREF 0x00000030 #define ECONV_UNDEF_HEX_CHARREF 0x00000030
/* usable only if destination encoding is ascii compatible */ #define ECONV_DECORATOR_MASK 0x0000ff00
#define ECONV_DECODER_MASK 0x00000f00
#define ECONV_UNIVERSAL_NEWLINE_DECODER 0x00000100
/* usable only if source encoding is ascii compatible */ #define ECONV_UNIVERSAL_NEWLINE_DECORATOR 0x00000100
#define ECONV_ENCODER_MASK 0x0000f000 #define ECONV_CRLF_NEWLINE_DECORATOR 0x00001000
#define ECONV_CRLF_NEWLINE_ENCODER 0x00001000 #define ECONV_CR_NEWLINE_DECORATOR 0x00002000
#define ECONV_CR_NEWLINE_ENCODER 0x00002000 #define ECONV_XML_TEXT_DECORATOR 0x00004000
#define ECONV_XML_TEXT_ENCODER 0x00004000 #define ECONV_XML_ATTR_CONTENT_DECORATOR 0x00008000
#define ECONV_XML_ATTR_CONTENT_ENCODER 0x00008000
#define ECONV_STATEFUL_ENCODER_MASK 0x00f00000 #define ECONV_STATEFUL_DECORATOR_MASK 0x00f00000
#define ECONV_XML_ATTR_QUOTE_ENCODER 0x00100000 #define ECONV_XML_ATTR_QUOTE_DECORATOR 0x00100000
/* end of flags for rb_econv_open */ /* end of flags for rb_econv_open */

32
io.c
View File

@ -673,16 +673,16 @@ rb_io_wait_writable(int f)
#if defined(RUBY_TEST_CRLF_ENVIRONMENT) || defined(_WIN32) #if defined(RUBY_TEST_CRLF_ENVIRONMENT) || defined(_WIN32)
/* Windows */ /* Windows */
# define NEED_NEWLINE_DECODER(fptr) (!(fptr->mode & FMODE_BINMODE)) # define NEED_NEWLINE_DECORATOR_ON_READ(fptr) (!(fptr->mode & FMODE_BINMODE))
# define NEED_NEWLINE_ENCODER(fptr) (!(fptr->mode & FMODE_BINMODE)) # define NEED_NEWLINE_DECORATOR_ON_WRITE(fptr) (!(fptr->mode & FMODE_BINMODE))
# define TEXTMODE_NEWLINE_ENCODER ECONV_CRLF_NEWLINE_ENCODER # define TEXTMODE_NEWLINE_DECORATOR_ON_WRITE ECONV_CRLF_NEWLINE_DECORATOR
#else #else
/* Unix */ /* Unix */
# define NEED_NEWLINE_DECODER(fptr) (fptr->mode & FMODE_TEXTMODE) # define NEED_NEWLINE_DECORATOR_ON_READ(fptr) (fptr->mode & FMODE_TEXTMODE)
# define NEED_NEWLINE_ENCODER(fptr) 0 # define NEED_NEWLINE_DECORATOR_ON_WRITE(fptr) 0
#endif #endif
#define NEED_READCONV(fptr) (fptr->encs.enc2 != NULL || NEED_NEWLINE_DECODER(fptr)) #define NEED_READCONV(fptr) (fptr->encs.enc2 != NULL || NEED_NEWLINE_DECORATOR_ON_READ(fptr))
#define NEED_WRITECONV(fptr) (fptr->encs.enc != NULL || NEED_NEWLINE_ENCODER(fptr) || (fptr->encs.ecflags & (ECONV_DECODER_MASK|ECONV_ENCODER_MASK|ECONV_STATEFUL_ENCODER_MASK))) #define NEED_WRITECONV(fptr) (fptr->encs.enc != NULL || NEED_NEWLINE_DECORATOR_ON_WRITE(fptr) || (fptr->encs.ecflags & (ECONV_DECORATOR_MASK|ECONV_STATEFUL_DECORATOR_MASK)))
static void static void
make_writeconv(rb_io_t *fptr) make_writeconv(rb_io_t *fptr)
@ -697,9 +697,9 @@ make_writeconv(rb_io_t *fptr)
ecflags = fptr->encs.ecflags; ecflags = fptr->encs.ecflags;
ecopts = fptr->encs.ecopts; ecopts = fptr->encs.ecopts;
#ifdef TEXTMODE_NEWLINE_ENCODER #ifdef TEXTMODE_NEWLINE_DECORATOR_ON_WRITE
if (NEED_NEWLINE_ENCODER(fptr)) if (NEED_NEWLINE_DECORATOR_ON_WRITE(fptr))
ecflags |= TEXTMODE_NEWLINE_ENCODER; ecflags |= TEXTMODE_NEWLINE_DECORATOR_ON_WRITE;
#endif #endif
if (!fptr->encs.enc) { if (!fptr->encs.enc) {
@ -714,7 +714,7 @@ make_writeconv(rb_io_t *fptr)
else { else {
enc = fptr->encs.enc2 ? fptr->encs.enc2 : fptr->encs.enc; enc = fptr->encs.enc2 ? fptr->encs.enc2 : fptr->encs.enc;
senc = rb_econv_asciicompat_encoding(enc->name); senc = rb_econv_asciicompat_encoding(enc->name);
if (!senc && !(fptr->encs.ecflags & ECONV_STATEFUL_ENCODER_MASK)) { if (!senc && !(fptr->encs.ecflags & ECONV_STATEFUL_DECORATOR_MASK)) {
/* single conversion */ /* single conversion */
fptr->writeconv_pre_ecflags = ecflags; fptr->writeconv_pre_ecflags = ecflags;
fptr->writeconv_pre_ecopts = ecopts; fptr->writeconv_pre_ecopts = ecopts;
@ -723,7 +723,7 @@ make_writeconv(rb_io_t *fptr)
} }
else { else {
/* double conversion */ /* double conversion */
fptr->writeconv_pre_ecflags = ecflags & ~ECONV_STATEFUL_ENCODER_MASK; fptr->writeconv_pre_ecflags = ecflags & ~ECONV_STATEFUL_DECORATOR_MASK;
fptr->writeconv_pre_ecopts = ecopts; fptr->writeconv_pre_ecopts = ecopts;
if (senc) { if (senc) {
denc = enc->name; denc = enc->name;
@ -733,7 +733,7 @@ make_writeconv(rb_io_t *fptr)
senc = denc = ""; senc = denc = "";
fptr->writeconv_stateless = rb_str_new2(enc->name); fptr->writeconv_stateless = rb_str_new2(enc->name);
} }
ecflags = fptr->encs.ecflags & (ECONV_ERROR_HANDLER_MASK|ECONV_STATEFUL_ENCODER_MASK); ecflags = fptr->encs.ecflags & (ECONV_ERROR_HANDLER_MASK|ECONV_STATEFUL_DECORATOR_MASK);
ecopts = fptr->encs.ecopts; ecopts = fptr->encs.ecopts;
fptr->writeconv = rb_econv_open_opts(senc, denc, ecflags, ecopts); fptr->writeconv = rb_econv_open_opts(senc, denc, ecflags, ecopts);
if (!fptr->writeconv) if (!fptr->writeconv)
@ -1455,8 +1455,8 @@ make_readconv(rb_io_t *fptr)
const char *sname, *dname; const char *sname, *dname;
ecflags = fptr->encs.ecflags; ecflags = fptr->encs.ecflags;
ecopts = fptr->encs.ecopts; ecopts = fptr->encs.ecopts;
if (NEED_NEWLINE_DECODER(fptr)) if (NEED_NEWLINE_DECORATOR_ON_READ(fptr))
ecflags |= ECONV_UNIVERSAL_NEWLINE_DECODER; ecflags |= ECONV_UNIVERSAL_NEWLINE_DECORATOR;
if (fptr->encs.enc2) { if (fptr->encs.enc2) {
sname = fptr->encs.enc2->name; sname = fptr->encs.enc2->name;
dname = fptr->encs.enc->name; dname = fptr->encs.enc->name;
@ -3509,7 +3509,7 @@ rb_io_binmode(VALUE io)
rb_econv_binmode(fptr->writeconv); rb_econv_binmode(fptr->writeconv);
fptr->mode |= FMODE_BINMODE; fptr->mode |= FMODE_BINMODE;
fptr->mode &= ~FMODE_TEXTMODE; fptr->mode &= ~FMODE_TEXTMODE;
fptr->writeconv_pre_ecflags &= ~(ECONV_UNIVERSAL_NEWLINE_DECODER|ECONV_CRLF_NEWLINE_ENCODER|ECONV_CR_NEWLINE_ENCODER); fptr->writeconv_pre_ecflags &= ~(ECONV_UNIVERSAL_NEWLINE_DECORATOR|ECONV_CRLF_NEWLINE_DECORATOR|ECONV_CR_NEWLINE_DECORATOR);
return io; return io;
} }

32
test/ruby/test_econv.rb
View File

@ -69,23 +69,23 @@ class TestEncodingConverter < Test::Unit::TestCase
def test_newline_converter_with_ascii_incompatible def test_newline_converter_with_ascii_incompatible
assert_nothing_raised { assert_nothing_raised {
Encoding::Converter.new("UTF-8", "UTF-16BE", Encoding::Converter::UNIVERSAL_NEWLINE_DECODER) Encoding::Converter.new("UTF-8", "UTF-16BE", Encoding::Converter::UNIVERSAL_NEWLINE_DECORATOR)
} }
assert_nothing_raised { assert_nothing_raised {
Encoding::Converter.new("UTF-16BE", "UTF-8", Encoding::Converter::CRLF_NEWLINE_ENCODER) Encoding::Converter.new("UTF-16BE", "UTF-8", Encoding::Converter::CRLF_NEWLINE_DECORATOR)
} }
assert_nothing_raised { assert_nothing_raised {
Encoding::Converter.new("UTF-16BE", "UTF-8", Encoding::Converter::CR_NEWLINE_ENCODER) Encoding::Converter.new("UTF-16BE", "UTF-8", Encoding::Converter::CR_NEWLINE_DECORATOR)
} }
assert_nothing_raised { assert_nothing_raised {
Encoding::Converter.new("UTF-16BE", "UTF-8", Encoding::Converter::UNIVERSAL_NEWLINE_DECODER) Encoding::Converter.new("UTF-16BE", "UTF-8", Encoding::Converter::UNIVERSAL_NEWLINE_DECORATOR)
} }
assert_nothing_raised { assert_nothing_raised {
Encoding::Converter.new("UTF-8", "UTF-16BE", Encoding::Converter::CRLF_NEWLINE_ENCODER) Encoding::Converter.new("UTF-8", "UTF-16BE", Encoding::Converter::CRLF_NEWLINE_DECORATOR)
} }
assert_nothing_raised { assert_nothing_raised {
Encoding::Converter.new("UTF-8", "UTF-16BE", Encoding::Converter::CR_NEWLINE_ENCODER) Encoding::Converter.new("UTF-8", "UTF-16BE", Encoding::Converter::CR_NEWLINE_DECORATOR)
} }
end end
@ -372,7 +372,7 @@ class TestEncodingConverter < Test::Unit::TestCase
end end
def test_universal_newline def test_universal_newline
ec = Encoding::Converter.new("UTF-8", "EUC-JP", universal_newline_decoder: true) ec = Encoding::Converter.new("UTF-8", "EUC-JP", universal_newline: true)
a = ["", src="", ec, nil, 50, :partial_input=>true] a = ["", src="", ec, nil, 50, :partial_input=>true]
src << "abc\r\ndef"; check_ec("abc\ndef", "", :source_buffer_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 << "ghi\njkl"; check_ec("abc\ndefghi\njkl", "", :source_buffer_empty, *a)
@ -383,7 +383,7 @@ class TestEncodingConverter < Test::Unit::TestCase
end end
def test_universal_newline2 def test_universal_newline2
ec = Encoding::Converter.new("", "", universal_newline_decoder: true) ec = Encoding::Converter.new("", "", universal_newline: true)
a = ["", src="", ec, nil, 50, :partial_input=>true] a = ["", src="", ec, nil, 50, :partial_input=>true]
src << "abc\r\ndef"; check_ec("abc\ndef", "", :source_buffer_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 << "ghi\njkl"; check_ec("abc\ndefghi\njkl", "", :source_buffer_empty, *a)
@ -394,22 +394,22 @@ class TestEncodingConverter < Test::Unit::TestCase
end end
def test_crlf_newline def test_crlf_newline
ec = Encoding::Converter.new("UTF-8", "EUC-JP", crlf_newline_encoder: true) ec = Encoding::Converter.new("UTF-8", "EUC-JP", crlf_newline: true)
assert_econv("abc\r\ndef", :finished, 50, ec, "abc\ndef", "") assert_econv("abc\r\ndef", :finished, 50, ec, "abc\ndef", "")
end end
def test_crlf_newline2 def test_crlf_newline2
ec = Encoding::Converter.new("", "", crlf_newline_encoder: true) ec = Encoding::Converter.new("", "", crlf_newline: true)
assert_econv("abc\r\ndef", :finished, 50, ec, "abc\ndef", "") assert_econv("abc\r\ndef", :finished, 50, ec, "abc\ndef", "")
end end
def test_cr_newline def test_cr_newline
ec = Encoding::Converter.new("UTF-8", "EUC-JP", cr_newline_encoder: true) ec = Encoding::Converter.new("UTF-8", "EUC-JP", cr_newline: true)
assert_econv("abc\rdef", :finished, 50, ec, "abc\ndef", "") assert_econv("abc\rdef", :finished, 50, ec, "abc\ndef", "")
end end
def test_cr_newline2 def test_cr_newline2
ec = Encoding::Converter.new("", "", cr_newline_encoder: true) ec = Encoding::Converter.new("", "", cr_newline: true)
assert_econv("abc\rdef", :finished, 50, ec, "abc\ndef", "") assert_econv("abc\rdef", :finished, 50, ec, "abc\ndef", "")
end end
@ -777,18 +777,18 @@ class TestEncodingConverter < Test::Unit::TestCase
end end
def test_xml_escape_with_charref def test_xml_escape_with_charref
ec = Encoding::Converter.new("utf-8", "euc-jp", Encoding::Converter::XML_TEXT_ENCODER|Encoding::Converter::UNDEF_HEX_CHARREF) ec = Encoding::Converter.new("utf-8", "euc-jp", Encoding::Converter::XML_TEXT_DECORATOR|Encoding::Converter::UNDEF_HEX_CHARREF)
assert_equal('&lt;&#x2665;&gt;&amp;"&#x2661;"', ec.convert("<\u2665>&\"\u2661\"")) assert_equal('&lt;&#x2665;&gt;&amp;"&#x2661;"', ec.convert("<\u2665>&\"\u2661\""))
assert_equal('', ec.finish) assert_equal('', ec.finish)
ec = Encoding::Converter.new("utf-8", "euc-jp", ec = Encoding::Converter.new("utf-8", "euc-jp",
Encoding::Converter::XML_ATTR_CONTENT_ENCODER| Encoding::Converter::XML_ATTR_CONTENT_DECORATOR|
Encoding::Converter::XML_ATTR_QUOTE_ENCODER| Encoding::Converter::XML_ATTR_QUOTE_DECORATOR|
Encoding::Converter::UNDEF_HEX_CHARREF) Encoding::Converter::UNDEF_HEX_CHARREF)
assert_equal('"&lt;&#x2665;&gt;&amp;&quot;&#x2661;&quot;', ec.convert("<\u2665>&\"\u2661\"")) assert_equal('"&lt;&#x2665;&gt;&amp;&quot;&#x2661;&quot;', ec.convert("<\u2665>&\"\u2661\""))
assert_equal('"', ec.finish) assert_equal('"', ec.finish)
ec = Encoding::Converter.new("utf-8", "iso-2022-jp", Encoding::Converter::XML_TEXT_ENCODER) ec = Encoding::Converter.new("utf-8", "iso-2022-jp", Encoding::Converter::XML_TEXT_DECORATOR)
assert_equal("&amp;\e$B$&\e(B&amp;".force_encoding("iso-2022-jp"), ec.convert("&\u3046&")) assert_equal("&amp;\e$B$&\e(B&amp;".force_encoding("iso-2022-jp"), ec.convert("&\u3046&"))
assert_equal('', ec.finish) assert_equal('', ec.finish)
end end

124
transcode.c
View File

@ -22,9 +22,9 @@ VALUE rb_cEncodingConverter;
static VALUE sym_invalid, sym_undef, sym_ignore, sym_replace; static VALUE sym_invalid, sym_undef, sym_ignore, sym_replace;
static VALUE sym_xml, sym_text, sym_attr; static VALUE sym_xml, sym_text, sym_attr;
static VALUE sym_universal_newline_decoder; static VALUE sym_universal_newline;
static VALUE sym_crlf_newline_encoder; static VALUE sym_crlf_newline;
static VALUE sym_cr_newline_encoder; static VALUE sym_cr_newline;
static VALUE sym_partial_input; static VALUE sym_partial_input;
static VALUE sym_invalid_byte_sequence; static VALUE sym_invalid_byte_sequence;
@ -947,37 +947,37 @@ rb_econv_open(const char *sname, const char *dname, int ecflags)
const char *decorators[6]; const char *decorators[6];
int i; int i;
if ((ecflags & ECONV_CRLF_NEWLINE_ENCODER) && if ((ecflags & ECONV_CRLF_NEWLINE_DECORATOR) &&
(ecflags & ECONV_CR_NEWLINE_ENCODER)) (ecflags & ECONV_CR_NEWLINE_DECORATOR))
return NULL; return NULL;
if ((ecflags & (ECONV_CRLF_NEWLINE_ENCODER|ECONV_CR_NEWLINE_ENCODER)) && if ((ecflags & (ECONV_CRLF_NEWLINE_DECORATOR|ECONV_CR_NEWLINE_DECORATOR)) &&
(ecflags & ECONV_UNIVERSAL_NEWLINE_DECODER)) (ecflags & ECONV_UNIVERSAL_NEWLINE_DECORATOR))
return NULL; return NULL;
if ((ecflags & ECONV_XML_TEXT_ENCODER) && if ((ecflags & ECONV_XML_TEXT_DECORATOR) &&
(ecflags & ECONV_XML_ATTR_CONTENT_ENCODER)) (ecflags & ECONV_XML_ATTR_CONTENT_DECORATOR))
return NULL; return NULL;
num_decorators = 0; num_decorators = 0;
if (ecflags & ECONV_XML_TEXT_ENCODER) if (ecflags & ECONV_XML_TEXT_DECORATOR)
if (!(decorators[num_decorators++] = "xml-text-escaped")) if (!(decorators[num_decorators++] = "xml-text-escaped"))
return NULL; return NULL;
if (ecflags & ECONV_XML_ATTR_CONTENT_ENCODER) if (ecflags & ECONV_XML_ATTR_CONTENT_DECORATOR)
if (!(decorators[num_decorators++] = "xml-attr-content-escaped")) if (!(decorators[num_decorators++] = "xml-attr-content-escaped"))
return NULL; return NULL;
if (ecflags & ECONV_XML_ATTR_QUOTE_ENCODER) if (ecflags & ECONV_XML_ATTR_QUOTE_DECORATOR)
if (!(decorators[num_decorators++] = "xml-attr-quoted")) if (!(decorators[num_decorators++] = "xml-attr-quoted"))
return NULL; return NULL;
if (ecflags & ECONV_CRLF_NEWLINE_ENCODER) if (ecflags & ECONV_CRLF_NEWLINE_DECORATOR)
if (!(decorators[num_decorators++] = "crlf_newline")) if (!(decorators[num_decorators++] = "crlf_newline"))
return NULL; return NULL;
if (ecflags & ECONV_CR_NEWLINE_ENCODER) if (ecflags & ECONV_CR_NEWLINE_DECORATOR)
if (!(decorators[num_decorators++] = "cr_newline")) if (!(decorators[num_decorators++] = "cr_newline"))
return NULL; return NULL;
if (ecflags & ECONV_UNIVERSAL_NEWLINE_DECODER) if (ecflags & ECONV_UNIVERSAL_NEWLINE_DECORATOR)
if (!(decorators[num_decorators++] = "universal_newline")) if (!(decorators[num_decorators++] = "universal_newline"))
return NULL; return NULL;
@ -1832,17 +1832,17 @@ rb_econv_binmode(rb_econv_t *ec)
int num_trans; int num_trans;
n = 0; n = 0;
if (ec->flags & ECONV_UNIVERSAL_NEWLINE_DECODER) { if (ec->flags & ECONV_UNIVERSAL_NEWLINE_DECORATOR) {
entry = get_transcoder_entry("universal_newline", ""); entry = get_transcoder_entry("universal_newline", "");
if (entry->transcoder) if (entry->transcoder)
trs[n++] = entry->transcoder; trs[n++] = entry->transcoder;
} }
if (ec->flags & ECONV_CRLF_NEWLINE_ENCODER) { if (ec->flags & ECONV_CRLF_NEWLINE_DECORATOR) {
entry = get_transcoder_entry("", "crlf_newline"); entry = get_transcoder_entry("", "crlf_newline");
if (entry->transcoder) if (entry->transcoder)
trs[n++] = entry->transcoder; trs[n++] = entry->transcoder;
} }
if (ec->flags & ECONV_CR_NEWLINE_ENCODER) { if (ec->flags & ECONV_CR_NEWLINE_DECORATOR) {
entry = get_transcoder_entry("", "cr_newline"); entry = get_transcoder_entry("", "cr_newline");
if (entry->transcoder) if (entry->transcoder)
trs[n++] = entry->transcoder; trs[n++] = entry->transcoder;
@ -1866,7 +1866,7 @@ rb_econv_binmode(rb_econv_t *ec)
} }
} }
ec->flags &= ~(ECONV_UNIVERSAL_NEWLINE_DECODER|ECONV_CRLF_NEWLINE_ENCODER|ECONV_CR_NEWLINE_ENCODER); ec->flags &= ~(ECONV_UNIVERSAL_NEWLINE_DECORATOR|ECONV_CRLF_NEWLINE_DECORATOR|ECONV_CR_NEWLINE_DECORATOR);
} }
@ -1888,36 +1888,36 @@ econv_description(const char *sname, const char *dname, int ecflags, VALUE mesg)
has_description = 1; has_description = 1;
} }
if (ecflags & (ECONV_UNIVERSAL_NEWLINE_DECODER| if (ecflags & (ECONV_UNIVERSAL_NEWLINE_DECORATOR|
ECONV_CRLF_NEWLINE_ENCODER| ECONV_CRLF_NEWLINE_DECORATOR|
ECONV_CR_NEWLINE_ENCODER| ECONV_CR_NEWLINE_DECORATOR|
ECONV_XML_TEXT_ENCODER| ECONV_XML_TEXT_DECORATOR|
ECONV_XML_ATTR_CONTENT_ENCODER| ECONV_XML_ATTR_CONTENT_DECORATOR|
ECONV_XML_ATTR_QUOTE_ENCODER)) { ECONV_XML_ATTR_QUOTE_DECORATOR)) {
const char *pre = ""; const char *pre = "";
if (has_description) if (has_description)
rb_str_cat2(mesg, " with "); rb_str_cat2(mesg, " with ");
if (ecflags & ECONV_UNIVERSAL_NEWLINE_DECODER) { if (ecflags & ECONV_UNIVERSAL_NEWLINE_DECORATOR) {
rb_str_cat2(mesg, pre); pre = ","; rb_str_cat2(mesg, pre); pre = ",";
rb_str_cat2(mesg, "universal-newline"); rb_str_cat2(mesg, "universal-newline");
} }
if (ecflags & ECONV_CRLF_NEWLINE_ENCODER) { if (ecflags & ECONV_CRLF_NEWLINE_DECORATOR) {
rb_str_cat2(mesg, pre); pre = ","; rb_str_cat2(mesg, pre); pre = ",";
rb_str_cat2(mesg, "CRLF-newline"); rb_str_cat2(mesg, "CRLF-newline");
} }
if (ecflags & ECONV_CR_NEWLINE_ENCODER) { if (ecflags & ECONV_CR_NEWLINE_DECORATOR) {
rb_str_cat2(mesg, pre); pre = ","; rb_str_cat2(mesg, pre); pre = ",";
rb_str_cat2(mesg, "CR-newline"); rb_str_cat2(mesg, "CR-newline");
} }
if (ecflags & ECONV_XML_TEXT_ENCODER) { if (ecflags & ECONV_XML_TEXT_DECORATOR) {
rb_str_cat2(mesg, pre); pre = ","; rb_str_cat2(mesg, pre); pre = ",";
rb_str_cat2(mesg, "XML-text"); rb_str_cat2(mesg, "XML-text");
} }
if (ecflags & ECONV_XML_ATTR_CONTENT_ENCODER) { if (ecflags & ECONV_XML_ATTR_CONTENT_DECORATOR) {
rb_str_cat2(mesg, pre); pre = ","; rb_str_cat2(mesg, pre); pre = ",";
rb_str_cat2(mesg, "XML-attr-content"); rb_str_cat2(mesg, "XML-attr-content");
} }
if (ecflags & ECONV_XML_ATTR_QUOTE_ENCODER) { if (ecflags & ECONV_XML_ATTR_QUOTE_DECORATOR) {
rb_str_cat2(mesg, pre); pre = ","; rb_str_cat2(mesg, pre); pre = ",";
rb_str_cat2(mesg, "XML-attr-quote"); rb_str_cat2(mesg, "XML-attr-quote");
} }
@ -2275,27 +2275,27 @@ econv_opts(VALUE opt)
if (!NIL_P(v)) { if (!NIL_P(v)) {
v = rb_convert_type(v, T_SYMBOL, "Symbol", "to_sym"); v = rb_convert_type(v, T_SYMBOL, "Symbol", "to_sym");
if (v==sym_text) { if (v==sym_text) {
ecflags |= ECONV_XML_TEXT_ENCODER|ECONV_UNDEF_HEX_CHARREF; ecflags |= ECONV_XML_TEXT_DECORATOR|ECONV_UNDEF_HEX_CHARREF;
} }
else if (v==sym_attr) { else if (v==sym_attr) {
ecflags |= ECONV_XML_ATTR_CONTENT_ENCODER|ECONV_XML_ATTR_QUOTE_ENCODER|ECONV_UNDEF_HEX_CHARREF; ecflags |= ECONV_XML_ATTR_CONTENT_DECORATOR|ECONV_XML_ATTR_QUOTE_DECORATOR|ECONV_UNDEF_HEX_CHARREF;
} }
else { else {
rb_raise(rb_eArgError, "unexpected value for xml option: %s", rb_id2name(SYM2ID(v))); rb_raise(rb_eArgError, "unexpected value for xml option: %s", rb_id2name(SYM2ID(v)));
} }
} }
v = rb_hash_aref(opt, sym_universal_newline_decoder); v = rb_hash_aref(opt, sym_universal_newline);
if (RTEST(v)) if (RTEST(v))
ecflags |= ECONV_UNIVERSAL_NEWLINE_DECODER; ecflags |= ECONV_UNIVERSAL_NEWLINE_DECORATOR;
v = rb_hash_aref(opt, sym_crlf_newline_encoder); v = rb_hash_aref(opt, sym_crlf_newline);
if (RTEST(v)) if (RTEST(v))
ecflags |= ECONV_CRLF_NEWLINE_ENCODER; ecflags |= ECONV_CRLF_NEWLINE_DECORATOR;
v = rb_hash_aref(opt, sym_cr_newline_encoder); v = rb_hash_aref(opt, sym_cr_newline);
if (RTEST(v)) if (RTEST(v))
ecflags |= ECONV_CR_NEWLINE_ENCODER; ecflags |= ECONV_CR_NEWLINE_DECORATOR;
return ecflags; return ecflags;
} }
@ -2430,12 +2430,12 @@ str_transcode0(int argc, VALUE *argv, VALUE *self, int ecflags, VALUE ecopts)
dencidx = str_transcode_enc_args(str, argv[0], argc==1 ? Qnil : argv[1], &sname, &senc, &dname, &denc); dencidx = str_transcode_enc_args(str, argv[0], argc==1 ? Qnil : argv[1], &sname, &senc, &dname, &denc);
if ((ecflags & (ECONV_UNIVERSAL_NEWLINE_DECODER| if ((ecflags & (ECONV_UNIVERSAL_NEWLINE_DECORATOR|
ECONV_CRLF_NEWLINE_ENCODER| ECONV_CRLF_NEWLINE_DECORATOR|
ECONV_CR_NEWLINE_ENCODER| ECONV_CR_NEWLINE_DECORATOR|
ECONV_XML_TEXT_ENCODER| ECONV_XML_TEXT_DECORATOR|
ECONV_XML_ATTR_CONTENT_ENCODER| ECONV_XML_ATTR_CONTENT_DECORATOR|
ECONV_XML_ATTR_QUOTE_ENCODER)) == 0) { ECONV_XML_ATTR_QUOTE_DECORATOR)) == 0) {
if (senc && senc == denc) { if (senc && senc == denc) {
return -1; return -1;
} }
@ -2644,18 +2644,18 @@ econv_s_asciicompat_encoding(VALUE klass, VALUE arg)
* *
* possible options elements: * possible options elements:
* hash form: * hash form:
* :universal_newline_decoder => true # convert CRLF and CR to LF at last * :universal_newline => true # convert CRLF and CR to LF
* :crlf_newline_encoder => true # convert LF to CRLF at first * :crlf_newline => true # convert LF to CRLF
* :cr_newline_encoder => true # convert LF to CR at first * :cr_newline => true # convert LF to CR
* :invalid => nil # error on invalid byte sequence (default) * :invalid => nil # error on invalid byte sequence (default)
* :invalid => :replace # replace invalid byte sequence * :invalid => :replace # replace invalid byte sequence
* :undef => nil # error on undefined conversion (default) * :undef => nil # error on undefined conversion (default)
* :undef => :replace # replace undefined conversion * :undef => :replace # replace undefined conversion
* :replace => string # replacement string ("?" or "\uFFFD" if not specified) * :replace => string # replacement string ("?" or "\uFFFD" if not specified)
* integer form: * integer form:
* Encoding::Converter::UNIVERSAL_NEWLINE_DECODER * Encoding::Converter::UNIVERSAL_NEWLINE_DECORATOR
* Encoding::Converter::CRLF_NEWLINE_ENCODER * Encoding::Converter::CRLF_NEWLINE_DECORATOR
* Encoding::Converter::CR_NEWLINE_ENCODER * Encoding::Converter::CR_NEWLINE_DECORATOR
* *
* Encoding::Converter.new creates an instance of Encoding::Converter. * Encoding::Converter.new creates an instance of Encoding::Converter.
* *
@ -2670,11 +2670,11 @@ econv_s_asciicompat_encoding(VALUE klass, VALUE arg)
* *
* # (1) convert UTF-16BE to UTF-8 * # (1) convert UTF-16BE to UTF-8
* # (2) convert CRLF and CR to LF * # (2) convert CRLF and CR to LF
* ec = Encoding::Converter.new("UTF-16BE", "UTF-8", :universal_newline_decoder => true) * ec = Encoding::Converter.new("UTF-16BE", "UTF-8", :universal_newline => true)
* *
* # (1) convert LF to CRLF * # (1) convert LF to CRLF
* # (2) convert UTF-8 to UTF-16BE * # (2) convert UTF-8 to UTF-16BE
* ec = Encoding::Converter.new("UTF-8", "UTF-16BE", :crlf_newline_encoder => true) * ec = Encoding::Converter.new("UTF-8", "UTF-16BE", :crlf_newline => true)
* *
*/ */
static VALUE static VALUE
@ -3633,9 +3633,9 @@ Init_transcode(void)
sym_finished = ID2SYM(rb_intern("finished")); sym_finished = ID2SYM(rb_intern("finished"));
sym_output_followed_by_input = ID2SYM(rb_intern("output_followed_by_input")); sym_output_followed_by_input = ID2SYM(rb_intern("output_followed_by_input"));
sym_incomplete_input = ID2SYM(rb_intern("incomplete_input")); sym_incomplete_input = ID2SYM(rb_intern("incomplete_input"));
sym_universal_newline_decoder = ID2SYM(rb_intern("universal_newline_decoder")); sym_universal_newline = ID2SYM(rb_intern("universal_newline"));
sym_crlf_newline_encoder = ID2SYM(rb_intern("crlf_newline_encoder")); sym_crlf_newline = ID2SYM(rb_intern("crlf_newline"));
sym_cr_newline_encoder = ID2SYM(rb_intern("cr_newline_encoder")); sym_cr_newline = ID2SYM(rb_intern("cr_newline"));
sym_partial_input = ID2SYM(rb_intern("partial_input")); sym_partial_input = ID2SYM(rb_intern("partial_input"));
rb_define_method(rb_cString, "encode", str_encode, -1); rb_define_method(rb_cString, "encode", str_encode, -1);
@ -3665,12 +3665,12 @@ Init_transcode(void)
rb_define_const(rb_cEncodingConverter, "UNDEF_HEX_CHARREF", INT2FIX(ECONV_UNDEF_HEX_CHARREF)); rb_define_const(rb_cEncodingConverter, "UNDEF_HEX_CHARREF", INT2FIX(ECONV_UNDEF_HEX_CHARREF));
rb_define_const(rb_cEncodingConverter, "PARTIAL_INPUT", INT2FIX(ECONV_PARTIAL_INPUT)); rb_define_const(rb_cEncodingConverter, "PARTIAL_INPUT", INT2FIX(ECONV_PARTIAL_INPUT));
rb_define_const(rb_cEncodingConverter, "OUTPUT_FOLLOWED_BY_INPUT", INT2FIX(ECONV_OUTPUT_FOLLOWED_BY_INPUT)); rb_define_const(rb_cEncodingConverter, "OUTPUT_FOLLOWED_BY_INPUT", INT2FIX(ECONV_OUTPUT_FOLLOWED_BY_INPUT));
rb_define_const(rb_cEncodingConverter, "UNIVERSAL_NEWLINE_DECODER", INT2FIX(ECONV_UNIVERSAL_NEWLINE_DECODER)); rb_define_const(rb_cEncodingConverter, "UNIVERSAL_NEWLINE_DECORATOR", INT2FIX(ECONV_UNIVERSAL_NEWLINE_DECORATOR));
rb_define_const(rb_cEncodingConverter, "CRLF_NEWLINE_ENCODER", INT2FIX(ECONV_CRLF_NEWLINE_ENCODER)); rb_define_const(rb_cEncodingConverter, "CRLF_NEWLINE_DECORATOR", INT2FIX(ECONV_CRLF_NEWLINE_DECORATOR));
rb_define_const(rb_cEncodingConverter, "CR_NEWLINE_ENCODER", INT2FIX(ECONV_CR_NEWLINE_ENCODER)); rb_define_const(rb_cEncodingConverter, "CR_NEWLINE_DECORATOR", INT2FIX(ECONV_CR_NEWLINE_DECORATOR));
rb_define_const(rb_cEncodingConverter, "XML_TEXT_ENCODER", INT2FIX(ECONV_XML_TEXT_ENCODER)); rb_define_const(rb_cEncodingConverter, "XML_TEXT_DECORATOR", INT2FIX(ECONV_XML_TEXT_DECORATOR));
rb_define_const(rb_cEncodingConverter, "XML_ATTR_CONTENT_ENCODER", INT2FIX(ECONV_XML_ATTR_CONTENT_ENCODER)); rb_define_const(rb_cEncodingConverter, "XML_ATTR_CONTENT_DECORATOR", INT2FIX(ECONV_XML_ATTR_CONTENT_DECORATOR));
rb_define_const(rb_cEncodingConverter, "XML_ATTR_QUOTE_ENCODER", INT2FIX(ECONV_XML_ATTR_QUOTE_ENCODER)); rb_define_const(rb_cEncodingConverter, "XML_ATTR_QUOTE_DECORATOR", INT2FIX(ECONV_XML_ATTR_QUOTE_DECORATOR));
rb_define_method(rb_eConversionUndefined, "source_encoding_name", ecerr_source_encoding_name, 0); rb_define_method(rb_eConversionUndefined, "source_encoding_name", ecerr_source_encoding_name, 0);
rb_define_method(rb_eConversionUndefined, "destination_encoding_name", ecerr_destination_encoding_name, 0); rb_define_method(rb_eConversionUndefined, "destination_encoding_name", ecerr_destination_encoding_name, 0);