1
0
dust/dust-lang/src/vm.rs

716 lines
25 KiB
Rust
Raw Normal View History

2024-10-13 08:21:07 +00:00
use std::{cmp::Ordering, mem::replace};
use crate::{
2024-10-13 06:33:58 +00:00
parse, value::Primitive, AnnotatedError, Chunk, ChunkError, DustError, Identifier, Instruction,
Operation, Span, Value, ValueError,
};
pub fn run(source: &str) -> Result<Option<Value>, DustError> {
let chunk = parse(source)?;
let mut vm = Vm::new(chunk);
vm.run()
.map_err(|error| DustError::Runtime { error, source })
}
#[derive(Debug, Eq, PartialEq)]
pub struct Vm {
ip: usize,
chunk: Chunk,
stack: Vec<Register>,
}
impl Vm {
const STACK_LIMIT: usize = u16::MAX as usize;
pub fn new(chunk: Chunk) -> Self {
Self {
ip: 0,
chunk,
stack: Vec::new(),
}
}
pub fn run(&mut self) -> Result<Option<Value>, VmError> {
2024-09-24 03:38:49 +00:00
// DRY helper to get constant or register values for binary operations
2024-09-23 23:16:15 +00:00
fn get_arguments(
2024-09-19 03:02:28 +00:00
vm: &mut Vm,
instruction: Instruction,
position: Span,
2024-09-23 23:16:15 +00:00
) -> Result<(&Value, &Value), VmError> {
2024-09-24 20:49:17 +00:00
let left = if instruction.b_is_constant() {
vm.chunk.get_constant(instruction.b(), position)?
2024-09-18 01:10:44 +00:00
} else {
2024-09-24 20:49:17 +00:00
vm.get(instruction.b(), position)?
2024-09-18 01:10:44 +00:00
};
2024-09-24 20:49:17 +00:00
let right = if instruction.c_is_constant() {
vm.chunk.get_constant(instruction.c(), position)?
2024-09-18 01:10:44 +00:00
} else {
2024-09-24 20:49:17 +00:00
vm.get(instruction.c(), position)?
2024-09-18 01:10:44 +00:00
};
Ok((left, right))
2024-09-19 03:02:28 +00:00
}
2024-09-18 01:10:44 +00:00
while let Ok((instruction, position)) = self.read(Span(0, 0)).copied() {
log::info!(
"{} | {} | {} | {}",
self.ip - 1,
position,
instruction.operation(),
instruction
.disassembly_info(Some(&self.chunk))
.0
.unwrap_or_default()
);
2024-09-15 05:24:04 +00:00
match instruction.operation() {
Operation::Move => {
let to_register = instruction.a();
let from_register = instruction.b();
let value = self.take(from_register, to_register, position)?;
self.set(to_register, value, position)?;
}
2024-09-18 03:06:58 +00:00
Operation::Close => {
let from_register = instruction.b();
let to_register = instruction.c();
if self.stack.len() < to_register as usize {
return Err(VmError::StackUnderflow { position });
}
2024-09-18 03:06:58 +00:00
for register_index in from_register..to_register {
self.stack[register_index as usize] = Register::Empty;
2024-09-18 03:06:58 +00:00
}
}
Operation::LoadBoolean => {
2024-09-24 20:49:17 +00:00
let to_register = instruction.a();
let boolean = instruction.b_as_boolean();
let skip = instruction.c_as_boolean();
let value = Value::boolean(boolean);
self.set(to_register, value, position)?;
2024-09-23 08:01:36 +00:00
if skip {
self.ip += 1;
}
}
Operation::LoadConstant => {
2024-09-24 20:49:17 +00:00
let to_register = instruction.a();
let from_constant = instruction.b();
let jump = instruction.c_as_boolean();
self.set_constant(to_register, from_constant, position)?;
if jump {
self.ip += 1;
}
}
2024-09-17 23:35:33 +00:00
Operation::LoadList => {
2024-09-24 20:49:17 +00:00
let to_register = instruction.a();
let first_register = instruction.b();
let last_register = instruction.c();
2024-10-12 10:16:12 +00:00
let item_type = self.get(first_register, position)?.r#type();
let value = Value::list(first_register, last_register, item_type);
2024-09-17 23:35:33 +00:00
self.set(to_register, value, position)?;
2024-09-17 23:35:33 +00:00
}
2024-09-18 15:27:41 +00:00
Operation::DefineLocal => {
2024-09-24 20:49:17 +00:00
let from_register = instruction.a();
let to_local = instruction.b();
self.chunk.define_local(to_local, from_register, position)?;
}
Operation::GetLocal => {
let to_register = instruction.a();
2024-09-24 20:49:17 +00:00
let local_index = instruction.b();
let local = self.chunk.get_local(local_index, position)?;
2024-10-13 08:21:07 +00:00
self.set_pointer(to_register, local.register_index, position)?;
}
2024-09-15 01:05:03 +00:00
Operation::SetLocal => {
let register = instruction.a();
2024-09-24 20:49:17 +00:00
let local_index = instruction.b();
let local = self.chunk.get_local(local_index, position)?;
if !local.is_mutable {
return Err(VmError::CannotMutateImmutableLocal {
identifier: local.identifier.clone(),
position,
});
}
self.chunk.define_local(local_index, register, position)?;
2024-09-15 01:05:03 +00:00
}
Operation::Add => {
2024-09-23 23:16:15 +00:00
let (left, right) = get_arguments(self, instruction, position)?;
let sum = left
2024-09-23 12:57:49 +00:00
.add(right)
.map_err(|error| VmError::Value { error, position })?;
self.set(instruction.a(), sum, position)?;
}
Operation::Subtract => {
2024-09-23 23:16:15 +00:00
let (left, right) = get_arguments(self, instruction, position)?;
let difference = left
2024-09-23 12:57:49 +00:00
.subtract(right)
.map_err(|error| VmError::Value { error, position })?;
self.set(instruction.a(), difference, position)?;
}
Operation::Multiply => {
2024-09-23 23:16:15 +00:00
let (left, right) = get_arguments(self, instruction, position)?;
let product = left
2024-09-23 12:57:49 +00:00
.multiply(right)
.map_err(|error| VmError::Value { error, position })?;
self.set(instruction.a(), product, position)?;
}
Operation::Divide => {
2024-09-23 23:16:15 +00:00
let (left, right) = get_arguments(self, instruction, position)?;
let quotient = left
2024-09-23 12:57:49 +00:00
.divide(right)
.map_err(|error| VmError::Value { error, position })?;
self.set(instruction.a(), quotient, position)?;
}
Operation::Modulo => {
2024-09-23 23:16:15 +00:00
let (left, right) = get_arguments(self, instruction, position)?;
let remainder = left
2024-09-23 12:57:49 +00:00
.modulo(right)
.map_err(|error| VmError::Value { error, position })?;
self.set(instruction.a(), remainder, position)?;
}
2024-09-19 15:41:18 +00:00
Operation::Test => {
2024-09-24 20:49:17 +00:00
let register = instruction.a();
let test_value = instruction.c_as_boolean();
2024-09-23 23:16:15 +00:00
let value = self.get(register, position)?;
let boolean = if let Value::Primitive(Primitive::Boolean(boolean)) = value {
*boolean
} else {
return Err(VmError::ExpectedBoolean {
found: value.clone(),
position,
});
};
2024-09-19 15:41:18 +00:00
2024-09-24 20:49:17 +00:00
if boolean != test_value {
2024-09-19 15:41:18 +00:00
self.ip += 1;
}
}
2024-09-19 15:41:18 +00:00
Operation::TestSet => {
2024-09-24 20:49:17 +00:00
let to_register = instruction.a();
let argument = instruction.b();
let test_value = instruction.c_as_boolean();
let borrowed_value = self.get(argument, position)?;
let boolean =
if let Value::Primitive(Primitive::Boolean(boolean)) = borrowed_value {
*boolean
} else {
return Err(VmError::ExpectedBoolean {
found: borrowed_value.clone(),
position,
});
};
2024-09-19 15:41:18 +00:00
if boolean == test_value {
let value = self.take(argument, to_register, position)?;
self.set(to_register, value, position)?;
2024-09-19 15:41:18 +00:00
} else {
self.ip += 1;
}
}
Operation::Equal => {
debug_assert_eq!(
self.chunk.get_instruction(self.ip, position)?.0.operation(),
Operation::Jump
);
2024-09-24 14:16:19 +00:00
2024-09-23 23:16:15 +00:00
let (left, right) = get_arguments(self, instruction, position)?;
let equal_result = left
2024-09-23 12:57:49 +00:00
.equal(right)
.map_err(|error| VmError::Value { error, position })?;
let boolean =
if let Value::Primitive(Primitive::Boolean(boolean)) = equal_result {
boolean
} else {
return Err(VmError::ExpectedBoolean {
found: equal_result.clone(),
position,
});
};
2024-09-24 20:49:17 +00:00
let compare_to = instruction.a_as_boolean();
2024-09-24 14:16:19 +00:00
if boolean == compare_to {
self.ip += 1;
} else {
let (jump, _) = *self.chunk.get_instruction(self.ip, position)?;
2024-09-24 20:49:17 +00:00
let jump_distance = jump.a();
2024-10-06 01:30:48 +00:00
let is_positive = jump.b_as_boolean();
2024-09-24 14:16:19 +00:00
let new_ip = if is_positive {
self.ip + jump_distance as usize
} else {
self.ip - jump_distance as usize
};
self.ip = new_ip;
}
}
Operation::Less => {
debug_assert_eq!(
self.chunk.get_instruction(self.ip, position)?.0.operation(),
Operation::Jump
);
2024-09-24 14:16:19 +00:00
2024-09-23 23:16:15 +00:00
let (left, right) = get_arguments(self, instruction, position)?;
let less_result = left
2024-09-24 15:40:12 +00:00
.less_than(right)
.map_err(|error| VmError::Value { error, position })?;
let boolean = if let Value::Primitive(Primitive::Boolean(boolean)) = less_result
{
boolean
} else {
return Err(VmError::ExpectedBoolean {
found: less_result.clone(),
2024-09-24 14:16:19 +00:00
position,
});
};
2024-09-24 20:49:17 +00:00
let compare_to = instruction.a_as_boolean();
2024-09-24 14:16:19 +00:00
if boolean == compare_to {
self.ip += 1;
} else {
let jump = self.chunk.get_instruction(self.ip, position)?.0;
2024-09-24 20:49:17 +00:00
let jump_distance = jump.a();
2024-10-06 01:30:48 +00:00
let is_positive = jump.b_as_boolean();
2024-09-24 14:16:19 +00:00
let new_ip = if is_positive {
self.ip + jump_distance as usize
} else {
self.ip - jump_distance as usize
};
self.ip = new_ip;
}
}
Operation::LessEqual => {
debug_assert_eq!(
self.chunk.get_instruction(self.ip, position)?.0.operation(),
Operation::Jump
);
2024-09-24 15:40:12 +00:00
2024-09-23 23:16:15 +00:00
let (left, right) = get_arguments(self, instruction, position)?;
let less_or_equal_result = left
2024-09-24 15:40:12 +00:00
.less_than_or_equal(right)
.map_err(|error| VmError::Value { error, position })?;
let boolean = if let Value::Primitive(Primitive::Boolean(boolean)) =
less_or_equal_result
{
boolean
} else {
return Err(VmError::ExpectedBoolean {
found: less_or_equal_result.clone(),
2024-09-24 14:16:19 +00:00
position,
});
};
2024-09-24 20:49:17 +00:00
let compare_to = instruction.a_as_boolean();
2024-09-24 14:16:19 +00:00
if boolean == compare_to {
self.ip += 1;
} else {
let jump = self.chunk.get_instruction(self.ip, position)?.0;
2024-09-24 20:49:17 +00:00
let jump_distance = jump.a();
2024-10-06 01:30:48 +00:00
let is_positive = jump.b_as_boolean();
2024-09-24 14:16:19 +00:00
let new_ip = if is_positive {
self.ip + jump_distance as usize
} else {
self.ip - jump_distance as usize
};
self.ip = new_ip;
}
}
Operation::Negate => {
2024-09-24 20:49:17 +00:00
let value = if instruction.b_is_constant() {
self.chunk.get_constant(instruction.b(), position)?
2024-09-18 01:10:44 +00:00
} else {
2024-09-24 20:49:17 +00:00
self.get(instruction.b(), position)?
2024-09-18 01:10:44 +00:00
};
let negated = value
.negate()
.map_err(|error| VmError::Value { error, position })?;
self.set(instruction.a(), negated, position)?;
}
Operation::Not => {
2024-09-24 20:49:17 +00:00
let value = if instruction.b_is_constant() {
self.chunk.get_constant(instruction.b(), position)?
2024-09-18 01:10:44 +00:00
} else {
2024-09-24 20:49:17 +00:00
self.get(instruction.b(), position)?
2024-09-18 01:10:44 +00:00
};
2024-09-18 11:58:31 +00:00
let not = value
.not()
.map_err(|error| VmError::Value { error, position })?;
self.set(instruction.a(), not, position)?;
}
Operation::Jump => {
2024-09-24 20:49:17 +00:00
let offset = instruction.b();
let is_positive = instruction.c_as_boolean();
let new_ip = if is_positive {
self.ip + offset as usize
} else {
2024-10-05 06:07:26 +00:00
self.ip - (offset + 1) as usize
};
self.ip = new_ip;
}
2024-10-12 14:55:34 +00:00
Operation::Call => {
2024-10-13 11:14:12 +00:00
let to_register = instruction.a();
let function_index = instruction.b();
2024-10-13 06:33:58 +00:00
let value = self.get(function_index, position)?.clone();
let function = if let Value::Function(function) = value {
2024-10-12 14:55:34 +00:00
function
} else {
2024-10-13 06:33:58 +00:00
return Err(VmError::ExpectedFunction {
found: value,
position,
});
2024-10-12 14:55:34 +00:00
};
let mut function_vm = Vm::new(function.take_chunk());
2024-10-12 14:55:34 +00:00
2024-10-13 11:14:12 +00:00
for argument_index in function_index + 1..to_register {
2024-10-13 08:21:07 +00:00
let argument = self.get(argument_index, position)?.clone();
2024-10-13 11:14:12 +00:00
let top_of_stack = function_vm.stack.len() as u8;
2024-10-12 14:55:34 +00:00
2024-10-13 11:14:12 +00:00
function_vm.set(top_of_stack, argument, position)?;
2024-10-12 14:55:34 +00:00
}
let return_value = function_vm.run()?;
if let Some(value) = return_value {
self.set(function_index, value, position)?;
} else {
self.empty(function_index, position)?;
2024-10-12 14:55:34 +00:00
}
}
Operation::Return => {
let should_return_value = instruction.b_as_boolean();
return if should_return_value {
let top_of_stack = (self.stack.len() - 1) as u8;
2024-10-12 14:55:34 +00:00
let value = self.empty(top_of_stack, position)?;
Ok(Some(value))
} else {
Ok(None)
};
}
}
}
Ok(None)
}
2024-10-13 08:21:07 +00:00
fn set(&mut self, to_register: u8, value: Value, position: Span) -> Result<(), VmError> {
let length = self.stack.len();
2024-10-13 08:21:07 +00:00
let to_register = to_register as usize;
2024-09-15 01:05:03 +00:00
if length == Self::STACK_LIMIT {
return Err(VmError::StackOverflow { position });
}
2024-10-13 08:21:07 +00:00
match to_register.cmp(&length) {
Ordering::Less => {
log::trace!("Replace R{to_register} with {value}");
2024-10-13 08:21:07 +00:00
self.stack[to_register] = Register::Value(value);
2024-10-13 08:21:07 +00:00
Ok(())
}
Ordering::Equal => {
log::trace!("Push R{to_register} with {value}");
2024-10-13 08:21:07 +00:00
self.stack.push(Register::Value(value));
2024-09-19 15:41:18 +00:00
2024-10-13 08:21:07 +00:00
Ok(())
}
Ordering::Greater => Err(VmError::SkippedRegister {
index: to_register,
length,
position,
}),
}
}
2024-09-19 15:41:18 +00:00
2024-10-13 08:21:07 +00:00
fn set_pointer(
&mut self,
to_register: u8,
from_register: u8,
position: Span,
) -> Result<(), VmError> {
let length = self.stack.len();
let to_register = to_register as usize;
if length == Self::STACK_LIMIT {
return Err(VmError::StackOverflow { position });
2024-09-19 15:41:18 +00:00
}
2024-10-13 08:21:07 +00:00
match to_register.cmp(&length) {
Ordering::Less => {
log::trace!("Replace R{to_register} with R{from_register}");
self.stack[to_register] = Register::Pointer(from_register);
Ok(())
}
Ordering::Equal => {
log::trace!("Push R{to_register} with R{from_register}");
self.stack.push(Register::Pointer(from_register));
Ok(())
}
Ordering::Greater => Err(VmError::SkippedRegister {
index: to_register,
length,
position,
}),
}
2024-09-19 15:41:18 +00:00
}
fn set_constant(
&mut self,
index: u8,
constant_index: u8,
position: Span,
) -> Result<(), VmError> {
let length = self.stack.len();
2024-09-23 12:57:49 +00:00
let index = index as usize;
if length == Self::STACK_LIMIT {
return Err(VmError::StackOverflow { position });
}
if index == length {
log::trace!("Push register {index} with constant {constant_index}");
self.stack.push(Register::Constant(constant_index));
2024-09-23 12:57:49 +00:00
return Ok(());
2024-09-23 12:57:49 +00:00
}
if index < length {
log::trace!("Replace register {index} with constant {constant_index}");
self.stack[index] = Register::Constant(constant_index);
return Ok(());
}
Err(VmError::SkippedRegister {
index,
length: self.stack.len(),
position,
})
2024-09-23 12:57:49 +00:00
}
pub fn get(&self, index: u8, position: Span) -> Result<&Value, VmError> {
2024-09-15 01:05:03 +00:00
let index = index as usize;
let register = self
.stack
.get(index)
2024-10-13 08:21:07 +00:00
.ok_or_else(|| VmError::RegisterIndexOutOfBounds { index, position })?;
2024-09-15 01:05:03 +00:00
match register {
Register::Value(value) => Ok(value),
Register::Pointer(register_index) => {
let value = self.get(*register_index, position)?;
2024-09-14 19:06:13 +00:00
Ok(value)
}
Register::Constant(constant_index) => {
let value = self.chunk.get_constant(*constant_index, position)?;
2024-09-14 19:06:13 +00:00
Ok(value)
}
Register::Empty => Err(VmError::EmptyRegister { index, position }),
}
}
fn take(&mut self, index: u8, point_to: u8, position: Span) -> Result<Value, VmError> {
2024-09-18 15:27:41 +00:00
let index = index as usize;
let register = replace(&mut self.stack[index], Register::Pointer(point_to));
2024-09-18 15:27:41 +00:00
match register {
Register::Value(value) => Ok(value),
Register::Pointer(register_index) => {
let value = self.take(register_index, point_to, position)?;
2024-09-18 15:27:41 +00:00
Ok(value)
}
Register::Constant(constant_index) => {
let value = self.chunk.take_constant(constant_index, position)?;
2024-09-18 15:27:41 +00:00
Ok(value)
}
Register::Empty => Err(VmError::EmptyRegister { index, position }),
2024-09-18 15:27:41 +00:00
}
}
2024-10-12 14:55:34 +00:00
fn empty(&mut self, index: u8, position: Span) -> Result<Value, VmError> {
let index = index as usize;
if index >= self.stack.len() {
2024-10-13 08:21:07 +00:00
return Err(VmError::RegisterIndexOutOfBounds { index, position });
2024-09-18 11:58:31 +00:00
}
let register = replace(&mut self.stack[index], Register::Empty);
match register {
Register::Value(value) => Ok(value),
Register::Pointer(register_index) => {
2024-10-12 14:55:34 +00:00
let value = self.empty(register_index, position)?;
Ok(value)
}
Register::Constant(constant_index) => {
let value = self.chunk.take_constant(constant_index, position)?;
Ok(value)
}
Register::Empty => Err(VmError::EmptyRegister { index, position }),
}
}
fn read(&mut self, position: Span) -> Result<&(Instruction, Span), VmError> {
let current = self.chunk.get_instruction(self.ip, position)?;
self.ip += 1;
Ok(current)
}
}
#[derive(Debug, Eq, PartialEq)]
enum Register {
Empty,
Value(Value),
Pointer(u8),
Constant(u8),
}
#[derive(Debug, Clone, PartialEq)]
pub enum VmError {
CannotMutateImmutableLocal {
identifier: Identifier,
position: Span,
},
EmptyRegister {
index: usize,
position: Span,
},
2024-09-19 15:41:18 +00:00
ExpectedBoolean {
found: Value,
position: Span,
},
2024-10-13 06:33:58 +00:00
ExpectedFunction {
found: Value,
position: Span,
},
RegisterIndexOutOfBounds {
2024-10-13 08:21:07 +00:00
index: usize,
position: Span,
},
InvalidInstruction {
instruction: Instruction,
position: Span,
},
SkippedRegister {
index: usize,
length: usize,
position: Span,
},
StackOverflow {
position: Span,
},
StackUnderflow {
position: Span,
},
UndefinedVariable {
identifier: Identifier,
position: Span,
},
// Wrappers for foreign errors
Chunk(ChunkError),
Value {
error: ValueError,
position: Span,
},
}
impl From<ChunkError> for VmError {
2024-09-18 15:27:41 +00:00
fn from(error: ChunkError) -> Self {
Self::Chunk(error)
}
}
impl AnnotatedError for VmError {
fn title() -> &'static str {
"Runtime Error"
}
fn description(&self) -> &'static str {
match self {
Self::CannotMutateImmutableLocal { .. } => "Cannot mutate immutable variable",
Self::EmptyRegister { .. } => "Empty register",
2024-09-19 15:41:18 +00:00
Self::ExpectedBoolean { .. } => "Expected boolean",
2024-10-13 06:33:58 +00:00
Self::ExpectedFunction { .. } => "Expected function",
Self::RegisterIndexOutOfBounds { .. } => "Register index out of bounds",
Self::InvalidInstruction { .. } => "Invalid instruction",
Self::SkippedRegister { .. } => "Skipped register",
Self::StackOverflow { .. } => "Stack overflow",
Self::StackUnderflow { .. } => "Stack underflow",
Self::UndefinedVariable { .. } => "Undefined variable",
2024-09-18 11:58:31 +00:00
Self::Chunk(error) => error.description(),
Self::Value { .. } => "Value error",
}
}
fn details(&self) -> Option<String> {
match self {
Self::EmptyRegister { index, .. } => Some(format!("Register {index} is empty")),
2024-10-13 06:33:58 +00:00
Self::ExpectedFunction { found, .. } => Some(format!("{found} is not a function")),
2024-10-13 08:21:07 +00:00
Self::RegisterIndexOutOfBounds { index, .. } => {
Some(format!("R{index} does not exist at this time"))
}
Self::UndefinedVariable { identifier, .. } => {
Some(format!("{identifier} is not in scope"))
}
Self::Chunk(error) => error.details(),
Self::Value { error, .. } => Some(error.to_string()),
_ => None,
}
}
fn position(&self) -> Span {
match self {
Self::CannotMutateImmutableLocal { position, .. } => *position,
Self::EmptyRegister { position, .. } => *position,
2024-09-19 15:41:18 +00:00
Self::ExpectedBoolean { position, .. } => *position,
2024-10-13 06:33:58 +00:00
Self::ExpectedFunction { position, .. } => *position,
2024-10-13 08:21:07 +00:00
Self::RegisterIndexOutOfBounds { position, .. } => *position,
Self::InvalidInstruction { position, .. } => *position,
Self::SkippedRegister { position, .. } => *position,
Self::StackUnderflow { position } => *position,
Self::StackOverflow { position } => *position,
Self::UndefinedVariable { position, .. } => *position,
Self::Chunk(error) => error.position(),
Self::Value { position, .. } => *position,
}
}
}