starting to_risc descent

just fleshing it for now

test/mom/to_risc/helper.rb

@@ -0,0 +1,81 @@
+require_relative '../helper'
+
+module Risc
+  module SpaceHack
+    # test hack to in place change object type
+    def add_space_field(name,type)
+      class_type = Parfait.object_space.get_class_by_name(:Space).instance_type
+      class_type.send(:private_add_instance_variable, name , type)
+    end
+  end
+  module ExpressionHelper
+    include SpaceHack
+
+    def check
+      Risc.machine.boot unless Risc.machine.booted
+      compiler = Vm::MethodCompiler.new Parfait.object_space.get_main
+      code = Vm.ast_to_code @input
+      assert code.to_s , @input
+      produced = compiler.process( code )
+      assert @output , "No output given"
+      assert_equal produced.class , @output , "Wrong class"
+      produced
+    end
+
+  end
+
+  module Statements
+    include AST::Sexp
+    include CleanCompile
+    include SpaceHack
+
+    def setup
+      Risc.machine.boot # force boot to reset main
+    end
+
+    def preamble
+      [Label, SlotToReg , LoadConstant, RegToSlot, LoadConstant,RegToSlot, LoadConstant, SlotToReg, SlotToReg ]
+    end
+    def postamble
+      [ Label, FunctionReturn]
+    end
+    def check_nil
+      assert @expect , "No output given"
+
+      Vool::VoolCompiler.ruby_to_vool "class Space; def main(arg);#{@input};end;end"
+
+      produced = Parfait.object_space.get_main.instructions
+      compare_instructions produced , @expect
+    end
+    def check_return
+      was = check_nil
+      raise was if was
+      Parfait.object_space.get_main.instructions
+    end
+
+    def compare_instructions( instruction , expect )
+      index = 0
+      all = instruction.to_arr
+      full_expect = preamble + expect + postamble
+      full_expect =  expect
+      begin
+        should = full_expect[index]
+        return "No instruction at #{index}" unless should
+        return "Expected at #{index+1}\n#{should(all)}" unless instruction.class == should
+        index += 1
+        instruction = instruction.next
+      end while( instruction )
+      nil
+    end
+    def should( all )
+      #preamble.each {all.shift}
+      #postamble.each {all.pop}
+      str = all.to_s.gsub("Risc::","")
+      ret = ""
+      str.split(",").each_slice(6).each do |line|
+        ret += "                " + line.join(",") + " ,\n"
+      end
+      ret
+    end
+  end
+end

test/mom/to_risc/test_assignment.rb

@@ -0,0 +1,112 @@
+
+require_relative 'helper'
+
+module Risc
+  class TestAssignStatement < MiniTest::Test
+    include Statements
+
+    def test_assign_op
+      Parfait.object_space.get_main.add_local(:r , :Integer)
+
+      @input    = "r = 10.mod4"
+
+      @expect = [Label, LoadConstant, SlotToReg, RegToSlot, Label, FunctionReturn]
+      assert_nil msg = check_nil , msg
+    end
+
+    def pest_assign_ivar_notpresent
+      @input =s(:statements, s(:i_assignment, s(:ivar, :r), s(:int, 5)))
+      @expect =  []
+      assert_raises{ check_nil }
+    end
+
+    def pest_assign_ivar
+      add_space_field(:r , :Integer)
+
+      @input =s(:statements, s(:i_assignment, s(:ivar, :r), s(:int, 5)))
+
+      @expect =  [Label, LoadConstant, SlotToReg, RegToSlot, LoadConstant, SlotToReg ,
+                 RegToSlot, Label, FunctionReturn]
+      assert_nil msg = check_nil , msg
+    end
+
+    def pest_assign_local_assign
+      Parfait.object_space.get_main.add_local(:r , :Integer)
+
+      @input = s(:statements, s(:l_assignment, s(:local, :r), s(:int, 5)))
+
+      @expect = [Label, LoadConstant, SlotToReg, RegToSlot, LoadConstant, SlotToReg ,
+               RegToSlot, Label, FunctionReturn]
+      assert_nil msg = check_nil , msg
+    end
+
+    def pest_assign_call
+      Parfait.object_space.get_main.add_local(:r , :Object)
+      @input = s(:statements, s(:l_assignment, s(:local, :r), s(:call, :main, s(:arguments))))
+      @expect = [Label, SlotToReg, SlotToReg, RegToSlot, LoadConstant, RegToSlot ,
+               LoadConstant, SlotToReg, RegToSlot, LoadConstant, RegToSlot, RiscTransfer ,
+               FunctionCall, Label, RiscTransfer, SlotToReg, SlotToReg, SlotToReg ,
+               RegToSlot, LoadConstant, SlotToReg, RegToSlot, Label, FunctionReturn]
+      assert_nil msg = check_nil , msg
+    end
+
+    def pest_named_list_get
+      Parfait.object_space.get_main.add_local(:r , :Integer)
+      @input = s(:statements, s(:l_assignment, s(:local, :r), s(:int, 5)), s(:return, s(:local, :r)))
+      @expect = [Label, LoadConstant, SlotToReg, RegToSlot, SlotToReg, SlotToReg ,
+                 RegToSlot, LoadConstant, SlotToReg, RegToSlot, Label, FunctionReturn]
+      was = check_return
+      get = was.next(5)
+      assert_equal SlotToReg , get.class
+      assert_equal 1 + 1, get.index , "Get to named_list index must be offset, not #{get.index}"
+    end
+
+    def pest_assign_local_int
+      Parfait.object_space.get_main.add_local(:r , :Integer)
+      @input = s(:statements, s(:l_assignment, s(:local, :r), s(:int, 5)) )
+      @expect =  [Label, LoadConstant, SlotToReg, RegToSlot, LoadConstant, SlotToReg ,
+                 RegToSlot, Label, FunctionReturn]
+      was = check_return
+      set = was.next(3)
+      assert_equal RegToSlot , set.class
+      assert_equal 1 + 1, set.index , "Set to named_list index must be offset, not #{set.index}"
+    end
+
+    def pest_misassign_local
+      Parfait.object_space.get_main.add_local(:r , :Integer)
+      @input = s(:statements, s(:l_assignment, s(:local, :r), s(:string, "5")) )
+      @expect =  [Label, LoadConstant, SlotToReg, RegToSlot, Label, FunctionReturn]
+      assert_raises {check }
+    end
+
+    def pest_assign_arg
+      Parfait.object_space.get_main.add_argument(:blar , :Integer)
+      @input = s(:statements, s(:a_assignment, s(:arg, :blar), s(:int, 5)))
+      @expect = [Label, LoadConstant, SlotToReg, RegToSlot, LoadConstant, SlotToReg ,
+                 RegToSlot, Label, FunctionReturn]
+      was = check_return
+      set = was.next(3)
+      assert_equal RegToSlot , set.class
+      assert_equal 1 + 1, set.index , "Set to args index must be offset, not #{set.index}"
+    end
+
+    def pest_misassign_arg
+      Parfait.object_space.get_main.add_argument(:blar , :Integer)
+      @input = s(:statements, s(:a_assignment, s(:arg, :blar), s(:string, "5")))
+      @expect =  [Label, LoadConstant, SlotToReg, RegToSlot, Label, FunctionReturn]
+      assert_raises {check }
+    end
+
+    def pest_arg_get
+      # have to define bar externally, just because redefining main. Otherwise that would be automatic
+      Parfait.object_space.get_main.add_argument(:balr , :Integer)
+      @input = s(:statements, s(:return, s(:arg, :balr)))
+      @expect = [Label, SlotToReg, SlotToReg, RegToSlot, LoadConstant, SlotToReg ,
+                 RegToSlot, Label, FunctionReturn]
+      was = check_return
+      get = was.next(2)
+      assert_equal SlotToReg , get.class
+      assert_equal 1 + 1, get.index , "Get to args index must be offset, not #{get.index}"
+    end
+  end
+end