Struct spectrusty_formats::mdr::MdrFileHeader

#[repr(C, packed)]
pub struct MdrFileHeader {
    pub block_type: BlockType,
    pub length: [u8; 2],
    pub start: [u8; 2],
    pub prog_length: [u8; 2],
    pub line: [u8; 2],
}

Binary (SAVE *) file’s header.

Occupies the first 9 bytes of a first data block.

This is the equivalent of an audio tape header.

Fields

block_type: BlockType

The type of the file this header represents.

length: [u8; 2]

Length of data.

start: [u8; 2]

Start of data.

prog_length: [u8; 2]

Program length.

line: [u8; 2]

Program’s starting line number.

Implementations

impl MdrFileHeader

pub fn array_name(&self) -> char

Examples found in repository

src/mdr.rs (line 388)

    fn from(fbh: &MdrFileHeader) -> Self {
        let length = u16::from_le_bytes(fbh.length);
        match fbh.block_type {
            BlockType::Program => {
                let vars = u16::from_le_bytes(fbh.prog_length);
                let line = u16::from_le_bytes(fbh.line);
                Header::new_program(length).with_start(line).with_vars(vars)
            }
            BlockType::NumberArray => {
                Header::new_number_array(length).with_array_name(fbh.array_name())
            }
            BlockType::CharArray => {
                Header::new_char_array(length).with_array_name(fbh.array_name())
            }
            BlockType::Code => {
                let start = u16::from_le_bytes(fbh.start);
                Header::new_code(length).with_start(start)
            }
        }
    }

pub fn length(&self) -> u16

pub fn start(&self) -> u16

pub fn prog_length(&self) -> u16

pub fn line(&self) -> u16

pub fn into_array(self) -> [u8; 9]

Examples found in repository

src/mdr.rs (line 808)

    fn file_from_tap_reader<R: Read + Seek>(&mut self, rd: &mut TapChunkReader<R>) -> io::Result<u8> {
        if rd.chunk_limit() == 0 {
            rd.next_chunk()?;
        }
        let header = if let TapChunkInfo::Head(header) = TapChunkInfo::try_from(rd.get_mut())? {
            header
        }
        else {
            return Err(io::Error::new(io::ErrorKind::InvalidData, "not a TAP header"))
        };
        if let Some(chunk_size) = rd.next_chunk()? {
            if chunk_size < 2 || header.length != chunk_size - 2 {
                return Err(io::Error::new(io::ErrorKind::InvalidData, "not a TAP block"))
            }
            let mut flag = 0u8;
            rd.read_exact(slice::from_mut(&mut flag))?;
            if flag != DATA_BLOCK_FLAG {
                return Err(io::Error::new(io::ErrorKind::InvalidData, "invalid TAP block flag"))
            }
        }
        else {
            return Err(io::Error::new(io::ErrorKind::InvalidData, "missing TAP chunk"))
        }
        let fbheader = MdrFileHeader::from(&header).into_array();
        let hdrd = io::Cursor::new(fbheader).chain(rd.take(header.length as u64));
        let res = self.store_file(header.name, true, hdrd)?;
        {
            let mut checksum = 0u8;
            let res = rd.read_exact(slice::from_mut(&mut checksum));
            if res.is_err() || rd.checksum != 0 {
                self.erase_file(header.name);
                return Err(io::Error::new(io::ErrorKind::InvalidData, "TAP block checksum error"))
            }
        }
        Ok(res)
    }

Trait Implementations

impl Clone for MdrFileHeader

fn clone(&self) -> MdrFileHeader

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MdrFileHeader

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for MdrFileHeader

fn default() -> MdrFileHeader

Returns the “default value” for a type.

impl From<&Header> for MdrFileHeader

fn from(header: &Header) -> Self

Converts to this type from the input type.

impl From<&MdrFileHeader> for Header

fn from(fbh: &MdrFileHeader) -> Self

Converts to this type from the input type.

impl PartialEq<MdrFileHeader> for MdrFileHeader

fn eq(&self, other: &MdrFileHeader) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<&[u8]> for &MdrFileHeader

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(data: &[u8]) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for MdrFileHeader

impl Eq for MdrFileHeader

impl StructuralEq for MdrFileHeader

impl StructuralPartialEq for MdrFileHeader