badline 0.13.0 → 0.14.0

data/lib/badline/c64/keyed_modules.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    # The whole machine as keyed snapshot modules (Snapshot::Keyed), in the
+    # order a load applies them: BL-MACHINE with the setup, the memories,
+    # the cartridge, the CPU with its port, the chips, an REU, the
+    # datasette, device 8 through the traps and the true drives. A load
+    # reads the CPU's port before the chips, so the banks are mapped as the
+    # chips load, and the CPU's own fields after them. What each unit works
+    # out again from its fields comes last, once every unit is loaded.
+    module KeyedModules
+      def save_modules
+        bus = address_bus
+        sections = [Snapshot::Keyed.section("BL-MACHINE") { |out| save_machine_fields(out) },
+                    Snapshot::Keyed.section("BL-RAM") { |out| bus.ram.save_fields(out, "ram") }]
+        expansion = bus.ram_expansion
+        sections << Snapshot::Keyed.section("BL-RAMEXP") { |out| expansion.save_fields(out) } if expansion.type
+        sections << Snapshot::Keyed.section("BL-COLORRAM") { |out| bus.color_ram.save_fields(out, "ram") }
+        cartridge = bus.cartridge
+        sections << Snapshot::Keyed.section("BL-CART") { |out| cartridge.save_fields(out) } if cartridge
+        save_chip_modules(sections, bus)
+        reu = @reu
+        sections << Snapshot::Keyed.section("BL-REU") { |out| reu.save_fields(out) } if reu
+        sections << Snapshot::Keyed.section("BL-TAPE") { |out| bus.datasette.save_fields(out) }
+        sections << Snapshot::Keyed.section("BL-TRAPDOS") { |out| save_trap_dos_fields(out) } if mounted?
+        save_drive_modules(sections)
+      end
+
+      # Raises Snapshot::FormatError for the modules of a machine built
+      # another way.
+      def load_modules(modules)
+        machine = modules.machine
+        check_snapshot_setup(Snapshot::C64Setup.read_fields(machine))
+        load_machine_fields(machine)
+        bus = address_bus
+        bus.ram.load_fields(modules.required("BL-RAM"), "ram")
+        bus.ram_expansion.load_fields(modules.required("BL-RAMEXP")) if bus.ram_expansion.type
+        bus.color_ram.load_fields(modules.required("BL-COLORRAM"), "ram")
+        load_cartridge_module(modules.optional("BL-CART"))
+        cpu = modules.required("BL-CPU")
+        bus.load_port_fields(cpu)
+        bus.restored!
+        load_chip_modules(modules, cpu)
+        bus.datasette.load_fields(modules.required("BL-TAPE"))
+        load_trap_dos_module(modules)
+        load_drive_modules(modules)
+        modules_restored!
+        self
+      end
+
+      private
+
+      def save_chip_modules(sections, bus)
+        sections << Snapshot::Keyed.section("BL-CPU") do |out|
+          @cpu.save_fields(out)
+          bus.save_port_fields(out)
+        end
+        sections << Snapshot::Keyed.section("BL-VIC") { |out| @vic.save_fields(out) }
+        sections << Snapshot::Keyed.section("BL-CIA1") { |out| @cia1.save_fields(out) }
+        sections << Snapshot::Keyed.section("BL-CIA2") { |out| @cia2.save_fields(out) }
+        sections << Snapshot::Keyed.section("BL-SID") { |out| @sid.save_fields(out) }
+      end
+
+      def load_chip_modules(modules, cpu)
+        @vic.load_fields(modules.required("BL-VIC"))
+        @cia1.load_fields(modules.required("BL-CIA1"))
+        @cia2.load_fields(modules.required("BL-CIA2"))
+        @sid.load_fields(modules.required("BL-SID"))
+        @reu&.load_fields(modules.required("BL-REU"))
+        @cpu.load_fields(cpu)
+      end
+
+      # The cartridge comes back built afresh from the CRT image the module
+      # holds, before its state goes in. No module means no cartridge.
+      def load_cartridge_module(input)
+        if input
+          cartridge = Cartridge.from_fields(input)
+          connect_cartridge(cartridge)
+          cartridge.load_fields(input)
+        elsif address_bus.cartridge
+          address_bus.detach_cartridge
+        end
+      end
+
+      def load_trap_dos_module(modules)
+        input = modules.optional("BL-TRAPDOS")
+        input ? load_trap_dos_fields(input, detached: modules.detached?) : unmount
+      end
+
+      def modules_restored!
+        @cpu.restored!
+        @vic.restored!
+        @cia1.restored!
+        @cia2.restored!
+        @sid.restored!
+        @reu&.restored!
+        machine_restored!
+      end
+
+      def check_snapshot_setup(setup)
+        ours = Snapshot::C64Setup.of(address_bus)
+        return if setup == ours
+
+        raise Snapshot::FormatError, "the snapshot is of a machine with #{setup}, not #{ours}"
+      end
+    end
+
+    include KeyedModules
+  end
+end

data/lib/badline/c64/keyed_state.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    # The machine's own fields in a keyed snapshot module (Snapshot::Keyed,
+    # BL-MACHINE): the family, its setup by name, the cycle count, the NMI
+    # glue, the freezer's write count and the REU's hold on the bus, and the
+    # host's typing still to feed and on_init handlers still to run under
+    # host.*. The badline version that wrote it is written for reports and
+    # never read.
+    module KeyedState
+      # How many more on_init handlers the machine a snapshot was taken of had
+      # yet to run than this one has: they are the host's blocks, which a
+      # snapshot can't hold. Nil until the machine is restored.
+      attr_reader :init_handlers_lost
+
+      # Sets the machine's cycle count, for a snapshot from VICE, which
+      # counts from its own clock.
+      def resume_at(cycles)
+        @cycles = cycles
+      end
+
+      # Whether a snapshot saves now (Machine::Settling): the CPU between
+      # instructions or jammed, and no REU transfer under way.
+      def settled_for_snapshot? = (@cpu.boundary? || @cpu.jammed?) && !reu&.dma?
+
+      # The SID's deferred cycles and writes, run up to this cycle, and the
+      # VIC's sprite collisions latched up to the beam.
+      def settle_chips_for_snapshot
+        sid.catch_up!
+        @vic.fold_collisions!
+      end
+
+      def save_machine_fields(out)
+        out.text("family", "c64").text("written_by", VERSION)
+        Snapshot::C64Setup.of(address_bus).write_fields(out)
+        out.int("cycles", @cycles).bool("nmi_asserted", @nmi_asserted).bool("cartridge_nmi", @cartridge_nmi)
+        out.bool("restore_pulse", @restore_pulse).bool("freezing", @freezing).int("freeze_writes", @freeze_writes)
+        out.bool("dma", @dma)
+        pending = @pending_keys
+        out.ints("host.pending_keys", pending) if pending
+        out.int("host.init_pending", booting? ? @init_handlers.length : 0)
+      end
+
+      def load_machine_fields(input)
+        @cycles = input.int("cycles", @cycles)
+        @nmi_asserted = input.bool("nmi_asserted", @nmi_asserted)
+        @cartridge_nmi = input.bool("cartridge_nmi", @cartridge_nmi)
+        @restore_pulse = input.bool("restore_pulse", @restore_pulse)
+        @freezing = input.bool("freezing", @freezing)
+        @freeze_writes = input.int("freeze_writes", @freeze_writes)
+        @dma = input.bool("dma", @dma)
+        pending = input.ints("host.pending_keys", [])
+        @pending_keys = pending.empty? ? nil : pending.dup
+        @init_handlers_lost = [input.int("host.init_pending", 0) - @init_handlers.length, 0].max
+      end
+
+      # The REU's IRQ line and the serial bus's lines from CIA 2, once the
+      # chips are loaded.
+      def machine_restored!
+        @reu_irq = @reu.nil? ? false : @reu.irq?
+        push_serial_lines
+      end
+    end
+
+    include KeyedState
+  end
+end

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "badline/c64/reu/dma/saved_state"
-
 module Badline
   class C64
     class REU
@@ -11,8 +9,6 @@ module Badline
       # After a write it goes on through the first BA-low cycle and stops at
       # the second. See doc/pinned-behaviour.md, REU DMA.
       class DMA
-        include SavedState
-
         # Transfer types, as the command register's bottom two bits give
         # them.
         STASH = 0

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

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Badline
+  class C64
+    class REU
+      class DMA
+        # The kinds of transfer, by name.
+        TYPE_NAMES = %w[stash fetch swap verify].freeze
+
+        # A transfer's fields in a keyed snapshot module, under `prefix`.
+        # Before the first transfer, the fields it sets on starting are
+        # absent.
+        module KeyedState
+          def save_fields(out, prefix)
+            out.int("#{prefix}c64", @c64).int("#{prefix}expansion", @expansion).int("#{prefix}length", @length)
+            out.int("#{prefix}events", @events)
+            type = @type
+            out.text("#{prefix}type", TYPE_NAMES.fetch(type)) unless type.nil?
+            out.optional_int("#{prefix}c64_step", @c64_step).optional_int("#{prefix}expansion_step", @expansion_step)
+            out.optional_int("#{prefix}last", @last).optional_int("#{prefix}ba_low_after_writes", @ba_low_after_writes)
+            out.optional_int("#{prefix}swap_byte", @swap_byte).optional_int("#{prefix}held_read", @held_read)
+            save_flag_fields(out, prefix)
+          end
+
+          def load_fields(input, prefix)
+            @c64 = input.word("#{prefix}c64", @c64)
+            @expansion = input.int("#{prefix}expansion", @expansion)
+            @length = input.int("#{prefix}length", @length)
+            @events = input.int("#{prefix}events", @events)
+            type = input.choice("#{prefix}type", TYPE_NAMES + ["none"], "none")
+            @type = type == "none" ? nil : TYPE_NAMES.index(type)
+            @c64_step = input.optional_int("#{prefix}c64_step")
+            @expansion_step = input.optional_int("#{prefix}expansion_step")
+            @last = input.optional_int("#{prefix}last")
+            @ba_low_after_writes = input.optional_int("#{prefix}ba_low_after_writes")
+            @swap_byte = input.optional_int("#{prefix}swap_byte")
+            @held_read = input.optional_int("#{prefix}held_read")
+            load_flag_fields(input, prefix)
+          end
+
+          private
+
+          def save_flag_fields(out, prefix)
+            out.bool("#{prefix}holding", @holding).bool("#{prefix}waiting", @waiting)
+            out.bool("#{prefix}stopped_after_write", @stopped_after_write)
+            out.bool("#{prefix}swap_write_due", @swap_write_due).bool("#{prefix}swap_read_again", @swap_read_again)
+            out.bool("#{prefix}moved_all", @moved_all).bool("#{prefix}extra_cycle", @extra_cycle)
+          end
+
+          def load_flag_fields(input, prefix)
+            @holding = input.bool("#{prefix}holding", @holding)
+            @waiting = input.bool("#{prefix}waiting", @waiting)
+            @stopped_after_write = input.bool("#{prefix}stopped_after_write", @stopped_after_write)
+            @swap_write_due = input.bool("#{prefix}swap_write_due", @swap_write_due)
+            @swap_read_again = input.bool("#{prefix}swap_read_again", @swap_read_again)
+            @moved_all = input.bool("#{prefix}moved_all", @moved_all)
+            @extra_cycle = input.bool("#{prefix}extra_cycle", @extra_cycle)
+          end
+        end
+
+        include KeyedState
+      end
+
+      class RAM
+        # The data latch and each bank the REC has touched, as bank<N>; a
+        # bank left out holds its power-on contents.
+        module KeyedState
+          def save_fields(out)
+            out.int("latch", @latch)
+            @banks.each_with_index { |bank, number| out.bytes("bank#{number}", bank) unless bank.empty? }
+          end
+
+          def load_fields(input)
+            @latch = input.byte("latch", @latch)
+            @banks.each_index do |number|
+              @banks[number] = input.bytes("bank#{number}", "".b).bytes
+            end
+          end
+        end
+
+        include KeyedState
+      end
+
+      # The REU's fields in a keyed snapshot module (Snapshot::Keyed): the
+      # REC's registers and the values its counters start from, an armed or
+      # running transfer, the transfer under dma.*, and the RAM. The IRQ
+      # line comes from the status register on load.
+      module KeyedState
+        # The REU's size in K, which the machine's setup names.
+        def size_kb = @size_kb
+
+        def save_fields(out)
+          out.int("status", @status).int("command", @command).int("c64", @c64).int("c64_start", @c64_start)
+          out.int("expansion", @expansion).int("expansion_start", @expansion_start).int("bank", @bank)
+          out.int("bank_start", @bank_start).int("length", @length).int("length_start", @length_start)
+          out.int("interrupt_mask", @interrupt_mask).int("address_control", @address_control)
+          out.bool("armed", @armed).bool("requested", @requested).bool("running", @running)
+          out.bool("ba_was_low", @ba_was_low)
+          @dma.save_fields(out, "dma.")
+          @ram.save_fields(out)
+          out
+        end
+
+        def load_fields(input)
+          load_register_fields(input)
+          @armed = input.bool("armed", @armed)
+          @requested = input.bool("requested", @requested)
+          @running = input.bool("running", @running)
+          @ba_was_low = input.bool("ba_was_low", @ba_was_low)
+          @dma.load_fields(input, "dma.")
+          @ram.load_fields(input)
+        end
+
+        # Without calling back into the machine, which reads the line again.
+        def restored!
+          @irq = @status.anybits?(INTERRUPT_PENDING)
+        end
+
+        private
+
+        def load_register_fields(input)
+          @status = input.byte("status", @status)
+          @command = input.byte("command", @command)
+          @c64 = input.word("c64", @c64)
+          @c64_start = input.word("c64_start", @c64_start)
+          @expansion = input.word("expansion", @expansion)
+          @expansion_start = input.word("expansion_start", @expansion_start)
+          @bank = input.byte("bank", @bank)
+          @bank_start = input.byte("bank_start", @bank_start)
+          @length = input.word("length", @length)
+          @length_start = input.word("length_start", @length_start)
+          @interrupt_mask = input.byte("interrupt_mask", @interrupt_mask)
+          @address_control = input.byte("address_control", @address_control)
+        end
+      end
+
+      include KeyedState
+    end
+  end
+end

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

@@ -38,21 +38,6 @@ module Badline
           bank(addr >> 16)[addr & 0xffff] = value if addr < @size
         end
 
-        # The latch, and each 64K bank the REC has touched. A bank it hasn't
-        # keeps its power-on contents until it does.
-        def save_state(out)
-          out.int(@latch)
-          @banks.each do |bank|
-            out.boolean(!bank.empty?)
-            out.blob(bank) unless bank.empty?
-          end
-        end
-
-        def load_state(input)
-          @latch = input.int
-          @banks.each_index { |number| @banks[number] = input.boolean? ? input.blob : [] }
-        end
-
         # Every byte, as one string, with a bank the REC hasn't touched at
         # its power-on contents.
         def contents

data/lib/badline/c64/reu.rb

@@ -3,7 +3,7 @@
 require "badline/c64/reu/ram"
 require "badline/c64/reu/dma"
 require "badline/c64/reu/trigger"
-require "badline/c64/reu/saved_state"
+require "badline/c64/reu/keyed_state"
 
 module Badline
   class C64
@@ -20,8 +20,6 @@ module Badline
     # waits for the CPU's next read cycle with BA high, and C64 then
     # clocks it through #dma_cycle! until it hands the bus back.
     class REU
-      include SavedState
-
       SIZES_KB = [128, 256, 512, 1024, 2048, 4096, 8192, 16_384].freeze
 
       # The registers, by offset.

data/lib/badline/c64/true_drives.rb

@@ -8,6 +8,9 @@ module Badline
     module TrueDrives
       include Drives::Model1581::Slot
 
+      # The true drive models a snapshot names.
+      DRIVE_MODELS = %w[1541 1571 1581].freeze
+
       # Plugs in a Drives::Model1541, which then runs alongside the machine on its
       # own clock and talks to it over the serial bus. The serial traps stop
       # answering the drive's device number, so the KERNAL's TALK, LISTEN and
@@ -33,6 +36,35 @@ module Badline
         Drives::Model1541.new.tap { |drive| attach_drive1541(drive) }
       end
 
+      # The true drives as keyed snapshot modules, each named from its device
+      # number: BL-D8, BL-D8-CPU and so on for device 8.
+      def save_drive_modules(sections)
+        drive1541 = @drive1541
+        drive1541&.save_modules(sections, "BL-D#{drive1541.device}")
+        drive1581 = @drive1581
+        drive1581&.save_modules(sections, "BL-D#{drive1581.device}")
+        save_drive1571_modules(sections)
+        sections
+      end
+
+      # The true drives a snapshot's modules hold, built afresh unless the
+      # same model is on the bus as the same device. A drive the snapshot
+      # doesn't have comes off the bus.
+      def load_drive_modules(modules)
+        models = []
+        8.upto(11) do |device|
+          input = modules.optional("BL-D#{device}")
+          next unless input
+
+          model = input.choice("model", DRIVE_MODELS, "1541")
+          load_drive_model(modules, input, device, model)
+          models << model
+        end
+        detach_drive1541 unless models.include?("1541")
+        detach_drive1581 unless models.include?("1581")
+        detach_drive1571 unless models.include?("1571")
+      end
+
       # Unplugs the Drives::Model1541, leaving the serial bus with nothing on it.
       def detach_drive1541
         return unless @drive1541
@@ -55,15 +87,34 @@ module Badline
       # for its DOS to boot before typing.
       def drive1541_attached = nil
 
-      # A true 1541 on the serial bus, with its device number.
-      def load_drive1541(input)
-        return detach_drive1541 unless input.boolean?
+      def load_drive_model(modules, input, device, model)
+        case model
+        when "1581" then load_drive1581_modules(modules, input, device)
+        when "1571" then load_drive1571_modules(modules, input, device)
+        else load_drive1541_modules(modules, input, device)
+        end
+      end
 
-        device = input.int
+      def load_drive1541_modules(modules, input, device)
         detach_drive1541 if @drive1541 && @drive1541.device != device
         attach_drive1541(Drives::Model1541.new(device:)) unless @drive1541
-        @drive1541.load_state(input)
+        @drive1541.load_modules(modules, input, "BL-D#{device}")
       end
+
+      def load_drive1581_modules(modules, input, device)
+        detach_drive1581 if @drive1581 && @drive1581.device != device
+        attach_drive1581(Drives::Model1581.new(device:)) unless @drive1581
+        @drive1581.load_modules(modules, input, "BL-D#{device}")
+      end
+
+      # The C128D's 1571, which only the C128 has (C128::Drives).
+      def save_drive1571_modules(sections) = sections
+
+      def load_drive1571_modules(_modules, input, _device)
+        input.adjust("a 1571 doesn't plug into this machine, left out")
+      end
+
+      def detach_drive1571 = nil
     end
   end
 end

data/lib/badline/c64.rb

@@ -4,17 +4,18 @@ require "badline/c64/common"
 require "badline/c64/true_drives"
 require "badline/c64/attachments"
 require "badline/c64/kernal_traps"
-require "badline/c64/saved_state"
+require "badline/c64/keyed_state"
+require "badline/c64/keyed_modules"
 
 module Badline
   class C64
     include IntegerHelper
-    include KeyboardBuffer
+    include Machine::KeyboardBuffer
     include Machine::Clocking
+    include Machine::Settling
     include Common
     include Attachments
     include KernalTraps
-    include SavedState
 
     attr_reader :address_bus, :cpu, :cycles, :drive1541
 
@@ -188,6 +189,9 @@ module Badline
     # The KERNAL the traps stand in for (KernalTraps#mount).
     def trap_layout = KernalTrap::C64_LAYOUT
 
+    # The KERNAL's keyboard buffer, which #type_text feeds.
+    def keyboard_buffer = Machine::KeyboardBuffer::C64_LAYOUT
+
     def trap_bus = address_bus
 
     def plug_reu(size_kb)

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

@@ -35,23 +35,6 @@ module Badline
 
         def interrupted? = status.value >= 0x80
 
-        def save_state(out)
-          out.int(@mask.value).int(@status.value).int(@pending)
-          [@read, @read_last_cycle, @read_two_cycles_ago].each { |read| out.optional_int(read) }
-          out.boolean(@timer_b_bug).boolean(@quiet)
-        end
-
-        def load_state(input)
-          @mask.value = input.int
-          @status.value = input.int
-          @pending = input.int
-          @read = input.optional_int
-          @read_last_cycle = input.optional_int
-          @read_two_cycles_ago = input.optional_int
-          @timer_b_bug = input.boolean?
-          @quiet = input.boolean?
-        end
-
         # Raises IR on this cycle.
         def assert_now
           status.interrupt = true