1045 lines
40 KiB
Rust
1045 lines
40 KiB
Rust
use thiserror::Error;
|
|
|
|
use std::{cell::RefCell, collections::HashMap, fmt::Debug, i64, rc::Rc};
|
|
|
|
use crate::{
|
|
CompilationUnit,
|
|
ast::{BinaryOperator, UnaryOperator},
|
|
vm::value::{Constant, IndexableValue, LuaInteger, RustFunction, Table, Value},
|
|
};
|
|
|
|
pub mod value;
|
|
|
|
#[derive(Debug)]
|
|
pub struct SetMetatable;
|
|
impl RustFunction for SetMetatable {
|
|
fn execute(&self, parameters: Vec<Value>) -> Result<Vec<Value>, RuntimeError> {
|
|
let table = parameters
|
|
.get(0)
|
|
.ok_or(RuntimeError::NotTable(Value::Nil))?;
|
|
let metatable = parameters
|
|
.get(1)
|
|
.ok_or(RuntimeError::NotTable(Value::Nil))?;
|
|
|
|
match table {
|
|
Value::Table {
|
|
metatable: inner, ..
|
|
} => match metatable {
|
|
Value::Table {
|
|
contents: metatable,
|
|
..
|
|
} => {
|
|
*inner.borrow_mut() = metatable.borrow().clone();
|
|
Ok(Vec::new())
|
|
}
|
|
_ => Err(RuntimeError::NotTable(metatable.clone())),
|
|
},
|
|
_ => Err(RuntimeError::NotTable(table.clone())),
|
|
}
|
|
}
|
|
|
|
fn as_indexable(&self) -> String {
|
|
"SETMETATABLE".to_owned()
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Copy)]
|
|
pub enum Instruction {
|
|
/// R(A) := R(B)
|
|
Move(u16, u16),
|
|
/// R(A) ... R(A + func_register - top) := previous function return values
|
|
MoveRetValues(u16),
|
|
|
|
/// R(A) := K(Bx)
|
|
LoadK(u16, u32),
|
|
/// R(A), ..., R(B) := nil
|
|
LoadNil(u16, u16),
|
|
/// G[K(Bx)] := R(A)
|
|
SetGlobal(u16, u32),
|
|
/// R(A) := G[K(Bx)]
|
|
GetGlobal(u16, u32),
|
|
/// R(A) := U[B]
|
|
GetUpVal(u16, u16),
|
|
/// U[B] := R(A)
|
|
SetUpVal(u16, u16),
|
|
/// R(A)[R(B)] := R(C)
|
|
SetTable(u16, u16, u16),
|
|
/// R(A)[B...] := all values returned from previous function
|
|
SetList(u16, u32),
|
|
/// R(A) := R(B)[R(C)]
|
|
GetTable(u16, u16, u16),
|
|
|
|
/// R(A) := {}
|
|
NewTable(u16),
|
|
|
|
/// R(A) := R(B) .. R(C)
|
|
Concat(u16, u16, u16),
|
|
|
|
/// R(A) := R(B) + R(C)
|
|
Add(u16, u16, u16),
|
|
/// R(A) := R(B) * R(C)
|
|
Mult(u16, u16, u16),
|
|
/// R(A) := R(B) / R(C)
|
|
Div(u16, u16, u16),
|
|
/// R(A) := R(B) // R(C)
|
|
IDiv(u16, u16, u16),
|
|
/// R(A) := R(B) % R(C)
|
|
Mod(u16, u16, u16),
|
|
/// R(A) := R(B) ^ R(C)
|
|
Exp(u16, u16, u16),
|
|
|
|
/// R(A) := R(B) & R(C)
|
|
BitAnd(u16, u16, u16),
|
|
/// R(A) := R(B) | R(C)
|
|
BitOr(u16, u16, u16),
|
|
/// R(A) := R(B) ~ R(C)
|
|
BitXOr(u16, u16, u16),
|
|
/// R(A) := R(B) >> R(C)
|
|
BitSRight(u16, u16, u16),
|
|
/// R(A) := R(B) << R(C)
|
|
BitSLeft(u16, u16, u16),
|
|
|
|
/// R(A) := -R(B)
|
|
Unm(u16, u16),
|
|
/// R(A) := #R(B) (length operator)
|
|
Len(u16, u16),
|
|
/// R(A) := not R(B)
|
|
Not(u16, u16),
|
|
/// R(A) := ~R(B)
|
|
BitNot(u16, u16),
|
|
|
|
/// R(A) := R(B) == R(C)
|
|
Equal(u16, u16, u16),
|
|
/// R(A) := R(B) < R(C)
|
|
LessThan(u16, u16, u16),
|
|
/// R(A) := R(B) <= R(C)
|
|
LessThanOrEqual(u16, u16, u16),
|
|
|
|
/// R(A) := R(B) or R(C)
|
|
Or(u16, u16, u16),
|
|
/// R(A) := R(B) and R(C)
|
|
And(u16, u16, u16),
|
|
|
|
/// PC += sAx
|
|
Jmp(i32),
|
|
/// PC = Ax
|
|
GoTo(u32),
|
|
/// if (R(B) <=> C) then R(A) := R(B) else PC++
|
|
Test(u16, u16, u16),
|
|
/// if R(C) >= 0
|
|
/// then if R(A) < R(B)
|
|
/// PC ++
|
|
/// otherwise if R(A) > R(B)
|
|
/// PC ++
|
|
ForTest(u16, u16, u16),
|
|
/// [func] [params.len()] [ret_regs.len()]
|
|
/// R(A), ... R(A+C-2) := R(A)(R(A+1), ... R(A+B-1))
|
|
Call(u16, u16, u16),
|
|
/// return R(A), ... , R(B)
|
|
Return(u16, u16),
|
|
|
|
/// close stack variables up to R(A)
|
|
Close(u16),
|
|
/// R(A) := closure(KPROTO[Bx], R(A), ..., R(A+n))
|
|
Closure(u16, u32),
|
|
|
|
/// R(A), ... , R(A+B-2) := varargs
|
|
Vararg(u16, u16),
|
|
}
|
|
|
|
impl Debug for Instruction {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
match self {
|
|
Instruction::Move(arg0, arg1) => write!(f, "MOVE {} {}", arg0, arg1),
|
|
Instruction::MoveRetValues(arg0) => write!(f, "MOVERETVALS {}", arg0),
|
|
Instruction::LoadK(arg0, arg1) => write!(f, "LOADK {} {}", arg0, arg1),
|
|
Instruction::SetGlobal(arg0, arg1) => write!(f, "SETGLOBAL {} {}", arg0, arg1),
|
|
Instruction::GetGlobal(arg0, arg1) => write!(f, "GETGLOBAL {} {}", arg0, arg1),
|
|
Instruction::GetUpVal(arg0, arg1) => write!(f, "GETUPVAL {} {}", arg0, arg1),
|
|
Instruction::SetUpVal(arg0, arg1) => write!(f, "SETUPVAL {} {}", arg0, arg1),
|
|
Instruction::SetTable(arg0, arg1, arg2) => {
|
|
write!(f, "SETTABLE {} {} {}", arg0, arg1, arg2)
|
|
}
|
|
Instruction::GetTable(arg0, arg1, arg2) => {
|
|
write!(f, "GETTABLE {} {} {}", arg0, arg1, arg2)
|
|
}
|
|
Instruction::SetList(arg0, arg1) => write!(f, "SETLIST {} {}", arg0, arg1),
|
|
Instruction::NewTable(arg0) => write!(f, "NEWTABLE {}", arg0),
|
|
Instruction::Jmp(arg0) => write!(f, "JMP {}", arg0),
|
|
Instruction::GoTo(arg0) => write!(f, "GOTO {}", arg0),
|
|
Instruction::Test(arg0, arg1, arg2) => write!(f, "TEST {} {} {}", arg0, arg1, arg2),
|
|
Instruction::ForTest(arg0, arg1, arg2) => {
|
|
write!(f, "FORTEST {} {} {}", arg0, arg1, arg2)
|
|
}
|
|
Instruction::Call(arg0, arg1, arg2) => write!(f, "CALL {} {} {}", arg0, arg1, arg2),
|
|
Instruction::Close(arg0) => write!(f, "CLOSE {}", arg0),
|
|
Instruction::Closure(arg0, arg1) => write!(f, "CLOSURE {} {}", arg0, arg1),
|
|
Instruction::Return(arg0, arg1) => write!(f, "RETURN {} {}", arg0, arg1),
|
|
|
|
Instruction::Concat(arg0, arg1, arg2) => write!(f, "CONCAT {} {} {}", arg0, arg1, arg2),
|
|
|
|
Instruction::Equal(arg0, arg1, arg2) => write!(f, "EQ {} {} {}", arg0, arg1, arg2),
|
|
Instruction::LessThan(arg0, arg1, arg2) => write!(f, "LT {} {} {}", arg0, arg1, arg2),
|
|
Instruction::LessThanOrEqual(arg0, arg1, arg2) => {
|
|
write!(f, "LE {} {} {}", arg0, arg1, arg2)
|
|
}
|
|
|
|
Instruction::Add(arg0, arg1, arg2) => write!(f, "ADD {} {} {}", arg0, arg1, arg2),
|
|
Instruction::Mult(arg0, arg1, arg2) => write!(f, "MUL {} {} {}", arg0, arg1, arg2),
|
|
Instruction::Div(arg0, arg1, arg2) => write!(f, "DIV {} {} {}", arg0, arg1, arg2),
|
|
Instruction::IDiv(arg0, arg1, arg2) => write!(f, "IDIV {} {} {}", arg0, arg1, arg2),
|
|
Instruction::Mod(arg0, arg1, arg2) => write!(f, "MOD {} {} {}", arg0, arg1, arg2),
|
|
Instruction::Exp(arg0, arg1, arg2) => write!(f, "EXP {} {} {}", arg0, arg1, arg2),
|
|
|
|
Instruction::BitAnd(arg0, arg1, arg2) => write!(f, "BAND {} {} {}", arg0, arg1, arg2),
|
|
Instruction::BitOr(arg0, arg1, arg2) => write!(f, "BOR {} {} {}", arg0, arg1, arg2),
|
|
Instruction::BitXOr(arg0, arg1, arg2) => write!(f, "BXOR {} {} {}", arg0, arg1, arg2),
|
|
Instruction::BitSRight(arg0, arg1, arg2) => write!(f, "BSR {} {} {}", arg0, arg1, arg2),
|
|
Instruction::BitSLeft(arg0, arg1, arg2) => write!(f, "BSL {} {} {}", arg0, arg1, arg2),
|
|
|
|
Instruction::LoadNil(arg0, arg1) => write!(f, "LOADNIL {} {}", arg0, arg1),
|
|
|
|
Instruction::Unm(arg0, arg1) => write!(f, "UNM {} {}", arg0, arg1),
|
|
Instruction::Len(arg0, arg1) => write!(f, "LEN {} {}", arg0, arg1),
|
|
Instruction::Not(arg0, arg1) => write!(f, "NOT {} {}", arg0, arg1),
|
|
Instruction::BitNot(arg0, arg1) => write!(f, "BNOT {} {}", arg0, arg1),
|
|
|
|
Instruction::Or(arg0, arg1, arg2) => write!(f, "OR {} {} {}", arg0, arg1, arg2),
|
|
Instruction::And(arg0, arg1, arg2) => write!(f, "AND {} {} {}", arg0, arg1, arg2),
|
|
Instruction::Vararg(arg0, arg1) => write!(f, "VARARG {} {}", arg0, arg1),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Error, Debug)]
|
|
pub enum RuntimeError {
|
|
#[error("Unable to perform {0:?} operator between {1:?} and {2:?}")]
|
|
InvalidOperands(BinaryOperator, Value, Value),
|
|
#[error("Unable to call metamethod {0} for values {1:?} and {2:?}")]
|
|
InvalidOperation(String, Value, Value),
|
|
#[error("Metatable is not a table: {0:?}")]
|
|
MetatableNotTable(Value),
|
|
#[error("Metafunction not found: {0}")]
|
|
MetafunctionNotFound(String),
|
|
#[error("Metafunction is not callable: {0:?}")]
|
|
MetafunctionNotCallable(Value),
|
|
#[error("Unable to perform {0:?} operator to {1:?}")]
|
|
InvalidOperand(UnaryOperator, Value),
|
|
#[error("Tried calling a non-function: {0:?}")]
|
|
TriedCallingNonFunction(Value),
|
|
#[error("Global not found: {0:?}")]
|
|
GlobalNotFound(Option<Constant>),
|
|
#[error("Unable to index tables with {0:?}")]
|
|
InvalidTableIndex(Value),
|
|
#[error("Value is not a table: {0:?}")]
|
|
NotTable(Value),
|
|
#[error("Value is not coercable to a float: {0:?}")]
|
|
NotFloatable(Value),
|
|
#[error("Value is not coercable to bits: {0:?}")]
|
|
NotBittable(Value),
|
|
#[error("Value does not have a length: {0:?}")]
|
|
NotLengthable(Value),
|
|
#[error("{0}")]
|
|
Custom(String),
|
|
}
|
|
|
|
#[derive(Debug, Clone, Default)]
|
|
pub struct Prototype {
|
|
pub instructions: Vec<Instruction>,
|
|
pub parameters: usize,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct VirtualMachine {
|
|
pub(super) environment: Table,
|
|
pub(super) constants: Vec<Constant>,
|
|
pub(super) prototypes: HashMap<u32, Prototype>,
|
|
pub(super) proto_counter: u32,
|
|
}
|
|
|
|
impl Default for VirtualMachine {
|
|
fn default() -> Self {
|
|
let environment: Table = Default::default();
|
|
environment.borrow_mut().insert(
|
|
IndexableValue::String("SETMETATABLE".into()),
|
|
SetMetatable.into(),
|
|
);
|
|
Self {
|
|
environment,
|
|
constants: Default::default(),
|
|
prototypes: Default::default(),
|
|
proto_counter: Default::default(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl VirtualMachine {
|
|
pub fn new_prototype(&mut self, instructions: Prototype) -> u32 {
|
|
let proto_id = self.proto_counter;
|
|
self.proto_counter += 1;
|
|
self.prototypes.insert(proto_id, instructions);
|
|
proto_id
|
|
}
|
|
|
|
pub(crate) fn create_closure(&self, prototype: u32) -> Closure {
|
|
Closure {
|
|
vm: self.clone(),
|
|
prototype,
|
|
environment: self.environment.clone(),
|
|
upvalues: HashMap::new(),
|
|
}
|
|
}
|
|
|
|
pub fn set_global(&mut self, key: Value, value: Value) -> Result<(), RuntimeError> {
|
|
self.environment
|
|
.borrow_mut()
|
|
.insert(key.as_indexable()?, value);
|
|
Ok(())
|
|
}
|
|
|
|
pub fn get_globals(&self) -> HashMap<IndexableValue, Value> {
|
|
let mut values = HashMap::new();
|
|
for (key, value) in self.environment.borrow().iter() {
|
|
values.insert(key.clone(), value.clone());
|
|
}
|
|
|
|
values
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct Closure {
|
|
vm: VirtualMachine,
|
|
pub(crate) prototype: u32,
|
|
environment: Table,
|
|
upvalues: HashMap<u16, Rc<RefCell<Value>>>,
|
|
}
|
|
|
|
impl Closure {
|
|
pub fn run(&self, params: Vec<Value>) -> ClosureRunner {
|
|
let mut stack = HashMap::new();
|
|
for (i, param) in params.iter().enumerate() {
|
|
stack.insert(i as u16, Rc::new(RefCell::new(param.clone())));
|
|
}
|
|
|
|
ClosureRunner {
|
|
closure: self.clone(),
|
|
program_counter: 0,
|
|
stack,
|
|
inner: None,
|
|
function_register: 0,
|
|
return_registers: Vec::new(),
|
|
top: 0,
|
|
parameters: params,
|
|
to_close_upvalues: 0,
|
|
}
|
|
}
|
|
|
|
fn get_upvalue(&mut self, idx: u16) -> StackValue {
|
|
let value = self.upvalues.get(&idx);
|
|
if let Some(value) = value {
|
|
match &*value.borrow() {
|
|
_ => StackValue::Value(value.borrow().clone()),
|
|
}
|
|
} else {
|
|
StackValue::Value(Value::Nil)
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct ClosureRunner {
|
|
closure: Closure,
|
|
program_counter: usize,
|
|
stack: HashMap<u16, Rc<RefCell<Value>>>,
|
|
inner: Option<Box<ClosureRunner>>,
|
|
function_register: u16,
|
|
return_registers: Vec<u16>,
|
|
top: u16,
|
|
parameters: Vec<Value>,
|
|
to_close_upvalues: u16,
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
enum StackValue {
|
|
Value(Value),
|
|
}
|
|
|
|
impl ClosureRunner {
|
|
fn set_stack(&mut self, idx: u16, value: StackValue) {
|
|
if let Some(stack_slot) = self.stack.get_mut(&idx) {
|
|
match value {
|
|
StackValue::Value(value) => {
|
|
*stack_slot.borrow_mut() = value;
|
|
}
|
|
}
|
|
} else {
|
|
match value {
|
|
StackValue::Value(value) => {
|
|
self.stack.insert(idx, Rc::new(RefCell::new(value)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn get_stack(&mut self, idx: u16) -> StackValue {
|
|
let value = self.stack.get(&idx);
|
|
if let Some(value) = value {
|
|
match &*value.borrow() {
|
|
_ => StackValue::Value(value.borrow().clone()),
|
|
}
|
|
} else {
|
|
StackValue::Value(Value::Nil)
|
|
}
|
|
}
|
|
|
|
fn close_upvalues(&self) -> HashMap<u16, Rc<RefCell<Value>>> {
|
|
let highest_upvalue = self
|
|
.closure
|
|
.upvalues
|
|
.iter()
|
|
.map(|(v, _)| *v as i32)
|
|
.max()
|
|
.unwrap_or(-1);
|
|
|
|
let mut upvalues = self.closure.upvalues.clone();
|
|
for (reg, value) in self
|
|
.stack
|
|
.iter()
|
|
.filter(|(r, _)| **r < self.to_close_upvalues)
|
|
{
|
|
upvalues.insert(reg + (highest_upvalue + 1) as u16, value.clone());
|
|
}
|
|
upvalues
|
|
}
|
|
|
|
pub fn execute(&mut self, unit: &CompilationUnit) -> ClosureRunner {
|
|
let mut vm = self.closure.vm.clone();
|
|
vm.constants = unit.constants.clone();
|
|
let proto_id = vm.new_prototype(Prototype {
|
|
instructions: unit.instructions.clone(),
|
|
parameters: 0,
|
|
});
|
|
for prototype in &unit.state.prototypes {
|
|
vm.new_prototype(prototype.clone());
|
|
}
|
|
|
|
let closure = Closure {
|
|
vm,
|
|
prototype: proto_id,
|
|
environment: self.closure.environment.clone(),
|
|
upvalues: self.close_upvalues(),
|
|
};
|
|
closure.run(Vec::new())
|
|
}
|
|
|
|
pub fn next(&mut self) -> Result<Option<Vec<Value>>, RuntimeError> {
|
|
if let Some(inner) = &mut self.inner {
|
|
match inner.next() {
|
|
Ok(ret_values) => {
|
|
if let Some(ret_values) = ret_values {
|
|
self.inner = None;
|
|
if self.return_registers.len() == 0 {
|
|
for (i, value) in ret_values.iter().enumerate() {
|
|
self.set_stack(
|
|
self.function_register + i as u16 + 1,
|
|
StackValue::Value(value.clone()),
|
|
);
|
|
}
|
|
self.top = self.function_register + ret_values.len() as u16;
|
|
}
|
|
for (i, reg) in self.return_registers.clone().iter().enumerate() {
|
|
self.set_stack(
|
|
*reg,
|
|
StackValue::Value(ret_values.get(i).cloned().unwrap_or(Value::Nil)),
|
|
);
|
|
}
|
|
} else {
|
|
return Ok(None);
|
|
}
|
|
}
|
|
Err(e) => return Err(e),
|
|
}
|
|
}
|
|
|
|
let prototype = self
|
|
.closure
|
|
.vm
|
|
.prototypes
|
|
.get(&self.closure.prototype)
|
|
.unwrap()
|
|
.clone();
|
|
let constants = self.closure.vm.constants.clone();
|
|
|
|
if let Some(instr) = prototype.instructions.get(self.program_counter) {
|
|
match instr {
|
|
Instruction::Move(a, b) => {
|
|
let b = self.get_stack(*b);
|
|
self.set_stack(*a, b);
|
|
}
|
|
Instruction::MoveRetValues(res) => {
|
|
let length = self.top - self.function_register;
|
|
|
|
let mut values = Vec::new();
|
|
for i in 0..length {
|
|
let b = self.get_stack(self.function_register + i + 1);
|
|
values.push(b);
|
|
}
|
|
for (i, val) in values.into_iter().enumerate() {
|
|
self.set_stack(*res + i as u16, val);
|
|
}
|
|
|
|
self.top = *res + length;
|
|
}
|
|
Instruction::LoadK(reg, constant) => {
|
|
self.set_stack(
|
|
*reg,
|
|
StackValue::Value(match constants.get(*constant as usize).unwrap() {
|
|
Constant::String(value) => Value::String(value.clone()),
|
|
Constant::Float(value) => Value::Float(*value),
|
|
Constant::Integer(value) => Value::Integer(*value),
|
|
Constant::Bool(lua_bool) => Value::Boolean(*lua_bool),
|
|
Constant::Nil => Value::Nil,
|
|
}),
|
|
);
|
|
}
|
|
Instruction::LoadNil(from_reg, to_reg) => {
|
|
for i in *from_reg..=*to_reg {
|
|
self.set_stack(i, StackValue::Value(Value::Nil));
|
|
}
|
|
}
|
|
Instruction::SetGlobal(reg, global) => {
|
|
let value = self.get_stack(*reg);
|
|
self.closure.environment.borrow_mut().insert(
|
|
constants
|
|
.get(*global as usize)
|
|
.unwrap()
|
|
.clone()
|
|
.as_value()
|
|
.as_indexable()?,
|
|
match value {
|
|
StackValue::Value(value) => value,
|
|
},
|
|
);
|
|
}
|
|
Instruction::GetGlobal(reg, global) => {
|
|
let constant = constants.get(*global as usize).unwrap().clone();
|
|
|
|
if let Constant::String(name) = &constant
|
|
&& name.clone() == "_ENV".to_owned()
|
|
{
|
|
self.set_stack(
|
|
*reg,
|
|
StackValue::Value(Value::Table {
|
|
contents: self.closure.environment.clone(),
|
|
metatable: Rc::new(RefCell::new(HashMap::new())),
|
|
}),
|
|
);
|
|
} else {
|
|
let environment = self.closure.environment.borrow_mut().clone();
|
|
let glob = environment
|
|
.get(&constant.as_value().as_indexable()?)
|
|
.cloned();
|
|
|
|
if let Some(global) = glob {
|
|
self.set_stack(*reg, StackValue::Value(global));
|
|
} else {
|
|
return Err(RuntimeError::GlobalNotFound(
|
|
constants.get(*global as usize).cloned(),
|
|
));
|
|
}
|
|
}
|
|
}
|
|
Instruction::GetUpVal(reg, upvalreg) => {
|
|
let upvalue = self.closure.get_upvalue(*upvalreg);
|
|
self.set_stack(*reg, upvalue);
|
|
}
|
|
Instruction::SetUpVal(upvalreg, reg) => {
|
|
*self.closure.upvalues.get(upvalreg).unwrap().borrow_mut() = self
|
|
.stack
|
|
.get(reg)
|
|
.map(|v| v.borrow().clone())
|
|
.unwrap_or(Value::Nil);
|
|
}
|
|
Instruction::SetTable(tablereg, indexreg, valuereg) => {
|
|
let table = self.stack.get(tablereg);
|
|
match table {
|
|
Some(value) => {
|
|
let mut table = value.borrow_mut();
|
|
if let Value::Table { contents, .. } = &mut *table {
|
|
let index_value = self
|
|
.stack
|
|
.get(indexreg)
|
|
.map(|v| v.borrow().clone())
|
|
.unwrap_or(Value::Nil)
|
|
.as_indexable()?;
|
|
let value = self
|
|
.stack
|
|
.get(valuereg)
|
|
.map(|v| v.borrow().clone())
|
|
.unwrap_or(Value::Nil);
|
|
match value {
|
|
Value::Nil => {
|
|
contents.borrow_mut().remove(&index_value);
|
|
}
|
|
_ => {
|
|
contents.borrow_mut().insert(index_value, value);
|
|
}
|
|
}
|
|
} else {
|
|
return Err(RuntimeError::NotTable(table.clone()));
|
|
}
|
|
}
|
|
None => todo!(),
|
|
}
|
|
}
|
|
Instruction::GetTable(res, tablereg, indexreg) => {
|
|
let value = match self.stack.get(tablereg).cloned() {
|
|
Some(value) => {
|
|
let table = value.borrow();
|
|
if let Value::Table { contents, .. } = &*table {
|
|
let table = contents.borrow();
|
|
let index_value = self
|
|
.stack
|
|
.get(indexreg)
|
|
.map(|v| v.borrow().clone())
|
|
.unwrap_or(Value::Nil)
|
|
.as_indexable()?;
|
|
let value = table.get(&index_value);
|
|
match value {
|
|
Some(value) => StackValue::Value(value.clone()),
|
|
None => StackValue::Value(Value::Nil),
|
|
}
|
|
} else {
|
|
return Err(RuntimeError::NotTable(table.clone()));
|
|
}
|
|
}
|
|
None => {
|
|
return Err(RuntimeError::NotTable(Value::Nil));
|
|
}
|
|
};
|
|
|
|
self.set_stack(*res, value);
|
|
}
|
|
Instruction::SetList(reg, start_idx) => {
|
|
let table = self.stack.get(reg).cloned();
|
|
match table {
|
|
Some(value) => {
|
|
let mut table = value.borrow_mut();
|
|
if let Value::Table { contents, .. } = &mut *table {
|
|
let mut counter = *start_idx as i64;
|
|
for i in self.function_register..self.top {
|
|
let value = self.get_stack(i + 1);
|
|
match value {
|
|
StackValue::Value(value) => contents.borrow_mut().insert(
|
|
IndexableValue::Integer(LuaInteger(counter)),
|
|
value.clone(),
|
|
),
|
|
};
|
|
counter += 1;
|
|
}
|
|
} else {
|
|
return Err(RuntimeError::NotTable(table.clone()));
|
|
}
|
|
}
|
|
None => todo!(),
|
|
}
|
|
}
|
|
Instruction::NewTable(reg) => {
|
|
self.set_stack(
|
|
*reg,
|
|
StackValue::Value(Value::Table {
|
|
contents: Rc::new(RefCell::new(HashMap::new())),
|
|
metatable: Rc::new(RefCell::new(HashMap::new())),
|
|
}),
|
|
);
|
|
}
|
|
Instruction::Jmp(b) => {
|
|
self.program_counter = (self.program_counter as i32 + *b) as usize
|
|
}
|
|
Instruction::GoTo(a) => {
|
|
self.program_counter = *a as usize;
|
|
return Ok(None);
|
|
}
|
|
Instruction::Test(a, b, c) => {
|
|
let is_true = match self
|
|
.stack
|
|
.get(b)
|
|
.map(|v| v.borrow().clone())
|
|
.unwrap_or(Value::Nil)
|
|
{
|
|
Value::Boolean(val) => (val.0 as u16) == *c,
|
|
_ => false,
|
|
};
|
|
if is_true {
|
|
let b = self.get_stack(*b);
|
|
self.set_stack(*a, b);
|
|
} else {
|
|
self.program_counter += 1;
|
|
}
|
|
}
|
|
Instruction::ForTest(counter_reg, end_reg, step_reg) => {
|
|
let step_gte_0 = match self.get_stack(*step_reg) {
|
|
StackValue::Value(value) => Value::Integer(LuaInteger(0)).lt(&value),
|
|
};
|
|
let counter = match self.get_stack(*counter_reg) {
|
|
StackValue::Value(value) => value,
|
|
};
|
|
let end = match self.get_stack(*end_reg) {
|
|
StackValue::Value(value) => value,
|
|
};
|
|
|
|
if step_gte_0?.is_truthy() {
|
|
if !end.lt(&counter)?.is_truthy() {
|
|
self.program_counter += 1;
|
|
}
|
|
} else {
|
|
if !counter.lt(&end)?.is_truthy() {
|
|
self.program_counter += 1;
|
|
}
|
|
}
|
|
}
|
|
Instruction::Call(func_reg, param_len, ret_len) => {
|
|
let param_start_func_reg = *func_reg;
|
|
|
|
let param_len = if *param_len == 0 {
|
|
self.top - self.top.min(param_start_func_reg + 1)
|
|
} else {
|
|
*param_len
|
|
};
|
|
self.function_register = *func_reg;
|
|
|
|
let mut params = Vec::new();
|
|
for i in 0..param_len {
|
|
params.push(
|
|
self.stack
|
|
.get(&(param_start_func_reg + i + 1))
|
|
.map(|v| v.borrow().clone())
|
|
.unwrap_or(Value::Nil)
|
|
.clone(),
|
|
);
|
|
}
|
|
|
|
let value = self
|
|
.stack
|
|
.get(func_reg)
|
|
.map(|v| v.borrow().clone())
|
|
.unwrap_or(Value::Nil);
|
|
match value {
|
|
Value::RustFunction(func) => {
|
|
let ret_values = func.borrow_mut().execute(params)?;
|
|
if *ret_len != 0 {
|
|
for i in 0..=(*ret_len - 2) {
|
|
self.set_stack(
|
|
*func_reg + i,
|
|
StackValue::Value(
|
|
ret_values
|
|
.get(i as usize)
|
|
.cloned()
|
|
.unwrap_or(Value::Nil),
|
|
),
|
|
);
|
|
}
|
|
} else {
|
|
for (i, value) in ret_values.iter().enumerate() {
|
|
self.set_stack(
|
|
*func_reg + i as u16 + 1,
|
|
StackValue::Value(value.clone()),
|
|
);
|
|
}
|
|
self.top = *func_reg + ret_values.len() as u16;
|
|
}
|
|
}
|
|
Value::Function(closure) => {
|
|
self.return_registers = Vec::new();
|
|
if *ret_len != 0 {
|
|
for i in 0..=(*ret_len - 2) {
|
|
self.return_registers.push(*func_reg + i);
|
|
}
|
|
}
|
|
self.inner = Some(Box::new(closure.run(params)));
|
|
}
|
|
_ => return Err(RuntimeError::TriedCallingNonFunction(value.clone())),
|
|
}
|
|
}
|
|
Instruction::Close(up_until) => {
|
|
self.to_close_upvalues = *up_until;
|
|
}
|
|
Instruction::Closure(reg, protok) => {
|
|
let upvalues = self.close_upvalues();
|
|
self.set_stack(
|
|
*reg,
|
|
StackValue::Value(Value::Function(Closure {
|
|
vm: self.closure.vm.clone(),
|
|
prototype: *protok,
|
|
environment: self.closure.environment.clone(),
|
|
upvalues,
|
|
})),
|
|
);
|
|
}
|
|
Instruction::Return(reg_start, reg_end) => {
|
|
self.program_counter += 1;
|
|
let mut ret_values = Vec::new();
|
|
let (reg_start, reg_end) = if *reg_end == 0 {
|
|
if self.top > 0 {
|
|
(*reg_start, self.top - 1)
|
|
} else {
|
|
(*reg_start, *reg_end)
|
|
}
|
|
} else {
|
|
(*reg_start, *reg_end)
|
|
};
|
|
for i in reg_start..=reg_end {
|
|
ret_values.push(
|
|
self.stack
|
|
.get(&i)
|
|
.map(|v| v.borrow().clone())
|
|
.unwrap_or(Value::Nil),
|
|
);
|
|
}
|
|
return Ok(Some(ret_values));
|
|
}
|
|
|
|
Instruction::Concat(res, lhs, rhs) => {
|
|
let (lhs, rhs) = self.lhs_and_rhs(lhs, rhs);
|
|
self.set_stack(*res, StackValue::Value(lhs.concat(&rhs)?));
|
|
}
|
|
|
|
Instruction::Add(res, lhs, rhs) => {
|
|
let (lhs, rhs) = self.lhs_and_rhs(lhs, rhs);
|
|
self.set_stack(
|
|
*res,
|
|
StackValue::Value(self.result_or_metamethod(
|
|
lhs.add(&rhs),
|
|
"__add",
|
|
lhs,
|
|
rhs,
|
|
)?),
|
|
);
|
|
}
|
|
Instruction::Mult(res, lhs, rhs) => {
|
|
let (lhs, rhs) = self.lhs_and_rhs(lhs, rhs);
|
|
self.set_stack(*res, StackValue::Value(lhs.mult(&rhs)?));
|
|
}
|
|
Instruction::Div(res, lhs, rhs) => {
|
|
let (lhs, rhs) = self.lhs_and_rhs(lhs, rhs);
|
|
self.set_stack(*res, StackValue::Value(lhs.div(&rhs)?));
|
|
}
|
|
Instruction::IDiv(res, lhs, rhs) => {
|
|
let (lhs, rhs) = self.lhs_and_rhs(lhs, rhs);
|
|
self.set_stack(*res, StackValue::Value(lhs.idiv(&rhs)?));
|
|
}
|
|
Instruction::Mod(res, lhs, rhs) => {
|
|
let (lhs, rhs) = self.lhs_and_rhs(lhs, rhs);
|
|
self.set_stack(*res, StackValue::Value(lhs.r#mod(&rhs)?));
|
|
}
|
|
Instruction::Exp(res, lhs, rhs) => {
|
|
let (lhs, rhs) = self.lhs_and_rhs(lhs, rhs);
|
|
self.set_stack(*res, StackValue::Value(lhs.exp(&rhs)?));
|
|
}
|
|
|
|
Instruction::BitAnd(res, lhs, rhs) => {
|
|
let (lhs, rhs) = self.lhs_and_rhs(lhs, rhs);
|
|
self.set_stack(*res, StackValue::Value(lhs.band(&rhs)?));
|
|
}
|
|
Instruction::BitOr(res, lhs, rhs) => {
|
|
let (lhs, rhs) = self.lhs_and_rhs(lhs, rhs);
|
|
self.set_stack(*res, StackValue::Value(lhs.bor(&rhs)?));
|
|
}
|
|
Instruction::BitXOr(res, lhs, rhs) => {
|
|
let (lhs, rhs) = self.lhs_and_rhs(lhs, rhs);
|
|
self.set_stack(*res, StackValue::Value(lhs.bxor(&rhs)?));
|
|
}
|
|
Instruction::BitSRight(res, lhs, rhs) => {
|
|
let (lhs, rhs) = self.lhs_and_rhs(lhs, rhs);
|
|
self.set_stack(*res, StackValue::Value(lhs.bsright(&rhs)?));
|
|
}
|
|
Instruction::BitSLeft(res, lhs, rhs) => {
|
|
let (lhs, rhs) = self.lhs_and_rhs(lhs, rhs);
|
|
self.set_stack(*res, StackValue::Value(lhs.bsleft(&rhs)?));
|
|
}
|
|
|
|
Instruction::Equal(res, lhs, rhs) => {
|
|
let (lhs, rhs) = self.lhs_and_rhs(lhs, rhs);
|
|
self.set_stack(*res, StackValue::Value(lhs.eq(&rhs)?));
|
|
}
|
|
Instruction::LessThan(res, lhs, rhs) => {
|
|
let (lhs, rhs) = self.lhs_and_rhs(lhs, rhs);
|
|
self.set_stack(*res, StackValue::Value(lhs.lt(&rhs)?));
|
|
}
|
|
Instruction::LessThanOrEqual(res, lhs, rhs) => {
|
|
let (lhs, rhs) = self.lhs_and_rhs(lhs, rhs);
|
|
self.set_stack(*res, StackValue::Value(lhs.lte(&rhs)?));
|
|
}
|
|
|
|
Instruction::Or(res, lhs, rhs) => {
|
|
let (lhs, rhs) = self.lhs_and_rhs(lhs, rhs);
|
|
self.set_stack(*res, StackValue::Value(lhs.or(&rhs)?));
|
|
}
|
|
Instruction::And(res, lhs, rhs) => {
|
|
let (lhs, rhs) = self.lhs_and_rhs(lhs, rhs);
|
|
self.set_stack(*res, StackValue::Value(lhs.and(&rhs)?));
|
|
}
|
|
|
|
Instruction::Unm(res, reg) => {
|
|
self.set_stack(
|
|
*res,
|
|
StackValue::Value(
|
|
self.stack
|
|
.get(reg)
|
|
.map(|v| v.borrow().clone())
|
|
.unwrap_or(Value::Nil)
|
|
.unm()?,
|
|
),
|
|
);
|
|
}
|
|
Instruction::Len(res, reg) => {
|
|
self.set_stack(
|
|
*res,
|
|
StackValue::Value(
|
|
self.stack
|
|
.get(reg)
|
|
.map(|v| v.borrow().clone())
|
|
.unwrap_or(Value::Nil)
|
|
.len()?,
|
|
),
|
|
);
|
|
}
|
|
Instruction::Not(res, reg) => {
|
|
self.set_stack(
|
|
*res,
|
|
StackValue::Value(
|
|
self.stack
|
|
.get(reg)
|
|
.map(|v| v.borrow().clone())
|
|
.unwrap_or(Value::Nil)
|
|
.not()?,
|
|
),
|
|
);
|
|
}
|
|
Instruction::BitNot(res, reg) => {
|
|
self.set_stack(
|
|
*res,
|
|
StackValue::Value(
|
|
self.stack
|
|
.get(reg)
|
|
.map(|v| v.borrow().clone())
|
|
.unwrap_or(Value::Nil)
|
|
.bxor(&Value::Integer(LuaInteger(u64::MAX as i64)))?,
|
|
),
|
|
);
|
|
}
|
|
|
|
Instruction::Vararg(reg, len) => {
|
|
self.function_register = reg - 1;
|
|
if *len == 0 {
|
|
self.top = self.function_register + self.parameters.len() as u16
|
|
- prototype.parameters as u16;
|
|
|
|
for (i, param) in self
|
|
.parameters
|
|
.clone()
|
|
.iter()
|
|
.skip(prototype.parameters)
|
|
.enumerate()
|
|
{
|
|
self.set_stack(*reg + i as u16, StackValue::Value(param.clone()));
|
|
}
|
|
} else {
|
|
let len = len - 2;
|
|
self.top = self.function_register + len + 1;
|
|
for i in 0..len {
|
|
self.set_stack(
|
|
*reg + i as u16,
|
|
StackValue::Value(
|
|
self.parameters
|
|
.iter()
|
|
.skip(prototype.parameters)
|
|
.next()
|
|
.unwrap_or(&Value::Nil)
|
|
.clone(),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
self.program_counter += 1;
|
|
|
|
Ok(None)
|
|
} else {
|
|
Ok(Some(Vec::new()))
|
|
}
|
|
}
|
|
|
|
fn result_or_metamethod(
|
|
&self,
|
|
value: Result<Value, RuntimeError>,
|
|
metamethod: &str,
|
|
lhs: Value,
|
|
rhs: Value,
|
|
) -> Result<Value, RuntimeError> {
|
|
match value {
|
|
Ok(value) => Ok(value),
|
|
Err(_) => match (&lhs, &rhs) {
|
|
(Value::Table { metatable, .. }, _) => {
|
|
self.call_metamethod(metatable, metamethod, vec![lhs.clone(), rhs.clone()])
|
|
}
|
|
(_, Value::Table { metatable, .. }) => {
|
|
self.call_metamethod(metatable, metamethod, vec![lhs.clone(), rhs.clone()])
|
|
}
|
|
_ => Err(RuntimeError::InvalidOperation(
|
|
metamethod.to_owned(),
|
|
lhs,
|
|
rhs,
|
|
)),
|
|
},
|
|
}
|
|
}
|
|
|
|
fn call_metamethod(
|
|
&self,
|
|
metatable: &Table,
|
|
metamethod: &str,
|
|
params: Vec<Value>,
|
|
) -> Result<Value, RuntimeError> {
|
|
if let Some(value) = metatable
|
|
.borrow()
|
|
.get(&IndexableValue::String(metamethod.to_owned()))
|
|
{
|
|
match value {
|
|
Value::RustFunction(function) => {
|
|
let result = function.borrow_mut().execute(params)?;
|
|
Ok(result.into_iter().next().unwrap())
|
|
}
|
|
Value::Function(closure) => {
|
|
let mut runnable = closure.run(params);
|
|
#[allow(unused_assignments)]
|
|
let mut return_value = None;
|
|
while {
|
|
return_value = runnable.next()?;
|
|
return_value.is_none()
|
|
} {}
|
|
Ok(return_value.unwrap().into_iter().next().unwrap())
|
|
}
|
|
_ => Err(RuntimeError::MetafunctionNotCallable(value.clone())),
|
|
}
|
|
} else {
|
|
Err(RuntimeError::MetafunctionNotFound(metamethod.to_owned()))
|
|
}
|
|
}
|
|
|
|
fn lhs_and_rhs(&self, lhs: &u16, rhs: &u16) -> (Value, Value) {
|
|
(
|
|
self.stack
|
|
.get(lhs)
|
|
.map(|v| v.borrow().clone())
|
|
.unwrap_or(Value::Nil),
|
|
self.stack
|
|
.get(rhs)
|
|
.map(|v| v.borrow().clone())
|
|
.unwrap_or(Value::Nil),
|
|
)
|
|
}
|
|
}
|