Base initial commit
Still WIP, working on object system still, which in Rust, makes me want to kill myself Signed-off-by: Alek Ratzloff <alekratz@gmail.com>
This commit is contained in:
350
src/vm.rs
Normal file
350
src/vm.rs
Normal file
@@ -0,0 +1,350 @@
|
||||
use std::sync::Arc;
|
||||
|
||||
use crate::builtins;
|
||||
use crate::obj::*;
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq)]
|
||||
pub enum Op {
|
||||
// Stack functions
|
||||
Pop,
|
||||
PushConstant(LongOpArg),
|
||||
|
||||
// Variables
|
||||
GetLocal(LocalIndex),
|
||||
SetLocal(LocalIndex),
|
||||
GetGlobal(GlobalId),
|
||||
SetGlobal(GlobalId),
|
||||
|
||||
// Attributes
|
||||
GetAttr(ConstantId),
|
||||
SetAttr(ConstantId),
|
||||
|
||||
// Jumps
|
||||
Jump(JumpOpArg),
|
||||
JumpFalse(JumpOpArg),
|
||||
JumpTrue(JumpOpArg),
|
||||
|
||||
// Functions
|
||||
Call(Argc),
|
||||
Return,
|
||||
CloseOver { depth: ShortOpArg, slot: ShortOpArg },
|
||||
|
||||
// VM control
|
||||
Halt,
|
||||
}
|
||||
|
||||
pub type LineRange = (usize, usize);
|
||||
|
||||
type ShortOpArg = u16;
|
||||
type LongOpArg = u32;
|
||||
|
||||
pub type JumpOpArg = i32;
|
||||
pub type LocalIndex = LongOpArg;
|
||||
pub type LocalSlot = ShortOpArg;
|
||||
pub type ConstantId = LongOpArg;
|
||||
pub type GlobalId = LongOpArg;
|
||||
pub type Argc = LongOpArg;
|
||||
pub type FrameDepth = ShortOpArg;
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Local {
|
||||
pub(crate) slot: LocalSlot,
|
||||
pub(crate) index: LocalIndex,
|
||||
pub(crate) name: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Default, Clone)]
|
||||
pub struct Chunk {
|
||||
pub(crate) code: Vec<Op>,
|
||||
pub(crate) lines: Vec<LineRange>,
|
||||
pub(crate) locals: Vec<Local>,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Frame {
|
||||
pub(crate) name: Arc<String>,
|
||||
pub(crate) chunk: Arc<Chunk>,
|
||||
pub(crate) ip: usize,
|
||||
pub(crate) stack_base: usize,
|
||||
}
|
||||
|
||||
impl Frame {
|
||||
pub fn new(name: Arc<String>, chunk: Arc<Chunk>, stack_base: usize) -> Self {
|
||||
Self {
|
||||
name,
|
||||
chunk,
|
||||
ip: 0,
|
||||
stack_base,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct Vm {
|
||||
constants: Vec<ObjP>,
|
||||
//global_names: Vec<String>,
|
||||
globals: Vec<ObjP>,
|
||||
stack: Vec<ObjP>,
|
||||
frames: Vec<Frame>,
|
||||
}
|
||||
|
||||
impl Vm {
|
||||
/// Create a new virtual machine with the given chunk, constants, and global names.
|
||||
pub fn new(chunk: Arc<Chunk>, constants: Vec<ObjP>, global_names: Vec<String>) -> Self {
|
||||
// set up globals
|
||||
let nil = NilInst::create();
|
||||
let mut globals: Vec<_> = global_names
|
||||
.iter()
|
||||
.map(|_| Ptr::clone(&nil) as ObjP)
|
||||
.collect();
|
||||
|
||||
let mut register_global = |name: &str, value: ObjP| {
|
||||
let index = global_names
|
||||
.iter()
|
||||
.position(|global| global == name)
|
||||
.expect("could not find global");
|
||||
globals[index] = value;
|
||||
};
|
||||
|
||||
register_global(
|
||||
"print",
|
||||
BuiltinFunctionInst::create("print".to_string(), builtins::print, 1),
|
||||
);
|
||||
register_global(
|
||||
"println",
|
||||
BuiltinFunctionInst::create("println".to_string(), builtins::println, 1),
|
||||
);
|
||||
|
||||
// stack and frames
|
||||
let stack = Vec::new();
|
||||
let frames = vec![Frame::new("__main__".to_string().into(), chunk, 0)];
|
||||
|
||||
Vm {
|
||||
constants,
|
||||
//global_names,
|
||||
globals,
|
||||
stack,
|
||||
frames,
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the stack.
|
||||
pub fn stack(&self) -> &Vec<ObjP> {
|
||||
&self.stack
|
||||
}
|
||||
|
||||
/// Current stack frame.
|
||||
pub fn frame(&self) -> &Frame {
|
||||
self.frames.last().unwrap()
|
||||
}
|
||||
|
||||
/// Current stack frame, mutably.
|
||||
pub fn frame_mut(&mut self) -> &mut Frame {
|
||||
self.frames.last_mut().unwrap()
|
||||
}
|
||||
|
||||
/// Push a new stack frame.
|
||||
pub fn push_frame(&mut self, frame: Frame) {
|
||||
self.frames.push(frame);
|
||||
}
|
||||
|
||||
/// Pop the current stack frame.
|
||||
pub fn pop_frame(&mut self) -> Frame {
|
||||
self.frames.pop().expect("no frame")
|
||||
}
|
||||
|
||||
/// Gets the chunk of the currently executing frame.
|
||||
pub fn chunk(&self) -> &Chunk {
|
||||
&self.frame().chunk
|
||||
}
|
||||
|
||||
/// Instruction pointer of the current frame.
|
||||
pub fn ip(&self) -> usize {
|
||||
self.frame().ip
|
||||
}
|
||||
|
||||
/// Update the current instruction pointer.
|
||||
pub fn set_ip(&mut self, ip: usize) {
|
||||
self.frame_mut().ip = ip;
|
||||
}
|
||||
|
||||
/*
|
||||
/// Gets the line of the current instruction.
|
||||
fn line(&self, offset: isize) -> LineRange {
|
||||
let index = (((self.ip() as isize) + offset).max(0) as usize).min(self.chunk().lines.len());
|
||||
self.chunk().lines[index]
|
||||
}
|
||||
*/
|
||||
|
||||
/// Get the current instruction and advance the IP.
|
||||
fn next(&mut self) -> Op {
|
||||
let ip = self.ip();
|
||||
self.set_ip(ip + 1);
|
||||
self.chunk().code[ip]
|
||||
}
|
||||
|
||||
/// Pop a value from the stack.
|
||||
pub fn pop(&mut self) -> ObjP {
|
||||
self.stack.pop().expect("stack empty")
|
||||
}
|
||||
|
||||
/// Peek the top value of the stack.
|
||||
pub fn peek(&self) -> ObjP {
|
||||
self.stack.last().map(Ptr::clone).expect("stack empty")
|
||||
}
|
||||
|
||||
/// Push a value to the stack.
|
||||
pub fn push(&mut self, value: ObjP) {
|
||||
self.stack.push(value);
|
||||
}
|
||||
|
||||
pub fn run(&mut self) {
|
||||
loop {
|
||||
match self.next() {
|
||||
Op::Pop => {
|
||||
self.pop();
|
||||
}
|
||||
Op::PushConstant(constant_id) => {
|
||||
let constant = Ptr::clone(&self.constants[constant_id as usize]);
|
||||
self.push(constant);
|
||||
}
|
||||
Op::GetLocal(local_index) => {
|
||||
let local = &self.chunk().locals[local_index as usize];
|
||||
let value =
|
||||
Ptr::clone(&self.stack[self.frame().stack_base + local.slot as usize]);
|
||||
self.push(value);
|
||||
}
|
||||
Op::SetLocal(local_index) => {
|
||||
let value = self.pop();
|
||||
let local = &self.chunk().locals[local_index as usize];
|
||||
let index = self.frame().stack_base + local.slot as usize;
|
||||
self.stack[index] = value;
|
||||
}
|
||||
Op::GetGlobal(global_index) => {
|
||||
let value = Ptr::clone(&self.globals[global_index as usize]);
|
||||
self.push(value);
|
||||
}
|
||||
Op::SetGlobal(global_index) => {
|
||||
let value = self.pop();
|
||||
self.globals[global_index as usize] = value;
|
||||
}
|
||||
Op::GetAttr(constant_id) => {
|
||||
// need both declarations to borrow cell value
|
||||
let name_obj = Ptr::clone(&self.constants[constant_id as usize]);
|
||||
let name =
|
||||
with_obj_downcast(name_obj, |name: &StrInst| Arc::clone(&name.str_value()));
|
||||
let owner = self.pop();
|
||||
let value = owner.try_read().unwrap().get_attr(&name);
|
||||
if let Some(value) = value {
|
||||
self.push(value);
|
||||
} else {
|
||||
// TODO Vm::run, Op::GetAttr - throw an exception when the attribute
|
||||
// doesn't exist
|
||||
// BLOCKED-ON: exceptions
|
||||
todo!(
|
||||
"throw an error because we couldn't read attr '{}' on '{}'",
|
||||
name,
|
||||
owner.try_read().unwrap(),
|
||||
);
|
||||
}
|
||||
}
|
||||
Op::SetAttr(constant_id) => {
|
||||
let name_obj = Ptr::clone(&self.constants[constant_id as usize]);
|
||||
let name =
|
||||
with_obj_downcast(name_obj, |name: &StrInst| Arc::clone(&name.str_value()));
|
||||
let value = self.pop();
|
||||
let target = self.pop();
|
||||
|
||||
let mut target_ptr = target.try_write().unwrap();
|
||||
target_ptr.set_attr(&name, value);
|
||||
}
|
||||
Op::Jump(offset) => {
|
||||
let base = (self.ip() - 1) as JumpOpArg;
|
||||
assert!(base + offset > 0, "tried to jump to negative IP");
|
||||
self.set_ip((base + offset) as usize);
|
||||
}
|
||||
Op::JumpFalse(offset) => {
|
||||
let base = (self.ip() - 1) as JumpOpArg;
|
||||
let value = self.peek();
|
||||
if !value.try_read().unwrap().is_truthy() {
|
||||
self.set_ip((base + offset) as usize);
|
||||
}
|
||||
}
|
||||
Op::JumpTrue(offset) => {
|
||||
let base = (self.ip() - 1) as JumpOpArg;
|
||||
let value = self.peek();
|
||||
if value.try_read().unwrap().is_truthy() {
|
||||
self.set_ip((base + offset) as usize);
|
||||
}
|
||||
}
|
||||
Op::Call(argc) => {
|
||||
let argc = argc as usize;
|
||||
let index = self.stack.len() - argc - 1;
|
||||
let fun_ptr = Ptr::clone(&self.stack[index]);
|
||||
let fun_ptr = fun_ptr.try_read().unwrap();
|
||||
|
||||
let arity = if let Some(arity) = fun_ptr.arity() {
|
||||
arity as usize
|
||||
} else {
|
||||
// TODO Vm::run, Op::Call - throw an exception when the value isn't
|
||||
// callable
|
||||
// BLOCKED-ON: exceptions
|
||||
todo!("throw an error because we couldn't call {}", fun_ptr);
|
||||
};
|
||||
|
||||
// Methods with bound "self" parameter
|
||||
// argc may be mutated
|
||||
let mut argc = argc;
|
||||
if let Some(method) = fun_ptr.as_any().downcast_ref::<MethodInst>() {
|
||||
// shift all of the arguments over by one
|
||||
// (duplicate the last item on the stack and then shift everyone else over)
|
||||
self.stack
|
||||
.insert(self.stack.len() - argc, Ptr::clone(method.self_binding()));
|
||||
// also increment argc since we're specifying another arg
|
||||
argc += 1;
|
||||
}
|
||||
// remove mutability
|
||||
let argc = argc;
|
||||
|
||||
if arity != argc {
|
||||
// TODO Vm::run, Op::Call - throw an exception when the number of arguments
|
||||
// does not match the function's arity
|
||||
// BLOCKED-ON: exceptions
|
||||
todo!(
|
||||
"throw an error because we passed the wrong number of arguments to {}",
|
||||
fun_ptr
|
||||
);
|
||||
}
|
||||
fun_ptr.call(self, argc as Argc);
|
||||
}
|
||||
Op::Return => {
|
||||
let return_value = self.pop();
|
||||
let old_frame = self.frames.pop().unwrap();
|
||||
// stack_base is always going to be <= current stack size
|
||||
self.stack
|
||||
.resize_with(old_frame.stack_base, || unreachable!());
|
||||
// also pop the function object off of the stack
|
||||
self.stack.pop();
|
||||
self.push(return_value);
|
||||
}
|
||||
Op::CloseOver { depth, slot } => {
|
||||
// since we're closing over a value, and functions ultimately come from
|
||||
// constants, we want to deep-clone this object so we don't alter any live
|
||||
// objects.
|
||||
// there is some room for optimization here so we aren't cloning the entire
|
||||
// UserFunctionInst for every individual capture in a function.
|
||||
let fun_ptr = self.pop();
|
||||
let mut fun: UserFunctionInst =
|
||||
with_obj_downcast(fun_ptr, UserFunctionInst::clone);
|
||||
let frame_index = self.frames.len() - (depth as usize) - 1;
|
||||
let stack_base = self.frames[frame_index].stack_base;
|
||||
let value = Ptr::clone(&self.stack[stack_base + (slot as usize)]);
|
||||
fun.push_capture(value);
|
||||
self.push(make_ptr(fun));
|
||||
}
|
||||
Op::Halt => {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user