ruby-internal 0.7.3 → 0.8.0

data/ext/internal/vm/iseq/extconf.rb

@@ -3,5 +3,6 @@ require 'mkmf-ruby-internal'
 
 have_header('iseq.h')
 have_header('ruby/node.h') or have_header('node.h')
+have_type('struct RTypedData')
 
 create_ruby_internal_makefile 'internal/vm/iseq/iseq'

data/ext/internal/vm/iseq/iseq.c

@@ -11,13 +11,41 @@
 #ifdef RUBY_VM
 
 #include "vm_core.h"
-
-#include "iseq_load.inc"
+#include "gc.h"
+#include "internal/method/internal_method.h"
 
 #ifdef HAVE_ISEQ_H
 #include "iseq.h"
 #endif
 
+#ifdef HAVE_TYPE_STRUCT_RTYPEDDATA
+
+#  undef GET_THREAD
+#  undef GetThreadPtr
+#  define GetThreadPtr(obj, ptr) \
+   TypedData_Get_Struct((obj), rb_thread_t, p_ruby_threadptr_data_type, (ptr))
+
+  static rb_data_type_t const * p_ruby_threadptr_data_type;
+
+  static rb_thread_t * GET_THREAD()
+  {
+    VALUE thread = rb_thread_current();
+    rb_thread_t * th;
+    ID * local_tbl;
+    GetThreadPtr(thread, th);
+    return th;
+  }
+
+  static void init_ruby_threadptr_data_type()
+  {
+    VALUE thread = rb_thread_current();
+    p_ruby_threadptr_data_type = RTYPEDDATA_TYPE(thread);
+  }
+
+#endif
+
+#include "iseq_load.inc"
+
 #ifndef RARRAY_LEN
 #define RARRAY_LEN(a) RARRAY(a)->len
 #endif
@@ -368,7 +396,7 @@ static VALUE iseq_insn_line(VALUE self, VALUE n)
 static VALUE iseq_catch_table(VALUE self)
 {
   rb_iseq_t *iseqdat = iseq_check(self);
-  unsigned long j;
+  long j;
 
   VALUE catch_table = rb_ary_new();
 
@@ -475,7 +503,7 @@ static VALUE iseq_marshal_load(VALUE klass, VALUE str)
   arr = marshal_load(str);
   convert_placeholders_to_modules(arr);
 
-  VALUE iseq = iseq_load(Qnil, arr, 0, Qnil);
+  VALUE iseq = iseq_load(rb_cISeq, arr, 0, Qnil);
   return iseq;
 }
 
@@ -504,6 +532,7 @@ void Init_iseq(void)
 
   rb_require("internal/node");
   rb_require("internal/module");
+  rb_require("internal/method");
   rb_require("internal/vm/instruction");
   rb_require("internal/vm/inline_cache");
 
@@ -563,5 +592,10 @@ void Init_iseq(void)
   insn_name(0);
   insn_op_types(0);
 #endif
+
+#ifdef HAVE_TYPE_STRUCT_RTYPEDDATA
+  init_iseq_data_type();
+  init_ruby_threadptr_data_type();
+#endif
 }
 

data/ext/internal/vm/iseq/iseq_load.inc.rpp

@@ -1,10 +1,28 @@
 #ifndef ruby_internal_iseq_load__inc_
 #define ruby_internal_iseq_load__inc_
 
-#include "gc.h"
-#include "iseq.h"
-#include "vm_core.h"
+#ifdef HAVE_TYPE_STRUCT_RTYPEDDATA
 
+  static rb_data_type_t const * p_iseq_data_type;
+
+  static void init_iseq_data_type()
+  {
+    rb_proc_t * p;
+    VALUE body;
+
+    VALUE binding = rb_binding_new();
+    VALUE new_proc = rb_funcall(
+        rb_cObject, rb_intern("eval"), 2, rb_str_new2("proc { }"), binding);
+    GetProcPtr(new_proc, p);
+    body = p->block.iseq->self;
+
+    p_iseq_data_type = RTYPEDDATA_TYPE(body);
+  }
+
+#else
+
+#endif
+#
 #ruby <<END
   ruby_version_code = RUBY_VERSION.gsub(/\./, '').to_i
 
@@ -23,13 +41,13 @@
         when /^(iseq_load|iseq_alloc|iseq_mark|iseq_free|compile_data_free|make_compile_option|make_compile_option_value|prepare_iseq_build|cleanup_iseq_build|set_relation|iseq_memsize)/
           write = true
           puts prev_line
-        when /^static.*iseq_data_type.*=/
-          write = true
         when /^static.*COMPILE_OPTION_DEFAULT.*=/
           write = true
         when /^static.*COMPILE_OPTION_FALSE.*=/
           write = true
           stopwrite = true
+        when /TypedData_Make_Struct.*\&iseq_data_type/
+          line.gsub!(/\&iseq_data_type/, 'p_iseq_data_type')
         when /^#define CHECK_/,
              /^static inline VALUE CHECK_/
           write = true

data/ext/internal/vm/vm.c

@@ -4,6 +4,22 @@
 
 #include "vm_core.h"
 
+#ifdef HAVE_TYPE_STRUCT_RTYPEDDATA
+
+#  undef GetThreadPtr
+#  define GetThreadPtr(obj, ptr) \
+   TypedData_Get_Struct((obj), rb_thread_t, p_ruby_threadptr_data_type, (ptr))
+
+  static rb_data_type_t const * p_ruby_threadptr_data_type;
+
+  static void init_ruby_threadptr_data_type()
+  {
+    VALUE thread = rb_thread_current();
+    p_ruby_threadptr_data_type = RTYPEDDATA_TYPE(thread);
+  }
+
+#endif
+
 extern rb_vm_t * ruby_current_vm;
 
 /*
@@ -14,7 +30,15 @@ extern rb_vm_t * ruby_current_vm;
  */
 static VALUE vm_current(VALUE klass)
 {
+#ifdef HAVE_TYPE_STRUCT_RTYPEDDATA
+  VALUE thread = rb_thread_current();
+  rb_thread_t * th;
+  ID * local_tbl;
+  GetThreadPtr(thread, th);
+  return th->vm->self;
+#else
   return ruby_current_vm->self;
+#endif
 }
 
 /*
@@ -51,5 +75,9 @@ void Init_vm(void)
   rb_define_singleton_method(rb_cRubyVM, "current", vm_current, 0);
   rb_define_method(rb_cRubyVM, "top_self", vm_top_self, 0);
 #endif
+
+#ifdef HAVE_TYPE_STRUCT_RTYPEDDATA
+  init_ruby_threadptr_data_type();
+#endif
 }
 

data/lib/internal/classtree.rb

@@ -2,6 +2,34 @@ require 'internal/object'
 require 'internal/module'
 
 class Object
+  # Returns an ASCII representation of a class hierarchy, e.g.:
+  #
+  #   irb(main):004:0> puts Object.new.classtree
+  #   #<Object:0x40330ce8>
+  #   +-class = Object
+  #     |-class = #<Class:Object>
+  #     | |-class = Class
+  #     | | |-class = #<Class:Class>
+  #     | | | |-class = #<Class:Class> (*)
+  #     | | | +-super = #<Class:Module>
+  #     | | |   |-class = Class (*)
+  #     | | |   +-super = #<Class:Object> (*)
+  #     | | +-super = Module
+  #     | |   |-class = #<Class:Module> (*)
+  #     | |   +-super = Object (*)
+  #     | +-super = Class (*)
+  #     +-super = #<PP::ObjectMixin?:0x40349568>
+  #       +-class = PP::ObjectMixin?
+  #         |-class = Module (*)
+  #         +-super = #<Kernel:0x4033507c>
+  #           +-class = Kernel
+  #   => nil
+  #
+  # An asterisk (*) indicates that the class has previously been
+  # printed.
+  #
+  # The notation #<Class:XXXX> indicates a singleton class.
+  #
   def classtree(s = '', prefix = '', obj=self, graphed={})
     # if Module == obj.class.class then
     #   s << "included module "

data/lib/internal/debug.rb

@@ -2,14 +2,22 @@ require 'internal/node'
 require 'internal/node/as_expression'
 require 'internal/node/pp'
 
-module Nodewrap
+module Internal
+  # Print an expression and its result, e.g.:
+  #
+  #   printdebug { 1 + 1 }
+  #
+  # will print:
+  #
+  #   test.rb:42: 1 + 1 => 2
+  #
   def printdebug(&block)
     puts "#{caller[0]}: #{block.body.as_expression} => #{block.call}"
   end
 end
 
 if __FILE__ == $0 then
-  include Nodewrap
+  include Internal
   a = 41
   printdebug { a + 1 }
 end

data/lib/internal/method/as_code.rb

@@ -4,6 +4,31 @@ require 'internal/method'
 require 'internal/method/signature'
 
 module MethodAsCode
+  # Returns a string representation of the method definition/body.
+  #
+  #   irb(main):001:0> def foo(a, b, *rest, &block)
+  #   irb(main):002:1>   begin
+  #   irb(main):003:2*     if not a and not b then
+  #   irb(main):004:3*       raise "Need more input!"
+  #   irb(main):005:3>     end
+  #   irb(main):006:2>     return a + b
+  #   irb(main):007:2>   ensure
+  #   irb(main):008:2*     puts "In ensure block"
+  #   irb(main):009:2>   end
+  #   irb(main):010:1> end
+  #   => nil
+  #   irb(main):011:0> m = method(:foo)
+  #   => #<Method: Object#foo>
+  #   irb(main):012:0> puts m.as_code
+  #   def foo(a, b, *rest, &block)
+  #     begin
+  #       (raise("Need more input!")) if (not a and not b)
+  #       return a + b
+  #     ensure
+  #       puts("In ensure block")
+  #     end
+  #   end
+  #
   def as_code(indent=0, name=nil)
     sig = self.signature
     if self.body.respond_to?(:body) then

data/lib/internal/method/as_expression.rb

@@ -4,9 +4,8 @@ require 'internal/method/signature'
 require 'internal/method'
 
 module MethodAsExpression
-  # It doesn't entirely make sense to have Method#as_expression, because
-  # a method definition isn't an expression.  We have one anyway, to be
-  # consistent with Proc.
+  # Return a single-line string representation of a method
+  # TODO: this method would be more aptly named "as_expression_string".
   def as_expression
     sig = self.signature
     if self.body.respond_to?(:body) then

data/lib/internal/method/origin.rb

@@ -0,0 +1,29 @@
+module MethodOrigin
+  # An abstraction for a method origin.
+  class Origin
+    attr_reader :file, :line
+
+    def initialize(file, line)
+      @file = file
+      @line = line
+    end
+
+    def to_s
+      return "#{file}:#{line}"
+    end
+  end
+
+  # Return a Method::Origin representing where the method was defined.
+  def origin
+    block = body().next
+    return Origin.new(block.nd_file, block.nd_line)
+  end
+end
+
+class Method
+  include MethodOrigin
+end
+
+class UnboundMethod
+  include MethodOrigin
+end

data/lib/internal/method/signature.rb

@@ -1,111 +1,17 @@
 require 'internal/method'
 require 'internal/node'
 require 'internal/node/as_expression'
+require 'internal/method/signature/argument'
+require 'internal/method/signature/node'
+require 'internal/method/signature/signature'
 
 if defined?(RubyVM) then
 require 'internal/vm/bytedecoder'
+require 'internal/method/signature/iseq'
 end
 
 module MethodSig
-  class Argument
-    attr_reader :name
-
-    def required?
-      return !optional?
-    end
-
-    def optional?
-      return rest? || block?
-    end
-
-    def rest?
-      return @is_rest
-    end
-
-    def block?
-      return @is_block
-    end
-
-    def default
-      return nil
-    end
-
-    def initialize(name, is_rest, is_block)
-      @name = name
-      @is_rest = is_rest
-      @is_block = is_block
-    end
-
-    def to_s
-      if @is_rest then
-        prefix = "*"
-      elsif @is_block then
-        prefix = "&"
-      end
-
-      if self.default then
-        suffix = "=#{default()}"
-      end
-
-      return "#{prefix}#{@name}#{suffix}"
-    end
-  end
-
-  class OptionalArgument < Argument
-    def optional?
-      return true
-    end
-  end
-
-  class NodeOptionalArgument < OptionalArgument
-    attr_reader :node_for_default
-    attr_reader :default
-
-    def initialize(name, default, node_for_default, is_rest, is_block)
-      super(name, is_rest, is_block)
-      @default = default
-      @node_for_default = node_for_default
-    end
-  end
-
-  class YarvOptionalArgument < OptionalArgument
-    attr_reader :iseq
-    attr_reader :pc_start
-    attr_reader :local_idx
-
-    def initialize(name, iseq, pc_start, local_idx, is_rest, is_block)
-      super(name, is_rest, is_block)
-      @iseq = iseq
-      @pc_start = pc_start
-      @local_idx = local_idx
-      @default = nil
-    end
-
-    def inspect
-      default()
-      super
-    end
-
-    def default
-      return @default if @default
-
-      env = Nodewrap::ByteDecoder::Environment.new(@iseq.local_table())
-      local_table_idx = local_table_idx()
-      @iseq.bytedecode(env, @pc_start) do |instr|
-        RubyVM::Instruction::SETLOCAL === instr &&
-        instr.operands[0] == local_table_idx
-      end
-      expressions = env.expressions + env.stack
-
-      @default = expressions[0].rhs.to_s
-      return @default
-    end
-
-    def local_table_idx
-      return @iseq.local_table.size - @local_idx + 1
-    end
-  end
-
+  # Return the names of the local variables of this method.
   def local_vars
     return self.body.local_vars
   end
@@ -169,47 +75,6 @@ module MethodSig
 
     return args
   end
-
-  # An abstraction for a method signature.
-  class Signature
-    attr_reader :origin_class, :name, :arg_names, :args
-
-    def initialize(origin_class, name, arg_names, args)
-      @origin_class = origin_class
-      @name = name
-      @arg_names = arg_names
-      @args = args
-    end
-
-    def to_s
-      return "#{@origin_class}\##{@name}(#{param_list})"
-    end
-
-    def param_list
-      params = @arg_names.map{ |n| args[n].to_s }
-      return params.join(', ')
-    end
-  end
-
-  # An abstraction for a method origin.
-  class Origin
-    attr_reader :file, :line
-
-    def initialize(file, line)
-      @file = file
-      @line = line
-    end
-
-    def to_s
-      return "#{file}:#{line}"
-    end
-  end
-
-  # Return a Method::Origin representing where the method was defined.
-  def origin
-    block = body().next
-    return Origin.new(block.nd_file, block.nd_line)
-  end
 end
 
 class Method
@@ -238,166 +103,6 @@ class UnboundMethod
   end
 end
 
-class Node
-  # pre-YARV
-  class SCOPE
-    include MethodSig
-
-    def local_vars
-      return self.tbl || []
-    end
-
-    def argument_names
-      local_vars = self.local_vars
-      args = self.args_node
-      num_required_args = args.cnt
-      num_optional_args = 0
-      opt = args.opt
-      while opt do
-        num_optional_args += 1
-        opt = opt.next
-      end
-      num_args = \
-        num_required_args + \
-        num_optional_args + \
-        (rest_arg ? 1 : 0) + \
-        (block_arg ? 1 : 0)
-      return local_vars[0...num_args]
-    end
-
-    def args_node
-      if self.next.class == Node::ARGS then
-        return self.next
-      elsif self.next.head.class == Node::ARGS then
-        return self.next.head
-      else
-        raise "Could not find method arguments"
-      end
-    end
-
-    def rest_arg
-      args_node = args_node()
-      rest = args_node.rest()
-      if rest.class == Node::LASGN then
-        # subtract 2 to account for implicit vars
-        return rest.cnt - 2
-      elsif not rest
-        return nil
-      else
-        return rest > 0 ? rest - 2 : nil
-      end
-    end
-
-    def block_arg
-      block = self.next
-      if block.class == Node::BLOCK and
-         block.next.head.class == Node::BLOCK_ARG then
-        # subtract 2 to account for implicit vars
-        return block.next.head.cnt - 2
-      else
-        return nil
-      end
-    end
-
-    def set_optional_args(args, args_node, names)
-      opt = args_node.opt
-      while opt do
-        head = opt.head
-        if head.class == Node::LASGN then
-          args[head.vid] = NodeOptionalArgument.new(
-              head.vid, head.value.as_expression, head.value, false, false)
-        else
-          raise "Unexpected node type: #{opt.class}"
-        end
-        opt = opt.next
-      end
-    end
-  end
-
-  # Pre-YARV, I think
-  class BMETHOD
-    def local_vars
-      raise "TODO: Not implemented yet"
-    end
-
-    def argument_names
-      return self.cval.arguments.names
-    end
-
-    def arguments
-      return self.cval.arguments
-    end
-
-    def args_node
-      raise "TODO: Not implemented yet"
-    end
-
-    def rest_arg
-      raise "TODO: Not implemented yet"
-    end
-
-    def block_arg
-      raise "TODO: Not implemented yet"
-    end
-
-    def set_optional_args(args, args_node, names)
-      raise "TODO: Not implemented yet"
-    end
-  end
-
-  # YARV
-  class METHOD
-    include MethodSig
-
-    def local_vars
-      iseq = self.body
-      local_vars = iseq.local_table
-      return local_vars
-    end
-
-    def argument_names
-      local_vars = self.local_vars
-      iseq = self.body
-      opt_args = iseq.arg_opt_table
-      opt_args.pop # last arg is a pointer to the start of the code
-      num_args = \
-        iseq.argc + \
-        opt_args.size + \
-        (rest_arg ? 1 : 0) + \
-        (block_arg ? 1 : 0)
-      return local_vars[0...num_args]
-    end
-
-    def args_node
-      return nil
-    end
-
-    def rest_arg
-      arg_rest = self.body.arg_rest
-      return arg_rest >= 0 ? arg_rest : nil
-    end
-
-    def block_arg
-      arg_block = self.body.arg_block
-      return arg_block >= 0 ? arg_block : nil
-    end
-
-    def set_optional_args(args, args_node, names)
-      opt_table = self.body.arg_opt_table
-      opt_table.pop
-      first_opt_idx =
-        names.size -
-        opt_table.size -
-        (self.rest_arg ? 1 : 0) -
-        (self.block_arg ? 1 : 0)
-      opt_table.each_with_index do |pc, idx|
-        name = names[first_opt_idx + idx]
-        args[name] = YarvOptionalArgument.new(name, self.body, pc, idx, false, false)
-      end
-    end
-  end
-end
-
 if __FILE__ == $0 then
   def foo(); end
   puts method(:foo).signature