atomy 0.1.1 → 0.6.3

data/lib/patterns/any.rb

@@ -1,21 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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