rpiet 0.1 → 0.2

data/lib/rpiet/asg.rb

@@ -0,0 +1,336 @@
+module RPiet
+  module ASG
+    ##
+    # Base class of all nodes
+    class Node
+      attr_accessor :next_node
+      attr_reader :step, :x, :y
+
+      def initialize(step, x, y, *)
+        @step, @x, @y = step, x, y
+      end
+
+      def eql?(o)
+        x == o.x && y == o.y && operation == o.operation
+      end
+
+      def hash
+        [x, y, operation].hash
+      end
+
+      def visit(visitor) = visitor.visit self
+
+      # Does this node represent a branching operation?
+      def branch? = false
+
+      ##
+      # Is this node hidden from the perspective of calling next_step?
+      # In simpler interpreter noop, cc, and dp will change during next_step
+      # while in graph and ir interpreters they are explicit actions.
+      def hidden? = false
+
+      # What possible paths can this node navigate to next
+      def paths = [@next_node]
+
+      def add_path(node, *)
+        @next_node = node
+      end
+
+      def operation = self.class.operation_name.to_sym
+
+      def self.operation_name = name.sub(/.*::/, '').sub('Node', '').downcase
+
+      def exec(machine)
+        value = execute(machine)
+        return value if branch?
+        next_node
+      end
+
+      def inspect
+        "p##{@step} [#{@x}, #{@y}](#{operation})"
+      end
+      alias :to_s :inspect
+
+      def self.create(step, x, y, operation, *extra_args)
+        Nodes[operation].new step, x, y, *extra_args
+      end
+
+      # Overhead of event handler is extreme so only reference it if there is one.
+      def self.handle_event_handler(event_handler)
+        prepend NodeEventHandler if event_handler
+      end
+    end
+
+    module NodeEventHandler
+      def exec(machine)
+        machine.event_handler.operation(machine, @step, operation)
+        super
+      end
+    end
+
+    ##
+    # Perform common mathematical binary operation
+    class MathNode < Node
+      def initialize(step, x, y, operation, *)
+        super(step, x, y)
+        @operation = operation
+      end
+
+      def execute(machine)
+        stack = machine.stack
+        return nil unless stack.length >= 2
+        a, b = stack.pop(2)
+        stack << a.send(@operation, b)
+      end
+    end
+
+    ##
+    # Add two values from stack
+    class AddNode < MathNode
+      def initialize(step, x, y, *) = super(step, x, y, :+)
+    end
+
+    ##
+    # When dp changes due to natural navigation we update it
+    # to the new value
+    class CcNode < Node
+      attr_reader :value
+
+      def initialize(step, x, y, cc_ordinal, *)
+        super(step, x, y)
+        @value = cc_ordinal
+      end
+
+      def hidden? = true
+
+      def execute(machine) = machine.cc.from_ordinal!(@value)
+    end
+
+    ##
+    # Read in character from the console and push on the stack
+    class CinNode < Node
+      def execute(machine)
+        machine.output.write "> "
+        machine.stack << machine.input.read(1).ord
+      end
+    end
+
+    ##
+    # Display top element of the stack to the console as a character.
+    class CoutNode < Node
+      def execute(machine) = print machine.stack.pop.chr
+    end
+
+    ##
+    # Add two values from stack
+    class DivNode < MathNode
+      def initialize(step, x, y, *)= super(step, x, y, :/)
+
+      # Note: Following npiet's div by zero value.
+      def execute(machine)
+        stack = machine.stack
+        return nil unless stack.length >= 2
+        a, b = stack.pop(2)
+        stack << (b == 0 ? DIV_BY_ZERO_VALUE : a / b)
+      end
+    end
+
+    ##
+    # When dp changes due to natural navigation we update it
+    # to the new value
+    class DpNode < Node
+      attr_reader :value
+
+      def initialize(step, x, y, _, dp_ordinal)
+        super(step, x, y)
+        @value = dp_ordinal
+      end
+
+      def hidden? = true
+
+      def execute(machine) = machine.dp.from_ordinal!(@value)
+    end
+
+    ##
+    # Duplicate top element of the stack.
+    class DupNode < Node
+      def execute(machine)
+        stack = machine.stack
+        stack << stack[-1] if stack[-1]
+      end
+    end
+
+    class ExitNode < Node
+      def execute(machine)
+      end
+    end
+
+  ##
+    # Greater than operation on top two stack values
+    class GtrNode < Node
+      def execute(machine)
+        stack = machine.stack
+        return nil unless stack.length >= 2
+        a, b = stack.pop(2)
+        stack << (a > b ? 1 : 0)
+      end
+    end
+
+    ##
+    # Modulos two values from stack
+    class ModNode < MathNode
+      def initialize(step, x, y, *) = super(step, x, y, :%)
+    end
+
+    ##
+    # Multiply two values from stack
+    class MultNode < MathNode
+      def initialize(step, x, y, *)= super(step, x, y, :*)
+    end
+
+    ##
+    # Read in number from the console and push on the stack
+    class NinNode < Node
+      def execute(machine)
+        machine.output.puts "Enter an integer: "
+        machine.stack << machine.input.gets.to_i
+      end
+    end
+
+    ##
+    # Entry point into the program.  Not strictly necessary
+    # but we will kill this during analysis
+    class NoopNode < Node
+      def hidden? = true
+
+      def execute(_); end  # No-op
+    end
+
+    ##
+    # Greater than operation on top two stack values
+    class NotNode < Node
+      def execute(machine)
+        stack = machine.stack
+        top = stack.pop
+        stack << (!top || top == 0 ? 1 : 0)
+      end
+    end
+
+    ##
+    # Diplay top element of the stack to the console.
+    class NoutNode < Node
+      def execute(machine) = print machine.stack.pop
+    end
+
+    ##
+    # Rotate the direction based on top stack value and
+    # change execution flow.
+    class PntrNode < Node
+      def branch? = true
+
+      def add_path(node, _, dp_value)
+        @values ||= []
+        @values[dp_value] = node
+      end
+
+      # What possible paths can this node navigate to next
+      def paths = @values
+
+      def execute(machine)
+        top = machine.stack.pop
+        @values[machine.dp.rotate!(top).ordinal]
+      end
+    end
+
+    ##
+    # Pop a value from the stack
+    class PopNode < Node
+      def execute(machine) = machine.stack.pop
+    end
+
+    ##
+    # Push a value onto the stack
+    class PushNode < Node
+      attr_reader :value
+
+      def initialize(step, x, y, value)
+        super(step, x, y)
+        @value = value
+      end
+
+      def execute(machine) = machine.stack << @value
+    end
+
+    ##
+    # Roll the stack
+    class RollNode < Node
+      def execute(machine)
+        stack = machine.stack
+        depth, num = stack.pop(2)
+        num %= depth
+        return if depth <= 0 || num == 0
+        if num > 0
+          stack[-depth..-1] = stack[-num..-1] + stack[-depth...-num]
+        elsif num < 0
+          stack[-depth..-1] = stack[-depth...-num] + stack[-num..-1]
+        end
+      end
+    end
+
+    ##
+    # Subtract two values from stack
+    class SubNode < MathNode
+      def initialize(step, x, y, *)= super(step, x, y, :-)
+    end
+
+    ##
+    # Rotate the codel chooser based on top stack value and
+    # change execution flow.
+    class SwchNode < Node
+      def branch? = true
+
+      def add_path(node, cc, _)
+        if cc == RPiet::CodelChooser::LEFT
+          @left = node
+        else
+          @right = node
+        end
+      end
+
+      # What possible paths can this node navigate to next
+      def paths = [@left, @right]
+
+      def execute(machine)
+        top = machine.stack.pop
+        if machine.cc.switch!(top) == RPiet::CodelChooser::LEFT
+          @left
+        else
+          @right
+        end
+      end
+    end
+
+    Nodes = {
+      noop: NoopNode,
+      push: PushNode,
+      pop: PopNode,
+      add: AddNode,
+      sub: SubNode,
+      mult: MultNode,
+      div: DivNode,
+      mod: ModNode,
+      not: NotNode,
+      gtr: GtrNode,
+      pntr: PntrNode,
+      swch: SwchNode,
+      dup: DupNode,
+      roll: RollNode,
+      nin: NinNode,
+      cin: CinNode,
+      nout: NoutNode,
+      cout: CoutNode,
+      dp: DpNode,
+      cc: CcNode
+    }
+  end
+end

data/lib/rpiet/codel_chooser.rb

@@ -1,11 +1,15 @@
-require 'rpiet/direction_pointer'
+require_relative 'direction_pointer'
 
 module RPiet
   class CodelChooser
     LEFT, RIGHT = -1, 1
-    attr_reader :direction
+    attr_accessor :direction
+
     def initialize; @direction = LEFT; end
-    def switch!(amount = 1); @direction *= -1.**(amount % 2); end
+    def switch!(amount = 1)
+      @direction *= -1.**(amount % 2)
+      self
+    end
 
     def ascii(dp)
       case dp.direction
@@ -20,8 +24,32 @@ module RPiet
       end
     end
 
+    def degrees(dp)
+      case dp.direction
+      when RPiet::Direction::RIGHT
+        @direction == LEFT ? 270 : 90
+      when RPiet::Direction::UP
+        @direction == LEFT ? 180 : 0
+      when RPiet::Direction::LEFT
+        @direction == LEFT ? 90 : 270
+      when RPiet::Direction::DOWN
+        @direction == LEFT ? 0 : 180
+      end
+    end
+
+    def as_constant
+      @direction == LEFT ? "LEFT" : "RIGHT"
+    end
+
+    alias :ordinal :direction
+
+    def from_ordinal!(ordinal)
+      @direction = ordinal == LEFT ? LEFT : RIGHT
+    end
+
     def inspect
-      (@direction == LEFT ? "left(0)" : "right(1)")
+      @direction.to_s
+      #(@direction == LEFT ? "<-" : "->")
     end
     alias :to_s :inspect
   end

data/lib/rpiet/color.rb

@@ -1,4 +1,4 @@
-require 'rpiet/cycle'
+require_relative 'cycle'
 
 module RPiet
   class Color
@@ -7,48 +7,93 @@ module RPiet
     cycle :LIGHTNESS, :LIGHT, :NORMAL, :DARK
     cycle :HUE, :RED, :YELLOW, :GREEN, :CYAN, :BLUE, :MAGENTA
 
-    attr_reader :hue, :lightness
+    attr_reader :hue, :lightness, :rgb
 
-    def initialize(lightness, hue)
-      @lightness, @hue = lightness, hue
+    def initialize(lightness, hue, rgb)
+      @lightness, @hue, @rgb = lightness, hue, rgb
     end
 
+    def color_from(lightness_delta: 0, hue_delta: 0)
+      LIGHTNESS_HUE[lightness.incr(lightness_delta)][hue.incr(hue_delta)]
+    end
+    
+    # Display color as initial of lightness followed by hue (normal blue == nb).
     def to_initial
       @lightness.to_initial + @hue.to_initial
     end
 
     def to_s
-      (@lightness == LIGHTNESS::NORMAL ? "" : @lightness.to_s + ' ') + @hue.to_s
+      [@lightness == LIGHTNESS::NORMAL ? nil : @lightness.to_s,
+       @hue.to_s].compact.join('_')
     end
     alias :inspect :to_s
 
-    RGB_WHITE, WHITE = '0xffffff', Color.new('white', '')
-    RGB_BLACK, BLACK = '0x000000', Color.new('black', '')
+    def self.color_for(rgb_hex)
+      RGB[rgb_hex]
+    end
+
+    RGB_WHITE, WHITE = '0xffffff', Color.new(LIGHTNESS::NORMAL, 'white', '0xffffff')
+    RGB_BLACK, BLACK = '0x000000', Color.new(LIGHTNESS::NORMAL, 'black', '0x000000')
 
     class << WHITE; def to_initial; '..'; end; end
     class << BLACK; def to_initial; '++'; end; end
 
+    LIGHT_RED = Color.new(LIGHTNESS::LIGHT, HUE::RED, '0xffc0c0')
+    LIGHT_YELLOW = Color.new(LIGHTNESS::LIGHT, HUE::YELLOW, '0xffffc0')
+    LIGHT_GREEN = Color.new(LIGHTNESS::LIGHT, HUE::GREEN, '0xc0ffc0')
+    LIGHT_CYAN = Color.new(LIGHTNESS::LIGHT, HUE::CYAN, '0xc0ffff')
+    LIGHT_BLUE = Color.new(LIGHTNESS::LIGHT, HUE::BLUE, '0xc0c0ff')
+    LIGHT_MAGENTA = Color.new(LIGHTNESS::LIGHT, HUE::MAGENTA, '0xffc0ff')
+    RED = Color.new(LIGHTNESS::NORMAL, HUE::RED, '0xff0000')
+    YELLOW = Color.new(LIGHTNESS::NORMAL, HUE::YELLOW, '0xffff00')
+    GREEN = Color.new(LIGHTNESS::NORMAL, HUE::GREEN, '0x00ff00')
+    CYAN = Color.new(LIGHTNESS::NORMAL, HUE::CYAN, '0x00ffff')
+    BLUE = Color.new(LIGHTNESS::NORMAL, HUE::BLUE, '0x0000ff')
+    MAGENTA = Color.new(LIGHTNESS::NORMAL, HUE::MAGENTA, '0xff00ff')
+    DARK_RED = Color.new(LIGHTNESS::DARK, HUE::RED, '0xc00000')
+    DARK_YELLOW = Color.new(LIGHTNESS::DARK, HUE::YELLOW, '0xc0c000')
+    DARK_GREEN = Color.new(LIGHTNESS::DARK, HUE::GREEN, '0x00c000')
+    DARK_CYAN = Color.new(LIGHTNESS::DARK, HUE::CYAN, '0x00c0c0')
+    DARK_BLUE = Color.new(LIGHTNESS::DARK, HUE::BLUE, '0x0000c0')
+    DARK_MAGENTA = Color.new(LIGHTNESS::DARK, HUE::MAGENTA, '0xc000c0')
+
     RGB = {
-      '0xffc0c0' => Color.new(LIGHTNESS::LIGHT, HUE::RED),
-      '0xffffc0' => Color.new(LIGHTNESS::LIGHT, HUE::YELLOW),
-      '0xc0ffc0' => Color.new(LIGHTNESS::LIGHT, HUE::GREEN),
-      '0xc0ffff' => Color.new(LIGHTNESS::LIGHT, HUE::CYAN),
-      '0xc0c0ff' => Color.new(LIGHTNESS::LIGHT, HUE::BLUE),
-      '0xffc0ff' => Color.new(LIGHTNESS::LIGHT, HUE::MAGENTA),
-      '0xff0000' => Color.new(LIGHTNESS::NORMAL, HUE::RED),
-      '0xffff00' => Color.new(LIGHTNESS::NORMAL, HUE::YELLOW),
-      '0x00ff00' => Color.new(LIGHTNESS::NORMAL, HUE::GREEN),
-      '0x00ffff' => Color.new(LIGHTNESS::NORMAL, HUE::CYAN),
-      '0x0000ff' => Color.new(LIGHTNESS::NORMAL, HUE::BLUE),
-      '0xff00ff' => Color.new(LIGHTNESS::NORMAL, HUE::MAGENTA),
-      '0xc00000' => Color.new(LIGHTNESS::DARK, HUE::RED),
-      '0xc0c000' => Color.new(LIGHTNESS::DARK, HUE::YELLOW),
-      '0x00c000' => Color.new(LIGHTNESS::DARK, HUE::GREEN),
-      '0x00c0c0' => Color.new(LIGHTNESS::DARK, HUE::CYAN),
-      '0x0000c0' => Color.new(LIGHTNESS::DARK, HUE::BLUE),
-      '0xc000c0' => Color.new(LIGHTNESS::DARK, HUE::MAGENTA),
+      '0xffc0c0' => LIGHT_RED, '0xffffc0' => LIGHT_YELLOW, '0xc0ffc0' => LIGHT_GREEN,
+      '0xc0ffff' => LIGHT_CYAN, '0xc0c0ff' => LIGHT_BLUE, '0xffc0ff' => LIGHT_MAGENTA,
+      '0xff0000' => RED, '0xffff00' => YELLOW, '0x00ff00' => GREEN,
+      '0x00ffff' => CYAN, '0x0000ff' => BLUE, '0xff00ff' => MAGENTA,
+      '0xc00000' => DARK_RED, '0xc0c000' => DARK_YELLOW, '0x00c000' => DARK_GREEN,
+      '0x00c0c0' => DARK_CYAN, '0x0000c0' => DARK_BLUE, '0xc000c0' => DARK_MAGENTA,
       RGB_WHITE => WHITE,
       RGB_BLACK => BLACK
     }
+
+    LIGHTNESS_HUE = {
+      LIGHTNESS::LIGHT => {
+        HUE::RED => LIGHT_RED,
+        HUE::YELLOW => LIGHT_YELLOW,
+        HUE::GREEN => LIGHT_GREEN,
+        HUE::CYAN => LIGHT_CYAN,
+        HUE::BLUE => LIGHT_BLUE,
+        HUE::MAGENTA => LIGHT_MAGENTA
+      },
+      LIGHTNESS::NORMAL => {
+        HUE::RED => RED,
+        HUE::YELLOW => YELLOW,
+        HUE::GREEN => GREEN,
+        HUE::CYAN => CYAN,
+        HUE::BLUE => BLUE,
+        HUE::MAGENTA => MAGENTA
+      },
+      LIGHTNESS::DARK => {
+        HUE::RED => DARK_RED,
+        HUE::YELLOW => DARK_YELLOW,
+        HUE::GREEN => DARK_GREEN,
+        HUE::CYAN => DARK_CYAN,
+        HUE::BLUE => DARK_BLUE,
+        HUE::MAGENTA => DARK_MAGENTA
+      }
+
+    }
   end
 end

data/lib/rpiet/cycle.rb

@@ -1,29 +1,34 @@
 module RPiet
   class Cycle
-    attr_reader :name, :value
+    attr_reader :type, :value
+    attr_accessor :length
 
     def initialize(value, name, list)
       @value, @name, @list = value, name.to_s.downcase, list
     end
 
     def delta(other)
-      (@value - other.value) % @list.length      
+      (@value - other.value) % @length
     end
 
     def -(other)
-      @list[(@value - other.value) % @list.length]
+      @list[(@value - other.value) % @length]
     end
 
     def +(other)
-      @list[(@value + other.value) % @list.length]
+      @list[(@value + other.value) % @length]
     end
 
     def incr(amount = 1)
-      @list[(@value + amount) % @list.length]
+      @list[(@value + amount) % @length]
     end
 
     def decr(amount = 1)
-      @list[(@value - amount) % @list.length]
+      @list[(@value - amount) % @length]
+    end
+
+    def abs(amount)
+      @list[amount % @length]
     end
 
     def to_initial
@@ -31,9 +36,12 @@ module RPiet
     end
 
     def to_s
+      "#{@name}"
+    end
+    
+    def inspect
       "#{@name}(#{@value})"
     end
-    alias :inspect :to_s
   end
 
   module CycleMethod
@@ -53,6 +61,9 @@ module RPiet
         list[i] = Cycle.new(i, name, list)
         holder_module.const_set name, list[i]
       end
+
+      # Micro-opt...@list.length is slower than @length
+      list.each { |element| element.length = list.length}
     end
     module_function :cycle
   end