From 749ba9a1a982990746b35cd798d28154a65f2761 Mon Sep 17 00:00:00 2001
From: afonya2 <adamhir@freemail.hu>
Date: Sun, 1 Jun 2025 17:07:41 +0200
Subject: [PATCH] fixing

---
 src/main.rs           |  1 +
 src/virtualmachine.rs | 53 ++++++++++++++++++++++---------------------
 test.as               |  3 ++-
 3 files changed, 30 insertions(+), 27 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index ec74c01..576ca01 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -131,6 +131,7 @@ fn main() {
             let mut vm = Machine::new();
             vm.load(compiled);
             vm.run();
+            println!("\n");
             println!("Registers: {:?}", vm.registers);
             println!("Program Counter: {}", vm.pc);
             println!("Memory: {:?}", vm.memory);
diff --git a/src/virtualmachine.rs b/src/virtualmachine.rs
index 8090dd3..409d00a 100644
--- a/src/virtualmachine.rs
+++ b/src/virtualmachine.rs
@@ -181,26 +181,28 @@ fn do_operation_operation(registers: &mut Vec<Register>, memory: &mut Vec<VMMemo
     let reg1 = get_register_by_id(registers, operation.arg1);
     let reg2 = get_register_by_id(registers, operation.arg2 as u8);
     let reg3 = get_register_by_id(registers, operation.arg3);
-    let mem1 = get_mem_pos_by_var_id(memory, reg1.unwrap().pointer as u32);
-    let mem2 = get_mem_pos_by_var_id(memory, reg2.unwrap().pointer as u32);
-    let mut mem3 = get_mem_pos_by_var_id(memory, reg3.unwrap().pointer as u32);
-    if mem1.is_none() || mem2.is_none() {
+    if reg1.is_none() || reg2.is_none() || reg3.is_none() {
+        panic!("One or more registers not found for operation");
+    }
+    let mem1 = reg1.unwrap().pointer;
+    let mem2 = reg2.unwrap().pointer;
+    let mut mem3 = reg3.unwrap().pointer;
+    if memory.get(mem1).is_none() || memory.get(mem2).is_none() {
         panic!("Memory location not found for registers");
     }
-    let mem1 = mem1.unwrap();
-    if mem3.is_none() {
+    if reg3.unwrap().pointer == 0 {
         match operation.opcode {
             10 => {
-                match memory[mem1] {
+                match memory.get(mem1).unwrap() {
                     VMMemory::String(_) => {
                         memory.push(VMMemory::String(VMMemoryString { value: String::new(), variable_id: 0 }));
                         set_register(registers, Register { id: operation.arg3, pointer: memory.len() - 1 });
-                        mem3 = Some(memory.len() - 1);
+                        mem3 = memory.len() - 1;
                     }
                     VMMemory::Number(_) => {
                         memory.push(VMMemory::Number(VMMemoryNumber { value: 0, variable_id: 0 }));
                         set_register(registers, Register { id: operation.arg3, pointer: memory.len() - 1 });
-                        mem3 = Some(memory.len() - 1);
+                        mem3 = memory.len() - 1;
                     }
                     _ => {
                         panic!("Invalid memory type for operation");
@@ -210,18 +212,16 @@ fn do_operation_operation(registers: &mut Vec<Register>, memory: &mut Vec<VMMemo
             11 | 12 | 13 | 14 | 15 => {
                 memory.push(VMMemory::Number(VMMemoryNumber { value: 0, variable_id: 0 }));
                 set_register(registers, Register { id: operation.arg3, pointer: memory.len() - 1 });
-                mem3 = Some(memory.len() - 1);
+                mem3 = memory.len() - 1;
             },
             16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 => {
                 memory.push(VMMemory::Boolean(VMMemoryBoolean { value: false, variable_id: 0 }));
                 set_register(registers, Register { id: operation.arg3, pointer: memory.len() - 1 });
-                mem3 = Some(memory.len() - 1);
+                mem3 = memory.len() - 1;
             },
             _ => {}
         }
     }
-    let mem2 = mem2.unwrap();
-    let mem3 = mem3.unwrap();
     let temp_mem = memory.clone();
     match (&temp_mem[mem1], &temp_mem[mem2], &mut memory[mem3]) {
         (VMMemory::Number(num1), VMMemory::Number(num2), VMMemory::Number(num3)) => {
@@ -312,7 +312,7 @@ fn do_operation_operation(registers: &mut Vec<Register>, memory: &mut Vec<VMMemo
 impl Machine {
     pub fn new() -> Self {
         let mut registers = Vec::new();
-        for i in 1..17 {
+        for i in 0..17 {
             registers.push(Register {
                 id: i,
                 pointer: 0,
@@ -523,18 +523,19 @@ impl Machine {
                     //NOT
                     let reg1 = get_register_by_id(&self.registers, operation.arg1);
                     let reg2 = get_register_by_id(&self.registers, operation.arg2 as u8);
-                    let mem1 = get_mem_pos_by_var_id(&self.memory, reg1.unwrap().pointer as u32);
-                    let mut mem2 = get_mem_pos_by_var_id(&self.memory, reg2.unwrap().pointer as u32);
-                    if mem1.is_none() {
-                        panic!("Memory location not found for register");
+                    if reg1.is_none() || reg2.is_none() {
+                        panic!("One or more registers not found for NOT operation");
                     }
-                    if mem2.is_none() {
+                    let mem1 = reg1.unwrap().pointer;
+                    let mut mem2 = reg2.unwrap().pointer;
+                    if self.memory.get(mem1).is_none() {
+                        panic!("Memory location not found for register {}", operation.arg1);
+                    }
+                    if reg2.unwrap().pointer == 0 {
                         self.memory.push(VMMemory::Boolean(VMMemoryBoolean { value: false, variable_id: 0 }));
                         set_register(&mut self.registers, Register { id: operation.arg3, pointer: self.memory.len() - 1 });
-                        mem2 = Some(self.memory.len() - 1);
+                        mem2 = self.memory.len() - 1;
                     }
-                    let mem1 = mem1.unwrap();
-                    let mem2 = mem2.unwrap();
                     let temp_mem = self.memory.clone();
                     match (&temp_mem[mem1], &mut self.memory[mem2]) {
                         (VMMemory::Boolean(bool1), VMMemory::Boolean(bool2)) => {
@@ -554,12 +555,12 @@ impl Machine {
                         panic!("Register {} not found", operation.arg1);
                     }
                     let reg = reg.unwrap();
-                    let mem = get_mem_pos_by_var_id(&self.memory, reg.pointer as u32);
+                    let mem = self.memory.get(reg.pointer);
                     if mem.is_none() {
                         panic!("Memory location not found for register");
                     }
                     let mem = mem.unwrap();
-                    match &self.memory[mem] {
+                    match &mem {
                         VMMemory::Boolean(bool) => {
                             if bool.value {
                                 self.pc = operation.arg2 as usize;
@@ -579,12 +580,12 @@ impl Machine {
                         panic!("Register {} not found", operation.arg1);
                     }
                     let reg = reg.unwrap();
-                    let mem = get_mem_pos_by_var_id(&self.memory, reg.pointer as u32);
+                    let mem = self.memory.get(reg.pointer);
                     if mem.is_none() {
                         panic!("Memory location not found for register");
                     }
                     let mem = mem.unwrap();
-                    self.stack.push(self.memory[mem].clone());
+                    self.stack.push(mem.clone());
                 },
                 29 => {
                     //RET
diff --git a/test.as b/test.as
index 54fe6f1..0dbfba3 100644
--- a/test.as
+++ b/test.as
@@ -1 +1,2 @@
-gethelj a = 1
\ No newline at end of file
+gethelj a = 1
+gethelj b = (a + 2) * 3
\ No newline at end of file