Implement setiosys

6 files changed, 890 insertions, 780 deletions

diff --git a/opcode_proc/src/lib.rs b/opcode_proc/src/lib.rs
index d777214..7c84f9a 100644
--- a/opcode_proc/src/lib.rs
+++ b/opcode_proc/src/lib.rs
@@ -19,7 +19,7 @@ pub fn generate_opcodes(item: TokenStream) -> TokenStream {
         let code = &field.byte_code;
         let variant = &field.name;
         quote! {
-            #code => Self::#variant,
+            #code => Some(Self::#variant),
         }
     }).collect::<Vec<_>>();
 
@@ -39,6 +39,14 @@ pub fn generate_opcodes(item: TokenStream) -> TokenStream {
         }
     });
 
+    let gen_stub_arms = ops_def.codes.iter().map(|field| {
+        let variant = &field.name;
+        let value = &field.no_store;
+        quote! {
+            #enum_name::#variant => #value,
+        }
+    });
+
     let closure_match_arms = ops_def.codes.iter().map(|field| {
         let variant = &field.name;
         let closure_expr = &field.func_block;
@@ -87,15 +95,16 @@ pub fn generate_opcodes(item: TokenStream) -> TokenStream {
     });
 
     let tokens = quote! {
+        #[derive(Debug, Clone)]
         pub enum #enum_name {
             #(#field_names),*
         }
 
         impl #enum_name {
-            pub fn get_from_code(code: u32) -> Self {
+            pub fn get_from_code(code: u32) -> Option<Self> {
                 match code {
                     #(#getcode_match_arms)*
-                    _ => panic!("Unknown opcode 0x{code:03x}")
+                    _ => None
                 }
             }
 
@@ -111,6 +120,12 @@ pub fn generate_opcodes(item: TokenStream) -> TokenStream {
                 }
             }
 
+            pub fn should_gen_return_stub(opcode: Self) -> bool {
+                match opcode {
+                    #(#gen_stub_arms)*
+                }
+            }
+
             pub fn call_opcode(interpreter: &mut crate::Interpreter, opcode: Self, input_params: Vec<u32>) -> Vec<u32> {
                 match opcode {
                     #(#closure_match_arms)*
@@ -148,6 +163,15 @@ impl Parse for SingleOpcodeDefinition {
         parenthesized!(code in attr);
         let byte_code = code.parse::<LitInt>()?;
 
+        let mut no_store = false;
+        if attr.peek(Token![,]) {
+            attr.parse::<Token![,]>()?;
+            let extra_attr = attr.parse::<Ident>()?;
+            if extra_attr == "no_store" {
+                no_store = true;
+            }
+        }
+
         input.parse::<Token![fn]>()?;
         let name = input.parse::<Ident>()?;
 
@@ -186,6 +210,7 @@ impl Parse for SingleOpcodeDefinition {
 
         Ok(SingleOpcodeDefinition {
             byte_code,
+            no_store,
             name,
             input_params,
             interpreter_ident,
@@ -204,6 +229,7 @@ struct OpcodeBlock {
 
 struct SingleOpcodeDefinition {
     pub byte_code: LitInt,
+    pub no_store: bool,
     pub name: Ident,
     pub interpreter_ident: Option<Ident>,
     pub input_params: Vec<PatType>,
diff --git a/src/glk.rs b/src/glk.rs
index 3efb095..ed308f9 100644
--- a/src/glk.rs
+++ b/src/glk.rs
@@ -1,3 +1,2 @@
 pub struct Glk {
-
 }
diff --git a/src/instructions.rs b/src/instructions.rs
index 59efd47..55bc5b9 100644
--- a/src/instructions.rs
+++ b/src/instructions.rs
@@ -1,11 +1,13 @@
 use core::panic;
 
 use crate::interpreter::{MemAddress, StackAddress};
+use crate::opcodes::OpCode;
 
 #[derive(Debug)]
 pub struct Instruction {
-    pub operation: OpCode,
-    pub operands: Vec<Operand>
+    pub opcode: OpCode,
+    pub in_operands: Vec<Operand>,
+    pub out_operands: Vec<Operand>,
 }
 
 enum Nybble {
@@ -13,7 +15,7 @@ enum Nybble {
     Low,
 }
 
-#[derive(PartialEq, Debug)]
+#[derive(PartialEq, Debug, Clone)]
 pub enum Operand {
     Constant(i32),
     PopStack,
@@ -23,17 +25,44 @@ pub enum Operand {
 }
 
 impl Instruction {
-    pub fn read<'a, I>(bytes: &mut I) -> (Instruction, u32)
+    pub fn read<'a, I>(bytes: &mut I) -> Result<(Instruction, u32), u32>
     where
         I: IntoIterator<Item = &'a u8> + Copy
     {
         let mut bytes = bytes.into_iter().enumerate().peekable();
-        let instruction_length = OpCode::get_length(*bytes.peek().unwrap().1);
-        let mut bytes = bytes.into_iter();
-        let instruction_bytes = (0..instruction_length).into_iter().map(|_n| *bytes.next().unwrap().1).collect();
-        let operation = OpCode::from_bytes(instruction_bytes);
 
-        let operand_count = operation.get_operand_count();
+        let instruction_length = {
+            let first_byte = *bytes.peek().unwrap().1;
+            match first_byte >> 6 {
+                0b00 | 0b01 => 1,
+                0b10 => 2,
+                0b11 => 4,
+                _ => unreachable!()
+            }
+        };
+
+        let mask = match instruction_length {
+            1 => 0,
+            2 => 0x8000,
+            4 => 0xC0000000,
+            _ => panic!("Invalid opcode byte array"),
+        };
+
+        let instruction_bytes = (0..4-instruction_length).into_iter().map(|_n| 0).chain(
+                (0..instruction_length).into_iter().map(|_n| *bytes.next().unwrap().1)
+            ).collect::<Vec<_>>();
+
+        let opcode_num = u32::from_be_bytes(instruction_bytes.clone().try_into().unwrap()) & !mask;
+        println!("instruction length: {instruction_length}, number: 0x{opcode_num:x}, bytes: {instruction_bytes:?}");
+        let opcode = OpCode::get_from_code(opcode_num);
+        if let None = opcode {
+            return Err(opcode_num);
+        }
+        let opcode = opcode.unwrap();
+        let input_operand_count = OpCode::get_input_arg_count(opcode.clone());
+        let output_operand_count = OpCode::get_output_arg_count(opcode.clone());
+
+        let operand_count = input_operand_count + output_operand_count;
         let operand_bytes = (operand_count + 1) / 2;
         let skip_last_half = operand_bytes != operand_count / 2;
         let operand_bytes = (0..operand_bytes).into_iter().map(|_n| *bytes.next().unwrap().1);
@@ -76,382 +105,14 @@ impl Instruction {
             operands.remove(operands.len() - 1);
         }
 
-        // Return instruction along with the number of bytes we've read
-        (Instruction {
-            operation,
-            operands,
-        }, data_bytes.peek().unwrap().0 as u32)
-    }
-}
-
-impl OpCode {
-    fn get_length(first_byte: u8) -> usize {
-        let length = match first_byte >> 6 {
-            0b00 | 0b01 => 1,
-            0b10 => 2,
-            0b11 => 4,
-            _ => unreachable!()
-        };
-        return length
-    }
-
-    fn from_bytes(bytes: Vec<u8>) -> Self {
-        let (padded_bytes, mask) = match bytes.len() {
-            1 => ([0,0,0,bytes[0]], 0),
-            2 => ([0,0,bytes[0],bytes[1]], 0x8000),
-            4 => ([bytes[0],bytes[1],bytes[2],bytes[3]], 0xC0000000),
-            _ => panic!("Invalid opcode byte array")
-        };
-
-        let instruction = u32::from_be_bytes(padded_bytes) & !mask;
-        return unsafe { std::mem::transmute(instruction) }
-    }
-
-    fn get_operand_count(&self) -> usize {
-        match *self {
-            // Misc
-            OpCode::Nop => 0,
-            OpCode::Gestalt => 3,
-            OpCode::Debugtrap => 1,
-            OpCode::Glk => 3,
-
-            // Integer math
-            OpCode::Add => 3,
-            OpCode::Sub => 3,
-            OpCode::Mul => 3,
-            OpCode::Div => 3,
-            OpCode::Mod => 3,
-            OpCode::Neg => 2,
-            OpCode::Bitand => 3,
-            OpCode::Bitor => 3,
-            OpCode::Bitxor => 3,
-            OpCode::Bitnot => 3,
-            OpCode::Shiftl => 3,
-            OpCode::Sshiftr => 3,
-            OpCode::Ushiftr => 3,
-
-            // Branches
-            OpCode::Jump => 1,
-            OpCode::Jz => 2,
-            OpCode::Jnz => 2,
-            OpCode::Jeq => 3,
-            OpCode::Jne => 3,
-            OpCode::Jlt => 3,
-            OpCode::Jge => 3,
-            OpCode::Jgt => 3,
-            OpCode::Jle => 3,
-            OpCode::Jltu => 3,
-            OpCode::Jgeu => 3,
-            OpCode::Jgtu => 3,
-            OpCode::Jleu => 3,
-            OpCode::Jumpabs => 1,
+        let in_operands = operands[0..input_operand_count].try_into().unwrap();
+        let out_operands = operands[input_operand_count..].try_into().unwrap();
 
-            // Moving data
-            OpCode::Copy => 2,
-            OpCode::Copys => 2,
-            OpCode::Copyb => 2,
-            OpCode::Sexs => 2,
-            OpCode::Sexb => 2,
-
-            // Array data
-            OpCode::Aload => 3,
-            OpCode::Aloads => 3,
-            OpCode::Aloadb => 3,
-            OpCode::Aloadbit => 3,
-            OpCode::Astore => 3,
-            OpCode::Astores => 3,
-            OpCode::Astoreb => 3,
-            OpCode::Astorebit => 3,
-
-            // Stack operations
-            OpCode::Stkcount => 1,
-            OpCode::Stkpeek => 2,
-            OpCode::Stkswap => 0,
-            OpCode::Stkroll => 2,
-            OpCode::Stkcopy => 1,
-
-            // Functions
-            OpCode::Call => 3,
-            OpCode::Callf => 2,
-            OpCode::Callfi => 3,
-            OpCode::Callfii => 4,
-            OpCode::Callfiii => 5,
-            OpCode::Return => 1,
-            OpCode::Tailcall => 2,
-
-            // Continuations
-            OpCode::Catch => 2,
-            OpCode::Throw => 2,
-
-            // Memory
-            OpCode::Getmemsize => 1,
-            OpCode::Setmemsize => 2,
-            OpCode::Malloc => 2,
-            OpCode::Mfree => 1,
-
-            // Game state
-            OpCode::Quit => 0,
-            OpCode::Restart => 0,
-            OpCode::Save => 2,
-            OpCode::Restore => 2,
-            OpCode::Saveundo => 1,
-            OpCode::Restoreundo => 1,
-            OpCode::Hasundo => 1,
-            OpCode::Discardundo => 0,
-            OpCode::Protect => 2,
-            OpCode::Verify => 1,
-
-            // Output
-            OpCode::Getiosys => 2,
-            OpCode::Setiosys => 2,
-            OpCode::Streamchar => 1,
-            OpCode::Streamunichar => 1,
-            OpCode::Streamnum => 1,
-            OpCode::Streamstr => 1,
-            OpCode::Getstringtbl => 1,
-            OpCode::Setstringtbl => 1,
-
-            // Floating point math
-            OpCode::Numtof => 2,
-            OpCode::Ftonumz => 2,
-            OpCode::Ftonumn => 2,
-            OpCode::Fadd => 3,
-            OpCode::Fsub => 3,
-            OpCode::Fmul => 3,
-            OpCode::Fdiv => 3,
-            OpCode::Fmod => 4,
-            OpCode::Ceil => 2,
-            OpCode::Floor => 2,
-            OpCode::Sqrt => 2,
-            OpCode::Exp => 2,
-            OpCode::Log => 2,
-            OpCode::Pow => 3,
-            OpCode::Sin => 2,
-            OpCode::Cos => 2,
-            OpCode::Tan => 2,
-            OpCode::Asin => 2,
-            OpCode::Acos => 2,
-            OpCode::Atan => 2,
-            OpCode::Atan2 => 3,
-
-            // Double precision math
-            OpCode::Numtod => 3,
-            OpCode::Dtonumz => 3,
-            OpCode::Dtonumn => 3,
-            OpCode::Ftod => 3,
-            OpCode::Dtof => 3,
-            OpCode::Dadd => 6,
-            OpCode::Dsub => 6,
-            OpCode::Dmul => 6,
-            OpCode::Ddiv => 6,
-            OpCode::Dmodr => 6,
-            OpCode::Dmodq => 6,
-            OpCode::Dceil => 4,
-            OpCode::Dfloor => 4,
-            OpCode::Dsqrt => 4,
-            OpCode::Dexp => 4,
-            OpCode::Dlog => 4,
-            OpCode::Dpow => 6,
-            OpCode::Dsin => 4,
-            OpCode::Dcos => 4,
-            OpCode::Dtan => 4,
-            OpCode::Dasin => 4,
-            OpCode::Dacos => 4,
-            OpCode::Datan => 4,
-            OpCode::Datan2 => 4,
-
-            // Floating point comparisons
-            OpCode::Jisnan => 2,
-            OpCode::Jisinf => 2,
-            OpCode::Jfeq => 4,
-            OpCode::Jfne => 4,
-            OpCode::Jflt => 3,
-            OpCode::Jfle => 3,
-            OpCode::Jfgt => 3,
-            OpCode::Jfge => 3,
-
-            // Double precision comparisons
-            OpCode::Jdisnan => 3,
-            OpCode::Jdisinf => 3,
-            OpCode::Jdeq => 7,
-            OpCode::Jdne => 7,
-            OpCode::Jdlt => 5,
-            OpCode::Jdle => 5,
-            OpCode::Jdgt => 5,
-            OpCode::Jdge => 5,
-
-            // RNG
-            OpCode::Random => 2,
-            OpCode::Setrandom => 1,
-
-            // Block copy and clear
-            OpCode::Mzero => 2,
-            OpCode::Mcopy => 3,
-
-            // Searching
-            OpCode::Linearsearch => 8,
-            OpCode::Binarysearch => 8,
-            OpCode::Linkedsearch => 7,
-
-            // Accelerated functions
-            OpCode::Accelfunc => 2,
-            OpCode::Accelparam => 2,
-        }
+        // Return instruction along with the number of bytes we've read
+        Ok((Instruction {
+            opcode,
+            in_operands,
+            out_operands,
+        }, data_bytes.peek().unwrap().0 as u32))
     }
 }
-
-
-#[repr(u32)]
-#[derive(Debug)]
-pub enum OpCode {
-    Nop = 0x00,
-    Add = 0x10,
-    Sub = 0x11,
-    Mul = 0x12,
-    Div = 0x13,
-    Mod = 0x14,
-    Neg = 0x15,
-    Bitand = 0x18,
-    Bitor = 0x19,
-    Bitxor = 0x1A,
-    Bitnot = 0x1B,
-    Shiftl = 0x1C,
-    Sshiftr = 0x1D,
-    Ushiftr = 0x1E,
-    Jump = 0x20,
-    Jz = 0x22,
-    Jnz = 0x23,
-    Jeq = 0x24,
-    Jne = 0x25,
-    Jlt = 0x26,
-    Jge = 0x27,
-    Jgt = 0x28,
-    Jle = 0x29,
-    Jltu = 0x2A,
-    Jgeu = 0x2B,
-    Jgtu = 0x2C,
-    Jleu = 0x2D,
-    Call = 0x30,
-    Return = 0x31,
-    Catch = 0x32,
-    Throw = 0x33,
-    Tailcall = 0x34,
-    Copy = 0x40,
-    Copys = 0x41,
-    Copyb = 0x42,
-    Sexs = 0x44,
-    Sexb = 0x45,
-    Aload = 0x48,
-    Aloads = 0x49,
-    Aloadb = 0x4A,
-    Aloadbit = 0x4B,
-    Astore = 0x4C,
-    Astores = 0x4D,
-    Astoreb = 0x4E,
-    Astorebit = 0x4F,
-    Stkcount = 0x50,
-    Stkpeek = 0x51,
-    Stkswap = 0x52,
-    Stkroll = 0x53,
-    Stkcopy = 0x54,
-    Streamchar = 0x70,
-    Streamnum = 0x71,
-    Streamstr = 0x72,
-    Streamunichar = 0x73,
-    Gestalt = 0x100,
-    Debugtrap = 0x101,
-    Getmemsize = 0x102,
-    Setmemsize = 0x103,
-    Jumpabs = 0x104,
-    Random = 0x110,
-    Setrandom = 0x111,
-    Quit = 0x120,
-    Verify = 0x121,
-    Restart = 0x122,
-    Save = 0x123,
-    Restore = 0x124,
-    Saveundo = 0x125,
-    Restoreundo = 0x126,
-    Protect = 0x127,
-    Hasundo = 0x128,
-    Discardundo = 0x129,
-    Glk = 0x130,
-    Getstringtbl = 0x140,
-    Setstringtbl = 0x141,
-    Getiosys = 0x148,
-    Setiosys = 0x149,
-    Linearsearch = 0x150,
-    Binarysearch = 0x151,
-    Linkedsearch = 0x152,
-    Callf = 0x160,
-    Callfi = 0x161,
-    Callfii = 0x162,
-    Callfiii = 0x163,
-    Mzero = 0x170,
-    Mcopy = 0x171,
-    Malloc = 0x178,
-    Mfree = 0x179,
-    Accelfunc = 0x180,
-    Accelparam = 0x181,
-    Numtof = 0x190,
-    Ftonumz = 0x191,
-    Ftonumn = 0x192,
-    Ceil = 0x198,
-    Floor = 0x199,
-    Fadd = 0x1A0,
-    Fsub = 0x1A1,
-    Fmul = 0x1A2,
-    Fdiv = 0x1A3,
-    Fmod = 0x1A4,
-    Sqrt = 0x1A8,
-    Exp = 0x1A9,
-    Log = 0x1AA,
-    Pow = 0x1AB,
-    Sin = 0x1B0,
-    Cos = 0x1B1,
-    Tan = 0x1B2,
-    Asin = 0x1B3,
-    Acos = 0x1B4,
-    Atan = 0x1B5,
-    Atan2 = 0x1B6,
-    Jfeq = 0x1C0,
-    Jfne = 0x1C1,
-    Jflt = 0x1C2,
-    Jfle = 0x1C3,
-    Jfgt = 0x1C4,
-    Jfge = 0x1C5,
-    Jisnan = 0x1C8,
-    Jisinf = 0x1C9,
-    Numtod = 0x200,
-    Dtonumz = 0x201,
-    Dtonumn = 0x202,
-    Ftod = 0x203,
-    Dtof = 0x204,
-    Dceil = 0x208,
-    Dfloor = 0x209,
-    Dadd = 0x210,
-    Dsub = 0x211,
-    Dmul = 0x212,
-    Ddiv = 0x213,
-    Dmodr = 0x214,
-    Dmodq = 0x215,
-    Dsqrt = 0x218,
-    Dexp = 0x219,
-    Dlog = 0x21A,
-    Dpow = 0x21B,
-    Dsin = 0x220,
-    Dcos = 0x221,
-    Dtan = 0x222,
-    Dasin = 0x223,
-    Dacos = 0x224,
-    Datan = 0x225,
-    Datan2 = 0x226,
-    Jdeq = 0x230,
-    Jdne = 0x231,
-    Jdlt = 0x232,
-    Jdle = 0x233,
-    Jdgt = 0x234,
-    Jdge = 0x235,
-    Jdisnan = 0x238,
-    Jdisinf = 0x239,
-}
diff --git a/src/interpreter.rs b/src/interpreter.rs
index b93b05f..9f226ae 100644
--- a/src/interpreter.rs
+++ b/src/interpreter.rs
@@ -1,6 +1,6 @@
 use core::panic;
 
-use crate::{glk::Glk, instructions::{Instruction, Operand}};
+use crate::{glk::Glk, instructions::{Instruction, Operand}, opcodes::OpCode};
 
 pub type MemAddress = u32;
 pub type StackAddress = u32;
@@ -33,7 +33,7 @@ pub struct HeapChunk {
 pub enum Output {
     Null,
     Filter(FunctionPointer),
-    Glk(Glk),
+    Glk(Glk, u32),
 }
 
 pub struct Interpreter {
@@ -49,6 +49,7 @@ pub struct Interpreter {
     pub reg_strdec: MemAddress,
 
     pub output_mode: Output,
+    tmp_dest_oper: Option<Operand>,
 }
 
 impl Interpreter {
@@ -81,6 +82,7 @@ impl Interpreter {
             reg_strdec: str_decode,
 
             output_mode: Output::Null,
+            tmp_dest_oper: None,
         }
     }
 
@@ -90,406 +92,53 @@ impl Interpreter {
         loop {
             let pc = self.reg_program as usize;
             let mut instruction_slice = &self.memory[pc..pc+100];
-            let (instruction, bytes_read) = Instruction::read(&mut instruction_slice);
+            let instruction_read = Instruction::read(&mut instruction_slice);
+            if let Err(unknown_opcode) = instruction_read {
+                panic!("Unknown opcode 0x{unknown_opcode:03x} at 0x{pc:08x}")
+            }
+            let (instruction, bytes_read) = instruction_read.unwrap();
             self.reg_program += bytes_read;
 
             println!("Executing instruction {instruction:?}");
 
-            match instruction.operation {
-                crate::instructions::OpCode::Nop => (),
-                crate::instructions::OpCode::Add => {
-                    let op1 = self.eval_source_operand(&instruction.operands[0]);
-                    let op2 = self.eval_source_operand(&instruction.operands[1]);
-
-                    self.store_dest_operand(&instruction.operands[2], op1 + op2);
-                },
-                crate::instructions::OpCode::Sub => {
-                    let op1 = self.eval_source_operand(&instruction.operands[0]);
-                    let op2 = self.eval_source_operand(&instruction.operands[1]);
-
-                    self.store_dest_operand(&instruction.operands[2], op1 - op2);
-                },
-                crate::instructions::OpCode::Mul => {
-                    let op1 = self.eval_source_operand(&instruction.operands[0]);
-                    let op2 = self.eval_source_operand(&instruction.operands[1]);
-
-                    self.store_dest_operand(&instruction.operands[2], op1 * op2);
-                },
-                crate::instructions::OpCode::Div => {
-                    let op1 = self.eval_source_operand(&instruction.operands[0]) as i32;
-                    let op2 = self.eval_source_operand(&instruction.operands[1]) as i32;
-                    let result = (op1 / op2) as u32;
-
-                    self.store_dest_operand(&instruction.operands[2], result);
-                },
-                crate::instructions::OpCode::Mod => {
-                    let op1 = self.eval_source_operand(&instruction.operands[0]) as i32;
-                    let op2 = self.eval_source_operand(&instruction.operands[1]) as i32;
-                    let result = (op1 % op2) as u32;
-
-                    self.store_dest_operand(&instruction.operands[2], result);
-                },
-                crate::instructions::OpCode::Neg => {
-                    let op1 = self.eval_source_operand(&instruction.operands[0]) as i32;
-                    let result = (-op1) as u32;
-
-                    self.store_dest_operand(&instruction.operands[1], result);
-                },
-                crate::instructions::OpCode::Bitand => {
-                    let op1 = self.eval_source_operand(&instruction.operands[0]);
-                    let op2 = self.eval_source_operand(&instruction.operands[1]);
-
-                    self.store_dest_operand(&instruction.operands[2], op1 & op2);
-                },
-                crate::instructions::OpCode::Bitor => {
-                    let op1 = self.eval_source_operand(&instruction.operands[0]);
-                    let op2 = self.eval_source_operand(&instruction.operands[1]);
-
-                    self.store_dest_operand(&instruction.operands[2], op1 | op2);
-                },
-                crate::instructions::OpCode::Bitxor => {
-                    let op1 = self.eval_source_operand(&instruction.operands[0]);
-                    let op2 = self.eval_source_operand(&instruction.operands[1]);
-
-                    self.store_dest_operand(&instruction.operands[2], op1 ^ op2);
-                },
-                crate::instructions::OpCode::Bitnot => {
-                    let op1 = self.eval_source_operand(&instruction.operands[0]);
-
-                    self.store_dest_operand(&instruction.operands[1], !op1);
-                },
-                crate::instructions::OpCode::Shiftl => {
-                    let op1 = self.eval_source_operand(&instruction.operands[0]);
-                    let op2 = self.eval_source_operand(&instruction.operands[1]);
-
-                    self.store_dest_operand(&instruction.operands[2], op1 << op2);
-                },
-                crate::instructions::OpCode::Sshiftr => {
-                    let op1 = self.eval_source_operand(&instruction.operands[0]);
-                    let op2 = self.eval_source_operand(&instruction.operands[1]);
-
-                    self.store_dest_operand(&instruction.operands[2], op1 >> op2);
-                },
-                crate::instructions::OpCode::Ushiftr => {
-                    let op1 = self.eval_source_operand(&instruction.operands[0]);
-                    let op2 = self.eval_source_operand(&instruction.operands[1]);
-
-                    self.store_dest_operand(&instruction.operands[2], op1 >> op2);
-                },
-                crate::instructions::OpCode::Jump => {
-                    let op1 = self.eval_source_operand(&instruction.operands[0]);
-                    self.jump_with_offset(op1);
-                },
-                crate::instructions::OpCode::Jz => {
-                    let check = self.eval_source_operand(&instruction.operands[0]);
-                    let destination = self.eval_source_operand(&instruction.operands[1]);
-                    if check == 0 {
-                        self.jump_with_offset(destination);
-                    }
-                },
-                crate::instructions::OpCode::Jnz => {
-                    let check = self.eval_source_operand(&instruction.operands[0]);
-                    let destination = self.eval_source_operand(&instruction.operands[1]);
-                    if check != 0 {
-                        self.jump_with_offset(destination);
-                    }
-                },
-                crate::instructions::OpCode::Jeq => {
-                    let op1 = self.eval_source_operand(&instruction.operands[0]);
-                    let op2 = self.eval_source_operand(&instruction.operands[1]);
-                    let destination = self.eval_source_operand(&instruction.operands[2]);
-                    if op1 == op2 {
-                        self.jump_with_offset(destination);
-                    }
-                },
-                crate::instructions::OpCode::Jne => {
-                    let op1 = self.eval_source_operand(&instruction.operands[0]) as i32;
-                    let op2 = self.eval_source_operand(&instruction.operands[1]) as i32;
-                    let destination = self.eval_source_operand(&instruction.operands[2]);
-                    if op1 != op2 {
-                        self.jump_with_offset(destination);
-                    }
-                },
-                crate::instructions::OpCode::Jlt => {
-                    let op1 = self.eval_source_operand(&instruction.operands[0]) as i32;
-                    let op2 = self.eval_source_operand(&instruction.operands[1]) as i32;
-                    let destination = self.eval_source_operand(&instruction.operands[2]);
-                    if op1 < op2 {
-                        self.jump_with_offset(destination);
-                    }
-                },
-                crate::instructions::OpCode::Jge => {
-                    let op1 = self.eval_source_operand(&instruction.operands[0]) as i32;
-                    let op2 = self.eval_source_operand(&instruction.operands[1]) as i32;
-                    let destination = self.eval_source_operand(&instruction.operands[2]);
-                    if op1 >= op2 {
-                        self.jump_with_offset(destination);
-                    }
-                },
-                crate::instructions::OpCode::Jgt => {
-                    let op1 = self.eval_source_operand(&instruction.operands[0]) as i32;
-                    let op2 = self.eval_source_operand(&instruction.operands[1]) as i32;
-                    let destination = self.eval_source_operand(&instruction.operands[2]);
-                    if op1 > op2 {
-                        self.jump_with_offset(destination);
-                    }
-                },
-                crate::instructions::OpCode::Jle => {
-                    let op1 = self.eval_source_operand(&instruction.operands[0]);
-                    let op2 = self.eval_source_operand(&instruction.operands[1]);
-                    let destination = self.eval_source_operand(&instruction.operands[2]);
-                    if op1 <= op2 {
-                        self.jump_with_offset(destination);
-                    }
-                },
-                crate::instructions::OpCode::Jltu => {
-                    let op1 = self.eval_source_operand(&instruction.operands[0]);
-                    let op2 = self.eval_source_operand(&instruction.operands[1]);
-                    let destination = self.eval_source_operand(&instruction.operands[2]);
-                    if op1 < op2 {
-                        self.jump_with_offset(destination);
-                    }
-                },
-                crate::instructions::OpCode::Jgeu => {
-                    let op1 = self.eval_source_operand(&instruction.operands[0]);
-                    let op2 = self.eval_source_operand(&instruction.operands[1]);
-                    let destination = self.eval_source_operand(&instruction.operands[2]);
-                    if op1 >= op2 {
-                        self.jump_with_offset(destination);
-                    }
-                },
-                crate::instructions::OpCode::Jgtu => {
-                    let op1 = self.eval_source_operand(&instruction.operands[0]);
-                    let op2 = self.eval_source_operand(&instruction.operands[1]);
-                    let destination = self.eval_source_operand(&instruction.operands[2]);
-                    if op1 > op2 {
-                        self.jump_with_offset(destination);
-                    }
-                },
-                crate::instructions::OpCode::Jleu => {
-                    let op1 = self.eval_source_operand(&instruction.operands[0]);
-                    let op2 = self.eval_source_operand(&instruction.operands[1]);
-                    let destination = self.eval_source_operand(&instruction.operands[2]);
-                    if op1 <= op2 {
-                        self.jump_with_offset(destination);
-                    }
-                },
-                crate::instructions::OpCode::Jumpabs => {
-                    let destination = self.eval_source_operand(&instruction.operands[0]);
-                    self.reg_program = destination;
-                },
-                crate::instructions::OpCode::Copy => {
-                    let source = self.eval_source_operand(&instruction.operands[0]);
-                    self.store_dest_operand(&instruction.operands[1], source);
-                },
-                crate::instructions::OpCode::Copys => todo!(),
-                crate::instructions::OpCode::Copyb => todo!(),
-                crate::instructions::OpCode::Sexs => {
-                    let source = self.eval_source_operand(&instruction.operands[0]);
-                    let result = source as i16 as i32 as u32;
-                    self.store_dest_operand(&instruction.operands[1], result);
-                },
-                crate::instructions::OpCode::Sexb => {
-                    let source = self.eval_source_operand(&instruction.operands[0]);
-                    let result = source as i8 as i32 as u32;
-                    self.store_dest_operand(&instruction.operands[1], result);
-                },
-                crate::instructions::OpCode::Aload => {
-                    let l1 = self.eval_source_operand(&instruction.operands[0]);
-                    let l2 = self.eval_source_operand(&instruction.operands[1]);
-                    let value = self.get_word(l1.wrapping_add(4 * l2), ReadWriteDest::Memory);
-                    self.store_dest_operand(&instruction.operands[2], value);
-                },
-                crate::instructions::OpCode::Aloads => {
-                    let l1 = self.eval_source_operand(&instruction.operands[0]);
-                    let l2 = self.eval_source_operand(&instruction.operands[1]);
-                    let value = self.get_twobyte(l1.wrapping_add(2 * l2), ReadWriteDest::Memory);
-                    self.store_dest_operand(&instruction.operands[2], value as u32);
-                },
-                crate::instructions::OpCode::Aloadb => {
-                    let l1 = self.eval_source_operand(&instruction.operands[0]);
-                    let l2 = self.eval_source_operand(&instruction.operands[1]);
-                    let value = self.get_twobyte(l1.wrapping_add(l2), ReadWriteDest::Memory);
-                    self.store_dest_operand(&instruction.operands[2], value as u32);
-                },
-                crate::instructions::OpCode::Astore => {
-                    let l1 = self.eval_source_operand(&instruction.operands[0]);
-                    let l2 = self.eval_source_operand(&instruction.operands[1]);
-                    let l3 = self.eval_source_operand(&instruction.operands[2]);
-                    self.write_word(l1.wrapping_add(4 * l2), ReadWriteDest::Memory, l3);
-                },
-                crate::instructions::OpCode::Astores => {
-                    let l1 = self.eval_source_operand(&instruction.operands[0]);
-                    let l2 = self.eval_source_operand(&instruction.operands[1]);
-                    let l3 = self.eval_source_operand(&instruction.operands[2]);
-                    self.write_twobyte(l1.wrapping_add(2 * l2), ReadWriteDest::Memory, l3 as u16);
-                },
-                crate::instructions::OpCode::Astoreb => {
-                    let l1 = self.eval_source_operand(&instruction.operands[0]);
-                    let l2 = self.eval_source_operand(&instruction.operands[1]);
-                    let l3 = self.eval_source_operand(&instruction.operands[2]);
-                    self.write_byte(l1.wrapping_add(l2), ReadWriteDest::Memory, l3 as u8);
-                },
-                crate::instructions::OpCode::Aloadbit => todo!(),
-                crate::instructions::OpCode::Astorebit => todo!(),
-                crate::instructions::OpCode::Stkcount => todo!(),
-                crate::instructions::OpCode::Stkpeek => todo!(),
-                crate::instructions::OpCode::Stkswap => todo!(),
-                crate::instructions::OpCode::Stkroll => todo!(),
-                crate::instructions::OpCode::Stkcopy => todo!(),
-                crate::instructions::OpCode::Call => {
-                    let func_addr = self.eval_source_operand(&instruction.operands[0]);
-                    let arg_count = self.eval_source_operand(&instruction.operands[1]);
-                    let args = (0..arg_count).map(|_| self.pop_stack()).collect::<Vec<_>>();
-                    self.call_function(func_addr, args, &instruction.operands[2]);
-                },
-                crate::instructions::OpCode::Callf => {
-                    let func_addr = self.eval_source_operand(&instruction.operands[0]);
-                    self.call_function(func_addr, Vec::new(), &instruction.operands[1]);
-                },
-                crate::instructions::OpCode::Callfi => todo!(),
-                crate::instructions::OpCode::Callfii => todo!(),
-                crate::instructions::OpCode::Callfiii => todo!(),
-                crate::instructions::OpCode::Return => todo!(),
-                crate::instructions::OpCode::Catch => todo!(),
-                crate::instructions::OpCode::Throw => todo!(),
-                crate::instructions::OpCode::Tailcall => todo!(),
-                crate::instructions::OpCode::Streamchar => todo!(),
-                crate::instructions::OpCode::Streamnum => todo!(),
-                crate::instructions::OpCode::Streamstr => todo!(),
-                crate::instructions::OpCode::Streamunichar => todo!(),
-                crate::instructions::OpCode::Gestalt => {
-                    let gestalt_num = self.eval_source_operand(&instruction.operands[0]);
-                    let extra_arg   = self.eval_source_operand(&instruction.operands[1]);
-
-                    if gestalt_num == 4 && extra_arg == 2 {
-                        self.store_dest_operand(&instruction.operands[2], 1);
-                    } else {
-                        self.store_dest_operand(&instruction.operands[2], 0);
-                    }
-                },
-                crate::instructions::OpCode::Debugtrap => todo!(),
-                crate::instructions::OpCode::Getmemsize => todo!(),
-                crate::instructions::OpCode::Setmemsize => todo!(),
-                crate::instructions::OpCode::Random => todo!(),
-                crate::instructions::OpCode::Setrandom => todo!(),
-                crate::instructions::OpCode::Quit => {
-                    println!("Quit called");
-                    return;
-                },
-                crate::instructions::OpCode::Verify => todo!(),
-                crate::instructions::OpCode::Restart => todo!(),
-                crate::instructions::OpCode::Save => todo!(),
-                crate::instructions::OpCode::Restore => todo!(),
-                crate::instructions::OpCode::Saveundo => todo!(),
-                crate::instructions::OpCode::Restoreundo => todo!(),
-                crate::instructions::OpCode::Protect => todo!(),
-                crate::instructions::OpCode::Hasundo => todo!(),
-                crate::instructions::OpCode::Discardundo => todo!(),
-                crate::instructions::OpCode::Glk => todo!(),
-                crate::instructions::OpCode::Getstringtbl => todo!(),
-                crate::instructions::OpCode::Setstringtbl => todo!(),
-                crate::instructions::OpCode::Getiosys => todo!(),
-                crate::instructions::OpCode::Setiosys => todo!(),
-                crate::instructions::OpCode::Linearsearch => todo!(),
-                crate::instructions::OpCode::Binarysearch => todo!(),
-                crate::instructions::OpCode::Linkedsearch => todo!(),
-                crate::instructions::OpCode::Mzero => todo!(),
-                crate::instructions::OpCode::Mcopy => todo!(),
-                crate::instructions::OpCode::Malloc => todo!(),
-                crate::instructions::OpCode::Mfree => todo!(),
-                crate::instructions::OpCode::Accelfunc => todo!(),
-                crate::instructions::OpCode::Accelparam => todo!(),
-                crate::instructions::OpCode::Numtof => todo!(),
-                crate::instructions::OpCode::Ftonumz => todo!(),
-                crate::instructions::OpCode::Ftonumn => todo!(),
-                crate::instructions::OpCode::Ceil => todo!(),
-                crate::instructions::OpCode::Floor => todo!(),
-                crate::instructions::OpCode::Fadd => todo!(),
-                crate::instructions::OpCode::Fsub => todo!(),
-                crate::instructions::OpCode::Fmul => todo!(),
-                crate::instructions::OpCode::Fdiv => todo!(),
-                crate::instructions::OpCode::Fmod => todo!(),
-                crate::instructions::OpCode::Sqrt => todo!(),
-                crate::instructions::OpCode::Exp => todo!(),
-                crate::instructions::OpCode::Log => todo!(),
-                crate::instructions::OpCode::Pow => todo!(),
-                crate::instructions::OpCode::Sin => todo!(),
-                crate::instructions::OpCode::Cos => todo!(),
-                crate::instructions::OpCode::Tan => todo!(),
-                crate::instructions::OpCode::Asin => todo!(),
-                crate::instructions::OpCode::Acos => todo!(),
-                crate::instructions::OpCode::Atan => todo!(),
-                crate::instructions::OpCode::Atan2 => todo!(),
-                crate::instructions::OpCode::Jfeq => todo!(),
-                crate::instructions::OpCode::Jfne => todo!(),
-                crate::instructions::OpCode::Jflt => todo!(),
-                crate::instructions::OpCode::Jfle => todo!(),
-                crate::instructions::OpCode::Jfgt => todo!(),
-                crate::instructions::OpCode::Jfge => todo!(),
-                crate::instructions::OpCode::Jisnan => todo!(),
-                crate::instructions::OpCode::Jisinf => todo!(),
-                crate::instructions::OpCode::Numtod => todo!(),
-                crate::instructions::OpCode::Dtonumz => todo!(),
-                crate::instructions::OpCode::Dtonumn => todo!(),
-                crate::instructions::OpCode::Ftod => todo!(),
-                crate::instructions::OpCode::Dtof => todo!(),
-                crate::instructions::OpCode::Dceil => todo!(),
-                crate::instructions::OpCode::Dfloor => todo!(),
-                crate::instructions::OpCode::Dadd => todo!(),
-                crate::instructions::OpCode::Dsub => todo!(),
-                crate::instructions::OpCode::Dmul => todo!(),
-                crate::instructions::OpCode::Ddiv => todo!(),
-                crate::instructions::OpCode::Dmodr => todo!(),
-                crate::instructions::OpCode::Dmodq => todo!(),
-                crate::instructions::OpCode::Dsqrt => todo!(),
-                crate::instructions::OpCode::Dexp => todo!(),
-                crate::instructions::OpCode::Dlog => todo!(),
-                crate::instructions::OpCode::Dpow => todo!(),
-                crate::instructions::OpCode::Dsin => todo!(),
-                crate::instructions::OpCode::Dcos => todo!(),
-                crate::instructions::OpCode::Dtan => todo!(),
-                crate::instructions::OpCode::Dasin => todo!(),
-                crate::instructions::OpCode::Dacos => todo!(),
-                crate::instructions::OpCode::Datan => todo!(),
-                crate::instructions::OpCode::Datan2 => todo!(),
-                crate::instructions::OpCode::Jdeq => todo!(),
-                crate::instructions::OpCode::Jdne => todo!(),
-                crate::instructions::OpCode::Jdlt => todo!(),
-                crate::instructions::OpCode::Jdle => todo!(),
-                crate::instructions::OpCode::Jdgt => todo!(),
-                crate::instructions::OpCode::Jdge => todo!(),
-                crate::instructions::OpCode::Jdisnan => todo!(),
-                crate::instructions::OpCode::Jdisinf => todo!(),
+            let in_operands = instruction.in_operands.iter().map(|op| self.eval_source_operand(&op)).collect();
+            let no_store = OpCode::should_gen_return_stub(instruction.opcode.clone());
+            self.tmp_dest_oper = instruction.out_operands.get(0).cloned();
+
+            let result_values = OpCode::call_opcode(self, instruction.opcode, in_operands);
+
+            if !no_store {
+                instruction.out_operands.iter().enumerate().for_each(|(index, op)| self.store_dest_operand(&op, result_values[index]));
             }
         }
     }
 
-    fn call_function(&mut self, func_addr: FunctionPointer, args: Vec<u32>, dest_oper: &Operand) {
-        let (dest_type, dest_addr) = match dest_oper {
-            Operand::Constant(_) => (StubDestType::DoNotStore, 0),
-            Operand::PopStack => (StubDestType::PushOnStack, 0),
-            Operand::FrameIndirect(offset) => (StubDestType::LocalVariable, *offset),
-            Operand::MemIndirect(offset) => (StubDestType::MainMemory, *offset),
-            Operand::MemRamIndirect(offset) => (StubDestType::MainMemory, self.mem_writeable + *offset),
-        };
-
-        self.create_return_stub(dest_type, dest_addr, self.reg_program, self.reg_frame);
-
+    pub fn call_function(&mut self, func_addr: FunctionPointer, args: Vec<u32>) {
         let new_program_counter = self.create_stack_frame(func_addr, args);
         println!("Jumping to function at 0x{new_program_counter:04x}");
         self.reg_program = new_program_counter;
     }
 
-    fn create_return_stub(&mut self, dest_type: StubDestType, dest_addr: u32, program_counter: MemAddress, frame_pointer: StackAddress) {
+    pub fn create_return_stub(&mut self) {
+        let dest_oper = self.tmp_dest_oper.clone();
+        
+        let (dest_type, dest_addr) = match dest_oper {
+            None => (StubDestType::DoNotStore, 0),
+            Some(Operand::Constant(_)) => (StubDestType::DoNotStore, 0),
+            Some(Operand::PopStack) => (StubDestType::PushOnStack, 0),
+            Some(Operand::FrameIndirect(offset)) => (StubDestType::LocalVariable, offset),
+            Some(Operand::MemIndirect(offset)) => (StubDestType::MainMemory, offset),
+            Some(Operand::MemRamIndirect(offset)) => (StubDestType::MainMemory, self.mem_writeable + offset),
+        };
+
         self.push_stack(dest_type as u32);
         self.push_stack(dest_addr);
-        self.push_stack(program_counter);
-        self.push_stack(frame_pointer);
+        self.push_stack(self.reg_program);
+        self.push_stack(self.reg_frame);
     }
 
     // Returns program counter after parsing all the args
-    fn create_stack_frame(&mut self, func: FunctionPointer, mut args: Vec<u32>) -> MemAddress {
+    pub fn create_stack_frame(&mut self, func: FunctionPointer, mut args: Vec<u32>) -> MemAddress {
 
         // Reading function signature
         let func_type = self.get_byte(func, ReadWriteDest::Memory);
@@ -572,7 +221,7 @@ impl Interpreter {
         return opcode_start;
     }
 
-    fn return_from_function(&mut self, value: u32) {
+    pub fn return_from_function(&mut self, value: u32) {
         // Discard frame
         self.reg_stack = self.reg_frame - 4;
 
@@ -600,7 +249,7 @@ impl Interpreter {
         }
     }
 
-    fn jump_with_offset(&mut self, offset: u32) {
+    pub fn jump_with_offset(&mut self, offset: u32) {
         if offset == 1 || offset == 0 {
             return self.return_from_function(offset);
         }
@@ -616,12 +265,12 @@ impl Interpreter {
         self.reg_program = destination;
     }
 
-    fn push_stack(&mut self, value: u32) {
+    pub fn push_stack(&mut self, value: u32) {
         self.write_word(self.reg_stack, ReadWriteDest::Stack, value);
         self.reg_stack += 4;
     }
 
-    fn pop_stack(&mut self) -> u32 {
+    pub fn pop_stack(&mut self) -> u32 {
         self.reg_stack -= 4;
         self.get_word(self.reg_stack, ReadWriteDest::Stack)
     }
diff --git a/src/main.rs b/src/main.rs
index 4e97cd4..3aeb2e7 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -3,7 +3,6 @@ mod interpreter;
 mod glk;
 mod instructions;
 mod opcodes;
-use opcodes::OpCodes;
 
 use interpreter::Interpreter;
 use std::{env, fs, process::exit};
diff --git a/src/opcodes.rs b/src/opcodes.rs
index e8ef7fe..1fbc80f 100644
--- a/src/opcodes.rs
+++ b/src/opcodes.rs
@@ -1,7 +1,9 @@
 use opcode_proc::generate_opcodes;
 
+use crate::{glk::Glk, interpreter::Output};
+
 generate_opcodes!(
-    pub enum OpCodes {
+    pub enum OpCode {
         #[code(0x00)]
         fn Nop() {
             
@@ -17,11 +19,785 @@ generate_opcodes!(
             a - b
         },
 
+        #[code(0x12)]
+        fn Mul(a: u32, b: u32) -> u32 {
+            a * b
+        },
+
+        #[code(0x13)]
+        fn Div(a: u32, b: u32) -> u32 {
+            a / b
+        },
+
+        #[code(0x14)]
+        fn Mod(a: u32, b: u32) -> u32 {
+            a % b
+        },
+
+        #[code(0x15)]
+        fn Neg(a: u32) -> u32 {
+            -(a as i32) as u32
+        },
+
+        #[code(0x18)]
+        fn Bitand(a: u32, b: u32) -> u32 {
+            a & b
+        },
+
+        #[code(0x19)]
+        fn Bitor(a: u32, b: u32) -> u32 {
+            a | b
+        },
+
+        #[code(0x1A)]
+        fn Bitxor(a: u32, b: u32) -> u32 {
+            a ^ b
+        },
+
+        #[code(0x1B)]
+        fn Bitnot(a: u32) -> u32 {
+            !a
+        },
+
+        #[code(0x1C)]
+        fn Shiftl() {
+            todo!()
+        },
+
+        #[code(0x1D)]
+        fn Sshiftr() {
+            todo!()
+        },
+
+        #[code(0x1E)]
+        fn Ushiftr() {
+            todo!()
+        },
+
+        #[code(0x20)]
+        fn Jump() {
+            todo!()
+        },
+
+        #[code(0x22)]
+        fn Jz() {
+            todo!()
+        },
+
         #[code(0x23)]
         fn Jnz(&mut interpreter, comparison: u32, offset: u32) {
             if comparison != 0 {
-                interpreter.reg_program += offset;
+                interpreter.reg_program = interpreter.reg_program + offset - 2;
+            }
+        },
+
+        #[code(0x24)]
+        fn Jeq() {
+            todo!();
+        },
+
+        #[code(0x25)]
+        fn Jne() {
+            todo!();
+        },
+
+        #[code(0x26)]
+        fn Jlt() {
+            todo!();
+        },
+
+        #[code(0x27)]
+        fn Jge() {
+            todo!();
+        },
+
+        #[code(0x28)]
+        fn Jgt() {
+            todo!();
+        },
+
+        #[code(0x29)]
+        fn Jle() {
+            todo!();
+        },
+
+        #[code(0x2A)]
+        fn Jltu() {
+            todo!();
+        },
+
+        #[code(0x2B)]
+        fn Jgeu() {
+            todo!();
+        },
+
+        #[code(0x2C)]
+        fn Jgtu() {
+            todo!();
+        },
+
+        #[code(0x2D)]
+        fn Jleu() {
+            todo!();
+        },
+
+        #[code(0x30), no_store]
+        fn Call(&mut interpreter, func_addr: u32, arg_count: u32) -> u32 {
+            let args = (0..arg_count).map(|_| interpreter.pop_stack()).collect::<Vec<_>>();
+
+            interpreter.create_return_stub();
+            interpreter.call_function(func_addr, args);
+
+            // This gets ignored because of gen_return_stub but it's here for type reasons
+            return 0;
+        },
+
+        #[code(0x31)]
+        fn Return() {
+            todo!();
+        },
+
+        #[code(0x32)]
+        fn Catch() {
+            todo!();
+        },
+
+        #[code(0x33)]
+        fn Throw() {
+            todo!();
+        },
+
+        #[code(0x34)]
+        fn Tailcall() {
+            todo!();
+        },
+
+        #[code(0x40)]
+        fn Copy(param: u32) -> u32 {
+            return param
+        },
+
+        #[code(0x41)]
+        fn Copys() {
+            todo!();
+        },
+
+        #[code(0x42)]
+        fn Copyb() {
+            todo!();
+        },
+
+        #[code(0x44)]
+        fn Sexs() {
+            todo!();
+        },
+
+        #[code(0x45)]
+        fn Sexb() {
+            todo!();
+        },
+
+        #[code(0x48)]
+        fn Aload() {
+            todo!();
+        },
+
+        #[code(0x49)]
+        fn Aloads() {
+            todo!();
+        },
+
+        #[code(0x4A)]
+        fn Aloadb() {
+            todo!();
+        },
+
+        #[code(0x4B)]
+        fn Aloadbit() {
+            todo!();
+        },
+
+        #[code(0x4C)]
+        fn Astore() {
+            todo!();
+        },
+
+        #[code(0x4D)]
+        fn Astores() {
+            todo!();
+        },
+
+        #[code(0x4E)]
+        fn Astoreb() {
+            todo!();
+        },
+
+        #[code(0x4F)]
+        fn Astorebit() {
+            todo!();
+        },
+
+        #[code(0x50)]
+        fn Stkcount() {
+            todo!();
+        },
+
+        #[code(0x51)]
+        fn Stkpeek() {
+            todo!();
+        },
+
+        #[code(0x52)]
+        fn Stkswap() {
+            todo!();
+        },
+
+        #[code(0x53)]
+        fn Stkroll() {
+            todo!();
+        },
+
+        #[code(0x54)]
+        fn Stkcopy() {
+            todo!();
+        },
+
+        #[code(0x70)]
+        fn Streamchar() {
+            todo!();
+        },
+
+        #[code(0x71)]
+        fn Streamnum() {
+            todo!();
+        },
+
+        #[code(0x72)]
+        fn Streamstr() {
+            todo!();
+        },
+
+        #[code(0x73)]
+        fn Streamunichar() {
+            todo!();
+        },
+
+        #[code(0x100)]
+        fn Gestalt(gestalt_selector: u32, extra_arg: u32) -> u32 {
+            match gestalt_selector {
+                // IO System
+                4 => {
+                    return match extra_arg {
+                        // Null
+                        0 => 1,
+                        1 => 0,
+                        2 => 1,
+                        20 => 0,
+                        _ => 0,
+                    }
+                }
+
+                _ => {
+                    println!("WARN: Unknown gestalt {gestalt_selector}");
+                    return 0
+                }
+            }
+        },
+
+        #[code(0x101)]
+        fn Debugtrap() {
+            todo!();
+        },
+
+        #[code(0x102)]
+        fn Getmemsize() {
+            todo!();
+        },
+
+        #[code(0x103)]
+        fn Setmemsize() {
+            todo!();
+        },
+
+        #[code(0x104)]
+        fn Jumpabs() {
+            todo!();
+        },
+
+        #[code(0x110)]
+        fn Random() {
+            todo!();
+        },
+
+        #[code(0x111)]
+        fn Setrandom() {
+            todo!();
+        },
+
+        #[code(0x120)]
+        fn Quit() {
+            println!("Story exited");
+            std::process::exit(0);
+        },
+
+        #[code(0x121)]
+        fn Verify() {
+            todo!();
+        },
+
+        #[code(0x122)]
+        fn Restart() {
+            todo!();
+        },
+
+        #[code(0x123)]
+        fn Save() {
+            todo!();
+        },
+
+        #[code(0x124)]
+        fn Restore() {
+            todo!();
+        },
+
+        #[code(0x125)]
+        fn Saveundo() {
+            todo!();
+        },
+
+        #[code(0x126)]
+        fn Restoreundo() {
+            todo!();
+        },
+
+        #[code(0x127)]
+        fn Protect() {
+            todo!();
+        },
+
+        #[code(0x128)]
+        fn Hasundo() {
+            todo!();
+        },
+
+        #[code(0x129)]
+        fn Discardundo() {
+            todo!();
+        },
+
+        #[code(0x130)]
+        fn Glk() {
+            todo!();
+        },
+
+        #[code(0x140)]
+        fn Getstringtbl() {
+            todo!();
+        },
+
+        #[code(0x141)]
+        fn Setstringtbl() {
+            todo!();
+        },
+
+        #[code(0x148)]
+        fn Getiosys() {
+            todo!();
+        },
+
+        #[code(0x149)]
+        fn Setiosys(&mut interpreter, mode: u32, rock: u32) {
+            match mode {
+                0 => {
+                    interpreter.output_mode = Output::Null;
+                },
+                1 => {
+                    interpreter.output_mode = Output::Filter(rock);
+                },
+                2 => {
+                    interpreter.output_mode = Output::Glk(Glk {}, rock);
+                },
+                20 => {
+                    panic!("This interpreter does not support FyreVM");
+                },
+                _ => {
+                    panic!("Unknown iosys mode {mode}");
+                }
             }
+        },
+
+        #[code(0x150)]
+        fn Linearsearch() {
+            todo!();
+        },
+
+        #[code(0x151)]
+        fn Binarysearch() {
+            todo!();
+        },
+
+        #[code(0x152)]
+        fn Linkedsearch() {
+            todo!();
+        },
+
+        #[code(0x160), no_store]
+        fn Callf(&mut interpreter, func_addr: u32) -> u32 {
+            interpreter.create_return_stub();
+            interpreter.call_function(func_addr, Vec::new());
+
+            // This gets ignored because of gen_return_stub but it's here for type reasons
+            return 0;
+        },
+
+        #[code(0x161)]
+        fn Callfi() {
+            todo!();
+        },
+
+        #[code(0x162)]
+        fn Callfii() {
+            todo!();
+        },
+
+        #[code(0x163)]
+        fn Callfiii() {
+            todo!();
+        },
+
+        #[code(0x170)]
+        fn Mzero() {
+            todo!();
+        },
+
+        #[code(0x171)]
+        fn Mcopy() {
+            todo!();
+        },
+
+        #[code(0x178)]
+        fn Malloc() {
+            todo!();
+        },
+
+        #[code(0x179)]
+        fn Mfree() {
+            todo!();
+        },
+
+        #[code(0x180)]
+        fn Accelfunc() {
+            todo!();
+        },
+
+        #[code(0x181)]
+        fn Accelparam() {
+            todo!();
+        },
+
+        #[code(0x190)]
+        fn Numtof() {
+            todo!();
+        },
+
+        #[code(0x191)]
+        fn Ftonumz() {
+            todo!();
+        },
+
+        #[code(0x192)]
+        fn Ftonumn() {
+            todo!();
+        },
+
+        #[code(0x198)]
+        fn Ceil() {
+            todo!();
+        },
+
+        #[code(0x199)]
+        fn Floor() {
+            todo!();
+        },
+
+        #[code(0x1A0)]
+        fn Fadd() {
+            todo!();
+        },
+
+        #[code(0x1A1)]
+        fn Fsub() {
+            todo!();
+        },
+
+        #[code(0x1A2)]
+        fn Fmul() {
+            todo!();
+        },
+
+        #[code(0x1A3)]
+        fn Fdiv() {
+            todo!();
+        },
+
+        #[code(0x1A4)]
+        fn Fmod() {
+            todo!();
+        },
+
+        #[code(0x1A8)]
+        fn Sqrt() {
+            todo!();
+        },
+
+        #[code(0x1A9)]
+        fn Exp() {
+            todo!();
+        },
+
+        #[code(0x1AA)]
+        fn Log() {
+            todo!();
+        },
+
+        #[code(0x1AB)]
+        fn Pow() {
+            todo!();
+        },
+
+        #[code(0x1B0)]
+        fn Sin() {
+            todo!();
+        },
+
+        #[code(0x1B1)]
+        fn Cos() {
+            todo!();
+        },
+
+        #[code(0x1B2)]
+        fn Tan() {
+            todo!();
+        },
+
+        #[code(0x1B3)]
+        fn Asin() {
+            todo!();
+        },
+
+        #[code(0x1B4)]
+        fn Acos() {
+            todo!();
+        },
+
+        #[code(0x1B5)]
+        fn Atan() {
+            todo!();
+        },
+
+        #[code(0x1B6)]
+        fn Atan2() {
+            todo!();
+        },
+
+        #[code(0x1C0)]
+        fn Jfeq() {
+            todo!();
+        },
+
+        #[code(0x1C1)]
+        fn Jfne() {
+            todo!();
+        },
+
+        #[code(0x1C2)]
+        fn Jflt() {
+            todo!();
+        },
+
+        #[code(0x1C3)]
+        fn Jfle() {
+            todo!();
+        },
+
+        #[code(0x1C4)]
+        fn Jfgt() {
+            todo!();
+        },
+
+        #[code(0x1C5)]
+        fn Jfge() {
+            todo!();
+        },
+
+        #[code(0x1C8)]
+        fn Jisnan() {
+            todo!();
+        },
+
+        #[code(0x1C9)]
+        fn Jisinf() {
+            todo!();
+        },
+
+        #[code(0x200)]
+        fn Numtod() {
+            todo!();
+        },
+
+        #[code(0x201)]
+        fn Dtonumz() {
+            todo!();
+        },
+
+        #[code(0x202)]
+        fn Dtonumn() {
+            todo!();
+        },
+
+        #[code(0x203)]
+        fn Ftod() {
+            todo!();
+        },
+
+        #[code(0x204)]
+        fn Dtof() {
+            todo!();
+        },
+
+        #[code(0x208)]
+        fn Dceil() {
+            todo!();
+        },
+
+        #[code(0x209)]
+        fn Dfloor() {
+            todo!();
+        },
+
+        #[code(0x210)]
+        fn Dadd() {
+            todo!();
+        },
+
+        #[code(0x211)]
+        fn Dsub() {
+            todo!();
+        },
+
+        #[code(0x212)]
+        fn Dmul() {
+            todo!();
+        },
+
+        #[code(0x213)]
+        fn Ddiv() {
+            todo!();
+        },
+
+        #[code(0x214)]
+        fn Dmodr() {
+            todo!();
+        },
+
+        #[code(0x215)]
+        fn Dmodq() {
+            todo!();
+        },
+
+        #[code(0x218)]
+        fn Dsqrt() {
+            todo!();
+        },
+
+        #[code(0x219)]
+        fn Dexp() {
+            todo!();
+        },
+
+        #[code(0x21A)]
+        fn Dlog() {
+            todo!();
+        },
+
+        #[code(0x21B)]
+        fn Dpow() {
+            todo!();
+        },
+
+        #[code(0x220)]
+        fn Dsin() {
+            todo!();
+        },
+
+        #[code(0x221)]
+        fn Dcos() {
+            todo!();
+        },
+
+        #[code(0x222)]
+        fn Dtan() {
+            todo!();
+        },
+
+        #[code(0x223)]
+        fn Dasin() {
+            todo!();
+        },
+
+        #[code(0x224)]
+        fn Dacos() {
+            todo!();
+        },
+
+        #[code(0x225)]
+        fn Datan() {
+            todo!();
+        },
+
+        #[code(0x226)]
+        fn Datan2() {
+            todo!();
+        },
+
+        #[code(0x230)]
+        fn Jdeq() {
+            todo!();
+        },
+
+        #[code(0x231)]
+        fn Jdne() {
+            todo!();
+        },
+
+        #[code(0x232)]
+        fn Jdlt() {
+            todo!();
+        },
+
+        #[code(0x233)]
+        fn Jdle() {
+            todo!();
+        },
+
+        #[code(0x234)]
+        fn Jdgt() {
+            todo!();
+        },
+
+        #[code(0x235)]
+        fn Jdge() {
+            todo!();
+        },
+
+        #[code(0x238)]
+        fn Jdisnan() {
+            todo!();
+        },
+
+        #[code(0x239)]
+        fn Jdisinf() {
+            todo!();
         }
     }
 );