Inline arguments into message

thus removing indirection for access
does affect rather much, several commits

lib/mom/builtin.rb

@@ -54,7 +54,7 @@ module Mom
       [ :div4, :<,:<= , :>=, :> , :div10 ].each do |f|   #div4 is just a forward declaration
         compilers << compiler_for( int_type , Integer , f)
       end
-      compilers
+      return compilers
     end
 
     def self.compiler_for( type , mod , name)

lib/mom/builtin/comparison.rb

@@ -12,8 +12,7 @@ module Mom
         builder.build do
           integer! << message[:receiver]
           integer.reduce_int
-          integer_reg! << message[:arguments]
-          integer_reg << integer_reg[Parfait::NamedList.type_length + 0] #"other" is at index 0
+          integer_reg! << message[:arg1] #"other" 
           integer_reg.reduce_int
           swap_names(:integer , :integer_reg) if(operator.to_s.start_with?('<') )
           integer.op :- , integer_reg

lib/mom/builtin/get_internal_byte.rb

@@ -6,8 +6,7 @@ module Mom
         integer_tmp = builder.allocate_int
         builder.build do
           object! << message[:receiver]
-          integer! << message[:arguments]
-          integer << integer[Parfait::NamedList.type_length + 0] #"at" is at index 0
+          integer! << message[:arg1] #"at" 
           integer.reduce_int
           object <= object[integer]
           integer_tmp[Parfait::Integer.integer_index] << object

lib/mom/builtin/get_internal_word.rb

@@ -4,8 +4,7 @@ module Mom
       def to_risc(compiler)
         compiler.builder(compiler.source).build do
           object! << message[:receiver]
-          integer! << message[:arguments]
-          integer << integer[Parfait::NamedList.type_length + 0] #"at" is at index 0
+          integer! << message[:arg1] #"at" is at index 0
           integer.reduce_int
           object << object[integer]
           message[:return_value] << object

lib/mom/builtin/operator.rb

@@ -14,8 +14,7 @@ module Mom
         builder.build do
           integer! << message[:receiver]
           integer.reduce_int
-          integer_reg! << message[:arguments]
-          integer_reg << integer_reg[Parfait::NamedList.type_length + 0] #"other" is at index 0
+          integer_reg! << message[:arg1] #"other" 
           integer_reg.reduce_int
           integer.op operator , integer_reg
           integer_tmp[Parfait::Integer.integer_index] << integer

lib/mom/builtin/set_internal_byte.rb

@@ -4,10 +4,9 @@ module Mom
       def to_risc(compiler)
         compiler.builder(compiler.source).build do
           word! << message[:receiver]
-          integer! << message[:arguments]
-          integer_reg! << integer[Parfait::NamedList.type_length + 1] #"value" is at index 1
+          integer_reg! << message[:arg2] #VALUE
           message[:return_value] << integer_reg
-          integer << integer[Parfait::NamedList.type_length + 0] #"at" is at index 0
+          integer! << message[:arg1] #"index" 
           integer.reduce_int
           integer_reg.reduce_int
           word[integer] <= integer_reg

lib/mom/builtin/set_internal_word.rb

@@ -4,9 +4,8 @@ module Mom
       def to_risc(compiler)
         compiler.builder(compiler.source).build do
           object! << message[:receiver]
-          integer! << message[:arguments]
-          object_reg! << integer[Parfait::NamedList.type_length + 1] #"value" is at index 1
-          integer << integer[Parfait::NamedList.type_length + 0] #"at" is at index 0
+          integer! << message[:arg1] # "index"
+          object_reg! << message[:arg2]#"value"
           integer.reduce_int
           object[integer] << object_reg
           message[:return_value] << object_reg

lib/parfait/message.rb

@@ -15,22 +15,27 @@ module Parfait
     # :return_address => :Integer, :return_value => :Integer,
     # :caller => :Message , :name => :Word , :arguments => :NamedList
 
-    attr   :type, :next_message
-    attr   :receiver  , :frame
-    attr   :return_address, :return_value
-    attr   :caller , :method , :arguments
+    attr  :type, :next_message
+    attr  :receiver  , :frame
+    attr  :return_address, :return_value
+    attr  :caller , :method
+    attr  :arguments_given
+    attr  :arg1 , :arg2, :arg3, :arg4, :arg5, :arg6
 
     def self.type_length
-      9
+      16
     end
     def self.memory_size
-      16
+      32
+    end
+    def self.args_start_at
+      Parfait.object_space.get_type_by_class_name(:Message).variable_index(:arguments_given)
     end
 
     def initialize(  )
       super()
       self.frame = NamedList.new()
-      self.arguments = NamedList.new()
+      self.arguments_given = Parfait::Integer.new(0)
     end
     public :initialize
 

lib/risc/parfait_boot.rb

@@ -151,6 +151,7 @@ module Parfait
       Data4: {},
       Data8: {},
       Data16: {},
+      Data32: {},
       Dictionary: {i_keys: :List , i_values: :List  } ,
       FalseClass: {},
       Factory: { for_type: :Type , next_object: :Object ,
@@ -159,7 +160,10 @@ module Parfait
       List: {indexed_length: :Integer , next_list: :List} ,
       Message: { next_message: :Message,   receiver: :Object, frame: :NamedList ,
                  return_address: :Integer, return_value: :Object,
-                 caller: :Message , method: :TypedMethod ,     arguments: :NamedList },
+                 caller: :Message , method: :TypedMethod ,
+                 arguments_given: :Integer ,
+                 arg1: :Integer , arg2: :Integer, arg3: :Integer,
+                 arg4: :Integer,  arg5: :Integer, arg6: :Integer},
       MetaClass: {instance_methods: :List, instance_type: :Type, clazz: :Class },
       NamedList: {},
       NilClass: {},