rubinius-ast 1.0.1

data/lib/rubinius/ast/node.rb

@@ -0,0 +1,389 @@
+# -*- encoding: us-ascii -*-
+
+module Rubinius::ToolSet.current::TS
+  module AST
+    class Node
+      attr_accessor :line
+
+      def self.transform(category, name, comment)
+        Transforms.register category, name, self
+        @transform_name = name
+        @transform_comment = comment
+        @transform_kind = :call
+      end
+
+      def self.transform_name
+        @transform_name
+      end
+
+      def self.transform_comment
+        @transform_comment
+      end
+
+      def self.transform_kind
+        @transform_kind
+      end
+
+      def self.transform_kind=(k)
+        @transform_kind = k
+      end
+
+      def self.match_send?(node, receiver, method, name)
+        node.kind_of? ConstantAccess and
+          node.name == receiver and
+          method == name
+      end
+
+      def self.match_arguments?(arguments, count)
+        case arguments
+        when ArrayLiteral
+          arguments.body.size == count
+        when nil
+          count == 0
+        else
+          false
+        end
+      end
+
+      def initialize(line)
+        @line = line
+      end
+
+      def pos(g)
+        g.set_line @line
+      end
+
+      def new_block_generator(g, arguments)
+        blk = g.class.new
+        blk.name = g.state.name || :__block__
+        blk.file = g.file
+        blk.for_block = true
+
+        blk.required_args = arguments.required_args
+        blk.post_args = arguments.post_args
+        blk.total_args = arguments.total_args
+        blk.splat_index = arguments.splat_index
+        blk.block_index = arguments.block_index
+
+        blk
+      end
+
+      def new_generator(g, name, arguments=nil)
+        meth = g.class.new
+        meth.name = name
+        meth.file = g.file
+
+        if arguments
+          meth.required_args = arguments.required_args
+          meth.post_args = arguments.post_args
+          meth.total_args = arguments.total_args
+          meth.splat_index = arguments.splat_index
+          meth.block_index = arguments.block_index
+        end
+
+        meth
+      end
+
+      def bytecode(g)
+      end
+
+      def defined(g)
+        g.push_rubinius
+        g.push_scope
+        g.send :active_path, 0
+        g.push @line
+        g.send :unrecognized_defined, 2
+        g.pop
+        g.push :nil
+      end
+
+      def value_defined(g, f)
+        bytecode(g)
+      end
+
+      # This method implements a sort of tree iterator, yielding each Node
+      # instance to the provided block with the first argument to #walk. If
+      # the block returns a non-true value, the walk is terminated.
+      #
+      # This method is really an iterator, not a Visitor pattern.
+      def walk(arg=true, &block)
+        children do |child|
+          if ch_arg = block.call(arg, child)
+            child.walk(ch_arg, &block)
+          end
+        end
+      end
+
+      def ascii_graph
+        AsciiGrapher.new(self).print
+      end
+
+      # Called if used as the lhs of an ||=. Expected to yield if the
+      # value was not found, so the bytecode for it to be emitted.
+      def or_bytecode(g)
+        found = g.new_label
+        bytecode(g)
+        g.dup
+        g.git found
+        g.pop
+        yield
+        found.set!
+      end
+
+      def to_sexp
+        [:node, self.class.name]
+      end
+
+      # Yields each child of this Node to the block. Additionally, for any
+      # attribute that is an Array, yields each element that is a Node.
+      def children
+        instance_variables.each do |var|
+          child = instance_variable_get var
+          if child.kind_of? Node
+            yield child
+          elsif child.kind_of? Array
+            child.each { |x| yield x if x.kind_of? Node }
+          end
+        end
+      end
+
+      # The equivalent of Some::Module.demodulize.underscore in ActiveSupport.
+      # The code is shamelessly borrowed as well.
+      def node_name
+        name = self.class.name.gsub(/^.*::/, '')
+        name.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+        name.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        name.downcase!
+        name
+      end
+
+      # Supports the Visitor pattern on a tree of Nodes. The +visitor+ should
+      # be an object that responds to methods named after the Node subclasses.
+      # The method called is determined by the #node_name method. Passes both
+      # the node and its parent so that the visitor can maintain nesting
+      # information if desired.
+      #
+      # The #visit implements a read-only traversal of the tree. To modify the
+      # tree, see the #transform methed.
+      def visit(visitor, parent=nil)
+        visitor.__send__ self.node_name, self, parent
+        children { |c| c.visit visitor, self }
+      end
+
+      # Called by #transform to update the child of a Node instance. The
+      # default just calls the attr_accessor for the child. However, Node
+      # subclasses that must synchronize other internal state can override
+      # this method.
+      def set_child(name, node)
+        send :"#{name}=", node
+      end
+
+      # Yields each attribute and its name to the block.
+      def attributes
+        instance_variables.each do |var|
+          child = instance_variable_get var
+          name = var.to_s[1..-1]
+          yield child, name
+        end
+      end
+
+      # A fixed-point algorithm for transforming an AST with a visitor. The
+      # traversal is top-down. The visitor object's method corresponding to
+      # each node (see #node_name) is called for each node, passing the node
+      # and its parent.
+      #
+      # To replace the node in the tree, the visitor method should return a
+      # new node; otherwise, return the existing node. The visitor is free to
+      # change values in the node, but substituting a node causes the entire
+      # tree to be walked repeatedly until no modifications are made.
+      def transform(visitor, parent=nil, state=nil)
+        state ||= TransformState.new
+
+        node = visitor.send :"node_#{node_name}", self, parent
+        state.modify unless equal? node
+
+        node.attributes do |attr, name|
+          if attr.kind_of? Node
+            child = attr.transform visitor, node, state
+            unless attr.equal? child
+              state.modify
+              node.set_child name, child
+            end
+          elsif attr.kind_of? Array
+            attr.each_with_index do |x, i|
+              if x.kind_of? Node
+                child = x.transform visitor, node, state
+                unless x.equal? child
+                  state.modify
+                  attr[i] = child
+                end
+              end
+            end
+          end
+        end
+
+        # Repeat the walk until the tree is not modified.
+        if parent.nil? and state.modified?
+          state.unmodify
+          node = transform visitor, nil, state
+        end
+
+        node
+      end
+
+      # Manage the state of the #transform method.
+      class TransformState
+        def initialized
+          @modified = false
+        end
+
+        def modified?
+          @modified
+        end
+
+        def modify
+          @modified = true
+        end
+
+        def unmodify
+          @modified = false
+        end
+      end
+    end
+
+    # In a perfect world, each AST node would fully encapsulate its state. But
+    # in the real world, some state exists across the AST rather than just in
+    # a node. For example, some nodes need to emit different bytecode when in
+    # a rescue.
+    #
+    # This class maintains state needed as the AST is walked to generate
+    # bytecode. An instance of State is pushed onto a stack in the Generator
+    # instance as each ClosedScope or Iter is entered, and popped when left.
+    class State
+      attr_reader :scope, :super, :eval
+      attr_accessor :check_for_locals
+
+      class << self
+        attr_accessor :flip_flops
+      end
+
+      self.flip_flops ||= 0
+
+      def initialize(scope)
+        @scope = scope
+        @ensure = 0
+        @block = 0
+        @masgn = 0
+        @loop = 0
+        @op_asgn = 0
+        @rescue = []
+        @name = []
+        @check_for_locals = true
+      end
+
+      def push_name(name)
+        @name.push name
+      end
+
+      def pop_name
+        @name.pop
+      end
+
+      def name
+        @name.last
+      end
+
+      def push_rescue(val)
+        @rescue.push(val)
+      end
+
+      def pop_rescue
+        @rescue.pop if rescue?
+      end
+
+      def rescue?
+        @rescue.last
+      end
+
+      def push_ensure
+        @ensure += 1
+      end
+
+      def pop_ensure
+        @ensure -= 1 if ensure?
+      end
+
+      def ensure?
+        @ensure > 0
+      end
+
+      def push_block
+        @block += 1
+      end
+
+      def pop_block
+        @block -= 1 if block?
+      end
+
+      def block?
+        @block > 0
+      end
+
+      def flip_flops
+        State.flip_flops
+      end
+
+      def push_flip_flop
+        State.flip_flops += 1
+      end
+
+      def push_masgn
+        @masgn += 1
+      end
+
+      def pop_masgn
+        @masgn -= 1 if masgn?
+      end
+
+      def masgn?
+        @masgn > 0
+      end
+
+      def push_op_asgn
+        @op_asgn += 1
+      end
+
+      def pop_op_asgn
+        @op_asgn -= 1 if op_asgn?
+      end
+
+      def op_asgn?
+        @op_asgn > 0
+      end
+
+      def push_super(scope)
+        @super = scope
+      end
+
+      alias_method :super?, :super
+
+      def push_eval(scope)
+        @eval = scope
+      end
+
+      alias_method :eval?, :eval
+
+      def push_loop
+        @loop += 1
+      end
+
+      def pop_loop
+        @loop -= 1 if loop?
+      end
+
+      def loop?
+        @loop > 0
+      end
+    end
+  end
+end

data/lib/rubinius/ast/operators.rb

@@ -0,0 +1,394 @@
+# -*- encoding: us-ascii -*-
+
+module Rubinius::ToolSet.current::TS
+  module AST
+    class And < Node
+      attr_accessor :left, :right
+
+      def initialize(line, left, right)
+        @line = line
+        @left = left
+        @right = right
+      end
+
+      def bytecode(g, use_gif=true)
+        @left.bytecode(g)
+        g.dup
+        lbl = g.new_label
+
+        if use_gif
+          g.gif lbl
+        else
+          g.git lbl
+        end
+
+        g.pop
+        @right.bytecode(g)
+        lbl.set!
+      end
+
+      def defined(g)
+        t = g.new_label
+        f = g.new_label
+        done = g.new_label
+
+        case @left
+        when GlobalVariableAccess, InstanceVariableAccess
+          g.goto t
+        else
+          @left.value_defined(g, f)
+          g.pop
+        end
+
+        case @right
+        when GlobalVariableAccess, InstanceVariableAccess
+          g.goto t
+        else
+          @right.value_defined(g, f)
+          g.pop
+        end
+
+        t.set!
+        g.push_literal "expression"
+        g.string_dup
+        g.goto done
+
+        f.set!
+        g.push :nil
+
+        done.set!
+      end
+
+      def sexp_name
+        :and
+      end
+
+      def to_sexp
+        [sexp_name, @left.to_sexp, @right.to_sexp]
+      end
+    end
+
+    class Or < And
+      def bytecode(g)
+        super(g, false)
+      end
+
+      def sexp_name
+        :or
+      end
+    end
+
+    class Not < Node
+      attr_accessor :value
+
+      def initialize(line, value)
+        @line = line
+        @value = value
+      end
+
+      def bytecode(g)
+        true_label = g.new_label
+        end_label = g.new_label
+
+        @value.bytecode(g)
+        g.git true_label
+
+        g.push :true
+        g.goto end_label
+
+        true_label.set!
+        g.push :false
+        end_label.set!
+      end
+
+      def defined(g)
+        t = g.new_label
+        f = g.new_label
+        done = g.new_label
+
+        case @value
+        when GlobalVariableAccess, InstanceVariableAccess
+          g.goto t
+        else
+          @value.value_defined(g, f)
+          g.pop
+        end
+
+        t.set!
+        g.push_literal "expression"
+        g.goto done
+
+        f.set!
+        g.push :nil
+
+        done.set!
+      end
+
+      def to_sexp
+        [:not, @value.to_sexp]
+      end
+    end
+
+    class OpAssign1 < Node
+      attr_accessor :receiver, :op, :arguments, :value
+
+      def initialize(line, receiver, arguments, op, value)
+        @line = line
+        @receiver = receiver
+        @op = op
+        arguments = nil if arguments.is_a?(EmptyArray)
+        @arguments = ActualArguments.new line, arguments
+        @value = value
+      end
+
+      def bytecode(g)
+        pos(g)
+
+        # X: Snippet used for explanation: h[:a] += 3
+        # X: given h = { :a => 2 }
+        # X: Pull h onto the stack
+        @receiver.bytecode(g)
+        # X: Pull :a in
+        @arguments.bytecode(g)
+        recv_stack = @arguments.stack_size + 1
+
+        # Dup the receiver and arguments to use later
+        g.dup_many recv_stack
+
+        #
+        # X: Call [](:a) on h
+        #
+        # @arguments.size will be 1
+
+        if @arguments.splat?
+          g.push :nil
+          g.send_with_splat :[], @arguments.size
+        else
+          g.send :[], @arguments.size
+        end
+
+        # X: 2 is now on the top of the stack (TOS)
+
+        # A special case, where we use the value as boolean
+        if @op == :or or @op == :and
+          fnd = g.new_label
+          fin = g.new_label
+
+          # We dup the value from [] to leave it as the value of the
+          # expression
+
+          g.dup
+          if @op == :or
+            g.git fnd
+          else
+            g.gif fnd
+          end
+
+          # Ok, take the extra copy off and pull the value onto the stack
+          g.pop
+
+          # The receiver and arguments are still on the stack
+
+          @value.bytecode(g)
+
+          # retain the rhs as the expression value
+          g.dup
+          g.move_down recv_stack + 1
+
+          if @arguments.splat?
+            g.send :push, 1
+            g.push :nil
+            g.send_with_splat :[]=, @arguments.size
+          else
+            g.send :[]=, @arguments.size + 1
+          end
+          g.pop
+
+          # Leaves the value we moved down the stack on the top
+          g.goto fin
+
+          fnd.set!
+
+          # Clean up the stack but retain return value from :[]
+          g.move_down recv_stack
+          g.pop_many recv_stack
+
+          fin.set!
+        else
+          # @op is something like + or -
+          # We pull in @value to the stack
+          @value.bytecode(g)
+          # X: 3 TOS
+
+          # ... then call it as an argument to @or, called on the return
+          # from [].
+          # X: 2 + 3
+
+          g.send @op, 1
+          # X: 5 TOS
+
+          # The new value is on the stack now. It is the last argument to the call
+          # to []= because your dupd versions of recv and arguments are still on the stack.
+
+          # retain the rhs as the expression value
+          g.dup
+          g.move_down recv_stack + 1
+
+          # X: Call []=(:a, 5) on h
+          if @arguments.splat?
+            g.send :push, 1
+            g.push :nil
+            g.send_with_splat :[]=, @arguments.size
+          else
+            g.send :[]=, @arguments.size + 1
+          end
+          g.pop
+        end
+      end
+
+      def to_sexp
+        arguments = [:arglist] + @arguments.to_sexp
+        op = @op == :or ? :"||" : :"&&"
+        [:op_asgn1, @receiver.to_sexp, arguments, op, @value.to_sexp]
+      end
+    end
+
+    class OpAssign2 < Node
+      attr_accessor :receiver, :name, :assign, :op, :value
+
+      def initialize(line, receiver, name, op, value)
+        @line = line
+        @receiver = receiver
+        @name = name
+        @op = op
+        @value = value
+        @assign = name.to_s[-1] == ?= ? name : :"#{name}="
+      end
+
+      def bytecode(g)
+        pos(g)
+
+        # X: h[:a] += 3, given h.a == 2
+        @receiver.bytecode(g)
+        # X: TOS = h
+        g.dup
+        g.send @name, 0
+        # X: TOS = 2
+
+        if @op == :or or @op == :and
+          fnd = g.new_label
+          fin = g.new_label
+
+          g.dup
+          if @op == :or
+            g.git fnd
+          else
+            g.gif fnd
+          end
+
+          # Remove the copy of 2 and push @value on the stack
+          g.pop
+          @value.bytecode(g)
+
+          # Retain the this value to use as the expression value
+          g.dup
+          g.move_down 2
+
+          # Call the assignement method, passing @value as the argument
+          g.send @assign, 1
+          g.pop
+
+          g.goto fin
+
+          fnd.set!
+
+          # Clean up the stack
+          g.swap
+          g.pop
+
+          fin.set!
+        else
+          @value.bytecode(g)
+          # X: TOS = 3
+          # X: 2 + 3
+          g.send @op, 1
+
+          # Retain the this value to use as the expression value
+          g.dup
+          g.move_down 2
+          # X: TOS = 5
+          g.send @assign, 1
+          # X: TOS = 5 (or whatever a=() returns)
+
+          # Discard the methods return value
+          g.pop
+        end
+      end
+
+      def to_sexp
+        op = @op == :or ? :"||" : :"&&"
+        [:op_asgn2, @receiver.to_sexp, :"#{@name}=", op, @value.to_sexp]
+      end
+    end
+
+    class OpAssignAnd < Node
+      attr_accessor :left, :right
+
+      def initialize(line, left, right)
+        @line = line
+        @left = left
+        @right = right
+      end
+
+      def bytecode(g)
+        pos(g)
+
+        @left.bytecode(g)
+        lbl = g.new_label
+        g.dup
+        g.gif lbl
+        g.pop
+        @right.bytecode(g)
+        lbl.set!
+      end
+
+      def defined(g)
+        g.push_literal "assignment"
+      end
+
+      def sexp_name
+        :op_asgn_and
+      end
+
+      def to_sexp
+        [sexp_name, @left.to_sexp, @right.to_sexp]
+      end
+    end
+
+    class OpAssignOr < OpAssignAnd
+      def bytecode(g)
+        pos(g)
+
+        @left.or_bytecode(g) do
+          @right.bytecode(g)
+        end
+      end
+
+      def sexp_name
+        :op_asgn_or
+      end
+    end
+
+    class OpAssignOr19 < OpAssignOr
+      def bytecode(g)
+        pos(g)
+
+        g.state.push_op_asgn
+        @left.or_bytecode(g) do
+          g.state.pop_op_asgn
+          @right.bytecode(g)
+        end
+      end
+    end
+  end
+end