rubymirrors 0.0.1

data/lib/maglev/reflection/field_mirror.rb

@@ -0,0 +1,39 @@
+require 'ruby/reflection/field_mirror/class_variable_mirror'
+require 'ruby/reflection/field_mirror/instance_variable_mirror'
+require 'ruby/reflection/field_mirror/constant_mirror'
+require 'maglev/reflection/field_mirror/fixed_instance_variable_mirror'
+
+module Maglev
+  class Reflection
+    class FieldMirror < Mirror
+      include AbstractReflection::FieldMirror
+      Field = Struct.new(:object, :name)
+      reflect! Field
+
+      def self.mirror_class(field)
+        if reflects?(field)
+          case
+          when field.name.start_with?("@@")
+            Ruby::Reflection::ClassVariableMirror
+          when field.name.start_with?("@")
+            Ruby::Reflection::InstanceVariableMirror
+          when field.name === Symbol
+            FixedInstanceVariableMirror
+          else
+            Ruby::Reflection::ConstantMirror
+          end
+        end
+      end
+
+      def initialize(obj)
+        super
+        @object = obj.object
+        @name = obj.name
+      end
+
+      def name
+        @name
+      end
+    end
+  end
+end

data/lib/maglev/reflection/field_mirror/fixed_instance_variable_mirror.rb

@@ -0,0 +1,25 @@
+require 'maglev/reflection/core_ext/module'
+
+module Maglev
+  class Reflection
+    class FixedInstanceVariableMirror < FieldMirror
+      def initialize(obj)
+        super
+        fixed_ivs = @object.__inst_var_names.to_a
+        @index = index(@name)
+      end
+
+      def public?
+        false
+      end
+
+      def protected?
+        false
+      end
+
+      def private?
+        true
+      end
+    end
+  end
+end

data/lib/maglev/reflection/method_mirror.rb

@@ -0,0 +1,149 @@
+require 'maglev/reflection/core_ext/method'
+
+module Maglev
+  class Reflection
+    class MethodMirror < Mirror
+      include AbstractReflection::MethodMirror
+      reflect! Method, UnboundMethod, GsNMethod
+
+      # Adding support for on-demand wrapping of GsNMethods
+      def initialize(obj)
+        super
+        if @subject.kind_of? GsNMethod
+          @subject = wrap_gsmeth(@subject)
+        end
+      end
+
+      def file
+        (@subject.source_location || [])[0]
+      end
+
+      def file=(string)
+        raise CapabilitiesExceeded unless regular_method?
+        reload_after do
+          defining_class.reflectee.class_eval(source, string, line)
+        end
+      end
+
+      def line
+        (@subject.source_location || [])[1]
+      end
+
+      def line=(num)
+        raise CapabilitiesExceeded unless regular_method?
+        reload_after do
+          defining_class.reflectee.class_eval(source, file, num)
+        end
+      end
+
+      def source
+        gsmeth.__source_string
+      end
+
+      def source=(str)
+        raise CapabilitiesExceeded unless regular_method?
+        reload_after do
+          if file.nil? && line.nil? # Smalltalk method
+            defining_class.reflectee.__compile_method_category_environment_id(str, '*maglev-dynamic-compile-unclassified', 1)
+          else # Ruby method
+            defining_class.reflectee.class_eval(str, file, line)
+          end
+        end
+      end
+
+      def selector
+        @subject.name.to_s
+      end
+
+      def defining_class
+        reflection.reflect gsmeth.__in_class
+      end
+
+      def arguments
+        gsmeth.__args_and_temps.to_a[0...gsmeth.__num_args].collect(&:to_s)
+      end
+
+      def block_argument
+        return nil unless gsmeth.__selector.to_s[-1] == ?&
+        arguments.last
+      end
+
+      def optional_arguments
+        opt_arg_offset = gsmeth.__ruby_opt_args_bits.to_s(2).reverse.index(?1)
+        argsize = gsmeth.__num_args
+        unless opt_arg_offset
+          if block_argument && splat_argument
+            opt_arg_offset = argsize - 2
+          elsif block_argument || splat_argument
+            opt_arg_offset = argsize - 1
+          else
+            opt_arg_offset = -2
+          end
+        end
+        arguments[opt_arg_offset..-1]
+      end
+
+      def required_arguments
+        arguments - optional_arguments
+      end
+
+      def splat_argument
+        return nil unless gsmeth.__selector.to_s[-2] == ?*
+        block_argument ? arguments[-2] : arguments[-1]
+      end
+
+      def step_offsets
+        gsmeth.__source_offsets
+      end
+
+      def send_offsets
+        offs = gsmeth.__source_offsets_of_sends.to_a
+        offs = offs.each_slice(2).collect do |offset, selector|
+          [prefix_if_ruby_selector(selector), offset]
+        end
+        Hash[*offs.flatten]
+      end
+
+      def bytecodes
+        gsmeth.__ip_steps.to_a.collect {|ip| gsmeth.__opcode_info_at(ip) }
+      end
+
+      def delete
+        raise CapabilitiesExceeded unless regular_method?
+        gsmeth.__in_class.remove_method(selector)
+      end
+
+      private
+      def wrap_gsmeth(gsmethod)
+        label = gsmethod.__name.to_s
+        cls = gsmethod.__in_class
+        if cls.instance_methods.include?(label)
+          cls.instance_method(label)
+        else
+          GsNMethodWrapper.new(gsmethod)
+        end
+      end
+
+      def gsmeth
+        @subject.__st_gsmeth
+      end
+
+      # Removes the Ruby suffix from the GsNMethod selector
+      def prefix_if_ruby_selector(sym)
+        selector = sym.to_s
+        selector[0...(selector.rindex(?#) || -1)]
+      end
+
+      def regular_method?
+        not (gsmeth.__is_method_for_block || gsmeth.__in_class.nil?)
+      end
+
+      def reload_after(&block)
+        cls = defining_class.reflectee
+        sel = selector.to_sym
+        yield
+        @subject = cls.instance_method(sel)
+      end
+    end
+  end
+end

data/lib/maglev/reflection/mirror.rb

@@ -0,0 +1,6 @@
+module Maglev
+  class Reflection
+    class Mirror < Ruby::Reflection::Mirror
+    end
+  end
+end

data/lib/maglev/reflection/object_mirror.rb

@@ -0,0 +1,18 @@
+module Maglev
+  class Reflection
+    class ObjectMirror < Ruby::Reflection::ObjectMirror
+      reflect! Object
+
+      private
+      def field_mirrors(list, subject = @subject)
+        list.collect do |name|
+          field_mirror(subject, name)
+        end
+      end
+
+      def field_mirror(subject, name)
+        reflection.reflect FieldMirror::Field.new(subject, name)
+      end
+    end
+  end
+end

data/lib/maglev/reflection/stack_frame_mirror.rb

@@ -0,0 +1,104 @@
+module Maglev
+  class Reflection
+    class StackFrameMirror < ObjectMirror
+      include AbstractReflection::StackFrameMirror
+      reflect! ThreadMirror::StackFrame
+
+      attr_reader :method
+
+      def initialize(obj)
+        super
+        @method = obj.method
+        @index = obj.index
+        @thread = obj.thread
+      end
+
+      def name
+        @method.selector
+      end
+
+      def receiver
+        reflection.reflect detailed_report[1]
+      end
+
+      def self
+        reflection.reflect detailed_report[2]
+      end
+
+      def selector
+        reflection.reflect detailed_report[3].to_s
+      end
+
+      def arguments
+        args_and_temps(0, num_args - 1)
+      end
+
+      def locals
+        args_and_temps(num_args, -1)
+      end
+
+      def step_offset
+        detailed_report[4]
+      end
+
+      def source_offset
+        detailed_report[5][step_offset - 1]
+      end
+
+      def variable_context
+        raise NotImplementedError, "TODO"
+        @thread.reflectee.__frame_contents_at(@index)[3]
+      end
+
+      def restart
+        @thread.reflectee.__trim_stack_to_level(@index)
+        true
+      end
+
+      def pop
+        @thread.reflectee.__trim_stack_to_level(@index + 1)
+        true
+      end
+
+      def step(*args)
+        @thread.step(*args)
+        true
+      end
+
+      def inspect
+        "#<#{self.class}: #{@index}: #{@method.defining_class}##{@method.name}>"
+      end
+
+      private
+      def detailed_report
+        @report ||= @thread.thread_report(@index)
+      end
+
+      def num_args
+        @method.arguments.size
+      end
+
+      def args_and_temps(from, to)
+        names = detailed_report[6][from..to].collect(&:to_s)
+        values = detailed_report[7][from..to].collect(&:to_s)
+        (values.size - names.size).times {|i| names << ".temp#{i+1}"}
+        values.map! {|v| reflection.reflect v }
+        FrameHash[names.zip(values)].tap {|o| o.frame = self }
+      end
+
+      class FrameHash < Hash
+        attr_writer :frame
+
+        def []=(key, value)
+          super
+          if @frame
+            @frame.thread.reflectee.__frame_at_temp_named_put(@frame.index,
+                                                              key.to_s,
+                                                              value)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/maglev/reflection/thread_mirror.rb

@@ -0,0 +1,116 @@
+require 'maglev/reflection/core_ext/thread'
+require 'maglev/reflection/core_ext/method'
+require 'maglev/reflection/core_ext/maglev'
+require 'maglev/objectlog'
+
+module Maglev
+  class Reflection
+    class ThreadMirror < Ruby::Reflection::ThreadMirror
+      reflect! Thread
+      StackFrame = Struct.new :method, :index, :thread
+      ExceptionHandlers = {}
+
+      def self.copy_active_thread
+        save_thread("Continuation #{Thread.current}").continuation
+      end
+
+      def stack
+        @subject.__stack_depth.times.collect do |idx|
+          method = reflection.reflect @subject.__method_at(idx + 1)
+          frame = StackFrame.new method, idx + 1, self
+          StackFrameMirror.reflect frame, reflection
+        end
+      end
+
+      # Maglev specific
+      def thread_report(index)
+        @subject.__gsi_debugger_detailed_report_at(index)
+      end
+
+      def run
+        if @subject.__is_continuation
+          Thread.start { @subject.__value(nil) }.run
+        end
+        super
+      end
+
+      def wakeup
+        if @subject.__is_continuation
+          raise RuntimeError, "cannot wakeup a continuation with #wakeup"
+        end
+        super
+      end
+
+      def step(symbol = :over)
+        case symbol
+        when :into
+          @subject.__step_over_in_frame(0)
+        when :over
+          @subject.__step_over_in_frame(1)
+        when :through
+          raise NotImplementedError, "not implemented yet"
+        when Fixnum
+          @subject.__step_over_in_frame(symbol)
+        end
+      end
+
+      def handle_exception(e = Exception, &block)
+        ExceptionHandlers[@subject.object_id] ||= []
+        ExceptionHandlers[@subject.object_id] << proc do |ex|
+          block[ex] if [*e].any? {|ec| ex.is_a? ec }
+        end
+
+        Exception.install_debug_block do |ex|
+          if handlers = ExceptionHandlers[Thread.current.object_id]
+            handlers.each {|h| h[ex] }
+          end
+        end
+      end
+
+      # Maglev specific... for now
+      def raw_stack
+        stack # Force cache refresh
+      end
+
+      def thread_data
+        @subject.__client_data
+      end
+
+      def compiler_state
+        thread_data.first
+      end
+
+      def shift(block = Proc.new)
+        cm = self.method(:reset).__st_gsmeth
+        markLevel = nil
+        level = 1
+        idx = nil
+        while aFrame = Thread.__frame_contents_at(level) and idx == nil
+          idx = level if aFrame[0] == cm
+          level += 1
+        end
+        raise(RuntimeError, "no enclosing #reset") if idx.nil?
+        # from my caller to the reset caller
+        partial_cc = Thread.__partialContinuationFromLevel_to(2, idx + 1)
+        res = block.call(reflection.reflect(partial_cc))
+
+        # Now, return execution to the reset: call and replace the
+        # top-of-stack with the result of the block
+
+        # from reset to reset caller
+        cc = Thread.__partialContinuationFromLevel_to(idx - 1, idx + 1)
+        Thread.__installPartialContinuation_atLevel_value(cc, idx + 1, res)
+      end
+
+      def reset(block = Proc.new)
+        (proc { block.call }).call
+      end
+
+      def call(arg)
+        if @subject.__is_partial_continuation
+          Thread.__installPartialContinuation_atLevel_value(@subject, 1, arg)
+        end
+      end
+    end
+  end
+end