rdx 0.9.0.pre

data/examples/ruby-2.0.0-p0/install/core/diffs/transcode.c.diff

@@ -0,0 +1,435 @@
+--- core/orig/transcode.c	2015-06-11 07:51:44 +0000
++++ core/patched/transcode.c	2015-06-25 17:35:23 +0000
+@@ -2951,8 +2951,8 @@
+  * can represents exactly the same characters as the given ASCII incompatible encoding.
+  * So, no conversion undefined error occurs when converting between the two encodings.
+  *
+- *   Encoding::Converter.asciicompat_encoding("ISO-2022-JP") #=> #<Encoding:stateless-ISO-2022-JP>
+- *   Encoding::Converter.asciicompat_encoding("UTF-16BE") #=> #<Encoding:UTF-8>
++ *   Encoding::Converter.asciicompat_encoding("ISO-2022-JP") # > #<Encoding:stateless-ISO-2022-JP>
++ *   Encoding::Converter.asciicompat_encoding("UTF-16BE") #=> Encoding::UTF_8
+  *   Encoding::Converter.asciicompat_encoding("UTF-8") #=> nil
+  *
+  */
+@@ -3099,23 +3099,21 @@
+  *
+  *  Returns a conversion path.
+  *
+- *   p Encoding::Converter.search_convpath("ISO-8859-1", "EUC-JP")
+- *   #=> [[#<Encoding:ISO-8859-1>, #<Encoding:UTF-8>],
+- *   #    [#<Encoding:UTF-8>, #<Encoding:EUC-JP>]]
+- *
+- *   p Encoding::Converter.search_convpath("ISO-8859-1", "EUC-JP", universal_newline: true)
+- *   or
+- *   p Encoding::Converter.search_convpath("ISO-8859-1", "EUC-JP", newline: :universal)
+- *   #=> [[#<Encoding:ISO-8859-1>, #<Encoding:UTF-8>],
+- *   #    [#<Encoding:UTF-8>, #<Encoding:EUC-JP>],
++ *   Encoding::Converter.search_convpath("ISO-8859-1", "EUC-JP")
++ *   #=> [[Encoding::ISO_8859_1, Encoding::UTF_8],
++ *   #    [Encoding::UTF_8, Encoding::EUC_JP]]
++ *
++ *   Encoding::Converter.search_convpath("ISO-8859-1", "EUC-JP", universal_newline: true)
++ *   #=> [[Encoding::ISO_8859_1, Encoding::UTF_8],
++ *   #    [Encoding::UTF_8, Encoding::EUC_JP],
+  *   #    "universal_newline"]
+  *
+- *   p Encoding::Converter.search_convpath("ISO-8859-1", "UTF-32BE", universal_newline: true)
+- *   or
+- *   p Encoding::Converter.search_convpath("ISO-8859-1", "UTF-32BE", newline: :universal)
+- *   #=> [[#<Encoding:ISO-8859-1>, #<Encoding:UTF-8>],
++ *  or
++ * 
++ *   Encoding::Converter.search_convpath("ISO-8859-1", "UTF-32BE", newline: :universal)
++ *   #=> [[Encoding::ISO_8859_1, Encoding::UTF_8],
+  *   #    "universal_newline",
+- *   #    [#<Encoding:UTF-8>, #<Encoding:UTF-32BE>]]
++ *   #    [Encoding::UTF_8, Encoding::UTF_32BE]]
+  */
+ static VALUE
+ econv_s_search_convpath(int argc, VALUE *argv, VALUE klass)
+@@ -3251,6 +3249,7 @@
+  *   Encoding::Converter.new(convpath)
+  *
+  * possible options elements:
++ * :rdx: off -
+  *   hash form:
+  *     :invalid => nil            # raise error on invalid byte sequence (default)
+  *     :invalid => :replace       # replace invalid byte sequence
+@@ -3335,20 +3334,20 @@
+  *
+  *   # Usually, decorators such as newline conversion are inserted last.
+  *   ec = Encoding::Converter.new("UTF-16BE", "UTF-8", :universal_newline => true)
+- *   p ec.convpath #=> [[#<Encoding:UTF-16BE>, #<Encoding:UTF-8>],
+- *                 #    "universal_newline"]
++ *   ec.convpath #=> [[Encoding::UTF_16BE, Encoding::UTF_8],
++ *               #    "universal_newline"]
+  *
+  *   # But, if the last encoding is ASCII incompatible,
+  *   # decorators are inserted before the last conversion.
+  *   ec = Encoding::Converter.new("UTF-8", "UTF-16BE", :crlf_newline => true)
+- *   p ec.convpath #=> ["crlf_newline",
+- *                 #    [#<Encoding:UTF-8>, #<Encoding:UTF-16BE>]]
++ *   ec.convpath #=> ["crlf_newline",
++ *               #    [Encoding::UTF_8, Encoding::UTF_16BE]]
+  *
+  *   # Conversion path can be specified directly.
+  *   ec = Encoding::Converter.new(["universal_newline", ["EUC-JP", "UTF-8"], ["UTF-8", "UTF-16BE"]])
+- *   p ec.convpath #=> ["universal_newline",
+- *                 #    [#<Encoding:EUC-JP>, #<Encoding:UTF-8>],
+- *                 #    [#<Encoding:UTF-8>, #<Encoding:UTF-16BE>]]
++ *   ec.convpath #=> ["universal_newline",
++ *               #    [Encoding::EUC_JP, Encoding::UTF_8],
++ *               #    [Encoding::UTF_8, Encoding::UTF_16BE]]
+  */
+ static VALUE
+ econv_init(int argc, VALUE *argv, VALUE self)
+@@ -3401,7 +3400,7 @@
+  * Returns a printable version of <i>ec</i>
+  *
+  *   ec = Encoding::Converter.new("iso-8859-1", "utf-8")
+- *   puts ec.inspect    #=> #<Encoding::Converter: ISO-8859-1 to UTF-8>
++ *   ec.inspect    #=> "#<Encoding::Converter: ISO-8859-1 to UTF-8>"
+  *
+  */
+ static VALUE
+@@ -3475,9 +3474,9 @@
+  * The result is an array of conversions.
+  *
+  *   ec = Encoding::Converter.new("ISO-8859-1", "EUC-JP", crlf_newline: true)
+- *   p ec.convpath
+- *   #=> [[#<Encoding:ISO-8859-1>, #<Encoding:UTF-8>],
+- *   #    [#<Encoding:UTF-8>, #<Encoding:EUC-JP>],
++ *   ec.convpath
++ *   #=> [[Encoding::ISO_8859_1, Encoding::UTF_8],
++ *   #    [Encoding::UTF_8, Encoding::EUC_JP],
+  *   #    "crlf_newline"]
+  *
+  * Each element of the array is a pair of encodings or a string.
+@@ -3570,6 +3569,7 @@
+  *   ec.primitive_convert(source_buffer, destination_buffer, destination_byteoffset, destination_bytesize, opt) -> symbol
+  *
+  * possible opt elements:
++ * :rdx: off -
+  *   hash form:
+  *     :partial_input => true           # source buffer may be part of larger source
+  *     :after_output => true            # stop conversion after output before input
+@@ -3578,6 +3578,7 @@
+  *     Encoding::Converter::AFTER_OUTPUT
+  *
+  * possible results:
++ * :rdx: off -
+  *    :invalid_byte_sequence
+  *    :incomplete_input
+  *    :undefined_conversion
+@@ -3643,17 +3644,30 @@
+  * example:
+  *   ec = Encoding::Converter.new("UTF-8", "UTF-16BE")
+  *   ret = ec.primitive_convert(src="pi", dst="", nil, 100)
+- *   p [ret, src, dst] #=> [:finished, "", "\x00p\x00i"]
++ *   ret #=> :finished
++ *   src #=> ""
++ *   dst #=> "\x00p\x00i"
+  *
+  *   ec = Encoding::Converter.new("UTF-8", "UTF-16BE")
+  *   ret = ec.primitive_convert(src="pi", dst="", nil, 1)
+- *   p [ret, src, dst] #=> [:destination_buffer_full, "i", "\x00"]
++ *   ret #=> :destination_buffer_full
++ *   src #=> "i"
++ *   dst #=> "\x00"
++ * 
+  *   ret = ec.primitive_convert(src, dst="", nil, 1)
+- *   p [ret, src, dst] #=> [:destination_buffer_full, "", "p"]
++ *   ret #=> :destination_buffer_full
++ *   src #=> ""
++ *   dst #=> "p"
++ * 
+  *   ret = ec.primitive_convert(src, dst="", nil, 1)
+- *   p [ret, src, dst] #=> [:destination_buffer_full, "", "\x00"]
++ *   ret #=> :destination_buffer_full
++ *   src #=> ""
++ *   dst #=> "\x00"
++ * 
+  *   ret = ec.primitive_convert(src, dst="", nil, 1)
+- *   p [ret, src, dst] #=> [:finished, "", "i"]
++ *   ret #=> :finished
++ *   src #=> ""
++ *   dst #=> "i"
+  *
+  */
+ static VALUE
+@@ -3777,19 +3791,19 @@
+  * finish method should be used last.
+  *
+  *   ec = Encoding::Converter.new("utf-8", "euc-jp")
+- *   puts ec.convert("\u3042").dump     #=> "\xA4\xA2"
+- *   puts ec.finish.dump                #=> ""
++ *   ec.convert("\u3042")     #=> "\xA4\xA2"
++ *   ec.finish                #=> ""
+  *
+  *   ec = Encoding::Converter.new("euc-jp", "utf-8")
+- *   puts ec.convert("\xA4").dump       #=> ""
+- *   puts ec.convert("\xA2").dump       #=> "\xE3\x81\x82"
+- *   puts ec.finish.dump                #=> ""
+- *
++ *   ec.convert("\xA4")       #=> ""
++ *   ec.convert("\xA2")       #=> "\xE3\x81\x82"
++ *   ec.finish                #=> ""
++ * 
+  *   ec = Encoding::Converter.new("utf-8", "iso-2022-jp")
+- *   puts ec.convert("\xE3").dump       #=> "".force_encoding("ISO-2022-JP")
+- *   puts ec.convert("\x81").dump       #=> "".force_encoding("ISO-2022-JP")
+- *   puts ec.convert("\x82").dump       #=> "\e$B$\"".force_encoding("ISO-2022-JP")
+- *   puts ec.finish.dump                #=> "\e(B".force_encoding("ISO-2022-JP")
++ *   ec.convert("\xE3")       #=> "".force_encoding("ISO-2022-JP")
++ *   ec.convert("\x81")       #=> "".force_encoding("ISO-2022-JP")
++ *   ec.convert("\x82")       #=> "\e$B$\"".force_encoding("ISO-2022-JP")
++ *   ec.finish                #=> "\e(B".force_encoding("ISO-2022-JP")
+  *
+  * If a conversion error occur,
+  * Encoding::UndefinedConversionError or
+@@ -3847,8 +3861,8 @@
+  * It returns the last part of the converted string.
+  *
+  *   ec = Encoding::Converter.new("utf-8", "iso-2022-jp")
+- *   p ec.convert("\u3042")     #=> "\e$B$\""
+- *   p ec.finish                #=> "\e(B"
++ *   ec.convert("\u3042")     #=> "\e$B$\""
++ *   ec.finish                #=> "\e(B"
+  */
+ static VALUE
+ econv_finish(VALUE self)
+@@ -3889,6 +3903,7 @@
+  *
+  * primitive_errinfo returns important information regarding the last error
+  * as a 5-element array:
++ * :rdx: off -
+  *
+  *   [result, enc1, enc2, error_bytes, readagain_bytes]
+  *
+@@ -3911,28 +3926,28 @@
+  *   # \xff is invalid as EUC-JP.
+  *   ec = Encoding::Converter.new("EUC-JP", "Shift_JIS")
+  *   ec.primitive_convert(src="\xff", dst="", nil, 10)
+- *   p ec.primitive_errinfo
+- *   #=> [:invalid_byte_sequence, "EUC-JP", "UTF-8", "\xFF", ""]
++ *   ec.primitive_errinfo
++ *   #=> [:invalid_byte_sequence, "EUC-JP", "Shift_JIS", "\xFF", ""]
+  *
+  *   # HIRAGANA LETTER A (\xa4\xa2 in EUC-JP) is not representable in ISO-8859-1.
+  *   # Since this error is occur in UTF-8 to ISO-8859-1 conversion,
+  *   # error_bytes is HIRAGANA LETTER A in UTF-8 (\xE3\x81\x82).
+  *   ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1")
+  *   ec.primitive_convert(src="\xa4\xa2", dst="", nil, 10)
+- *   p ec.primitive_errinfo
++ *   ec.primitive_errinfo
+  *   #=> [:undefined_conversion, "UTF-8", "ISO-8859-1", "\xE3\x81\x82", ""]
+  *
+  *   # partial character is invalid
+  *   ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1")
+  *   ec.primitive_convert(src="\xa4", dst="", nil, 10)
+- *   p ec.primitive_errinfo
++ *   ec.primitive_errinfo
+  *   #=> [:incomplete_input, "EUC-JP", "UTF-8", "\xA4", ""]
+  *
+  *   # Encoding::Converter::PARTIAL_INPUT prevents invalid errors by
+  *   # partial characters.
+  *   ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1")
+  *   ec.primitive_convert(src="\xa4", dst="", nil, 10, Encoding::Converter::PARTIAL_INPUT)
+- *   p ec.primitive_errinfo
++ *   ec.primitive_errinfo
+  *   #=> [:source_buffer_empty, nil, nil, nil, nil]
+  *
+  *   # \xd8\x00\x00@ is invalid as UTF-16BE because
+@@ -3943,18 +3958,18 @@
+  *   # Since the byte is buffered in ec, it is dropped from src.
+  *   ec = Encoding::Converter.new("UTF-16BE", "UTF-8")
+  *   ec.primitive_convert(src="\xd8\x00\x00@", dst="", nil, 10)
+- *   p ec.primitive_errinfo
++ *   ec.primitive_errinfo
+  *   #=> [:invalid_byte_sequence, "UTF-16BE", "UTF-8", "\xD8\x00", "\x00"]
+- *   p src
++ *   src
+  *   #=> "@"
+  *
+  *   # Similar to UTF-16BE, \x00\xd8@\x00 is invalid as UTF-16LE.
+  *   # The problem is detected by 4th byte.
+  *   ec = Encoding::Converter.new("UTF-16LE", "UTF-8")
+  *   ec.primitive_convert(src="\x00\xd8@\x00", dst="", nil, 10)
+- *   p ec.primitive_errinfo
++ *   ec.primitive_errinfo
+  *   #=> [:invalid_byte_sequence, "UTF-16LE", "UTF-8", "\x00\xD8", "@\x00"]
+- *   p src
++ *   src
+  *   #=> ""
+  *
+  */
+@@ -4000,20 +4015,24 @@
+  *  ec = Encoding::Converter.new("utf-8", "iso-8859-1")
+  *  src = "HIRAGANA LETTER A is \u{3042}."
+  *  dst = ""
+- *  p ec.primitive_convert(src, dst)    #=> :undefined_conversion
+- *  puts "[#{dst.dump}, #{src.dump}]"   #=> ["HIRAGANA LETTER A is ", "."]
++ *  ec.primitive_convert(src, dst)    #=> :undefined_conversion
++ *  src #=> "."
++ *  dst #=> "HIRAGANA LETTER A is "
+  *  ec.insert_output("<err>")
+- *  p ec.primitive_convert(src, dst)    #=> :finished
+- *  puts "[#{dst.dump}, #{src.dump}]"   #=> ["HIRAGANA LETTER A is <err>.", ""]
++ *  ec.primitive_convert(src, dst)    #=> :finished
++ *  src #=> ""
++ *  dst #=> "HIRAGANA LETTER A is <err>."
+  *
+  *  ec = Encoding::Converter.new("utf-8", "iso-2022-jp")
+  *  src = "\u{306F 3041 3068 2661 3002}" # U+2661 is not representable in iso-2022-jp
+  *  dst = ""
+- *  p ec.primitive_convert(src, dst)    #=> :undefined_conversion
+- *  puts "[#{dst.dump}, #{src.dump}]"   #=> ["\e$B$O$!$H".force_encoding("ISO-2022-JP"), "\xE3\x80\x82"]
+- *  ec.insert_output "?"                # state change required to output "?".
+- *  p ec.primitive_convert(src, dst)    #=> :finished
+- *  puts "[#{dst.dump}, #{src.dump}]"   #=> ["\e$B$O$!$H\e(B?\e$B!#\e(B".force_encoding("ISO-2022-JP"), ""]
++ *  ec.primitive_convert(src, dst)    #=> :undefined_conversion
++ *  src #=> "\xE3\x80\x82"
++ *  dst #=> "\e$B$O$!$H".force_encoding("ISO-2022-JP")
++ *  ec.insert_output "?"              # state change required to output "?".
++ *  ec.primitive_convert(src, dst)    #=> :finished
++ *  src #=> ""
++ *  dst #=> "\e$B$O$!$H\e(B?\e$B!#\e(B".force_encoding("ISO-2022-JP")
+  *
+  */
+ static VALUE
+@@ -4038,7 +4057,7 @@
+ }
+ 
+ /*
+- * call-seq
++ * call-seq:
+  *   ec.putback                    -> string
+  *   ec.putback(max_numbytes)      -> string
+  *
+@@ -4055,10 +4074,10 @@
+  *   ec = Encoding::Converter.new("utf-16le", "iso-8859-1")
+  *   src = "\x00\xd8\x61\x00"
+  *   dst = ""
+- *   p ec.primitive_convert(src, dst)   #=> :invalid_byte_sequence
+- *   p ec.primitive_errinfo     #=> [:invalid_byte_sequence, "UTF-16LE", "UTF-8", "\x00\xD8", "a\x00"]
+- *   p ec.putback               #=> "a\x00"
+- *   p ec.putback               #=> ""          # no more bytes to put back
++ *   ec.primitive_convert(src, dst)   #=> :invalid_byte_sequence
++ *   ec.primitive_errinfo     #=> [:invalid_byte_sequence, "UTF-16LE", "UTF-8", "\x00\xD8", "a\x00"]
++ *   ec.putback               #=> "a\x00"
++ *   ec.putback               #=> ""          # no more bytes to put back
+  *
+  */
+ static VALUE
+@@ -4104,10 +4123,10 @@
+  * 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::InvalidByteSequenceError: "\xF1" followed by "a" on UTF-8>
+- *  p ec.primitive_convert(src, dst, nil, 1)             #=> :destination_buffer_full
+- *  p ec.last_error      #=> nil
++ *  ec.primitive_convert(src="\xf1abcd", dst="")       #=> :invalid_byte_sequence
++ *  ec.last_error      # > #<Encoding::InvalidByteSequenceError: "\xF1" followed by "a" on UTF-8>
++ *  ec.primitive_convert(src, dst, nil, 1)             #=> :destination_buffer_full
++ *  ec.last_error      #=> nil
+  *
+  */
+ static VALUE
+@@ -4129,10 +4148,10 @@
+  * Returns the replacement string.
+  *
+  *  ec = Encoding::Converter.new("euc-jp", "us-ascii")
+- *  p ec.replacement    #=> "?"
++ *  ec.replacement    #=> "?"
+  *
+  *  ec = Encoding::Converter.new("euc-jp", "utf-8")
+- *  p ec.replacement    #=> "\uFFFD"
++ *  ec.replacement    #=> "\uFFFD"
+  */
+ static VALUE
+ econv_get_replacement(VALUE self)
+@@ -4158,7 +4177,7 @@
+  *
+  *  ec = Encoding::Converter.new("utf-8", "us-ascii", :undef => :replace)
+  *  ec.replacement = "<undef>"
+- *  p ec.convert("a \u3042 b")      #=> "a <undef> b"
++ *  ec.convert("a \u3042 b")      #=> "a <undef> b"
+  */
+ static VALUE
+ econv_set_replacement(VALUE self, VALUE arg)
+@@ -4225,13 +4244,13 @@
+  *  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::UndefinedConversionError
+- *    p $!.source_encoding              #=> #<Encoding:UTF-8>
+- *    p $!.destination_encoding         #=> #<Encoding:EUC-JP>
+- *    p $!.source_encoding_name         #=> "UTF-8"
+- *    p $!.destination_encoding_name    #=> "EUC-JP"
++ *  rescue Encoding::UndefinedConversionError => err
+  *  end
+- *
++ *  err.source_encoding              #=> Encoding::UTF_8
++ *  err.destination_encoding         #=> Encoding::EUC_JP
++ *  err.source_encoding_name         #=> "UTF-8"
++ *  err.destination_encoding_name    #=> "EUC-JP"
++ * 
+  */
+ static VALUE
+ ecerr_source_encoding(VALUE self)
+@@ -4272,10 +4291,10 @@
+  *  ec = Encoding::Converter.new("ISO-8859-1", "EUC-JP")
+  *  begin
+  *    ec.convert("\xa0")
+- *  rescue Encoding::UndefinedConversionError
+- *    puts $!.error_char.dump   #=> "\xC2\xA0"
+- *    p $!.error_char.encoding  #=> #<Encoding:UTF-8>
++ *  rescue Encoding::UndefinedConversionError => err
+  *  end
++ *  err.error_char           #=> "\xC2\xA0"
++ *  err.error_char.encoding  #=> Encoding::UTF_8
+  *
+  */
+ static VALUE
+@@ -4293,11 +4312,11 @@
+  *  ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1")
+  *  begin
+  *    ec.convert("abc\xA1\xFFdef")
+- *  rescue Encoding::InvalidByteSequenceError
+- *    p $!      #=> #<Encoding::InvalidByteSequenceError: "\xA1" followed by "\xFF" on EUC-JP>
+- *    puts $!.error_bytes.dump          #=> "\xA1"
+- *    puts $!.readagain_bytes.dump      #=> "\xFF"
++ *  rescue Encoding::InvalidByteSequenceError => err
+  *  end
++ *  err   # > #<Encoding::InvalidByteSequenceError: "\xA1" followed by "\xFF" on EUC-JP>
++ *  err.error_bytes          #=> "\xA1"
++ *  err.readagain_bytes      #=> "\xFF"
+  */
+ static VALUE
+ ecerr_error_bytes(VALUE self)
+@@ -4328,18 +4347,18 @@
+  *
+  *  begin
+  *    ec.convert("abc\xA1z")
+- *  rescue Encoding::InvalidByteSequenceError
+- *    p $!      #=> #<Encoding::InvalidByteSequenceError: "\xA1" followed by "z" on EUC-JP>
+- *    p $!.incomplete_input?    #=> false
++ *  rescue Encoding::InvalidByteSequenceError => err
+  *  end
++ *  err # > #<Encoding::InvalidByteSequenceError: "\xA1" followed by "z" on EUC-JP>
++ *  err.incomplete_input?    #=> false
+  *
+  *  begin
+  *    ec.convert("abc\xA1")
+  *    ec.finish
+- *  rescue Encoding::InvalidByteSequenceError
+- *    p $!      #=> #<Encoding::InvalidByteSequenceError: incomplete "\xA1" on EUC-JP>
+- *    p $!.incomplete_input?    #=> true
++ *  rescue Encoding::InvalidByteSequenceError => err
+  *  end
++ *  err # > #<Encoding::InvalidByteSequenceError: incomplete "\xA1" on EUC-JP>
++ *  err.incomplete_input?    #=> true
+  */
+ static VALUE
+ ecerr_incomplete_input(VALUE self)

data/examples/ruby-2.0.0-p0/install/core/diffs/variable.c.diff

@@ -0,0 +1,62 @@
+--- core/orig/variable.c	2015-06-11 07:51:44 +0000
++++ core/patched/variable.c	2015-06-20 08:57:47 +0000
+@@ -630,6 +630,9 @@
+  *     trace_var :$_, proc {|v| puts "$_ is now '#{v}'" }
+  *     $_ = "hello"
+  *     $_ = ' there'
++ *-- rdx
++ *     untrace_var :$_
++ *++
+  *
+  *  <em>produces:</em>
+  *
+@@ -1482,11 +1485,13 @@
+  * returns a value to be used for that constant. The
+  * following code is an example of the same:
+  *
+- *   def Foo.const_missing(name)
+- *     name # return the constant name as Symbol
++ *   class Foo
++ *     def self.const_missing(name)
++ *       name # return the constant name as Symbol
++ *     end
+  *   end
+  *
+- *   Foo::UNDEFINED_CONST    #=> :UNDEFINED_CONST: symbol returned
++ *   Foo::UNDEFINED_CONST    #=> :UNDEFINED_CONST # symbol returned
+  *
+  * In the next example when a reference is made to an undefined constant,
+  * it attempts to load a file whose name is the lowercase version of the
+@@ -1494,6 +1499,10 @@
+  * <code>fred.rb</code>).  If found, it returns the loaded class. It
+  * therefore implements an autoload feature similar to Kernel#autoload and
+  * Module#autoload.
++ * 
++ *-- rdx
++ *   orig_obj_cnst_missing = Object.method(:const_missing)
++ *++
+  *
+  *   def Object.const_missing(name)
+  *     @looked_for ||= {}
+@@ -1506,6 +1515,10 @@
+  *     return klass if klass
+  *     raise "Class not found: #{name}"
+  *   end
++ * 
++ *-- rdx
++ *   RDX::Util.restore_singleton_method Object, orig_obj_cnst_missing
++ *++
+  *
+  */
+ 
+@@ -2031,8 +2044,8 @@
+  *  modules (example at start of section), unless the <i>inherit</i>
+  *  parameter is set to <code>false</code>.
+  *
+- *    IO.constants.include?(:SYNC)        #=> true
+- *    IO.constants(false).include?(:SYNC) #=> false
++ *    File.constants.include?(:SEEK_END)         #=> true   # Defined in IO class
++ *    File.constants(false).include?(:SEEK_END)  #=> false
+  *
+  *  Also see <code>Module::const_defined?</code>.
+  */