added even more opeartions to the VM

src/virtualmachine.rs

@@ -519,12 +519,91 @@ impl Machine {
                 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 => {
                     do_operation_operation(&mut self.registers, &mut self.memory, operation);
                 },
+                24 => {
+                    //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 mem2.is_none() {
+                        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);
+                    }
+                    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)) => {
+                            bool2.value = !bool1.value;
+                        },
+                        _ => panic!("Invalid memory types for NOT operation"),
+                    }
+                },
+                25 => {
+                    //JMP
+                    self.pc = operation.arg2 as usize;
+                },
+                26 => {
+                    //CJP
+                    let reg = get_register_by_id(&self.registers, operation.arg1);
+                    if reg.is_none() {
+                        panic!("Register {} not found", operation.arg1);
+                    }
+                    let reg = reg.unwrap();
+                    let mem = get_mem_pos_by_var_id(&self.memory, reg.pointer as u32);
+                    if mem.is_none() {
+                        panic!("Memory location not found for register");
+                    }
+                    let mem = mem.unwrap();
+                    match &self.memory[mem] {
+                        VMMemory::Boolean(bool) => {
+                            if bool.value {
+                                self.pc = operation.arg2 as usize;
+                            }
+                        }
+                        _ => panic!("Invalid memory type for CJP operation"),
+                    }
+                },
+                27 => {
+                    //CAL
+                    //not implemented yet
+                },
+                28 => {
+                    //PSH
+                    let reg = get_register_by_id(&self.registers, operation.arg1);
+                    if reg.is_none() {
+                        panic!("Register {} not found", operation.arg1);
+                    }
+                    let reg = reg.unwrap();
+                    let mem = get_mem_pos_by_var_id(&self.memory, reg.pointer as u32);
+                    if mem.is_none() {
+                        panic!("Memory location not found for register");
+                    }
+                    let mem = mem.unwrap();
+                    self.stack.push(self.memory[mem].clone());
+                },
                 29 => {
                     //RET
                     //not implemented yet
                 },
-                _ => panic!("Unknown opcode: {}", main_func.body[self.pc].opcode),
-                
+                30 => {
+                    //not implemented yet
+                },
+                31 => {
+                    //GET
+                    //not implemented yet
+                },
+                32 => {
+                    //SET
+                    //not implemented yet
+                },
+                _ => {
+                    panic!("Unknown operation code: {}", operation.opcode);
+                }
             }
         }
     }