rpiet 0.1 → 0.2

data/lib/rpiet/image/image.rb

@@ -15,11 +15,16 @@ module RPiet
 
       def pixel(x, y)
         r,g,b = raw_pixel(x * @codel_size, y * @codel_size)
-        color_for(format "0x%02x%02x%02x" % [r,g,b])
+        RPiet::Color.color_for(format "0x%02x%02x%02x" % [r,g,b])
       end
 
-      def color_for(rgb_hex)
-        RPiet::Color::RGB[rgb_hex]
+      def each
+        w, h = size
+        h.times do |j|
+          w.times do |i|
+            yield i, j, pixel(i, j)
+          end
+        end
       end
 
       def ascii(group = [])

data/lib/rpiet/image/url_image.rb

@@ -1,27 +1,41 @@
-require 'java'
+
 require 'rpiet/image/image'
 
 # Raw in Java is BufferendImage.  In MRI it just needs to define:
 #  width, height, getRGB(x, y)
 module RPiet
   module Image
-    class URLImage < RPiet::Image::Image
-      def initialize(file, codel_size=1)
-        super(codel_size)
-        @raw = javax.imageio.ImageIO.read(java.net.URL.new(file))
-      end
+    if RUBY_ENGINE == "jruby"
+      class URLImage < RPiet::Image::Image
+        attr_reader :raw_width, :raw_height
 
-      def raw_pixel(x, y)
-        rgb = @raw.getRGB(x, y)
-        [(rgb >> 16 ) & 0xff, (rgb >> 8) & 0xff, rgb & 0xff]
-      end
+        def initialize(file, codel_size=1)
+          super(codel_size)
+          image = javax.imageio.ImageIO.read(java.net.URL.new(file))
+          @raw_width, @raw_height, @raw = image.width, image.height, image
+        end
 
-      def raw_width
-        @raw.width
+        def raw_pixel(x, y)
+          rgb = java.awt.Color.new(@raw.get_rgb(x, y))
+
+          [rgb.red, rgb.green, rgb.blue]
+        end
       end
+    else
+      require 'mini_magick'
+      class URLImage < RPiet::Image::Image
+        attr_reader :raw_width, :raw_height
+
+        def initialize(file, codel_size=1)
+          super(codel_size)
+          file = file[5..-1] if file.start_with?('file:')
+          image = MiniMagick::Image.open(file)
+          @raw_width, @raw_height, @raw = image.width, image.height, image.get_pixels
+        end
 
-      def raw_height
-        @raw.height
+        def raw_pixel(x, y)
+          @raw[y][x]
+        end
       end
     end
   end

data/lib/rpiet/interpreter.rb

@@ -1,63 +1,99 @@
-require 'rpiet/color'
-require 'rpiet/machine'
-require 'rpiet/group'
-require 'rpiet/event_handler'
+require_relative 'color'
+require_relative 'machine'
+require_relative 'source'
+require_relative 'event_handler'
 
 module RPiet
   class Interpreter
-    attr_reader :pvm, :source, :groups, :x, :y, :step
+    attr_reader :pvm, :source, :pixels, :x, :y, :step, :event_handler
 
-    def initialize(source, event_handler=RPiet::Logger::NoOutput.new)
+    def initialize(image, event_handler=RPiet::Logger::NoOutput.new)
+      @interpreter_thread = Thread.current
+      @source, @event_handler = RPiet::Source.new(image), event_handler
+      @delay = 0
+    end
+
+    def delay=(time)
+      @delay = time
+    end
+
+    def pause
+      @paused = true
+    end
+
+    def resume
+      @paused = false
+      @interpreter_thread.run
+    end
+
+    def advance
+      @paused = true
+      @interpreter_thread.run
+    end
+
+    def restart
+      @restart = true
+      abort
+    end
+
+    def abort
+      @abort = true
+      resume
+    end
+
+    def reset
       @x, @y, @pvm, @step = 0, 0, RPiet::Machine.new, 1
-      @source, @event_handler = source, event_handler
-      @rows, @cols = @source.size
-      @pixels = alloc_matrix { |i, j| @source.pixel(i, j)}
-      @groups = calculate_groups(alloc_matrix { |i, j| 0 })
       @event_handler.initialized(self)
     end
 
     def run
-      while(next_step) do
+      @restart = true
+      while @restart
+        @restart = false
+        reset
+        Thread.stop if @paused
+        while(next_step) do
+          Thread.stop if @paused
+        end
+        @abort = false
       end
     end
 
-    ##
-    # Is this point on the image and not black?
-    def valid?(x, y)
-      x >= 0 && x < @rows && y >= 0 && y < @cols && 
-        @pixels[x][y] != RPiet::Color::BLACK
-    end
-
     def next_step
-      @pvm.block_value = @groups[@x][@y].size
-      i = 0
+      return false if @abort
+      @pvm.block_value = @source.group_at(@x, @y).size
+      attempt = 1
       seen_white = false
-      @event_handler.step_begin(self)
-      ex, ey = @groups[@x][@y].point_for(@pvm)
-      while i < 8 do
-        nx, ny = @pvm.next_possible(ex, ey)
+      ex, ey = @source.group_at(@x, @y).point_for(@pvm)                         # Exit point from group
+      @event_handler.step_begin(self, ex, ey)
+      while attempt <= 8 do
+        nx, ny = @pvm.next_possible(ex, ey)                                     # where we enter Next group
+        valid = @source.valid?(nx, ny)
+        @event_handler.next_possible(self, ex, ey, nx, ny, valid)
+        sleep @delay if @delay != 0
+        Thread.stop if @paused
+        return false if @abort
 
-        if !valid?(nx, ny)
-          i += 1
-          @pvm.orient_elsewhere(i)
+        if !valid
+          @pvm.orient_elsewhere(attempt)
+          attempt += 1
 
-          ex, ey = @groups[@x][@y].point_for(@pvm) if !seen_white
+          ex, ey = @source.group_at(@x, @y).point_for(@pvm) if !seen_white
           @event_handler.trying_again(self, ex, ey)
-          next
-        elsif @pixels[nx][ny] == RPiet::Color::WHITE
+        elsif @source.pixels[nx][ny] == RPiet::Color::WHITE
           if !seen_white
             seen_white = true
-            i = 0
+            attempt = 1
             @event_handler.seen_white(self)
           end
           ex, ey = nx, ny
         else
           if !seen_white
-            operation = @pvm.execute(@pixels[nx][ny], @pixels[@x][@y])
+            operation = @pvm.execute(@source.pixels[nx][ny], @source.pixels[@x][@y])
           else
             operation = 'noop'            
           end
-          @event_handler.operation(self, operation)
+          @event_handler.operation(self, @step, operation)
           @x, @y = nx, ny
           @step += 1
           return true
@@ -67,46 +103,10 @@ module RPiet
       false
     end
 
-    # always look up, left, or make new group
-    def calculate_groups(groups)
-      all_groups = []
-      walk_matrix(groups) do |i, j|
-        rgb = @pixels[i][j]
-        up = j-1 >= 0 ? groups[i][j-1] : nil
-        left = i-1 >= 0 ? groups[i-1][j] : nil
-        if up && up.rgb == rgb
-          up << [i, j]
-          groups[i][j] = up
-          # disjoint groups to merge
-          up.merge(groups, left) if left && left != up && left.rgb == rgb
-        end
-
-        if groups[i][j] == 0 && left && left.rgb == rgb
-          left << [i, j]
-          groups[i][j] = left
-        end
-
-        if groups[i][j] == 0
-          groups[i][j] = RPiet::Group.new(rgb, [i, j])
-          all_groups << groups[i][j]
-        end
-      end
-      all_groups.each { |group| group.finish }
-      groups
-    end
-
-    def alloc_matrix
-      Array.new(@rows) { Array.new(@cols) {nil} }.tap do |matrix|
-        walk_matrix(matrix) { |i, j| matrix[i][j] = yield i, j }
-      end
+    def to_s
+      @pvm.to_s
     end
 
-    def walk_matrix(matrix)
-      0.upto(@rows-1) do |i|
-        0.upto(@cols-1) do |j|
-          yield i, j
-        end
-      end
-    end
+    def stack = @pvm.stack
   end
 end

data/lib/rpiet/ir/assembler.rb

@@ -0,0 +1,87 @@
+require_relative 'instructions'
+require_relative 'operands'
+
+module RPiet
+  module IR
+    class Assembler
+      class << self
+        include Instructions, Operands
+
+        def assemble(code)
+          instructions = []
+          assignments = {}
+
+          code.split($/).each do |line|
+            result, rhs = line.split(/\s+=\s+/, 2)
+            rhs, result = result, nil unless rhs
+            if rhs =~ /\s*(\S+)\s*(==|!=|\*\*|[>\*\/\-%+])\s+(\S+)(?:\s*(\S+))?\s*/
+              operation, *operands = $2, *[$1, $3, $4].compact
+            else
+              operation, *operands = rhs.split(/\s+/)
+            end
+
+            instructions << create(assignments, result, operation, *operands)
+          end
+
+          instructions
+        end
+
+        def create(assignments, result, operation, *operands)
+          result = create_assignment(assignments, result) if result
+          operands = create_operands(assignments, *operands)
+
+          # Assumes assembly is valid.
+          case operation
+          when 'push' then PushInstr.new(operands[0])
+          when 'dpset' then DPSetInstr.new(operands[0])
+          when 'ccset' then CCSetInstr.new(operands[0])
+          when 'pop' then PopInstr.new(result)
+          when 'dpget' then DPGetInstr.new(result)
+          when 'ccset' then CCGetInstr.new(result)
+          when '+' then AddInstr.new(result, *operands)
+          when '-' then SubInstr.new(result, *operands)
+          when '*' then MultInstr.new(result, *operands)
+          when '/' then DivInstr.new(result, *operands)
+          when '%' then ModInstr.new(result, *operands)
+          when '**' then PowInstr.new(result, *operands)
+          when 'nout' then NoutInstr.new(*operands)
+          when 'cout' then CoutInstr.new(*operands)
+          when '>' then GTInstr.new(result, *operands)
+          when '==' then BEQInstr.new(*operands)
+          when '!=' then BNEInstr.new(*operands)
+          when 'jump' then JumpInstr.new(*operands)
+          when 'cin' then CinInstr.new(result)
+          when 'nin' then NinInstr.new(result)
+          when 'roll' then RollInstr.new *operands
+          when 'copy' then CopyInstr.new(result, *operands)
+          when 'label' then LabelInstr.new(*operands)
+          when 'exit' then ExitInstr.new
+          else
+            raise ArgumentError.new("unknown operation: #{operation}")
+          end
+        end
+
+        def create_assignment(assignments, result)
+          raise ArgumentError.new("result must be variable") unless result[0] == 'v'
+          raise ArgumentError.new("Same assignment found: #{result}.  Not in SSA form") if assignments[result]
+          assignments[result] = VariableOperand.new(result)
+        end
+
+        def create_operands(assignments, *operands)
+          operands.map do |operand|
+            case operand[0]
+            when 'v' then
+              variable = assignments[operand]
+              raise ArgumentError.new("Variable without assignment found: #{operand}.  Not in SSA form") unless variable
+              variable
+            when /[\d-]/ then Integer(operand)
+            when '\'' then operand[1..-2]
+            when /\S/ then operand.to_sym
+            else raise ArgumentError.new("unknown operand: #{operand}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rpiet/ir/builder.rb

@@ -0,0 +1,255 @@
+require_relative '../asg/visitor'
+require_relative 'instructions'
+require_relative 'operands'
+
+module RPiet
+  # Visit each node from ASG and translate into simpler more
+  # traditional instructions.  These instructions will be
+  # translated into different back-ends.
+  class Builder < Visitor
+    DEBUG = false
+    include RPiet::IR::Instructions, RPiet::IR::Operands
+
+    attr_reader :instructions, :dp, :cc
+
+    def initialize
+      super
+      @instructions = []
+      @node_mappings = {} # instruction -> node
+      @jump_labels = {} # node -> label
+      @variable_counter = 0
+      @current_node = nil
+      add DPInstr.new(num(0))
+      add CCInstr.new(num(-1))
+    end
+
+    def run(graph)
+      super
+      # We need to preserve noops while building initial instrs because backward
+      # jumps may target the first instr for a graph node and that can be a noop.
+      #@instructions.delete_if { |instr| instr.operation == :noop }
+    end
+
+    def copy(variable, value, comment=nil)
+      add(CopyInstr.new(variable, value).tap do |instr|
+        instr.comment = comment if comment
+      end)
+    end
+
+    def visit_first(node)
+      @graph_node = node
+      @current_node = node
+      instructions_for node
+      super node
+    end
+
+    # def visit_first_pntr(node, worklist)
+    #   # In stack make pntr = (pntr + 1) % 4
+    #   @current_node = node
+    #   @graph_node = node
+    #   variable, dp = pop, acquire_variable
+    #   add DPRotateInstr.new(dp, variable)
+    #   # FIXME: n paths can go to same location so this should consider emitting to produce less jumps
+    #   label(:"end_pntr#{@graph_node.step}") do |end_label|
+    #     4.times do |i|
+    #       if i == 3
+    #         next_label = end_label
+    #       else
+    #         segment_label = LabelInstr.new(:"pntr[#{i}]#{@graph_node.step}")
+    #         next_label = segment_label.value
+    #       end
+    #       add BNEInstr.new dp, DirectionPointer.from_ordinal(i), next_label
+    #       visit(worklist << node.paths[i])
+    #       @graph_node = node
+    #       add segment_label unless i == 3
+    #     end
+    #   end
+    #
+    #   nil
+    # end
+
+    def visit_first_pntr(node, worklist)
+      # In stack make pntr = (pntr + 1) % 4
+      @current_node = node
+      @graph_node = node
+      variable, dp = pop, acquire_variable
+      add DPRotateInstr.new(dp, variable)
+      labels = []
+      3.times do |i|
+        label = LabelInstr.new(:"pntr_#{i}_#{@graph_node.step}")
+        add BEQInstr.new dp, DirectionPointer.new(i), label.value
+        labels << label
+      end
+      label = LabelInstr.new(:"pntr_3_#{@graph_node.step}")
+      labels << label
+      jump label.value
+
+      4.times do |i|
+        @graph_node = node
+        add labels[i]
+        visit(worklist << node.paths[i])
+      end
+      nil
+    end
+
+    def visit_first_swch(node, worklist)
+      @current_node = node
+      @graph_node = node
+      value, cc = pop, acquire_variable
+      add CCToggleInstr.new(cc, value)
+
+      # both swch paths goes to same location so eliminate the jumping logic
+      if node.paths[0] == node.paths[1]
+        visit(worklist << node.paths[0])
+      else
+        label(:"swch_left_#{@graph_node.step}") do |next_label|
+          add BNEInstr.new(cc, CodelChooser::LEFT, next_label)
+          visit(worklist << node.paths[0])
+        end
+        visit(worklist << node.paths[1])
+      end
+      nil
+    end
+
+    def visit_again(node)
+      label = @jump_labels[node]
+      @graph_node = node
+
+      unless label  # first time to insert label
+        label_operand = :"re_#{node.object_id}"
+        label = LabelInstr.new(label_operand)
+        label.graph_node = node
+        @jump_labels[node] = label
+        index = @instructions.find_index(@node_mappings[node])
+        @instructions.insert index, label if index
+      else
+        label_operand = label.value
+      end
+
+      # This will be in proper place because all new nodes are added to
+      # end of instruction list.
+      jump = JumpInstr.new(label_operand)
+      jump.comment = "back to visited #{node} => #{label_operand}"
+      add(jump)
+    end
+
+    def add(instruction)
+      # For first instruction that represents a node from ASG we record it
+      # so when we encounter a cycle we know where we should jump.
+      if @current_node
+        @node_mappings[@current_node] = instruction
+        @current_node = nil
+      end
+
+      instruction.graph_node = @graph_node
+
+      @instructions << instruction
+    end
+
+    def num(value)
+      Integer(value)
+    end
+
+    def string(value)
+      value
+    end
+
+    def acquire_variable
+      VariableOperand.new("v#{@variable_counter += 1}")
+    end
+
+    def jump(label)
+      add JumpInstr.new label
+    end
+
+    def label(label_name)
+      saved_node = @current_node
+      label = LabelInstr.new(label_name)
+      yield label.value
+      @current_node = saved_node
+      add label
+    end
+
+    def mod(operand1, operand2)
+      acquire_variable.tap { |result| add ModInstr.new result, operand1, operand2 }
+    end
+
+    def mult(operand1, operand2)
+      acquire_variable.tap { |result| add MultInstr.new result, operand1, operand2 }
+    end
+
+    def plus(operand1, operand2)
+      acquire_variable.tap { |result| add AddInstr.new result, operand1, operand2 }
+    end
+
+    def pop
+      acquire_variable.tap { |variable| add PopInstr.new variable }
+    end
+
+    def pow(operand1, operand2)
+      acquire_variable.tap { |result| add PowInstr.new result, operand1, operand2 }
+    end
+
+    def push(operand)
+      add PushInstr.new operand
+    end
+
+    def instructions_for(node)
+      case node.operation
+      when :noop then add(NoopInstr.new)
+      when :push then push(num(node.value))
+      when :pop then pop
+      when :add then bin_op AddInstr
+      when :sub then bin_op SubInstr
+      when :mult then bin_op MultInstr
+      when :div then bin_op DivInstr
+      when :mod then bin_op ModInstr
+      when :nout then unary_op NoutInstr
+      when :cout then unary_op CoutInstr
+      when :gtr then
+        value2, value1, result = pop, pop, acquire_variable
+          add GTInstr.new result, value1, value2
+        push(result)
+      when :not then # REWRITE AS BEQ/BNE
+        value1, result = pop, acquire_variable
+        add NEInstr.new result, value1, num(0)
+        push(result)
+      when :dup then
+        variable = pop
+        push(variable)
+        push(variable)
+      when :cin then
+        # Can be written in terms in nin
+        variable = acquire_variable
+        add CinInstr.new variable
+        push(variable)
+      when :nin then
+        variable = acquire_variable
+        add NinInstr.new variable
+        push(variable)
+      when :swch then
+        @in_branch_oper, @in_branch = :swch, -1
+      when :roll then
+        variable1, variable2 = pop, pop
+        add RollInstr.new variable2, variable1
+      when :cc then
+        add CCInstr.new(num(node.value))
+      when :dp then
+        add DPInstr.new(num(node.value))
+      when :exit then
+        add ExitInstr.new
+      end
+
+    end
+
+    def bin_op(instr_class)
+      variable1, variable2, variable3 = pop, pop, acquire_variable
+      add instr_class.new variable3, variable2, variable1
+      push(variable3)
+    end
+
+    def unary_op(instr_class)
+      add instr_class.new(pop)
+    end
+  end
+end