atomy 0.1.1

data/lib/patterns/named_class.rb

@@ -0,0 +1,46 @@
+module Atomy::Patterns
+  class NamedClass < Pattern
+    attr_reader :identifier
+
+    def initialize(n)
+      @identifier = n
+    end
+
+    def name
+      ("@@" + @identifier).to_sym
+    end
+
+    def construct(g)
+      get(g)
+      g.push_literal @identifier
+      g.send :new, 1
+    end
+
+    def ==(b)
+      b.kind_of?(NamedClass) and \
+      @identifier == b.identifier
+    end
+
+    def target(g)
+      g.push_const :Object
+    end
+
+    def matches?(g)
+      g.pop
+      g.push_true
+    end
+
+    def deconstruct(g, locals = {})
+      Rubinius::AST::ClassVariableAssignment.new(0, name, nil).bytecode(g)
+      g.pop
+    end
+
+    def local_names
+      []
+    end
+
+    def bindings
+      1
+    end
+  end
+end

data/lib/patterns/named_global.rb

@@ -0,0 +1,46 @@
+module Atomy::Patterns
+  class NamedGlobal < Pattern
+    attr_reader :identifier
+
+    def initialize(n)
+      @identifier = n
+    end
+
+    def name
+      ("$" + @identifier).to_sym
+    end
+
+    def construct(g)
+      get(g)
+      g.push_literal @identifier
+      g.send :new, 1
+    end
+
+    def ==(b)
+      b.kind_of?(NamedGlobal) and \
+      @identifier == b.identifier
+    end
+
+    def target(g)
+      g.push_const :Object
+    end
+
+    def matches?(g)
+      g.pop
+      g.push_true
+    end
+
+    def deconstruct(g, locals = {})
+      Rubinius::AST::GlobalVariableAssignment.new(0, name, nil).bytecode(g)
+      g.pop
+    end
+
+    def local_names
+      []
+    end
+
+    def bindings
+      1
+    end
+  end
+end

data/lib/patterns/named_instance.rb

@@ -0,0 +1,46 @@
+module Atomy::Patterns
+  class NamedInstance < Pattern
+    attr_reader :identifier
+
+    def initialize(n)
+      @identifier = n
+    end
+
+    def name
+      ("@" + @identifier).to_sym
+    end
+
+    def construct(g)
+      get(g)
+      g.push_literal @identifier
+      g.send :new, 1
+    end
+
+    def ==(b)
+      b.kind_of?(NamedInstance) and \
+      @identifier == b.identifier
+    end
+
+    def target(g)
+      g.push_const :Object
+    end
+
+    def matches?(g)
+      g.pop
+      g.push_true
+    end
+
+    def deconstruct(g, locals = {})
+      Rubinius::AST::InstanceVariableAssignment.new(0, name, nil).bytecode(g)
+      g.pop
+    end
+
+    def local_names
+      []
+    end
+
+    def bindings
+      1
+    end
+  end
+end

data/lib/patterns/particle.rb

@@ -0,0 +1,29 @@
+module Atomy::Patterns
+  class Particle < Pattern
+    attr_reader :value
+
+    def initialize(x)
+      @value = x
+    end
+
+    def construct(g)
+      get(g)
+      g.push_literal @value
+      g.send :new, 1
+    end
+
+    def ==(b)
+      b.kind_of?(Match) and \
+      @value == b.value
+    end
+
+    def target(g)
+      g.push_const :Symbol # TODO
+    end
+
+    def matches?(g)
+      g.push_literal @value
+      g.send :==, 1
+    end
+  end
+end

data/lib/patterns/quasi_quote.rb

@@ -0,0 +1,184 @@
+# TODO: fix splice unquotes
+module Atomy::Patterns
+  class QuasiQuote < Pattern
+    attr_reader :quoted
+
+    def initialize(x)
+      @quoted = x
+    end
+
+    def construct(g)
+      get(g)
+      @quoted.construct(g, nil)
+      g.send :new, 1
+    end
+
+    def ==(b)
+      b.kind_of?(QuasiQuote) and \
+      @quoted == b.expression
+    end
+
+    def expression
+      @quoted.expression
+    end
+
+    def target(g)
+      names = expression.class.name.split("::")
+      g.push_const names.slice!(0).to_sym
+      names.each do |n|
+        g.find_const n.to_sym
+      end
+    end
+
+    def context(g, w)
+      w.each do |c|
+        # TODO: fail if out of bounds?
+        # e.g. `(foo(~bar, ~baz)) = '(foo(1))
+        if c.kind_of?(Array)
+          g.send c[0], 0
+          g.push_int c[1]
+          g.send :[], 1
+        else
+          g.send c, 0
+        end
+      end
+    end
+
+    def matches?(g)
+      mismatch = g.new_label
+      done = g.new_label
+
+      them = g.new_stack_local
+      g.set_stack_local them
+      g.pop
+
+      where = nil
+      splice = false
+
+      pre = proc { |e, c, d|
+        where << c if c && where
+
+        where = [] if !where and c == :expression
+
+        splice = true if e.kind_of?(Atomy::AST::Splice)
+
+        if !(e.unquote? && d == 1) && where && c != :unquoted
+          e.get(g)
+          g.push_stack_local them
+          context(g, where)
+          g.kind_of
+          g.gif mismatch
+
+          e.details.each do |a|
+            val = e.send(a)
+            if val.kind_of?(Array)
+              val.each do |v|
+                g.push_literal v
+              end
+              g.make_array val.size
+            else
+              g.push_literal val
+            end
+            g.push_stack_local them
+            context(g, where)
+            g.send a, 0
+            g.send :==, 1
+            g.gif mismatch
+          end
+
+          if e.bottom?
+            e.construct(g)
+            g.push_stack_local them
+            context(g, where)
+            g.send :==, 1
+            g.gif mismatch
+          end
+        end
+
+        true
+      }
+
+      post = proc { where.pop }
+
+      @quoted.through_quotes(pre, post) do |e|
+        ctx = where.last == :unquoted ? where[0..-2] : where
+        g.push_stack_local them
+        if splice
+          g.send ctx.last[0], 0
+          g.push_int ctx.last[1]
+          g.send :drop, 1
+          splice = false
+        else
+          context(g, ctx)
+        end
+        e.to_pattern.matches?(g)
+        g.gif mismatch
+        e
+      end
+
+      g.push_true
+      g.goto done
+
+      mismatch.set!
+      g.push_false
+
+      done.set!
+    end
+
+    def deconstruct(g, locals = {})
+      them = g.new_stack_local
+      g.set_stack_local them
+      g.pop
+
+      where = nil
+      splice = false
+
+      pre = proc { |n, c|
+        where << c if c && where
+
+        where = [] if !where and c == :expression
+
+        splice = true if n.kind_of?(Atomy::AST::Splice)
+
+        true
+      }
+
+      post = proc { where.pop }
+
+      @quoted.through_quotes(pre, post) do |e|
+        ctx = where.last == :unquoted ? where[0..-2] : where
+        g.push_stack_local them
+        if splice
+          g.send ctx.last[0], 0
+          g.push_int ctx.last[1]
+          g.send :drop, 1
+          splice = false
+        else
+          context(g, ctx)
+        end
+        e.to_pattern.deconstruct(g)
+        e
+      end
+    end
+
+    def local_names
+      names = []
+
+      @quoted.through_quotes(proc { true }) do |e|
+        names += e.to_pattern.local_names
+      end
+
+      names
+    end
+
+    def bindings
+      bindings = 0
+
+      @quoted.through_quotes(proc { true }) do |e|
+        bindings += e.to_pattern.bindings
+      end
+
+      bindings
+    end
+  end
+end

data/lib/patterns/quote.rb

@@ -0,0 +1,33 @@
+module Atomy::Patterns
+  class Quote < Pattern
+    attr_reader :expression
+
+    def initialize(x)
+      @expression = x
+    end
+
+    def construct(g)
+      get(g)
+      @expression.construct(g, nil)
+      g.send :new, 1
+    end
+
+    def ==(b)
+      b.kind_of?(Quote) and \
+      @expression == b.expression
+    end
+
+    def target(g)
+      names = @expression.class.name.split("::")
+      g.push_const names.slice!(0).to_sym
+      names.each do |n|
+        g.find_const n.to_sym
+      end
+    end
+
+    def matches?(g)
+      @expression.construct(g, nil)
+      g.send :==, 1
+    end
+  end
+end

data/lib/patterns/singleton_class.rb

@@ -0,0 +1,31 @@
+module Atomy::Patterns
+  class SingletonClass < Pattern
+    attr_reader :body
+
+    def initialize(body)
+      @body = body
+    end
+
+    def construct(g)
+      get(g)
+      @body.construct(g, nil)
+      g.send(:new, 1)
+    end
+
+    def ==(b)
+      b.kind_of?(SingletonClass) and \
+      @body == b.body
+    end
+
+    def target(g)
+      @body.compile(g)
+      g.send :call, 0
+      g.send :singleton_class, 0
+    end
+
+    def matches?(g)
+      g.pop
+      g.push_true
+    end
+  end
+end

data/lib/patterns/splat.rb

@@ -0,0 +1,57 @@
+module Atomy::Patterns
+  class Splat < Pattern
+    attr_accessor :pattern
+
+    def initialize(p)
+      @pattern = p
+    end
+
+    def construct(g)
+      get(g)
+      @pattern.construct(g)
+      g.send :new, 1
+    end
+
+    def ==(b)
+      b.kind_of?(Splat) and \
+      @pattern == b.pattern
+    end
+
+    def target(g)
+      g.push_const :Object
+    end
+
+    def matches?(g)
+      g.pop
+      g.push_true
+    end
+
+    def deconstruct(g, locals = {})
+      singleton = g.new_label
+      done = g.new_label
+
+      g.dup
+      g.push_const :Array
+      g.swap
+      g.instance_of
+      g.git singleton
+
+      g.cast_array
+      g.goto done
+
+      singleton.set!
+      g.make_array 1
+
+      done.set!
+      @pattern.deconstruct(g, locals)
+    end
+
+    def local_names
+      @pattern.local_names
+    end
+
+    def bindings
+      @pattern.bindings
+    end
+  end
+end