WriteData accepts a command, parameter, or (during write execution) data byte from the CPU. The CPU writes this to port 0x3FFD on the +3.

Helper to create a test CPU

Store writes a byte directly to the backing storage, bypassing any OnWrite handler installed for that register. Subsystems use Store inside their own

New creates a new Memory instance for a given machine model.

Load loads a snapshot from a file.

WriteFile serialises the file with the supplied options and writes it to disk in one shot. Wrapper around Write + os.WriteFile so the caller doesn't h

New creates a new Snapshot instance.

New returns a fresh dispatcher with hardware-identity and reset-default registers seeded to the values the FPGA's `tbblue_reset_common` publishes at c

StepInstruction executes exactly one Z80 instruction without checking for interrupts. Used by conformance tests (Zexdoc / Zexall) and unit tests — no

=========================================================================== Per-opcode T-state timing batch. Pins documented Z80 timings for the most

m1 models the opcode-fetch machine cycle (4 T): contend the fetch address, then charge 4 T. The actual byte fetch + R-increment is done separately by

GetMMU returns the bank ID currently mapped at the given 8K MMU slot. Used to service NextReg 0x50..0x57 reads. Slot indexes outside 0..7 return 0.

New creates a new Keyboard instance.

WriteRegister writes val to register reg directly.

Run starts a standalone emulation loop at 50Hz. Note: the main application uses its own run loop instead of this method.

SetOnWrite installs a write-side-effect callback for the given register. The callback replaces the default storage behaviour; if the handler wants the

Close properly shuts down the ULA and releases resources

InstructionCount returns the number of opcode fetches the CPU has performed since boot or the last ResetInstructionCount call. RZX playback uses this

NewUPD765 creates an idle FDC with no disk loaded.

AttachDisk loads a parsed Disk into the given physical drive (0 = A, 1 = B). Pass nil to eject. Calling this from the UI thread while the CPU goroutin

New returns a fresh pager backed by the supplied ROM image with automap *disabled*. On the real Next, cold reset leaves NextReg $0A bit 4 = 1 (per the

PageMemory handles the 128K memory paging mechanism.

Set installs an attribute record at the given slot.

HandlePortWrite handles writes to DISCiPLE I/O ports.

SetMMU writes the bank ID for an 8K MMU slot. Called from the NextReg 0x50..0x57 OnWrite handlers when guest code writes to those registers (either vi

exec models internal (no-MREQ) cycles: the ULA still holds the bus once per T-state for the value currently on the address bus, so contention is appli

ReadData handles a byte clocked in by the host (IN A,(0xEB)). Returns 0xFF when no card is present or no response is queued.

drainResult reads MSR and the result phase bytes, returning them. The FDC must already be in result phase.

helper: send 6-byte command frame and read R1 response.

NewPeripheralManager creates a new peripheral manager

Bytes returns a copy of the track's raw byte stream — the MFM-decoded track image (gaps, sync, address marks, sector ID + data fields, CRCs) as the WD

NewImageSource wraps an image-bytes slice as a block source. The image length must be a multiple of 512.

New returns a fresh Engine with all sprites invisible and the pattern RAM zero.

NewMultiface creates a new Multiface interface

invokeAPI simulates the post-RST-8 state and dispatches.

New allocates an empty cartridge with the given length in blocks. All bytes are initialised to 0xFF — the value an unwritten microdrive tape returns w

helper creates a temp dir with a dummy 48.rom and returns a *memory.Memory plus cleanup func.

readOperand reads the next byte at PC without incrementing R (for immediate operands).

New creates a new Z80 CPU instance.

Scan returns the ANDed column bits of the rows selected by the high address byte. A cleared bit r of highByte selects row r (active-low); multiple sel

WriteCommand issues a command (Beta port $1F write).

rd models a memory-read machine cycle (3 T): contend then read.

AddPreFetchHook registers a callback fired on every M1 fetch after the legacy CPU.PreFetchHook field. If a hook with the same name is already register

WriteData handles a byte clocked out by the host (OUT 0xEB,A). On a card with no media this is a no-op — the host's clocks are absorbed but produce no

WriteRegister writes a value to a specific register, bypassing the register-select latch. Mostly useful for tests and snapshot loading.

New constructs a fresh Harness for the given Spectrum model. The peripheral ROMs are loaded from the embedded ROM filesystem (the same path memory.New

NewTapePlayer creates an empty tape player.

Raw returns the backing register byte without going through OnRead. Useful for debug snapshots and for handlers that recompute reads from stored state

createTestROMDir builds a temporary directory with all the ROM files that memory.New and the peripheral subsystems need.

newTestMemory creates a *memory.Memory suitable for testing.

NewCard returns a fresh card backed by src. A nil src means the slot is empty — IN(0xEB) returns 0xFF unconditionally and all commands stay in idle.

Stat returns metadata for a path.

Tstates returns the absolute T-state counter. Used by RZX recording to seed input recording blocks with the T-state offset at which the recording wind

GetCurrentModel returns the current Spectrum model

BC returns the BC register pair.

GetModelName returns a human-readable name for a Spectrum model

New creates a new ULA instance.

Select sets the active palette per the NextReg 0x43 layout: bit 0 toggles first/second, bits 1-2 select layer.

wr models a memory-write machine cycle (3 T): contend then write.

HL, BC, DE: 16-bit register-pair accessors. Exported convenience wrappers for callers outside pkg/z80 — the Spectrum Next esxDOS handlers reach for th

GetPortState returns the current port 7FFD and 1FFD values for debugging.

PressMatrixKey directly sets or clears the given bit of the Spectrum keyboard matrix, bypassing the host-key-to-Spectrum-key mapping entirely. Used by

executeZ80NEDInstruction dispatches the ZX Spectrum Next's extended ED-prefixed opcodes. Returns true if the opcode was handled and the caller should

Active returns the currently-selected Palette so layer code can read entries directly.

Open opens a file at the given esxDOS-style path. The flags follow esxDOS conventions: bit 0 = read, bit 1 = write, bit 2 = create, bit 3 = exclusive,

SetHL writes the HL register pair.

Clean up test ROMs