badline 0.5.0 → 0.6.0

data/lib/badline/computer/saved_state.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Badline
+  class Computer
+    # The keyword arguments Computer.new takes to build the machine a
+    # State from #snapshot was taken of.
+    def self.setup(state)
+      input = Snapshot::StateReader.new(state)
+      input.marker("COMPUTER")
+      input.check_stamp
+      Snapshot::Setup.read(input)
+    end
+
+    # 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(Computer.setup(state))
+        Computer.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 (Computer.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("COMPUTER").stamp
+        Snapshot::Setup.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_drive(out)
+        save_serial_bus(out)
+        save_reu(out)
+      end
+
+      def load_state(input)
+        input.marker("COMPUTER")
+        input.check_stamp
+        check_setup(Snapshot::Setup.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)
+        @cpu.load_state(input)
+        load_trap_drive(input)
+        load_serial_bus(input)
+        load_reu(input)
+      end
+
+      private
+
+      def check_setup(setup)
+        ours = Snapshot::Setup.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/computer.rb

@@ -1,9 +1,14 @@
 # frozen_string_literal: true
 
+require "badline/computer/attachments"
+require "badline/computer/saved_state"
+
 module Badline
   class Computer
     include IntegerHelper
     include KeyboardBuffer
+    include Attachments
+    include SavedState
 
     attr_reader :address_bus, :cpu, :cycles, :drive1541
 
@@ -59,6 +64,7 @@ module Badline
       @pending_keys = nil
       @drive = nil
       @serial_trap = nil
+      @save_trap = nil
       @drive1541 = nil
       @iec_bus = nil
       @reu = reu ? plug_reu(reu) : nil
@@ -95,9 +101,7 @@ module Badline
     end
 
     def attach_cartridge(cartridge)
-      cartridge.clock = -> { @cycles }
-      cartridge.on_nmi_change { |level| @cartridge_nmi = level }
-      address_bus.attach_cartridge(cartridge)
+      connect_cartridge(cartridge)
       power_cycle!
     end
 
@@ -151,33 +155,6 @@ module Badline
       @restore_pulse = true
     end
 
-    # Puts the storage in device 8. Mounting again swaps the disk at any
-    # point while the machine runs: the drive keeps its RAM, which only a
-    # drive reset clears, and its status.
-    def mount(storage)
-      return @drive.insert(storage) if @drive
-
-      @drive = KernalTrap::Drive.new(storage)
-      load_trap = KernalTrap::Load.new(cpu:, bus: address_bus, drive: @drive)
-      cpu.install_trap(KernalTrap::Load::ADDRESS) { load_trap.call }
-      @serial_trap = KernalTrap::Serial.new(cpu:, bus: address_bus, drive: @drive, device: serial_trap_device).install
-      save_trap = KernalTrap::Save.new(cpu:, bus: address_bus, drive: @drive)
-      cpu.install_trap(KernalTrap::Save::ADDRESS) { save_trap.call }
-    end
-
-    # Takes device 8's mounted storage out, and with it the LOAD, SAVE and
-    # serial traps, so the KERNAL's routines go out over the serial bus.
-    # Mounting again starts a new drive, with its RAM cleared.
-    def unmount
-      return unless @drive
-
-      cpu.remove_trap(KernalTrap::Load::ADDRESS)
-      cpu.remove_trap(KernalTrap::Save::ADDRESS)
-      @serial_trap.device = nil
-      @serial_trap = nil
-      @drive = nil
-    end
-
     # Plugs in a Drive1541, which then runs alongside the C64 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
@@ -195,7 +172,7 @@ module Badline
     # for, which plugging in a drive does. Until then port A's serial
     # inputs float high.
     def iec_bus
-      @iec_bus ||= IECBus.new(host: @cia2).tap { |bus| @cia2.peripheral = bus }
+      @iec_bus ||= IECBus.new(host: @cia2).tap(&:plug_in!)
     end
 
     def capture_output

data/lib/badline/cpu/microcode.rb

@@ -165,5 +165,13 @@ module Badline
     INTERRUPT_WRITES = Microcode.write_mask(INTERRUPT_PLAN)
     JAMMED_WRITES = Microcode.write_mask(JAMMED_PLAN)
     MICROCODE = Microcode.table
+
+    # The instruction methods, in a fixed order a snapshot names them by.
+    OPERATIONS = MICROCODE.map(&:operation).uniq.freeze
+
+    # The plans a snapshot names that aren't an opcode's.
+    FETCH = -1
+    INTERRUPT = -2
+    JAMMED = -3
   end
 end

data/lib/badline/cpu/saved_state.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Badline
+  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

data/lib/badline/cpu.rb

@@ -4,6 +4,7 @@ require "badline/cpu/microcode"
 require "badline/cpu/addressing"
 require "badline/cpu/operations"
 require "badline/cpu/stack_operations"
+require "badline/cpu/saved_state"
 
 module Badline
   class CPU
@@ -16,6 +17,7 @@ module Badline
     include Addressing
     include Operations
     include StackOperations
+    include SavedState
 
     attr_reader :memory, :instructions, :boundary_crossed, :cycles, :pending_write
     attr_accessor :program_counter, :stack_pointer, :status, :a, :x, :y, :nmi, :irq

data/lib/badline/datasette.rb

@@ -54,6 +54,33 @@ module Badline
 
     def running? = @playing && @motor && !@tape.nil?
 
+    # The keys, the motor, the countdown to the next pulse and the tape: its
+    # path and how far it has played.
+    def save_state(out)
+      out.marker("DATASETTE")
+      out.boolean(@playing).boolean(@motor).int(@countdown).boolean(!@tape.nil?)
+      return unless @tape
+
+      out.string(@tape.path).int(@tape.position)
+    end
+
+    # A tape from another file goes in from its path, and a detached
+    # reader leaves the tape out. The sense and flag handlers don't fire.
+    def load_state(input)
+      input.marker("DATASETTE")
+      @playing = input.boolean?
+      @motor = input.boolean?
+      @countdown = input.int
+      return @tape = nil unless input.boolean?
+
+      path = input.string
+      position = input.int
+      return @tape = nil if input.detached?
+
+      @tape = Storage::TAP.new(path) unless @tape&.path&.b == path
+      @tape.position = position
+    end
+
     def cycle!
       return unless running?
 

data/lib/badline/drive1541/bus.rb

@@ -19,7 +19,8 @@ module Badline
     # both on a real 1541.
     #
     # While Idle records a pass of the DOS's idle loop, the bus watches it
-    # (see watch!).
+    # (see watch!). While Idle looks for an orbit, the bus guards the drive
+    # (see guard!).
     class Bus
       include Addressable
 
@@ -31,6 +32,10 @@ module Badline
       VOLATILE_VIA2_READS = 0x0730
       VOLATILE_VIA2_WRITES = 0x0ff0
 
+      # The timer each VIA register reaches, by offset, as bits: 1 for
+      # timer 1 and 2 for timer 2.
+      TIMER_REGISTERS = [0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 0, 0, 0, 0, 0, 0].freeze
+
       attr_reader :ram, :rom, :via1, :via2, :data
 
       # Whether a watched stretch did something that makes it unrepeatable.
@@ -40,6 +45,14 @@ module Badline
       # from before the first access.
       attr_reader :touched
 
+      # Whether the drive did something since guard! that reached outside
+      # it, or took something in from outside.
+      attr_reader :tainted
+
+      # The timers the drive read or wrote since guard!, as bits: VIA 1's
+      # timer 1 and timer 2 in bits 0 and 1, and VIA 2's in bits 2 and 3.
+      attr_reader :touched_timers
+
       def initialize(rom:, via1:, via2:)
         addressable_at(0, length: 2**16)
         @ram = Memory.new([], length: 0x0800, start: 0)
@@ -47,20 +60,50 @@ module Badline
         @via1 = via1
         @via2 = via2
         @data = 0
-        @watching = false
-        @volatile = false
+        @recording = @guarding = @watching = false
+        @volatile = @tainted = false
         @touched = {}
+        @touched_timers = 0
+        @led = 0
       end
 
       # Starts watching: see volatile and touched. The bus stops watching
       # once the stretch turns volatile.
       def watch!
-        @watching = true
+        @recording = true
         @volatile = false
         @touched = {}
+        watching!
       end
 
       def unwatch!
+        @recording = false
+        watching!
+      end
+
+      # Starts guarding: see tainted and touched_timers. Reading VIA 1's
+      # port B, which reads the serial bus, taints the drive, and so do
+      # any write to VIA 1, whose port B drives the serial bus, a write to
+      # VIA 2's shift register or ACR, and VIA 2 turning the motor on or
+      # changing the LED. The bus stops guarding once the drive is tainted.
+      def guard!
+        @guarding = true
+        @tainted = false
+        @touched_timers = 0
+        @led = @via2.port_b_output & Mechanism::LED
+        watching!
+      end
+
+      # The last byte on the data bus and the RAM. What a watched stretch
+      # touched is Idle's, and a restored bus isn't watching.
+      def save_state(out)
+        out.int(@data)
+        @ram.save_state(out)
+      end
+
+      def load_state(input)
+        @data = input.int
+        @ram.load_state(input)
         @watching = false
       end
 
@@ -86,7 +129,7 @@ module Badline
 
         addr &= 0x1fff
         if addr < 0x0800
-          touch(addr) if @watching
+          touch(addr) if @recording
           @ram.poke(addr, value)
         elsif addr >= 0x1c00
           @via2.poke(addr, value)
@@ -98,36 +141,69 @@ module Badline
 
       private
 
+      def watching!
+        @watching = @recording || @guarding
+      end
+
       def touch(addr)
         @touched[addr] = @ram.peek(addr) unless @touched.key?(addr)
       end
 
       def watch_read(addr)
         if addr < 0x0800
-          touch(addr)
+          touch(addr) if @recording
         elsif addr >= 0x1800
-          watch(addr < 0x1c00 ? VOLATILE_VIA1_READS : VOLATILE_VIA2_READS, addr)
+          via1 = addr < 0x1c00
+          watch(via1 ? VOLATILE_VIA1_READS : VOLATILE_VIA2_READS, addr) if @recording
+          guard_read(via1, addr & 0x0f) if @guarding
         end
       end
 
-      # Any write to VIA 1 makes the stretch volatile, and so does a write
-      # to VIA 2 that leaves the motor on.
       def watch_write(addr)
         if addr >= 0x1c00
-          watch(VOLATILE_VIA2_WRITES, addr)
-          volatile! if @watching && @via2.port_b_output.anybits?(Mechanism::MOTOR)
+          watch_via2_write(addr) if @recording
+          guard_via2_write(addr & 0x0f) if @guarding
         elsif addr >= 0x1800
-          volatile!
+          volatile! if @recording
+          taint! if @guarding
         end
       end
 
+      # Any write to VIA 1 makes the stretch volatile (watch_write), and so
+      # does a write to VIA 2 that leaves the motor on.
+      def watch_via2_write(addr)
+        watch(VOLATILE_VIA2_WRITES, addr)
+        volatile! if @recording && @via2.port_b_output.anybits?(Mechanism::MOTOR)
+      end
+
       def watch(volatile, addr)
         volatile! if volatile.anybits?(1 << (addr & 0x0f))
       end
 
       def volatile!
         @volatile = true
-        @watching = false
+        @recording = false
+        watching!
+      end
+
+      def guard_read(via1, offset)
+        return taint! if via1 && offset.zero?
+
+        @touched_timers |= via1 ? TIMER_REGISTERS[offset] : TIMER_REGISTERS[offset] << 2
+      end
+
+      def guard_via2_write(offset)
+        return taint! if offset.between?(0x0a, 0x0b)
+
+        @touched_timers |= TIMER_REGISTERS[offset] << 2
+        lines = @via2.port_b_output
+        taint! if lines.anybits?(Mechanism::MOTOR) || (lines & Mechanism::LED) != @led
+      end
+
+      def taint!
+        @tainted = true
+        @guarding = false
+        watching!
       end
     end
   end

data/lib/badline/drive1541/disk.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "badline/drive1541/sector_reader"
+require "badline/drive1541/disk_state"
 
 module Badline
   class Drive1541
@@ -16,6 +17,8 @@ module Badline
     # host file. The disk is write-protected when the image won't take
     # writes.
     class Disk
+      include State
+
       MAX_HALF_TRACK = 84
 
       # GCR bytes around a track in each speed zone: 200 ms of rotation at
@@ -52,9 +55,9 @@ module Badline
       # anything else as a .d64, formatted. `read_only` opens the image
       # write-protected.
       def self.open(path, read_only: false)
-        return from_g64(Storage::G64Image.new(path, read_only:)) if File.extname(path).casecmp?(".g64")
+        return from_g64(Storage::G64Image.new(path, read_only:)).opened(path, read_only) if State.g64?(path)
 
-        from_d64(Storage::D64Image.new(path, read_only:))
+        from_d64(Storage::D64Image.new(path, read_only:)).opened(path, read_only)
       end
 
       # A disk from a G64 image, each half track as the image stores it,
@@ -145,6 +148,8 @@ module Badline
         @image = image
         @tracks = Array.new(MAX_HALF_TRACK + 1)
         @written = {}
+        @path = nil
+        @read_only = false
       end
 
       # The Track at the half track, or nil where there's no data.

data/lib/badline/drive1541/disk_state.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1541
+    class Disk
+      # Saving and restoring a Disk for a snapshot: the image by its path,
+      # and every half track as the head sees it, with those written since
+      # the last flush. The image itself is read again from its host file.
+      module State
+        # The image's path, expanded, and whether it was opened read-only,
+        # for a disk from Disk.open. Nil for a disk made another way.
+        attr_reader :path, :read_only
+
+        # A .g64 image by its name, and anything else a .d64.
+        def self.g64?(path) = File.extname(path).casecmp?(".g64")
+
+        # A disk for the image at the path, its tracks left for the state.
+        def self.reopen(path, read_only)
+          if g64?(path)
+            Disk.new(Storage::G64Image.new(path, read_only:)).opened(path, read_only)
+          else
+            Disk.new(Storage::D64Image.new(path, read_only:)).opened(path, read_only)
+          end
+        end
+
+        # The disk a state from save_state describes: +current+ when it was
+        # opened from the same image the same way, and otherwise a disk for
+        # the image at the path the state names, or one without an image,
+        # as a detached reader always gets. Either way its tracks come from
+        # the state.
+        def self.load(input, current)
+          path = input.optional_string
+          read_only = input.boolean?
+          disk = current if current && !path.nil? && current.path == path && current.read_only == read_only
+          disk ||= path && !input.detached? ? reopen(path, read_only) : Disk.new
+          disk.load_tracks(input)
+          disk
+        end
+
+        # Notes the image's path and how it was opened.
+        def opened(path, read_only)
+          @path = File.expand_path(path)
+          @read_only = read_only
+          self
+        end
+
+        def save_state(out)
+          out.optional_string(@path).boolean(@read_only)
+          @tracks.each do |track|
+            out.boolean(!track.nil?)
+            save_track(track, out) if track
+          end
+          out.ints(@written.keys)
+        end
+
+        def load_tracks(input)
+          @tracks.each_index do |half_track|
+            @tracks[half_track] = input.boolean? ? load_track(input) : nil
+          end
+          @written.clear
+          input.ints.each { |half_track| @written[half_track] = true }
+        end
+
+        private
+
+        def save_track(track, out)
+          out.int(track.zone).boolean(!track.speeds.nil?)
+          out.ints(track.speeds) if track.speeds
+          out.blob(track.bytes)
+        end
+
+        def load_track(input)
+          zone = input.int
+          speeds = input.boolean? ? input.ints : nil
+          Track.new(input.blob, zone, speeds)
+        end
+      end
+    end
+  end
+end