mirascript-vm 0.1.105

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

impl Decoder<'_> {
    pub(super) fn read_if(
        &mut self,
        opcode: OpCode,
        wide: bool,
        offset: usize,
    ) -> Result<InstructionKind> {
        let register = self.read_register(wide, offset)?;
        let condition = match opcode {
            OpCode::If => Condition::Truthy,
            OpCode::IfNot => Condition::Falsy,
            OpCode::IfInit => Condition::Initialized,
            OpCode::IfNotInit => Condition::Uninitialized,
            OpCode::IfNil => Condition::Nil,
            OpCode::IfNotNil => Condition::NonNil,
            _ => unreachable!(),
        };
        let (then_body, terminal) = self.read_block(&[OpCode::Else, OpCode::IfEnd])?;
        let else_body = if terminal == OpCode::Else {
            self.read_block(&[OpCode::IfEnd])?.0
        } else {
            Vec::new()
        };
        Ok(InstructionKind::If {
            condition,
            register,
            then_body: Box::from(then_body),
            else_body: Box::from(else_body),
        })
    }

    pub(super) fn read_loop(
        &mut self,
        opcode: OpCode,
        wide: bool,
        offset: usize,
    ) -> Result<InstructionKind> {
        let register_count = self.read_param(wide, offset)?;
        let kind = match opcode {
            OpCode::Loop => LoopKind::Infinite,
            OpCode::LoopFor => LoopKind::Iterable {
                value: self.read_register(wide, offset)?,
            },
            OpCode::LoopRange | OpCode::LoopRangeExclusive => LoopKind::Range {
                start: self.read_register(wide, offset)?,
                end: self.read_register(wide, offset)?,
                exclusive: opcode == OpCode::LoopRangeExclusive,
            },
            _ => unreachable!(),
        };

        self.scopes.push(register_count);
        self.loop_depth += 1;
        let block = self.read_block(&[OpCode::LoopEnd]);
        self.loop_depth -= 1;
        self.scopes.pop();
        let body = block?.0;
        let reuse_frame = !block_may_capture_frame(&body);
        Ok(InstructionKind::Loop {
            register_count,
            kind,
            body: Box::from(body),
            reuse_frame,
        })
    }

    pub(super) fn read_record(&mut self, wide: bool, offset: usize) -> Result<InstructionKind> {
        let destination = self.read_register(wide, offset)?;
        let mut elements = Vec::new();
        loop {
            let (opcode, element_wide, element_offset) = self.read_opcode()?;
            match opcode {
                OpCode::Field | OpCode::FieldOpt => {
                    let key = self.read_string_constant(element_wide, element_offset)?;
                    let value = self.read_register(element_wide, element_offset)?;
                    elements.push(RecordElement::Field {
                        key: RecordKey::Constant(key),
                        value,
                        optional: opcode == OpCode::FieldOpt,
                    });
                }
                OpCode::FieldDyn | OpCode::FieldOptDyn => {
                    let key = self.read_register(element_wide, element_offset)?;
                    let value = self.read_register(element_wide, element_offset)?;
                    elements.push(RecordElement::Field {
                        key: RecordKey::Dynamic(key),
                        value,
                        optional: opcode == OpCode::FieldOptDyn,
                    });
                }
                OpCode::FieldIndex | OpCode::FieldOptIndex => {
                    let key = self.read_index(element_wide, element_offset)?;
                    let value = self.read_register(element_wide, element_offset)?;
                    elements.push(RecordElement::Field {
                        key: RecordKey::Index(key),
                        value,
                        optional: opcode == OpCode::FieldOptIndex,
                    });
                }
                OpCode::Spread => {
                    elements.push(RecordElement::Spread(
                        self.read_register(element_wide, element_offset)?,
                    ));
                }
                OpCode::Freeze => {
                    if element_wide {
                        return Err(MiraError::invalid_bytecode(
                            element_offset,
                            InvalidBytecodeReason::UnsupportedWide,
                        ));
                    }
                    break;
                }
                _ => {
                    return Err(MiraError::invalid_bytecode(
                        element_offset,
                        InvalidBytecodeReason::UnexpectedOpCode(opcode),
                    ));
                }
            }
        }
        Ok(InstructionKind::Record {
            destination,
            elements,
        })
    }

    pub(super) fn read_array(&mut self, wide: bool, offset: usize) -> Result<InstructionKind> {
        let destination = self.read_register(wide, offset)?;
        let mut elements = Vec::new();
        loop {
            let (opcode, element_wide, element_offset) = self.read_opcode()?;
            match opcode {
                OpCode::Item => elements.push(ArrayElement::Item(
                    self.read_register(element_wide, element_offset)?,
                )),
                OpCode::ItemRange => {
                    let start = self.read_index(element_wide, element_offset)?;
                    let end = self.read_index(element_wide, element_offset)?;
                    elements.push(ArrayElement::Range {
                        start: RangeEndpoint::Constant(start),
                        end: RangeEndpoint::Constant(end),
                        exclusive: false,
                    });
                }
                OpCode::ItemRangeDyn | OpCode::ItemRangeExclusiveDyn => {
                    let start = self.read_register(element_wide, element_offset)?;
                    let end = self.read_register(element_wide, element_offset)?;
                    elements.push(ArrayElement::Range {
                        start: RangeEndpoint::Dynamic(start),
                        end: RangeEndpoint::Dynamic(end),
                        exclusive: opcode == OpCode::ItemRangeExclusiveDyn,
                    });
                }
                OpCode::Spread => elements.push(ArrayElement::Spread(
                    self.read_register(element_wide, element_offset)?,
                )),
                OpCode::Freeze => {
                    if element_wide {
                        return Err(MiraError::invalid_bytecode(
                            element_offset,
                            InvalidBytecodeReason::UnsupportedWide,
                        ));
                    }
                    break;
                }
                _ => {
                    return Err(MiraError::invalid_bytecode(
                        element_offset,
                        InvalidBytecodeReason::UnexpectedOpCode(opcode),
                    ));
                }
            }
        }
        Ok(InstructionKind::Array {
            destination,
            elements,
        })
    }

    pub(super) fn read_module(&mut self, wide: bool, offset: usize) -> Result<InstructionKind> {
        let destination = self.read_register(wide, offset)?;
        let name = self.read_string_constant(wide, offset)?;
        let mut fields = Vec::new();
        loop {
            let (opcode, field_wide, field_offset) = self.read_opcode()?;
            match opcode {
                OpCode::Field => {
                    let key = self.read_string_constant(field_wide, field_offset)?;
                    let value = self.read_register(field_wide, field_offset)?;
                    if fields.iter().any(|(existing, _)| existing == &key) {
                        return Err(MiraError::invalid_bytecode(
                            field_offset,
                            InvalidBytecodeReason::DuplicateExportKey(key),
                        ));
                    }
                    fields.push((key, value));
                }
                OpCode::Freeze => {
                    if field_wide {
                        return Err(MiraError::invalid_bytecode(
                            field_offset,
                            InvalidBytecodeReason::UnsupportedWide,
                        ));
                    }
                    break;
                }
                _ => {
                    return Err(MiraError::invalid_bytecode(
                        field_offset,
                        InvalidBytecodeReason::UnexpectedOpCode(opcode),
                    ));
                }
            }
        }
        Ok(InstructionKind::Module {
            destination,
            name,
            fields,
        })
    }
}