atomy 0.1.1 → 0.6.3

data/lib/atomy/module.rb

@@ -0,0 +1,144 @@
+require "atomy/compiler"
+require "atomy/locals"
+require "atomy/errors"
+
+require "atomy/method"
+
+module Atomy
+  class Module < ::Module
+    # [Symbol] Absolute path to the file the module was loaded from.
+    attr_reader :file
+
+    def file=(file)
+      @file = file
+      Rubinius::Type.set_module_name(self, File.basename(file.to_s).to_sym, Object)
+    end
+
+    # [Module] Modules users of this module should automatically use.
+    attr_reader :exported_modules
+
+    def initialize
+      extend self
+
+      @exported_modules = []
+
+      # easy accessor for the current module via ConstantScope lookup
+      const_set(:Self, self)
+
+      super
+    end
+
+    def export(*modules)
+      @exported_modules.concat(modules)
+    end
+
+    def compile(gen, node)
+      gen.set_line(node.line) if node.respond_to?(:line) && node.line
+
+      expanded = node
+      while expanded.is_a?(Atomy::Grammar::AST::Node)
+        expanded = expand(expanded)
+      end
+
+      expanded.bytecode(gen, self)
+    rescue
+      puts "when compiling: #{node}"
+      raise
+    end
+
+    def evaluate(node, binding = nil)
+      binding ||=
+        Binding.setup(
+          Rubinius::VariableScope.of_sender,
+          Rubinius::CompiledCode.of_sender,
+          Rubinius::ConstantScope.of_sender,
+          self)
+
+      code = Atomy::Compiler.compile(
+        node,
+        self,
+        Atomy::EvalLocalState.new(binding.variables))
+
+      code.add_metadata :for_eval, true
+
+      block = Atomy::Compiler.construct_block(code, binding)
+      block.call
+    end
+
+    def require(path)
+      Atomy::CodeLoader.require(path)
+    end
+
+    def inspect
+      if @file
+        super.sub(/>$/, " #{@file}>")
+      else
+        super
+      end
+    end
+
+    def use(mod)
+      extend mod
+      include mod
+
+      if mod.is_a?(self.class)
+        mod.exported_modules.each do |m|
+          use(m)
+        end
+      end
+
+      mod
+    end
+
+    # Node -> (Node | Code)
+    def expand(node)
+      raise UnknownCode.new(node)
+    end
+
+    # Node -> Code::Pattern
+    def pattern(node)
+      raise UnknownPattern.new(node)
+    end
+
+    def compile_context
+      return @compile_context if @compile_context
+
+      scope = Rubinius::ConstantScope.new(
+        self,
+        Rubinius::ConstantScope.new(Object))
+
+      meth = proc {}.block.compiled_code
+      meth.metadata = nil
+      meth.name = :__script__
+      meth.scope = scope
+
+      variables =
+        Rubinius::VariableScope.synthesize(
+          meth, self, nil, self, nil, Rubinius::Tuple.new(0))
+
+      if @file
+        script = meth.create_script
+        script.file_path = @file.to_s
+        script.data_path = File.expand_path(@file.to_s)
+        script.make_main!
+
+        scope.script = script
+      end
+
+      @compile_context = Binding.setup(variables, meth, scope)
+    end
+
+    private
+
+    # atomy module semantics are defined via 'extend self', but we have to
+    # make sure that later extends are added *after* self
+    #
+    # this ensures that modules a module use don't take priority over the
+    # module's own methods
+    def extend(mod)
+      return super if mod == self
+
+      mod.include_into(singleton_class.direct_superclass)
+    end
+  end
+end

data/lib/atomy/node/constructable.rb

@@ -0,0 +1,169 @@
+require "atomy/grammar"
+
+module Atomy::Grammar::AST
+  class Node
+    def construct(gen)
+      raise "no #construct for #{self.class}"
+    end
+
+    private
+
+    def push_node(gen, name)
+      gen.push_cpath_top
+      gen.find_const(:Atomy)
+      gen.find_const(:Grammar)
+      gen.find_const(:AST)
+      gen.find_const(name)
+    end
+  end
+
+  class Sequence
+    def construct(gen)
+      push_node(gen, :Sequence)
+      @nodes.each do |node|
+        node.construct(gen)
+      end
+      gen.make_array(@nodes.size)
+      gen.send(:new, 1)
+    end
+  end
+
+  class Number
+    def construct(gen)
+      push_node(gen, :Number)
+      gen.push_int(@value)
+      gen.send(:new, 1)
+    end
+  end
+
+  class Literal
+    def construct(gen)
+      push_node(gen, :Literal)
+      gen.push_literal(@value)
+      gen.send(:new, 1)
+    end
+  end
+
+  class Quote
+    def construct(gen)
+      push_node(gen, :Quote)
+      @node.construct(gen)
+      gen.send(:new, 1)
+    end
+  end
+
+  class QuasiQuote
+    def construct(gen)
+      push_node(gen, :QuasiQuote)
+      @node.construct(gen)
+      gen.send(:new, 1)
+    end
+  end
+
+  class Unquote
+    def construct(gen)
+      push_node(gen, :Unquote)
+      @node.construct(gen)
+      gen.send(:new, 1)
+    end
+  end
+
+  class Constant
+    def construct(gen)
+      push_node(gen, :Constant)
+      gen.push_literal(@text)
+      gen.send(:new, 1)
+    end
+  end
+
+  class Word
+    def construct(gen)
+      push_node(gen, :Word)
+      gen.push_literal(@text)
+      gen.send(:new, 1)
+    end
+  end
+
+  class Prefix
+    def construct(gen)
+      push_node(gen, :Prefix)
+      @node.construct(gen)
+      gen.push_literal(@operator)
+      gen.send(:new, 2)
+    end
+  end
+
+  class Postfix
+    def construct(gen)
+      push_node(gen, :Postfix)
+      @node.construct(gen)
+      gen.push_literal(@operator)
+      gen.send(:new, 2)
+    end
+  end
+
+  class Infix
+    def construct(gen)
+      push_node(gen, :Infix)
+      if @left
+        @left.construct(gen)
+      else
+        gen.push_nil
+      end
+      @right.construct(gen)
+      gen.push_literal(@operator)
+      gen.send(:new, 3)
+    end
+  end
+
+  class Block
+    def construct(gen)
+      push_node(gen, :Block)
+      @nodes.each do |node|
+        node.construct(gen)
+      end
+      gen.make_array(@nodes.size)
+      gen.send(:new, 1)
+    end
+  end
+
+  class List
+    def construct(gen)
+      push_node(gen, :List)
+      @nodes.each do |node|
+        node.construct(gen)
+      end
+      gen.make_array(@nodes.size)
+      gen.send(:new, 1)
+    end
+  end
+
+  class Compose
+    def construct(gen)
+      push_node(gen, :Compose)
+      @left.construct(gen)
+      @right.construct(gen)
+      gen.send(:new, 2)
+    end
+  end
+
+  class Apply
+    def construct(gen)
+      push_node(gen, :Apply)
+      @node.construct(gen)
+      @arguments.each do |node|
+        node.construct(gen)
+      end
+      gen.make_array(@arguments.size)
+      gen.send(:new, 2)
+    end
+  end
+
+  class StringLiteral
+    def construct(gen)
+      push_node(gen, :StringLiteral)
+      gen.push_literal(@value)
+      gen.send(:new, 1)
+    end
+  end
+end

data/lib/atomy/node/equality.rb

@@ -0,0 +1,113 @@
+require "atomy/grammar"
+
+module Atomy::Grammar::AST
+  class Node
+  end
+
+  class Sequence
+    def ==(other)
+      super || other.is_a?(self.class) && @nodes == other.nodes
+    end
+  end
+
+  class Number
+    def ==(other)
+      super || other.is_a?(self.class) && @value == other.value
+    end
+  end
+
+  class Literal
+    def ==(other)
+      super || other.is_a?(self.class) && @value == other.value
+    end
+  end
+
+  class Quote
+    def ==(other)
+      super || other.is_a?(self.class) && @node == other.node
+    end
+  end
+
+  class QuasiQuote
+    def ==(other)
+      super || other.is_a?(self.class) && @node == other.node
+    end
+  end
+
+  class Unquote
+    def ==(other)
+      super || other.is_a?(self.class) && @node == other.node
+    end
+  end
+
+  class Constant
+    def ==(other)
+      super || other.is_a?(self.class) && @text == other.text
+    end
+  end
+
+  class Word
+    def ==(other)
+      super || other.is_a?(self.class) && @text == other.text
+    end
+  end
+
+  class Prefix
+    def ==(other)
+      super || other.is_a?(self.class) && \
+        @operator == other.operator && \
+        @node == other.node
+    end
+  end
+
+  class Postfix
+    def ==(other)
+      super || other.is_a?(self.class) && \
+        @operator == other.operator && \
+        @node == other.node
+    end
+  end
+
+  class Infix
+    def ==(other)
+      super || other.is_a?(self.class) && \
+        @operator == other.operator && \
+        @left == other.left && \
+        @right == other.right
+    end
+  end
+
+  class Block
+    def ==(other)
+      super || other.is_a?(self.class) && @nodes == other.nodes
+    end
+  end
+
+  class List
+    def ==(other)
+      super || other.is_a?(self.class) && @nodes == other.nodes
+    end
+  end
+
+  class Compose
+    def ==(other)
+      super || other.is_a?(self.class) && \
+        @left == other.left && \
+        @right == other.right
+    end
+  end
+
+  class Apply
+    def ==(other)
+      super || other.is_a?(self.class) && \
+        @node == other.node && \
+        @arguments == other.arguments
+    end
+  end
+
+  class StringLiteral
+    def ==(other)
+      super || other.is_a?(self.class) && @value == other.value
+    end
+  end
+end

data/lib/atomy/node/meta.rb

@@ -0,0 +1,206 @@
+module Atomy::Grammar::AST
+  class Node
+    class << self
+      def basename
+        @basename ||= name.split("::").last.to_sym
+      end
+    end
+
+    def each_child
+    end
+
+    def each_attribute
+    end
+
+    def children
+      names = []
+
+      each_child do |name, _|
+        names << name
+      end
+
+      names
+    end
+
+    def attributes
+      names = []
+
+      each_attribute do |name, _|
+        names << name
+      end
+
+      names
+    end
+
+    def accept(x)
+      name = :"visit_#{self.class.basename.downcase}"
+
+      if x.respond_to?(name)
+        x.send(name, self)
+      else
+        x.visit(self)
+      end
+    end
+
+    # Recreate the node, calling the block for sub-nodes and using its return
+    # value in place of the node
+    def through
+      dup
+    end
+  end
+
+  class Sequence
+    def each_child
+      yield :nodes, @nodes
+    end
+
+    def through
+      self.class.new(nodes.collect { |n| yield n })
+    end
+  end
+
+  class Number
+    def each_attribute
+      yield :value, @value
+    end
+  end
+
+  class Literal
+    def each_attribute
+      yield :value, @value
+    end
+  end
+
+  class Quote
+    def each_child
+      yield :node, @node
+    end
+
+    def through
+      self.class.new(yield @node)
+    end
+  end
+
+  class QuasiQuote
+    def each_child
+      yield :node, @node
+    end
+
+    def through
+      self.class.new(yield @node)
+    end
+  end
+
+  class Unquote
+    def each_child
+      yield :node, @node
+    end
+
+    def through
+      self.class.new(yield @node)
+    end
+  end
+
+  class Constant
+    def each_attribute
+      yield :text, @text
+    end
+  end
+
+  class Word
+    def each_attribute
+      yield :text, @text
+    end
+  end
+
+  class Prefix
+    def each_attribute
+      yield :operator, @operator
+    end
+
+    def each_child
+      yield :node, @node
+    end
+
+    def through
+      self.class.new(yield(@node), @operator)
+    end
+  end
+
+  class Postfix
+    def each_attribute
+      yield :operator, @operator
+    end
+
+    def each_child
+      yield :node, @node
+    end
+
+    def through
+      self.class.new(yield(@node), @operator)
+    end
+  end
+
+  class Infix
+    def each_attribute
+      yield :operator, @operator
+    end
+
+    def each_child
+      yield :left, @left if @left
+      yield :right, @right
+    end
+
+    def through
+      self.class.new(@left && yield(@left), yield(@right), @operator)
+    end
+  end
+
+  class Block
+    def each_child
+      yield :nodes, @nodes
+    end
+
+    def through
+      self.class.new(@nodes.collect { |n| yield n })
+    end
+  end
+
+  class List
+    def each_child
+      yield :nodes, @nodes
+    end
+
+    def through
+      self.class.new(@nodes.collect { |n| yield n })
+    end
+  end
+
+  class Compose
+    def each_child
+      yield :left, @left
+      yield :right, @right
+    end
+
+    def through
+      self.class.new(yield(@left), yield(@right))
+    end
+  end
+
+  class Apply
+    def each_child
+      yield :node, @node
+      yield :arguments, @arguments
+    end
+
+    def through
+      self.class.new(yield(@node), @arguments.collect { |a| yield a })
+    end
+  end
+
+  class StringLiteral
+    def each_attribute
+      yield :value, @value
+    end
+  end
+end