mirascript-vm 0.1.87

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

impl Runtime<'_> {
    pub(super) fn execute_op(&mut self, operation: &Operation, frame: usize) -> Result<Flow> {
        match operation {
            Operation::Noop => {}
            Operation::Break => return Ok(Flow::Break),
            Operation::Continue => return Ok(Flow::LoopContinue),
            Operation::Return { value } => {
                return Ok(Flow::Return(self.read_register(frame, *value)));
            }
            Operation::Constant {
                destination,
                constant,
            } => self.write_register(
                frame,
                *destination,
                self.program.constants[*constant].clone(),
            ),
            Operation::Uninit { destination } => {
                self.write_register(frame, *destination, MiraAny::Uninitialized)
            }
            Operation::Unary {
                kind,
                destination,
                value,
            } => {
                let value = self.read_register(frame, *value);
                let result = match kind {
                    UnaryOperation::Pos | UnaryOperation::Plus => {
                        MiraAny::Number(operations::to_number(&value)?)
                    }
                    UnaryOperation::Neg => MiraAny::Number(-operations::to_number(&value)?),
                    UnaryOperation::Not => MiraAny::Boolean(!operations::to_boolean(&value)?),
                    UnaryOperation::Type => MiraAny::String(value.type_name().into()),
                    UnaryOperation::ToBoolean => MiraAny::Boolean(operations::to_boolean(&value)?),
                    UnaryOperation::ToNumber => MiraAny::Number(operations::to_number(&value)?),
                    UnaryOperation::ToString => MiraAny::String(operations::to_string(&value)?),
                    UnaryOperation::IsBoolean
                    | UnaryOperation::IsNumber
                    | UnaryOperation::IsString
                    | UnaryOperation::IsRecord
                    | UnaryOperation::IsArray => {
                        operations::assert_initialized(&value)?;
                        MiraAny::Boolean(match kind {
                            UnaryOperation::IsBoolean => matches!(value, MiraAny::Boolean(_)),
                            UnaryOperation::IsNumber => matches!(value, MiraAny::Number(_)),
                            UnaryOperation::IsString => matches!(value, MiraAny::String(_)),
                            UnaryOperation::IsRecord => {
                                matches!(value, MiraAny::Record(_) | MiraAny::RustRecord(_))
                            }
                            UnaryOperation::IsArray => {
                                matches!(value, MiraAny::Array(_) | MiraAny::RustArray(_))
                            }
                            _ => unreachable!(),
                        })
                    }
                    UnaryOperation::Assign => value,
                    UnaryOperation::Length => MiraAny::Number(operations::length(&value)? as f64),
                };
                self.write_register(frame, *destination, result);
            }
            Operation::Numeric {
                kind,
                destination,
                left,
                right,
            } => {
                let left = self.read_number(frame, *left)?;
                let right = self.read_number(frame, *right)?;
                let result = MiraAny::Number(match kind {
                    NumericOperation::Add => left + right,
                    NumericOperation::Sub => left - right,
                    NumericOperation::Mul => left * right,
                    NumericOperation::Div => left / right,
                    NumericOperation::Mod => left % right,
                    NumericOperation::Pow => left.powf(right),
                });
                self.write_register(frame, *destination, result);
            }
            Operation::Binary {
                kind,
                destination,
                left,
                right,
            } => {
                let left = self.read_register(frame, *left);
                let right = self.read_register(frame, *right);
                let result = match kind {
                    BinaryOperation::Eq
                    | BinaryOperation::Neq
                    | BinaryOperation::Same
                    | BinaryOperation::Nsame => {
                        operations::assert_initialized(&left)?;
                        operations::assert_initialized(&right)?;
                        let mut equal =
                            if matches!(kind, BinaryOperation::Eq | BinaryOperation::Neq) {
                                match (&left, &right) {
                                    (MiraAny::Number(a), MiraAny::Number(b)) => a == b,
                                    _ => left == right,
                                }
                            } else {
                                left == right
                            };
                        if matches!(kind, BinaryOperation::Neq | BinaryOperation::Nsame) {
                            equal = !equal;
                        }
                        MiraAny::Boolean(equal)
                    }
                    BinaryOperation::Aeq | BinaryOperation::Naeq => {
                        let mut equal = operations::approximately_equal(&left, &right)?;
                        if *kind == BinaryOperation::Naeq {
                            equal = !equal;
                        }
                        MiraAny::Boolean(equal)
                    }
                    BinaryOperation::Lt
                    | BinaryOperation::Lte
                    | BinaryOperation::Gt
                    | BinaryOperation::Gte => {
                        let ordering = operations::compare(&left, &right)?;
                        MiraAny::Boolean(match (kind, ordering) {
                            (_, None) => false,
                            (BinaryOperation::Lt, Some(value)) => value == Ordering::Less,
                            (BinaryOperation::Lte, Some(value)) => value != Ordering::Greater,
                            (BinaryOperation::Gt, Some(value)) => value == Ordering::Greater,
                            (BinaryOperation::Gte, Some(value)) => value != Ordering::Less,
                            _ => unreachable!(),
                        })
                    }
                    BinaryOperation::In => MiraAny::Boolean(operations::in_value(&left, &right)?),
                    BinaryOperation::And | BinaryOperation::Or => {
                        let left = operations::to_boolean(&left)?;
                        let right = operations::to_boolean(&right)?;
                        MiraAny::Boolean(if *kind == BinaryOperation::And {
                            left && right
                        } else {
                            left || right
                        })
                    }
                };
                self.write_register(frame, *destination, result);
            }
            Operation::Swap { left, right } => {
                let left_value = self.read_register(frame, *left);
                let right_value = self.read_register(frame, *right);
                self.write_register(frame, *left, right_value);
                self.write_register(frame, *right, left_value);
            }
            Operation::Upvalue {
                kind,
                value,
                level,
                register,
            } => {
                let owner = self.parent_frame(frame, *level)?;
                match kind {
                    UpvalueOperation::Get => {
                        let result = self.read_register(owner, *register);
                        operations::assert_initialized(&result)?;
                        self.write_register(frame, *value, result);
                    }
                    UpvalueOperation::Set => {
                        let result = self.read_register(frame, *value);
                        self.write_register(owner, *register, result);
                    }
                }
            }
            Operation::GetGlobal { destination, slot } => {
                let result = self.get_global_slot(*slot)?;
                self.write_register(frame, *destination, result);
            }
            Operation::GetGlobalDyn { destination, key } => {
                let key = operations::to_string(&self.read_register(frame, *key))?;
                let result = self.get_global_name(&key)?;
                self.write_register(frame, *destination, result);
            }
            Operation::InGlobal { destination, key } => {
                let key = operations::to_string(&self.read_register(frame, *key))?;
                self.write_register(
                    frame,
                    *destination,
                    MiraAny::Boolean(self.context.contains(&key)),
                );
            }
            Operation::Concat {
                destination,
                values,
            } => {
                let mut result = String::new();
                for value in values {
                    result.push_str(&operations::format_value(
                        &self.read_register(frame, *value),
                        None,
                    )?);
                }
                self.write_register(frame, *destination, MiraAny::String(result));
            }
            Operation::Format {
                destination,
                value,
                format,
            } => {
                let format = match &self.program.constants[*format] {
                    MiraAny::String(value) => Some(value.as_str()),
                    MiraAny::Nil => None,
                    _ => unreachable!("validated format constant"),
                };
                let result = operations::format_value(&self.read_register(frame, *value), format)?;
                self.write_register(frame, *destination, MiraAny::String(result));
            }
            Operation::Assert { kind, value } => {
                let value = self.read_register(frame, *value);
                match kind {
                    AssertOperation::Initialized => operations::assert_initialized(&value)?,
                    AssertOperation::NonNil => operations::assert_non_nil(&value)?,
                }
            }
            Operation::PickOmit {
                kind,
                destination,
                value,
                keys,
            } => {
                let keys: Result<Vec<_>> = keys
                    .iter()
                    .map(|index| operations::to_string(&self.program.constants[*index]))
                    .collect();
                let source = self.read_register(frame, *value);
                let result = match kind {
                    PickOmitOperation::Pick => operations::pick(&source, &keys?)?,
                    PickOmitOperation::Omit => operations::omit(&source, &keys?)?,
                };
                self.write_register(frame, *destination, result);
            }
            Operation::CallGlobal0 { destination, slot } => {
                let target = self.get_global_slot_ref(*slot)?;
                let result = self.call(target, &[])?;
                self.write_register(frame, *destination, result);
            }
            Operation::CallGlobal1 {
                destination,
                slot,
                argument,
            } => {
                let target = self.get_global_slot_ref(*slot)?;
                let argument = self.call_argument(frame, *argument)?;
                let result = self.call(target, &[argument])?;
                self.write_register(frame, *destination, result);
            }
            Operation::CallGlobal1FromGlobal {
                destination,
                slot,
                argument_slot,
            } => {
                let target = self.get_global_slot_ref(*slot)?;
                let argument = self.get_global_slot_ref(*argument_slot)?;
                operations::assert_initialized(argument)?;
                let result = self.call(target, std::slice::from_ref(argument))?;
                self.write_register(frame, *destination, result);
            }
            Operation::CallGlobal2 {
                destination,
                slot,
                arguments: [a, b],
            } => {
                let target = self.get_global_slot_ref(*slot)?;
                let arguments = [
                    self.call_argument(frame, *a)?,
                    self.call_argument(frame, *b)?,
                ];
                let result = self.call(target, &arguments)?;
                self.write_register(frame, *destination, result);
            }
            Operation::CallGlobal3 {
                destination,
                slot,
                arguments: [a, b, c],
            } => {
                let target = self.get_global_slot_ref(*slot)?;
                let arguments = [
                    self.call_argument(frame, *a)?,
                    self.call_argument(frame, *b)?,
                    self.call_argument(frame, *c)?,
                ];
                let result = self.call(target, &arguments)?;
                self.write_register(frame, *destination, result);
            }
            Operation::CallGlobal4 {
                destination,
                slot,
                arguments: [a, b, c, d],
            } => {
                let target = self.get_global_slot_ref(*slot)?;
                let arguments = [
                    self.call_argument(frame, *a)?,
                    self.call_argument(frame, *b)?,
                    self.call_argument(frame, *c)?,
                    self.call_argument(frame, *d)?,
                ];
                let result = self.call(target, &arguments)?;
                self.write_register(frame, *destination, result);
            }
            Operation::Call {
                destination,
                target,
                arguments,
                spreads,
            } => {
                let target = match target {
                    CallTarget::Global(constant) => self.get_global_slot(*constant)?,
                    CallTarget::Register(register) => self.read_register(frame, *register),
                };
                let result = self.call_registers(&target, arguments, spreads, frame)?;
                self.write_register(frame, *destination, result);
            }
            Operation::Access {
                kind,
                destination,
                value,
                key,
            } => {
                let key = match key {
                    AccessKey::Constant(constant) => self.program.constants[*constant].clone(),
                    AccessKey::Register(register) => self.read_register(frame, *register),
                    AccessKey::Index(index) => MiraAny::Number(*index as f64),
                };
                let source = self.read_register(frame, *value);
                match kind {
                    AccessOperation::Has => {
                        let result = MiraAny::Boolean(self.has_value(&source, &key)?);
                        self.write_register(frame, *destination, result);
                    }
                    AccessOperation::Get => {
                        let result = self.get_value(&source, &key)?;
                        self.write_register(frame, *destination, result);
                    }
                    AccessOperation::Set => {
                        let assigned = self.read_register(frame, *destination);
                        operations::set(&source, &key, assigned)?;
                    }
                }
            }
            Operation::Slice {
                destination,
                value,
                start,
                end,
                exclusive,
            } => {
                let bound = |bound: &SliceBound| match bound {
                    SliceBound::Constant(value) => MiraAny::Number(*value as f64),
                    SliceBound::Register(register) => self.read_register(frame, *register),
                };
                let start = start.as_ref().map(bound);
                let end = end.as_ref().map(bound);
                let result = operations::slice(
                    &self.read_register(frame, *value),
                    start.as_ref(),
                    end.as_ref(),
                    *exclusive,
                )?;
                self.write_register(frame, *destination, result);
            }
        }
        Ok(Flow::Continue)
    }
}