atomy 0.1.1 → 0.6.3

data/lib/atomy/code/define_method.rb

@@ -0,0 +1,20 @@
+require "atomy/compiler"
+require "atomy/code/define"
+
+module Atomy
+  module Code
+    class DefineMethod < Define
+      def bytecode(gen, mod)
+        gen.push_cpath_top
+        gen.find_const(:Atomy)
+        gen.push_cpath_top
+        gen.find_const(:Kernel)
+        gen.send(:binding, 0)
+        gen.push_literal(@name)
+        push_branch(gen, mod)
+        gen.send(:for_method!, 0)
+        gen.send(:define_branch, 3)
+      end
+    end
+  end
+end

data/lib/atomy/code/false.rb

@@ -0,0 +1,9 @@
+module Atomy
+  module Code
+    class False
+      def bytecode(gen, mod)
+        gen.push_false
+      end
+    end
+  end
+end

data/lib/atomy/code/instance_variable.rb

@@ -0,0 +1,15 @@
+module Atomy
+  module Code
+    class InstanceVariable
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def bytecode(gen, mod)
+        gen.push_ivar(:"@#{@name}")
+      end
+    end
+  end
+end

data/lib/atomy/code/integer.rb

@@ -0,0 +1,13 @@
+module Atomy
+  module Code
+    class Integer
+      def initialize(value)
+        @value = value
+      end
+
+      def bytecode(gen, mod)
+        gen.push_int(@value)
+      end
+    end
+  end
+end

data/lib/atomy/code/list.rb

@@ -0,0 +1,17 @@
+module Atomy
+  module Code
+    class List
+      def initialize(elements)
+        @elements = elements
+      end
+
+      def bytecode(gen, mod)
+        @elements.each do |e|
+          mod.compile(gen, e)
+        end
+
+        gen.make_array(@elements.size)
+      end
+    end
+  end
+end

data/lib/atomy/code/nil.rb

@@ -0,0 +1,9 @@
+module Atomy
+  module Code
+    class Nil
+      def bytecode(gen, mod)
+        gen.push_nil
+      end
+    end
+  end
+end

data/lib/atomy/code/pattern.rb

@@ -0,0 +1,23 @@
+module Atomy
+  module Code
+    class Pattern
+      attr_reader :node
+
+      def initialize(node)
+        @node = node
+      end
+
+      def bytecode(gen, mod)
+        mod.compile(gen, @node)
+      end
+
+      # [value, pattern] on stack
+      def assign(gen)
+      end
+
+      def splat?
+        false
+      end
+    end
+  end
+end

data/lib/atomy/code/pattern/and.rb

@@ -0,0 +1,61 @@
+require "atomy/code/pattern"
+
+require "atomy/node/meta"
+
+
+class Atomy::Code::Pattern
+  class And < self
+    def initialize(a, b)
+      @a = a
+      @b = b
+    end
+
+    def bytecode(gen, mod)
+      gen.push_cpath_top
+      gen.find_const(:Atomy)
+      gen.find_const(:Pattern)
+      gen.find_const(:And)
+      mod.compile(gen, @a)
+      mod.compile(gen, @b)
+      gen.send(:new, 2)
+    end
+
+    def assign(gen)
+      # [value, pattern, value, pattern]
+      gen.dup_many(2)
+
+      # [pattern, value, value, pattern]
+      gen.swap
+
+      # [a pattern, value, value, pattern]
+      gen.send(:a, 0)
+
+      # [value, a pattern, value, pattern]
+      gen.swap
+
+      # [value, a pattern, value, pattern]
+      @a.assign(gen)
+
+      # [value, pattern]
+      gen.pop_many(2)
+
+      # [value, pattern, value, pattern]
+      gen.dup_many(2)
+
+      # [pattern, value, value, pattern]
+      gen.swap
+
+      # [b pattern, value, value, pattern]
+      gen.send(:b, 0)
+
+      # [value, b pattern, value, pattern]
+      gen.swap
+
+      # [value, b pattern, value, pattern]
+      @b.assign(gen)
+
+      # [value, pattern]
+      gen.pop_many(2)
+    end
+  end
+end

data/lib/atomy/code/pattern/quasi_quote.rb

@@ -0,0 +1,185 @@
+require "atomy/code/pattern"
+
+require "atomy/node/meta"
+
+
+class Atomy::Code::Pattern
+  class QuasiQuote < self
+    def initialize(node, mod)
+      constructor = Constructor.new(mod)
+      @pattern = constructor.go(node)
+    end
+
+    def bytecode(gen, mod)
+      gen.push_cpath_top
+      gen.find_const(:Atomy)
+      gen.find_const(:Pattern)
+      gen.find_const(:QuasiQuote)
+      mod.compile(gen, @pattern)
+      gen.send(:new, 1)
+    end
+
+    def assign(gen)
+      AssignWalker.new(gen).go(@pattern.node)
+    end
+
+    private
+
+    class Walker
+      def initialize
+        @depth = 0
+      end
+
+      def go(x)
+        x.accept(self)
+      end
+
+      def visit_quasiquote(qq)
+        @depth += 1
+        visit(qq)
+      ensure
+        @depth -= 1
+      end
+
+      def visit_unquote(x)
+        @depth -= 1
+
+        if @depth == 0
+          unquote(x)
+        else
+          visit(x)
+        end
+      ensure
+        @depth += 1
+      end
+
+      def unquote(_)
+        raise NotImplementedError
+      end
+    end
+
+    class Constructor < Walker
+      attr_reader :locals
+
+      def initialize(mod)
+        super()
+
+        @module = mod
+      end
+
+      def go(x)
+        x.accept(self)
+      end
+
+      def visit(x)
+        x.through do |v|
+          go(v)
+        end
+      end
+
+      def unquote(x)
+        x.through do |p|
+          @module.pattern(p)
+        end
+      end
+    end
+
+    class AssignWalker
+      def initialize(gen)
+        @gen = gen
+
+        # [[msg, [args...]]]
+        @path = []
+      end
+
+      def go(a)
+        if a.is_a?(Atomy::Code::Pattern)
+          @path.pop # remove .node call from following through the unquote
+          assign_using_path(a)
+          @path << :node # add it back so the parent .pop doesn't break
+        else
+          a.each_child do |attr, val|
+            @path << [attr, []]
+
+            if val.is_a?(Array)
+              go_array(val)
+            else
+              go(val)
+            end
+
+            @path.pop
+          end
+        end
+      end
+
+      def go_array(as)
+        splat = nil
+        req_size = 0
+        as.each do |a|
+          if a.is_a?(Atomy::Grammar::AST::Unquote) && a.node.is_a?(Atomy::Code::Pattern) && a.node.splat?
+            splat = a.node
+            break
+          end
+
+          req_size += 1
+        end
+
+        req_size.times do |i|
+          @path << [:[], [i]]
+          go(as[i])
+          @path.pop
+        end
+
+        if splat
+          assign_using_path(splat, req_size)
+        end
+
+        true
+      end
+
+      def assign_using_path(pattern, splat_index = nil)
+        @gen.dup_many(2)
+
+        # get path from value
+        push_path
+
+        if splat_index
+          @gen.push_int(splat_index)
+          @gen.send(:drop, 1)
+        end
+
+        @gen.swap
+
+        # get quasiquote tree of pattern
+        @gen.send(:node, 0)
+
+        # get path from pattern
+        push_path
+
+        if splat_index
+          @gen.push_int(splat_index)
+          @gen.send(:[], 1)
+          @gen.send(:pattern, 0)
+        end
+
+        # restore original order
+        @gen.swap
+
+        # assign sub-pattern against sub-value
+        pattern.assign(@gen)
+
+        @gen.pop_many(2)
+      end
+
+      def push_path
+        @path.each do |m, args|
+          args.each do |a|
+            @gen.push(a)
+          end
+
+          @gen.send(m, args.size)
+        end
+      end
+    end
+  end
+end

data/lib/atomy/code/pattern/splat.rb

@@ -0,0 +1,29 @@
+require "atomy/code/pattern"
+
+require "atomy/node/meta"
+
+
+class Atomy::Code::Pattern
+  class Splat < self
+    def initialize(pattern)
+      @pattern = pattern
+    end
+
+    def bytecode(gen, mod)
+      gen.push_cpath_top
+      gen.find_const(:Atomy)
+      gen.find_const(:Pattern)
+      gen.find_const(:Splat)
+      mod.compile(gen, @pattern)
+      gen.send(:new, 1)
+    end
+
+    def assign(gen)
+      @pattern.assign(gen)
+    end
+
+    def splat?
+      true
+    end
+  end
+end

data/lib/atomy/code/pattern/wildcard.rb

@@ -0,0 +1,37 @@
+require "atomy/code/pattern"
+
+require "atomy/node/meta"
+
+
+class Atomy::Code::Pattern
+  class Wildcard < self
+    def initialize(name = nil, set = false)
+      @name = name
+      @set = set
+    end
+
+    def bytecode(gen, mod)
+      gen.push_cpath_top
+      gen.find_const(:Atomy)
+      gen.find_const(:Pattern)
+      gen.find_const(:Wildcard)
+      gen.send(:new, 0)
+    end
+
+    def assign(gen)
+      assignment_local(gen, @name, @set).set_bytecode(gen)
+    end
+
+    private
+
+    def assignment_local(gen, name, set = false)
+      var = gen.state.scope.search_local(name)
+
+      if var && (set || var.depth == 0)
+        var
+      else
+        gen.state.scope.new_local(name).nested_reference
+      end
+    end
+  end
+end

data/lib/atomy/code/quasi_quote.rb

@@ -0,0 +1,118 @@
+module Atomy
+  module Code
+    class QuasiQuote
+      attr_reader :node
+
+      def initialize(node)
+        @node = node
+      end
+
+      def bytecode(gen, mod)
+        Constructor.new(gen, mod).go(@node)
+      end
+
+      class Constructor
+        def initialize(gen, mod)
+          @gen = gen
+          @module = mod
+          @depth = 1
+        end
+
+        def go(x)
+          x.accept(self)
+        end
+
+        def unquote(x)
+          @module.compile(@gen, x.node)
+        end
+
+        def visit(x)
+          push_class(x.class)
+
+          args = 0
+          x.each_child do |_, c|
+            if c.is_a?(Array)
+              construct_many(c)
+            else
+              go(c)
+            end
+            args += 1
+          end
+
+          x.each_attribute do |_, a|
+            push_literal(a)
+            args += 1
+          end
+
+          @gen.send(:new, args)
+        end
+
+        def visit_quasiquote(qq)
+          @depth += 1
+          visit(qq)
+        ensure
+          @depth -= 1
+        end
+
+        def visit_unquote(x)
+          @depth -= 1
+
+          if @depth == 0
+            unquote(x)
+          else
+            visit(x)
+          end
+        ensure
+          @depth += 1
+        end
+
+        def construct_many(c)
+          size = 0
+          splats = 0
+          c.each do |e|
+            if @depth == 1 && e.is_a?(Atomy::Grammar::AST::Unquote) && \
+                e.node.is_a?(Atomy::Grammar::AST::Prefix) && \
+                e.node.operator == :*
+              splat = true
+              @gen.make_array(size)
+              @module.compile(@gen, e.node.node)
+              @gen.send(:+, 1)
+
+              splats += 1
+              size = 0
+            else
+              size += 1
+              go(e)
+            end
+          end
+
+          @gen.make_array(size)
+
+          splats.times do
+            @gen.send(:+, 1)
+          end
+        end
+
+        def push_literal(x)
+          case x
+          when Array
+            x.each { |v| push_literal(v) }
+            @gen.make_array(x.size)
+          when String
+            @gen.push_literal(x)
+            @gen.string_dup
+          else
+            @gen.push_literal(x)
+          end
+        end
+
+        def push_class(cls)
+          @gen.push_cpath_top
+          cls.name.split("::").each do |n|
+            @gen.find_const(n.to_sym)
+          end
+        end
+      end
+    end
+  end
+end