Use usize for CALL_INTRINSIC, since it takes a pointer as argument.

Author: Ivorforce

src/interpreter/builtins/vm.rs

@@ -163,18 +163,18 @@ pub fn inline_fn_push_with_u8(opcode: OpCode, arg: u8) -> InlineFunction {
     }})
 }
 
-pub fn inline_fn_push_with_u64(opcode: OpCode, arg: u64) -> InlineFunction {
+pub fn inline_fn_push_with_usize(opcode: OpCode, arg: usize) -> InlineFunction {
     Rc::new(move |compiler, expression| {{
         let arguments = &compiler.implementation.expression_tree.children[expression];
         for arg in arguments { compiler.compile_expression(arg)? }
 
-        compiler.chunk.push_with_u64(opcode, arg);
+        compiler.chunk.push_with_usize(opcode, arg);
         Ok(())
     }})
 }
 
 pub fn inline_fn_push_intrinsic_call(arg: IntrinsicFunction) -> InlineFunction {
-    inline_fn_push_with_u64(OpCode::CALL_INTRINSIC, unsafe { transmute(arg) })
+    inline_fn_push_with_usize(OpCode::CALL_INTRINSIC, unsafe { transmute(arg) })
 }
 
 pub unsafe fn to_str_ptr<A: ToString>(a: A) -> *mut () {

src/interpreter/chunks.rs

@@ -56,6 +56,19 @@ impl Chunk {
         }
     }
 
+    pub fn push_with_usize(&mut self, code: OpCode, arg: usize) {
+        // TODO Should be constexpr
+        if size_of::<usize>() == size_of::<u64>() {
+            self.push_with_u64(code, arg as u64);
+        }
+        else if size_of::<usize>() == size_of::<u32>() {
+            self.push_with_u64(code, arg as u64);
+        }
+        else {
+            panic!()
+        }
+    }
+
     pub fn push_with_u128(&mut self, code: OpCode, arg: u128) {
         let len = self.code.len();
 

src/interpreter/disassembler.rs

@@ -40,10 +40,14 @@ pub fn disassemble_one(ip: *const u8) -> usize {
                 print!("\t{:?}", *(ip.add(1) as *mut u32));
                 return 1 + 4;
             }
-            OpCode::LOAD64 | OpCode::CALL_INTRINSIC => {
+            OpCode::LOAD64 => {
                 print!("\t{:?}", *(ip.add(1) as *mut u64));
                 return 1 + 8;
             }
+            OpCode::CALL_INTRINSIC => {
+                print!("\t{:?}", *(ip.add(1) as *mut usize));
+                return 1 + size_of::<usize>();
+            }
             OpCode::JUMP | OpCode::JUMP_IF_FALSE | OpCode::LOAD_LOCAL_32 | OpCode::STORE_LOCAL_32 => {
                 print!("\t{:?}", *(ip.add(1) as *mut i32));
                 return 1 + 4;

src/interpreter/vm.rs

@@ -96,9 +96,7 @@ impl VM {
                         current_chunk = chunk;
                     }
                     OpCode::CALL_INTRINSIC => {
-                        // TODO Should be platform dependent int (32bit / 64bit)
-                        let fun_ptr_int = pop_ip!(u64);
-                        let fun: IntrinsicFunction = transmute(fun_ptr_int);
+                        let fun = pop_ip!(IntrinsicFunction);
                         fun(self, &mut sp)?;
                     }
                     OpCode::LOAD0 => {