wood 0.1.1

data/lib/wood/node_visitor.rb

@@ -0,0 +1,60 @@
+module Wood
+  # Mixin module for {Wood::Node} visitors.
+  module NodeVisitor
+    module ClassMethods
+      # @param node_names [Array<Symbol>] List of node names to be ignored.
+      #
+      # Creates an empty visit handler for all node names in `node_names`.
+      def ignore_nodes(*node_names)
+        node_names.each do |n|
+          define_method(n) do |node|
+            context.ignored = true
+          end
+        end
+      end
+    end
+
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    Context = Struct.new(:ignored)
+
+    def new_context
+      Context.new(false)
+    end
+
+    def contexts
+      @contexts ||= []
+    end
+
+    def context
+      @contexts.last
+    end
+
+    def visit(node)
+      contexts.push new_context
+       __send__(node.node_name, node)
+      contexts.pop
+    end
+
+    def visit_type(node)
+      case node.type
+      when Wood::Types::BuiltinType
+        visit node.type
+      when Wood::Types::CompoundType
+        visit node.type
+      when Wood::Types::CustomType
+        visit node.type
+      else
+        visit node.type.type if node.type
+      end
+    end
+
+    def array(nodes)
+      nodes.each do |n|
+        visit n
+      end
+    end
+  end
+end

data/lib/wood/nodes.rb

@@ -0,0 +1,22 @@
+module Wood
+  module Nodes
+    Node = Wood::Node
+  end
+end
+
+require_relative "nodes/no_op"
+require_relative "nodes/nested_node"
+require_relative "nodes/literals"
+require_relative "nodes/assignment"
+require_relative "nodes/operator"
+require_relative "nodes/null"
+require_relative "nodes/code_block"
+require_relative "nodes/function"
+require_relative "nodes/if_else"
+require_relative "nodes/return"
+require_relative "nodes/break"
+require_relative "nodes/continue"
+require_relative "nodes/for_loop"
+require_relative "nodes/while_loop"
+require_relative "nodes/switch"
+require_relative "nodes/variable"

data/lib/wood/nodes/assignment.rb

@@ -0,0 +1,34 @@
+module Wood::Nodes
+  class Assignment < Node
+    child_nodes :var, :value
+    node_name   :assign
+  end
+
+  class AddAssignment < Assignment
+    node_name   :add_assign
+  end
+
+  class SubAssignment < Assignment
+    node_name   :sub_assign
+  end
+
+  class MulAssignment < Assignment
+    node_name   :mul_assign
+  end
+
+  class DivAssignment < Assignment
+    node_name   :div_assign
+  end
+
+  class BitwiseAndAssignment < Assignment
+    node_name   :band_assign
+  end
+
+  class BitwiseNotAssignment < Assignment
+    node_name   :bnot_assign
+  end
+
+  class BitwiseXORAssignment < Assignment
+    node_name   :xor_assign
+  end
+end

data/lib/wood/nodes/break.rb

@@ -0,0 +1,4 @@
+module Wood::Nodes
+  class Break < Node
+  end
+end

data/lib/wood/nodes/code_block.rb

@@ -0,0 +1,44 @@
+module Wood::Nodes
+  class CodeBlock < Node
+    def self.[](*options)
+      case opts = options.first
+      when Hash
+        new(opts)
+      else
+        new(expressions: options)
+      end
+    end
+
+    include Enumerable
+
+    child_nodes :expressions
+
+    def setup
+      @expressions = Array(expressions).flatten
+    end
+
+    def sexp
+      expressions.map(&:sexp)
+    end
+
+    def empty?
+      expressions.empty?
+    end
+
+    def size
+      expressions.size
+    end
+
+    def each(&block)
+      @expressions.each(&block)
+    end
+
+    def << node
+      @expressions << node
+    end
+
+    def [](idx)
+      @expressions[idx]
+    end
+  end
+end

data/lib/wood/nodes/continue.rb

@@ -0,0 +1,4 @@
+module Wood::Nodes
+  class Continue < Node
+  end
+end

data/lib/wood/nodes/for_loop.rb

@@ -0,0 +1,11 @@
+module Wood::Nodes
+  class ForLoop < Node
+    child_nodes :init_op, :condition, :post_op, :body
+
+    def setup
+      @init_op   = init_op || NoOp[pos: pos]
+      @post_op   = post_op || NoOp[pos: pos]
+      @body      = body    || CodeBlock[pos: pos]
+    end
+  end
+end

data/lib/wood/nodes/function.rb

@@ -0,0 +1,45 @@
+module Wood::Nodes
+  module Function
+    class Argument < Node
+      child_nodes :storage, :type, :name
+
+      def sexp
+        [type.sexp, name]
+      end
+    end
+
+    class Declaration < Node
+      child_nodes :storage, :type, :name, :args
+
+      attr_accessor :scope
+    end
+
+    class Definition < Node
+      child_nodes :storage, :type, :name, :args, :body
+
+      attr_accessor :scope
+
+      def setup
+        @args = args || []
+        @body = body || CodeBlock[pos: pos]
+      end
+    end
+
+    class Call < Node
+      child_nodes :name, :args
+      node_name   :call
+
+      attr_accessor :function
+
+      def setup
+        @args = args || []
+      end
+
+      def type
+        if @function
+          @function.type
+        end
+      end
+    end
+  end
+end

data/lib/wood/nodes/if_else.rb

@@ -0,0 +1,6 @@
+module Wood::Nodes
+  class IfElse < Node
+    child_nodes :condition, :then_branch, :else_branch
+    node_name   :if
+  end
+end

data/lib/wood/nodes/literals.rb

@@ -0,0 +1,68 @@
+module Wood::Nodes
+  class Literal < Node
+    def self.[](options = nil)
+      case options
+      when Hash
+        new(options)
+      else
+        new(value: options)
+      end
+    end
+
+    child_nodes :type, :value
+
+    def sexp
+      [node_name, value]
+    end
+  end
+
+  class IntLiteral < Literal
+    child_nodes :base
+    def setup
+      @type = Wood::Types::Int
+      @base = base || 10
+    end
+  end
+
+  class LongLiteral < Literal
+    def setup
+      @type = Wood::Types::Long
+    end
+  end
+
+  class FloatLiteral < Literal
+    def setup
+      @type = Wood::Types::Float
+    end
+  end
+
+  class DoubleLiteral < Literal
+    def setup
+      @type = Wood::Types::Double
+    end
+  end
+
+  class StringLiteral < Literal
+    def setup
+      @type = Wood::Types::String
+    end
+  end
+
+  class CharLiteral < Literal
+    def setup
+      @type = Wood::Types::Char
+    end
+  end
+
+  class BoolLiteral < Literal
+    def setup
+      @type = Wood::Types::Bool
+    end
+  end
+
+  class TrueLiteral < BoolLiteral
+  end
+
+  class FalseLiteral < BoolLiteral
+  end
+end

data/lib/wood/nodes/nested_node.rb

@@ -0,0 +1,5 @@
+module Wood::Nodes
+  class NestedNode < Node
+    child_nodes :node
+  end
+end

data/lib/wood/nodes/no_op.rb

@@ -0,0 +1,7 @@
+module Wood::Nodes
+  class NoOp < Node
+    def type
+      Wood::Types::Void
+    end
+  end
+end

data/lib/wood/nodes/null.rb

@@ -0,0 +1,4 @@
+module Wood::Nodes
+  class Null < Node
+  end
+end

data/lib/wood/nodes/operator.rb

@@ -0,0 +1,28 @@
+module Wood::Nodes
+  class Operator < Node
+    child_nodes :name, :left, :right
+
+    BOOL_OPS     = [:<, :>, :<=, :>=, :==, :"!=", :"&&", :"||"]
+    NON_BOOL_OPS = [:*, :/, :+, :-, :>>, :<<, :&, :|]
+
+    def boolean?
+      BOOL_OPS.include? name
+    end
+
+    def to_boolean
+      if boolean?
+        return self
+      else
+        return Operator[name: :"!=", left: self, right: IntLiteral[0]]
+      end
+    end
+
+    def type
+      if boolean?
+        Wood::Types::Bool
+      else
+        @type || Wood::Types::CommonType[@left.type, @right.type]
+      end
+    end
+  end
+end

data/lib/wood/nodes/return.rb

@@ -0,0 +1,15 @@
+module Wood::Nodes
+  class Return < Node
+    def self.[](options = nil)
+      case options
+      when Hash
+        new(options)
+      else
+        new(expression: options)
+      end
+    end
+
+    child_nodes :expression
+    attr_accessor :function_def
+  end
+end

data/lib/wood/nodes/switch.rb

@@ -0,0 +1,13 @@
+module Wood::Nodes
+  class Switch < Node
+    class Case < Node
+      child_nodes :expression, :body
+    end
+
+    class DefaultCase < Node
+      child_nodes :body
+    end
+
+    child_nodes :expression, :cases
+  end
+end

data/lib/wood/nodes/variable.rb

@@ -0,0 +1,24 @@
+module Wood::Nodes
+  module Variable
+    class Declaration < Node
+      child_nodes :type, :name, :init_val
+      node_name   :var_decl
+    end
+
+    class Reference < Node
+      def self.[](options)
+        case options
+        when Hash
+          new(options)
+        else
+          new(name: options)
+        end
+      end
+
+      child_nodes :name
+      node_name   :var_ref
+
+      attr_accessor :var
+    end
+  end
+end

data/lib/wood/nodes/while_loop.rb

@@ -0,0 +1,10 @@
+module Wood::Nodes
+  class WhileLoop < Node
+    child_nodes :condition, :body
+    node_name   :while
+
+    def setup
+      @body = body || CodeBlock[pos: pos]
+    end
+  end
+end

data/lib/wood/tree_pattern.rb

@@ -0,0 +1,14 @@
+module Wood
+  module TreePattern
+  end
+end
+
+require_relative "tree_pattern/any_matcher"
+require_relative "tree_pattern/or_matcher"
+require_relative "tree_pattern/variable_matcher"
+require_relative "tree_pattern/type_matcher"
+require_relative "tree_pattern/pattern_builder"
+require_relative "tree_pattern/replacement_builder"
+require_relative "tree_pattern/pattern_callback"
+require_relative "tree_pattern/matcher"
+require_relative "tree_pattern/node_finder"