* transcode.c: add "Error" suffix for Encoding exception classes.

  a patch from Tadashi Saito <shiba at mail2.accsnet.ne.jp> in
  [ruby-dev:36346].

* encoding.c (Init_Encoding): rename EncodingCompatibilityError to
  Encoding::CompatibilityError.  [ruby-dev:36366]

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

1 files changed, 41 insertions, 41 deletions

diff --git a/transcode.c b/transcode.c
index c3c08d309f..cd77ddbacd 100644
--- a/transcode.c
+++ b/transcode.c
@@ -14,9 +14,9 @@
 #include "transcode_data.h"
 #include <ctype.h>
 
-VALUE rb_eConversionUndefined;
-VALUE rb_eInvalidByteSequence;
-VALUE rb_eNoConverter;
+VALUE rb_eConversionUndefinedError;
+VALUE rb_eInvalidByteSequenceError;
+VALUE rb_eNoConverterError;
 
 VALUE rb_cEncodingConverter;
 
@@ -1960,7 +1960,7 @@ rb_econv_open_exc(const char *sname, const char *dname, int ecflags)
     mesg = rb_str_new_cstr("code converter not found (");
     econv_description(sname, dname, ecflags, mesg);
     rb_str_cat2(mesg, ")");
-    exc = rb_exc_new3(rb_eNoConverter, mesg);
+    exc = rb_exc_new3(rb_eNoConverterError, mesg);
     return exc;
 }
 
@@ -1997,7 +1997,7 @@ make_econv_exception(rb_econv_t *ec)
                     ec->last_error.source_encoding);
         }
 
-        exc = rb_exc_new3(rb_eInvalidByteSequence, mesg);
+        exc = rb_exc_new3(rb_eInvalidByteSequenceError, mesg);
         rb_ivar_set(exc, rb_intern("error_bytes"), bytes);
         rb_ivar_set(exc, rb_intern("readagain_bytes"), bytes2);
         rb_ivar_set(exc, rb_intern("incomplete_input"), ec->last_error.result == econv_incomplete_input ? Qtrue : Qfalse);
@@ -2023,7 +2023,7 @@ make_econv_exception(rb_econv_t *ec)
                 StringValueCStr(dumped),
                 ec->last_error.source_encoding,
                 ec->last_error.destination_encoding);
-        exc = rb_exc_new3(rb_eConversionUndefined, mesg);
+        exc = rb_exc_new3(rb_eConversionUndefinedError, mesg);
         idx = rb_enc_find_index(ec->last_error.source_encoding);
         if (0 <= idx)
             rb_enc_associate_index(bytes, idx);
@@ -3381,8 +3381,8 @@ econv_primitive_convert(int argc, VALUE *argv, VALUE self)
  *   puts ec.finish.dump                #=> "\e(B".force_encoding("ISO-2022-JP")
  *
  * If a conversion error occur,
- * Encoding::ConversionUndefined or
- * Encoding::InvalidByteSequence is raised.
+ * Encoding::ConversionUndefinedError or
+ * Encoding::InvalidByteSequenceError is raised.
  *
  */
 static VALUE
@@ -3634,7 +3634,7 @@ econv_insert_output(VALUE self, VALUE string)
  * some bytes are buffered to be converted later.
  * The latter bytes can be put back.
  * It can be observed by
- * Encoding::InvalidByteSequence#readagain_bytes and
+ * Encoding::InvalidByteSequenceError#readagain_bytes and
  * Encoding::Converter#primitive_errinfo.
  *
  *   ec = Encoding::Converter.new("utf-16le", "iso-8859-1")
@@ -3683,14 +3683,14 @@ econv_putback(int argc, VALUE *argv, VALUE self)
  * It returns nil if the last conversion is not an error. 
  *
  * "error" means that
- * Encoding::InvalidByteSequence and Encoding::ConversionUndefined for
+ * Encoding::InvalidByteSequenceError and Encoding::ConversionUndefinedError for
  * Encoding::Converter#convert and
  * :invalid_byte_sequence, :incomplete_input and :undefined_conversion for
  * Encoding::Converter#primitive_convert.
  *
  *  ec = Encoding::Converter.new("utf-8", "iso-8859-1")
  *  p ec.primitive_convert(src="\xf1abcd", dst="")       #=> :invalid_byte_sequence
- *  p ec.last_error      #=> #<Encoding::InvalidByteSequence: "\xF1" followed by "a" on UTF-8>
+ *  p ec.last_error      #=> #<Encoding::InvalidByteSequenceError: "\xF1" followed by "a" on UTF-8>
  *  p ec.primitive_convert(src, dst, nil, 1)             #=> :destination_buffer_full
  *  p ec.last_error      #=> nil
  *
@@ -3728,7 +3728,7 @@ econv_get_replacement(VALUE self)
 
     ret = make_replacement(ec);
     if (ret == -1) {
-        rb_raise(rb_eConversionUndefined, "replacement character setup failed");
+        rb_raise(rb_eConversionUndefinedError, "replacement character setup failed");
     }
 
     enc = rb_enc_find(ec->replacement_enc);
@@ -3762,8 +3762,8 @@ econv_set_replacement(VALUE self, VALUE arg)
             rb_enc_name(enc));
 
     if (ret == -1) {
-        /* xxx: rb_eInvalidByteSequence? */
-        rb_raise(rb_eConversionUndefined, "replacement character setup failed");
+        /* xxx: rb_eInvalidByteSequenceError? */
+        rb_raise(rb_eConversionUndefinedError, "replacement character setup failed");
     }
 
     return arg;
@@ -3804,7 +3804,7 @@ ecerr_source_encoding_name(VALUE self)
  *  ec = Encoding::Converter.new("ISO-8859-1", "EUC-JP") # ISO-8859-1 -> UTF-8 -> EUC-JP
  *  begin
  *    ec.convert("\xa0") # NO-BREAK SPACE, which is available in UTF-8 but not in EUC-JP.
- *  rescue Encoding::ConversionUndefined
+ *  rescue Encoding::ConversionUndefinedError
  *    p $!.source_encoding              #=> #<Encoding:UTF-8>
  *    p $!.destination_encoding         #=> #<Encoding:EUC-JP>
  *    p $!.source_encoding_name         #=> "UTF-8"
@@ -3846,12 +3846,12 @@ ecerr_destination_encoding(VALUE self)
  * call-seq:
  *   ecerr.error_char         -> string
  *
- * returns the one-character string which cause Encoding::ConversionUndefined.
+ * returns the one-character string which cause Encoding::ConversionUndefinedError.
  *
  *  ec = Encoding::Converter.new("ISO-8859-1", "EUC-JP")
  *  begin
  *    ec.convert("\xa0")
- *  rescue Encoding::ConversionUndefined
+ *  rescue Encoding::ConversionUndefinedError
  *    puts $!.error_char.dump   #=> "\xC2\xA0"
  *    p $!.error_char.encoding  #=> #<Encoding:UTF-8>
  *  end
@@ -3867,13 +3867,13 @@ ecerr_error_char(VALUE self)
  * call-seq:
  *   ecerr.error_bytes         -> string
  *
- * returns the discarded bytes when Encoding::InvalidByteSequence occur.
+ * returns the discarded bytes when Encoding::InvalidByteSequenceError occur.
  *
  *  ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1")
  *  begin
  *    ec.convert("abc\xA1\xFFdef")
- *  rescue Encoding::InvalidByteSequence
- *    p $!      #=> #<Encoding::InvalidByteSequence: "\xA1" followed by "\xFF" on EUC-JP>
+ *  rescue Encoding::InvalidByteSequenceError
+ *    p $!      #=> #<Encoding::InvalidByteSequenceError: "\xA1" followed by "\xFF" on EUC-JP>
  *    puts $!.error_bytes.dump          #=> "\xA1"
  *    puts $!.readagain_bytes.dump      #=> "\xFF"
  *  end
@@ -3888,7 +3888,7 @@ ecerr_error_bytes(VALUE self)
  * call-seq:
  *   ecerr.readagain_bytes         -> string
  *
- * returns the bytes to be read again when Encoding::InvalidByteSequence occur.
+ * returns the bytes to be read again when Encoding::InvalidByteSequenceError occur.
  */
 static VALUE
 ecerr_readagain_bytes(VALUE self)
@@ -3907,16 +3907,16 @@ ecerr_readagain_bytes(VALUE self)
  *
  *  begin
  *    ec.convert("abc\xA1z")
- *  rescue Encoding::InvalidByteSequence
- *    p $!      #=> #<Encoding::InvalidByteSequence: "\xA1" followed by "z" on EUC-JP>
+ *  rescue Encoding::InvalidByteSequenceError
+ *    p $!      #=> #<Encoding::InvalidByteSequenceError: "\xA1" followed by "z" on EUC-JP>
  *    p $!.incomplete_input?    #=> false
  *  end
  *
  *  begin
  *    ec.convert("abc\xA1")
  *    ec.finish
- *  rescue Encoding::InvalidByteSequence
- *    p $!      #=> #<Encoding::InvalidByteSequence: incomplete "\xA1" on EUC-JP>
+ *  rescue Encoding::InvalidByteSequenceError
+ *    p $!      #=> #<Encoding::InvalidByteSequenceError: incomplete "\xA1" on EUC-JP>
  *    p $!.incomplete_input?    #=> true
  *  end
  */
@@ -3931,9 +3931,9 @@ extern void Init_newline(void);
 void
 Init_transcode(void)
 {
-    rb_eConversionUndefined = rb_define_class_under(rb_cEncoding, "ConversionUndefined", rb_eStandardError);
-    rb_eInvalidByteSequence = rb_define_class_under(rb_cEncoding, "InvalidByteSequence", rb_eStandardError);
-    rb_eNoConverter = rb_define_class_under(rb_cEncoding, "NoConverter", rb_eStandardError);
+    rb_eConversionUndefinedError = rb_define_class_under(rb_cEncoding, "ConversionUndefinedError", rb_eStandardError);
+    rb_eInvalidByteSequenceError = rb_define_class_under(rb_cEncoding, "InvalidByteSequenceError", rb_eStandardError);
+    rb_eNoConverterError = rb_define_class_under(rb_cEncoding, "NoConverterError", rb_eStandardError);
 
     transcoder_table = st_init_strcasetable();
 
@@ -3993,19 +3993,19 @@ Init_transcode(void)
     rb_define_const(rb_cEncodingConverter, "XML_ATTR_CONTENT_DECORATOR", INT2FIX(ECONV_XML_ATTR_CONTENT_DECORATOR));
     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, "destination_encoding_name", ecerr_destination_encoding_name, 0);
-    rb_define_method(rb_eConversionUndefined, "source_encoding", ecerr_source_encoding, 0);
-    rb_define_method(rb_eConversionUndefined, "destination_encoding", ecerr_destination_encoding, 0);
-    rb_define_method(rb_eConversionUndefined, "error_char", ecerr_error_char, 0);
-
-    rb_define_method(rb_eInvalidByteSequence, "source_encoding_name", ecerr_source_encoding_name, 0);
-    rb_define_method(rb_eInvalidByteSequence, "destination_encoding_name", ecerr_destination_encoding_name, 0);
-    rb_define_method(rb_eInvalidByteSequence, "source_encoding", ecerr_source_encoding, 0);
-    rb_define_method(rb_eInvalidByteSequence, "destination_encoding", ecerr_destination_encoding, 0);
-    rb_define_method(rb_eInvalidByteSequence, "error_bytes", ecerr_error_bytes, 0);
-    rb_define_method(rb_eInvalidByteSequence, "readagain_bytes", ecerr_readagain_bytes, 0);
-    rb_define_method(rb_eInvalidByteSequence, "incomplete_input?", ecerr_incomplete_input, 0);
+    rb_define_method(rb_eConversionUndefinedError, "source_encoding_name", ecerr_source_encoding_name, 0);
+    rb_define_method(rb_eConversionUndefinedError, "destination_encoding_name", ecerr_destination_encoding_name, 0);
+    rb_define_method(rb_eConversionUndefinedError, "source_encoding", ecerr_source_encoding, 0);
+    rb_define_method(rb_eConversionUndefinedError, "destination_encoding", ecerr_destination_encoding, 0);
+    rb_define_method(rb_eConversionUndefinedError, "error_char", ecerr_error_char, 0);
+
+    rb_define_method(rb_eInvalidByteSequenceError, "source_encoding_name", ecerr_source_encoding_name, 0);
+    rb_define_method(rb_eInvalidByteSequenceError, "destination_encoding_name", ecerr_destination_encoding_name, 0);
+    rb_define_method(rb_eInvalidByteSequenceError, "source_encoding", ecerr_source_encoding, 0);
+    rb_define_method(rb_eInvalidByteSequenceError, "destination_encoding", ecerr_destination_encoding, 0);
+    rb_define_method(rb_eInvalidByteSequenceError, "error_bytes", ecerr_error_bytes, 0);
+    rb_define_method(rb_eInvalidByteSequenceError, "readagain_bytes", ecerr_readagain_bytes, 0);
+    rb_define_method(rb_eInvalidByteSequenceError, "incomplete_input?", ecerr_incomplete_input, 0);
 
     Init_newline();
 }