rpiet 0.1 → 0.2

data/lib/rpiet/ir/passes/push_pop_elimination_pass.rb

@@ -0,0 +1,112 @@
+require_relative 'data_flow_problem'
+require_relative 'flow_graph_node'
+
+module RPiet
+  module IR
+    module Passes
+      class PushInfo
+        attr_reader :bb, :instr
+        def initialize(bb, instr)
+          @bb, @instr = bb, instr
+        end
+
+        def ==(other)
+          other && operand == other.operand
+        end
+
+        def operand = instr&.operand
+
+        def to_s
+          "#{bb.label}:#{instr}"
+        end
+        alias inspect to_s
+      end
+
+      class PushPopEliminationNode < FlowGraphNode
+        attr_reader :ins, :outs
+        TOP, BOTTOM = nil, PushInfo.new(nil, nil)
+
+        def initialize(problem, bb)
+          super
+        end
+
+        def replace_instr(instr, new_instr)
+          index = bb.instrs.index(instr)
+          bb.instrs[index] = new_instr
+        end
+
+        def apply_transfer_function(instr)
+          if instr.operation == :push
+            @ins ||= []
+            @ins << PushInfo.new(bb, instr)
+          elsif instr.operation == :pop
+            push = @ins.pop # Can ASG create invalid instrs combos of push/pop?
+            if push != TOP && push != BOTTOM
+              puts "replace pop #{instr} with #{push.instr} in #{push.bb.label}" if debug
+              replace_instr(instr, Instructions::CopyInstr.new(instr.result, push.operand))
+              @remove_instrs << [push.bb, push.instr]
+            end
+          end
+        end
+
+        def assign_outs
+          puts "assign_outs: #{bb.label}" if debug
+          puts "ins: #{@ins}" if debug
+          @remove_instrs.each { |bb, instr| bb.instrs.delete(instr) }
+          @outs = @ins.dup
+          puts "outs: #{@outs}" if debug
+        end
+
+        def compute_meet(other)
+          if @ins.nil?
+            puts "initial meet: #{self} +++ #{other.outs.dup}" if debug
+            @ins = other.outs.dup
+            return
+          end
+
+          puts "continued meet: #{self} +++ #{other}" if debug
+          oins = other.outs
+
+          # if one branch has more pushes recorded than another branch then obviously
+          # all branches do not have a push to eliminate.  We truncate to shortest of n
+          # last pushes.
+          if @ins.size > oins.size
+            @ins = @ins[-oins.size..-1]
+          elsif @ins.size < oins.size
+            oins = oins[-@ins.size..-1]
+          end
+
+          @ins.zip(oins).each_with_index do |(joined_in, other_in), index|
+            if joined_in != other_in
+              if other_in != TOP          # Any mismatched value lowers to unsolved
+                @ins[index] = BOTTOM
+              elsif joined_in == TOP      # if meet has nothing yet then we can give it incoming value
+                @ins[index] = other_in    # Note: I doubt this is possible for this pass
+              end
+            end
+          end
+        end
+
+        def solution_changed?
+          !@remove_instrs.empty?
+        end
+
+        def solution_init
+          @remove_instrs = []
+        end
+
+        def to_s
+          "#{bb.label}\n#{bb.instrs.map {|i| i.disasm}.join("\n")}\nins: #{@ins}\nouts: #{@outs}"
+        end
+        alias inspect to_s
+
+      end
+
+      class PushPopEliminationProblem < DataFlowProblem
+        def initialize(cfg)
+          super(cfg, PushPopEliminationNode)
+        end
+      end
+    end
+  end
+end

data/lib/rpiet/live_machine_state.rb

@@ -0,0 +1,15 @@
+module RPiet
+  module LiveMachineState
+    attr_reader :stack, :event_handler
+    attr_accessor :dp, :cc, :input, :output
+
+    def reset_machine
+      @stack, @dp, @cc, @input, @output = [], DirectionPointer.new, CodelChooser.new, $stdin, $stdout
+    end
+
+    def inspect
+      "dp: #{dp}, cc: #{cc}, st: #{stack}"
+    end
+    alias :to_s :inspect
+  end
+end

data/lib/rpiet/machine.rb

@@ -1,18 +1,25 @@
-require 'rpiet/direction_pointer'
-require 'rpiet/codel_chooser'
+require_relative 'direction_pointer'
+require_relative 'codel_chooser'
+require_relative 'live_machine_state'
 
 module RPiet
+  # Using the value npiet decided to use if division by zero happens.
+  DIV_BY_ZERO_VALUE = 99999999
+
   ## 
   # This is a simple piet runtime to be controled by interp.
   #
   # dp - Direction Pointer (right, down, left, up)
   # cc - Codel Chooser (left, right)
   class Machine
-    attr_reader :dp, :cc, :stack
+    ##
+    # Each group's size represents a block value which can be used by the push operation.
     attr_accessor :block_value
 
+    include LiveMachineState
+
     def initialize
-      @stack, @dp, @cc = [], DirectionPointer.new, CodelChooser.new
+      reset_machine
       @block_value = 1
     end
 
@@ -25,35 +32,53 @@ module RPiet
     ##
     # Change either codel chooser or direction pointer to try and look
     # at a different codel.
-    def orient_elsewhere(i)
-      if i.even?
+    def orient_elsewhere(attempt)
+      if attempt.even?
         dp.rotate!
       else
         cc.switch!
       end
     end
      
-    def noop; end
-    def push;  @stack << @block_value; end
-    def pop; @stack.pop; end
-
-    def add; math_op :+; end
-    def sub; math_op :-; end
-    def mult; math_op :*; end
-    def div; math_op :/; end
-    def mod; math_op :%; end
-
-    def gtr; bin_op { |a, b| @stack << (a > b ? 1 : 0) }; end
-    def not; unary_op { |top| @stack << (!top || top == 0 ? 1 : 0) }; end
-    def dup; @stack << @stack[-1]; end
-    def nout; unary_op { |top| print top }; end
-    def cout; unary_op { |top| print top.chr }; end
-    def pntr; unary_op { |top| @dp.rotate! top }; end
-    def swch; unary_op { |top| @cc.switch! top }; end
-    def n_in; puts "Enter an integer: "; @stack << $stdin.gets.to_i; end
-    def c_in; $stdout.write "> "; c = $stdin.read(1).ord; @stack << c; end
+    def noop
+    end
+
+    def push = @stack << @block_value
+    def pop = @stack.pop
+
+    def add = math_op :+
+    def sub = math_op :-
+    def mult = math_op :*
+
+    # Note: Following npiet's div by zero value.
+    def div = bin_op { |a, b| @stack << (b == 0 ? DIV_BY_ZERO_VALUE : a / b) }
+
+    def mod = math_op :%
+
+    def gtr = bin_op { |a, b| @stack << (a > b ? 1 : 0) }
+    def not = unary_op { |top| @stack << (!top || top == 0 ? 1 : 0) }
+
+    def dup
+      @stack << @stack[-1] if @stack[-1]
+    end
+
+    def nout = unary_op { |top| print top }
+    def cout = unary_op { |top| print top.chr }
+    def pntr = unary_op { |top| @dp.rotate! top }
+    def swch = unary_op { |top| @cc.switch! top }
+
+    def nin
+      output.puts "Enter an integer: "
+      @stack << input.gets.to_i
+    end
+
+    def cin
+      output.write "> "
+      @stack << input.read(1).ord
+    end
+
     def roll
-      bin_op do |depth, num| 
+      bin_op do |depth, num|
         num %= depth
         return if depth <= 0 || num == 0
         if num > 0
@@ -65,17 +90,22 @@ module RPiet
     end
 
     def inspect
-      "dp: #{@dp.ascii}, cc: #{@cc.ascii(@dp)}, bv: #{@block_value}, st: #{@stack}"
+      super + ", bv: #@block_value"
     end
     alias :to_s :inspect
 
     ##
     # Execute the operation represented by the two colors
     def execute(color1, color2)
+      operation = calculate_operation(color1, color2)
+      __send__(operation)
+      operation
+    end
+
+    def calculate_operation(color1, color2)
       dh = color1.hue.delta color2.hue
       dd = color1.lightness.delta color2.lightness
-      operation = OPERATION[dh][dd]
-      __send__(operation)
+      OPERATION[dh][dd]
     end
 
     private
@@ -85,7 +115,7 @@ module RPiet
     end
     
     def unary_op(&block)
-      return unless @stack.length >= 1
+      return if @stack.length < 1
       block.call(@stack.pop)
     end
 
@@ -105,7 +135,7 @@ module RPiet
                  [:add,  :sub, :mult],
                  [:div,  :mod, :not],
                  [:gtr,  :pntr, :swch],
-                 [:dup,  :roll, :n_in],
-                 [:c_in, :nout, :cout]]
+                 [:dup,  :roll, :nin],
+                 [:cin, :nout, :cout]]
   end
 end

data/lib/rpiet/source.rb

@@ -0,0 +1,83 @@
+require_relative 'color'
+require_relative 'group'
+require_relative 'image/image'
+
+
+module RPiet
+  class Source
+    attr_reader :rows, :cols, :groups, :pixels, :codel_size
+
+    def initialize(image)
+      @cols, @rows = image.size.map &:to_i
+      @codel_size = image.codel_size
+      @pixels = alloc_matrix { |i, j| image.pixel(i, j)}
+      @groups_matrix, @groups = calculate_groups
+    end
+
+    def entry_group
+    end
+
+    ##
+    # Is this point on the image and not black?
+    def valid?(x, y)
+      x >= 0 && x < @cols && y >= 0 && y < @rows &&
+          @pixels[x][y] != RPiet::Color::BLACK
+    end
+
+    def group_at(x, y)
+      @groups_matrix[x][y]
+    end
+
+    ##
+    # With grid of pixels start in upper left corner processing each pixel
+    # rightwards and downwards. As you encounter a pixel look up and left to
+    # see if it is a new color or part of an existing neighboring group.
+    def calculate_groups
+      groups_matrix = alloc_matrix { |i, j| 0 }
+      group = []
+      walk_matrix do |i, j|
+        color = @pixels[i][j]
+        up = j-1 >= 0 ? groups_matrix[i][j-1] : nil
+        left = i-1 >= 0 ? groups_matrix[i-1][j] : nil
+        if up && up.color == color
+          up << [i, j]
+          groups_matrix[i][j] = up
+          # disjoint groups to merge
+          if left && left != up && left.color == color
+            up.merge(groups_matrix, left)
+            left.points.each do |x, y|
+              groups_matrix[x][y] = up
+              group.delete left
+            end
+          end
+        end
+
+        if groups_matrix[i][j] == 0 && left && left.color == color
+          left << [i, j]
+          groups_matrix[i][j] = left
+        end
+
+        if groups_matrix[i][j] == 0  # Create new group for first codel found
+          groups_matrix[i][j] = RPiet::Group.new(color, [i, j])
+          group << groups_matrix[i][j]
+        end
+      end
+      group.each { |group| group.calculate_corners }
+      return groups_matrix, group
+    end
+
+    private def alloc_matrix
+      Array.new(@cols) { Array.new(@rows) {nil} }.tap do |matrix|
+        walk_matrix {|i, j| matrix[i][j] = yield i, j }
+      end
+    end
+
+    private def walk_matrix
+      0.upto(@cols-1) do |i|
+        0.upto(@rows-1) do |j|
+          yield i, j
+        end
+      end
+    end
+  end
+end

data/lib/rpiet/version.rb

@@ -1,3 +1,3 @@
 module RPiet
-  VERSION = '0.1'
+  VERSION = '0.2'
 end

data/lib/rpiet.rb

@@ -1,2 +1,2 @@
-require 'rpiet/version'
-require 'rpiet/interpreter'
+require_relative 'rpiet/version'
+require_relative 'rpiet/interpreter'

data/rpiet.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rpiet/version"
+
+Gem::Specification.new do |s|
+  s.name        = 'rpiet'
+  s.version     = RPiet::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = 'Thomas E. Enebo'
+  s.email       = 'tom.enebo@gmail.com'
+  s.homepage    = 'http://github.com/enebo/rpiet'
+  s.summary     = 'A Piet runtime'
+  s.description = 'An implementation of the esoteric programming language Piet'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/asg/visitor_spec.rb

@@ -0,0 +1,41 @@
+require_relative '../../lib/rpiet/asg/parser'
+require_relative '../../lib/rpiet/asg/visitor'
+require_relative '../../lib/rpiet/image/ascii_image'
+
+describe "RPiet::Visitor" do
+  let(:cycle) do
+    RPiet::Image::AsciiImage.new <<-EOS
+nb db nb
+db ++ nb
+db db db
+    EOS
+  end
+
+  let(:my_visitor) do
+    Class.new(RPiet::Visitor) {
+      attr_reader :nodes
+
+      def initialize
+        super
+        @nodes = {}
+      end
+
+      def visit_first(node)
+        @nodes[node] = 1
+        super
+      end
+      alias :visit_first_swch :visit_first
+      alias :visit_first_pntr :visit_first
+
+      def visit_again(node)
+        @nodes[node] += 1
+      end
+    }.new
+  end
+
+  it "can visit all nodes once plus one extra visit for a cycle" do
+    my_visitor.run RPiet::ASG::Parser.new(cycle).run
+    expect(my_visitor.nodes.size).to eq(10)
+    expect(my_visitor.nodes.values.inject(0) { |s, e| s += e; s}).to eq(11) # 1 node visited twice
+  end
+end

data/spec/cycle_spec.rb

@@ -1,4 +1,4 @@
-require 'rpiet/cycle'
+require_relative '../lib/rpiet/cycle'
 
 module A
   extend RPiet::CycleMethod
@@ -7,50 +7,50 @@ end
 
 describe "RPiet::Cycle" do
   it "can do cycle addition" do
-    (A::Letter::A + A::Letter::A).should == A::Letter::A
-    (A::Letter::A + A::Letter::B).should == A::Letter::B
-    (A::Letter::A + A::Letter::C).should == A::Letter::C
-    (A::Letter::B + A::Letter::A).should == A::Letter::B
-    (A::Letter::B + A::Letter::B).should == A::Letter::C
-    (A::Letter::B + A::Letter::C).should == A::Letter::A
-    (A::Letter::C + A::Letter::A).should == A::Letter::C
-    (A::Letter::C + A::Letter::B).should == A::Letter::A
-    (A::Letter::C + A::Letter::C).should == A::Letter::B
+    expect(A::Letter::A + A::Letter::A).to eq(A::Letter::A)
+    expect(A::Letter::A + A::Letter::B).to eq(A::Letter::B)
+    expect(A::Letter::A + A::Letter::C).to eq(A::Letter::C)
+    expect(A::Letter::B + A::Letter::A).to eq(A::Letter::B)
+    expect(A::Letter::B + A::Letter::B).to eq(A::Letter::C)
+    expect(A::Letter::B + A::Letter::C).to eq(A::Letter::A)
+    expect(A::Letter::C + A::Letter::A).to eq(A::Letter::C)
+    expect(A::Letter::C + A::Letter::B).to eq(A::Letter::A)
+    expect(A::Letter::C + A::Letter::C).to eq(A::Letter::B)
   end
 
   it "can do cycle subtraction" do
-    (A::Letter::A - A::Letter::A).should == A::Letter::A
-    (A::Letter::A - A::Letter::B).should == A::Letter::C
-    (A::Letter::A - A::Letter::C).should == A::Letter::B
-    (A::Letter::B - A::Letter::A).should == A::Letter::B
-    (A::Letter::B - A::Letter::B).should == A::Letter::A
-    (A::Letter::B - A::Letter::C).should == A::Letter::C
-    (A::Letter::C - A::Letter::A).should == A::Letter::C
-    (A::Letter::C - A::Letter::B).should == A::Letter::B
-    (A::Letter::C - A::Letter::C).should == A::Letter::A
+    expect(A::Letter::A - A::Letter::A).to eq(A::Letter::A)
+    expect(A::Letter::A - A::Letter::B).to eq(A::Letter::C)
+    expect(A::Letter::A - A::Letter::C).to eq(A::Letter::B)
+    expect(A::Letter::B - A::Letter::A).to eq(A::Letter::B)
+    expect(A::Letter::B - A::Letter::B).to eq(A::Letter::A)
+    expect(A::Letter::B - A::Letter::C).to eq(A::Letter::C)
+    expect(A::Letter::C - A::Letter::A).to eq(A::Letter::C)
+    expect(A::Letter::C - A::Letter::B).to eq(A::Letter::B)
+    expect(A::Letter::C - A::Letter::C).to eq(A::Letter::A)
   end
 
   it "can increment" do
-    A::Letter::A.incr.should == A::Letter::B
-    A::Letter::B.incr.should == A::Letter::C
-    A::Letter::C.incr.should == A::Letter::A
+    expect(A::Letter::A.incr).to eq(A::Letter::B)
+    expect(A::Letter::B.incr).to eq(A::Letter::C)
+    expect(A::Letter::C.incr).to eq(A::Letter::A)
   end
 
   it "can decrement" do
-    A::Letter::A.decr.should == A::Letter::C
-    A::Letter::B.decr.should == A::Letter::A
-    A::Letter::C.decr.should == A::Letter::B
+    expect(A::Letter::A.decr).to eq(A::Letter::C)
+    expect(A::Letter::B.decr).to eq(A::Letter::A)
+    expect(A::Letter::C.decr).to eq(A::Letter::B)
   end
 
   it "can calculate deltas" do
-    A::Letter::A.delta(A::Letter::A).should == 0
-    A::Letter::A.delta(A::Letter::B).should == 2
-    A::Letter::A.delta(A::Letter::C).should == 1
-    A::Letter::B.delta(A::Letter::A).should == 1
-    A::Letter::B.delta(A::Letter::B).should == 0
-    A::Letter::B.delta(A::Letter::C).should == 2
-    A::Letter::C.delta(A::Letter::A).should == 2
-    A::Letter::C.delta(A::Letter::B).should == 1
-    A::Letter::C.delta(A::Letter::C).should == 0
+    expect(A::Letter::A.delta(A::Letter::A)).to eq(0)
+    expect(A::Letter::A.delta(A::Letter::B)).to eq(2)
+    expect(A::Letter::A.delta(A::Letter::C)).to eq(1)
+    expect(A::Letter::B.delta(A::Letter::A)).to eq(1)
+    expect(A::Letter::B.delta(A::Letter::B)).to eq(0)
+    expect(A::Letter::B.delta(A::Letter::C)).to eq(2)
+    expect(A::Letter::C.delta(A::Letter::A)).to eq(2)
+    expect(A::Letter::C.delta(A::Letter::B)).to eq(1)
+    expect(A::Letter::C.delta(A::Letter::C)).to eq(0)
   end
 end

data/spec/direction_pointer_spec.rb

@@ -1,17 +1,44 @@
-require 'rpiet/direction_pointer'
+require_relative '../lib/rpiet/direction_pointer'
 
 describe "DirectionPointer" do
   it "can rotate" do
     dp = RPiet::DirectionPointer.new
 
-    dp.direction.should == RPiet::Direction::RIGHT
+    expect(dp.direction).to eq(RPiet::Direction::RIGHT)
     dp.rotate!
-    dp.direction.should == RPiet::Direction::DOWN
+    expect(dp.direction).to eq(RPiet::Direction::DOWN)
     dp.rotate!
-    dp.direction.should == RPiet::Direction::LEFT
+    expect(dp.direction).to eq(RPiet::Direction::LEFT)
     dp.rotate!
-    dp.direction.should == RPiet::Direction::UP
+    expect(dp.direction).to eq(RPiet::Direction::UP)
     dp.rotate!(2)
-    dp.direction.should == RPiet::Direction::DOWN
+    expect(dp.direction).to eq(RPiet::Direction::DOWN)
+  end
+
+  it "knows it's ordinal values" do
+    dp = RPiet::DirectionPointer.new
+    expect(dp.ordinal).to eq(0)
+    dp.rotate!
+    expect(dp.ordinal).to eq(1)
+    dp.rotate!
+    expect(dp.ordinal).to eq(2)
+    dp.rotate!
+    expect(dp.ordinal).to eq(3)
+    dp.rotate!
+    expect(dp.ordinal).to eq(0)
+  end
+
+  it "can restore from it's ordinal values" do
+    dp = RPiet::DirectionPointer.new
+    dp.from_ordinal!(0)
+    expect(dp.direction).to eq(RPiet::Direction::RIGHT)
+    dp.from_ordinal!(1)
+    expect(dp.direction).to eq(RPiet::Direction::DOWN)
+    dp.from_ordinal!(2)
+    expect(dp.direction).to eq(RPiet::Direction::LEFT)
+    dp.from_ordinal!(3)
+    expect(dp.direction).to eq(RPiet::Direction::UP)
+    dp.from_ordinal!(4)
+    expect(dp.direction).to eq(RPiet::Direction::RIGHT)
   end
 end