badline 0.13.0 → 0.15.0

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

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

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Chips
-    class CPU
-      # The CPU's state for a snapshot: the registers, the interrupt lines and
-      # their pipeline, and the step of the instruction in flight, named by
-      # where its plan comes from.
-      module SavedState
-        # Writes everything the CPU holds, down to the step of the instruction
-        # it is in, for load_state to put back. The interrupt lines, BA stalls
-        # and SO are state too; the traps and the debug flag belong to the host.
-        def save_state(out)
-          out.marker("CPU")
-          out.int(@program_counter).int(@stack_pointer).int(@a).int(@x).int(@y).int(@status.value)
-          [@irq, @nmi, @irq_sample, @irq_pending, @nmi_sample, @nmi_pending, @skip_poll, @boundary_irq,
-           @boundary_nmi, @boundary_crossed, @brk, @pending_write, @so_high, @optional_dummy,
-           @branch_taken].each { |flag| out.boolean(flag) }
-          out.optional_int(@interrupt).optional_int(@stalled_at).int(@cycles).int(@instructions)
-          out.int(plan_source).int(@index).int(OPERATIONS.index(@operation) || -1)
-          [@address, @dummy_address, @value, @rmw_result, @pointer].each { |register| out.optional_int(register) }
-        end
-
-        def load_state(input)
-          input.marker("CPU")
-          @program_counter = input.int
-          @stack_pointer = input.int
-          @a = input.int
-          @x = input.int
-          @y = input.int
-          @status.value = input.int
-          load_flags(input)
-          @interrupt = input.optional_int
-          @stalled_at = input.optional_int
-          @cycles = input.int
-          @instructions = input.int
-          load_plan(input.int)
-          @index = input.int
-          operation = input.int
-          @operation = operation.negative? ? nil : OPERATIONS.fetch(operation)
-          load_working_registers(input)
-        end
-
-        # Drops the instruction or interrupt sequence in flight and the
-        # interrupt lines' pipeline, so the next cycle fetches an opcode at the
-        # program counter, and sets the cycle count. A snapshot taken between
-        # instructions, as VICE's are, restores through here.
-        def resume(cycles)
-          @irq_sample = @irq_pending = false
-          @nmi_sample = @nmi_pending = false
-          @skip_poll = false
-          @interrupt = nil
-          @brk = false
-          @stalled_at = nil
-          @cycles = cycles
-          end_sequence
-          @pending_write = false
-        end
-
-        private
-
-        # Where the plan running comes from: an opcode's microcode, or FETCH,
-        # INTERRUPT or JAMMED below it.
-        def plan_source
-          return FETCH if @plan.equal?(FETCH_PLAN)
-          return INTERRUPT if @plan.equal?(INTERRUPT_PLAN)
-          return JAMMED if @plan.equal?(JAMMED_PLAN)
-
-          MICROCODE.index { |micro| micro.plan.equal?(@plan) && micro.operation == @operation } ||
-            MICROCODE.index { |micro| micro.plan.equal?(@plan) }
-        end
-
-        def load_plan(source)
-          case source
-          when FETCH then use_plan(FETCH_PLAN, FETCH_WRITES)
-          when INTERRUPT then use_plan(INTERRUPT_PLAN, INTERRUPT_WRITES)
-          when JAMMED then use_plan(JAMMED_PLAN, JAMMED_WRITES)
-          else
-            micro = MICROCODE.fetch(source)
-            use_plan(micro.plan, micro.writes)
-          end
-        end
-
-        def use_plan(plan, writes)
-          @plan = plan
-          @writes = writes
-        end
-
-        def load_flags(input)
-          @irq = input.boolean?
-          @nmi = input.boolean?
-          @irq_sample = input.boolean?
-          @irq_pending = input.boolean?
-          @nmi_sample = input.boolean?
-          @nmi_pending = input.boolean?
-          @skip_poll = input.boolean?
-          @boundary_irq = input.boolean?
-          @boundary_nmi = input.boolean?
-          @boundary_crossed = input.boolean?
-          @brk = input.boolean?
-          @pending_write = input.boolean?
-          @so_high = input.boolean?
-          @optional_dummy = input.boolean?
-          @branch_taken = input.boolean?
-        end
-
-        def load_working_registers(input)
-          @address = input.optional_int
-          @dummy_address = input.optional_int
-          @value = input.optional_int
-          @rmw_result = input.optional_int
-          @pointer = input.optional_int
-        end
-      end
-    end
-  end
-end