rb-threadframe 0.39 → 0.40

data/test/unit/test-sp-size.rb

@@ -1,13 +1,12 @@
 require 'test/unit'
 
-# require 'thread_frame'  # To compare with previous version
-require_relative '../../ext/thread_frame'
+require_relative '../../ext/thread_frame' if '1.9.2' == RUBY_VERSION
 
-# Test source_location and source_container.
+# Test accessing and settign RubyVM::Frame stack data
 class TestSpSize < Test::Unit::TestCase
 
   def sizes
-    tf = RubyVM::ThreadFrame::current
+    tf = RubyVM::Frame::current
     ary = []
     0.upto(2) do |i|
       ary << tf.sp_size
@@ -37,7 +36,7 @@ class TestSpSize < Test::Unit::TestCase
     assert_equal(f1_s[1..-1], f2_s[1..-1])
 
     assert_raises ArgumentError do 
-      tf = RubyVM::ThreadFrame.current
+      tf = RubyVM::Frame.current
       tf.sp_set(tf.sp_size, "Should not be able to set this.")
     end
   end

data/test/unit/test-thread-trace-masks.rb

@@ -1,6 +1,7 @@
 # Test of additional tracing flag use to selectively turn on off tracing
 require 'test/unit'
-require_relative '../../ext/thread_frame'
+
+require_relative '../../ext/thread_frame' if '1.9.2' == RUBY_VERSION
 
 class TestTracingMasks < Test::Unit::TestCase
   @@EVENT2MASK = {

data/test/unit/test-trace.rb

@@ -1,10 +1,10 @@
 # Test of additional tracing flag use to selectively turn on off tracing
 require 'test/unit'
-require_relative '../../ext/thread_frame'
+require_relative '../../ext/thread_frame' if '1.9.2' == RUBY_VERSION
 
 class TestTracing < Test::Unit::TestCase
   def test_basic_query_set_unset
-    tf = RubyVM::ThreadFrame::current
+    tf = RubyVM::Frame::current
     # Test default values
     assert_equal(false, tf.trace_off?)
     assert_equal(false, tf.return_stop?)
@@ -25,14 +25,14 @@ class TestTracing < Test::Unit::TestCase
   def test_trace_off
     @levels = []
     def trace_hook(event, file, line, id, binding, klass)
-      @levels << RubyVM::ThreadFrame::current.stack_size
+      @levels << RubyVM::Frame::current.stack_size
     end
 
     def baz
       6
     end
     def bar(set_off)
-      RubyVM::ThreadFrame::current.trace_off = true if set_off
+      RubyVM::Frame::current.trace_off = true if set_off
       baz
       5
     end

data/threadframe.rd

@@ -1,17 +1,17 @@
 # = NAME  
-# +RubyVM+::+ThreadFrame+
+# +RubyVM+::+Frame+
 #
 # = SYNOPSES 
 #
-# The +RubyVM+::+ThreadFrame+ class gives call-stack frame information
+# The +RubyVM+::+Frame+ class gives call-stack frame information
 # (controlled access to +rb_control_frame_t+)
 #
 #
 # It is possible that a The +Thread+::+Frame+ may be proposed for
-# all Ruby 1.9 implementations.  +RubyVM+::+ThreadFrame+
+# all Ruby 1.9 implementations.  +RubyVM+::+Frame+
 # contains routines in the YARV 1.9 implementation.
 #
-# Should there be a +Thread+::+Frame+ +RubyVM+::+ThreadFrame+ would be
+# Should there be a +Thread+::+Frame+ +RubyVM+::+Frame+ would be
 # a subclass of +Thread+::+Frame+. In code:
 #
 #   class Thread
@@ -19,11 +19,11 @@
 #        # ...
 #     end
 #     def threadframe        
-#        RubyVM::ThreadFrame.new(self) # or possibly Thread::Frame.new(self)
+#        RubyVM::Frame.new(self) # or possibly Thread::Frame.new(self)
 #     end
 #   end
 #           
-#   class RubyVM::ThreadFrame < Thread::Frame # In YARV 
+#   class RubyVM::Frame < Thread::Frame # In YARV 
 #     def initialize(thread_object)
 #       # implementation-specific code
 #     end    
@@ -36,25 +36,25 @@
 # A +RubyVM+::Thread+Frame+ contains information from a frame running +Thread+
 # object, and the information may change or disappear in the course of
 # running that thread. Therefore, it is advisable ensure that the
-# threads of the ThreadFrame objects are blocked.
+# threads of the Frame objects are blocked.
 #
 #
-# === RubyVM::ThreadFrame::new(thread_object)
+# === RubyVM::Frame::new(thread_object)
 # Creates a thread-frame object for the given thread object.
 #
-# === RubyVM::ThreadFrame::current
-# Shorthand for RubyVM::ThreadFrame.new(Thread::current)
+# === RubyVM::Frame::current
+# Shorthand for RubyVM::Frame.new(Thread::current)
 #
 # === Thread#threadframe
 #   tf = Thread::current.threadframe() 
 #
 # Creates a thread-frame object for the given thread object.
 # Note:
-#  Thread::current.threadframe() == RubyVM::ThreadFrame.new(Thread::current)
+#  Thread::current.threadframe() == RubyVM::Frame.new(Thread::current)
 #
-# == RubyVM::ThreadFrame Instance Methods
+# == RubyVM::Frame Instance Methods
 # 
-# === RubyVM::ThreadFrame#prev
+# === RubyVM::Frame#prev
 #   tf.prev(n) -> tf or nil
 #   tf.prev() -> tf or nil  # same as tf.prev(1)
 #
@@ -65,7 +65,7 @@
 # tf. A negative number of a number greater than the number of frames
 # returns nil. 
 #
-# === RubyVM::ThreadFrame#invalid?
+# === RubyVM::Frame#invalid?
 #   tf.invalid?() -> boolean
 #
 # Returns true if the frame is no longer valid. On the other hand,
@@ -78,24 +78,24 @@
 # variable is active.
 # 
 #
-# === RubyVM::ThreadFrame#thread
+# === RubyVM::Frame#thread
 #   tf.thread() -> Thread
-#   RubyVM::ThreadFrame.current().thread == Thread.current
+#   RubyVM::Frame.current().thread == Thread.current
 #
-# === RubyVM::ThreadFrame#type
+# === RubyVM::Frame#type
 #   tf.type() -> 'C' or 'Ruby'
 #
 # Indicates whether the frame is implemented in C or Ruby.
 #
-# === RubyVM::ThreadFrame#source_container
+# === RubyVM::Frame#source_container
 #  RubyVM::Threadframe#source_container() -> [Type, String]
 #
 # Returns a tuple representing kind of container, e.g. file
 # eval'd string object, and the name of the container. If file,
 # it would be a file name. If an eval'd string it might be the string.
 # 
-# === RubyVM::ThreadFrame#source_location
-#  RubyVM::ThreadFrame#.source_location() -> Array 
+# === RubyVM::Frame#source_location
+#  RubyVM::Frame#.source_location() -> Array 
 #
 # Returns an array of source location positions that match
 # +tf.instruction_offset+. A source location position is left
@@ -103,12 +103,12 @@
 # and start and end column, or a start line number, start column, end
 # line number, end column.
 #
-# === RubyVM::ThreadFrame#stack_size
-#  RubyVM::ThreadFrame#.stack_size -> Fixnum
+# === RubyVM::Frame#stack_size
+#  RubyVM::Frame#.stack_size -> Fixnum
 #
 #  Returns the number of entries 
 #
-# === RubyVM::ThreadFrame#binding
+# === RubyVM::Frame#binding
 #  tf.binding() -> binding
 #
 #
@@ -117,28 +117,28 @@
 # execution of the program, variables may spring into existence and
 # values may change.
 
-# == RubyVM::ThreadFrame 
+# == RubyVM::Frame 
 #
 # === RubyVM::new(thread_object)
 
-# Like RubyVM::ThreadFrame.new(thread_object), but has additional information
+# Like RubyVM::Frame.new(thread_object), but has additional information
 # available.
 #
-# === RubyVM::ThreadFrame#iseq
+# === RubyVM::Frame#iseq
 #   tf.iseq() -> ISeq
 #
 # Returns an instruction sequence object from the instruction sequence
-# found inside the +ThreadFrame+ object or +nil+ if there is none.
+# found inside the +Frame+ object or +nil+ if there is none.
 # But if iseq is +nil+ and tf.type is not C, +binding+, and
 # +instruction_offset+, and +source_location+ are probably meaningless
 # and will be +nil+ as well.
 #
 #
-# === RubyVM::ThreadFrame#instruction_offset
+# === RubyVM::Frame#instruction_offset
 #  tf.instruction_offset -> Fixnum
 # Offset inside ISeq of instruction that the frame is currently on.
 #
-# === RubyVM::ThreadFrame#instruction_offset=
+# === RubyVM::Frame#instruction_offset=
 #
 #  tf.instruction_offset=(Fixnum)
 # Sets the threadframe to a new offset. Some restrictions may apply, e.g.
@@ -147,7 +147,7 @@
 #
 # <em>Don't need to implement initially.</em>
 #
-# === RubyVM::ThreadFrame#return_changed?
+# === RubyVM::Frame#return_changed?
 #   tf.return_changed?() -> boolean
 #
 # Returns true if tf _may_ be part of tail recursion removal so when
@@ -160,4 +160,4 @@
 # = THANKS
 #
 # Martin Davis for suggesting 
-# RubyVM::ThreadFrame#new == Thread::current.threadframe
+# RubyVM::Frame#new == Thread::current.threadframe

metadata

@@ -1,33 +1,29 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: rb-threadframe
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 39
-  version: "0.39"
+version: !ruby/object:Gem::Version
+  version: '0.40'
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - R. Bernstein
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-10-27 00:00:00 -04:00
-default_executable: 
+date: 2012-11-25 00:00:00.000000000 Z
 dependencies: []
+description: ! '
+
+  rb-threadframe gives introspection access for frames of a thread.
 
-description: "\n\
-  rb-threadframe gives introspection access for frames of a thread.\n"
+'
 email: rockyb@rubyforge.net
 executables: []
-
-extensions: 
+extensions:
 - ext/extconf.rb
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.md
 - threadframe.rd
-files: 
+files:
 - README.md
 - Rakefile
 - Makefile
@@ -40,78 +36,56 @@ files:
 - include/vm_core_mini.h
 - lib/iseq_extra.rb
 - lib/thread_frame.rb
-- ext/iseq_extra.c
-- ext/thread_frame.c
-- ext/proc_extra.c
-- ext/thread_extra.c
-- ext/thread_frame.h
-- ext/proc_extra.h
-- ext/thread_pthread.h
-- ext/node.h
-- ext/thread_extra.h
-- ext/iseq_extra.h
-- ext/iseq_mini.h
+- ext/1.9.3/thread_frame.c
+- ext/version.h
 - test/unit/test-trace.rb
 - test/unit/test-iseq-save.rb
 - test/unit/test-prev.rb
 - test/unit/test-source.rb
 - test/unit/test-lib-iseq.rb
 - test/unit/test-return-stop.rb
+- test/unit/test-frame.rb
 - test/unit/test-proc.rb
 - test/unit/test-invalid.rb
 - test/unit/test-argc.rb
 - test/unit/cfunc-use.rb
 - test/unit/test-binding.rb
 - test/unit/test-lib-iseq-extra.rb
-- test/unit/test-thread.rb
 - test/unit/test-iseq-brkpt.rb
 - test/unit/test-iseq.rb
 - test/unit/test-thread-trace-masks.rb
 - test/unit/test-settracefunc.rb
 - test/unit/test-sp-size.rb
-- test/ruby/test_disasm.rb
-- test/ruby/test_iseq.rb
-- test/ruby/test_brkpt.rb
 - test/ruby/test_tracefunc_adds.rb
-- test/ruby/test_tracefunc_raise.rb
 - threadframe.rd
 - ext/extconf.rb
-has_rdoc: true
 homepage: http://github.com/rocky/rb-threadframe/tree/master
-licenses: 
+licenses:
 - MIT
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - --main
 - README.md
 - --title
-- ThreadFrame 0.39 Documentation
-require_paths: 
+- ThreadFrame 0.40 Documentation
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ~>
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 1
-      - 9
-      - 2frame
-      version: 1.9.2frame
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Frame introspection
 test_files: []
-

data/ext/iseq_extra.c

@@ -1,441 +0,0 @@
-/* 
- * Copyright (C) 2010 Rocky Bernstein
- */
-#if 0  /* The following is to fake out rdoc, until I find a better fix. */
-/* 
- *  Additions to the RubyVM::InstructionSequence class
- */
-VALUE rb_cIseq = rb_define_class_under(rb_cRubyVM, "InstructionSequence", 
-				       rb_cObject);
-#endif
-
-#include "../include/vm_core_mini.h"   /* Pulls in ruby.h and node.h */
-#include "iseq_mini.h"  /* Pulls in ruby.h */
-#include "../include/ruby19_externs.h"
-#include <string.h>       /* For strlen() */
-
-struct iseq_insn_info_entry {
-    unsigned short position;
-    unsigned short line_no;
-    unsigned short sp;
-};
-
-#define COMPILE_OPTS_BOOL_SET_HASH(FIELD) \
-    rb_hash_aset(hash_opts, rb_str_new2(#FIELD), \
-		 (compile_opts->FIELD) ? Qtrue : Qfalse)
-    
-/* 
- *  Document-method: RubyVM::InstructionSequence::compile_options
- *
- *  call-seq:
- *     RubyVM::InstructionSequence#compile_options -> Hash
- *
- *  Returns a hash of the compiler options used to create the 
- *  instruction sequence.
- */
-VALUE
-iseq_compile_options(VALUE iseqval)
-{
-    rb_iseq_t *iseq;
-    if (Qnil == iseqval) return Qnil;
-    else {
-	VALUE hash_opts = rb_hash_new();
-	rb_compile_option_t *compile_opts;
-	GetISeqPtr(iseqval, iseq);
-	if (!iseq->compile_data) return Qnil;
-	compile_opts = iseq->compile_data->option;
-	COMPILE_OPTS_BOOL_SET_HASH(inline_const_cache);
-	COMPILE_OPTS_BOOL_SET_HASH(peephole_optimization);
-	COMPILE_OPTS_BOOL_SET_HASH(tailcall_optimization);
-	COMPILE_OPTS_BOOL_SET_HASH(specialized_instruction);
-	COMPILE_OPTS_BOOL_SET_HASH(operands_unification);
-	COMPILE_OPTS_BOOL_SET_HASH(stack_caching);
-	COMPILE_OPTS_BOOL_SET_HASH(trace_instruction);
-	COMPILE_OPTS_BOOL_SET_HASH(debug_level);
-	COMPILE_OPTS_BOOL_SET_HASH(save_tree_node);
-	COMPILE_OPTS_BOOL_SET_HASH(save_compile_opts);
-	return hash_opts;
-    }
-}
-
-/* 
- *  Document-method: RubyVM::InstructionSequence::encoded
- * 
- *  call-seq:
- *     RubyVM::InstructionSequence#iseq_encoded -> String
- *
- *  Returns a string of the encoded bytes of the instruction
- *  sequence. Note that this is probably not usable as is, may be useful in
- *  decoding instructions (using other info) or for getting a sha1
- *  checksum.
- */
-VALUE 
-iseq_iseq_encoded(VALUE iseqval)
-{
-    rb_iseq_t *iseq;
-    GetISeqPtr(iseqval, iseq);
-    return rb_str_new((char *) iseq->iseq_encoded, iseq->iseq_size);
-}
-
-
-/* 
- *  Document-method: RubyVM::InstructionSequence::equal?
- * 
- *  call-seq:
- *     RubyVM::InstructionSequence#equal?(iseq2) -> bool
- *
- *  Returns true if the instruction sequences are equal.
- */
-VALUE 
-iseq_equal(VALUE iseqval1, VALUE iseqval2)
-{
-    rb_iseq_t *iseq1, *iseq2;
-
-    if (Qnil == iseqval2) return Qfalse;
-    if (!rb_obj_is_kind_of(iseqval2, rb_cISeq)) {
-	rb_raise(rb_eTypeError, 
-		 "comparison argument must be an instance of %s or nil (is %s)",
-		 rb_obj_classname(iseqval1), rb_obj_classname(iseqval2));
-    }
-    
-    if (iseqval1 == iseqval2) return Qtrue;
-    GetISeqPtr(iseqval1, iseq1);
-    GetISeqPtr(iseqval2, iseq2);
-
-    /* FIXME: the count 28 below  is bogus. I think this should be the fields
-       from "type" to  "mark_ary". Should also include iseq->encoded.
-     */
-    if (0 == memcmp(iseq1, iseq2, 28))
-	return Qtrue;
-    else
-	return Qfalse;
-}
-
-VALUE 
-iseq_parent(VALUE self)
-{
-    rb_iseq_t *piseq;
-    rb_iseq_t *parent_iseq;
-    VALUE parent_iseqval;
-    GetISeqPtr(self, piseq);
-
-    if (!RTEST(piseq->parent_iseq)) return Qnil;
-    parent_iseqval = iseq_alloc_shared(rb_cISeq);
-    GetISeqPtr(parent_iseqval, parent_iseq);
-    memcpy(parent_iseq, piseq->parent_iseq, sizeof(struct rb_iseq_struct));
-    return parent_iseqval;
-}
-
-VALUE 
-iseq_local_iseq(VALUE self)
-{
-    rb_iseq_t *piseq;
-    rb_iseq_t *local_iseq;
-    VALUE local_iseqval;
-    GetISeqPtr(self, piseq);
-
-    if (!RTEST(piseq->local_iseq)) return Qnil;
-    local_iseqval = iseq_alloc_shared(rb_cISeq);
-    GetISeqPtr(local_iseqval, local_iseq);
-    memcpy(local_iseq, piseq->local_iseq, sizeof(struct rb_iseq_struct));
-    return local_iseqval;
-}
-
-/* 
- * call-seq:
- *     RubyVM::InstructionSequence#local_name(i) - String
- * 
- *  Returns the string name of local variable in i'th position
- *  of the instruction sequence local table, or nil if i is
- * out of range.
- */
-VALUE
-iseq_local_name(VALUE iseqval, VALUE val)
-{
-    rb_iseq_t *iseq;
-    if (FIXNUM_P(val)) {
-      long int i = FIX2INT(val);
-      long int size;
-      
-      GetISeqPtr(iseqval, iseq);
-      
-      size = iseq->local_table_size;
-      
-      if (i < 0) i = size + i;
-      
-      if (i >= size)
-	rb_raise(rb_eIndexError, 
-		 "local table index %ld should be in the range -%ld .. %ld",
-		 i, size, size-1);
-      
-      return rb_str_new2(rb_id2name(iseq->local_table[i]));
-    } else {
-      rb_raise(rb_eTypeError, "type mismatch: %s given, Fixnum expected", 
-	       rb_class2name(CLASS_OF(val)));
-    }
-    /* not reached. */
-    return Qnil;
-}
-
-/* 
- * call-seq:
- *     RubyVM::InstructionSequence#name -> String
- * 
- *  Returns the name if the instruction sequence.
- */
-VALUE
-iseq_name(VALUE iseqval)
-{
-    rb_iseq_t *iseq;
-    GetISeqPtr(iseqval, iseq);
-    return(iseq->name);
-}
-
-/* 
- * call-seq:
- *     RubyVM::InstructionSequence#offsetlines -> Hash[Fixnum] -> [Fixnum]
- * 
- * Returns an hash. The keys in the hash form the VM offsets of the
- * instructions.  The value of the hash for a given offset is a list
- * of line numbers associated with that offset.
- */
-VALUE iseq_offsetlines(VALUE iseqval)
-{
-    rb_iseq_t *iseq;
-    VALUE offsetlines = rb_hash_new();
-    unsigned long i, size;
-    struct iseq_insn_info_entry *table;
-   
-    GetISeqPtr(iseqval, iseq);
-    
-    size = iseq->insn_info_size;
-    table = iseq->insn_info_table;
-
-    for (i = 0; i < size; i++) {
-	VALUE ary = rb_ary_new2(1);
-	rb_ary_push(ary, INT2FIX(table[i].line_no));
-	rb_hash_aset(offsetlines, INT2FIX(table[i].position), ary);
-    }
-    return offsetlines;
-}
-
-/* 
- * call-seq:
- *     RubyVM::InstructionSequence#offset2lines(offset) -> [Fixnum]
- * 
- * Returns an Array or nil. If offset is found then return the list of
- * lines associated with that offset. If the offset isn't found return nil.
- */
-VALUE iseq_offset2lines(VALUE iseqval, VALUE offsetval)
-{
-    rb_iseq_t *iseq;
-   
-    GetISeqPtr(iseqval, iseq);
-    
-    if (FIXNUM_P(offsetval)) {
-	unsigned long i, size;
-	int offset = FIX2INT(offsetval);
-	struct iseq_insn_info_entry *table;
-
-	size = iseq->insn_info_size;
-	table = iseq->insn_info_table;
-
-	for (i = 0; i < size; i++) {
-	    if (table[i].position == offset) {
-		VALUE ary = rb_ary_new2(1);
-		rb_ary_push(ary, INT2FIX(table[i].line_no));
-		return ary;
-	    }
-	}
-    }
-    return Qnil;
-}
-
-/* FIXME: should return array of destroyed entries */
-VALUE iseq_killcache(VALUE iseqval)
-{
-    rb_iseq_t *iseqdat;
-    VALUE *iseq ;
-    unsigned long i, size, count = 0;
-    struct iseq_insn_info_entry *table;
-
-    GetISeqPtr(iseqval, iseqdat);
-    iseq = iseqdat->iseq;
-    size = iseqdat->insn_info_size;
-    table = iseqdat->insn_info_table;
-    for (i = 0; i < size; i++) {
-      const unsigned long pos = table[i].position;
-      const VALUE insn = iseq[pos];
-      if (0 == strncmp(insn_name(insn), "getinlinecache", 
-		       sizeof("getinlinecache")))
-      {
-	/* printf("pos: %lu\n", pos); */
-	count ++;
-	iseq[pos] = 0;
-	iseq[pos+1] = 0;
-	iseq[pos+2] = 0;
-      }
-    }
-    return INT2FIX(count);
-}
-
-const char *
-source_container_type(VALUE fileval) 
-{
-    const char *filename = RSTRING_PTR(fileval);
-    size_t len = strlen(filename);
-
-    /* FIXME: Looking for (...) is a hack that I would love to know how
-       to remove. Probably Ruby has to be changed to record this kind
-       of information.
-     */
-    if (len > 0 && 
-	((filename[0] == '(' && filename[len-1] == ')')
-	 || 0 == strncmp(filename, "<compiled>", 
-			 sizeof("<compiled>"))))
-	return "string";
-    else
-	return "file";
-}
-
-
-VALUE
-iseq_source_container_internal(rb_iseq_t *iseq)
-{
-    VALUE fileval = iseq->filename;
-    const char *contain_type = source_container_type(fileval);
-    
-    return rb_ary_new3(2, rb_str_new2(contain_type), fileval);
-}
-
-/*
- * call-seq:
- *    RubyVM::InstructionSequence#source_container() -> [Type, String]
- *
- * Returns a tuple representing kind of container, e.g. file
- * eval'd string object, and the name of the container. If file,
- * it would be a file name. If an eval'd string it might be the string.
- */
-static VALUE
-iseq_source_container(VALUE iseqval)
-{
-    rb_iseq_t *iseq;
-   
-    if (Qnil == iseqval) return Qnil;
-    GetISeqPtr(iseqval, iseq);
-    return iseq_source_container_internal(iseq);
-}
-
-
-#if 0
-/*
- * call-seq:
- *    RubyVM::InstructionSequence#type() -> Fixnum
- *
- * Returns instruction-sequence type.
- */
-static VALUE
-iseq_type(VALUE iseqval)
-#endif
-
-#define ISEQ_FIELD_METHOD(FIELD)		\
-static VALUE					\
-iseq_##FIELD(VALUE iseqval)			\
-{						\
-  rb_iseq_t *iseq;				\
-  if (Qnil == iseqval) return Qnil;		\
-  GetISeqPtr(iseqval, iseq);			\
-  return iseq->FIELD;				\
-}
-
-ISEQ_FIELD_METHOD(orig) ;
-ISEQ_FIELD_METHOD(self) ;
-ISEQ_FIELD_METHOD(type) ;
-
-#define ISEQ_INT_FIELD_METHOD(FIELD)		\
-extern VALUE					\
-iseq_##FIELD(VALUE iseqval)			\
-{						\
-  rb_iseq_t *iseq;				\
-  GetISeqPtr(iseqval, iseq);			\
-  return INT2FIX(iseq->FIELD);			\
-}
-
-ISEQ_INT_FIELD_METHOD(arg_block) ;
-ISEQ_INT_FIELD_METHOD(arg_opts) ;
-ISEQ_INT_FIELD_METHOD(arg_post_len) ;
-ISEQ_INT_FIELD_METHOD(arg_rest) ;
-ISEQ_INT_FIELD_METHOD(arg_simple) ;
-ISEQ_INT_FIELD_METHOD(argc) ;
-ISEQ_INT_FIELD_METHOD(iseq_size) ;
-ISEQ_INT_FIELD_METHOD(klass) ;
-ISEQ_INT_FIELD_METHOD(line_no) ;
-ISEQ_INT_FIELD_METHOD(local_size) ;
-ISEQ_INT_FIELD_METHOD(local_table_size) ;
-
-/*
- * call-seq:
- *    RubyVM::InstructionSequence#line_range() -> Range
- *
- * Returns a range containing the starting line number and the
- * ending line of the source code for the instruction-sequence.
- */
-static VALUE
-iseq_line_range(VALUE iseqval) 
-{
-    rb_iseq_t *iseq;
-
-    GetISeqPtr(iseqval, iseq);
-    if (Qnil == iseqval) return Qnil;
-    else {
-	unsigned long i, size = iseq->insn_info_size;
-	struct iseq_insn_info_entry *table = iseq->insn_info_table;
-	unsigned short min_line = table[0].line_no;
-	unsigned short max_line = table[0].line_no;
-	
-	for (i = 0; i < size; i++) {
-	    if (table[i].line_no < min_line) 
-		min_line = table[i].line_no;
-	    else if (table[i].line_no > max_line)
-		max_line = table[i].line_no;
-	}
-	return rb_range_new(INT2FIX(min_line), INT2FIX(max_line), 0);
-    }
-}
-
-
-/* RDoc can't find methods when we use a definition like this: */
-#define RB_DEFINE_ISEQ_METHOD(FIELD, ARGC) \
-    rb_define_method(rb_cISeq, #FIELD, iseq_##FIELD, ARGC);
-
-void
-Init_iseq_extra(void)
-{
-    rb_define_method(rb_cISeq, "arg_block",        iseq_arg_block, 0) ;
-    rb_define_method(rb_cISeq, "arg_opts",         iseq_arg_opts, 0) ;
-    rb_define_method(rb_cISeq, "arg_post_len",     iseq_arg_post_len, 0) ;
-    rb_define_method(rb_cISeq, "arg_rest",         iseq_arg_rest, 0) ;
-    rb_define_method(rb_cISeq, "arg_simple",       iseq_arg_simple, 0) ;
-    rb_define_method(rb_cISeq, "argc",             iseq_argc, 0) ;
-    rb_define_method(rb_cISeq, "compile_options",  iseq_compile_options, 0) ;
-    rb_define_method(rb_cISeq, "equal?",           iseq_equal, 1) ;
-    rb_define_method(rb_cISeq, "encoded",          iseq_iseq_encoded, 0) ;
-    rb_define_method(rb_cISeq, "iseq_size",        iseq_iseq_size, 0) ;
-    rb_define_method(rb_cISeq, "killcache",        iseq_killcache, 0) ;
-    rb_define_method(rb_cISeq, "klass",            iseq_klass, 0) ;
-    rb_define_method(rb_cISeq, "lineno",           iseq_line_no, 0) ;
-    rb_define_method(rb_cISeq, "line_range",       iseq_line_range, 0) ;
-    rb_define_method(rb_cISeq, "local_iseq",       iseq_local_iseq, 0) ;
-    rb_define_method(rb_cISeq, "local_name",       iseq_local_name, 1) ;
-    rb_define_method(rb_cISeq, "local_size",       iseq_local_size, 0) ;
-    rb_define_method(rb_cISeq, "local_table_size", iseq_local_table_size, 0) ;
-    rb_define_method(rb_cISeq, "offset2lines",     iseq_offset2lines, 1) ;
-    rb_define_method(rb_cISeq, "offsetlines",      iseq_offsetlines, 0) ;
-    rb_define_method(rb_cISeq, "orig",             iseq_orig, 0) ;
-    rb_define_method(rb_cISeq, "parent",           iseq_parent, 0) ;
-    rb_define_method(rb_cISeq, "name",             iseq_name, 0) ;
-    rb_define_method(rb_cISeq, "self",             iseq_self, 0) ;
-    rb_define_method(rb_cISeq, "source_container", iseq_source_container, 0) ;
-    rb_define_method(rb_cISeq, "type",             iseq_type, 0) ;
-
-}