mutant-melbourne 2.0.1

data/lib/compiler/ast/encoding.rb

@@ -0,0 +1,18 @@
+# -*- encoding: us-ascii -*-
+
+module Rubinius
+  module AST
+    class Encoding < Node
+      attr_accessor :name
+
+      def initialize(line, name)
+        @line = line
+        @name = name
+      end
+
+      def to_sexp
+        [:encoding, @name]
+      end
+    end
+  end
+end

data/lib/compiler/ast/exceptions.rb

@@ -0,0 +1,138 @@
+# -*- encoding: us-ascii -*-
+
+module Rubinius
+  module AST
+    class Begin < Node
+      attr_accessor :rescue
+
+      def initialize(line, body)
+        @line = line
+        @rescue = body || NilLiteral.new(line)
+      end
+
+      def to_sexp
+        @rescue.to_sexp
+      end
+    end
+
+    EnsureType = 1
+
+    class Ensure < Node
+      attr_accessor :body, :ensure
+
+      def initialize(line, body, ensr)
+        @line = line
+        @body = body || NilLiteral.new(line)
+        @ensure = ensr
+      end
+
+      def to_sexp
+        [:ensure, @body.to_sexp, @ensure.to_sexp]
+      end
+    end
+
+    RescueType = 0
+
+    class Rescue < Node
+      attr_accessor :body, :rescue, :else
+
+      def initialize(line, body, rescue_body, else_body)
+        @line = line
+        @body = body
+        @rescue = rescue_body
+        @else = else_body
+      end
+
+      def to_sexp
+        sexp = [:rescue, @body.to_sexp, @rescue.to_sexp]
+        sexp << @else.to_sexp if @else
+        sexp
+      end
+    end
+
+    class RescueCondition < Node
+      attr_accessor :conditions, :assignment, :body, :next, :splat
+
+      def initialize(line, conditions, body, nxt)
+        @line = line
+        @next = nxt
+        @splat = nil
+        @assignment = nil
+
+        case conditions
+        when ArrayLiteral
+          @conditions = conditions
+        when ConcatArgs
+          @conditions = conditions.array
+          @splat = RescueSplat.new line, conditions.rest
+        when SplatValue
+          @splat = RescueSplat.new line, conditions.value
+        when nil
+          condition = ConstantAccess.new line, :StandardError
+          @conditions = ArrayLiteral.new line, [condition]
+        end
+
+        case body
+        when Block
+          @assignment = body.array.shift if assignment? body.array.first
+          @body = body
+        when nil
+          @body = NilLiteral.new line
+        else
+          if assignment? body
+            @assignment = body
+            @body = NilLiteral.new line
+          else
+            @body = body
+          end
+        end
+      end
+
+      def assignment?(node)
+        case node
+        when VariableAssignment
+          value = node.value
+        when AttributeAssignment
+          value = node.arguments.array.last
+        else
+          return false
+        end
+
+        return true if value.kind_of? CurrentException
+      end
+
+      def to_sexp
+        array = @conditions.to_sexp
+        array << @assignment.to_sexp if @assignment
+        array << @splat.to_sexp if @splat
+
+        sexp = [:resbody, array]
+        case @body
+        when Block
+          sexp << (@body ? @body.array.map { |x| x.to_sexp } : nil)
+        when nil
+          sexp << nil
+        else
+          sexp << @body.to_sexp
+        end
+
+        sexp << @next.to_sexp if @next
+
+        sexp
+      end
+    end
+
+    class RescueSplat < Node
+      attr_accessor :value
+
+      def initialize(line, value)
+        @line = line
+        @value = value
+      end
+
+      def to_sexp
+        [:splat, @value.to_sexp]
+      end
+    end
+  end
+end

data/lib/compiler/ast/file.rb

@@ -0,0 +1,11 @@
+# -*- encoding: us-ascii -*-
+
+module Rubinius
+  module AST
+    class File < Node
+      def to_sexp
+        [:file]
+      end
+    end
+  end
+end

data/lib/compiler/ast/grapher.rb

@@ -0,0 +1,89 @@
+# -*- encoding: us-ascii -*-
+
+module Rubinius
+  module AST
+    class AsciiGrapher
+      def initialize(ast, node_kind=Node)
+        @ast = ast
+        @node_kind = node_kind
+      end
+
+      def print
+        graph_node @ast
+      end
+
+      def indented_print(level, value)
+        puts "#{" " * level}#{value}"
+      end
+
+      def print_node(node, level, idx=nil)
+        name = node.class.to_s.split("::").last
+
+        name = "#{name} [#{idx}]" if idx
+
+        indented_print level, name
+      end
+
+      def graph_node(node, level=0, idx=nil)
+        print_node node, level, idx
+        level += 2
+
+        nodes = []
+        node.instance_variables.each do |v|
+          next if v == "@compiler"
+
+          value = node.instance_variable_get v
+
+          # lame, yes. remove when Node doesn't have @body by default
+          next if v == "@body" and value.nil? and not v.respond_to? :body=
+
+          if value.kind_of? @node_kind
+            nodes << [v, value]
+          else
+            graph_value v, value, level
+          end
+        end
+
+        nodes.each do |name, n|
+          puts "#{" " * level}#{name}: \\"
+          graph_node n, level + 2
+        end
+      end
+
+      def graph_simple(name, value, level)
+        puts "#{" " * level}#{name}: #{value}"
+      end
+
+      def graph_value(name, value, level)
+        case value
+        when NilClass, String
+          graph_simple name, value.inspect, level
+        when Symbol
+          puts "#{" " * level}#{name}: :#{value}"
+        when TrueClass, FalseClass, Fixnum
+          graph_simple name, value, level
+        when Array
+          if value.empty?
+            puts "#{" " * level}#{name}: []"
+          else
+            puts "#{" " * level}#{name}: ["
+            nodes = []
+            value.each_with_index do |v,i|
+              if v.kind_of? @node_kind
+                nodes << [v, i]
+              else
+                graph_value "[#{i}] ", v, level + 2
+              end
+            end
+
+            nodes.each { |n| graph_node n[0], level + 2, n[1] }
+
+            puts "#{' ' * level}]"
+          end
+        else
+          graph_simple name, value.class, level
+        end
+      end
+    end
+  end
+end

data/lib/compiler/ast/literals.rb

@@ -0,0 +1,207 @@
+# -*- encoding: us-ascii -*-
+
+module Rubinius
+  module AST
+    class ArrayLiteral < Node
+      attr_accessor :body
+
+      def initialize(line, array)
+        @line = line
+        @body = array
+      end
+
+      def to_sexp
+        @body.inject([:array]) { |s, x| s << x.to_sexp }
+      end
+    end
+
+    class EmptyArray < Node
+      def to_sexp
+        [:array]
+      end
+    end
+
+    class FalseLiteral < Node
+      def to_sexp
+        [:false]
+      end
+    end
+
+    class TrueLiteral < Node
+      def to_sexp
+        [:true]
+      end
+    end
+
+    class FloatLiteral < Node
+      attr_accessor :value
+
+      def initialize(line, str)
+        @line = line
+        @value = str.to_f
+      end
+
+      def to_sexp
+        [:lit, @value]
+      end
+    end
+
+    class HashLiteral < Node
+      attr_accessor :array
+
+      def initialize(line, array)
+        @line = line
+        @array = array
+      end
+
+      def to_sexp
+        @array.inject([:hash]) { |s, x| s << x.to_sexp }
+      end
+    end
+
+    class SymbolLiteral < Node
+      attr_accessor :value
+
+      def initialize(line, sym)
+        @line = line
+        @value = sym
+      end
+
+      def to_sexp
+        [:lit, @value]
+      end
+    end
+
+    class NilLiteral < Node
+      def to_sexp
+        [:nil]
+      end
+    end
+
+    class NumberLiteral < Node
+      attr_accessor :value
+
+      def initialize(line, value)
+        @line = line
+        @value = value
+      end
+
+      def to_sexp
+        [:lit, @value]
+      end
+    end
+
+    class FixnumLiteral < NumberLiteral
+      def initialize(line, value)
+        @line = line
+        @value = value
+      end
+    end
+
+    class Range < Node
+      attr_accessor :start, :finish
+
+      def initialize(line, start, finish)
+        @line = line
+        @start = start
+        @finish = finish
+      end
+
+      def to_sexp
+        [:dot2, @start.to_sexp, @finish.to_sexp]
+      end
+    end
+
+    class RangeExclude < Range
+      def initialize(line, start, finish)
+        @line = line
+        @start = start
+        @finish = finish
+      end
+
+      def to_sexp
+        [:dot3, @start.to_sexp, @finish.to_sexp]
+      end
+    end
+
+    class RegexLiteral < Node
+      attr_accessor :source, :options
+
+      def initialize(line, str, flags)
+        @line = line
+        @source = str
+        @options = flags
+      end
+
+      def to_sexp
+        [:regex, @source, @options]
+      end
+    end
+
+    class StringLiteral < Node
+      attr_accessor :string
+
+      def initialize(line, str)
+        @line = line
+        @string = str
+      end
+
+      def to_sexp
+        [:str, @string]
+      end
+    end
+
+    class DynamicString < StringLiteral
+      attr_accessor :array, :options
+
+      def initialize(line, str, array)
+        @line = line
+        @string = str
+        @array = array
+      end
+
+      def sexp_name
+        :dstr
+      end
+
+      def to_sexp
+        @array.inject([sexp_name, @string]) { |s, x| s << x.to_sexp }
+      end
+    end
+
+    class DynamicSymbol < DynamicString
+      def sexp_name
+        :dsym
+      end
+    end
+
+    class DynamicExecuteString < DynamicString
+      def sexp_name
+        :dxstr
+      end
+    end
+
+    class DynamicRegex < DynamicString
+      def initialize(line, str, array, flags)
+        super line, str, array
+        @options = flags || 0
+      end
+
+      def sexp_name
+        :dregx
+      end
+    end
+
+    class DynamicOnceRegex < DynamicRegex
+      def sexp_name
+        :dregx_once
+      end
+    end
+
+    class ExecuteString < StringLiteral
+      def to_sexp
+        [:xstr, @string]
+      end
+    end
+  end
+end