rpiet 0.1 → 0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f899ca8b426c587720e0f92d070276e4f4290f6c06129768d7ce76f0f4c8aa44
+  data.tar.gz: a595f1cd225d3bfe78212e9d637023fd88edad148ce5376b0e57bea27f3d4844
+SHA512:
+  metadata.gz: 494ead01ba5971cf780765a0527bd5be690897701a9e025a94943b3e3bc1a07a63bdd98ba0b4ee4455935de44b56c0b462c8c8de0ddaf49ab9fc700f5345dd39
+  data.tar.gz: 9d65d740f440808d57854cceceede0a8e07b7713833501ae8bf14c0b5680515188e7e7b4e1b4ca767c8cc0bc5fec123b260ab41af3fd34ceea1bc692ca9eec9b

data/.gitignore

@@ -7,3 +7,4 @@ manifest.mf
 dist
 build
 nbproject
+.idea/

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'jrubyfx', platform: :jruby
+gem 'image_voodoo', platform: :jruby
+gem 'mini_magick', platform: :ruby
+gem 'rgl'
+
+group :development do
+  gem 'rspec'
+end

data/bin/color_wheel

@@ -0,0 +1,84 @@
+#!/bin/env ruby
+require 'rpiet/color'
+require 'rpiet/image/ascii_image'
+
+
+def die(message)
+  puts message
+  exit -1
+end
+
+def decode(item)
+  item, dimensions = item.split(':') if item.include? ':'
+
+  if dimensions
+    if dimensions.include? 'x'
+      rows, cols = dimensions.split('x').map &:to_i
+    else
+      rows, cols = 1, dimensions.to_i
+    end
+  else
+    rows, cols = 1, 1
+  end
+
+  [item, rows, cols]
+end  
+
+# Starting color
+color_name = ARGV.shift
+commands = ARGV
+color_name, rows, cols = decode(color_name)
+
+rgb = RPiet::Image::AsciiImage::STR2RGB[color_name]
+die "Invalid color name: '#{color_name}'" unless rgb
+
+color = RPiet::Color.color_for(format "0x%02x%02x%02x" % rgb)
+
+CHANGES = {
+  noop: [0, 0],
+  push: [0, 1],
+  pop: [0, 2],
+  add: [1, 0],
+  sub: [1, 1],
+  mult: [1, 2],
+  div: [2, 0],
+  mod: [2, 1],
+  not: [2, 2],
+  gtr: [3, 0],
+  pntr: [3, 1],
+  swch: [3, 2],
+  dup: [4, 0],
+  roll: [4, 1],
+  nin: [4, 2],
+  cin: [5, 0],
+  nout: [5, 1],
+  cout: [5, 2]
+}
+
+
+total_rows, total_cols = rows, cols
+groups = [[color, rows, cols]]
+commands.each do |command|
+  command, rows, cols = decode command
+  deltas = CHANGES[command.to_sym]
+  die "Invalid command: '#{command}'" unless deltas
+  color = color.color_from(hue_delta: deltas[0], lightness_delta: deltas[1])
+  groups << [color, rows, cols]
+  total_rows = rows if rows > total_rows
+  total_cols += cols
+end
+
+image = Array.new(total_rows) { Array.new(total_cols) {'++'} }
+
+col_index, row_index = 0, 0
+groups.each do |color, rows, cols|
+  id = color.to_initial
+  rows.times do |j|
+    cols.times do |i|
+      image[row_index + j][col_index + i] = id
+    end
+  end
+  col_index += cols
+end
+
+image.each { |rows|  puts rows.join(' ') }

data/bin/image_gen

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'rpiet/image/ascii_image'
+require 'image_voodoo'
+
+input_codel_size = 1
+output_codel_size = input_codel_size
+image_type = "png"
+opts = OptionParser.new do |opts|
+  opts.on("-i", "--input-codel-size w", "size of input codel") { |w| input_codel_size = w.to_i }
+  opts.on("-o", "--output-odel-size w", "size of output codel") { |w| output_codel_size = w.to_i }
+  opts.on("-t", "--image-type suffix", "image format") { |t| image_type = t }
+end
+
+opts.parse!(ARGV)
+unless ARGV.first
+  puts "You need to supply a source image filename."
+  puts opts
+  exit -1
+end
+
+filename = ARGV.first
+file_contents = filename == '-' ? $stdin.read(nil) : File.read(filename)
+
+image = RPiet::Image::AsciiImage.new(file_contents, input_codel_size)
+width, height = image.size
+
+canvas = ImageVoodoo.canvas(output_codel_size * width, output_codel_size * height, 'ffffff')
+
+image.each do |i, j, color|
+  canvas.rect i * output_codel_size, j * output_codel_size, output_codel_size, output_codel_size, color.rgb[2..-1]
+end
+
+if filename == '-'
+  $stdout.write canvas.bytes('png')
+else
+  canvas.save(File.basename(filename, ".txt") + "." + image_type)
+end

data/bin/rpiet

@@ -2,29 +2,86 @@
 
 require 'optparse'
 require 'rpiet'
-require 'rpiet/image/url_image'
 
+run = :chowder
+time_execution = false
 codel_size = 1
 
-log = RPiet::Logger::NoOutput
+dump = nil
+
+log = nil
 opts = OptionParser.new do |opts|
   opts.banner = "Usage: #{__FILE__} -d image_file"
 
+  opts.on("-t", "--time", "time execution") { time_execution = true }
+  opts.on("-r", "--runtime runtime") do |runtime|
+    run = case runtime
+          when 'native' then :native
+          when 'graph' then :graph
+          when 'ir' then :ir
+          when 'cfg' then :cfg
+          when 'chowder' then :chowder
+          else raise ArgumentError.new("invalid runtime specified: #{runtime}")
+          end
+
+  end
+  opts.on("-I", "--dump-ir", "Dump image as IR instructions") { dump = :ir }
   opts.on("-d", "--debug style", "turn on debugging") do |style|
     log = case style
-    when 'simple'
-      RPiet::Logger::SimpleAsciiOutput
-    when 'complex'
-      RPiet::Logger::ComplexAsciiOutput
-    end
+          when 'simple' then RPiet::Logger::SimpleAsciiOutput.new
+          when 'complex' then RPiet::Logger::ComplexAsciiOutput.new
+          when 'graphical' then RPiet::Logger::Graphical.new
+          else raise ArgumentError.new("invalid logger specified: #{style}")
+          end
   end
   opts.on("-c", "--codel-size w", "size of codel") { |w| codel_size = w.to_i }
 end
 
 opts.parse!(ARGV)
-opts.usage("You need to supply a source image filename.") unless ARGV.first
+unless ARGV.first
+  puts "You need to supply a source image filename."
+  puts opts
+  exit -1
+end
 
 filename = ARGV.first
-filename = 'file:' + ARGV.first if File.exist? filename
-image = RPiet::Image::URLImage.new(filename, codel_size)
-RPiet::Interpreter.new(image, log.new).run
+
+if filename =~ /.txt/
+  require 'rpiet/image/ascii_image'
+  image = RPiet::Image::AsciiImage.new(File.read(filename), codel_size)
+elsif filename == '-'
+  require 'rpiet/image/ascii_image'
+  image = RPiet::Image::AsciiImage.new($stdin.gets(nil), codel_size)
+else
+  filename = 'file:' + filename if File.exist? filename
+  require 'rpiet/image/url_image'
+  image = RPiet::Image::URLImage.new(filename, codel_size)
+end
+
+
+runner = case run
+         when :graph
+           require 'rpiet/asg/graph_interpreter'
+           RPiet::ASG::GraphInterpreter.new(image, log)
+         when :ir
+           require 'rpiet/ir/ir_interpreter'
+           RPiet::IR::IRInterpreter.new(image, log)
+         when :cfg
+           require 'rpiet/ir/ir_cfg_interpreter'
+           RPiet::IR::IRCFGInterpreter.new(image, log)
+         when :native
+           require 'rpiet/ir/ir_native_interpreter'
+           RPiet::IR::IRNativeInterpreter.new(image, log)
+         else
+           RPiet::Interpreter.new(image, log)
+         end
+
+if dump && (run == :ir || run == :cfg)
+  puts runner.disasm
+else
+  start = Time.now if time_execution
+  runner.run
+  puts "time: #{Time.now - start}s" if time_execution
+end
+
+exit 0

data/images/counter.txt

@@ -0,0 +1,7 @@
+lr db .. nc dc dc dc dc dc
+++ ++ ++ ++ ++ nc ++ ++ lb
+++ ny ++ ++ ++ .. ++ ++ lb
+ny ny ny ++ ++ .. ++ ++ lg
+++ ny ++ ++ ++ .. ++ ++ ng
+++ ny .. .. .. nc lr lc dg
+

data/lib/rpiet/asg/graph_interpreter.rb

@@ -0,0 +1,39 @@
+require_relative '../asg'
+require_relative 'parser'
+
+module RPiet
+  module ASG
+    class GraphInterpreter
+      include LiveMachineState
+
+      def initialize(image, event_handler = nil)
+        Node.handle_event_handler(@event_handler = event_handler)
+        # FIXME: need a way to debug parser conditionally from command line
+        @graph = Parser.new(image).run
+      end
+
+      def reset
+        reset_machine()
+        @node = @graph
+      end
+
+      def next_step
+        while @node && @node.hidden?
+          @node = @node.exec self
+        end
+        @node = @node.exec self if @node
+      end
+
+      def running?
+        @node
+      end
+
+      def run
+        reset
+        while running? do
+          next_step
+        end
+      end
+    end
+  end
+end

data/lib/rpiet/asg/parser.rb

@@ -0,0 +1,156 @@
+require_relative '../color'
+require_relative '../machine'
+require_relative '../source'
+require_relative '../event_handler'
+require_relative '../asg'
+
+module RPiet
+  module ASG
+    class Parser
+      ##
+      # Represents the transition to the next possible group from
+      # the current group.  The direction is directed by the cc
+      # and dp values.  The node passed in is the previously created
+      # node.  The result of this translation will get pointed to by
+      # the supplied node.
+      class Transition
+        attr_reader :group, :cc_ordinal, :dp_ordinal
+        attr_accessor :node
+
+        def initialize(group, cc_ordinal, dp_ordinal, node)
+          @group, @cc_ordinal, @dp_ordinal, @node = group, cc_ordinal, dp_ordinal, node
+        end
+
+        def eql?(other)
+          other.group == @group && other.cc_ordinal == @cc_ordinal && other.dp_ordinal == @dp_ordinal
+        end
+
+        def hash
+          @cc_ordinal ^ @group.hash ^ @dp_ordinal
+        end
+
+        def inspect
+          "#{group}: #{@cc_ordinal}=#{@dp_ordinal}"
+        end
+
+        alias :to_s :inspect
+      end
+
+      attr_reader :pvm, :source, :pixels, :x, :y, :step
+
+      def initialize(image, event_handler = RPiet::Logger::NoOutput.new)
+        @source, @event_handler = RPiet::Source.new(image), event_handler
+        @x, @y, @pvm, @step = 0, 0, RPiet::Machine.new, 1
+        @work_list = []
+        @already_visited = {} # state => node
+        @graph = Node.create(@step, @x, @y, :noop)
+        @nodes = {}
+      end
+
+      def run
+        @work_list.push Transition.new(@source.group_at(@x, @y), @pvm.cc.ordinal, @pvm.dp.ordinal, @graph)
+        while !@work_list.empty?
+          restore_state(@work_list.pop)
+          next_step
+        end
+        @graph
+      end
+
+      ##
+      # Add state to graph.  If we have seen it we link to it otherwise we add to worklist.
+      def add_state(state)
+        if @already_visited[state]
+          state.node.add_path @already_visited[state], state.cc_ordinal, state.dp_ordinal
+        elsif !@work_list.include?(state)
+          @work_list.push state
+        end
+      end
+
+      def restore_state(state)
+        @x, @y = state.group.rl
+        @pvm.cc.from_ordinal! state.cc_ordinal
+        @pvm.dp.from_ordinal! state.dp_ordinal
+        @current_state = state
+      end
+
+      def create_node(step, x, y, operation, block_value)
+        node = Node.create(step, x, y, operation, block_value)
+        return @nodes[node] if @nodes[node]
+        @nodes[node] = node
+        node
+      end
+
+      def next_step
+        @pvm.block_value = @source.group_at(@x, @y).size
+        attempt = 1
+        seen_white = false
+        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)
+
+          if !valid
+            @pvm.orient_elsewhere(attempt)
+            attempt += 1
+
+            ex, ey = @source.group_at(@x, @y).point_for(@pvm) if !seen_white
+            @event_handler.trying_again(self, ex, ey)
+          elsif @source.pixels[nx][ny] == RPiet::Color::WHITE
+            if !seen_white
+              seen_white = true
+              attempt = 1
+              @event_handler.seen_white(self)
+            end
+            ex, ey = nx, ny
+          else
+            if !seen_white
+              operation = @pvm.calculate_operation @source.pixels[nx][ny], @source.pixels[@x][@y]
+            else
+              operation = :noop
+            end
+
+            @step += 1
+
+            if @current_state.dp_ordinal != @pvm.dp.ordinal
+              node = Node.create(@step, nx, ny, :dp, @pvm.cc.ordinal, @pvm.dp.ordinal)
+              @current_state.node.add_path(node, @current_state.cc_ordinal, @current_state.dp_ordinal)
+              @current_state.node = node
+              @already_visited[@current_state] = node
+            end
+            if @current_state.cc_ordinal != @pvm.cc.ordinal
+              node = Node.create(@step, nx, ny, :cc, @pvm.cc.ordinal, @pvm.dp.ordinal)
+              @current_state.node.add_path(node, @current_state.cc_ordinal, @current_state.dp_ordinal)
+              @current_state.node = node
+              @already_visited[@current_state] = node unless @already_visited[@current_state]
+            end
+
+            node = create_node(@step, nx, ny, operation, @pvm.block_value)
+            @current_state.node.add_path(node, @current_state.cc_ordinal, @current_state.dp_ordinal)
+            @already_visited[@current_state] = node unless @already_visited[@current_state]
+
+            @x, @y = nx, ny
+            group = @source.group_at(@x, @y)
+
+            case operation
+            when :swch
+              add_state Transition.new(group, -1, @pvm.dp.ordinal, node)
+              add_state Transition.new(group, 1, @pvm.dp.ordinal, node)
+            when :pntr
+              add_state Transition.new(group, @pvm.cc.ordinal, 0, node)
+              add_state Transition.new(group, @pvm.cc.ordinal, 1, node)
+              add_state Transition.new(group, @pvm.cc.ordinal, 2, node)
+              add_state Transition.new(group, @pvm.cc.ordinal, 3, node)
+            else
+              add_state Transition.new(group, @pvm.cc.ordinal, @pvm.dp.ordinal, node)
+            end
+            return
+          end
+        end
+        @current_state.node.add_path(ExitNode.new(step, x, y))
+        @event_handler.execution_completed(self)
+      end
+    end
+  end
+end

data/lib/rpiet/asg/visitor.rb

@@ -0,0 +1,66 @@
+require 'set'
+
+module RPiet
+  # Generic visitor for visiting all nodes in the graph once but
+  # then also visiting all nodes which complete a cycle a second time.
+  class Visitor
+    def initialize
+      @visited = Set.new
+    end
+
+    def run(root)
+      worklist = [root]
+      
+      visit worklist
+    end
+
+    def visit(worklist)
+      while !worklist.empty?
+        node = worklist.pop
+        next unless node
+        already_visited = @visited.include? node
+
+        if already_visited
+          visit_again node
+        else
+          @visited.add node
+          if node  # child of nil means exit
+            if node.operation == :pntr
+              work_items = visit_first_pntr node, worklist
+            elsif node.operation == :swch
+              work_items = visit_first_swch node, worklist
+            else
+              work_items = visit_first node
+            end
+            worklist.concat work_items if work_items && !work_items.empty?
+          end
+        end
+        break if worklist.empty?
+      end
+    end    
+
+    def visit_children(node)
+      node.paths.each do |next_node|
+        next_node.visit self if next_node
+      end
+    end
+
+    def visit_first(node)
+      node.paths
+    end
+
+    # First time we encounter an individual swch node
+    def visit_first_swch(node, worklist=nil)
+      node.paths
+    end
+
+    # First time we encounter an individual pntr node
+    def visit_first_pntr(node, worklist=nil)
+      node.paths
+    end
+
+    # Second time we encounter any ndoe
+    def visit_again(node)
+    end
+  end
+end