atomy 0.1.1

data/lib/patterns/any.rb

@@ -0,0 +1,21 @@
+module Atomy::Patterns
+  class Any < Pattern
+    def construct(g)
+      get(g)
+      g.send :new, 0
+    end
+
+    def ==(b)
+      b.kind_of?(Any)
+    end
+
+    def target(g)
+      g.push_const :Object
+    end
+
+    def matches?(g)
+      g.pop
+      g.push_true
+    end
+  end
+end

data/lib/patterns/attribute.rb

@@ -0,0 +1,59 @@
+module Atomy::Patterns
+  class Attribute < Pattern
+    attr_reader :receiver, :name, :arguments
+
+    def initialize(r, n, as = [])
+      @receiver = r
+      @name = n
+      @arguments = as
+    end
+
+    def construct(g)
+      get(g)
+      @receiver.construct(g, nil)
+      g.push_literal @name
+      @arguments.each do |a|
+        a.construct(g)
+      end
+      g.make_array @arguments.size
+      g.send :new, 3
+    end
+
+    def ==(b)
+      b.kind_of?(Attribute) and \
+      @receiver == b.receiver and \
+      @name == b.name and \
+      @arguments == b.arguments
+    end
+
+    def target(g)
+      # this should be pretty rare, but seems sensible
+      @receiver.construct(g)
+    end
+
+    def matches?(g)
+      g.pop
+      g.push_true
+    end
+
+    def deconstruct(g, locals = {})
+      @receiver.compile(g)
+      g.swap
+      @arguments.each do |a|
+        a.compile(g)
+        g.swap
+      end
+      g.send((@name + "=").to_sym, 1 + @arguments.size)
+      g.pop
+    end
+
+    def local_names
+      []
+    end
+
+    def bindings
+      1
+    end
+  end
+end
+

data/lib/patterns/block_pass.rb

@@ -0,0 +1,54 @@
+module Atomy::Patterns
+  class BlockPass < Pattern
+    attr_reader :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?(BlockPass) 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 = {})
+      nil_block = g.new_label
+      done = g.new_label
+
+      g.dup
+      g.is_nil
+      g.git nil_block
+
+      g.push_cpath_top
+      g.find_const :Proc
+      g.swap
+      g.send :__from_block__, 1
+      @pattern.deconstruct(g, locals)
+      g.goto done
+
+      nil_block.set!
+      g.pop
+
+      done.set!
+    end
+
+    def local_names
+      @pattern.local_names
+    end
+  end
+end

data/lib/patterns/constant.rb

@@ -0,0 +1,33 @@
+module Atomy::Patterns
+  class Constant < Pattern
+    attr_reader :constant, :ancestors
+
+    def initialize(constant, ancestors = nil)
+      @constant = constant
+      @ancestors = ancestors
+    end
+
+    def construct(g)
+      get(g)
+      @constant.construct(g)
+      @constant.bytecode(g)
+      g.send :ancestors, 0
+      g.send :new, 2
+    end
+
+    def ==(b)
+      b.kind_of?(Constant) and \
+        @constant == b.constant
+    end
+
+    def target(g)
+      @constant.bytecode(g)
+    end
+
+    def matches?(g)
+      target(g)
+      g.swap
+      g.kind_of
+    end
+  end
+end

data/lib/patterns/default.rb

@@ -0,0 +1,44 @@
+module Atomy::Patterns
+  class Default < Pattern
+    attr_reader :pattern, :default
+
+    def initialize(p, d)
+      @pattern = p
+      @default = d
+    end
+
+    def construct(g)
+      get(g)
+      @pattern.construct(g)
+      @default.construct(g, nil)
+      g.send :new, 2
+    end
+
+    def ==(b)
+      b.kind_of?(Default) and \
+      @pattern == b.pattern and \
+      @default == b.default
+    end
+
+    def target(g)
+      @pattern.target(g)
+    end
+
+    def matches?(g)
+      @pattern.matches?(g)
+    end
+
+    def deconstruct(g, locals = {})
+      @pattern.deconstruct(g, locals)
+    end
+
+    def local_names
+      @pattern.local_names
+    end
+
+    def bindings
+      @pattern.bindings
+    end
+  end
+end
+

data/lib/patterns/head_tail.rb

@@ -0,0 +1,63 @@
+module Atomy::Patterns
+  class HeadTail < Pattern
+    attr_reader :head, :tail
+
+    def initialize(head, tail)
+      @head = head
+      @tail = tail
+    end
+
+    def construct(g)
+      get(g)
+      @head.construct(g)
+      @tail.construct(g)
+      g.send :new, 2
+    end
+
+    def ==(b)
+      b.kind_of?(HeadTail) and \
+      @head == b.head and \
+      @tail == b.tail
+    end
+
+    def target(g)
+      g.push_const :Array
+    end
+
+    def matches?(g)
+      mismatch = g.new_label
+      matched = g.new_label
+
+      g.dup
+      g.send :empty?, 0
+      g.git mismatch
+
+      g.shift_array
+      @head.matches?(g)
+      g.gif mismatch
+
+      @tail.matches?(g)
+      g.goto matched
+
+      mismatch.set!
+      g.pop
+      g.push_false
+
+      matched.set!
+    end
+
+    def deconstruct(g, locals = {})
+      g.shift_array
+      @head.deconstruct(g, locals)
+      @tail.deconstruct(g, locals)
+    end
+
+    def local_names
+      @head.local_names + @tail.local_names
+    end
+
+    def bindings
+      @head.bindings + @tail.bindings
+    end
+  end
+end

data/lib/patterns/list.rb

@@ -0,0 +1,77 @@
+module Atomy::Patterns
+  class List < Pattern
+    attr_reader :patterns
+
+    def initialize(ps)
+      @patterns = ps
+    end
+
+    def construct(g)
+      get(g)
+      @patterns.each do |p|
+        p.construct(g)
+      end
+      g.make_array @patterns.size
+      g.send :new, 1
+    end
+
+    def ==(b)
+      b.kind_of?(List) and \
+      @patterns == b.patterns
+    end
+
+    def target(g)
+      g.push_const :Array
+    end
+
+    def matches?(g)
+      matched = g.new_label
+      mismatch = g.new_label
+
+      g.dup
+      g.push_cpath_top
+      g.find_const :Array
+      g.swap
+      g.kind_of
+      g.gif mismatch
+
+      g.dup
+      g.send :size, 0
+      g.push @patterns.size
+      g.send :==, 1
+      g.gif mismatch
+
+      @patterns.each do |p|
+        g.shift_array
+        p.matches?(g)
+        g.gif mismatch
+      end
+      g.pop
+
+      g.push_true
+      g.goto matched
+
+      mismatch.set!
+      g.pop
+      g.push_false
+
+      matched.set!
+    end
+
+    def deconstruct(g, locals = {})
+      @patterns.each do |p|
+        g.shift_array
+        p.deconstruct(g, locals)
+      end
+      g.pop
+    end
+
+    def local_names
+      @patterns.collect { |p| p.local_names }.flatten
+    end
+
+    def bindings
+      @patterns.reduce(0) { |a, p| p.bindings + a }
+    end
+  end
+end

data/lib/patterns/match.rb

@@ -0,0 +1,45 @@
+module Atomy::Patterns
+  class Match < 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)
+      case @value
+      when :true
+        g.push_const :TrueClass
+      when :false
+        g.push_const :FalseClass
+      when :nil
+        g.push_const :NilClass
+      when :self
+        g.push_self
+      else
+        g.push_const @value.class.name.to_sym
+      end
+    end
+
+    def matches?(g)
+      case @value
+      when :true, :false, :self, :nil, Integer
+        g.push @value
+      else
+        g.push_literal @value
+      end
+      g.send :==, 1
+    end
+  end
+end

data/lib/patterns/named.rb

@@ -0,0 +1,55 @@
+module Atomy::Patterns
+  class Named < Pattern
+    attr_reader :name, :pattern
+
+    def initialize(n, p)
+      @name = n
+      @pattern = p
+    end
+
+    def construct(g)
+      get(g)
+      g.push_literal @name
+      @pattern.construct(g)
+      g.send :new, 2
+    end
+
+    def ==(b)
+      b.kind_of?(Named) and \
+      @name == b.name and \
+      @pattern == b.pattern
+    end
+
+    def target(g)
+      @pattern.target(g)
+    end
+
+    def matches?(g)
+      @pattern.matches?(g)
+    end
+
+    def deconstruct(g, locals = {})
+      if locals[@name]
+        local = locals[@name]
+      else
+        local = Atomy.assign_local(g, @name)
+      end
+
+      if @pattern.bindings > 0
+        g.dup
+        @pattern.deconstruct(g, locals)
+      end
+
+      local.set_bytecode(g)
+      g.pop
+    end
+
+    def local_names
+      [@name] + @pattern.local_names
+    end
+
+    def bindings
+      1 + @pattern.bindings
+    end
+  end
+end