mirascript-vm 0.1.87

Native Rust virtual machine for MiraScript
Documentation
use super::*;

impl<'a> Runtime<'a> {
    pub(super) fn create_frame(&mut self, register_count: usize, parent: Option<usize>) -> usize {
        self.frames.push(Frame {
            registers: vec![MiraAny::Uninitialized; register_count + 1],
            parent,
        })
    }

    pub(super) fn read_register(&self, frame: usize, register: usize) -> MiraAny {
        if register == 0 {
            MiraAny::Nil
        } else {
            self.frames.get(frame).registers[register].clone()
        }
    }

    #[inline]
    pub(super) fn read_number(&self, frame: usize, register: usize) -> Result<f64> {
        if register == 0 {
            return operations::to_number(&MiraAny::Nil);
        }
        match &self.frames.get(frame).registers[register] {
            MiraAny::Number(value) => Ok(*value),
            value => operations::to_number(value),
        }
    }

    pub(super) fn write_register(&mut self, frame: usize, register: usize, value: MiraAny) {
        if register != 0 {
            self.frames.get_mut(frame).registers[register] = value;
        }
    }

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

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

    pub(super) fn with_runtime_context(&self, error: MiraError, offset: usize) -> MiraError {
        let display = |name: &Option<Rc<str>>| name.as_deref().unwrap_or("<anonymous>").to_owned();
        let function = self.call_stack.last().map(display);
        let stack = self.call_stack.iter().map(display).collect();
        error.with_runtime_context(function, offset, stack)
    }

    pub(super) fn execute_instruction(
        &mut self,
        instruction: &Instruction,
        frame: usize,
    ) -> Result<Flow> {
        match &instruction.kind {
            InstructionKind::Op(operation) => self.execute_op(operation, frame),
            InstructionKind::Function {
                destination,
                function,
            } => {
                self.write_register(
                    frame,
                    *destination,
                    MiraAny::Function(MiraFunction::Script {
                        execution: self.execution,
                        function: *function,
                        frame,
                        name: None,
                    }),
                );
                Ok(Flow::Continue)
            }
            InstructionKind::If {
                condition,
                register,
                then_body,
                else_body,
            } => {
                let value = self.read_register(frame, *register);
                let matches = match condition {
                    Condition::Truthy => operations::to_boolean(&value)?,
                    Condition::Falsy => !operations::to_boolean(&value)?,
                    Condition::Initialized => value.is_initialized(),
                    Condition::Uninitialized => !value.is_initialized(),
                    Condition::Nil => matches!(value, MiraAny::Nil),
                    Condition::NonNil => !matches!(value, MiraAny::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,
                    frame,
                    exports: fields.iter().cloned().collect(),
                    name: Rc::from(name.as_str()),
                };
                self.write_register(
                    frame,
                    *destination,
                    MiraAny::Module(MiraModule::Script(Rc::new(module))),
                );
                Ok(Flow::Continue)
            }
        }
    }

    pub(super) fn execute_loop(
        &mut self,
        register_count: usize,
        kind: &LoopKind,
        body: &[Instruction],
        parent: usize,
        reuse_frame: bool,
    ) -> Result<Flow> {
        let mut reusable_frame = None;
        match kind {
            LoopKind::Infinite => loop {
                self.checkpoint_now()?;
                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 items = operations::iterable(&self.read_register(parent, *value))?;
                for item in items {
                    self.checkpoint_now()?;
                    let frame =
                        self.loop_frame(register_count, parent, reuse_frame, &mut reusable_frame);
                    self.write_register(frame, 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 = operations::to_number(&self.read_register(parent, *start))?;
                let end = operations::to_number(&self.read_register(parent, *end))?;
                while if *exclusive {
                    value < end
                } else {
                    value <= end
                } {
                    self.checkpoint_now()?;
                    let frame =
                        self.loop_frame(register_count, parent, reuse_frame, &mut reusable_frame);
                    self.write_register(frame, 1, MiraAny::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)
            }
        }
    }

    pub(super) fn loop_frame(
        &mut self,
        register_count: usize,
        parent: usize,
        reuse_frame: bool,
        reusable_frame: &mut Option<usize>,
    ) -> usize {
        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
    }

    pub(super) fn build_record(&self, elements: &[RecordElement], frame: usize) -> Result<MiraAny> {
        let mut record = IndexMap::new();
        for element in elements {
            match element {
                RecordElement::Field {
                    key,
                    value,
                    optional,
                } => {
                    let value = self.read_register(frame, *value);
                    operations::assert_initialized(&value)?;
                    if *optional
                        && (matches!(value, MiraAny::Nil)
                            || matches!(
                                value,
                                MiraAny::Function(_) | MiraAny::Module(_) | MiraAny::Extern(_)
                            ))
                    {
                        continue;
                    }
                    let key = match key {
                        RecordKey::Constant(key) => key.clone(),
                        RecordKey::Dynamic(register) => {
                            operations::to_string(&self.read_register(frame, *register))?
                        }
                        RecordKey::Index(index) => index.to_string(),
                    };
                    record.insert(key, value.into_element()?);
                }
                RecordElement::Spread(register) => {
                    let spread = operations::record_spread(&self.read_register(frame, *register))?;
                    record.extend(spread);
                }
            }
        }
        Ok(MiraAny::Record(record))
    }

    pub(super) fn build_array(&self, elements: &[ArrayElement], frame: usize) -> Result<MiraAny> {
        let mut array = Vec::new();
        for element in elements {
            match element {
                ArrayElement::Item(register) => {
                    array.push(self.read_register(frame, *register).into_element()?)
                }
                ArrayElement::Spread(register) => {
                    for item in operations::array_spread(&self.read_register(frame, *register))? {
                        array.push(item.into_element()?);
                    }
                }
                ArrayElement::Range {
                    start,
                    end,
                    exclusive,
                } => {
                    let start = match start {
                        RangeEndpoint::Constant(value) => MiraAny::Number(*value as f64),
                        RangeEndpoint::Dynamic(register) => self.read_register(frame, *register),
                    };
                    let end = match end {
                        RangeEndpoint::Constant(value) => MiraAny::Number(*value as f64),
                        RangeEndpoint::Dynamic(register) => self.read_register(frame, *register),
                    };
                    array.extend(operations::array_range(
                        &start,
                        &end,
                        *exclusive,
                        self.options.max_array_len.saturating_sub(array.len()),
                    )?);
                }
            }
            if array.len() > self.options.max_array_len {
                return Err(MiraError::runtime(format!(
                    "Array length exceeds maximum limit of {}",
                    self.options.max_array_len
                )));
            }
        }
        Ok(MiraAny::Array(array))
    }
}