xous-core/loader/src/args.rs

/// Convert a four-letter string into a 32-bit int.
#[macro_export]
macro_rules! make_type {
    ($fcc:expr) => {{
        let mut c: [u8; 4] = Default::default();
        c.copy_from_slice($fcc.as_bytes());
        u32::from_le_bytes(c)
    }};
}

#[derive(Clone, Copy)]
pub struct KernelArguments {
    pub base: *const u32,
}

pub struct KernelArgumentsIterator {
    base: *const u32,
    size: usize,
    offset: u32,
}

impl KernelArguments {
    pub fn new(base: *const usize) -> KernelArguments {
        KernelArguments {
            base: base as *const u32,
        }
    }

    pub fn iter(self) -> KernelArgumentsIterator {
        KernelArgumentsIterator {
            base: self.base,
            size: self.size(),
            offset: 0,
        }
    }

    pub fn size(self) -> usize {
        let s = unsafe { self.base.add(2).read() * 4 };
        s as usize
    }
}

pub struct KernelArgument {
    pub name: u32,

    // Total number of bytes in the data section
    pub size: u32,

    // Data section, as a slice of 32-bit ints
    pub data: &'static [u32],
}

impl KernelArgument {
    pub fn new(base: *const u32, offset: u32) -> Self {
        let name = unsafe { base.add(offset as usize / 4).read() };
        let size = unsafe {
            (base.add(offset as usize / 4 + 1) as *const u16)
                .add(1)
                .read()
        } as u32;
        let data = unsafe {
            core::slice::from_raw_parts(base.add(offset as usize / 4 + 2), size as usize)
        };
        KernelArgument {
            name,
            size: size * 4,
            data,
        }
    }
}

impl Iterator for KernelArgumentsIterator {
    type Item = KernelArgument;
    fn next(&mut self) -> Option<Self::Item> {
        if self.offset as usize >= self.size {
            None
        } else {
            let new_arg = KernelArgument::new(self.base, self.offset);
            self.offset += new_arg.size + 8;
            Some(new_arg)
        }
    }
}