rpiet 0.1 → 0.2

data/lib/rpiet/debugger/debugger.rb

@@ -0,0 +1,298 @@
+require 'jrubyfx'
+require 'thread'
+
+# FIXME : JRubyFX is not implementing add correctly.
+class Java::JavafxSceneControl::ScrollPane
+  def add(child)
+    set_content(child)
+  end
+end
+
+module RPiet
+
+  class Debugger < JRubyFX::Application
+    include JRubyFX
+
+    attr_reader :stage
+
+    DEFAULT_DELAY = 0.25 # seconds
+    SIZE = 30
+    NORMAL = Java::javafx.scene.paint.Color.web("0x222222")
+    CANDIDATE = Java::javafx.scene.paint.Color::YELLOW
+    BREAKPOINT = Java::javafx.scene.paint.Color::RED
+    CURRENT = Java::javafx.scene.paint.Color::CADETBLUE
+    WHITE = Java::javafx.scene.paint.Color::WHITE
+
+    ARROW = [2, 9, 11, 9, 10, 4, 18, 10, 10, 16, 11, 11, 2, 11].to_java(:double)
+
+    def self.instance
+      @@instance
+    end
+    
+    def break_point?(x,y)
+      @break_points["#{x}x#{y}"]
+    end
+
+    def update_directions(start_x, start_y, end_x, end_y)
+      stage["#connector"].tap do |connector|
+        connector.start_x = SIZE/2 + codel2pixels(start_x)
+        connector.start_y = SIZE/2 + codel2pixels(start_y)
+        connector.end_x = SIZE/2 + codel2pixels(end_x)
+        connector.end_y = SIZE/2 + codel2pixels(end_y)
+      end
+    end
+
+    def codel2pixels(codel_offset)
+      (codel_offset + 1) * SIZE
+    end
+
+    def begin_session
+      update_directions(-1, 0, 0, 0)
+    end
+
+    def highlight_candidate(runtime, edge_x, edge_y, next_x, next_y, valid)
+      update_directions(edge_x, edge_y, next_x, next_y)
+      # Replace with black edge in debugger later
+      if next_x < 0 || next_y < 0 || next_x >= runtime.source.cols || next_y >= runtime.source.rows
+        puts "OUT OF BOUNDS #{next_x} #{next_y} #{runtime.source.rows} #{runtime.source.cols}"
+        return
+      end
+      run_later do
+        stage["\##{next_x}x#{next_y}"].stroke = CANDIDATE
+        if @lastc_x
+          color = break_point?(@lastc_x, @lastc_y) ? BREAKPOINT : NORMAL
+          if color == NORMAL && stage["\##{@lastc_x}x#{@lastc_y}"].stroke != CURRENT
+            stage["\##{@lastc_x}x#{@lastc_y}"].stroke = color
+          end
+        end
+        @lastc_x, @lastc_y = next_x, next_y
+      end
+    end
+
+    def highlight(runtime, x, y)
+      run_later do
+        stage["\##{x}x#{y}"].stroke = CURRENT
+        if @last_x
+          color = break_point?(@last_x, @last_y) ? BREAKPOINT : NORMAL
+          stage["\##{@last_x}x#{@last_y}"].stroke = color
+        end
+        @last_x, @last_y = x, y
+
+        #@stage["#connector"].visible = false
+        stage["#dp-arrow"].rotate = @rpiet.pvm.dp.degrees
+        stage["#cc-arrow"].rotate = @rpiet.pvm.cc.degrees(@rpiet.pvm.dp)
+        stage["#cc-text"].text = @rpiet.pvm.cc.to_s
+
+        percent_y = y.to_f / (@rpiet.source.rows + 2)
+        percent_x = x.to_f / (@rpiet.source.cols + 2)
+        virtual_w = (@rpiet.source.cols + 2) * SIZE
+        virtual_h = (@rpiet.source.rows + 2) * SIZE
+        sb = stage['#scrollbar']
+        real_x, real_y = x * 43, y * 43  # I lay out 30x30 but they end up 43x43 on screen?
+        real_w, real_h = sb.width, sb.height
+        s_x, s_y = sb.hvalue * virtual_w, sb.vvalue * virtual_h
+
+        # FIXME: Add x,y offset guides on out of bound blocks so scrolling is less confusing
+        # FIXME: Clean this up and use a clamp so we do not exceed scroll bounds
+        a_x = real_x - s_x
+        if a_x > real_w
+          sb.hvalue += 0.1
+        elsif a_x < 0
+          sb.hvalue -= 0.1
+        end
+
+        a_y = real_y - s_y
+        if a_y > real_h
+          sb.vvalue += 0.1
+        elsif a_y < 0
+          sb.vvalue -= 0.1
+        end
+
+
+      #  puts "VirtW: #{virtual_w}, REAL_W: #{real_w}"
+      #  puts "S_X: #{(sb.hvalue * virtual_w).to_i} #{x * 43}"
+      #  puts "V: #{percent_y} #{sb.vmax} #{sb.vvalue} H: #{percent_x} #{sb.hmax} #{sb.hvalue}"
+        runtime.pause if break_point?(x, y)
+      end
+    end
+
+    def operation(runtime, oper)
+      run_later do
+        puts "operation"
+        stage['#oper'].text = "oper: " + oper.to_s
+        stage['#stack'].text = "stack: " + runtime.pvm.stack.inspect
+        stage['#bv'].text = "value: " + runtime.pvm.block_value.inspect
+        stage['#state-values'].visible = true
+      end
+    end
+
+    # JavaFX has some caching so we cheat the cache by using file: uri and varying the uri by adding  a time param.
+    def reload_stylesheet(scene)
+      run_later do
+        scene.stylesheets.clear
+        scene.stylesheets.add(File.join('file:' + File.dirname(__FILE__), (@odd_load_css ? '/./' : '') + "stylesheet.css"))
+        @odd_load_css = !@odd_load_css
+      end
+    end
+
+    def watch_stylesheet(scene)
+      file = File.join(File.dirname(__FILE__), "stylesheet.css")
+      last_time = File.mtime(file)
+      Thread.new do
+        loop do
+          mtime = File.mtime(file)
+
+          if mtime != last_time
+            reload_stylesheet(scene)
+            last_time = mtime
+          else
+            sleep 1
+          end
+        end
+      end.run
+    end
+
+    def start(stage)
+      @rpiet = $rpiet # how does jrubyfx pass params before start is called?
+      @break_points = break_points = {}
+      @stage = stage
+      debugger = self
+      @rpiet.delay = DEFAULT_DELAY
+
+      # FIXME: Move into convenience module near top of JRubyFX hier.  Maybe make a feature for these
+      ::Kernel.instance_eval {
+        define_method(:codel) { |i=1| SIZE * i}
+        define_method(:half_codel) { SIZE/2 }
+      }
+      rows, cols, pixels = @rpiet.source.rows, @rpiet.source.cols, @rpiet.source.pixels
+      rpiet = @rpiet
+      stroke_width = SIZE / 10
+      with(stage, title: "RPiet", width: 800, height: 600) do
+        layout_scene do
+          vbox(id: 'main') do
+            border_pane do
+              top(menu_bar! do
+                menu("File") do
+                  menu_item("Quit") do
+                    set_on_action do |event|
+                      rpiet.abort
+                      Platform.exit
+                    end
+                  end
+                end
+                menu("View") do
+                  menu_item("Reload Stylesheet") { set_on_action { |_| debugger.reload_stylesheet(stage.scene) } }
+                  menu_item("Pause (0.025s)") { set_on_action { |_| rpiet.delay = 0.025 } }
+                  menu_item("Pause (0.1s)") { set_on_action { |_| rpiet.delay = 0.1 } }
+                  menu_item("Pause (#{DEFAULT_DELAY}s)") { set_on_action { |_| rpiet.delay = DEFAULT_DELAY } }
+                end
+              end)
+              left(hbox(id: 'state') do
+                label("DP", id: 'dp-label')
+                polygon(ARROW, id: 'dp-arrow')
+                label("CC:", id: 'cc-label')
+                polygon(ARROW, id: 'cc-arrow')
+                label(rpiet.pvm.cc.to_s, id: 'cc-text')
+                hbox(id: 'state-values') do
+                  label("oper:", id: 'oper')
+                  label("value: ", id: 'bv')
+                  label("stack:", id: 'stack')
+                end
+              end)
+              right(hbox do
+                get_style_class.add "controls"
+                button("restart") do
+                  get_style_class.add "control"
+                  set_on_action { |_| rpiet.restart }
+                end
+                button("pause") do
+                  get_style_class.add "control"
+                  set_on_action { |_| rpiet.pause }
+                end
+                button("resume") do
+                  get_style_class.add "control"
+                  set_on_action { |_| rpiet.resume }
+                end
+                button("step") do
+                  get_style_class.add "control"
+                  set_on_action { |_| rpiet.advance }
+                end
+              end)
+            end
+            scroll_pane(id: 'scrollbar') do |sp|
+              sp.set_content(group() do
+                Java::javafx.scene.layout.VBox.setVgrow(sp, Java::javafx.scene.layout.Priority::ALWAYS)
+
+              # Horizontal top and bottom border
+              (rpiet.source.cols + 2).times do |i|
+                rectangle(codel(i), 0, codel-1, codel-1, stroke_type: :inside, stroke: NORMAL) do
+                  get_style_class.add "out-of-bounds"
+                end
+                text(codel(i) + half_codel, half_codel, (i-1).to_s) if i != 0 && i != cols + 1
+
+                rectangle(codel(i), codel(rpiet.source.rows + 1), codel-1, codel-1,
+                          stroke_type: :inside, stroke: NORMAL) do
+                  get_style_class.add "out-of-bounds"
+                end
+                text(codel(i) + half_codel, codel(rows + 1) + half_codel, (i-1).to_s) if i != 0 && i != cols + 1
+
+              end
+
+              # Left and right vertical border
+              group do
+                rpiet.source.rows.times do |j|
+                  rectangle(0, codel(j + 1), codel-1, codel-1, stroke_type: :inside, stroke: NORMAL) do
+                    get_style_class.add "out-of-bounds"
+                  end
+                  text(half_codel, codel(j + 1) + half_codel, j.to_s)
+
+                  rectangle(codel(cols + 1), codel(j + 1), codel-1, codel-1, stroke_type: :inside, stroke: NORMAL) do
+                    get_style_class.add "out-of-bounds"
+                  end
+                  text(codel(cols + 1) + half_codel, codel(j + 1) + half_codel, j.to_s)
+                end
+              end
+
+              # Main codels
+              pixels.each_with_index do |row, i|
+                row.each_with_index do |piet_pixel, j|
+                  color = Java::javafx.scene.paint.Color.web(piet_pixel.rgb)
+                  ident = "#{i}x#{j}"
+                  rectangle(codel(i+1), codel(j+1), codel-1, codel-1, fill: color,
+                            stroke_type: :inside, stroke_width: stroke_width,
+                            stroke: NORMAL, stroke_line_join: :round, id: ident) do
+                    get_style_class.add "codel"
+                    set_on_mouse_clicked do |event|
+                      new_color = if event.source.stroke == BREAKPOINT
+                                    break_points[ident] = nil
+                                    NORMAL
+                                  else
+                                    break_points[ident] = event.source
+                                    BREAKPOINT
+                                  end
+                      event.source.stroke = new_color
+                    end
+                  end
+                end
+              end
+              # FIXME: stroke_width must be derived but I feel I need to add scrolling and a minimum
+              # codel display SIZE before I can do this.
+              line(start_x: half_codel, start_y: codel + half_codel,
+                   end_x: codel + half_codel, end_y: codel + half_codel, stroke_width: 10, id: 'connector')
+              end)
+            end
+          end
+        end
+      end.show
+
+      stage.set_on_close_request {
+        rpiet.abort
+        Platform.exit
+      }
+      $event_handler.debugger_started self
+      begin_session
+      reload_stylesheet(stage.scene)
+      watch_stylesheet(stage.scene)
+    end
+  end
+end

data/lib/rpiet/debugger/stylesheet.css

@@ -0,0 +1,88 @@
+#bv {
+    -fx-text-fill: #ffffff;
+    -fx-padding: 3;
+}
+
+#cc-arrow {
+    -fx-fill: #ffffff;
+    -fx-padding: 3;
+    -fx-stroke_width: 6;
+}
+
+#cc-label {
+    -fx-text-fill: #ffffff;
+    -fx-padding: 3;
+    -fx-font-size: 28;
+}
+
+#cc-text {
+    -fx-text-fill: #ffffff;
+    -fx-font-size: 28;
+}
+
+.codel {
+    -fx-arc-width: 1;
+    -fx-arc-width: 1;
+    -fx-stroke-width: 2;
+    -fx-background-color: #444455;
+}
+
+#connector {
+    -fx-fill: #999999;
+    -fx-stroke-width: 4;
+}
+
+.controls {
+    -fx-padding: 10;
+    -fx-text-fill: #000000;
+}
+
+.control {
+    -fx-text-fill: #000000;
+}
+
+#dp {
+    -fx-spacing: 20;
+}
+
+#dp-arrow {
+    -fx-fill: #ffffff;
+}
+
+#dp-label {
+    -fx-text-fill: #ffffff;
+    -fx-font-size: 28;
+}
+
+#main {
+    -fx-background-color: #444455;
+}
+
+#oper {
+    -fx-text-fill: #ffffff;
+    -fx-padding: 3;
+}
+
+.out-of-bounds {
+    -fx-arc-width: 1;
+    -fx-arc-width: 1;
+    -fx-stroke-width: 0;
+    -fx-fill: #999999;
+}
+
+#stack {
+    -fx-text-fill: #ffffff;
+    -fx-padding: 3;
+}
+
+#state {
+    -fx-padding: 40;
+}
+
+#state-values {
+}
+
+#value {
+    -fx-text-fill: #ffffff;
+    -fx-padding: 3;
+}

data/lib/rpiet/direction_pointer.rb

@@ -1,39 +1,70 @@
-require 'rpiet/cycle'
-require 'rpiet/codel_chooser'
+require_relative 'cycle'
+require_relative 'codel_chooser'
 
 module RPiet
   extend RPiet::CycleMethod
   cycle :Direction, :RIGHT, :DOWN, :LEFT, :UP
 
-  class << Direction::RIGHT; def deltas; [1, 0]; end; end
-  class << Direction::DOWN; def deltas; [0, 1]; end; end
-  class << Direction::LEFT; def deltas; [-1, 0]; end; end
-  class << Direction::UP; def deltas; [0, -1]; end; end
+  module DirectionExtras
+    def next_point(x, y)
+      dx, dy = deltas
+      [x + dx, y + dy]
+    end
+  end
+
+  class << Direction::RIGHT
+    include DirectionExtras
+    def deltas = [1, 0]
+  end
+
+  class << Direction::DOWN
+    include DirectionExtras
+    def deltas = [0, 1]
+  end
+
+  class << Direction::LEFT
+    include DirectionExtras
+    def deltas = [-1, 0]
+  end
+
+  class << Direction::UP
+    include DirectionExtras
+    def deltas = [0, -1]
+  end
 
   class DirectionPointer
-    attr_reader :direction
+    attr_accessor :direction
+
+    def initialize(value=nil)
+      @direction = value ? RPiet::Direction::RIGHT.abs(value) : RPiet::Direction::RIGHT
+    end
 
-    def initialize
-      @direction = RPiet::Direction::RIGHT
+    def ==(other)
+      @direction == other.direction
     end
 
     def rotate!(amount = 1)
       @direction = @direction.incr amount
+      self
     end
 
-    def next_possible(x, y)
-      dx, dy = @direction.deltas
-      [x + dx, y + dy]
+    def degrees = @direction.value * 90
+
+    def from_ordinal!(ordinal)
+      @direction = @direction.abs(ordinal)
+      self
     end
 
+    def as_constant = %w[RIGHT DOWN LEFT UP][ordinal]
+
+    def next_possible(x, y) = @direction.next_point(x, y)
+
+    def ordinal = @direction.value
+
     ASCII_ARROWS = ['>', 'v', '<', '^']
-    def ascii
-      ASCII_ARROWS[@direction.value]
-    end
+    def ascii = ASCII_ARROWS[@direction.value]
 
-    def inspect
-      @direction.inspect
-    end
+    def inspect = ordinal.to_s
     alias :to_s :inspect
   end
 end

data/lib/rpiet/event_handler.rb

@@ -7,7 +7,10 @@ module RPiet
     def initialized(runtime)
     end
 
-    def step_begin(runtime)
+    def next_possible(runtime, edge_x, edge_y, next_x, next_y, valid)
+    end
+
+    def step_begin(runtime, ex, ey)
     end
 
     def trying_again(runtime, ex, ey)
@@ -19,7 +22,10 @@ module RPiet
     def execution_completed(runtime)
     end
 
-    def operation(runtime, operation)
+    def operation(runtime, step, operation)
+    end
+
+    def instruction(runtime, instruction)
     end
   end
 
@@ -33,10 +39,11 @@ module RPiet
 
       def initialized(runtime)
         dmesg "codel_size: #{runtime.source.codel_size}"
+        dmesg "size: #{runtime.source.cols}x#{runtime.source.rows}"
       end
 
-      def step_begin(runtime)
-        dmesg "step \##{runtime.step} -- #{runtime.pvm}"
+      def step_begin(runtime, ex, ey)
+        dmesg "step \##{runtime.step} at #{ex} #{ey} -- #{runtime.pvm}"
       end
 
       def trying_again(runtime, ex, ey)
@@ -51,16 +58,64 @@ module RPiet
         dmesg "Execution trapped, program terminates"
       end
 
-      def operation(runtime, operation)
-        dmesg "exec: #{operation} -- #{runtime.pvm}"
+      def instruction(runtime, instruction)
+        dmesg "  instr: #{instruction}"
+      end
+
+      def operation(runtime, step, operation)
+        dmesg "exec: step: \##{step} oper: #{operation}, #{runtime}"
       end
     end
 
     class ComplexAsciiOutput < SimpleAsciiOutput
-      def step_begin(runtime)
+      def step_begin(runtime, ex, ey)
         super
         dmesg runtime.source.ascii(runtime.groups[runtime.x][runtime.y])
       end
     end
+
+    class Graphical < SimpleAsciiOutput
+      def initialized(runtime)
+        unless $event_handler
+          require 'rpiet/debugger/debugger'
+          $rpiet = runtime
+          $event_handler = self
+          Thread.new { RPiet::Debugger.launch }.run
+        else
+          @debugger.begin_session
+        end
+        runtime.pause
+      end
+
+      def debugger_started(debugger)
+        @debugger = debugger
+      end
+
+      def step_begin(runtime, ex, ey)
+        @debugger.highlight(runtime, ex, ey)
+        if @debugger.break_point?(ex, ey)
+          puts "Break point at #{ex}, #{ey}"
+        end
+      end
+      alias :trying_again :step_begin
+
+      # edge of current group to potential entry point of next group (valid is if next is a valid group).
+      def next_possible(runtime, edge_x, edge_y, next_x, next_y, valid)
+        @debugger.highlight_candidate(runtime, edge_x, edge_y, next_x, next_y, valid)
+      end
+
+      def operation(runtime, step, operation)
+        # FIXME: display step in debugger
+        @debugger.operation(runtime, operation)
+      end
+
+      def seen_white(runtime)
+        puts "SEEN WHITE"
+      end
+
+      def trying_again(runtime, ex, ey)
+        @debugger.highlight(runtime, ex, ey)
+      end
+    end
   end
 end

data/lib/rpiet/group.rb

@@ -1,16 +1,22 @@
-require 'rpiet/direction_pointer'
-require 'rpiet/codel_chooser'
+require 'set'
+require_relative 'direction_pointer'
+require_relative 'codel_chooser'
 
 module RPiet
   class Group
     include RPiet::Direction
-    attr_reader :rgb, :points
+    attr_reader :color, :points
 
-    def initialize(rgb, point)
-      @rgb, @points = rgb, []
+    # represents significant corners in a group based on the dp and cc.
+    # First letter is the dp: {r-ight, l-eft, d-own, u-p}.
+    # The second letter is the codel chooser: {l-eft, r-ight}.
+    attr_reader :rl, :rr, :lr, :ll, :ul, :ur, :dr, :dl
+
+    def initialize(color, *points)
+      @color, @points = color, []
       @max = { RIGHT => [], LEFT => [], UP => [], DOWN => [] }
 
-      self << point
+      points.each { |point| self << point}
     end
 
     def point_for(pvm)
@@ -35,11 +41,22 @@ module RPiet
       @points << point
     end
 
+    def edges
+      edges = Set.new
+      @points.each do |x, y|
+        edges.add [x, y, :up] unless @points.include?(UP.next_point(x, y))
+        edges.add [x, y, :down] unless @points.include? DOWN.next_point(x, y)
+        edges.add [x, y, :left] unless @points.include?(LEFT.next_point(x, y))
+        edges.add [x, y, :right] unless @points.include? RIGHT.next_point(x, y)
+      end
+      edges
+    end
+
     def include?(point)
       @points.include? point
     end
 
-    def finish
+    def calculate_corners
       @rl, @rr = ends(@max[RIGHT].sort { |a, b| a[1] <=> b[1] })
       @lr, @ll = ends(@max[LEFT].sort { |a, b| a[1] <=> b[1] })
       @ul, @ur = ends(@max[UP].sort { |a, b| a[0] <=> b[0] })
@@ -99,7 +116,7 @@ module RPiet
     end
 
     def inspect
-      "Group #{rgb}: Size: #{size} Points: #{@points.inspect}\n" +
+      "Group #{color}: Size: #{size} Points: #{@points.inspect}\n" +
       "rr #@rr rl #@rl lr #@lr ll #@ll ur #@ur ul #@ul dr #@dr dl #@dl"
     end
     alias :to_s :inspect

data/lib/rpiet/image/ascii_image.rb

@@ -4,25 +4,15 @@ module RPiet
   module Image
     class AsciiImage < RPiet::Image::Image
       def initialize(string, codel_size=1)
-        @codel_size = codel_size
-        lines = string.split("\n")
-        @data = []
-        lines.each do |line|
-          @data << line.split(/\s+/).map { |e| str_to_rgb(e) }
+        super codel_size
+        @data = string.each_line(chomp: true).map do |line|
+          line.split(/\s+/).map { |e| str_to_rgb(e) }
         end
       end
 
-      def raw_pixel(x, y)
-        @data[x][y]
-      end
-
-      def raw_height
-        @data.length
-      end
-
-      def raw_width
-        @data[0].length
-      end
+      def raw_pixel(x, y) = @data[y][x]
+      def raw_height = @data.length
+      def raw_width = @data[0].length
 
       STR2RGB = {
         'lr' => [0xff, 0xc0, 0xc0],
@@ -33,7 +23,7 @@ module RPiet
         'lm' => [0xff, 0xc0, 0xff],
         'nr' => [0xff, 0x00, 0x00],
         'ny' => [0xff, 0xff, 0x00],
-        'ng' => [0xc0, 0xff, 0x00],
+        'ng' => [0x00, 0xff, 0x00],
         'nc' => [0x00, 0xff, 0xff],
         'nb' => [0x00, 0x00, 0xff],
         'nm' => [0xff, 0x00, 0xff],
@@ -47,9 +37,7 @@ module RPiet
         '++' => [0x00, 0x00, 0x00]
       }
 
-      def str_to_rgb(str)
-        STR2RGB[str]
-      end
+      def str_to_rgb(str) = STR2RGB[str]
     end
   end
 end