implement greater than

lib/risc/boot.rb

@@ -184,7 +184,7 @@ module Risc
       Risc.operators.each do |op|
         obj.instance_type.add_method Builtin::Integer.operator_method(op)
       end
-      [:putint, :div4, :div10 , :<].each do |f|   #div4 is just a forward declaration
+      [:putint, :div4, :div10 , :<, :>].each do |f|   #div4 is just a forward declaration
         obj.instance_type.add_method Builtin::Integer.send(f , nil)
       end
     end

lib/risc/builtin/integer.rb

@@ -19,22 +19,28 @@ module Risc
           compiler.add_mom( Mom::ReturnSequence.new)
           return compiler.method
         end
+        def >( context )
+          comparison( :> , Risc::IsMinus)
+        end
         def <( context )
-          compiler = compiler_for(:Integer, :< ,{other: :Integer})
+          comparison( :< , Risc::IsPlus)
+        end
+        def comparison( operator , branch )
+          compiler = compiler_for(:Integer, operator ,{other: :Integer})
           builder = compiler.builder(true, compiler.method)
-          me , other = builder.self_and_int_arg("< load receiver and arg")
+          me , other = builder.self_and_int_arg("#{operator} load receiver and arg")
           false_label = Risc.label(compiler.method , "false_label_#{builder.object_id}")
           merge_label = Risc.label(compiler.method , "merge_label_#{builder.object_id}")
-          builder.reduce_int( "< fix me", me )
+          builder.reduce_int( "#{operator} fix me", me )
-          builder.reduce_int( "< fix arg", other )
+          builder.reduce_int( "#{operator} fix arg", other )
-          builder.add_code Risc.op( "< operator", :- , me , other)
+          builder.add_code Risc.op( "#{operator} operator", :- , me , other)
-          builder.add_code Risc::IsPlus.new( "< if", false_label)
+          builder.add_code branch.new( "#{operator} if", false_label)
-          builder.add_load_constant("< new int", Parfait.object_space.true_object , other)
+          builder.add_load_constant("#{operator} new int", Parfait.object_space.true_object , other)
           builder.add_code Risc::Branch.new("jump over false", merge_label)
           builder.add_code false_label
-          builder.add_load_constant("< new int", Parfait.object_space.false_object , other)
+          builder.add_load_constant("#{operator} new int", Parfait.object_space.false_object , other)
           builder.add_code merge_label
-          builder.add_reg_to_slot( "< save ret" , other , :message , :return_value)
+          builder.add_reg_to_slot( "#{operator} save ret" , other , :message , :return_value)
           compiler.add_mom( Mom::ReturnSequence.new)
           return compiler.method
         end

test/parfait/test_space.rb

@@ -34,7 +34,7 @@ class TestSpace < MiniTest::Test
 
   def test_integer
     int = Parfait.object_space.get_class_by_name :Integer
-    assert_equal 10, int.instance_type.method_names.get_length
+    assert_equal 12, int.instance_type.method_names.get_length
   end
 
   def test_classes_class

test/risc/builtin/test_simple_int.rb

@@ -29,10 +29,22 @@ module Risc
         run_all "4 * 4"
         assert_equal 16 , get_return.value
       end
-      def test_smaller
+      def test_smaller_true
         run_all "4 < 5"
         assert_equal Parfait::TrueClass , get_return.class
       end
+      def test_smaller_false
+        run_all "6 < 5"
+        assert_equal Parfait::FalseClass , get_return.class
+      end
+      def test_larger_true
+        run_all "5 > 4"
+        assert_equal Parfait::TrueClass , get_return.class
+      end
+      def test_larger_false
+        run_all "5 > 6"
+        assert_equal Parfait::FalseClass , get_return.class
+      end
     end
   end
 end

test/risc/interpreter/test_dynamic_call.rb

@@ -11,13 +11,17 @@ module Risc
 
     def test_chain
       #show_main_ticks # get output of what is
-      check_main_chain  [Label, LoadConstant, SlotToReg, RegToSlot, LoadConstant,
+      check_main_chain [Label, LoadConstant, SlotToReg, RegToSlot, LoadConstant,
              SlotToReg, SlotToReg, SlotToReg, SlotToReg, OperatorInstruction,
              IsZero, SlotToReg, SlotToReg, SlotToReg, LoadConstant,
              RegToSlot, LoadConstant, LoadConstant, SlotToReg, SlotToReg,
              Label, LoadConstant, SlotToReg, OperatorInstruction, IsZero,
              SlotToReg, OperatorInstruction, IsZero, SlotToReg, Branch,
              Label, LoadConstant, SlotToReg, OperatorInstruction, IsZero,
+             SlotToReg, OperatorInstruction, IsZero, SlotToReg, Branch,
+             Label, LoadConstant, SlotToReg, OperatorInstruction, IsZero,
+             SlotToReg, OperatorInstruction, IsZero, SlotToReg, Branch,
+             Label, LoadConstant, SlotToReg, OperatorInstruction, IsZero,
              SlotToReg, OperatorInstruction, IsZero, Label, RegToSlot,
              Label, LoadConstant, SlotToReg, LoadConstant, SlotToReg,
              RegToSlot, RegToSlot, SlotToReg, SlotToReg, RegToSlot,
@@ -47,16 +51,16 @@ module Risc
     end
 
     def test_dyn
-      cal = main_ticks(68)
+      cal = main_ticks(88)
       assert_equal DynamicJump ,  cal.class
     end
     #should end in exit, but doesn't, becasue resolve never returns
     def test_sys
-      sys = main_ticks(99)
+      sys = main_ticks(119)
       assert_equal Syscall ,  sys.class
     end
     def test_return
-      ret = main_ticks(97)
+      ret = main_ticks(117)
       assert_equal FunctionReturn ,  ret.class
       link = @interpreter.get_register( ret.register )
       assert_equal Label , link.class