Enum spectrusty_formats::snapshot::ComputerModel

#[non_exhaustive]
pub enum ComputerModel {
    Spectrum16,
    Spectrum48,
    SpectrumNTSC,
    Spectrum128,
    SpectrumPlus2,
    SpectrumPlus2A,
    SpectrumPlus3,
    SpectrumPlus3e,
    SpectrumSE,
    TimexTC2048,
    TimexTC2068,
    TimexTS2068,
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Spectrum16

Spectrum48

SpectrumNTSC

Spectrum128

SpectrumPlus2

SpectrumPlus2A

SpectrumPlus3

SpectrumPlus3e

SpectrumSE

TimexTC2048

TimexTC2068

TimexTS2068

Implementations

impl ComputerModel

pub fn frame_tstates(self) -> FTs

Returns the number of T-states per single frame.

Examples found in repository

src/z80/common.rs (line 240)

pub fn z80_to_cycles(ts_lo: u16, ts_hi: u8, model: ComputerModel) -> FTs {
    let total_ts = model.frame_tstates();
    let qts = total_ts / 4;
    let qcountdown = ts_lo as FTs;
    (((ts_hi + 1) % 4 + 1) as FTs * qts - (qcountdown + 1))
    .rem_euclid(total_ts)
}

pub fn cycles_to_z80(ts: FTs, model: ComputerModel) -> (u16, u8) {
    let total_ts = model.frame_tstates();
    let qts = total_ts / 4;
    let ts_lo = (qts - (ts.rem_euclid(qts)) - 1) as u16;
    let ts_hi = (ts.rem_euclid(total_ts) / qts - 1).rem_euclid(4) as u8;
    (ts_lo, ts_hi)
}

pub fn applicable_issue(self, issue: ReadEarMode) -> ReadEarMode

Returns issue or ReadEarMode::Clear when it does not apply to the model.

Examples found in repository

src/z80/loader.rs (lines 182-189)

pub fn load_z80<R: Read, S: SnapshotLoader>(
        mut rd: R,
        loader: &mut S
    ) -> Result<()>
{
    use ComputerModel::*;

    let header = Header::read_new_struct(rd.by_ref())?;
    let mut version = Z80Version::V1;

    let mut model = ComputerModel::Spectrum48;
    let mut extensions = Extensions::default();
    let mut cpu = create_cpu(&header)?;

    let header_ex = if cpu.get_pc() == 0 {
        let (ver, head_ex) = load_header_ex(rd.by_ref())?;
        version = ver;
        cpu.set_pc(u16::from_le_bytes(head_ex.pc));
        let (mdl, ext) = select_hw_model(version, &head_ex).ok_or_else(||
            io::Error::new(io::ErrorKind::InvalidData, "unsupported model")
        )?;
        model = mdl;
        extensions = ext;
        Some(head_ex)
    }
    else {
        None
    };

    let flags1 = Flags1::from(header.flags1);
    let border = flags1.border_color();
    let flags2 = Flags2::from(header.flags2);
    let joystick = flags2.joystick_model();
    let issue = model.applicable_issue(
        if flags2.is_issue2_emulation() {
            ReadEarMode::Issue2
        }
        else {
            ReadEarMode::Issue3
        }
    );

    loader.select_model(model, extensions, border, issue)
          .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
    loader.select_joystick(joystick);
    loader.assign_cpu(CpuModel::NMOS(cpu));

    // clippy false positive: https://github.com/rust-lang/rust-clippy/issues/9274
    #[allow(clippy::read_zero_byte_vec)] {
    let mut buf = Vec::new();
    if version == Z80Version::V1 {
        if flags1.is_mem_compressed() {
            rd.read_to_end(&mut buf)?;
            let buf = match buf.get(buf.len() - 4..) {
                Some(MEMORY_V1_TERM) => &buf[..buf.len() - 4],
                _ => &buf[..]
            };
            let decompress = MemDecompress::new(buf);
            loader.read_into_memory(MemoryRange::Ram(0..3*PAGE_SIZE), decompress)?;
        }
        else {
            loader.read_into_memory(MemoryRange::Ram(0..3*PAGE_SIZE), rd)?;
        }
    }
    else {
        while let Some((len, page, is_compressed)) = load_mem_header(rd.by_ref())? {
            let range = mem_page_to_range(page, model, extensions).ok_or_else(||
                io::Error::new(io::ErrorKind::InvalidData, "unsupported memory page")
            )?;
            if is_compressed {
                buf.resize(len, 0);
                rd.read_exact(&mut buf)?;
                let decompress = MemDecompress::new(&buf);
                loader.read_into_memory(range, decompress)?;
            }
            else {
                loader.read_into_memory(range, rd.by_ref().take(len as u64))?;
            }
        }
    }}

    if let Some(head_ex) = header_ex {
        if let Some(choice) = select_ay_model(model, Flags3::from(head_ex.flags3)) {
            loader.setup_ay(choice, head_ex.ay_sel_reg.into(), &head_ex.ay_regs);
        }

        if version == Z80Version::V3 {
            let ts = z80_to_cycles(u16::from_le_bytes(head_ex.ts_lo), head_ex.ts_hi, model);
            loader.set_clock(ts);
            let data = head_ex.port2;
            if data != 0 {
                match model {
                    SpectrumPlus2A|SpectrumPlus3|SpectrumPlus3e|
                    SpectrumSE => {
                        loader.write_port(0x1ffd, data);
                    }
                    _ => {}
                }
            }
        }

        match model {
            TimexTC2048|TimexTS2068|TimexTC2068 => {
                loader.write_port(0xf4, head_ex.port1);
            }
            Spectrum128|SpectrumPlus2|
            SpectrumPlus2A|SpectrumPlus3|SpectrumPlus3e|
            SpectrumSE => {
                loader.write_port(0x7ffd, head_ex.port1);
            }
            _ => {}
        }
        match model {
            TimexTC2048|TimexTS2068|TimexTC2068 => {
                loader.write_port(0xff, head_ex.ifrom);
            }
            Spectrum16|Spectrum48|
            Spectrum128|SpectrumPlus2|
            SpectrumPlus2A|SpectrumPlus3|SpectrumPlus3e|
            SpectrumSE
            if head_ex.ifrom == 0xff && extensions.intersects(Extensions::IF1) => {
                loader.interface1_rom_paged_in();
            }
            _ => {}
        }
    }
    Ok(())
}

pub fn validate_extensions(self, ext: Extensions) -> Result<(), Extensions>

Examples found in repository

src/z80/saver.rs (line 357)

pub fn save_z80v1<C: SnapshotCreator, W: Write>(
        snapshot: &C,
        mut wr: W
    ) -> Result<SnapshotResult>
{
    use ComputerModel::*;
    let mut result = SnapshotResult::OK;

    let model = snapshot.model();
    match model {
        Spectrum48 => {},
        Spectrum16|SpectrumNTSC|TimexTC2048 => {
            result.insert(SnapshotResult::MODEL_NSUP);
        }
        _ => return Err(io::Error::new(io::ErrorKind::InvalidInput,
                        "Z80: can't create a version 1 snapshot of this computer model"))
    };
    let extensions = snapshot.extensions();
    if let Err(bad_ext) = model.validate_extensions(extensions) {
        return Err(io::Error::new(io::ErrorKind::InvalidInput,
            format!("Z80: the model {} can't be saved with {}", model, bad_ext)))
    }

    if extensions.intersects(Extensions::IF1) && snapshot.is_interface1_rom_paged_in()
       || extensions.intersects(Extensions::PLUS_D) && snapshot.is_plus_d_rom_paged_in()
       || extensions.intersects(Extensions::DISCIPLE) && snapshot.is_disciple_rom_paged_in()
       || extensions.intersects(Extensions::TR_DOS) && snapshot.is_tr_dos_rom_paged_in()
    {
        return Err(io::Error::new(io::ErrorKind::InvalidInput,
                "Z80: can't create a version 1 snapshot with the external ROM paged in"))
    }
    if extensions != Extensions::NONE {
        result.insert(SnapshotResult::EXTENSTION_NSUP);
    }

    let cpu = get_nmos_cpu(snapshot.cpu(), &mut result);
    let border = snapshot.border_color();
    let issue = snapshot.issue();
    let joystick = snapshot.joystick();

    if snapshot.ay_state(Ay3_891xDevice::Ay128k).is_some()
       || snapshot.ay_state(Ay3_891xDevice::Melodik).is_some()
       || snapshot.ay_state(Ay3_891xDevice::FullerBox).is_some()
       || snapshot.ay_state(Ay3_891xDevice::Timex).is_some()
    {
        result.insert(SnapshotResult::SOUND_CHIP_NSUP);
    }

    let mut header = Header::default();
    init_z80_header(
        &mut header,
        Z80Version::V1,
        &cpu,
        border,
        issue,
        joystick,
        &mut result
    );

    header.write_struct(wr.by_ref())?;
    let is_16k = model == ComputerModel::Spectrum16;
    let ramend = if is_16k { 0x4000 } else { 0xC000 };
    let mem_slice = snapshot.memory_ref(MemoryRange::Ram(0..ramend))?;
    compress_write_all(mem_slice, wr.by_ref())?;
    if is_16k {
        compress_repeat_write_all(!0, 0x8000, wr.by_ref())?;
    }

    wr.write_all(MEMORY_V1_TERM)?;
    wr.flush()?;
    Ok(result)
}

/// Saves a **Z80** file version 2 into `wr` from the provided reference to a `snapshot` struct
/// implementing [SnapshotCreator].
///
/// # Errors
/// This function may return an error from attempts to write the file or if for some reason
/// a snapshot could not be created.
pub fn save_z80v2<C: SnapshotCreator, W: Write>(
        snapshot: &C,
        wr: W
    ) -> Result<SnapshotResult>
{
    let mut result = SnapshotResult::OK;
    let model = snapshot.model();
    let ext = snapshot.extensions();
    let border = snapshot.border_color();
    let issue = snapshot.issue();
    let joystick = snapshot.joystick();
    let cpu = get_nmos_cpu(snapshot.cpu(), &mut result);
    if !is_cpu_safe_for_snapshot(&cpu) {
        return Err(io::Error::new(io::ErrorKind::InvalidInput, "Z80: can't safely snapshot the CPU state"))
    }
    if let Err(bad_ext) = model.validate_extensions(ext) {
        return Err(io::Error::new(io::ErrorKind::InvalidInput,
            format!("Z80: the model {} can't be saved with {}", model, bad_ext)))
    }

    let mut header = Header::default();
    init_z80_header(
        &mut header,
        Z80Version::V2,
        &cpu,
        border,
        issue,
        joystick,
        &mut result
    );

    let mut head_ex = HeaderEx::default();
    init_z80_header_ex(
        &mut head_ex,
        cpu,
        model,
        ext,
        snapshot,
        select_hw_model_v2,
        &mut result
    )?;

    save_all_v2v3(Z80Version::V2, snapshot, model, &header, &head_ex, wr)?;
    Ok(result)
}

/// Saves a **Z80** file version 3 into `wr` from the provided reference to a `snapshot` struct
/// implementing [SnapshotCreator].
///
/// # Errors
/// This function may return an error from attempts to write the file or if for some reason
/// a snapshot could not be created.
pub fn save_z80v3<C: SnapshotCreator, W: Write>(
        snapshot: &C,
        wr: W
    ) -> Result<SnapshotResult>
{
    use ComputerModel::*;
    let mut result = SnapshotResult::OK;
    let model = snapshot.model();
    let ext = snapshot.extensions();
    let border = snapshot.border_color();
    let issue = snapshot.issue();
    let joystick = snapshot.joystick();
    let cpu = get_nmos_cpu(snapshot.cpu(), &mut result);
    if !is_cpu_safe_for_snapshot(&cpu) {
        return Err(io::Error::new(io::ErrorKind::InvalidInput, "Z80: can't safely snapshot the CPU state"))
    }
    if let Err(bad_ext) = model.validate_extensions(ext) {
        return Err(io::Error::new(io::ErrorKind::InvalidInput,
            format!("Z80: the model {} can't be saved with {}", model, bad_ext)))
    }

    let mut header = Header::default();
    init_z80_header(
        &mut header,
        Z80Version::V3,
        &cpu,
        border,
        issue,
        joystick,
        &mut result
    );

    let mut head_ex = HeaderEx::default();
    init_z80_header_ex(
        &mut head_ex,
        cpu,
        model,
        ext,
        snapshot,
        select_hw_model_v3,
        &mut result
    )?;

    let (ts_lo, ts_hi) = cycles_to_z80(snapshot.current_clock(), model);
    head_ex.ts_lo = ts_lo.to_le_bytes();
    head_ex.ts_hi = ts_hi;
    if (ext.intersects(Extensions::PLUS_D) && snapshot.is_plus_d_rom_paged_in())
        || (ext.intersects(Extensions::DISCIPLE) && snapshot.is_disciple_rom_paged_in())
    {
        head_ex.mgt_rom = !0;
    }

    if let Some(JoystickModel::Sinclair2) = joystick {
        head_ex.joy_bindings = [ 3, 1, 3, 2, 3, 4, 3, 8, 3,10];
        head_ex.joy_ascii    = [31, 0,32, 0,33, 0,34, 0,35, 0];
    }

    match model {
        SpectrumPlus2A|SpectrumPlus3|SpectrumPlus3e => {
            head_ex.port2 = snapshot.ula3_flags().bits();
        }
        _ => {
            head_ex.fn1 = !0;
            if !(ext.intersects(Extensions::PLUS_D) && snapshot.is_plus_d_rom_paged_in()) {
                head_ex.fn2 = !0;
            }
        }
    }

    if ext.intersects(Extensions::PLUS_D) {
        head_ex.mgt_type = 16;
    }

    // head_ex.flags4 = 0;
    // head_ex.disciple1 = 0;
    // head_ex.disciple2 = 0;

    save_all_v2v3(Z80Version::V3, snapshot, model, &header, &head_ex, wr)?;
    Ok(result)
}

Trait Implementations

impl Clone for ComputerModel

fn clone(&self) -> ComputerModel

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ComputerModel

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

Formats the value using the given formatter.

impl Display for ComputerModel

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

Formats the value using the given formatter.

impl From<&ComputerModel> for &'static str

fn from(model: &ComputerModel) -> Self

Converts to this type from the input type.

impl From<ComputerModel> for &str

fn from(model: ComputerModel) -> Self

Converts to this type from the input type.

impl Hash for ComputerModel

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<ComputerModel> for ComputerModel

fn eq(&self, other: &ComputerModel) -> 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 Copy for ComputerModel

impl Eq for ComputerModel

impl StructuralEq for ComputerModel

impl StructuralPartialEq for ComputerModel