rpiet 0.1 → 0.2

data/spec/group_spec.rb

@@ -1,57 +1,82 @@
-require 'rpiet/group'
-require 'rpiet/machine'
+require_relative 'spec_helper'
+require_relative '../lib/rpiet/group'
+require_relative '../lib/rpiet/color'
 
 describe "Group" do
-  before do
-    @group = RPiet::Group.new('0x0000c0', [0, 3])
-    [[0, 4], [0, 5], [0, 6], [0, 7], [1, 3], [1, 4], [1, 5], 
-     [1, 6], [2, 3], [2, 4], [2, 5], [2, 6], [3, 3], [3, 4], [3, 5], [3, 6], 
-     [4, 3], [4, 4], [4, 5], [4, 6], [5, 4], [6, 4], [6, 5], [6, 6], [7, 4], 
-     [7, 5], [7, 6], [8, 5], [8, 6]].each do |point|
-      @group << point
-    end
-    @group.finish
-
-    @group2 = RPiet::Group.new('0xff0000', [7, 0])
-    
-    [[7, 1], [6, 1], [6, 2], [5, 2], [6, 3], [7, 2], 
-     [7, 3], [8, 0], [8, 1]].each do |point|
-      @group2 << point
-    end
-    @group2.finish
-
-    @pvm = RPiet::Machine.new
+  SQUARE = <<-EOS
+.###.
+.###.
+.###.
+  EOS
+
+  WACKY = <<-EOS
+.#.#.
+#####
+.#.#.
+  EOS
+
+  HOOKY = <<-EOS
+.#.#.#
+######
+.#.#..
+  EOS
+
+
+  let(:light_cyan) { RPiet::Color.color_for('0x0000c0') }
+  let(:black) { RPiet::Color.color_for('0x000000') }
+  let(:blue) { RPiet::Color.color_for('0x0000ff') }
+  let(:square_group) { create_group(light_cyan, SQUARE) }
+  let(:wacky_group) { create_group(black, WACKY) }
+  let(:hooky_group) { create_group(blue, HOOKY) }
+
+  it "knows its color" do
+    expect(square_group.color).to eq light_cyan
+    expect(wacky_group.color).to eq black
+    expect(hooky_group.color).to eq blue
   end
 
   it "knows its size" do
-    @group.size.should == 30
+    expect(square_group.size).to eq(9)
+    expect(wacky_group.size).to eq(9)
+    expect(hooky_group.size).to eq(11)
+  end
+
+  it 'picks the right points (wacky)' do
+    expect(wacky_group.rr).to eq([4,1])
+    expect(wacky_group.rl).to eq([4,1])
+    expect(wacky_group.lr).to eq([0,1])
+    expect(wacky_group.ll).to eq([0,1])
+    expect(wacky_group.dr).to eq([1,2])
+    expect(wacky_group.dl).to eq([3,2])
+    expect(wacky_group.ur).to eq([3,0])
+    expect(wacky_group.ul).to eq([1,0])
+  end
+
+  it 'picks the right points (simple)' do
+    expect(square_group.rr).to eq([3,2])
+    expect(square_group.rl).to eq([3,0])
+    expect(square_group.lr).to eq([1,0])
+    expect(square_group.ll).to eq([1,2])
+    expect(square_group.dr).to eq([1,2])
+    expect(square_group.dl).to eq([3,2])
+    expect(square_group.ur).to eq([3,0])
+    expect(square_group.ul).to eq([1,0])
+  end
+
+  it 'picks the right points (hooky)' do
+    expect(hooky_group.rr).to eq([5,1])
+    expect(hooky_group.rl).to eq([5,0])
+    expect(hooky_group.lr).to eq([0,1])
+    expect(hooky_group.ll).to eq([0,1])
+    expect(hooky_group.dr).to eq([1,2])
+    expect(hooky_group.dl).to eq([3,2])
+    expect(hooky_group.ur).to eq([5,0])
+    expect(hooky_group.ul).to eq([1,0])
   end
 
-  it "can pick the right points" do
-    @group.point_for(@pvm).should == [8, 5] # dp: RIGHT cc: LEFT  -> UR
-    @pvm.cc.switch! # LEFT -> RIGHT
-    @group.point_for(@pvm).should == [8, 6] # dp: RIGHT cc: RIGHT  -> LR
-    @pvm.dp.rotate! # dp: RIGHT -> DOWN
-    @pvm.cc.switch! # cc: RIGHT -> LEFT
-    @group.point_for(@pvm).should == [0, 7] # dp: DOWN cc: LEFT -> LR
-    @pvm.cc.switch! # cc: LEFT -> RIGHT
-    @group.point_for(@pvm).should == [0, 7] # dp: DOWN cc: RIGHT -> LL
-    @pvm.dp.rotate! # dp: DOWN -> LEFT
-    @pvm.cc.switch! # cc: RIGHT -> LEFT
-    @group.point_for(@pvm).should == [0, 7] # dp: LEFT cc: LEFT -> LL
-    @pvm.cc.switch! # cc: LEFT -> RIGHT
-    @group.point_for(@pvm).should == [0, 3] # dp: LEFT cc: RIGHT -> UL
-    @pvm.dp.rotate! # dp: LEFT -> UP
-    @pvm.cc.switch! 
-    @group.point_for(@pvm).should == [0, 3] # dp: UP cc: LEFT -> UL
-    @pvm.cc.switch! # cc: LEFT -> RIGHT
-    @group.point_for(@pvm).should == [4, 3] # dp: UP cc: RIGHT -> UR
-
-    # Since last group only has single wide bottom let's try another
-    @pvm.cc.switch! # cc: RIGHT -> LEFT
-    @pvm.dp.rotate! 2 # dp: UP -> DOWN
-    @group2.point_for(@pvm).should == [7, 3] # dp: DOWN cc: LEFT -> LR
-    @pvm.cc.switch! # cc: RIGHT -> LEFT
-    @group2.point_for(@pvm).should == [6, 3] # dp: DOWN cc: RIGHT -> LL
+  it 'has edges' do
+    expect(square_group.edges.to_a).to match_array([[1,0,:left], [1,0,:up], [2,0,:up], [3,0,:up], [3,0,:right],
+                                                    [1,1,:left], [3,1,:right],
+                                                    [1,2,:left], [1,2,:down], [2,2,:down], [3,2,:down],[3,2,:right]])
   end
 end

data/spec/interpreter_spec.rb

@@ -1,14 +1,163 @@
-require 'rpiet/interpreter'
-require 'rpiet/image/ascii_image'
-
-describe "RPiet::Interpreter" do
-  it "Can push" do
-    source = RPiet::Image::AsciiImage.new "nb db ++\nnb ++ ++\n++ ++ ++\n"
-    interpreter = RPiet::Interpreter.new(source)
-
-    interpreter.next_step
-    interpreter.pvm.stack.should == [2]
-    interpreter.next_step
-    interpreter.pvm.stack.should == []
+require_relative 'spec_helper'
+require_relative '../lib/rpiet/asg/graph_interpreter'
+require_relative '../lib/rpiet/interpreter'
+
+describe "RPiet Runtimes" do
+
+  let(:push_pop) do # [push 2, pop]*
+    create_image <<-EOS
+nb db ++
+nb ++ ++
+++ ++ ++
+    EOS
+  end
+
+  let(:push_add) do # [push 2, push 1, add, ...]
+    create_image <<-EOS
+nb db lb lm ++
+nb ++ ++ lm ++
+++ ++ ++ ++ ++
+    EOS
+  end
+
+  let(:push_subtract) do # [push 2, push 1, subtract, ...]
+    create_image <<-EOS
+nb db lb nm ++
+nb ++ ++ nm ++
+++ ++ ++ ++ ++
+    EOS
+  end
+
+  let(:push_multiply) do # [push 2, push 2, multiply, ...]
+    create_image <<-EOS
+nb db lb dm ++
+nb db ++ dm ++
+++ ++ ++ ++ ++
+    EOS
+  end
+
+  let(:push_divide) do # [push 2, push 2, divide, ...]
+    create_image <<-EOS
+nb db lb lr ++
+nb db ++ lr ++
+++ ++ ++ ++ ++
+    EOS
+  end
+
+  let(:divide_by_zero) do # [push 2, push 1, push 1, subtract, divide]
+    create_image <<-EOS
+nb db lb nb dm dy ++
+nb ++ ++ ++ ++ dy ++
+++ ++ ++ ++ ++ ++ ++
+    EOS
+  end
+
+  let(:push_mod) do # [push 2, push 2, mod, ...]
+    create_image <<-EOS
+nb db lb nr ++
+nb db ++ nr ++
+++ ++ ++ ++ ++
+    EOS
+  end
+
+  let(:push_not) do # [push 2, push 2, mod, not, ...]
+    create_image <<-EOS
+nb db lb nr lg ++
+nb db ++ nr lg ++
+++ ++ ++ ++ ++ ++
+    EOS
+  end
+
+  let(:skip_white) do
+    create_image <<-EOS
+nb .. .. db ++
+nb .. .. ++ ++
+++ .. .. ++ ++
+    EOS
+  end
+
+  [RPiet::Interpreter, RPiet::ASG::GraphInterpreter].each do |runtime|
+    describe runtime do
+      it "Can push and pop" do
+        interpreter = runtime.new push_pop
+        interpreter.reset
+        interpreter.next_step
+        expect(interpreter.stack).to eq [2]
+        interpreter.next_step
+        expect(interpreter.stack).to eq []
+      end
+
+      it "Can push and add" do
+        interpreter = runtime.new push_add
+        interpreter.reset
+        2.times { interpreter.next_step }
+        expect(interpreter.stack).to eq [2, 1]
+        interpreter.next_step
+        expect(interpreter.stack).to eq [3]
+      end
+
+      it "Can push and subtract" do
+        interpreter = runtime.new push_subtract
+        interpreter.reset
+        2.times { interpreter.next_step }
+        expect(interpreter.stack).to eq [2, 1]
+        interpreter.next_step
+        expect(interpreter.stack).to eq [1]
+      end
+
+      it "Can push and multiply" do
+        interpreter = runtime.new push_multiply
+        interpreter.reset
+        2.times { interpreter.next_step }
+        expect(interpreter.stack).to eq [2, 2]
+        interpreter.next_step
+        expect(interpreter.stack).to eq [4]
+      end
+
+      it "Can push and divide" do
+        interpreter = runtime.new push_divide
+        interpreter.reset
+        2.times { interpreter.next_step }
+        expect(interpreter.stack).to eq [2, 2]
+        interpreter.next_step
+        expect(interpreter.stack).to eq [1]
+      end
+
+      it "Can divide by zero" do
+        interpreter = runtime.new divide_by_zero
+        interpreter.reset
+        4.times { interpreter.next_step }
+        expect(interpreter.stack).to eq [2, 0]
+        interpreter.next_step
+        expect(interpreter.stack).to eq [99999999]
+      end
+
+      it "Can push and mod" do
+        interpreter = runtime.new push_mod
+        interpreter.reset
+        2.times { interpreter.next_step }
+        expect(interpreter.stack).to eq [2, 2]
+        interpreter.next_step
+        expect(interpreter.stack).to eq [0]
+      end
+
+      it "Can push and not" do
+        interpreter = runtime.new push_not
+        interpreter.reset
+        2.times { interpreter.next_step }
+        expect(interpreter.stack).to eq [2, 2]
+        2.times { interpreter.next_step }
+        expect(interpreter.stack).to eq [1]
+      end
+
+      it "Can skip white and push and pop" do
+        interpreter = runtime.new push_pop
+        interpreter.reset
+        interpreter.next_step
+        expect(interpreter.stack).to eq [2]
+        interpreter.next_step
+        expect(interpreter.stack).to eq []
+      end
+    end
   end
 end

data/spec/ir/assembler_spec.rb

@@ -0,0 +1,122 @@
+require_relative '../spec_helper'
+
+include RPiet::IR::Instructions
+
+describe "RPiet::IR::Assembler" do
+  context "individual instructions" do
+    it "can load copy" do
+      instr = assemble("v1 = copy 1\n").first
+      expect(instr.operation).to eq(:copy)
+      expect(instr.operand).to be_numeric_operand(1)
+      expect(instr.result).to be_variable_operand("v1")
+    end
+
+    it "can load push" do
+      instr = assemble("push 10\n").first
+      expect(instr.operation).to eq(:push)
+      expect(instr.operand).to be_numeric_operand(10)
+    end
+
+    it "can load pop" do
+      instr = assemble("v1 = pop\n").first
+      expect(instr.operation).to eq(:pop)
+      expect(instr.result).to be_variable_operand("v1")
+    end
+
+    it "can load nout" do
+      instr = assemble("nout 12\n").first
+      expect(instr.operation).to eq(:nout)
+      expect(instr.operand).to be_numeric_operand(12)
+    end
+
+    it "can load cout" do
+      instr = assemble("cout 'a'\n").first
+      expect(instr.operation).to eq(:cout)
+      expect(instr.operand).to be_string_operand("a")
+    end
+
+    it "can load nin" do
+      instr = assemble("v1 = nin\n").first
+      expect(instr.operation).to eq(:nin)
+      expect(instr.result).to be_variable_operand("v1")
+    end
+
+    it "can load roll" do
+      instr = assemble("roll 1 10\n").first
+      expect(instr.operation).to eq(:roll)
+      expect(instr.depth).to be_numeric_operand(1)
+      expect(instr.num).to be_numeric_operand(10)
+    end
+
+    it "can load label" do
+      instr = assemble("label foo\n").first
+      expect(instr.operation).to eq(:label)
+      expect(instr.operand).to be_label_operand(:jump_reduction)
+    end
+
+    it "cannot load label with non-label operand" do
+      expect { assemble("label 1\n") }.to raise_error(ArgumentError)
+      expect { assemble("label 'a'\n") }.to raise_error(ArgumentError)
+      expect { assemble("v1 = copy 1\nlabel v1\n") }.to raise_error(ArgumentError)
+    end
+
+    context "can load infix math" do
+      %w[+ - * / % **].zip(%i[add sub mult div mod pow]).each do |oper, type|
+        it "can load #{oper}" do
+          instr = assemble("v1 = copy 2\nv2 = 1 #{oper} v1\n")[1]
+          expect(instr.operation).to eq(type)
+          expect(instr.operand1).to be_numeric_operand(1)
+          expect(instr.operand2).to be_variable_operand("v1")
+          expect(instr.result).to be_variable_operand("v2")
+        end
+
+        it "cannot load non-numeric/variable operands" do
+          expect { assemble("v1 = 10 #{oper} label\n")}.to raise_error(ArgumentError)
+          expect { assemble("v1 = 10 #{oper} 'a'\n")}.to raise_error(ArgumentError)
+        end
+      end
+    end
+
+    it "can process gt(>)" do
+      instr = assemble("v1 = 1 > 2\n").first
+      expect(instr.operation).to eq(:gt)
+      expect(instr.result).to be_variable_operand("v1")
+      expect(instr.operand1).to be_numeric_operand(1)
+      expect(instr.operand2).to be_numeric_operand(2)
+    end
+
+    context "can process branches" do
+      %w[!= ==].zip(%i[bne beq]).each do |oper, type|
+        it "can load #{oper}" do
+          instr = assemble("1 #{oper} 2 label\n").first
+          expect(instr.operation).to eq(type)
+          expect(instr.operand1).to be_numeric_operand(1)
+          expect(instr.operand2).to be_numeric_operand(2)
+          expect(instr.label).to be_label_operand(:label)
+        end
+      end
+    end
+
+    it "can load jump" do
+      instr = assemble("jump label\n").first
+      expect(instr.operation).to eq(:jump)
+      expect(instr.label).to be_label_operand(:label)
+    end
+
+    it "can load multiple instructions" do
+      instrs = assemble("push 10\nv1 = pop\n")
+      expect(instrs.size).to eq(2)
+      expect(instrs[0].operation).to eq(:push)
+      expect(instrs[1].operation).to eq(:pop)
+    end
+
+    it "is in single-static-assignment form (SSA)" do
+      expect { assemble("v1 = pop\nv2 = pop\nv1 = pop\n") }.to raise_error(ArgumentError)
+      expect { assemble("push v1\n") }.to raise_error(ArgumentError)
+    end
+
+    it "cannot use a non-variable as a result" do
+      expect { assemble("10 = pop\n")}.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/ir/builder_spec.rb

@@ -0,0 +1,20 @@
+require_relative '../spec_helper'
+require_relative '../../lib/rpiet/asg/parser'
+require_relative '../../lib/rpiet/ir/builder'
+
+describe "RPiet::Builder" do
+  let(:cycle) do
+    create_image <<-EOS
+nb db nb
+db ++ nb
+db db db
+    EOS
+  end
+
+  it "can visit all nodes once plus one extra visit for a cycle" do
+    graph = RPiet::ASG::Parser.new(cycle).run
+    builder = RPiet::Builder.new
+    builder.run graph
+    #p builder.instructions
+  end
+end

data/spec/ir/cfg_spec.rb

@@ -0,0 +1,151 @@
+require_relative '../spec_helper'
+require_relative '../../lib/rpiet/asg/parser'
+require_relative '../../lib/rpiet/ir/builder'
+require_relative '../../lib/rpiet/ir/cfg'
+
+
+describe "RPiet::IR::CFG" do
+  let(:push_divide) {
+    assemble("push 10\npush 2\nv1 = pop\nv2 = pop\nv3 = v2 / v1; push v3")
+  }
+
+  let(:gtr) {
+    assemble <<~EOS
+      10 != 2 true
+      push 0
+      jump end
+      label true
+      push 1
+      label end
+      exit
+    EOS
+  }
+
+  let(:pntr) {
+    assemble <<~EOS
+      dpset 0
+      push 2
+      v25 = pop
+      v26 = dpget
+      v27 = v26 + v25
+      v28 = v27 % 4
+      dpset v28
+      v28 != 0 pntr[0]43
+      push 0
+      jump re.4008
+      label pntr[0]43
+      v28 != 1 pntr[1]43
+      push 1
+      jump re.4008
+      label pntr[1]43
+      v28 != 2 pntr[2]43
+      push 2
+      jump re.4008
+      label pntr[2]43
+      v28 != 3 re.4008
+      push 3
+      label re.4008
+      v29 = pop
+      exit
+    EOS
+  }
+
+  let(:diamond) {
+    assemble <<~EOS
+      push 10
+      push 5
+      10 != 2 true
+      push 0
+      jump end
+      label true
+      push 1
+      label end
+      v1 = pop
+      v2 = pop
+      v3 = pop
+      v4 = v3 / v2
+      push v4
+      exit
+    EOS
+  }
+
+  let(:graph1) {
+    assemble <<~EOS
+      push 10
+      push 5
+      10 != 2 true
+      label foo
+      push 0
+      jump end
+      label true
+      push 1
+      label end
+      v1 = pop
+      v2 = pop
+      v3 = pop
+      v4 = v3 / v2
+      push v4
+      1 != 2 foo
+      push 1
+      exit
+    EOS
+  }
+
+  context "outgoing_edges" do
+    it "can see all edges in a simple graph" do
+      cfg = RPiet::IR::CFG.new(gtr)
+
+      entry_bb = cfg.entry_bb
+      fall_through = cfg.outgoing_target(entry_bb, :fall_through)
+      expect(fall_through.label).to start_with("fall_thru_")
+
+      jump = cfg.outgoing_target(entry_bb, :jump)
+      expect(jump.label).to eq(:true)
+
+      end_bb = cfg.outgoing_target(jump, :fall_through)
+      expect(end_bb.label).to eq(:end)
+
+      end_bb2 = cfg.outgoing_target(fall_through, :jump)
+      expect(end_bb.label).to eq(:end)
+
+      expect(end_bb).to eq(end_bb2)
+    end
+
+    it "can remove an edge" do
+      cfg = RPiet::IR::CFG.new(gtr)
+
+      entry_bb = cfg.entry_bb
+      jump = cfg.outgoing_target(entry_bb, :jump)
+      expect(cfg.outgoing_targets(entry_bb).size).to eq(2)
+      cfg.remove_edge(entry_bb, jump)
+      expect(cfg.outgoing_targets(entry_bb).size).to eq(1)
+    end
+
+    it "can see see outgoing edges with a block" do
+      cfg = RPiet::IR::CFG.new(gtr)
+
+      entry_bb = cfg.entry_bb
+      results = []
+      cfg.outgoing_edges(entry_bb) do |edge|
+        results << edge.target.label.to_s
+      end
+      results.sort!
+      expect(results[0]).to start_with("fall_thru_")
+      expect(results[1]).to eq("true")
+    end
+
+    it "can generate postorder traversal" do
+      cfg = RPiet::IR::CFG.new(diamond)
+      puts cfg.postorder_bbs.map { |bb| bb.label }.join(", ")
+      puts cfg.preorder_bbs.map { |bb| bb.label }.join(", ")
+    end
+
+    it "can generate postorder traversal" do
+      cfg = RPiet::IR::CFG.new(graph1)
+      cfg.write_to_dot_file
+      puts cfg.postorder_bbs.map { |bb| bb.label }.join(", ")
+      puts cfg.preorder_bbs.map { |bb| bb.label }.join(", ")
+    end
+
+  end
+end

data/spec/ir/ir_interpreter_spec.rb

@@ -0,0 +1,102 @@
+require_relative '../spec_helper'
+
+describe "RPiet::IR::IRInterpreter" do
+  it "can exec push" do
+    interp = ir_interp(assemble("push 10\n"))
+    expect(interp.stack).to eq([])
+    interp.next_step
+    expect(interp.stack).to eq([10])
+  end
+
+  it "can exec pop" do
+    interp = ir_interp(assemble("push 10\nv1 = pop\n"))
+    interp.next_step
+    expect(interp.stack).to eq([10])
+    interp.next_step
+    expect(interp.stack).to eq([])
+  end
+
+  it "can exec add" do
+    interp = ir_interp(assemble("v1 = 10 + 2\npush v1\n"))
+    2.times { interp.next_step }
+    expect(interp.stack).to eq([12])
+  end
+
+  it "can exec add with variable" do
+    interp = ir_interp(assemble("v1 = copy 10\nv2 = v1 + 2\npush v2\n"))
+    3.times { interp.next_step }
+    expect(interp.stack).to eq([12])
+  end
+
+  it "can exec sub" do
+    interp = ir_interp(assemble("v1 = 10 - 2\npush v1\n"))
+    2.times { interp.next_step }
+    expect(interp.stack).to eq([8])
+  end
+
+  it "can exec mult" do
+    interp = ir_interp(assemble("v1 = 10 * 2\npush v1\n"))
+    2.times { interp.next_step }
+    expect(interp.stack).to eq([20])
+  end
+
+  it "can exec div" do
+    interp = ir_interp(assemble("v1 = 10 / 2\npush v1\n"))
+    2.times { interp.next_step }
+    expect(interp.stack).to eq([5])
+  end
+
+  it "can exec mod" do
+    interp = ir_interp(assemble("v1 = 10 % 2\npush v1\n"))
+    2.times { interp.next_step }
+    expect(interp.stack).to eq([0])
+  end
+
+  it "can exec pow" do
+    interp = ir_interp(assemble("v1 = 10 ** 2\npush v1\n"))
+    2.times { interp.next_step }
+    expect(interp.stack).to eq([100])
+  end
+
+  it "can exec jump" do
+    interp = ir_interp(assemble("jump label\npush 1\nlabel label\npush 0\n"))
+    2.times { interp.next_step }
+    expect(interp.stack).to eq([0])
+  end
+
+  it "can exec bne" do
+    interp = ir_interp(assemble("1 != 2 label\npush 1\nlabel label\npush 2\n"))
+    2.times { interp.next_step }
+    expect(interp.stack).to eq([2])
+  end
+
+  it "can exec beq" do
+    interp = ir_interp(assemble("1 == 1 label\npush 1\nlabel label\npush 2\n"))
+    2.times { interp.next_step }
+    expect(interp.stack).to eq([2])
+  end
+
+  it "can exec gt" do
+    interp = ir_interp(assemble("v1 = 2 > 1\npush v1\n"))
+    2.times { interp.next_step }
+    expect(interp.stack).to eq([1])
+  end
+
+  it "can exec roll" do
+    interp = ir_interp(assemble("push 1\npush 2\npush 3\npush 4\npush 3\npush 1\nv1 = pop\nv2 = pop\nroll v2 v1\n"))
+    9.times { interp.next_step }
+    expect(interp.stack).to eq([1, 4, 2, 3]) # <- [1,2,3,4]  roll 3, 1
+
+    interp = ir_interp(assemble("push 1\npush 2\npush 3\npush 4\npush 3\npush 2\nv1 = pop\nv2 = pop\nroll v2 v1\n"))
+    9.times { interp.next_step }
+    expect(interp.stack).to eq([1, 3, 4, 2])  # <- [1,2,3,4] roll 3, 2
+
+    interp = ir_interp(assemble("push 1\npush 2\npush 3\npush 4\npush 4\npush -1\nv1 = pop\nv2 = pop\nroll v2 v1\n"))
+    9.times { interp.next_step; p interp.stack }
+    expect(interp.stack).to eq([2, 3, 4, 1])  # <- [1,2,3,4] roll 4, -1
+
+    interp = ir_interp(assemble("push 1\npush 2\npush 3\npush 4\npush 4\npush -2\nv1 = pop\nv2 = pop\nroll v2 v1\n"))
+    9.times { interp.next_step; p interp.stack }
+    expect(interp.stack).to eq([3, 4, 1, 2])  # <- [1,2,3,4] roll 4, -2
+  end
+end