badline 0.5.1 → 0.6.0

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

@@ -94,6 +94,19 @@ module Badline
         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
+
       def peek(addr)
         return @data = @rom.peek(addr | 0x4000) if addr >= 0x8000
 

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

data/lib/badline/drive1541/mechanism.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "badline/drive1541/rotation"
+require "badline/drive1541/mechanism_state"
 
 module Badline
   class Drive1541
@@ -65,6 +66,7 @@ module Badline
     # half track after it.
     class Mechanism
       include Rotation
+      include MechanismState
 
       MOTOR = 0x04
       LED = 0x08

data/lib/badline/drive1541/mechanism_state.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1541
+    # Saving and restoring the Mechanism for a snapshot.
+    module MechanismState
+      # The disk (Disk#save_state) and everything the head, the motor, the
+      # stepper and the read and write electronics hold, down to the cell
+      # under the head and the read clock's phase.
+      def save_state(out)
+        out.boolean(!@disk.nil?)
+        @disk&.save_state(out)
+        [@half_track, @slip, @zone, @clock, @time, @clock_at, @clocks, @shift, @ones, @bits, @write_shift,
+         @index, @mask, @cell_end, @width, @next].each { |value| out.int(value) }
+        [@motor, @led, @sync, @byte_ready, @writing, @write_gate, @protected, @track_written].each do |flag|
+          out.boolean(flag)
+        end
+        out.optional_int(@write_index)
+      end
+
+      # Puts the state back, reusing the disk in when it's the one the state
+      # names (Disk::State.load). A disk taken out is flushed, as insert
+      # does.
+      def load_state(input)
+        disk = input.boolean? ? Disk::State.load(input, @disk) : nil
+        flush unless disk.equal?(@disk)
+        @disk = disk
+        load_head(input)
+        load_flags(input)
+        @write_index = input.optional_int
+        head_on_track
+      end
+
+      private
+
+      def load_head(input)
+        @half_track = input.int
+        @slip = input.int
+        @zone = input.int
+        @clock = input.int
+        @time = input.int
+        @clock_at = input.int
+        @clocks = input.int
+        @shift = input.int
+        @ones = input.int
+        @bits = input.int
+        @write_shift = input.int
+        @index = input.int
+        @mask = input.int
+        @cell_end = input.int
+        @width = input.int
+        @next = input.int
+      end
+
+      def load_flags(input)
+        @motor = input.boolean?
+        @led = input.boolean?
+        @sync = input.boolean?
+        @byte_ready = input.boolean?
+        @writing = input.boolean?
+        @write_gate = input.boolean?
+        @protected = input.boolean?
+        @track_written = input.boolean?
+      end
+    end
+  end
+end

data/lib/badline/drive1541/rotation.rb

@@ -92,6 +92,16 @@ module Badline
         @writing ? write_bit(at) : read_bit(one)
       end
 
+      # The track under the head and its layout, leaving the head's place
+      # on it as it stands.
+      def head_on_track
+        @track = @disk&.track(@half_track) || BLANK
+        @bytes = @track.bytes
+        @widths = @track.widths
+        @length = @track.length
+        @last = @length - 1
+      end
+
       # The track under the head, from the cell that's under it +time+
       # into the turn.
       def load_track(time = @time)

data/lib/badline/drive1541/serial_port.rb

@@ -44,6 +44,16 @@ module Badline
         @host = @bus ? @bus.host_lines : 0
       end
 
+      # The C64's lines as last latched. The jumpers and the bus are the
+      # drive's wiring.
+      def save_state(out)
+        out.int(@host)
+      end
+
+      def load_state(input)
+        @host = input.int
+      end
+
       # Whether the C64 has moved ATN since the last latch_host.
       def atn_moved?
         lines = @bus ? @bus.host_lines : 0

data/lib/badline/drive1541.rb

@@ -180,6 +180,40 @@ module Badline
       step
     end
 
+    # The drive's whole state: its clock phase, the CPU, RAM, both VIAs,
+    # the serial port's latch of the C64's lines and the mechanism with its
+    # disk. The drive settles first, so it is awake and not recording a
+    # pass, and a restored drive starts the same way, its orbits forgotten
+    # from the state it takes: Idle's and Orbit's bookkeeping
+    # isn't stored. The device number, the host's clock rate and whether
+    # the drive may sleep are the machine's wiring.
+    def save_state(out)
+      settle!
+      out.marker("DRIVE1541")
+      out.int(@phase).int(@cycles).boolean(@so_pending)
+      @serial_port.save_state(out)
+      @via1.save_state(out)
+      @via2.save_state(out)
+      @bus.save_state(out)
+      @cpu.save_state(out)
+      @mechanism.save_state(out)
+    end
+
+    def load_state(input)
+      settle!
+      input.marker("DRIVE1541")
+      @phase = input.int
+      @cycles = input.int
+      @so_pending = input.boolean?
+      @serial_port.load_state(input)
+      @via1.load_state(input)
+      @via2.load_state(input)
+      @bus.load_state(input)
+      @cpu.load_state(input)
+      @mechanism.load_state(input)
+      forget_orbits
+    end
+
     def inspect
       "#<#{self.class.name} cycles=#{cycles} cpu=(#{cpu.inspect})>"
     end

data/lib/badline/gui/application.rb

@@ -6,6 +6,9 @@ module Badline
       TITLE = "Badline"
       TOGGLE_SYM = SDL::KEY_TAB
       MUTE_SYM = SDL::KEY_F10
+      SAVE_SYM = SDL::KEY_F11
+      RESTORE_SYM = SDL::KEY_F12
+      HOST_SYMS = [TOGGLE_SYM, MUTE_SYM, SAVE_SYM, RESTORE_SYM].freeze
       REVERSE_MOD = SDL::KMOD_SHIFT
 
       SHARED_KEYS = %i[cursor_up cursor_left cursor_h cursor_v space w a s d lshift].freeze
@@ -34,14 +37,12 @@ module Badline
       # options (autostart:, song:, disk:) go to Media.attach.
       def initialize(media_path: nil, machine: {}, sound: false, verbose: false, **media)
         @verbose = verbose
-        @computer = Computer.new(**machine_options(machine, media_path))
-        Media::TrueDrive.plug(@computer) if machine[:true_drive]
-        puts Media.attach(@computer, media_path, **media) if media_path
+        @snapshots = Snapshots.new
+        @computer = @snapshots.boot(media_path, machine, media)
 
         @mode = :keyboard
         @pot_device = nil
-        @panes = [ScreenPane.new(@computer)]
-        @panes << DriveLedPane.new(@computer.drive1541, @panes.first) if @computer.drive1541
+        @panes = panes
         @stream = open_stream if sound
         @paced = ENV["NOVSYNC"].nil?
         @window = Window.new(
@@ -94,8 +95,7 @@ module Badline
       end
 
       def handle_key_down(event)
-        return cycle_mode(event.mod.anybits?(REVERSE_MOD) ? -1 : 1) if event.sym == TOGGLE_SYM
-        return toggle_mute if event.sym == MUTE_SYM
+        return host_key(event) if HOST_SYMS.include?(event.sym)
 
         port, dir = JoyMap.parse(event) if @mode == :joystick
         if port
@@ -105,6 +105,16 @@ module Badline
         end
       end
 
+      # Tab, F10, F11 and F12 drive the front end, not the machine.
+      def host_key(event)
+        case event.sym
+        when TOGGLE_SYM then cycle_mode(event.mod.anybits?(REVERSE_MOD) ? -1 : 1)
+        when MUTE_SYM then toggle_mute
+        when SAVE_SYM then @snapshots.save(@computer) unless event.repeat
+        else restore_snapshot unless event.repeat
+        end
+      end
+
       # RESTORE isn't in the key matrix, so it goes to the machine instead,
       # once per press as the real key's one-shot fires.
       def press_key(key, repeat)
@@ -115,7 +125,7 @@ module Badline
       end
 
       def handle_key_up(event)
-        return if [TOGGLE_SYM, MUTE_SYM].include?(event.sym)
+        return if HOST_SYMS.include?(event.sym)
 
         port, dir = JoyMap.parse(event) if @mode == :joystick
         if port
@@ -155,6 +165,29 @@ module Badline
         update_title
       end
 
+      # Runs the restored machine in place of the one before: the screen,
+      # the drive LED, the gamepads and the sound go over to it. The input
+      # mode stays the host's, so a mouse or paddles go back in their port.
+      def restore_snapshot
+        computer = @snapshots.restore
+        return unless computer
+
+        release_inputs
+        @computer = computer
+        @panes = panes
+        @gamepads.computer = computer
+        @stream&.sid = computer.sid
+        attach_pot_device if POT_DEVICES.key?(@mode)
+      end
+
+      # The screen, and the drive LED in its border when a true drive is
+      # plugged in.
+      def panes
+        screen = ScreenPane.new(@computer)
+        drive = @computer.drive1541
+        drive ? [screen, DriveLedPane.new(drive, screen)] : [screen]
+      end
+
       def update_title
         tags = [MODES[@mode], @stream&.muted? && "MUTED"].select(&:itself)
         @window.title = [TITLE, *tags.map { |tag| "[#{tag}]" }].join(" ")
@@ -169,12 +202,6 @@ module Badline
         warn "badline: no sound, can't open the audio device: #{e.message}"
       end
 
-      def machine_options(machine, media_path)
-        options = { sid_model: machine[:sid_model] || Media.sid_model(media_path), **machine.slice(:reu) }
-        options[:region] = Region::NTSC if machine[:ntsc]
-        options
-      end
-
       def fit_frame
         rate = @window.refresh_rate
         clock_hz = @computer.region.clock_hz

data/lib/badline/gui/gamepads.rb

@@ -53,6 +53,13 @@ module Badline
                        .reject(&:null?)
       end
 
+      # Wires the controllers to another machine's joysticks, which take
+      # what they hold on the next poll.
+      def computer=(computer)
+        @computer = computer
+        @pressed.map! { [] }
+      end
+
       def poll
         @controllers.each_with_index { |controller, index| apply(controller, index) }
       end

data/lib/badline/gui/snapshots.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Badline
+  module GUI
+    # The window's snapshots: a .vsf opened as the media, F11 saving the
+    # machine to a new badline-<date>-<time>.vsf in the working directory,
+    # and F12 going back to the snapshot last saved or opened.
+    class Snapshots
+      def self.snapshot?(path) = !path.nil? && File.extname(path).casecmp?(".vsf")
+
+      def initialize
+        @last = nil
+      end
+
+      # The machine the window starts with: for a .vsf the machine it holds,
+      # built with that machine's chip models, which F12 goes back to, and
+      # otherwise one built from the machine options (Application.new) with
+      # the media attached.
+      def boot(media_path, machine, media)
+        return load(media_path) if Snapshots.snapshot?(media_path)
+
+        Computer.new(**machine_options(machine, media_path)).tap do |computer|
+          Media::TrueDrive.plug(computer) if machine[:true_drive]
+          puts Media.attach(computer, media_path, **media) if media_path
+        end
+      end
+
+      # A new machine, built as the snapshot's was and restored from it.
+      def load(path)
+        computer = Snapshot.load(path) { |line| puts line }
+        @last = path
+        puts "Restored #{path}"
+        computer
+      end
+
+      # Saves the machine, and warns when it can't.
+      def save(computer)
+        path = "badline-#{Time.now.strftime('%Y%m%d-%H%M%S')}.vsf"
+        computer.save_snapshot(path)
+        @last = path
+        puts "Saved #{path}, F12 restores it"
+      rescue Snapshot::FormatError, SystemCallError => e
+        warn "badline: #{path}: #{e.message}"
+      end
+
+      # A new machine restored from the snapshot last saved or opened, or
+      # nil when there is none or it fails, which it warns about.
+      def restore
+        return load(@last) if @last
+
+        puts "No snapshot to restore, F11 saves one"
+        nil
+      rescue Snapshot::FormatError, SystemCallError => e
+        warn "badline: #{@last}: #{e.message}"
+        nil
+      end
+
+      private
+
+      def machine_options(machine, media_path)
+        options = { sid_model: machine[:sid_model] || Media.sid_model(media_path), **machine.slice(:reu) }
+        options[:region] = Region::NTSC if machine[:ntsc]
+        options
+      end
+    end
+  end
+end

data/lib/badline/gui.rb

@@ -10,4 +10,5 @@ require "badline/gui/pane"
 require "badline/gui/screen_pane"
 require "badline/gui/drive_led_pane"
 require "badline/gui/window"
+require "badline/gui/snapshots"
 require "badline/gui/application"