mirascript-vm 0.1.105

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

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(crate) struct RegisterId(usize);

impl RegisterId {
    #[inline]
    pub const fn new(id: usize) -> Self {
        Self(id)
    }

    #[inline]
    pub const fn is_nil(self) -> bool {
        self.0 == 0
    }
}

const INLINE_REGISTER_COUNT: usize = 16;

#[derive(Debug)]
pub(super) struct Registers {
    inline: [MiraAny; INLINE_REGISTER_COUNT],
    overflow: Vec<MiraAny>,
    #[cfg(debug_assertions)]
    pub(super) max_register: usize,
}

impl Registers {
    #[inline]
    pub(super) fn new(count: usize) -> Self {
        Self {
            inline: std::array::from_fn(|_| MiraAny::uninitialized()),
            overflow: vec![MiraAny::uninitialized(); count.saturating_sub(INLINE_REGISTER_COUNT)],
            #[cfg(debug_assertions)]
            max_register: count,
        }
    }

    #[inline]
    pub(super) fn reset(&mut self, count: usize) {
        self.inline.fill(MiraAny::uninitialized());
        self.overflow.resize(
            count.saturating_sub(INLINE_REGISTER_COUNT),
            MiraAny::uninitialized(),
        );
        self.overflow.fill(MiraAny::uninitialized());
        #[cfg(debug_assertions)]
        {
            self.max_register = count;
        }
    }

    #[inline]
    pub(super) fn fill(&mut self, value: MiraAny) {
        for slot in self.inline.iter_mut() {
            *slot = value;
        }
        for slot in self.overflow.iter_mut() {
            *slot = value;
        }
    }

    #[inline(always)]
    fn check(&self, register: RegisterId) {
        let _id = register.0;
        #[cfg(debug_assertions)]
        debug_assert!(
            _id <= self.max_register,
            "register index {} out of bounds (max {})",
            _id,
            self.max_register
        );
    }

    #[inline]
    pub(super) fn get(&self, register: RegisterId) -> &MiraAny {
        self.check(register);
        let id = register.0 - 1;
        if id < INLINE_REGISTER_COUNT {
            &self.inline[id]
        } else {
            &self.overflow[id - INLINE_REGISTER_COUNT]
        }
    }

    #[inline]
    pub(super) fn get_mut(&mut self, register: RegisterId) -> &mut MiraAny {
        self.check(register);
        let id = register.0 - 1;
        if id < INLINE_REGISTER_COUNT {
            &mut self.inline[id]
        } else {
            &mut self.overflow[id - INLINE_REGISTER_COUNT]
        }
    }

    #[inline]
    pub(super) fn read(&self, register: RegisterId) -> MiraAny {
        if register.is_nil() {
            MiraAny::from(MiraValue::NIL)
        } else {
            *self.get(register)
        }
    }
}

impl Runtime {
    #[inline]
    pub(super) fn read_register_raw(&self, frame: FrameId, register: RegisterId) -> MiraAny {
        if register.is_nil() {
            MiraAny::from(MiraValue::NIL)
        } else {
            *self.frames.get(frame).registers.get(register)
        }
    }

    #[inline]
    pub(super) fn read_register(&self, frame: FrameId, register: RegisterId) -> Result<MiraValue> {
        self.read_register_raw(frame, register).check()
    }

    #[inline]
    pub(super) fn read_number(&self, frame: FrameId, register: RegisterId) -> Result<f64> {
        let value = self.read_register_raw(frame, register);
        if let Some(number) = value.unwrap().as_number() {
            return Ok(number);
        }
        let value = value.check()?;
        operations::to_number(self, value)
    }

    #[inline]
    pub(super) fn write_register_raw(
        &mut self,
        frame: FrameId,
        register: RegisterId,
        value: impl Into<MiraAny>,
    ) {
        if !register.is_nil() {
            *self.frames.get_mut(frame).registers.get_mut(register) = value.into();
        }
    }

    #[inline]
    pub(super) fn write_register(
        &mut self,
        frame: FrameId,
        register: RegisterId,
        value: MiraValue,
    ) {
        self.write_register_raw(frame, register, value);
    }

    #[inline]
    pub(super) fn clear_register(&mut self, frame: FrameId, register: RegisterId) {
        self.write_register_raw(frame, register, MiraAny::uninitialized());
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn mira_any_is_copy_and_eight_bytes() {
        fn assert_copy<T: Copy>() {}

        assert_copy::<MiraAny>();
        assert_eq!(std::mem::size_of::<MiraAny>(), 8);
    }

    #[test]
    fn uninitialized_is_distinct_from_nil() {
        assert!(MiraAny::uninitialized().check().is_err());
        assert_eq!(
            MiraAny::from(MiraValue::NIL).check().unwrap(),
            MiraValue::NIL
        );
    }
}