mirascript-vm 0.1.105

Native Rust virtual machine for MiraScript
Documentation
use indexmap::IndexMap;

use super::*;
use crate::{MiraHandle, MiraManageable, bytecode::Program, value::ANONYMOUS_FN_NAME};

pub(crate) struct ScriptModule {
    pub(crate) execution: ExecutionId,
    pub(crate) _program: Rc<Program>,
    pub(crate) frame: FrameId,
    pub(crate) exports: IndexMap<String, RegisterId>,
    pub(crate) name: Rc<str>,
}

impl MiraModule for ScriptModule {
    fn name(&self) -> &str {
        &self.name
    }

    fn len(&self) -> usize {
        self.exports.len()
    }

    fn index_of(&self, key: &str) -> Option<usize> {
        self.exports.get_index_of(key)
    }

    fn key(&self, index: usize) -> Result<&str> {
        self.exports
            .get_index(index)
            .map(|(key, _)| key.as_str())
            .ok_or_else(|| MiraError::runtime(RuntimeErrorKind::MissingIndexOrField))
    }

    fn get(
        &self,
        _self_handle: MiraHandle<dyn MiraModule>,
        runtime: &Runtime,
        index: usize,
    ) -> Result<MiraManageable> {
        if self.execution != runtime.execution {
            return Err(MiraError::runtime(RuntimeErrorKind::ExecutionEnded));
        }
        let (_, register) = self
            .exports
            .get_index(index)
            .ok_or_else(|| MiraError::runtime(RuntimeErrorKind::MissingIndexOrField))?;
        runtime.read_register(self.frame, *register).map(Into::into)
    }
}

impl Runtime {
    pub(super) fn create_frame(
        &mut self,
        register_count: usize,
        parent: Option<FrameId>,
    ) -> FrameId {
        self.frames.push(register_count, parent)
    }

    pub(super) fn parent_frame(&self, mut frame: FrameId, level: usize) -> Result<FrameId> {
        for _ in 0..level {
            frame = self.frames.get(frame).parent.ok_or_else(|| {
                MiraError::runtime(RuntimeErrorKind::InvalidUpvalueLevel { level })
            })?;
        }
        Ok(frame)
    }

    pub(super) fn execute_block(&mut self, body: &[Instruction], frame: FrameId) -> Result<Flow> {
        for instruction in body {
            let result = match self.execute_instruction(instruction, frame) {
                Ok(result) => result,
                Err(error) => {
                    return Err(self.with_runtime_context(*error, instruction.offset));
                }
            };
            if !matches!(result, Flow::Continue) {
                return Ok(result);
            }
        }
        Ok(Flow::Continue)
    }

    #[cold]
    #[inline(never)]
    pub(super) fn with_runtime_context(&self, error: MiraError, offset: usize) -> Box<MiraError> {
        let display = |handle| {
            self.get_function_dyn(handle)
                .expect("call stack function handles must remain valid")
                .name()
                .to_owned()
        };
        let function = self.call_stack.last().map(&display);
        let stack = self.call_stack.iter().map(display).collect();
        Box::new(error.with_runtime_context(function, offset, stack))
    }

    pub(super) fn execute_instruction(
        &mut self,
        instruction: &Instruction,
        frame: FrameId,
    ) -> Result<Flow> {
        match &instruction.kind {
            InstructionKind::Op(operation) => self.execute_op(operation, frame),
            InstructionKind::Function {
                destination,
                function,
            } => {
                let function = ScriptFunction {
                    execution: self.execution,
                    program: Rc::clone(self.active_program()),
                    function: *function,
                    frame,
                    name: ANONYMOUS_FN_NAME.into(),
                };
                let value = self.insert(MiraManageable::from_function(function))?;
                self.write_register(frame, *destination, value);
                Ok(Flow::Continue)
            }
            InstructionKind::If {
                condition,
                register,
                then_body,
                else_body,
            } => {
                let raw = self.read_register_raw(frame, *register);
                let matches = match condition {
                    Condition::Truthy => operations::to_boolean(raw.check()?)?,
                    Condition::Falsy => !operations::to_boolean(raw.check()?)?,
                    Condition::Initialized => !raw.is_uninitialized(),
                    Condition::Uninitialized => raw.is_uninitialized(),
                    Condition::Nil => raw.unwrap().is_nil(),
                    Condition::NonNil => !raw.unwrap().is_nil(),
                };
                self.execute_block(if matches { then_body } else { else_body }, frame)
            }
            InstructionKind::Loop {
                register_count,
                kind,
                body,
                reuse_frame,
            } => self.execute_loop(*register_count, kind, body, frame, *reuse_frame),
            InstructionKind::Record {
                destination,
                elements,
            } => {
                let value = self.build_record(elements, frame)?;
                self.write_register(frame, *destination, value);
                Ok(Flow::Continue)
            }
            InstructionKind::Array {
                destination,
                elements,
            } => {
                let value = self.build_array(elements, frame)?;
                self.write_register(frame, *destination, value);
                Ok(Flow::Continue)
            }
            InstructionKind::Module {
                destination,
                name,
                fields,
            } => {
                let module = ScriptModule {
                    execution: self.execution,
                    _program: Rc::clone(self.active_program()),
                    frame,
                    exports: fields.iter().map(|(f, r)| (f.clone(), *r)).collect(),
                    name: Rc::from(name.as_str()),
                };
                let value = self.insert(MiraManageable::from_module(module))?;
                self.write_register(frame, *destination, value);
                Ok(Flow::Continue)
            }
        }
    }

    pub(super) fn execute_loop(
        &mut self,
        register_count: usize,
        kind: &LoopKind,
        body: &[Instruction],
        parent: FrameId,
        reuse_frame: bool,
    ) -> Result<Flow> {
        let mut reusable_frame = None;
        match kind {
            LoopKind::Infinite => loop {
                self.checkpoint()?;
                let frame =
                    self.loop_frame(register_count, parent, reuse_frame, &mut reusable_frame);
                match self.execute_block(body, frame)? {
                    Flow::Continue | Flow::LoopContinue => {}
                    Flow::Break => return Ok(Flow::Continue),
                    flow @ Flow::Return(_) => return Ok(flow),
                }
            },
            LoopKind::Iterable { value } => {
                let value = self.read_register(parent, *value)?;
                let items = operations::iterable(self, value)?;
                for item in items {
                    self.checkpoint()?;
                    let frame =
                        self.loop_frame(register_count, parent, reuse_frame, &mut reusable_frame);
                    self.write_register(frame, RegisterId::new(1), item);
                    match self.execute_block(body, frame)? {
                        Flow::Continue | Flow::LoopContinue => {}
                        Flow::Break => break,
                        flow @ Flow::Return(_) => return Ok(flow),
                    }
                }
                Ok(Flow::Continue)
            }
            LoopKind::Range {
                start,
                end,
                exclusive,
            } => {
                let mut value = self.read_number(parent, *start)?;
                let end = self.read_number(parent, *end)?;
                while if *exclusive {
                    value < end
                } else {
                    value <= end
                } {
                    self.checkpoint()?;
                    let frame =
                        self.loop_frame(register_count, parent, reuse_frame, &mut reusable_frame);
                    self.write_register(frame, RegisterId::new(1), MiraValue::number(value));
                    match self.execute_block(body, frame)? {
                        Flow::Continue | Flow::LoopContinue => {}
                        Flow::Break => break,
                        flow @ Flow::Return(_) => return Ok(flow),
                    }
                    value += 1.0;
                }
                Ok(Flow::Continue)
            }
        }
    }

    fn loop_frame(
        &mut self,
        register_count: usize,
        parent: FrameId,
        reuse_frame: bool,
        reusable_frame: &mut Option<FrameId>,
    ) -> FrameId {
        if let Some(frame) = *reusable_frame {
            self.frames.reset(frame, Some(parent));
            return frame;
        }
        let frame = self.create_frame(register_count, Some(parent));
        if reuse_frame {
            *reusable_frame = Some(frame);
        }
        frame
    }

    fn build_record(&mut self, elements: &[RecordElement], frame: FrameId) -> Result<MiraValue> {
        let mut record = IndexMap::with_capacity(elements.len());
        for element in elements {
            match element {
                RecordElement::Field {
                    key,
                    value,
                    optional,
                } => {
                    let value = self.read_register(frame, *value)?;
                    if *optional && (value.is_nil() || value.is_function() || value.is_module()) {
                        continue;
                    }
                    let key = match key {
                        RecordKey::Constant(key) => key.clone(),
                        RecordKey::Dynamic(register) => {
                            let key = self.read_register(frame, *register)?;
                            operations::to_string(self, key)?
                        }
                        RecordKey::Index(index) => index.to_string(),
                    };
                    record.insert(key, operations::into_element(value));
                }
                RecordElement::Spread(register) => {
                    let value = self.read_register(frame, *register)?;
                    record.extend(operations::record_spread(self, value)?);
                }
            }
        }
        self.insert(record)
    }

    fn build_array(&mut self, elements: &[ArrayElement], frame: FrameId) -> Result<MiraValue> {
        let mut array = Vec::with_capacity(elements.len());
        for element in elements {
            match element {
                ArrayElement::Item(register) => array.push(operations::into_element(
                    self.read_register(frame, *register)?,
                )),
                ArrayElement::Spread(register) => {
                    let value = self.read_register(frame, *register)?;
                    array.extend(
                        operations::array_spread(self, value)?
                            .into_iter()
                            .map(operations::into_element),
                    );
                }
                ArrayElement::Range {
                    start,
                    end,
                    exclusive,
                } => {
                    let start = match start {
                        RangeEndpoint::Constant(value) => MiraValue::number(*value as f64),
                        RangeEndpoint::Dynamic(register) => self.read_register(frame, *register)?,
                    };
                    let end = match end {
                        RangeEndpoint::Constant(value) => MiraValue::number(*value as f64),
                        RangeEndpoint::Dynamic(register) => self.read_register(frame, *register)?,
                    };
                    array.extend(operations::array_range(
                        self,
                        start,
                        end,
                        *exclusive,
                        self.options.max_array_len.saturating_sub(array.len()),
                    )?);
                }
            }
            if array.len() > self.options.max_array_len {
                return Err(MiraError::runtime(RuntimeErrorKind::ArrayLimit {
                    requested: array.len(),
                    max: self.options.max_array_len,
                }));
            }
        }
        self.insert(array)
    }
}