also redid the get/set internal byte with builder

had to pimp register value to use a semblance of the dsl
using <= for bytes and << for words

lib/risc/builtin/word.rb

@@ -21,15 +21,16 @@ module Risc
         # return (and word sized int) is stored in return_value
         def get_internal_byte( context)
           compiler = compiler_for(:Word , :get_internal_byte , {at: :Integer})
-          source = "get_internal_byte"
-          builder = compiler.compiler_builder(compiler.source)
-          me , index = builder.self_and_int_arg(source)
-          builder.reduce_int( source + " fix arg", index )
-          # reduce me to me[index]
-          builder.add_byte_to_reg( source , me , index , me)
-          builder.add_new_int(source, me , index)
-          # and put it back into the return value
-          builder.add_reg_to_slot( source , index , Risc.message_reg , :return_value)
+          compiler.compiler_builder(compiler.source).build do
+            object << message[:receiver]
+            integer << message[:arguments]
+            integer << integer[1]
+            integer.reduce_int
+            object <= object[integer]
+            add_new_int("get_internal_byte", object , integer)
+            message[:return_value] << integer
+          end
+
           compiler.add_mom( Mom::ReturnSequence.new)
           return compiler
         end
@@ -39,15 +40,18 @@ module Risc
         # return self
         def set_internal_byte( context )
           compiler = compiler_for(:Word, :set_internal_byte , {at: :Integer , :value => :Integer} )
-          source = "set_internal_byte"
-          builder = compiler.compiler_builder(compiler.source)
-          me , index = builder.self_and_int_arg(source)
-          value = builder.load_int_arg_at(source , 1 )
-          builder.reduce_int( source + " fix me", value )
-          builder.reduce_int( source + " fix arg", index )
-          builder.add_reg_to_byte( source , value , me , index)
-          value = builder.load_int_arg_at(source , 1 )
-          builder.add_reg_to_slot( source , value , Risc.message_reg , :return_value)
+          compiler.compiler_builder(compiler.source).build do
+            word << message[:receiver]
+            integer << message[:arguments]
+            integer << integer[1]
+            integer_reg << message[:arguments]
+            integer_obj << integer_reg[2]
+            integer_reg << integer_reg[2]
+            integer.reduce_int
+            integer_reg.reduce_int
+            word[integer] <= integer_reg
+            message[:return_value] << integer_obj
+          end
           compiler.add_mom( Mom::ReturnSequence.new)
           return compiler
         end

lib/risc/register_value.rb

@@ -140,6 +140,15 @@ module Risc
       return ins
     end
 
+    # similar to above (<< which produces slot_to_reg), this produces byte_to_reg
+    # since << covers all other cases, this must have a RValue as the right
+    def <=( right )
+      raise "not implemented for #{right.class}:#{right}" unless right.is_a?( RValue )
+      ins = Risc.byte_to_reg("#{right.register.type}[#{right.index}] -> #{self.type}" , right.register , right.index , self)
+      builder.add_code(ins) if builder
+      return ins
+    end
+
     def -( right )
       raise "operators only on registers, not #{right.class}" unless right.is_a? RegisterValue
       op = Risc.op("#{self.type} - #{right.type}", :- , self , right )
@@ -187,6 +196,15 @@ module Risc
       reg_to_slot
     end
 
+    # similar to above (<< which produces reg_to_slot), this produces reg_to_byte
+    # from itself (the slot) and the register given
+    def <=( reg )
+      raise "not reg #{reg}" unless reg.is_a?(RegisterValue)
+      reg_to_byte = Risc.reg_to_byte("#{reg.class_name} -> #{register.class_name}[#{index}]" , reg , register, index)
+      builder.add_code(reg_to_byte) if builder
+      reg_to_byte
+    end
+
   end
 
   # The register we use to store the current message object is :r0