atomy 0.1.1 → 0.6.3

data/lib/ast/internal/let_macro.rb

@@ -1,35 +0,0 @@
-module Atomy
-  module AST
-    class LetMacro < Node
-      children :body, [:macros]
-      generate
-
-      def bytecode(g)
-        pos(g)
-
-        defined = {}
-        @macros.each do |m|
-          defined[m.pattern.method_name] =
-            m.pattern.register_macro m.body, true
-        end
-
-        @body.compile(g)
-
-        @macros.each do |m|
-          name = defined[m.pattern.method_name]
-
-          Atomy::Macro::Environment.singleton_class.remove_method(name)
-
-          meth = Atomy::Macro::Environment.let[m.pattern.method_name]
-          next unless meth && !meth.empty?
-
-          Atomy::Macro::Environment.singleton_class.send(
-            :define_method,
-            name,
-            meth.pop
-          )
-        end
-      end
-    end
-  end
-end

data/lib/ast/internal/macro_quote.rb

@@ -1,23 +0,0 @@
-module Atomy
-  module AST
-    class MacroQuote < Node
-      attributes :name, :contents, [:flags]
-      generate
-
-      def bytecode(g)
-        pos(g)
-        g.push_literal :impossible
-      end
-
-      def expand
-        Atomy::Macro::Environment.quote(
-          @name,
-          @contents,
-          @flags
-        ).to_node
-      end
-
-      alias :prepare :expand
-    end
-  end
-end

data/lib/ast/internal/match.rb

@@ -1,53 +0,0 @@
-module Atomy
-  module AST
-    class Match < Node
-      children :target, :body
-      generate
-
-      def bytecode(g)
-        pos(g)
-
-        done = g.new_label
-
-        @target.compile(g)
-
-        @body.contents.each do |e|
-          MatchBranch.new(e.line, e.lhs, e.rhs).bytecode(g, done)
-        end
-
-        g.pop
-        g.push_nil
-
-        done.set!
-      end
-    end
-
-    class MatchBranch < InlinedBody
-      children :pattern, :branch
-      generate
-
-      def bytecode(g, done)
-        pos(g)
-
-        setup(g)
-
-        skip = g.new_label
-
-        pat = @pattern.to_pattern
-        exp = @branch
-
-        g.dup
-        pat.matches?(g)
-        g.gif skip
-
-        pat.deconstruct(g)
-        exp.compile(g)
-        g.goto done
-
-        skip.set!
-
-        reset(g)
-      end
-    end
-  end
-end

data/lib/ast/internal/module.rb

@@ -1,30 +0,0 @@
-module Atomy
-  module AST
-    class Module < Node
-      children :name, :body
-      generate
-
-      def module_name
-        case @name
-        when Constant
-          Rubinius::AST::ModuleName.new @line, @name.name
-        when ToplevelConstant
-          Rubinius::AST::ToplevelModuleName.new @line, @name
-        when ScopedConstant
-          Rubinius::AST::ScopedModuleName.new @line, @name
-        else
-          @name
-        end
-      end
-
-      def module_body
-        Rubinius::AST::ModuleScope.new @line, module_name, @body
-      end
-
-      def bytecode(g)
-        module_name.bytecode(g)
-        module_body.bytecode(g)
-      end
-    end
-  end
-end

data/lib/ast/internal/pattern.rb

@@ -1,17 +0,0 @@
-module Atomy::AST
-  class Pattern < Node
-    attributes :pattern
-    generate
-
-    def construct(g, d = nil)
-      get(g)
-      g.push_int(@line)
-      @pattern.construct(g)
-      g.send :new, 2
-    end
-
-    def bytecode(g)
-      @pattern.construct(g)
-    end
-  end
-end

data/lib/ast/internal/return.rb

@@ -1,29 +0,0 @@
-module Atomy
-  module AST
-    class Return < Node
-      children :value
-      generate
-
-      def bytecode(g, force = false)
-        if @value
-          @value.compile(g)
-        else
-          g.push_nil
-        end
-
-        if lcl = g.state.rescue?
-          g.push_stack_local lcl
-          g.restore_exception_state
-        end
-
-        if g.state.block?
-          g.raise_return
-        elsif !force and g.state.ensure?
-          g.ensure_return
-        else
-          g.ret
-        end
-      end
-    end
-  end
-end

data/lib/ast/internal/set.rb

@@ -1,19 +0,0 @@
-module Atomy
-  module AST
-    class Set < Node
-      children :lhs, :rhs
-      generate
-
-      def bytecode(g)
-        pos(g)
-
-        if @lhs.respond_to?(:assign)
-          @lhs.assign(g, @rhs)
-          return
-        end
-
-        @lhs.to_pattern.assign(g, @rhs, true)
-      end
-    end
-  end
-end

data/lib/ast/internal/singleton_class.rb

@@ -1,18 +0,0 @@
-module Atomy
-  module AST
-    class SingletonClass < Node
-      children :receiver, :body
-      generate
-
-      def sclass_body
-        Rubinius::AST::SClassScope.new @line, @body
-      end
-
-      def bytecode(g)
-        pos(g)
-        @receiver.compile(g)
-        sclass_body.bytecode(g)
-      end
-    end
-  end
-end

data/lib/ast/internal/splat.rb

@@ -1,14 +0,0 @@
-module Atomy
-  module AST
-    class Splat < Node
-      children :value
-      generate
-
-      def bytecode(g)
-        pos(g)
-        @value.compile(g)
-        g.cast_array unless @value.kind_of?(List)
-      end
-    end
-  end
-end

data/lib/ast/internal/when.rb

@@ -1,24 +0,0 @@
-module Atomy
-  module AST
-    class When < Node
-      children :condition, :then
-      generate
-
-      def bytecode(g)
-        done = g.new_label
-        nope = g.new_label
-
-        @condition.compile(g)
-        g.gif nope
-
-        @then.compile(g)
-        g.goto done
-
-        nope.set!
-        g.push_nil
-
-        done.set!
-      end
-    end
-  end
-end

data/lib/ast/list.rb

@@ -1,25 +0,0 @@
-module Atomy
-  module AST
-    class List < Node
-      children [:elements]
-      generate
-
-      def as_message(send)
-        send.dup.tap do |s|
-          s.arguments = @elements
-          s.method_name = "[]"
-        end
-      end
-
-      def bytecode(g)
-        pos(g)
-
-        @elements.each do |e|
-          e.compile(g)
-        end
-
-        g.make_array @elements.size
-      end
-    end
-  end
-end

data/lib/ast/macro.rb

@@ -1,37 +0,0 @@
-module Atomy
-  module AST
-    class Macro < Node
-      children :pattern, :body
-      generate
-
-      def bytecode(g)
-        # register macro during compilation too.
-        @pattern.register_macro @body
-
-        done = g.new_label
-        skip = g.new_label
-
-        g.push_cpath_top
-        g.find_const :Atomy
-        g.find_const :CodeLoader
-        g.send :compiled?, 0
-        g.git skip
-
-        load_bytecode(g)
-        g.goto done
-
-        skip.set!
-        g.push_nil
-
-        done.set!
-      end
-
-      def load_bytecode(g)
-        pos(g)
-        @pattern.construct(g)
-        @body.construct(g)
-        g.send :register_macro, 1
-      end
-    end
-  end
-end

data/lib/ast/node.rb

@@ -1,599 +0,0 @@
-module Atomy
-  def self.unquote_splice(n)
-    n.collect do |x|
-      Atomy::AST::Quote.new(x.line, x)
-    end.to_node
-  end
-
-  module AST
-    module SentientNode
-      # hash from attribute to the type of child node it is
-      # :normal = normal, required subnode
-      # :many = an array of subnodes
-      # :optional = optional (might be nil)
-      def reset_children
-        @@children = {
-          :required => [],
-          :many => [],
-          :optional => []
-        }
-      end
-
-      def reset_attributes
-        @@attributes = {
-          :required => [],
-          :many => [],
-          :optional => []
-        }
-      end
-
-      def reset_slots
-        @@slots = {
-          :required => [],
-          :many => [],
-          :optional => []
-        }
-      end
-
-      def inherited(sub)
-        sub.reset_children
-        sub.reset_attributes
-        sub.reset_slots
-      end
-
-      def self.extended(sub)
-        sub.reset_children
-        sub.reset_attributes
-        sub.reset_slots
-      end
-
-      def spec(into, specs)
-        specs.each do |s|
-          if s.kind_of?(Array)
-            if s.size == 2
-              into[:optional] << s
-            else
-              into[:many] << s[0]
-            end
-          elsif s.to_s[-1] == ??
-            into[:optional] << [s.to_s[0..-2].to_sym, "nil"]
-          else
-            into[:required] << s
-          end
-        end
-      end
-
-      def attributes(*specs)
-        spec(@@attributes, specs)
-      end
-
-      def slots(*specs)
-        spec(@@slots, specs)
-      end
-
-      def children(*specs)
-        spec(@@children, specs)
-      end
-
-      def many_construct(n)
-        x = <<END
-          spliced = false
-          size = 0
-          @#{n}.each do |e|
-            if e.kind_of?(::Atomy::AST::Splice) && d == 1
-              g.make_array size if size > 0
-              e.construct(g, d)
-              g.send :+, 1 if size > 0 || spliced
-              spliced = true
-              size = 0
-            else
-              e.construct(g, d)
-              size += 1
-            end
-          end
-
-          g.make_array size
-
-          g.send :+, 1 if spliced
-END
-        x
-      end
-
-      def generate
-        all = []
-        args = ""
-        (@@children[:required] + @@children[:many] +
-         @@attributes[:required] + @@attributes[:many] +
-         @@slots[:required] + @@slots[:many]).each do |x|
-          all << x.to_s
-          args << ", #{x}_"
-        end
-
-        (@@children[:optional] + @@attributes[:optional]).each do |x, d|
-          all << x.to_s
-          args << ", #{x}_ = #{d}"
-        end
-
-        non_slots = all.dup
-        @@slots[:optional].each do |x, d|
-          all << x.to_s
-          args << ", #{x}_ = #{d}"
-        end
-
-        class_eval <<EOF
-          attr_accessor :line#{all.collect { |a| ", :#{a}" }.join}
-EOF
-
-        class_eval <<EOF
-          def initialize(line#{args})
-            @line = line
-            #{all.collect { |a| "@#{a} = #{a}_" }.join("; ")}
-          end
-EOF
-
-        class_eval <<EOF
-          def construct(g, d = nil)
-            get(g)
-            g.push_int(@line)
-
-            #{@@children[:required].collect { |n|
-                "@#{n}.construct(g, d)"
-              }.join("; ")}
-
-            #{@@children[:many].collect { |n|
-                many_construct(n)
-              }.join("; ")}
-
-            #{@@attributes[:required].collect { |a|
-                "g.push_literal(@#{a})"
-              }.join("; ")}
-
-            #{@@attributes[:many].collect { |a|
-                "@#{a}.each { |n| g.push_literal n }; g.make_array(@#{a}.size)"
-              }.join("; ")}
-
-            #{@@slots[:required].collect { |a|
-                "g.push_literal(@#{a})"
-              }.join("; ")}
-
-            #{@@slots[:many].collect { |a|
-                "@#{a}.each { |n| g.push_literal n }; g.make_array(@#{a}.size)"
-              }.join("; ")}
-
-            #{@@children[:optional].collect { |n, _|
-                "if @#{n}; @#{n}.construct(g, d); else; g.push_nil; end"
-              }.join("; ")}
-
-            #{@@attributes[:optional].collect { |a, _|
-                "g.push_literal(@#{a})"
-              }.join("; ")}
-
-            #{@@slots[:optional].collect { |a, _|
-                "g.push_literal(@#{a})"
-              }.join("; ")}
-
-            g.send :new, #{all.size + 1}
-          end
-EOF
-
-        class_eval <<EOF
-          def ==(b)
-            b.kind_of?(#{self.name}) \\
-            #{non_slots.collect { |a| " and @#{a} == b.#{a}" }.join}
-          end
-EOF
-
-        req_cs =
-          @@children[:required].collect { |n|
-            ", @#{n}.recursively(pre, post, :#{n}, &f)"
-          }.join
-
-        many_cs =
-          @@children[:many].collect { |n|
-            ", @#{n}.each_with_index.collect { |n, i| n.recursively(pre, post, [:#{n}, i], &f) }"
-          }.join
-
-        opt_cs =
-          @@children[:optional].collect { |n, _|
-            ", @#{n} ? @#{n}.recursively(pre, post, :#{n}, &f) : nil"
-          }.join
-
-        req_as =
-          (@@attributes[:required] + @@attributes[:many]).collect { |a|
-            ", @#{a}"
-          }.join
-
-        opt_as = @@attributes[:optional].collect { |a, _|
-            ", @#{a}"
-          }.join
-
-        req_ss =
-          (@@slots[:required] + @@slots[:many]).collect { |a|
-            ", @#{a}"
-          }.join
-
-        opt_ss = @@slots[:optional].collect { |a, _|
-            ", @#{a}"
-          }.join
-
-        class_eval <<EOF
-          def recursively(pre = nil, post = nil, context = nil, &f)
-            if pre and pre.arity == 2
-              stop = pre.call(self, context)
-            elsif pre
-              stop = pre.call(self)
-            else
-              stop = false
-            end
-
-            if stop
-              if f.arity == 2
-                res = f.call(self, context)
-                post.call(context) if post
-                return res
-              else
-                res = f.call(self)
-                post.call(context) if post
-                return res
-              end
-            end
-
-            recursed = #{self.name}.new(
-              @line#{req_cs + many_cs + req_as + req_ss + opt_cs + opt_as + opt_ss}
-            )
-
-            if f.arity == 2
-              res = f.call(recursed, context)
-            else
-              res = f.call(recursed)
-            end
-
-            post.call(context) if post
-
-            res
-          end
-EOF
-
-        class_eval <<EOF
-          def bottom?
-            #{@@children.values.flatten(1).empty?.inspect}
-          end
-EOF
-
-        attrs =
-          @@attributes[:required] + @@attributes[:many] +
-            @@attributes[:optional].collect(&:first)
-
-        class_eval <<EOF
-          def details
-            #{attrs.inspect}
-          end
-EOF
-
-        slots =
-          @@slots[:required] + @@slots[:many] +
-            @@slots[:optional].collect(&:first)
-
-        class_eval <<EOF
-          def slots
-            #{slots.inspect}
-          end
-EOF
-
-        required = @@children[:required].collect { |c| ", [:\"#{c}\", @#{c}.to_sexp]" }.join
-        many = @@children[:many].collect { |c| ", [:\"#{c}\", @#{c}.collect(&:to_sexp)]" }.join
-        optional = @@children[:optional].collect { |c, _| ", [:\"#{c}\", @#{c} && @#{c}.to_sexp]" }.join
-
-        a_required = @@attributes[:required].collect { |c| ", [:\"#{c}\", @#{c}]" }.join
-        a_many = @@attributes[:many].collect { |c| ", [:\"#{c}\", @#{c}]" }.join
-        a_optional = @@attributes[:optional].collect { |c, _| ", [:\"#{c}\", @#{c}]" }.join
-
-        class_eval <<EOF
-          def to_sexp
-            [:"#{self.name.split("::").last.downcase}"#{required}#{many}#{optional}#{a_required}#{a_many}#{a_optional}]
-          end
-EOF
-
-      end
-    end
-
-    module NodeLike
-      attr_accessor :line
-
-      # yield this node's subnodes to a block recursively, and then itself
-      # override this if for nodes with children, ie lists
-      #
-      # stop = predicate to determine whether to stop at a node before
-      # recursing into its children
-      def recursively(stop = nil, &f)
-        f.call(self)
-      end
-
-      # used to construct this expression in a quasiquote
-      # g = generator, d = depth
-      #
-      # quasiquotes should increase depth, unquotes should decrease
-      # an unquote at depth 0 should push the unquote's contents rather
-      # than itself
-      def construct(g, d)
-        raise Rubinius::CompileError, "no #construct for #{self}"
-      end
-
-      def through_quotes(pre_ = nil, post_ = nil, &f)
-        depth = 0
-
-        pre = proc { |x, c|
-          (pre_ && pre_.call(*([x, c, depth][0, pre_.arity])) && depth == 0) || \
-            x.kind_of?(AST::QuasiQuote) || \
-            x.unquote?
-        }
-
-        rpre = proc { |x, c|
-          pre_ && pre_.call(*([x, c, 0][0, pre_.arity]))
-        }
-
-        post = proc { post_ && post_.call }
-
-        action = proc { |e, c|
-          if e.unquote?
-            depth -= 1
-            if depth == 0
-              depth += 1
-              u = e.expression.recursively(rpre, post_, :unquoted, &f)
-              next e.class.new(
-                e.line,
-                u
-              )
-            end
-
-            u = e.expression.recursively(pre, post, :expression, &action)
-            depth += 1
-            e.class.new(
-              e.line,
-              u
-            )
-          elsif e.kind_of?(Atomy::AST::QuasiQuote)
-            depth += 1
-            q = e.expression.recursively(pre, post, :expression, &action)
-            depth -= 1
-            Atomy::AST::QuasiQuote.new(
-              e.line,
-              q
-            )
-          else
-            if depth == 0
-              f.call(e)
-            else
-              e
-            end
-          end
-        }
-
-        recursively(pre, post, &action)
-      end
-
-      def unquote(d)
-        return unless d
-        d - 1
-      end
-
-      def quote(d)
-        return unless d
-        d + 1
-      end
-
-      def get(g)
-        g.push_cpath_top
-        self.class.name.split("::").each do |n|
-          g.find_const n.to_sym
-        end
-      end
-
-      def to_node
-        self
-      end
-
-      def to_send
-        Send.new(
-          @line,
-          Primitive.new(@line, :self),
-          [],
-          self,
-          nil,
-          nil,
-          true
-        )
-      end
-
-      def method_name
-        nil
-      end
-
-      def namespace_symbol
-        method_name && method_name.to_sym
-      end
-
-      def unquote?
-        false
-      end
-
-      def caller
-        Atomy::AST::Send.new(
-          @line,
-          self,
-          [],
-          Atomy::AST::Variable.new(@line, "call"),
-          nil,
-          nil
-        )
-      end
-
-      def expand
-        Atomy::Macro.expand(self)
-      end
-
-      def evaluate(onto = nil)
-        Atomy::Compiler.evaluate_node(self, onto, TOPLEVEL_BINDING)
-      end
-
-      def resolve
-        ns = Atomy::Namespace.get
-        return self if @namespace || !ns
-
-        case self
-        when Atomy::AST::Send, Atomy::AST::Variable,
-              Atomy::AST::BinarySend, Atomy::AST::Unary
-          y = dup
-          if n = ns.resolve(namespace_symbol)
-            y.namespace = n.to_s
-          else
-            y.namespace = "_"
-          end
-          y
-        else
-          self
-        end
-      end
-
-      def prepare
-        self
-      end
-
-      def compile(g)
-        prepare.bytecode(g)
-      end
-
-      def load_bytecode(g)
-        compile(g)
-      end
-
-      def to_pattern
-        expand.pattern
-      end
-
-      def as_message(send)
-        raise "unknown message name: #{self.to_sexp.inspect}"
-      end
-    end
-
-    class Node < Rubinius::AST::Node
-      include NodeLike
-      extend SentientNode
-
-      def bytecode(g)
-        raise "no #bytecode for #{self.class.name}"
-      end
-    end
-
-    class Tree
-      attr_accessor :nodes
-
-      def initialize(nodes)
-        @nodes = Array(nodes)
-      end
-
-      def bytecode(g)
-        @nodes.each { |n| n.compile(g) }
-      end
-
-      def collect
-        Tree.new(@nodes.collect { |n| yield n })
-      end
-    end
-
-    class Script < Rubinius::AST::Container
-      def initialize(body)
-        super body
-        @name = :__script__
-      end
-
-      def bytecode(g)
-        super(g)
-
-        container_bytecode(g) do
-          g.push_state self
-
-          load = g.new_label
-          start = g.new_label
-          done = g.new_label
-
-          g.push_cpath_top
-          g.find_const :Atomy
-          g.find_const :CodeLoader
-          g.send :reason, 0
-          g.push_literal :load
-          g.send :==, 1
-          g.git load
-
-          start.set!
-          @body.bytecode g
-          g.goto done
-
-          load.set!
-          Atomy::CodeLoader.when_load.each do |e, c|
-            if c
-              skip = g.new_label
-
-              g.push_cpath_top
-              g.find_const :Atomy
-              g.find_const :CodeLoader
-              g.send :compiled?, 0
-              g.git skip
-
-              e.load_bytecode(g)
-              g.pop
-
-              skip.set!
-            else
-              e.load_bytecode(g)
-              g.pop
-            end
-          end
-          g.goto start
-
-          done.set!
-          g.pop
-          g.push :true
-          g.ret
-          g.pop_state
-        end
-      end
-    end
-  end
-end
-
-class Object
-  def to_node
-    raise "not a node: #{self.inspect}"
-  end
-end
-
-class Integer
-  def to_node
-    Atomy::AST::Primitive.new -1, self
-  end
-end
-
-class String
-  def to_node
-    Atomy::AST::String.new -1, self
-  end
-end
-
-class Array
-  def to_node
-    Atomy::AST::List.new -1, collect(&:to_node)
-  end
-end
-
-class NilClass
-  def to_node
-    Atomy::AST::Primitive.new -1, :nil
-  end
-end
-
-class Symbol
-  def to_node
-    Atomy::AST::Particle.new -1, self
-  end
-end