badline 0.13.0 → 0.14.0

data/lib/badline/c128/saved_state.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-require "badline/snapshot/c128_setup"
-
-module Badline
-  class C128
-    # How the machine a State from #snapshot was taken of was built.
-    def self.setup(state) = Snapshot::C128Setup.from(state)
-
-    # A new machine, built as the one a State from #snapshot was taken of,
-    # at that state.
-    def self.restored(state) = setup(state).build.apply_state(state)
-
-    # The whole machine's state for a snapshot, as C64's: the
-    # machine's own latches, FAST and TEST as they last took hold, the bus with its RAM, the MMU, the chips and
-    # the VDC, the CPU, the cartridge, the disk device 8 serves through the
-    # traps and a true 1541. The serial lines go back into the bus from the
-    # restored CIA 2. What the host holds stays out: the keyboard, the
-    # joysticks, CAPS LOCK and 40/80 DISPLAY, the traps and callbacks, and
-    # which chip renders.
-    module SavedState
-      # How many more on_init handlers the machine a State was taken of had
-      # yet to run than this one has. Nil until the machine is restored.
-      attr_reader :init_handlers_lost
-
-      def snapshot
-        out = Snapshot::StateWriter.new
-        save_state(out)
-        out.state
-      end
-
-      # Takes the machine back to a State from #snapshot, trying it on a new
-      # machine first, so one that fails leaves this machine as it was.
-      # Raises Snapshot::FormatError for a state of another model or SID.
-      def restore(state)
-        check_setup(C128.setup(state))
-        C128.restored(state)
-        apply_state(state)
-      end
-
-      # Puts a State into the machine without trying it on a new one first.
-      def apply_state(state)
-        input = Snapshot::StateReader.new(state)
-        load_state(input)
-        raise Snapshot::FormatError, "the state goes on past the machine" unless input.finished?
-
-        self
-      end
-
-      def save_state(out)
-        out.marker(Snapshot::C128Setup::MARKER).stamp
-        snapshot_setup.write(out)
-        out.int(@cycles).int(@clock_bits).boolean(@nmi_asserted).boolean(@cartridge_nmi).boolean(@restore_pulse)
-        out.boolean(!@pending_keys.nil?)
-        out.ints(@pending_keys) if @pending_keys
-        out.int(@cycles <= init_threshold ? @init_handlers.length : 0)
-        save_cartridge(out)
-        @bus.save_state(out)
-        @cpu.save_state(out)
-        @z80.save_state(out)
-        out.int(@z80_due).int(@chips_ahead).boolean(@cpu_reset_pending)
-        save_trap_dos(out)
-        save_serial_bus(out)
-      end
-
-      def load_state(input)
-        input.marker(Snapshot::C128Setup::MARKER)
-        input.check_stamp
-        check_setup(Snapshot::C128Setup.read(input))
-        @cycles = input.int
-        @clock_bits = input.int
-        @nmi_asserted = input.boolean?
-        @cartridge_nmi = input.boolean?
-        @restore_pulse = input.boolean?
-        @pending_keys = nil
-        @pending_keys = input.ints if input.boolean?
-        @init_handlers_lost = [input.int - @init_handlers.length, 0].max
-        load_cartridge(input)
-        @cpu_reset_pending = false
-        @bus.load_state(input)
-        push_serial_lines
-        @cpu.load_state(input)
-        load_z80(input)
-        load_trap_dos(input)
-        load_serial_bus(input)
-        push_fast_serial
-      end
-
-      private
-
-      # The Z80 and which CPU has the bus. The bus, restored before it,
-      # hands the bus to its CPU without resetting the 8502.
-      def load_z80(input)
-        @z80_running = @bus.z80?
-        @z80.load_state(input)
-        @z80_due = input.int
-        @chips_ahead = input.int
-        @cpu_reset_pending = input.boolean?
-        @z80_turn = @z80_running || @chips_ahead.positive?
-      end
-
-      # How this machine was built.
-      def snapshot_setup
-        Snapshot::C128Setup.new(model: @model.name, sid_model: @sid.model, mode: @c64_built ? :c64 : :c128)
-      end
-
-      def check_setup(setup)
-        ours = snapshot_setup
-        return if setup == ours
-
-        raise Snapshot::FormatError, "the state is of a #{setup}, not a #{ours}"
-      end
-    end
-
-    include SavedState
-  end
-end

data/lib/badline/c64/bus/saved_state.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class C64
-    class Bus
-      # The bus's state for a snapshot: the CPU port, the RAM, colour RAM and
-      # a RAM expansion, the cartridge, the datasette and the chips.
-      module SavedState
-        # The RAM expansion fitted, or an Unexpanded stand-in.
-        attr_reader :ram_expansion
-
-        # Takes the cartridge out of the expansion port, as a restore does for
-        # a state without one.
-        def detach_cartridge
-          @cartridge = nil
-          update_overlays!
-        end
-
-        # The 6510 port's direction and output registers, and the charge left
-        # on its floating bits.
-        def port_state = [@cpu_port.ddr, @cpu_port.data, @cpu_port.floating]
-
-        # Sets the port as port_state reads it, as a snapshot restores it,
-        # leaving the RAM under $00 and $01 alone.
-        def restore_port(ddr, out, floating)
-          @cpu_port.restore(ddr, out, floating)
-        end
-
-        # The machine's memory and everything on the bus but the keyboard, the
-        # joysticks and the pot devices, which the host holds. A cartridge is
-        # already in the port, built from its setup (C64#load_state).
-        def save_state(out)
-          out.marker("BUS")
-          out.int(@cpu_port.ddr).int(@cpu_port.data).int(@cpu_port.floating)
-          @ram.save_state(out)
-          @color_ram.save_state(out)
-          @ram_expansion.save_state(out)
-          @cartridge&.save_state(out)
-          @datasette.save_state(out)
-          @vic.save_state(out)
-          @cia1.save_state(out)
-          @cia2.save_state(out)
-          @sid.save_state(out)
-        end
-
-        def load_state(input)
-          input.marker("BUS")
-          ddr = input.int
-          port_out = input.int
-          floating = input.int
-          @ram.load_state(input)
-          @color_ram.load_state(input)
-          @ram_expansion.load_state(input)
-          @cartridge&.load_state(input)
-          @datasette.load_state(input)
-          @cpu_port.load(ddr, port_out, floating)
-          update_overlays!
-          @vic.load_state(input)
-          @cia1.load_state(input)
-          @cia2.load_state(input)
-          @sid.load_state(input)
-        end
-      end
-
-      include SavedState
-    end
-  end
-end

data/lib/badline/c64/cartridge/flash/saved_state.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class C64
-    class Cartridge
-      class Flash
-        # A Flash chip's state, for a snapshot.
-        module SavedState
-          STATES = %i[read program_setup autoselect programming erase_window erasing suspended chip_erase
-                      program_error].freeze
-
-          # The array, the command state, a timed operation's end on the
-          # machine's clock, and the windows handed out so far, which load_state
-          # builds anew.
-          def save_state(out)
-            out.blob(@data).int(STATES.index(@state)).int(STATES.index(@base_state)).int(@cycle).int(@toggle)
-            out.optional_int(@done_at).optional_int(@programmed).optional_int(@remaining)
-            out.boolean(!@erasing_sectors.nil?)
-            out.ints(@erasing_sectors) if @erasing_sectors
-            out.ints(@windows.keys).ints(@status_windows.keys)
-          end
-
-          def load_state(input)
-            input.blob_into(@data)
-            @state = STATES.fetch(input.int).to_sym
-            @base_state = STATES.fetch(input.int).to_sym
-            @cycle = input.int
-            @toggle = input.int
-            @done_at = input.optional_int
-            @programmed = input.optional_int
-            @remaining = input.optional_int
-            @erasing_sectors = nil
-            @erasing_sectors = input.ints if input.boolean?
-            rebuild_windows(input.ints, input.ints)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/badline/c64/cartridge/retro_replay/saved_state.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class C64
-    class Cartridge
-      class RetroReplay < Cartridge
-        # A Retro Replay's registers, RAM and flash, for a snapshot.
-        module SavedState
-          private
-
-          def save_jumpers(out)
-            out.boolean(true).boolean(@flash_jumper).boolean(@bank_jumper)
-          end
-
-          def save_mapper(out)
-            [@active, @frozen, @phi1_ultimax, @ram_enabled, @ram_at_a000, @allow_bank, @no_freeze, @reu_mapping,
-             @write_once].each { |flag| out.boolean(flag) }
-            out.int(@bank).int(RetroReplay::CONTROL_MODES.index(@config))
-            @ram_data.each { |data| out.blob(data) }
-            @flash.save_state(out)
-          end
-
-          def load_mapper(input)
-            load_flags(input)
-            @bank = input.int
-            @config = RetroReplay::CONTROL_MODES.fetch(input.int)
-            @ram_data.each { |data| input.blob_into(data) }
-            @flash.load_state(input)
-            map_windows
-          end
-
-          def load_flags(input)
-            @active = input.boolean?
-            @frozen = input.boolean?
-            @phi1_ultimax = input.boolean?
-            @ram_enabled = input.boolean?
-            @ram_at_a000 = input.boolean?
-            @allow_bank = input.boolean?
-            @no_freeze = input.boolean?
-            @reu_mapping = input.boolean?
-            @write_once = input.boolean?
-          end
-        end
-      end
-    end
-  end
-end

data/lib/badline/c64/cartridge/saved_state.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class C64
-    class Cartridge
-      # A cartridge's state for a snapshot: the setup that builds it again and
-      # the state that goes into it.
-      module SavedState
-        # What builds the same cartridge afresh (Cartridge.from_setup): the CRT
-        # image it was built from, and the jumpers of a mapper that has them.
-        def save_setup(out)
-          out.int(CRT_SETUP).string(Storage::CRTFile.encode(@crt))
-          save_jumpers(out)
-        end
-
-        # The lines, the pull on NMI, the button and the mapper's own state.
-        # Loading sets them without calling back into the machine, which maps
-        # the cartridge again afterwards.
-        def save_state(out)
-          out.marker("CARTRIDGE")
-          out.int(@exrom).int(@game).boolean(@nmi).boolean(@button == true)
-          save_mapper(out)
-        end
-
-        def load_state(input)
-          input.marker("CARTRIDGE")
-          @exrom = input.int
-          @game = input.int
-          @nmi = input.boolean?
-          @button = input.boolean?
-          load_mapper(input)
-        end
-
-        private
-
-        def save_jumpers(out)
-          out.boolean(false)
-        end
-
-        # The mapper's own state: where its windows point, for a mapper that
-        # moves them, and whatever a mapper adds after calling super.
-        def save_mapper(out)
-          save_windows(out, windows) if windows
-        end
-
-        def load_mapper(input)
-          load_windows(input, windows) if windows
-        end
-
-        # Where the ROML and ROMH windows point, as their places in `windows`,
-        # the banks and views the mapper picks them from, or -1 for none.
-        def save_windows(out, windows)
-          out.int(window_index(@roml, windows)).int(window_index(@romh, windows))
-        end
-
-        def load_windows(input, windows)
-          @roml = window_at(input.int, windows)
-          @romh = window_at(input.int, windows)
-        end
-      end
-    end
-  end
-end

data/lib/badline/c64/reu/dma/saved_state.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class C64
-    class REU
-      class DMA
-        # A transfer's state for a snapshot (REU::SavedState).
-        module SavedState
-          # Everything a transfer holds between cycles. Before the first
-          # transfer, the fields it sets on starting are empty.
-          def save_state(out)
-            out.int(@c64).int(@expansion).int(@length).int(@events)
-            [@type, @c64_step, @expansion_step, @last, @ba_low_after_writes, @swap_byte, @held_read].each do |value|
-              out.optional_int(value)
-            end
-            [@holding, @waiting, @stopped_after_write, @swap_write_due, @swap_read_again, @moved_all,
-             @extra_cycle].each do |flag|
-              out.boolean(flag)
-            end
-          end
-
-          def load_state(input)
-            @c64 = input.int
-            @expansion = input.int
-            @length = input.int
-            @events = input.int
-            load_steps(input)
-            @holding = input.boolean?
-            @waiting = input.boolean?
-            @stopped_after_write = input.boolean?
-            @swap_write_due = input.boolean?
-            @swap_read_again = input.boolean?
-            @moved_all = input.boolean?
-            @extra_cycle = input.boolean?
-          end
-
-          private
-
-          def load_steps(input)
-            @type = input.optional_int
-            @c64_step = input.optional_int
-            @expansion_step = input.optional_int
-            @last = input.optional_int
-            @ba_low_after_writes = input.optional_int
-            @swap_byte = input.optional_int
-            @held_read = input.optional_int
-          end
-        end
-      end
-    end
-  end
-end

data/lib/badline/c64/reu/saved_state.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class C64
-    class REU
-      # The REU's state for a snapshot: the REC's registers and the values
-      # its counters start from, an armed or running transfer, the IRQ line,
-      # the transfer's own state and the RAM. The size is the machine's
-      # setup (Snapshot::C64Setup), so a restore finds an REU of the same size.
-      module SavedState
-        def size_kb = @size_kb
-
-        def save_state(out)
-          out.marker("REU")
-          [@status, @command, @c64, @c64_start, @expansion, @expansion_start, @bank, @bank_start, @length,
-           @length_start, @interrupt_mask, @address_control].each { |value| out.int(value) }
-          out.boolean(@armed).boolean(@requested).boolean(@running).boolean(@irq).boolean(@ba_was_low)
-          @dma.save_state(out)
-          @ram.save_state(out)
-        end
-
-        # The IRQ line comes back as it was without calling back into the
-        # machine, which reads it again afterwards.
-        def load_state(input)
-          input.marker("REU")
-          load_registers(input)
-          @armed = input.boolean?
-          @requested = input.boolean?
-          @running = input.boolean?
-          @irq = input.boolean?
-          @ba_was_low = input.boolean?
-          @dma.load_state(input)
-          @ram.load_state(input)
-        end
-
-        private
-
-        def load_registers(input)
-          @status = input.int
-          @command = input.int
-          @c64 = input.int
-          @c64_start = input.int
-          @expansion = input.int
-          @expansion_start = input.int
-          @bank = input.int
-          @bank_start = input.int
-          @length = input.int
-          @length_start = input.int
-          @interrupt_mask = input.int
-          @address_control = input.int
-        end
-      end
-    end
-  end
-end

data/lib/badline/c64/saved_state.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class C64
-    # The keyword arguments C64.new takes to build the machine a
-    # State from #snapshot was taken of.
-    def self.setup(state) = Snapshot::C64Setup.from(state)
-
-    # A new machine, built as the one a State from #snapshot was taken of,
-    # at that state. `detached` builds it without the host's files
-    # (Snapshot::StateReader).
-    def self.restored(state, detached: false) = setup(state).build.apply_state(state, detached:)
-
-    # The whole machine's state for a snapshot: the machine's own latches,
-    # the bus and its chips, the CPU, and what is attached to it
-    # (Attachments).
-    module SavedState
-      # How many more on_init handlers the machine a State was taken of had
-      # yet to run than this one has: they are the host's blocks, which a
-      # State can't hold. Nil until the machine is restored.
-      attr_reader :init_handlers_lost
-
-      # The machine's whole state, in memory. #restore takes the machine, or
-      # another built with the same chip models, region and RAM expansion,
-      # back to it. The cartridge, the disk in device 8, a true 1541 and its
-      # disk and the tape go in the state too. What the host holds stays
-      # out: the keyboard, the joysticks and the pot devices, the traps and
-      # callbacks, whether the display renders and whether the SID records.
-      def snapshot
-        out = Snapshot::StateWriter.new
-        save_state(out)
-        out.state
-      end
-
-      # Takes the machine back to a State from #snapshot. The machine keeps
-      # its chips, its traps and its callbacks, and puts in the cartridge,
-      # drives and tape the state has, taking out any it hasn't. Raises
-      # Snapshot::FormatError for a state of a machine built another way.
-      # The state goes into a new machine first, so one that fails leaves
-      # this machine as it was.
-      def restore(state)
-        check_setup(C64.setup(state))
-        C64.restored(state)
-        apply_state(state)
-      end
-
-      # Puts a State into the machine without trying it on a new one
-      # first, for a machine built for it (C64.restored): a state that
-      # fails leaves the machine part restored. `detached` restores it
-      # without the host's files (Snapshot::StateReader).
-      def apply_state(state, detached: false)
-        input = Snapshot::StateReader.new(state, detached:)
-        load_state(input)
-        raise Snapshot::FormatError, "the state goes on past the machine" unless input.finished?
-
-        self
-      end
-
-      # Sets the machine's cycle count, for a snapshot from VICE, which
-      # counts from its own clock.
-      def resume_at(cycles)
-        @cycles = cycles
-      end
-
-      def save_state(out)
-        out.marker(Snapshot::C64Setup::MARKER).stamp
-        Snapshot::C64Setup.of(address_bus).write(out)
-        out.int(@cycles).boolean(@nmi_asserted).boolean(@cartridge_nmi).boolean(@restore_pulse).boolean(@freezing)
-        out.int(@freeze_writes).boolean(!@pending_keys.nil?)
-        out.ints(@pending_keys) if @pending_keys
-        out.int(booting? ? @init_handlers.length : 0)
-        save_cartridge(out)
-        address_bus.save_state(out)
-        @cpu.save_state(out)
-        save_trap_dos(out)
-        save_serial_bus(out)
-        save_reu(out)
-      end
-
-      def load_state(input)
-        input.marker(Snapshot::C64Setup::MARKER)
-        input.check_stamp
-        check_setup(Snapshot::C64Setup.read(input))
-        @cycles = input.int
-        @nmi_asserted = input.boolean?
-        @cartridge_nmi = input.boolean?
-        @restore_pulse = input.boolean?
-        @freezing = input.boolean?
-        @freeze_writes = input.int
-        @pending_keys = nil
-        @pending_keys = input.ints if input.boolean?
-        @init_handlers_lost = [input.int - @init_handlers.length, 0].max
-        load_cartridge(input)
-        address_bus.load_state(input)
-        push_serial_lines
-        @cpu.load_state(input)
-        load_trap_dos(input)
-        load_serial_bus(input)
-        load_reu(input)
-      end
-
-      private
-
-      def check_setup(setup)
-        ours = Snapshot::C64Setup.of(address_bus)
-        return if setup == ours
-
-        raise Snapshot::FormatError, "the state is of a machine with #{setup}, not #{ours}"
-      end
-    end
-  end
-end

data/lib/badline/chips/cia/saved_state.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Chips
-    class CIA
-      # A snapshot of the chip: everything it holds but its wiring, the ports,
-      # the PB4 and CNT levels, the timers, the interrupt register, the serial
-      # port and the TOD clock.
-      module SavedState
-        def save_state(out)
-          out.marker("CIA")
-          out.int(@data_port_a).int(@data_port_b).int(@data_dir_a).int(@data_dir_b)
-          out.boolean(@port_b4_high).boolean(@port_b4_driven_high).boolean(@cnt_high).boolean(@cnt_rise)
-          out.int(@control_a.value).int(@control_b.value)
-          @ta.save_state(out)
-          @tb.save_state(out)
-          @icr.save_state(out)
-          @serial.save_state(out)
-          @tod.save_state(out)
-        end
-
-        def load_state(input)
-          input.marker("CIA")
-          @data_port_a = input.int
-          @data_port_b = input.int
-          @data_dir_a = input.int
-          @data_dir_b = input.int
-          @port_b4_high = input.boolean?
-          @port_b4_driven_high = input.boolean?
-          @cnt_high = input.boolean?
-          @cnt_rise = input.boolean?
-          @control_a.value = input.int
-          @control_b.value = input.int
-          load_parts(input)
-        end
-
-        private
-
-        def load_parts(input)
-          @ta.load_state(input)
-          @tb.load_state(input)
-          @icr.load_state(input)
-          @serial.load_state(input)
-          @tod.load_state(input)
-        end
-      end
-    end
-  end
-end

data/lib/badline/chips/cia/serial/saved_state.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Chips
-    class CIA
-      class Serial
-        # The shift register's state for a snapshot.
-        module SavedState
-          def save_state(out)
-            out.int(@data).int(@shift).int(@steps).optional_int(@empty_in).optional_int(@busy_in)
-            out.boolean(@busy).boolean(@abandoned).optional_int(@pending).boolean(@underflow_high).boolean(@in_flight)
-            out.int(@flight_up).int(@flight_down).boolean(@idle)
-            [@cnt, @cnt_in, @sp_in, @sp_out].each { |level| out.boolean(level) }
-          end
-
-          def load_state(input)
-            @data = input.int
-            @shift = input.int
-            @steps = input.int
-            @empty_in = input.optional_int
-            @busy_in = input.optional_int
-            @busy = input.boolean?
-            @abandoned = input.boolean?
-            @pending = input.optional_int
-            load_lines(input)
-          end
-
-          private
-
-          def load_lines(input)
-            @underflow_high = input.boolean?
-            @in_flight = input.boolean?
-            @flight_up = input.int
-            @flight_down = input.int
-            @idle = input.boolean?
-            @cnt = input.boolean?
-            @cnt_in = input.boolean?
-            @sp_in = input.boolean?
-            @sp_out = input.boolean?
-          end
-        end
-      end
-    end
-  end
-end