badline 0.16.1 → 0.18.0

data/lib/badline/storage/disk_image/bam.rb

@@ -71,17 +71,32 @@ module Badline
         end
 
         # A chain's first block goes on the free track nearest the
-        # directory. Each block after it goes the interleave further round
-        # the same track, or on the next track out once that one is full.
+        # directory, from its sector 0. Each block after it looks from the
+        # interleave further round the track (#next_sector), on the same
+        # track or, once that one is full, from the same sector on the next
+        # track out.
         def next_block(track = nil, sector = nil)
           candidates = track ? [track, *tracks_after(track)] : allocation_order
+          start = track ? next_sector(track, sector) : 0
           candidates.each do |candidate|
-            free = free_sector(candidate, candidate == track ? sector + interleave : 0)
+            free = free_sector(candidate, start)
             return [candidate, free] if free
           end
           nil
         end
 
+        # The interleave on from the sector. Past the track's last sector
+        # it comes round again one short, but never below sector 0, as
+        # the 2031, 8050, 8250 and 1581 DOS do.
+        def next_sector(track, sector)
+          start = sector + interleave
+          count = sectors_in(track)
+          return start if start < count
+
+          start -= count
+          start.positive? ? start - 1 : start
+        end
+
         def free_sector(track, first)
           count = sectors_in(track)
           (0...count).map { |i| (first + i) % count }.find { |s| block_free?(track, s) }

data/lib/badline/storage/disk_image/formatting.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    class DiskImage
+      # The DOS's N command. With an ID it formats the disk: every block of
+      # the tracks the BAM covers is cleared, and the header, the BAM and an
+      # empty directory are written. Without one it only clears the disk:
+      # the header takes the new name and keeps its ID and whatever else it
+      # held, the BAM marks every block free, and the directory's first
+      # block is emptied. Either way the header, the BAM's blocks and the
+      # first directory block stay in use. Each format says where these go.
+      module Formatting
+        # The disk's ID, as the header holds it.
+        def disk_id = sector_at(*header_block)[header_name + Catalog::HEADER_ID, 2]
+
+        # Formats the disk under the name, or with no ID clears it.
+        def format(name, id = nil)
+          update_image do
+            full = !id.nil?
+            put_sector(*header_block, []) if full
+            id = (id || disk_id).first(2)
+            write_header(name, id)
+            clear_blocks if full
+            headers = bam_headers(id)
+            headers.each { |track, sector, bytes| write_at(track, sector, 0, bytes) }
+            put_sector(directory_track, directory_sector, [0, 0xff])
+            bam_tracks.each { |track| free_track(track) }
+            [header_block, *headers.map { |track, sector, _| [track, sector] }, [directory_track, directory_sector]]
+              .each { |block| mark(*block, false) }
+          end
+        end
+
+        private
+
+        # Every block the BAM covers but the header.
+        def clear_blocks
+          bam_tracks.each do |track|
+            (0...sectors_in(track)).each do |sector|
+              put_sector(track, sector, []) unless [track, sector] == header_block
+            end
+          end
+        end
+
+        # The link to the next block, the format's letter, the name, the ID
+        # and the DOS type, each field after the name set off with shifted
+        # spaces.
+        def write_header(name, id)
+          write_at(*header_block, 0, [*header_link, dos_type.getbyte(1), 0])
+          write_at(*header_block, header_name,
+                   encode_name(name) + [NAME_PADDING, NAME_PADDING] + id + [NAME_PADDING] +
+                   dos_type.bytes + Array.new(header_tail, NAME_PADDING))
+        end
+
+        # A free track counts its sectors and sets a bit for each.
+        def free_track(track)
+          count = sectors_in(track)
+          bits = (1 << count) - 1
+          @bytes[count_offset(track)] = count
+          bitmap_size.times { |i| @bytes[bitmap_offset(track) + i] = (bits >> (8 * i)) & 0xff }
+        end
+
+        def write_at(track, sector, offset, bytes)
+          @bytes[sector_offset(track, sector) + offset, bytes.length] = bytes
+        end
+      end
+    end
+  end
+end

data/lib/badline/storage/disk_image/writing.rb

@@ -51,6 +51,39 @@ module Badline
           files.length
         end
 
+        # Gives a file a new name in its directory entry. A missing file
+        # fails as FILE NOT FOUND, and a new name already on the disk as
+        # FILE EXISTS.
+        def rename(old_name, new_name)
+          entry = existing_entry(old_name)
+          raise WriteError, WriteError::FILE_EXISTS if entry_named(new_name)
+
+          update_image { @bytes[entry[:offset] + 5, Directory::NAME_LENGTH] = encode_name(new_name) }
+        end
+
+        # Writes a new file holding the files named, one after another, as
+        # the type of the first. A missing file fails as FILE NOT FOUND, and
+        # a new name already on the disk as FILE EXISTS.
+        def copy(new_name, names)
+          sources = names.map { |name| existing_entry(name) }
+          raise WriteError, WriteError::FILE_EXISTS if entry_named(new_name)
+
+          bytes = sources.flat_map { |entry| read_chain(entry[:track], entry[:sector]) }
+          update_image { add_file(new_name, bytes, sources.first[:type]) }
+        end
+
+        # Adds the files named to the end of a SEQ file. A missing file fails
+        # as FILE NOT FOUND, and a file of another type as FILE TYPE
+        # MISMATCH.
+        def concat(name, names)
+          entry = existing_entry(name)
+          sources = names.map { |source| existing_entry(source) }
+          raise WriteError, WriteError::FILE_TYPE_MISMATCH unless entry[:type] == :seq
+
+          bytes = [entry, *sources].flat_map { |source| read_chain(source[:track], source[:sector]) }
+          update_image { rewrite(entry, bytes, :seq) }
+        end
+
         # Raw block access for the DOS `U2` command. A block that the error
         # table marks bad reads cleanly once written.
         def write_block(track, sector, data)
@@ -81,6 +114,8 @@ module Badline
 
         private
 
+        def existing_entry(name) = entry_named(name) || raise(WriteError, WriteError::FILE_NOT_FOUND)
+
         def update_image
           raise WriteError, WriteError::WRITE_PROTECT_ON unless writable?
 
@@ -116,8 +151,8 @@ module Badline
         end
 
         def put_sector(track, sector, data)
-          block = data.first(SECTOR_SIZE)
-          @bytes[sector_offset(track, sector), SECTOR_SIZE] = block + Array.new(SECTOR_SIZE - block.length, 0)
+          offset = sector_offset(track, sector)
+          SECTOR_SIZE.times { |i| @bytes[offset + i] = data[i] || 0 }
           @errors[track_offset(track) + sector] = 1 if @errors
         end
       end

data/lib/badline/storage/disk_image.rb

@@ -3,6 +3,7 @@
 require "badline/storage/disk_image/bam"
 require "badline/storage/disk_image/catalog"
 require "badline/storage/disk_image/directory"
+require "badline/storage/disk_image/formatting"
 require "badline/storage/disk_image/writing"
 
 module Badline
@@ -15,6 +16,7 @@ module Badline
       include Bam
       include Catalog
       include Directory
+      include Formatting
       include Writing
 
       SECTOR_SIZE = 256

data/lib/badline/storage/kim_tape.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    # A KIM-1 cassette, held as the times its signal crosses zero, in
+    # microseconds from the start of the tape, which are the KIM-1's
+    # cycles. The KIM-1 writes the tape as a square wave on U2's PB7, each
+    # bit 3,700 Hz then 2,400 Hz, and reads it back through a 565 PLL and a
+    # 311 comparator, which hold PB7 high through the 2,400 Hz tone and low
+    # through the 3,700 Hz one (User Manual, appendix E). edges gives the
+    # times PB7 changes as the tape plays.
+    #
+    # A tape reads from a .wav file, 8-bit or 16-bit PCM, its first
+    # channel only, and writes one back as a square wave.
+    class KIMTape
+      class FormatError < StandardError; end
+
+      # A period longer than this many microseconds is the 2,400 Hz tone:
+      # the split between the tones, at the geometric mean of the two.
+      SPLIT = 336
+
+      # The time constants, in seconds, of the detector's DC level and of
+      # its envelope, which sets the hysteresis.
+      DC_TIME = 0.002
+      ENVELOPE_TIME = 0.005
+
+      # The signal crosses the DC level once it swings this fraction of the
+      # envelope past it, and not for an envelope smaller than SILENCE, of
+      # full scale.
+      HYSTERESIS = 0.3
+      SILENCE = 0.03
+
+      # A gap this many microseconds long between crossings plays as
+      # silence in the .wav a tape writes.
+      GAP = 2_000
+
+      # The file the tape reads from and writes back to, or "" for none.
+      attr_reader :path, :crossings
+
+      # The tape in the .wav file at `path`.
+      def self.read(path) = new(path, crossings: from_wav(File.binread(path).bytes))
+
+      # A blank tape at `path`, written to the host file.
+      def self.create(path)
+        tape = new(path)
+        tape.save
+        tape
+      end
+
+      # The zero crossings of the .wav file in `bytes`.
+      def self.from_wav(bytes)
+        raise FormatError, "Not a RIFF WAVE file" unless bytes[0, 4] == "RIFF".bytes && bytes[8, 4] == "WAVE".bytes
+
+        format = nil
+        pos = 12
+        while pos + 8 <= bytes.length
+          id = bytes[pos, 4].pack("C*")
+          size = little_endian(bytes, pos + 4, 4)
+          format = bytes[pos + 8, 16] if id == "fmt "
+          return Detector.new(Format.new(format)).crossings(bytes, pos + 8, size) if id == "data" && format
+
+          pos += 8 + size + (size & 1)
+        end
+        raise FormatError, "No PCM data in the WAVE file"
+      end
+
+      def self.little_endian(bytes, pos, count)
+        value = 0
+        count.times { |i| value |= bytes[pos + i].to_i << (8 * i) }
+        value
+      end
+
+      def initialize(path = "", crossings: [])
+        @path = path
+        @crossings = crossings
+      end
+
+      # The time of the last crossing.
+      def duration = @crossings.empty? ? 0 : @crossings.last
+
+      # Erases the tape from `time` on, as a deck recording from there
+      # does.
+      def erase_from(time)
+        @crossings.pop while !@crossings.empty? && @crossings.last >= time
+      end
+
+      # Records a crossing at `time`, after the last one.
+      def record(time)
+        @crossings << time
+      end
+
+      # The times PB7 changes as the tape plays, from high at its start: to
+      # low where a period is the 3,700 Hz tone and back to high where one
+      # is the 2,400 Hz tone. Each period runs over two crossings, and two
+      # in a row must agree before PB7 follows, so that one crossing out of
+      # place doesn't split a bit. The period that straddles the change
+      # lies between the tones, so PB7 changes half way through it.
+      def edges
+        crossings = @crossings
+        edges = []
+        high = true
+        disagree = 0
+        i = 2
+        while i < crossings.length
+          low_tone = crossings[i] - crossings[i - 2] > SPLIT
+          if low_tone == high
+            disagree = 0
+          else
+            disagree += 1
+            if disagree == 2
+              high = low_tone
+              edges << ((crossings[i - 3] + crossings[i - 2]) / 2)
+              disagree = 0
+            end
+          end
+          i += 1
+        end
+        edges
+      end
+
+      # Writes the tape back to its host file.
+      def save
+        write_wav(@path)
+      end
+
+      # Writes the tape to `path` as a .wav file, a square wave of `bits`
+      # (8 or 16) at `rate` samples a second.
+      def write_wav(path, rate: 44_100, bits: 8)
+        samples = square_wave(rate, bits == 8 ? 96 : 24_000)
+        bytes = bits == 8 ? samples.map { |sample| sample + 128 } : samples.flat_map { |s| [s & 0xff, (s >> 8) & 0xff] }
+        File.binwrite(path, (wav_header(rate, bits, bytes.length) + bytes).pack("C*"))
+      end
+
+      private
+
+      # The tape as samples of `amplitude`: silent up to the first
+      # crossing, after a GAP and at the end, and otherwise each crossing
+      # turning the wave over.
+      def square_wave(rate, amplitude)
+        samples = []
+        crossings = @crossings
+        count = crossings.empty? ? 0 : (((crossings.last + GAP) * rate) / 1_000_000) + 1
+        index = 0
+        level = -amplitude
+        count.times do |n|
+          time = (n * 1_000_000) / rate
+          while index < crossings.length && crossings[index] <= time
+            level = -level
+            index += 1
+          end
+          samples << (index.zero? || time - crossings[index - 1] > GAP ? 0 : level)
+        end
+        samples
+      end
+
+      def wav_header(rate, bits, size)
+        bytes_per_sample = bits / 8
+        "RIFF".bytes + le(36 + size, 4) + "WAVEfmt ".bytes + le(16, 4) + le(1, 2) + le(1, 2) +
+          le(rate, 4) + le(rate * bytes_per_sample, 4) + le(bytes_per_sample, 2) + le(bits, 2) +
+          "data".bytes + le(size, 4)
+      end
+
+      def le(value, count) = Array.new(count) { |i| (value >> (8 * i)) & 0xff }
+
+      # A WAVE file's fmt chunk: PCM, 8-bit unsigned or 16-bit signed.
+      class Format
+        attr_reader :channels, :rate, :bits
+
+        def initialize(chunk)
+          tag = KIMTape.little_endian(chunk, 0, 2)
+          @channels = KIMTape.little_endian(chunk, 2, 2)
+          @rate = KIMTape.little_endian(chunk, 4, 4)
+          @bits = KIMTape.little_endian(chunk, 14, 2)
+          return if [1, 0xfffe].include?(tag) && [8, 16].include?(@bits) && @channels.positive?
+
+          raise FormatError, "Only 8-bit and 16-bit PCM WAVE files are supported"
+        end
+
+        def frame_size = @channels * @bits / 8
+
+        # The first channel's sample at `pos`, from -1 to 1.
+        def level_at(bytes, pos)
+          return (bytes[pos] - 128) / 128.0 if @bits == 8
+
+          value = bytes[pos] | (bytes[pos + 1] << 8)
+          (value >= 0x8000 ? value - 0x10000 : value) / 32_768.0
+        end
+      end
+
+      # Finds where a recording crosses zero. A cassette's signal wanders
+      # off its centre and fades, so the detector follows its DC level and
+      # its envelope, and counts a crossing only once the signal swings past
+      # the DC level by HYSTERESIS of the envelope, timing it where it
+      # crossed the DC level, between two samples.
+      class Detector
+        def initialize(format)
+          @format = format
+          rate = format.rate
+          @dc_step = 1.0 / (rate * DC_TIME)
+          @decay = Math.exp(-1.0 / (rate * ENVELOPE_TIME))
+          @scale = 1_000_000.0 / rate
+          @dc = @envelope = @previous = @rose = @fell = 0.0
+          @high = false
+          @found = []
+        end
+
+        # The crossings, in microseconds, of the samples in `bytes` from
+        # `pos`, `size` bytes of them.
+        def crossings(bytes, pos, size)
+          format = @format
+          frame = format.frame_size
+          last = [pos + size, bytes.length].min - frame
+          n = 0
+          while pos <= last
+            follow(format.level_at(bytes, pos), n)
+            pos += frame
+            n += 1
+          end
+          @found
+        end
+
+        private
+
+        # Takes the sample `sample`, the `index`th.
+        def follow(sample, index)
+          @dc += (sample - @dc) * @dc_step
+          level = sample - @dc
+          @envelope *= @decay
+          @envelope = level.abs if level.abs > @envelope
+          previous = @previous
+          if previous <= 0 && level.positive?
+            @rose = index - 1 + (previous / (previous - level))
+          elsif previous >= 0 && level.negative?
+            @fell = index - 1 + (previous / (previous - level))
+          end
+          @previous = level
+          swing(level) if @envelope > SILENCE
+        end
+
+        # Turns over at a `level` far enough past the DC level.
+        def swing(level)
+          swing = @envelope * HYSTERESIS
+          if !@high && level > swing
+            @high = true
+            @found << (@rose * @scale).round
+          elsif @high && level < -swing
+            @high = false
+            @found << (@fell * @scale).round
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/storage/papertape.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    # A MOS papertape, the .ptp or .pap the KIM-1 monitor's Q command
+    # punches and its L command reads (User Manual, appendix F). Each
+    # record is a semicolon, then in hex its count of data bytes, its
+    # address, high byte first, the bytes and a 16-bit checksum, the sum
+    # of every byte before it, high byte first. The last record has a
+    # count of 0, the number of records before it where the address goes,
+    # and its checksum, which the monitor checks without counting the
+    # records. What comes between records, a line's end, NULs
+    # and the XOFF that ends a dump, the monitor skips, as this does.
+    class Papertape
+      class FormatError < StandardError; end
+
+      # One record's data: its bytes and where they go.
+      class Record
+        attr_reader :address, :bytes
+
+        def initialize(address, bytes)
+          @address = address
+          @bytes = bytes
+        end
+      end
+
+      HEX = "0123456789ABCDEFabcdef"
+
+      # The Records, in the tape's order.
+      attr_reader :records
+
+      # The tape's text from its start to the last record's end, which a
+      # teletype sends for the L command.
+      attr_reader :text
+
+      def self.read(path) = new(File.binread(path))
+
+      def initialize(text)
+        @records = []
+        @text = text.b
+        @position = 0
+        read_records
+      end
+
+      # Where the first record goes.
+      def start_address = @records.first.address
+
+      private
+
+      def read_records
+        loop do
+          start = @text.index(";", @position)
+          raise FormatError, "no last record" if start.nil?
+
+          @position = start + 1
+          count = byte
+          address = word
+          data = Array.new(count) { byte }
+          check(count, address, data)
+          return finish if count.zero?
+
+          @records << Record.new(address, data)
+        end
+      end
+
+      def check(count, address, data)
+        sum = (count + (address >> 8) + (address & 0xff) + data.sum) & 0xffff
+        raise FormatError, "bad checksum in the record at $#{address.to_s(16).rjust(4, '0')}" unless word == sum
+      end
+
+      def finish
+        raise FormatError, "no records" if @records.empty?
+
+        @text = @text[0, @position]
+      end
+
+      def byte
+        digits = @text[@position, 2].to_s
+        unless digits.size == 2 && HEX.include?(digits[0]) && HEX.include?(digits[1])
+          raise FormatError, "not a hex byte at offset #{@position}"
+        end
+
+        @position += 2
+        digits.to_i(16)
+      end
+
+      def word = (byte << 8) | byte
+    end
+  end
+end

data/lib/badline/storage.rb

@@ -5,13 +5,17 @@ require "badline/storage/p00"
 require "badline/storage/host_directory"
 require "badline/storage/disk_image"
 require "badline/storage/d64_image"
+require "badline/storage/d67_image"
 require "badline/storage/d71_image"
 require "badline/storage/d81_image"
 require "badline/storage/d80_image"
 require "badline/storage/d82_image"
+require "badline/storage/d90_image"
 require "badline/storage/g64_image"
 require "badline/storage/t64"
 require "badline/storage/tap"
+require "badline/storage/papertape"
+require "badline/storage/kim_tape"
 require "badline/storage/crt_file"
 require "badline/storage/unavailable"
 
@@ -24,6 +28,7 @@ module Badline
       WRITE_PROTECT_ON = 26
       FILE_NOT_FOUND = 62
       FILE_EXISTS = 63
+      FILE_TYPE_MISMATCH = 64
       DISK_FULL = 72
 
       attr_reader :code

data/lib/badline/support/cbm2_checkpoint.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Badline
+  module Support
+    # A Checkpoint of a CBM-II: its CPU with both segment registers, the
+    # 2K of segment 15's RAM, the RAM board's segments, the screen RAM, the
+    # picture, the CRTC's registers and counters, the CIA, the ACIA's
+    # registers and both TPIs.
+    module CBM2Checkpoint
+      COMPONENTS = %w[cpu ram segments screen display crtc cia acia tpi1 tpi2].freeze
+
+      def self.take(machine)
+        bus = machine.bus
+        Checkpoint.new(machine.cycles, [
+                         Checkpoint.fnv1a(Checkpoint.cpu_state(machine.cpu) +
+                                          [bus.execution_segment, bus.indirect_segment]),
+                         Checkpoint.fnv1a(Checkpoint.ram(bus.ram, 0x800)),
+                         Checkpoint.fnv1a(segments(bus)),
+                         Checkpoint.fnv1a(Array.new(0x800) { |offset| bus.screen.peek(0xd000 + offset) }),
+                         Checkpoint.fnv1a(machine.video.display),
+                         Checkpoint.fnv1a(crtc_state(machine.crtc)),
+                         Checkpoint.fnv1a(Checkpoint.cia_state(machine.cia)),
+                         Checkpoint.fnv1a(acia_state(machine.acia)),
+                         Checkpoint.fnv1a(tpi_state(machine.tpi1)),
+                         Checkpoint.fnv1a(tpi_state(machine.tpi2))
+                       ], COMPONENTS)
+      end
+
+      def self.parse(line) = Checkpoint.parse(line, COMPONENTS)
+
+      # Every byte of the segments the RAM board fills, segment by segment.
+      def self.segments(bus)
+        bytes = []
+        bus.segment_ram.each { |memory| bytes.concat(Checkpoint.ram(memory, 0x10000)) if memory }
+        bytes
+      end
+
+      def self.crtc_state(crtc) = crtc.registers + [crtc.column, crtc.line, crtc.row]
+
+      def self.acia_state(acia) = [acia.command, acia.control, acia.status]
+
+      def self.tpi_state(tpi)
+        [tpi.port_a_output, tpi.port_b_output, tpi.port_c_output, tpi.latches, tpi.mask, tpi.control,
+         tpi.irq? ? 1 : 0, *tpi.stack]
+      end
+    end
+  end
+end

data/lib/badline/support/kim1_checkpoint.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Badline
+  module Support
+    # A Checkpoint of a KIM-1: its CPU, the 1K of RAM, each 6530's RAM,
+    # ports and timer, the panel's held key and what its digits show, and
+    # what the teletype has printed and its line's level.
+    module KIM1Checkpoint
+      COMPONENTS = %w[cpu ram u2 u3 panel tty].freeze
+
+      def self.take(machine)
+        ram = machine.ram
+        Checkpoint.new(machine.cycles, [
+                         Checkpoint.fnv1a(Checkpoint.cpu_state(machine.cpu)),
+                         Checkpoint.fnv1a(Checkpoint.ram(ram, ram.length)),
+                         Checkpoint.fnv1a(rriot_state(machine.u2)),
+                         Checkpoint.fnv1a(rriot_state(machine.u3)),
+                         Checkpoint.fnv1a(panel_state(machine.panel)),
+                         Checkpoint.fnv1a(teletype_state(machine.teletype))
+                       ], COMPONENTS)
+      end
+
+      def self.parse(line) = Checkpoint.parse(line, COMPONENTS)
+
+      def self.rriot_state(rriot) = rriot.idle_state.map { |value| bit(value) } + [rriot.timer.counter]
+
+      def self.panel_state(panel)
+        held = panel.held
+        [held.nil? ? -1 : KIM1::Panel::KEYS.index(held), *panel.display]
+      end
+
+      def self.teletype_state(teletype) = teletype.output.bytes + [teletype.line_high? ? 1 : 0]
+
+      def self.bit(value)
+        return value if value.is_a?(Integer)
+
+        value ? 1 : 0
+      end
+    end
+  end
+end

data/lib/badline/support/p500_checkpoint.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Badline
+  module Support
+    # A Checkpoint of a P500: its CPU with both segment registers, the 2K
+    # of segment 15's RAM, segments 0 and 1, the static video matrix, the
+    # colour RAM's nibbles, the picture, the VIC's registers and beam, the
+    # SID's registers, the CIA, the ACIA's registers and both TPIs, the
+    # last three as CBM2Checkpoint digests them.
+    module P500Checkpoint
+      COMPONENTS = %w[cpu ram segments screen color_ram display vic sid cia acia tpi1 tpi2].freeze
+
+      def self.take(machine)
+        bus = machine.bus
+        Checkpoint.new(machine.cycles, [
+                         Checkpoint.fnv1a(Checkpoint.cpu_state(machine.cpu) +
+                                          [bus.execution_segment, bus.indirect_segment]),
+                         Checkpoint.fnv1a(Checkpoint.ram(bus.ram, 0x800)),
+                         Checkpoint.fnv1a(CBM2Checkpoint.segments(bus)),
+                         Checkpoint.fnv1a(Array.new(0x400) { |offset| bus.screen.peek(0xd000 + offset) }),
+                         Checkpoint.fnv1a(Checkpoint.color_ram(machine.color_ram, 0xd400)),
+                         Checkpoint.fnv1a(machine.vic.display),
+                         Checkpoint.fnv1a(Checkpoint.vic_state(machine.vic)),
+                         Checkpoint.fnv1a(Array.new(0x20) { |reg| machine.sid.register(reg) }),
+                         Checkpoint.fnv1a(Checkpoint.cia_state(machine.cia)),
+                         Checkpoint.fnv1a(CBM2Checkpoint.acia_state(machine.acia)),
+                         Checkpoint.fnv1a(CBM2Checkpoint.tpi_state(machine.tpi1)),
+                         Checkpoint.fnv1a(CBM2Checkpoint.tpi_state(machine.tpi2))
+                       ], COMPONENTS)
+      end
+
+      def self.parse(line) = Checkpoint.parse(line, COMPONENTS)
+    end
+  end
+end