835 lines
No EOL
45 KiB
Rust
835 lines
No EOL
45 KiB
Rust
use std::{any::Any, collections::HashMap, process, vec};
|
|
use crate::{decompiler::{operation_to_name, process, DecompiledFunction, DecompiledOperation}, enviroment, errors::{create_error, print_error, ASLError, ErrorSubType, ErrorType}, Context};
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum VMMemory {
|
|
String(VMMemoryString),
|
|
Number(VMMemoryNumber),
|
|
Boolean(VMMemoryBoolean),
|
|
Function(VMMemoryFunction),
|
|
Null(VMMemoryNull),
|
|
Table(VMMemoryTable),
|
|
NativeFunction(VMMemoryNativeFunction),
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct VMMemoryString {
|
|
pub value: String,
|
|
pub variable_id: u32,
|
|
}
|
|
#[derive(Debug, Clone)]
|
|
pub struct VMMemoryNumber {
|
|
pub value: f64,
|
|
pub variable_id: u32,
|
|
}
|
|
#[derive(Debug, Clone)]
|
|
pub struct VMMemoryBoolean {
|
|
pub value: bool,
|
|
pub variable_id: u32,
|
|
}
|
|
#[derive(Debug, Clone)]
|
|
pub struct VMMemoryFunction {
|
|
pub id: usize,
|
|
pub variable_id: u32,
|
|
}
|
|
#[derive(Debug, Clone)]
|
|
pub struct VMMemoryNull {
|
|
pub variable_id: u32,
|
|
}
|
|
#[derive(Debug, Clone)]
|
|
pub struct VMMemoryTable {
|
|
pub values: Vec<TableValue>,
|
|
pub variable_id: u32,
|
|
}
|
|
#[derive(Debug, Clone)]
|
|
pub struct TableValue {
|
|
pub key: VMMemory,
|
|
pub value: VMMemory
|
|
}
|
|
#[derive(Debug, Clone)]
|
|
pub struct VMMemoryNativeFunction {
|
|
pub func: fn(&mut Machine, &DecompiledOperation, Vec<VMMemory>) -> VMMemory,
|
|
pub variable_id: u32,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct Register {
|
|
id: u8,
|
|
pointer: usize
|
|
}
|
|
|
|
pub struct CallStack {
|
|
pub func: usize,
|
|
pub return_reg: usize,
|
|
pub pc: usize,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
enum VMState {
|
|
Running,
|
|
Paused,
|
|
Finished,
|
|
Error(ASLError),
|
|
}
|
|
|
|
pub struct Machine {
|
|
pub memory: Vec<VMMemory>,
|
|
functions: Vec<DecompiledFunction>,
|
|
pub stack: Vec<VMMemory>,
|
|
pub registers: Vec<Register>,
|
|
pub call_stack: Vec<CallStack>,
|
|
pub env: HashMap<String, VMMemory>,
|
|
pub ctx: Vec<Context>,
|
|
pub storage: Vec<Box<dyn Any>>,
|
|
pub state: VMState,
|
|
}
|
|
|
|
fn get_register_by_id(registers: &Vec<Register>, id: u8) -> Option<&Register> {
|
|
for reg in registers {
|
|
if reg.id == id {
|
|
return Some(reg);
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
fn set_register(registers: &mut Vec<Register>, new_register: Register) {
|
|
if new_register.id == 0 {
|
|
return;
|
|
}
|
|
for (i, reg) in registers.iter().enumerate() {
|
|
if reg.id == new_register.id {
|
|
registers[i] = new_register;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn get_mem_pos_by_var_id(memory: &Vec<VMMemory>, var_id: u32) -> Option<usize> {
|
|
for i in 0..memory.len() {
|
|
match &memory[i] {
|
|
VMMemory::String(str) if str.variable_id == var_id => return Some(i),
|
|
VMMemory::Number(num) if num.variable_id == var_id => return Some(i),
|
|
VMMemory::Boolean(bool) if bool.variable_id == var_id => return Some(i),
|
|
VMMemory::Null(null) if null.variable_id == var_id => return Some(i),
|
|
VMMemory::Function(func) if func.variable_id == var_id => return Some(i),
|
|
VMMemory::Table(tbl) if tbl.variable_id == var_id => return Some(i),
|
|
VMMemory::NativeFunction(func) if func.variable_id == var_id => return Some(i),
|
|
_ => continue
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
fn set_mem_tbl_val(tbl: &mut VMMemoryTable, key: VMMemory, value: VMMemory) {
|
|
for i in 0..tbl.values.len() {
|
|
let found = match (&tbl.values[i].key, &key) {
|
|
(VMMemory::Number(num1), VMMemory::Number(num2)) => num1.value == num2.value,
|
|
(VMMemory::String(str1), VMMemory::String(str2)) => str1.value == str2.value,
|
|
(VMMemory::Boolean(bool1), VMMemory::Boolean(bool2)) => bool1.value == bool2.value,
|
|
(VMMemory::Null(_), VMMemory::Null(_)) => true,
|
|
(VMMemory::Function(_), VMMemory::Function(_)) => false,
|
|
(VMMemory::Table(_), VMMemory::Table(_)) => false,
|
|
(VMMemory::NativeFunction(_), VMMemory::NativeFunction(_)) => false,
|
|
_ => false,
|
|
};
|
|
if found {
|
|
tbl.values[i].value = value;
|
|
return;
|
|
}
|
|
}
|
|
tbl.values.push(TableValue { key, value });
|
|
}
|
|
|
|
fn get_mem_tbl_val(tbl: &VMMemoryTable, key: VMMemory) -> Option<&VMMemory> {
|
|
for i in 0..tbl.values.len() {
|
|
let found = match (&tbl.values[i].key, &key) {
|
|
(VMMemory::Number(num1), VMMemory::Number(num2)) => num1.value == num2.value,
|
|
(VMMemory::String(str1), VMMemory::String(str2)) => str1.value == str2.value,
|
|
(VMMemory::Boolean(bool1), VMMemory::Boolean(bool2)) => bool1.value == bool2.value,
|
|
(VMMemory::Null(_), VMMemory::Null(_)) => true,
|
|
(VMMemory::Function(_), VMMemory::Function(_)) => false,
|
|
(VMMemory::Table(_), VMMemory::Table(_)) => false,
|
|
(VMMemory::NativeFunction(_), VMMemory::NativeFunction(_)) => false,
|
|
_ => false,
|
|
};
|
|
if found {
|
|
return Some(&tbl.values[i].value);
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
fn get_var_id(var: &VMMemory) -> u32 {
|
|
match var {
|
|
VMMemory::String(str) => str.variable_id,
|
|
VMMemory::Number(num) => num.variable_id,
|
|
VMMemory::Boolean(bool) => bool.variable_id,
|
|
VMMemory::Null(null) => null.variable_id,
|
|
VMMemory::Function(func) => func.variable_id,
|
|
VMMemory::Table(tbl) => tbl.variable_id,
|
|
VMMemory::NativeFunction(func) => func.variable_id,
|
|
}
|
|
}
|
|
|
|
fn set_var_id(var: &mut VMMemory, target: u32) {
|
|
match var {
|
|
VMMemory::String(str) => str.variable_id = target,
|
|
VMMemory::Number(num) => num.variable_id = target,
|
|
VMMemory::Boolean(bool) => bool.variable_id = target,
|
|
VMMemory::Null(null) => null.variable_id = target,
|
|
VMMemory::Function(func) => func.variable_id = target,
|
|
VMMemory::Table(tbl) => tbl.variable_id = target,
|
|
VMMemory::NativeFunction(func) => func.variable_id = target,
|
|
}
|
|
}
|
|
|
|
fn do_operation_operation(registers: &mut Vec<Register>, memory: &mut Vec<VMMemory>, operation: &DecompiledOperation, ctx: &Context) {
|
|
let reg_clone = registers.clone();
|
|
let reg1 = get_register_by_id(®_clone, operation.arg1);
|
|
let reg2 = get_register_by_id(®_clone, operation.arg2 as u8);
|
|
let reg3 = get_register_by_id(®_clone, operation.arg3);
|
|
if reg1.is_none() || reg2.is_none() || reg3.is_none() {
|
|
let err = create_error(&format!("One or more registers not found for operation"), operation.pos, ErrorType::MachineError, ErrorSubType::RegisterNotFound, ctx);
|
|
print_error(&err, &ctx);
|
|
process::exit(1);
|
|
}
|
|
let mem1 = reg1.unwrap().pointer;
|
|
let mem2 = reg2.unwrap().pointer;
|
|
if mem1 >= memory.len() || mem2 >= memory.len() || mem1 < 1 || mem2 < 1 {
|
|
let err = create_error(&format!("Memory location out of bounds `{}` or `{}`", mem1, mem2), operation.pos, ErrorType::MachineError, ErrorSubType::MemoryOutOfBounds, ctx);
|
|
print_error(&err, &ctx);
|
|
process::exit(1);
|
|
}
|
|
let mut result: VMMemory;
|
|
match (&memory[mem1], &memory[mem2]) {
|
|
(VMMemory::Number(num1), VMMemory::Number(num2)) => {
|
|
match operation.opcode {
|
|
10 => {
|
|
result = VMMemory::Number(VMMemoryNumber { value: num1.value + num2.value, variable_id: 0 });
|
|
},
|
|
11 => {
|
|
result = VMMemory::Number(VMMemoryNumber { value: num1.value - num2.value, variable_id: 0 });
|
|
},
|
|
12 => {
|
|
result = VMMemory::Number(VMMemoryNumber { value: num1.value * num2.value, variable_id: 0 });
|
|
},
|
|
13 => {
|
|
if num2.value == 0.0 {
|
|
let err = create_error(&format!("Division by zero"), operation.pos, ErrorType::MathError, ErrorSubType::DivisionByZero, ctx);
|
|
print_error(&err, &ctx);
|
|
process::exit(1);
|
|
}
|
|
result = VMMemory::Number(VMMemoryNumber { value: num1.value / num2.value, variable_id: 0 });
|
|
},
|
|
14 => {
|
|
result = VMMemory::Number(VMMemoryNumber { value: num1.value.powf(num2.value), variable_id: 0 });
|
|
},
|
|
15 => {
|
|
result = VMMemory::Number(VMMemoryNumber { value: num1.value % num2.value, variable_id: 0 });
|
|
},
|
|
18 => {
|
|
result = VMMemory::Boolean(VMMemoryBoolean { value: num1.value == num2.value, variable_id: 0 });
|
|
},
|
|
19 => {
|
|
result = VMMemory::Boolean(VMMemoryBoolean { value: num1.value != num2.value, variable_id: 0 });
|
|
},
|
|
20 => {
|
|
result = VMMemory::Boolean(VMMemoryBoolean { value: num1.value > num2.value, variable_id: 0 });
|
|
},
|
|
21 => {
|
|
result = VMMemory::Boolean(VMMemoryBoolean { value: num1.value >= num2.value, variable_id: 0 });
|
|
},
|
|
22 => {
|
|
result = VMMemory::Boolean(VMMemoryBoolean { value: num1.value < num2.value, variable_id: 0 });
|
|
},
|
|
23 => {
|
|
result = VMMemory::Boolean(VMMemoryBoolean { value: num1.value <= num2.value, variable_id: 0 });
|
|
},
|
|
_ => {
|
|
let err = create_error(&format!("Unknown operation code for number operation: `{}`", operation.opcode), operation.pos, ErrorType::MachineError, ErrorSubType::UnknownOPCode, ctx);
|
|
print_error(&err, &ctx);
|
|
process::exit(1);
|
|
}
|
|
};
|
|
},
|
|
(VMMemory::String(str1), VMMemory::String(str2)) => {
|
|
match operation.opcode {
|
|
10 => {
|
|
result = VMMemory::String(VMMemoryString { value: str1.value.clone() + &str2.value, variable_id: 0 });
|
|
},
|
|
18 => {
|
|
result = VMMemory::Boolean(VMMemoryBoolean { value: str1.value == str2.value, variable_id: 0 });
|
|
},
|
|
19 => {
|
|
result = VMMemory::Boolean(VMMemoryBoolean { value: str1.value != str2.value, variable_id: 0 });
|
|
},
|
|
_ => {
|
|
let err = create_error(&format!("Unknown operation code for string operation: `{}`", operation.opcode), operation.pos, ErrorType::MachineError, ErrorSubType::UnknownOPCode, ctx);
|
|
print_error(&err, &ctx);
|
|
process::exit(1);
|
|
}
|
|
};
|
|
},
|
|
(VMMemory::Boolean(bool1), VMMemory::Boolean(bool2)) => {
|
|
match operation.opcode {
|
|
16 => {
|
|
result = VMMemory::Boolean(VMMemoryBoolean { value: bool1.value && bool2.value, variable_id: 0 });
|
|
},
|
|
17 => {
|
|
result = VMMemory::Boolean(VMMemoryBoolean { value: bool1.value || bool2.value, variable_id: 0 });
|
|
},
|
|
18 => {
|
|
result = VMMemory::Boolean(VMMemoryBoolean { value: bool1.value == bool2.value, variable_id: 0 });
|
|
},
|
|
19 => {
|
|
result = VMMemory::Boolean(VMMemoryBoolean { value: bool1.value != bool2.value, variable_id: 0 });
|
|
},
|
|
_ => {
|
|
let err = create_error(&format!("Unknown operation code for boolean operation: `{}`", operation.opcode), operation.pos, ErrorType::MachineError, ErrorSubType::UnknownOPCode, ctx);
|
|
print_error(&err, &ctx);
|
|
process::exit(1);
|
|
}
|
|
};
|
|
},
|
|
(VMMemory::Null(_), VMMemory::Null(_)) => {
|
|
match operation.opcode {
|
|
18 => {
|
|
result = VMMemory::Boolean(VMMemoryBoolean { value: true, variable_id: 0 });
|
|
},
|
|
19 => {
|
|
result = VMMemory::Boolean(VMMemoryBoolean { value: false, variable_id: 0 });
|
|
},
|
|
_ => {
|
|
let err = create_error(&format!("Unknown operation code for null operation: `{}`", operation.opcode), operation.pos, ErrorType::MachineError, ErrorSubType::UnknownOPCode, ctx);
|
|
print_error(&err, &ctx);
|
|
process::exit(1);
|
|
}
|
|
};
|
|
},
|
|
_ => {
|
|
let err = create_error(&format!("Wrong memory types for operation: `{}`, position: `{}` and `{}`", operation_to_name(operation.opcode), mem1, mem2), operation.pos, ErrorType::TypeError, ErrorSubType::WrongType, ctx);
|
|
print_error(&err, &ctx);
|
|
process::exit(1);
|
|
}
|
|
}
|
|
let mut reg3_pointer = reg3.unwrap().pointer;
|
|
if reg3_pointer < 1 {
|
|
reg3_pointer = memory.len();
|
|
memory.push(VMMemory::Null(VMMemoryNull { variable_id: 0 }));
|
|
set_register(registers, Register { id: operation.arg3, pointer: reg3_pointer });
|
|
}
|
|
let var_id = get_var_id(&memory[reg3_pointer]);
|
|
set_var_id(&mut result, var_id);
|
|
memory[reg3_pointer] = result;
|
|
}
|
|
|
|
impl Machine {
|
|
pub fn new(ctx: Vec<Context>) -> Self {
|
|
let mut registers = Vec::new();
|
|
for i in 0..16 {
|
|
registers.push(Register {
|
|
id: i,
|
|
pointer: 0,
|
|
});
|
|
}
|
|
return Machine {
|
|
memory: vec![
|
|
VMMemory::Null(VMMemoryNull { variable_id: 0 })
|
|
],
|
|
functions: Vec::new(),
|
|
stack: Vec::new(),
|
|
registers: registers,
|
|
call_stack: vec![CallStack {
|
|
func: 0,
|
|
return_reg: 0,
|
|
pc: 0,
|
|
}],
|
|
env: enviroment::generate(),
|
|
ctx: ctx,
|
|
storage: Vec::new(),
|
|
state: VMState::Finished
|
|
};
|
|
}
|
|
|
|
pub fn load(&mut self, data: &Vec<u8>) {
|
|
let dec = process(data);
|
|
self.functions = dec.functions;
|
|
self.state = VMState::Paused
|
|
}
|
|
|
|
pub fn resume(&mut self) {
|
|
match self.state {
|
|
VMState::Paused => {},
|
|
_ => {
|
|
panic!("Unable to resume VM, current state is not paused");
|
|
}
|
|
};
|
|
if self.call_stack.len() == 0 {
|
|
return;
|
|
}
|
|
let func_clone = self.functions.clone();
|
|
let executed_func = func_clone.get(self.call_stack[self.call_stack.len()-1].func);
|
|
let mut executed_stack = self.call_stack.len()-1;
|
|
if executed_func.is_none() {
|
|
let err = create_error(&format!("Current function not found"), 1, ErrorType::MachineError, ErrorSubType::UnknownFunction, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
let mut executed_func = executed_func.unwrap();
|
|
self.state = VMState::Running;
|
|
while self.call_stack[executed_stack].pc < executed_func.body.len() {
|
|
match self.state {
|
|
VMState::Running => {},
|
|
_ => {
|
|
return;
|
|
}
|
|
};
|
|
let operation = &executed_func.body[self.call_stack[executed_stack].pc];
|
|
self.call_stack[executed_stack].pc += 1;
|
|
match operation.opcode {
|
|
0 => {
|
|
//HLT
|
|
return;
|
|
},
|
|
1 => {
|
|
//LDS
|
|
let str = executed_func.strings.get(&(operation.arg2 as u32));
|
|
if str.is_none() {
|
|
let err = create_error(&format!("String with ID `{}` not found", operation.arg2), operation.pos, ErrorType::MachineError, ErrorSubType::UnknownString, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
let str = str.unwrap();
|
|
self.memory.push(VMMemory::String(VMMemoryString { value: str.clone(), variable_id: 0 }));
|
|
set_register(&mut self.registers, Register { id: operation.arg1, pointer: self.memory.len() - 1 });
|
|
},
|
|
2 => {
|
|
//LDM
|
|
let mem = get_mem_pos_by_var_id(&self.memory, operation.arg2 as u32);
|
|
if mem.is_none() {
|
|
let err = create_error(&format!("Memory with variable ID `{}` not found", operation.arg2), operation.pos, ErrorType::MachineError, ErrorSubType::UnknownMemoryLocation, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
let mem = mem.unwrap();
|
|
if mem >= self.memory.len() || mem < 1 {
|
|
let err = create_error(&format!("Memory location out of bounds for variable ID `{}`", operation.arg2), operation.pos, ErrorType::MachineError, ErrorSubType::MemoryOutOfBounds, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
let mut nmem = self.memory[mem].clone();
|
|
match &mut nmem {
|
|
VMMemory::Number(num) => {
|
|
num.variable_id = 0;
|
|
},
|
|
VMMemory::String(str) => {
|
|
str.variable_id = 0;
|
|
},
|
|
VMMemory::Boolean(bool) => {
|
|
bool.variable_id = 0;
|
|
},
|
|
VMMemory::Null(null) => {
|
|
null.variable_id = 0;
|
|
},
|
|
VMMemory::Function(func) => {
|
|
func.variable_id = 0;
|
|
},
|
|
VMMemory::Table(tbl) => {
|
|
tbl.variable_id = 0;
|
|
},
|
|
VMMemory::NativeFunction(func) => {
|
|
func.variable_id = 0;
|
|
},
|
|
}
|
|
self.memory.push(nmem);
|
|
set_register(&mut self.registers, Register { id: operation.arg1, pointer: self.memory.len() - 1 });
|
|
},
|
|
3 => {
|
|
//LDI
|
|
self.memory.push(VMMemory::Number(VMMemoryNumber { value: operation.arg2, variable_id: 0 }));
|
|
set_register(&mut self.registers, Register { id: operation.arg1, pointer: self.memory.len() - 1 });
|
|
},
|
|
4 => {
|
|
//LDB
|
|
self.memory.push(VMMemory::Boolean(VMMemoryBoolean { value: operation.arg2 != 0.0, variable_id: 0 }));
|
|
set_register(&mut self.registers, Register { id: operation.arg1, pointer: self.memory.len() - 1 });
|
|
},
|
|
5 => {
|
|
//LDF
|
|
let func_pos = executed_func.functions.get(&(operation.arg2 as u32));
|
|
if func_pos.is_none() {
|
|
let err = create_error(&format!("Function with ID `{}` not found", operation.arg2), operation.pos, ErrorType::MachineError, ErrorSubType::UnknownFunction, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
let func_pos = func_pos.unwrap();
|
|
let func = self.functions.get(*func_pos as usize);
|
|
if func.is_none() {
|
|
let err = create_error(&format!("Function with position `{}` not found", func_pos), operation.pos, ErrorType::MachineError, ErrorSubType::UnknownFunction, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
self.memory.push(VMMemory::Function(VMMemoryFunction {
|
|
id: *func_pos as usize,
|
|
variable_id: 0,
|
|
}));
|
|
set_register(&mut self.registers, Register { id: operation.arg1, pointer: self.memory.len() - 1 });
|
|
},
|
|
6 => {
|
|
//LDN
|
|
if operation.arg2 > 0.0 {
|
|
self.memory.push(VMMemory::Table(VMMemoryTable { values: vec![], variable_id: 0 }));
|
|
set_register(&mut self.registers, Register { id: operation.arg1, pointer: self.memory.len() - 1 });
|
|
} else {
|
|
self.memory.push(VMMemory::Null(VMMemoryNull { variable_id: 0 }));
|
|
set_register(&mut self.registers, Register { id: operation.arg1, pointer: self.memory.len() - 1 });
|
|
}
|
|
},
|
|
7 => {
|
|
//ASS
|
|
let reg = get_register_by_id(&self.registers, operation.arg1);
|
|
if reg.is_none() {
|
|
let err = create_error(&format!("Register `{}` not found", operation.arg1), operation.pos, ErrorType::MachineError, ErrorSubType::RegisterNotFound, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
let reg = reg.unwrap();
|
|
if reg.pointer >= self.memory.len() || reg.pointer < 1 {
|
|
let err = create_error(&format!("Register `{}` points to an invalid memory location", operation.arg1), operation.pos, ErrorType::MachineError, ErrorSubType::MemoryOutOfBounds, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
let used_var = get_mem_pos_by_var_id(&self.memory, operation.arg2 as u32);
|
|
if let Some(pos) = used_var {
|
|
set_var_id(&mut self.memory[pos], 0);
|
|
}
|
|
set_var_id(&mut self.memory[reg.pointer], operation.arg2 as u32);
|
|
},
|
|
8 => {
|
|
//UNB
|
|
set_register(&mut self.registers, Register { id: operation.arg1, pointer: 0 });
|
|
},
|
|
9 => {
|
|
//MOV
|
|
let temp_regs = self.registers.clone();
|
|
let reg1 = get_register_by_id(&temp_regs, operation.arg1);
|
|
if reg1.is_none() {
|
|
let err = create_error(&format!("Register `{}` not found", operation.arg1), operation.pos, ErrorType::MachineError, ErrorSubType::RegisterNotFound, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
let reg1 = reg1.unwrap();
|
|
set_register(&mut self.registers, Register { id: operation.arg2 as u8, pointer: reg1.pointer });
|
|
},
|
|
10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 => {
|
|
do_operation_operation(&mut self.registers, &mut self.memory, operation, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
},
|
|
24 => {
|
|
//NOT
|
|
let reg_clone = self.registers.clone();
|
|
let reg1 = get_register_by_id(®_clone, operation.arg1);
|
|
let reg2 = get_register_by_id(®_clone, operation.arg2 as u8);
|
|
if reg1.is_none() || reg2.is_none() {
|
|
let err = create_error(&format!("Register `{}` or `{}` not found", operation.arg1, operation.arg2), operation.pos, ErrorType::MachineError, ErrorSubType::RegisterNotFound, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
let mem1 = reg1.unwrap().pointer;
|
|
if mem1 >= self.memory.len() || mem1 < 1 {
|
|
let err = create_error(&format!("Memory location out of bounds for register `{}`", operation.arg1), operation.pos, ErrorType::MachineError, ErrorSubType::MemoryOutOfBounds, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
let mut result: VMMemory;
|
|
match &self.memory[mem1] {
|
|
VMMemory::Boolean(bool) => {
|
|
result = VMMemory::Boolean(VMMemoryBoolean { value: !bool.value, variable_id: 0 });
|
|
},
|
|
_ => {
|
|
let err = create_error(&format!("Wrong memory type for NOT operation, position: `{}`", mem1), operation.pos, ErrorType::TypeError, ErrorSubType::WrongType, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
}
|
|
let mut reg2_pointer = reg2.unwrap().pointer;
|
|
if reg2_pointer >= self.memory.len() || reg2_pointer < 1 {
|
|
reg2_pointer = self.memory.len();
|
|
self.memory.push(VMMemory::Null(VMMemoryNull { variable_id: 0 }));
|
|
set_register(&mut self.registers, Register { id: operation.arg2 as u8, pointer: reg2_pointer });
|
|
}
|
|
let var_id = get_var_id(&self.memory[reg2_pointer]);
|
|
set_var_id(&mut result, var_id);
|
|
self.memory[reg2_pointer] = result;
|
|
},
|
|
25 => {
|
|
//JMP
|
|
self.call_stack[executed_stack].pc = operation.arg2 as usize;
|
|
},
|
|
26 => {
|
|
//CJP
|
|
let reg = get_register_by_id(&self.registers, operation.arg1);
|
|
if reg.is_none() {
|
|
let err = create_error(&format!("Register `{}` not found", operation.arg1), operation.pos, ErrorType::MachineError, ErrorSubType::RegisterNotFound, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
let reg = reg.unwrap();
|
|
let mem = self.memory.get(reg.pointer);
|
|
if mem.is_none() {
|
|
let err = create_error(&format!("Memory location not found for register `{}`", operation.arg1), operation.pos, ErrorType::MachineError, ErrorSubType::UnknownMemoryLocation, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
let mem = mem.unwrap();
|
|
match &mem {
|
|
VMMemory::Boolean(bool) => {
|
|
if bool.value {
|
|
self.call_stack[executed_stack].pc = operation.arg2 as usize;
|
|
}
|
|
}
|
|
_ => {
|
|
let err = create_error(&format!("Wrong memory type for CJP operation, position: `{}`", reg.pointer), operation.pos, ErrorType::TypeError, ErrorSubType::WrongType, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
},
|
|
}
|
|
},
|
|
27 => {
|
|
//CAL
|
|
let reg = get_register_by_id(&self.registers, operation.arg1);
|
|
if reg.is_none() {
|
|
let err = create_error(&format!("Register `{}` not found", operation.arg1), operation.pos, ErrorType::MachineError, ErrorSubType::RegisterNotFound, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
let reg = reg.unwrap();
|
|
let mem = self.memory.get(reg.pointer);
|
|
if mem.is_none() {
|
|
let err = create_error(&format!("Memory location not found for register `{}`", operation.arg1), operation.pos, ErrorType::MachineError, ErrorSubType::UnknownMemoryLocation, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
let mem = mem.unwrap().clone();
|
|
match mem {
|
|
VMMemory::Function(func) => {
|
|
let arg = 0;
|
|
for i in &self.stack {
|
|
let mut new_mem = i.clone();
|
|
if self.functions[func.id].variables.len() <= arg || self.functions[func.id].variables[arg].start != 0 {
|
|
let err = create_error(&format!("Too many arguments supplied for function: `{}`", func.id), operation.pos, ErrorType::SemanticError, ErrorSubType::TooManyArguments, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
set_var_id(&mut new_mem, self.functions[func.id].variables[arg].id);
|
|
self.memory.push(new_mem);
|
|
}
|
|
self.stack.clear();
|
|
|
|
self.call_stack.push(CallStack { func: func.id, return_reg: operation.arg2 as usize, pc: 0 });
|
|
executed_func = &func_clone[func.id];
|
|
executed_stack = self.call_stack.len() - 1;
|
|
},
|
|
VMMemory::NativeFunction(nfunc) => {
|
|
let mut result = (nfunc.func)(self, &operation, self.stack.clone());
|
|
let ret_reg = get_register_by_id(&self.registers, operation.arg2 as u8);
|
|
if ret_reg.is_none() {
|
|
let err = create_error(&format!("Register `{}` not found", operation.arg2), operation.pos, ErrorType::MachineError, ErrorSubType::RegisterNotFound, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
let mut ret_pointer = ret_reg.unwrap().pointer;
|
|
if ret_pointer >= self.memory.len() || ret_pointer < 1 {
|
|
self.memory.push(VMMemory::Null(VMMemoryNull { variable_id: 0 }));
|
|
ret_pointer = self.memory.len() - 1;
|
|
set_register(&mut self.registers, Register { id: operation.arg2 as u8, pointer: ret_pointer });
|
|
}
|
|
let var_id = get_var_id(&self.memory[ret_pointer]);
|
|
set_var_id(&mut result, var_id);
|
|
self.memory[ret_pointer] = result;
|
|
|
|
self.stack.clear();
|
|
},
|
|
_ => {
|
|
let err = create_error(&format!("Unable to call non-function type"), operation.pos, ErrorType::MachineError, ErrorSubType::NonFunctionCall, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
}
|
|
},
|
|
28 => {
|
|
//PSH
|
|
let reg = get_register_by_id(&self.registers, operation.arg1);
|
|
if reg.is_none() {
|
|
let err = create_error(&format!("Register `{}` not found", operation.arg1), operation.pos, ErrorType::MachineError, ErrorSubType::RegisterNotFound, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
let reg = reg.unwrap();
|
|
let mem = self.memory.get(reg.pointer);
|
|
if mem.is_none() {
|
|
let err = create_error(&format!("Memory location not found for register `{}`", operation.arg1), operation.pos, ErrorType::MachineError, ErrorSubType::MemoryOutOfBounds, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
let mem = mem.unwrap();
|
|
self.stack.push(mem.clone());
|
|
},
|
|
29 => {
|
|
//RET
|
|
let target_reg = get_register_by_id(&self.registers, self.call_stack[executed_stack].return_reg as u8);
|
|
let ret_reg = get_register_by_id(&self.registers, operation.arg1);
|
|
if target_reg.is_none() || ret_reg.is_none() {
|
|
let err = create_error(&format!("Register `{}` or `{}` not found", self.call_stack[executed_stack].return_reg, operation.arg1), operation.pos, ErrorType::MachineError, ErrorSubType::RegisterNotFound, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
let ret_mem = self.memory.get(ret_reg.unwrap().pointer);
|
|
if ret_mem.is_none() {
|
|
let err = create_error(&format!("Memory location not found for register `{}`", operation.arg1), operation.pos, ErrorType::MachineError, ErrorSubType::MemoryOutOfBounds, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
let return_value = ret_mem.unwrap().clone();
|
|
let target_reg_pointer = self.memory.len();
|
|
self.memory.push(VMMemory::Null(VMMemoryNull { variable_id: 0 }));
|
|
set_register(&mut self.registers, Register { id: self.call_stack[executed_stack].return_reg as u8, pointer: target_reg_pointer });
|
|
self.memory[target_reg_pointer] = return_value;
|
|
self.call_stack.pop();
|
|
if self.call_stack.len() < 1 {
|
|
return;
|
|
}
|
|
executed_stack = self.call_stack.len() - 1;
|
|
executed_func = &func_clone[self.call_stack[executed_stack].func];
|
|
},
|
|
30 => {
|
|
//GET
|
|
let reg_clone = self.registers.clone();
|
|
if operation.arg1 == 0 {
|
|
//We use the enviroment instead of a table
|
|
let reg2 = get_register_by_id(®_clone, operation.arg2 as u8);
|
|
let reg3 = get_register_by_id(®_clone, operation.arg3);
|
|
if reg2.is_none() || reg3.is_none() {
|
|
let err = create_error(&format!("Register `{}` or `{}` not found", operation.arg2, operation.arg3), operation.pos, ErrorType::MachineError, ErrorSubType::RegisterNotFound, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
let mem2 = self.memory.get(reg2.unwrap().pointer);
|
|
if mem2.is_none() {
|
|
let err = create_error(&format!("Memory location out of bounds for register `{}`", operation.arg2), operation.pos, ErrorType::MachineError, ErrorSubType::MemoryOutOfBounds, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
let mem2 = mem2.unwrap().clone();
|
|
let mut result: VMMemory;
|
|
match mem2 {
|
|
VMMemory::String(str) => {
|
|
let ret = self.env.get(&str.value);
|
|
if ret.is_none() {
|
|
result = VMMemory::Null(VMMemoryNull { variable_id: 0 });
|
|
} else {
|
|
result = ret.unwrap().clone();
|
|
}
|
|
},
|
|
_ => {
|
|
let err = create_error(&format!("Only string keys are allowed for GET enviroment"), operation.pos, ErrorType::TypeError, ErrorSubType::WrongType, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
}
|
|
let mut reg3_pointer = reg3.unwrap().pointer;
|
|
if reg3_pointer >= self.memory.len() || reg3_pointer < 1 {
|
|
reg3_pointer = self.memory.len();
|
|
self.memory.push(VMMemory::Null(VMMemoryNull { variable_id: 0 }));
|
|
set_register(&mut self.registers, Register { id: operation.arg3, pointer: reg3_pointer });
|
|
}
|
|
let var_id = get_var_id(&self.memory[reg3_pointer]);
|
|
set_var_id(&mut result, var_id);
|
|
self.memory[reg3_pointer] = result;
|
|
continue;
|
|
}
|
|
let reg = get_register_by_id(®_clone, operation.arg1);
|
|
let reg2 = get_register_by_id(®_clone, operation.arg2 as u8);
|
|
let reg3 = get_register_by_id(®_clone, operation.arg3);
|
|
if reg.is_none() || reg2.is_none() || reg3.is_none() {
|
|
let err = create_error(&format!("Register `{}` or `{}` or `{}` not found", operation.arg1, operation.arg2, operation.arg3), operation.pos, ErrorType::MachineError, ErrorSubType::RegisterNotFound, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
let mem1 = self.memory.get(reg.unwrap().pointer);
|
|
let mem2 = self.memory.get(reg2.unwrap().pointer);
|
|
if mem1.is_none() || mem2.is_none() {
|
|
let err = create_error(&format!("Memory location not found for register `{}` or `{}`", operation.arg1, operation.arg2), operation.pos, ErrorType::MachineError, ErrorSubType::MemoryOutOfBounds, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
let mem1 = mem1.unwrap().clone();
|
|
let mem2 = mem2.unwrap().clone();
|
|
let mut value: VMMemory;
|
|
match mem1 {
|
|
VMMemory::Table(tbl) => {
|
|
let tvalue = get_mem_tbl_val(&tbl, mem2);
|
|
if tvalue.is_none() {
|
|
value = VMMemory::Null(VMMemoryNull { variable_id: 0 });
|
|
} else {
|
|
value = tvalue.unwrap().clone();
|
|
}
|
|
},
|
|
_ => {
|
|
let err = create_error(&format!("Wrong memory type for GET operation, position: `{}`", reg.unwrap().pointer), operation.pos, ErrorType::TypeError, ErrorSubType::WrongType, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
}
|
|
let mut reg3_pointer = reg3.unwrap().pointer;
|
|
if reg3_pointer >= self.memory.len() || reg3_pointer < 1 {
|
|
reg3_pointer = self.memory.len();
|
|
self.memory.push(VMMemory::Null(VMMemoryNull { variable_id: 0 }));
|
|
set_register(&mut self.registers, Register { id: operation.arg3 as u8, pointer: reg3_pointer });
|
|
}
|
|
let var_id = get_var_id(&self.memory[reg3_pointer]);
|
|
set_var_id(&mut value, var_id);
|
|
self.memory[reg3_pointer] = value;
|
|
},
|
|
31 => {
|
|
//SET
|
|
let reg = get_register_by_id(&self.registers, operation.arg1);
|
|
let reg2 = get_register_by_id(&self.registers, operation.arg2 as u8);
|
|
let reg3 = get_register_by_id(&self.registers, operation.arg3);
|
|
if reg.is_none() || reg2.is_none() || reg3.is_none() {
|
|
let err = create_error(&format!("Register `{}` or `{}` or `{}` not found", operation.arg1, operation.arg2, operation.arg3), operation.pos, ErrorType::MachineError, ErrorSubType::RegisterNotFound, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
let mem1 = self.memory.get(reg.unwrap().pointer);
|
|
let mem2 = self.memory.get(reg2.unwrap().pointer);
|
|
let mem3 = self.memory.get(reg3.unwrap().pointer);
|
|
if mem1.is_none() || mem2.is_none() || mem3.is_none() {
|
|
let err = create_error(&format!("Memory location not found for register `{}` or `{}` or `{}`", operation.arg1, operation.arg2, operation.arg3), operation.pos, ErrorType::MachineError, ErrorSubType::MemoryOutOfBounds, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
let mem2 = mem2.unwrap().clone();
|
|
let mem3 = mem3.unwrap().clone();
|
|
let mem1 = self.memory.get_mut(reg.unwrap().pointer).expect("Memory location should exist");
|
|
match mem1 {
|
|
VMMemory::Table(tbl) => {
|
|
set_mem_tbl_val(tbl, mem2, mem3);
|
|
},
|
|
_ => {
|
|
let err = create_error(&format!("Wrong memory type for SET operation, position: `{}`", reg.unwrap().pointer), operation.pos, ErrorType::TypeError, ErrorSubType::WrongType, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
}
|
|
},
|
|
_ => {
|
|
let err = create_error(&format!("Unknown operation code: `{}`", operation.opcode), operation.pos, ErrorType::MachineError, ErrorSubType::UnknownOPCode, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
print_error(&err, &self.ctx[self.call_stack[executed_stack].func].clone());
|
|
process::exit(1);
|
|
}
|
|
}
|
|
}
|
|
self.state = VMState::Finished;
|
|
}
|
|
} |