rdx 0.9.0.pre

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

@@ -0,0 +1,195 @@
+--- core/orig/gc.c	2015-06-11 07:51:44 +0000
++++ core/patched/gc.c	2015-06-28 10:29:22 +0000
+@@ -1221,10 +1221,12 @@
+  *     a = 102.7
+  *     b = 95       # Won't be returned
+  *     c = 12345678987654321
++ *     ObjectSpace.each_object(Fixnum).to_a #=> []
+  *     count = ObjectSpace.each_object(Numeric) {|x| p x }
+  *     puts "Total count: #{count}"
+  *
+- *  <em>produces:</em>
++ *  <em>produces something like:</em>
++ *  :rdx: indicative_output
+  *
+  *     12345678987654321
+  *     102.7
+@@ -1608,7 +1610,7 @@
+  *
+  *     s = "I am a string"                    #=> "I am a string"
+  *     r = ObjectSpace._id2ref(s.object_id)   #=> "I am a string"
+- *     r == s                                 #=> true
++ *     r.equal?(s)                            #=> true
+  *
+  */
+ 
+@@ -1748,13 +1750,14 @@
+  *  Counts objects for each type.
+  *
+  *  It returns a hash, such as:
+- *	{
+- *	  :TOTAL=>10000,
+- *	  :FREE=>3011,
+- *	  :T_OBJECT=>6,
+- *	  :T_CLASS=>404,
+- *	  # ...
+- *	}
++ *  :rdx: off -
++ *    {
++ *      :TOTAL=>10000,
++ *      :FREE=>3011,
++ *      :T_OBJECT=>6,
++ *      :T_CLASS=>404,
++ *      # ...
++ *    }
+  *
+  *  The contents of the returned hash are implementation specific.
+  *  It may be changed in future.
+@@ -3141,18 +3144,19 @@
+  *  Returns a Hash containing information about the GC.
+  *
+  *  The hash includes information about internal statistics about GC such as:
+- *
+- *	{
+- *	    :count=>0,
+- *	    :heap_used=>12,
+- *     	    :heap_length=>12,
+- *     	    :heap_increment=>0,
+- *     	    :heap_live_num=>7539,
+- *     	    :heap_free_num=>88,
+- *     	    :heap_final_num=>0,
+- *     	    :total_allocated_object=>7630,
+- *     	    :total_freed_object=>88
+- *	}
++ * 
++ *    GC.stat
++ *    # -> {
++ *    #   :count=>0,
++ *    #   :heap_used=>12,
++ *    #   :heap_length=>12,
++ *    #   :heap_increment=>0,
++ *    #   :heap_live_num=>7539,
++ *    #   :heap_free_num=>88,
++ *    #   :heap_final_num=>0,
++ *    #   :total_allocated_object=>7630,
++ *    #   :total_freed_object=>88
++ *    # }
+  *
+  *  The contents of the hash are implementation specific and may be changed in
+  *  the future.
+@@ -3249,7 +3253,7 @@
+  *  Enables garbage collection, returning +true+ if garbage
+  *  collection was previously disabled.
+  *
+- *     GC.disable   #=> false
++ *     GC.disable   # now GC disabled
+  *     GC.enable    #=> true
+  *     GC.enable    #=> false
+  *
+@@ -3272,9 +3276,12 @@
+  *  Disables garbage collection, returning +true+ if garbage
+  *  collection was already disabled.
+  *
++ *     GC.enable    # now GC enabled
+  *     GC.disable   #=> false
+  *     GC.disable   #=> true
+- *
++ *-- rdx
++ *     GC.enable
++ *++
+  */
+ 
+ VALUE
+@@ -4133,17 +4140,18 @@
+  *
+  *  For example:
+  *
+- *    [
+- *	{
+- *	   :GC_TIME=>1.3000000000000858e-05,
+- *	   :GC_INVOKE_TIME=>0.010634999999999999,
+- *	   :HEAP_USE_SIZE=>289640,
+- *	   :HEAP_TOTAL_SIZE=>588960,
+- *	   :HEAP_TOTAL_OBJECTS=>14724,
+- *	   :GC_IS_MARKED=>false
+- *	},
+- *      # ...
+- *    ]
++ *    GC::Profiler.raw_data
++ *    # -> [
++ *    #  {
++ *    #    :GC_TIME=>1.3000000000000858e-05,
++ *    #    :GC_INVOKE_TIME=>0.010634999999999999,
++ *    #    :HEAP_USE_SIZE=>289640,
++ *    #    :HEAP_TOTAL_SIZE=>588960,
++ *    #    :HEAP_TOTAL_OBJECTS=>14724,
++ *    #    :GC_IS_MARKED=>false
++ *    #  },
++ *    #  # ...
++ *    # ]
+  *
+  *  The keys mean:
+  *
+@@ -4254,9 +4262,14 @@
+  *  call-seq:
+  *     GC::Profiler.result  -> String
+  *
+- *  Returns a profile data report such as:
+- *
+- *    GC 1 invokes.
++ *  Returns a profile data report, such as:
++ * 
++ *    puts GC::Profiler.result
++ * 
++ *  produces something like:
++ *  :rdx: indicative_output
++ * 
++ *    GC 1 ivokes.
+  *    Index    Invoke Time(sec)       Use Size(byte)     Total Size(byte)         Total Object                    GC time(ms)
+  *        1               0.012               159240               212940                10647         0.00000000000001530000
+  */
+@@ -4419,22 +4432,28 @@
+  *  ObjectSpace also provides support for object finalizers, procs that will be
+  *  called when a specific object is about to be destroyed by garbage
+  *  collection.
+- *
++ * 
++ *  :rdx: bug   on x64-mingw32 seems that the last object defined (c) isn't marked in this cycle...
++ *  :rdx: indicative_numbers
+  *     include ObjectSpace
+  *
+  *     a = "A"
+  *     b = "B"
+  *     c = "C"
+- *
++ * 
+  *     define_finalizer(a, proc {|id| puts "Finalizer one on #{id}" })
+- *     define_finalizer(a, proc {|id| puts "Finalizer two on #{id}" })
+- *     define_finalizer(b, proc {|id| puts "Finalizer three on #{id}" })
++ *     define_finalizer(b, proc {|id| puts "Finalizer two on #{id}" })
++ *     define_finalizer(c, proc {|id| puts "Finalizer three on #{id}" })
++ *     a = b = c = nil; # Now those strings are no more referenced,
++ *                      # but still alive until the next GC cycle...
++ *     GC.start # Garbage unreferenced objects now
+  *
+- *  _produces:_
++ *  <em>produces (your numbers may vary):</em>
++ *  :rdx: output
+  *
+- *     Finalizer three on 537763470
+  *     Finalizer one on 537763480
+- *     Finalizer two on 537763480
++ *     Finalizer two on 537763460
++ *     Finalzer three on 537763440
+  *
+  */
+ 
+@@ -4455,6 +4474,8 @@
+  *
+  *  Example:
+  *
++ *  :rdx: discard_output
++ * 
+  *    GC::Profiler.enable
+  *
+  *    require 'rdoc/rdoc'

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

@@ -0,0 +1,84 @@
+--- core/orig/hash.c	2015-06-11 07:51:44 +0000
++++ core/patched/hash.c	2015-06-19 16:15:53 +0000
+@@ -604,13 +604,7 @@
+  *  is not found and a default value is not supplied.
+  *
+  *     h = { "a" => 100, "b" => 200 }
+- *     h.fetch("z")
+- *
+- *  <em>produces:</em>
+- *
+- *     prog.rb:2:in `fetch': key not found (KeyError)
+- *      from prog.rb:2
+- *
++ *     h.fetch("z") # raises KeyError: key not found: "z"
+  */
+ 
+ static VALUE
+@@ -690,6 +684,7 @@
+  *  exist in the hash. It is not possible to set the default to a
+  *  <code>Proc</code> that will be executed on each key lookup.
+  *
++ *  :rdx: no_warnings result_instance_of
+  *     h = { "a" => 100, "b" => 200 }
+  *     h.default = "Go fish"
+  *     h["a"]     #=> 100
+@@ -718,6 +713,7 @@
+  *  If <code>Hash::new</code> was invoked with a block, return that
+  *  block, otherwise return <code>nil</code>.
+  *
++ *  :rdx: no_warnings result_instance_of
+  *     h = Hash.new {|h,k| h[k] = k*k }   #=> {}
+  *     p = h.default_proc                 #=> #<Proc:0x401b3d08@-:1>
+  *     a = []                             #=> []
+@@ -741,6 +737,7 @@
+  *
+  *  Sets the default proc to be executed on each failed key lookup.
+  *
++ *     h = Hash.new
+  *     h.default_proc = proc do |hash, key|
+  *       hash[key] = key + key
+  *     end
+@@ -2926,7 +2923,11 @@
+  *
+  * Converts the environment variables into an array of names and value arrays.
+  *
+- *   ENV.to_a # => [["TERM" => "xterm-color"], ["SHELL" => "/bin/bash"], ...]
++ *   ENV.to_a # -> [
++ *   #   ["TERM", "xterm-color"],
++ *   #   ["SHELL", "/bin/bash"],
++ *   #   # ...
++ *   # ]
+  *
+  */
+ static VALUE
+@@ -3347,7 +3348,7 @@
+  *
+  *  Accessing a value in a Hash requires using its key:
+  *
+- *    puts grades["Jane Doe"] # => 10
++ *    grades["Jane Doe"] # => 0
+  *
+  *  === Common Uses
+  *
+@@ -3362,13 +3363,15 @@
+  *  argument on a method call, no braces are needed, thus creating a really
+  *  clean interface:
+  *
+- *    Person.create(name: "John Doe", age: 27)
+- *
+- *    def self.create(params)
+- *      @name = params[:name]
+- *      @age  = params[:age]
++ *    class Person
++ *      def self.create(params)
++ *        @name = params[:name]
++ *        @age  = params[:age]
++ *      end
+  *    end
+  *
++ *    Person.create(name: "John Doe", age: 27)
++ 
+  *  === Hash Keys
+  *
+  *  Two objects refer to the same hash key when their <code>hash</code> value

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

@@ -0,0 +1,354 @@
+--- core/orig/iseq.c	2015-06-11 07:51:44 +0000
++++ core/patched/iseq.c	2015-06-25 17:35:23 +0000
+@@ -648,7 +648,7 @@
+  *  For details regarding valid compile options see ::compile_option=.
+  *
+  *     RubyVM::InstructionSequence.compile("a = 1 + 2")
+- *     #=> <RubyVM::InstructionSequence:<compiled>@<compiled>>
++ *     # > <RubyVM::InstructionSequence:<compiled>@<compiled>>
+  *
+  */
+ static VALUE
+@@ -678,12 +678,12 @@
+  *
+  *  For details regarding valid compile options see ::compile_option=.
+  *
+- *      # /tmp/hello.rb
++ *      # File: hello.rb
+  *      puts "Hello, world!"
+- *
++ *  :rdx:
+  *      # elsewhere
+- *      RubyVM::InstructionSequence.compile_file("/tmp/hello.rb")
+- *      #=> <RubyVM::InstructionSequence:<main>@/tmp/hello.rb>
++ *      RubyVM::InstructionSequence.compile_file("hello.rb")
++ *      # > <RubyVM::InstructionSequence:<main>@hello.rb>
+  */
+ static VALUE
+ iseq_s_compile_file(int argc, VALUE *argv, VALUE self)
+@@ -817,21 +817,21 @@
+  *
+  *  For example, using irb:
+  *
+- *	iseq = RubyVM::InstructionSequence.compile('num = 1 + 2')
+- *	#=> <RubyVM::InstructionSequence:<compiled>@<compiled>>
+- *	iseq.path
+- *	#=> "<compiled>"
++ *    iseq = RubyVM::InstructionSequence.compile('num = 1 + 2')
++ *    # > <RubyVM::InstructionSequence:<compiled>@<compiled>>
++ *    iseq.path
++ *    #=> "<compiled>"
+  *
+  *  Using ::compile_file:
+  *
+- *	# /tmp/method.rb
+- *	def hello
+- *	  puts "hello, world"
+- *	end
+- *
+- *	# in irb
+- *	> iseq = RubyVM::InstructionSequence.compile_file('/tmp/method.rb')
+- *	> iseq.path #=> /tmp/method.rb
++ *    # File: method.rb
++ *    def hello
++ *      puts "hello, world"
++ *    end
++ *  :rdx:
++ *    # in application
++ *    iseq = RubyVM::InstructionSequence.compile_file('method.rb')
++ *    iseq.path #=> 'method.rb'
+  */
+ static VALUE
+ iseq_path(VALUE self)
+@@ -847,15 +847,15 @@
+  *  +nil+ if the iseq was evaluated from a string.
+  *
+  *  For example, using ::compile_file:
+- *
+- *	# /tmp/method.rb
+- *	def hello
+- *	  puts "hello, world"
+- *	end
+- *
+- *	# in irb
+- *	> iseq = RubyVM::InstructionSequence.compile_file('/tmp/method.rb')
+- *	> iseq.absolute_path #=> /tmp/method.rb
++ * 
++ *    # File: method.rb
++ *    def hello
++ *      puts "hello, world"
++ *    end
++ *  :rdx:
++ *    # in application
++ *    iseq = RubyVM::InstructionSequence.compile_file('method.rb')
++ *    iseq.absolute_path #=> "#{Dir.pwd}/method.rb"
+  */
+ static VALUE
+ iseq_absolute_path(VALUE self)
+@@ -872,21 +872,21 @@
+  *
+  *  For example, using irb:
+  *
+- *	iseq = RubyVM::InstructionSequence.compile('num = 1 + 2')
+- *	#=> <RubyVM::InstructionSequence:<compiled>@<compiled>>
+- *	iseq.label
+- *	#=> "<compiled>"
++ *    iseq = RubyVM::InstructionSequence.compile('num = 1 + 2')
++ *    # > <RubyVM::InstructionSequence:<compiled>@<compiled>>
++ *    iseq.label
++ *    #=> "<compiled>"
+  *
+  *  Using ::compile_file:
+  *
+- *	# /tmp/method.rb
+- *	def hello
+- *	  puts "hello, world"
+- *	end
+- *
+- *	# in irb
+- *	> iseq = RubyVM::InstructionSequence.compile_file('/tmp/method.rb')
+- *	> iseq.label #=> <main>
++ *    # File: method.rb
++ *    def hello
++ *      puts "hello, world"
++ *    end
++ *  :rdx:
++ *    # in application
++ *    iseq = RubyVM::InstructionSequence.compile_file('method.rb')
++ *    iseq.label #=> "<main>"
+  */
+ static VALUE
+ iseq_label(VALUE self)
+@@ -900,21 +900,21 @@
+  *
+  *  For example, using irb:
+  *
+- *	iseq = RubyVM::InstructionSequence.compile('num = 1 + 2')
+- *	#=> <RubyVM::InstructionSequence:<compiled>@<compiled>>
+- *	iseq.base_label
+- *	#=> "<compiled>"
++ *    iseq = RubyVM::InstructionSequence.compile('num = 1 + 2')
++ *    # > <RubyVM::InstructionSequence:<compiled>@<compiled>>
++ *    iseq.base_label
++ *    #=> "<compiled>"
+  *
+  *  Using ::compile_file:
+  *
+- *	# /tmp/method.rb
+- *	def hello
+- *	  puts "hello, world"
+- *	end
+- *
+- *	# in irb
+- *	> iseq = RubyVM::InstructionSequence.compile_file('/tmp/method.rb')
+- *	> iseq.base_label #=> <main>
++ *    # File: method.rb
++ *    def hello
++ *      puts "hello, world"
++ *    end
++ *  :rdx:
++ *    # in application
++ *    iseq = RubyVM::InstructionSequence.compile_file('method.rb')
++ *    iseq.base_label #=> "<main>"
+  */
+ static VALUE
+ iseq_base_label(VALUE self)
+@@ -929,10 +929,10 @@
+  *
+  *  For example, using irb:
+  *
+- *	iseq = RubyVM::InstructionSequence.compile('num = 1 + 2')
+- *	#=> <RubyVM::InstructionSequence:<compiled>@<compiled>>
+- *	iseq.first_lineno
+- *	#=> 1
++ *    iseq = RubyVM::InstructionSequence.compile('num = 1 + 2')
++ *    # > <RubyVM::InstructionSequence:<compiled>@<compiled>>
++ *    iseq.first_lineno
++ *    #=> 1
+  */
+ static VALUE
+ iseq_first_lineno(VALUE self)
+@@ -969,13 +969,13 @@
+  *    A hash containing:
+  *
+  *    [+:arg_size+]
+- *	the total number of arguments taken by the method or the block (0 if
+- *	_iseq_ doesn't represent a method or block)
++ *      the total number of arguments taken by the method or the block (0 if
++ *      _iseq_ doesn't represent a method or block)
+  *    [+:local_size+]
+- *	the number of local variables + 1
++ *      the number of local variables + 1
+  *    [+:stack_max+]
+- *	used in calculating the stack depth at which a SystemStackError is
+- *	thrown.
++ *      used in calculating the stack depth at which a SystemStackError is
++ *      thrown.
+  *
+  *  [#label]
+  *    The name of the context (block, method, class, module, etc.) that this
+@@ -1014,6 +1014,7 @@
+  *    The arity if the method or block only has required arguments.
+  *
+  *    Otherwise an array of:
++ *    :rdx: off -
+  *
+  *      [required_argc, [optional_arg_labels, ...],
+  *       splat_index, post_splat_argc, post_splat_index,
+@@ -1333,10 +1334,11 @@
+  *
+  *    == disasm: <RubyVM::InstructionSequence:<compiled>@<compiled>>==========
+  *    0000 trace            1                                               (   1)
+- *    0002 putobject        1
+- *    0004 putobject        2
+- *    0006 opt_plus         <ic:1>
+- *    0008 leave
++ *    0002 putobject_OP_INT2FIX_O_1_C_ 
++ *    0003 putobject        2
++ *    0005 opt_plus         <callinfo!mid:+, argc:1, ARGS_SKIP>
++ *    0007 leave     
++ * 
+  */
+ VALUE
+ rb_iseq_disasm(VALUE self)
+@@ -1449,36 +1451,37 @@
+  *  Returns the instruction sequence containing the given proc or method.
+  *
+  *  For example, using irb:
++ *  :rdx: no_warnings result_instance_of
+  *
+- *	# a proc
+- *	> p = proc { num = 1 + 2 }
+- *	> RubyVM::InstructionSequence.of(p)
+- *	> #=> <RubyVM::InstructionSequence:block in irb_binding@(irb)>
+- *
+- *	# for a method
+- *	> def foo(bar); puts bar; end
+- *	> RubyVM::InstructionSequence.of(method(:foo))
+- *	> #=> <RubyVM::InstructionSequence:foo@(irb)>
++ *    # a proc
++ *    p = proc { num = 1 + 2 }
++ *    RubyVM::InstructionSequence.of(p)
++ *    #=> <RubyVM::InstructionSequence:block in irb_binding@(irb)>
++ *
++ *    # for a method
++ *    def foo(bar); puts bar; end
++ *    RubyVM::InstructionSequence.of(method(:foo))
++ *    #=> <RubyVM::InstructionSequence:foo@(irb)>
+  *
+  *  Using ::compile_file:
+  *
+- *	# /tmp/iseq_of.rb
+- *	def hello
+- *	  puts "hello, world"
+- *	end
+- *
+- *	$a_global_proc = proc { str = 'a' + 'b' }
+- *
+- *	# in irb
+- *	> require '/tmp/iseq_of.rb'
+- *
+- *	# first the method hello
+- *	> RubyVM::InstructionSequence.of(method(:hello))
+- *	> #=> #<RubyVM::InstructionSequence:0x007fb73d7cb1d0>
+- *
+- *	# then the global proc
+- *	> RubyVM::InstructionSequence.of($a_global_proc)
+- *	> #=> #<RubyVM::InstructionSequence:0x007fb73d7caf78>
++ *    # File: iseq_of.rb
++ *    def hello
++ *      puts "hello, world"
++ *    end
++ *
++ *    $a_global_proc = proc { str = 'a' + 'b' }
++ * 
++ *  from the command line:
++ *    
++ *    $ ruby <<'EOS'
++ *    > load File.expand_path('iseq_of.rb')
++ *    > p RubyVM::InstructionSequence.of(method(:hello))
++ *    > p RubyVM::InstructionSequence.of($a_global_proc)
++ *    > EOS
++ *    <RubyVM::InstructionSequence:hello@<relative_path>/iseq_of.rb>
++ *    <RubyVM::InstructionSequence:block in <top (required)>@<relative_path>/iseq_of.rb>
++ * 
+  */
+ static VALUE
+ iseq_s_of(VALUE klass, VALUE body)
+@@ -1511,47 +1514,51 @@
+  *  human readable instructions for +body+.
+  *
+  *  For a Method object:
+- *
+- *    # /tmp/method.rb
++ * 
++ *    # File: method.rb
+  *    def hello
+  *      puts "hello, world"
+  *    end
+  *
+  *    puts RubyVM::InstructionSequence.disasm(method(:hello))
+- *
+- *  Produces:
+- *
+- *    == disasm: <RubyVM::InstructionSequence:hello@/tmp/method.rb>============
++ * 
++ *  Running the file we obtain:
++ * 
++ *    $ ruby method.rb
++ *    == disasm: <RubyVM::InstructionSequence:hello@method.rb>================
+  *    0000 trace            8                                               (   1)
+  *    0002 trace            1                                               (   2)
+- *    0004 putself
++ *    0004 putself          
+  *    0005 putstring        "hello, world"
+- *    0007 send             :puts, 1, nil, 8, <ic:0>
+- *    0013 trace            16                                              (   3)
+- *    0015 leave                                                            (   2)
+- *
++ *    0007 opt_send_simple  <callinfo!mid:puts, argc:1, FCALL|ARGS_SKIP>
++ *    0009 trace            16                                              (   3)
++ *    0011 leave                                                            (   2)
++ *    
+  *  For a Proc:
+  *
+- *    # /tmp/proc.rb
++ *    # File: proc.rb
+  *    p = proc { num = 1 + 2 }
+  *    puts RubyVM::InstructionSequence.disasm(p)
++ * 
++ *  Then from command line:
+  *
+- *  Produces:
+- *
+- *    == disasm: <RubyVM::InstructionSequence:block in <main>@/tmp/proc.rb>===
++ *    $ ruby proc.rb
++ *    == disasm: <RubyVM::InstructionSequence:block in <main>@proc.rb>========
+  *    == catch table
+- *    | catch type: redo   st: 0000 ed: 0012 sp: 0000 cont: 0000
+- *    | catch type: next   st: 0000 ed: 0012 sp: 0000 cont: 0012
++ *    | catch type: redo   st: 0002 ed: 0012 sp: 0000 cont: 0002
++ *    | catch type: next   st: 0002 ed: 0012 sp: 0000 cont: 0012
+  *    |------------------------------------------------------------------------
+  *    local table (size: 2, argc: 0 [opts: 0, rest: -1, post: 0, block: -1] s1)
+- *    [ 2] num
+- *    0000 trace            1                                               (   1)
+- *    0002 putobject        1
+- *    0004 putobject        2
+- *    0006 opt_plus         <ic:1>
+- *    0008 dup
+- *    0009 setlocal         num, 0
+- *    0012 leave
++ *    [ 2] num        
++ *    0000 trace            256                                             (   1)
++ *    0002 trace            1
++ *    0004 putobject_OP_INT2FIX_O_1_C_ 
++ *    0005 putobject        2
++ *    0007 opt_plus         <callinfo!mid:+, argc:1, ARGS_SKIP>
++ *    0009 dup              
++ *    0010 setlocal_OP__WC__0 2
++ *    0012 trace            512
++ *    0014 leave
+  *
+  */
+