badline 0.16.0 → 0.17.0

data/lib/badline/snapshot/vice/pet_drive.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    module Vice
+      module PET
+        # A true 2031 on device 8, as xpet 3.10, xcbm2 and xcbm5x0 save it with true drive
+        # emulation: DRIVE8 to DRIVE11 2.0, one a unit, DRIVECPU0 1.3, the
+        # drive's 6502 and its RAM, and its VIAs as VIA 2.2 modules,
+        # 2031VIA1D0 at $1800 on the IEEE-488 bus and VIA2D0 at $1C00 on
+        # the mechanism.
+        #
+        # DRIVECPU0 holds the clock, the registers, the last opcode, the
+        # main CPU's clock, more clocks of the drive's interrupt bookkeeping,
+        # then the 2K of RAM from $5C and twelve bytes after it. DRIVE8
+        # holds the head's half track at $10, with track 18 at 36 as badline
+        # numbers them, the speed zone its VIA set at $24, $47 and $4B, the
+        # drive's type as a word at $28, and from $2C the disk's place in
+        # its turn and the clock it was last moved on at. The rest of it,
+        # the read electronics among it, badline doesn't read. xpet's head
+        # rests on a half track two phases on from where badline's stepper
+        # puts it (SLIP).
+        #
+        # Written: the registers and the RAM, the VIAs as the PET's VIA is
+        # written with the stepper's phase moved to xpet's, and DRIVE8 as
+        # xpet saves an idle 2031 but for the head's half track, the zone,
+        # and the disk at the start of its turn as of the snapshot's clock.
+        # The interrupt clocks are written as long past. The snapshot is
+        # settled with the drive's CPU between instructions too
+        # (PET#settle_for_vice!). One taken while the drive is mid-transfer
+        # on the bus may stall there in xpet, as xpet's own snapshots taken
+        # while it searches for a file do.
+        #
+        # Read: the registers, the RAM, the VIAs as the PET's VIA is read,
+        # and the head's half track, with the motor, the LED and the zone
+        # from VIA 2's port B and the stepper's phase as xpet's (SLIP). The
+        # disk turns on from where badline's left it, and the disk in the
+        # drive stays.
+        module Drive2031
+          UNITS = %w[DRIVE8 DRIVE9 DRIVE10 DRIVE11].freeze
+          DRIVE_MAJOR = 2
+          DRIVE_MINOR = 0
+          CPU = "DRIVECPU0"
+          CPU_MAJOR = 1
+          CPU_MINOR = 3
+          VIA1 = "2031VIA1D0"
+          VIA2 = "VIA2D0"
+          NAMES = [*UNITS, CPU, VIA1, VIA2].freeze
+          # Where DRIVECPU0's RAM starts, and its length.
+          RAM_AT = 0x5c
+          RAM_SIZE = 0x800
+          TAIL = 12
+          HALF_TRACK = 0x10
+          ZONES = [0x24, 0x47, 0x4b].freeze
+          SIZE = 145
+          # The disk's place in its turn, and the clock it was last moved on at.
+          TURN = 0x2c
+          # DRIVE8 as xpet saves an idle 2031, and a unit with no drive, by
+          # the bytes that aren't 0.
+          IDLE = { 0x00 => 0x01, 0x01 => 0x01, 0x02 => 0x01, 0x0f => 0x01, 0x10 => 0x25, 0x1a => 0x01, 0x1b => 0xdf,
+                   0x1f => 0x54, 0x20 => 0x55, 0x24 => 0x03, 0x28 => 0xef, 0x29 => 0x07, 0x2c => 0x60, 0x2d => 0x41,
+                   0x2e => 0x0f, 0x30 => 0x17, 0x31 => 0x51, 0x32 => 0x0f, 0x40 => 0x54, 0x41 => 0x01, 0x42 => 0x54,
+                   0x47 => 0x03, 0x4b => 0x03, 0x6f => 0xcd, 0x70 => 0xab, 0x71 => 0x34, 0x72 => 0x12 }.freeze
+          NONE = { 0x00 => 0x01, 0x01 => 0x01, 0x02 => 0x01, 0x0e => 0x01, 0x0f => 0x01, 0x10 => 0x24, 0x1a => 0x01,
+                   0x20 => 0x55, 0x6f => 0xcd, 0x70 => 0xab, 0x71 => 0x34, 0x72 => 0x12, 0x8f => 0x01 }.freeze
+          SLIP = 2
+          MOTOR = 0x04
+          LED = 0x08
+
+          module_function
+
+          # Whether the snapshot has a true 2031.
+          def present?(container) = !container[CPU].nil? && !container[VIA1].nil?
+
+          def reads?(section)
+            case section.name
+            when CPU then section.major == CPU_MAJOR && section.minor == CPU_MINOR
+            when VIA1, VIA2 then VIA.reads?(section)
+            else section.major == DRIVE_MAJOR && section.minor == DRIVE_MINOR
+            end
+          end
+
+          # xpet's modules for the 2031 whose BL-D8 modules `readers` holds,
+          # and none without one or for an 8050 or 8250, which they leave
+          # out.
+          def export(machine, readers)
+            drive = readers["BL-D8"]
+            return [] if drive.nil? || drive.text("model", "2031") != "2031"
+
+            via2 = readers.fetch("BL-D8-VIA2")
+            mechanism = readers.fetch("BL-D8-MECH")
+            zone = ((via2.int("orb", 0) | ~via2.int("ddrb", 0)) >> 5) & 0x03
+            idle = filled(IDLE)
+            idle[HALF_TRACK] = mechanism.int("half_track", 36)
+            ZONES.each { |offset| idle[offset] = zone }
+            idle[TURN, 8] = [0, machine.cycles & 0xffff_ffff].pack("VV").bytes
+            [FieldWriter.new.bytes(idle).section(UNITS.first, DRIVE_MAJOR, DRIVE_MINOR),
+             *UNITS.drop(1).map { |name| unit(NONE, name) },
+             cpu(machine, readers.fetch("BL-D8-CPU"), readers.fetch("BL-D8-RAM")),
+             stepper(VIA.export(via2, VIA2), mechanism.int("slip", 0)),
+             VIA.export(readers.fetch("BL-D8-VIA1"), VIA1)]
+          end
+
+          # VIA 2's port B with the stepper's phase as xpet's head takes it
+          # where badline's head is: SLIP on from badline's.
+          def stepper(section, slip)
+            bytes = section.data.bytes
+            bytes[2] = (bytes[2] & 0xfc) | ((bytes[2] - slip + SLIP) & 0x03)
+            section.with(data: bytes.pack("C*"))
+          end
+
+          def unit(bytes, name) = FieldWriter.new.bytes(filled(bytes)).section(name, DRIVE_MAJOR, DRIVE_MINOR)
+
+          def filled(bytes) = Array.new(SIZE) { |offset| bytes.fetch(offset, 0) }
+
+          def cpu(machine, input, ram)
+            bytes = ram.bytes("ram", "".b).bytes
+            cpu_section(machine, input, Array.new(RAM_SIZE) { |address| bytes[address] || 0 })
+          end
+
+          # The drive's clock, at its 1 MHz, for the machine's at its own.
+          def drive_clock(machine) = machine.cycles * Drives::Model2031::CLOCK_HZ / machine.timing.clock_hz
+
+          # DRIVECPU0 for a drive CPU whose BL- fields `input` holds, with
+          # `ram` the drive's RAM as xpet lays it out: the drive's clock,
+          # the registers, the machine's clock, the drive's clock again, and
+          # the RAM.
+          def cpu_section(machine, input, ram)
+            clock = drive_clock(machine)
+            fields = FieldWriter.new.qword(clock)
+            %w[a x y sp].each { |key| fields.byte(input.int(key, 0)) }
+            fields.word(input.int("pc", 0)).byte(input.int("p", 0x20)).dword(0)
+            fields.qword(machine.cycles).zeros(16).qword(clock).zeros(1).qword(0).zeros(8).qword(0)
+            fields.zeros(16).bytes(ram).zeros(TAIL)
+            fields.section(CPU, CPU_MAJOR, CPU_MINOR)
+          end
+
+          # The 2031's keyed modules, named for device 8, from the
+          # snapshot's, with `disk` the drive's disk module badline keeps,
+          # or nil.
+          def import(container, disk)
+            via2 = container[VIA2]
+            sections = [Keyed.section("BL-D8") { |out| drive(container, out) },
+                        Keyed.section("BL-D8-RAM") { |out| out.bytes("ram", ram(container[CPU])) },
+                        Keyed.section("BL-D8-VIA1") { |out| VIA.import(container[VIA1], out) },
+                        Keyed.section("BL-D8-VIA2") { |out| VIA.import(via2, out) },
+                        Keyed.section("BL-D8-CPU") { |out| registers(container[CPU], out) },
+                        Keyed.section("BL-D8-MECH") { |out| mechanism(container, via2, out) }]
+            disk ? sections + [disk] : sections
+          end
+
+          def drive(container, out)
+            out.text("model", "2031").int("phase", 0).int("cycles", FieldReader.new(container[CPU]).qword)
+            out.bool("so_pending", false)
+          end
+
+          def ram(section) = FieldReader.new(section).skip(RAM_AT).string(RAM_SIZE)
+
+          def registers(section, out)
+            fields = FieldReader.new(section)
+            clock = fields.qword
+            out.int("a", fields.byte).int("x", fields.byte).int("y", fields.byte).int("sp", fields.byte)
+            out.int("pc", fields.word).int("p", fields.byte).int("cycles", clock)
+          end
+
+          # The head where DRIVE8 has it, and the stepper's phase as VIA 2
+          # drives it, which the half track's low two bits stand for.
+          def mechanism(container, via2, out)
+            half_track = FieldReader.new(container[UNITS.first]).skip(HALF_TRACK).byte
+            bytes = FieldReader.new(via2).bytes(4)
+            port_b = bytes[2] | (~bytes[3] & 0xff)
+            out.int("half_track", half_track).int("slip", SLIP)
+            out.int("zone", (port_b >> 5) & 0x03)
+            out.bool("motor", port_b.anybits?(MOTOR)).bool("led", port_b.anybits?(LED))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/snapshot/vice/pet_drive8050.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    module Vice
+      module PET
+        # A true 8050 or 8250 on device 8, as xpet 3.10, xcbm2 and xcbm5x0 save it with true
+        # drive emulation: DRIVE8 2.0 with both drives, DRIVE9 to DRIVE11
+        # with none, DRIVECPU0 1.3, the interface processor and its RAM,
+        # RIOT1D0 and RIOT2D0 0.0, its two 6532s, and FDC0 0.0. xpet runs
+        # the floppy controller at a high level, so its 6504, VIA and 6530
+        # aren't in the snapshot: FDC0 holds the controller's state, its
+        # last track in byte 6.
+        #
+        # DRIVE8 holds a block of 139 bytes for each drive, then 6 for the
+        # unit: each block has its head's half track, twice the track, at
+        # $10 and the drive's type as a word at $28 (8050 or 8250).
+        # DRIVECPU0 is laid out as the 2031's (Drive2031), its RAM the IP's
+        # page 0, the 6532s' 128 bytes each, then the 4K of common RAM.
+        # A RIOT module holds port A's output and direction registers, port
+        # B's, the edge control (bit 0 the PA7 interrupt, bit 1 a rising
+        # edge), the flags (bit 7 the timer's interrupt, which xpet raises
+        # IRQ for, bit 6 PA7's), the timer's
+        # counter, its divider as a word, two bytes xpet leaves 0, and
+        # whether the timer interrupts.
+        #
+        # Written, once the controller is in its idle loop between
+        # instructions (PET#settle_for_vice!): the IP's registers and RAM,
+        # the 6532s, the heads' tracks, and FDC0 as xpet leaves an idle
+        # controller with the track badline's controller last stepped to.
+        # A unit whose controller is still busy is left out of xpet's
+        # modules. Read: the IP's registers and RAM and the 6532s, with the
+        # controller as a unit switched on has it in its idle loop, its
+        # heads on track 1, from where its next job steps them. A job under
+        # way in xpet's controller starts again from there. The disks in
+        # the drives stay.
+        module Drive8050
+          UNIT = "DRIVE8"
+          CPU = Drive2031::CPU
+          RIOTS = %w[RIOT1D0 RIOT2D0].freeze
+          FDC = "FDC0"
+          NAMES = [UNIT, CPU, *RIOTS, FDC].freeze
+          TYPES = { 0x1f72 => "8050", 0x203a => "8250" }.freeze
+          # Where each drive's block starts in DRIVE8, and its fields.
+          DRIVES = [0x00, 0x8b].freeze
+          HALF_TRACK = 0x10
+          TYPE = 0x28
+          SIZE = 284
+          # DRIVE8 as xpet saves an idle 8050, by the bytes that aren't 0,
+          # but for the type.
+          IDLE = { 0x00 => 0x01, 0x01 => 0x02, 0x02 => 0x01, 0x0e => 0x01, 0x0f => 0x01, 0x10 => 0x4c, 0x1a => 0x01,
+                   0x20 => 0x55, 0x30 => 0x06, 0x6f => 0xcd, 0x70 => 0xab, 0x71 => 0x34, 0x72 => 0x12, 0x99 => 0x01,
+                   0x9a => 0x01, 0x9b => 0x24, 0xa5 => 0x01, 0xab => 0x55, 0x11a => 0x01 }.freeze
+          ZERO_PAGE = 0x80
+          COMMON = 0x1000
+          # FDC0 as xpet leaves an idle controller, and where the track goes.
+          FDC_IDLE = [0x04, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00].freeze
+          FDC_TRACK = 6
+          # Where badline's controller keeps drive 0's track, in the 6530's
+          # RAM.
+          TRACK_AT = 0x21
+          DIVIDERS = [1, 8, 64, 1024].freeze
+          IRQ_EDGE = 0x01
+          RISING = 0x02
+          TIMER_FLAG = 0x80
+          PA7_FLAG = 0x40
+
+          module_function
+
+          # Whether the snapshot has a true 8050 or 8250.
+          def present?(container) = !container[FDC].nil? && !container[CPU].nil?
+
+          def reads?(section)
+            case section.name
+            when CPU then Drive2031.reads?(section)
+            when UNIT then section.major == Drive2031::DRIVE_MAJOR && section.minor == Drive2031::DRIVE_MINOR
+            else section.major.zero? && section.minor.zero?
+            end
+          end
+
+          # The model DRIVE8 names, or nil.
+          def model(container)
+            unit = container[UNIT]
+            return nil if unit.nil? || unit.data.bytesize < SIZE
+
+            TYPES[FieldReader.new(unit).skip(TYPE).word]
+          end
+
+          # xpet's modules for the 8050 or 8250 whose BL-D8 modules `readers`
+          # holds, and none without one, or with its controller away from
+          # its idle loop.
+          def export(machine, readers)
+            drive = readers["BL-D8"]
+            model = drive&.text("model", "")
+            return [] unless TYPES.value?(model) && idle?(readers)
+
+            [unit(model, readers.fetch("BL-D8-MECH")), *Drive2031::UNITS.drop(1).map { |name| none(name) },
+             Drive2031.cpu_section(machine, readers.fetch("BL-D8-IPCPU"), ram(readers)),
+             riot(RIOTS[0], readers.fetch("BL-D8-RIOT1")), riot(RIOTS[1], readers.fetch("BL-D8-RIOT2")),
+             fdc(readers.fetch("BL-D8-RRIOT"))]
+          end
+
+          # Whether both processors are between instructions, the
+          # controller at the start of its idle loop.
+          def idle?(readers)
+            fdc = readers.fetch("BL-D8-FDCCPU")
+            !position?(fdc) && !position?(readers.fetch("BL-D8-IPCPU")) &&
+              fdc.int("pc", 0) == Drives::Model8050::Idle::FDC_LOOP
+          end
+
+          def position?(cpu) = !cpu.text("pos.seq", "").empty?
+
+          def unit(model, mechanism)
+            bytes = Array.new(SIZE) { |offset| IDLE.fetch(offset, 0) }
+            cylinders = mechanism.ints("cylinders", [0, 0])
+            DRIVES.each_with_index do |at, drive|
+              bytes[at + HALF_TRACK] = ((cylinders[drive] || 0) + 1) * 2
+              bytes[at + TYPE, 2] = [TYPES.key(model)].pack("v").bytes
+            end
+            FieldWriter.new.bytes(bytes).section(UNIT, Drive2031::DRIVE_MAJOR, Drive2031::DRIVE_MINOR)
+          end
+
+          def none(name) = Drive2031.unit(Drive2031::NONE, name)
+
+          # The IP's RAM as xpet lays it out: page 0 from both 6532s, then
+          # the common RAM.
+          def ram(readers)
+            [readers.fetch("BL-D8-RIOT1"), readers.fetch("BL-D8-RIOT2")].flat_map do |riot|
+              filled(riot.bytes("ram", "".b).bytes, ZERO_PAGE)
+            end + filled(readers.fetch("BL-D8-COMMON").bytes("ram", "".b).bytes, COMMON)
+          end
+
+          def filled(bytes, length) = Array.new(length) { |index| bytes[index] || 0 }
+
+          def riot(name, input)
+            edge = input.bool("edge_irq_enabled", false) ? IRQ_EDGE : 0
+            edge |= RISING if input.bool("rising_edge", false)
+            timer = input.bool("timer.flag", false) && input.bool("timer.irq_enabled", false)
+            flags = (timer ? TIMER_FLAG : 0) | (input.bool("pa7_flag", false) ? PA7_FLAG : 0)
+            divider = DIVIDERS.fetch(input.int("timer.interval", 0) & 0x03)
+            fields = FieldWriter.new.byte(input.int("ora", 0)).byte(input.int("ddra", 0)).byte(input.int("orb", 0))
+            fields.byte(input.int("ddrb", 0)).byte(edge).byte(flags).byte(input.int("timer.counter", 0)).word(divider)
+            fields.zeros(2).flag(input.bool("timer.irq_enabled", false)).section(name, 0, 0)
+          end
+
+          def fdc(rriot)
+            bytes = FDC_IDLE.dup
+            bytes[FDC_TRACK] = rriot.bytes("ram", "".b).getbyte(TRACK_AT).to_i
+            FieldWriter.new.bytes(bytes).section(FDC, 0, 0)
+          end
+
+          # The unit's keyed modules, named for device 8, from the
+          # snapshot's: the IP's side from xpet's, the controller's side
+          # from `reference`, a unit's in its idle loop, and `disks`, the
+          # drives' disk modules badline keeps.
+          def import(container, reference, disks)
+            cpu = container[CPU]
+            page = FieldReader.new(cpu).skip(Drive2031::RAM_AT).string(ZERO_PAGE * 2)
+            common = FieldReader.new(cpu).skip(Drive2031::RAM_AT + (ZERO_PAGE * 2)).string(COMMON)
+            sections = [Keyed.section("BL-D8") { |out| unit_fields(container, reference, out) },
+                        Keyed.section("BL-D8-COMMON") { |out| out.bytes("ram", common) },
+                        riot_section("BL-D8-RIOT1", container[RIOTS[0]], page.byteslice(0, ZERO_PAGE)),
+                        riot_section("BL-D8-RIOT2", container[RIOTS[1]], page.byteslice(ZERO_PAGE, ZERO_PAGE)),
+                        Keyed.section("BL-D8-IPCPU") { |out| Drive2031.registers(cpu, out) }]
+            sections + reference.select { |section| CONTROLLER.include?(section.name) } + disks
+          end
+
+          # The controller's side, which comes from a unit in its idle loop.
+          CONTROLLER = %w[BL-D8-FDCCPU BL-D8-VIA BL-D8-RRIOT BL-D8-MECH].freeze
+
+          def unit_fields(container, reference, out)
+            own = Keyed::Reader.parse(reference.find { |section| section.name == "BL-D8" })
+            out.text("model", own.text("model", "8050")).int("phase", 0)
+            out.int("cycles", FieldReader.new(container[CPU]).qword).int("fdc_data", own.int("fdc_data", 0))
+          end
+
+          def riot_section(name, section, ram)
+            fields = FieldReader.new(section)
+            ora, ddra, orb, ddrb, edge, flags, counter = fields.bytes(7)
+            divider = fields.word
+            fields.skip(2)
+            irq = fields.flag?
+            Keyed.section(name) do |out|
+              out.bytes("ram", ram).int("ora", ora).int("ddra", ddra).int("orb", orb).int("ddrb", ddrb)
+              out.bool("edge_irq_enabled", edge.anybits?(IRQ_EDGE)).bool("rising_edge", edge.anybits?(RISING))
+              out.bool("pa7_flag", flags.anybits?(PA7_FLAG)).int("timer.counter", counter)
+              out.int("timer.interval", DIVIDERS.index(divider) || 0).int("timer.prescale", [divider, 1].max)
+              out.bool("timer.flag", flags.anybits?(TIMER_FLAG)).bool("timer.expired", flags.anybits?(TIMER_FLAG))
+              out.bool("timer.irq_enabled", irq)
+            end
+          end
+
+          # A unit of `model` switched on and run into its controller's idle
+          # loop, both processors between instructions, as keyed modules
+          # named for device 8, run once a model.
+          def reference(model)
+            @references ||= {}
+            @references[model] ||= booted(model)
+          end
+
+          def booted(model)
+            unit = model == "8250" ? Drives::Model8250.new : Drives::Model8050.new
+            Drives::Model8050::BOOT_CYCLES.times { unit.host_cycle! }
+            unit.cycle! until idle_loop?(unit)
+            unit.save_modules([], "BL-D8")
+          end
+
+          def idle_loop?(unit)
+            cpu = unit.fdc_cpu
+            unit.ip_cpu.boundary? && cpu.boundary? && cpu.program_counter == Drives::Model8050::Idle::FDC_LOOP
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/snapshot/vice/pet_mem.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    module Vice
+      module PET
+        # PETMEM 1.3: the board, the RAM below $8000 in K and the 8096's
+        # control register at $FFF0, then the RAM, the screen RAM, 1K or 2K
+        # as the board has, or on the 8296 its 32K from $8000, an 8096's or
+        # 8296's 64K board, and 24 bytes of xpet's own settings, which name
+        # the 2001.
+        #
+        # The board is 0 for the discrete video, 1 for a 40-column CRTC, 2
+        # for an 80-column one, 3 for the SuperPET, 4 for the 8096 and 5 for
+        # the 8296. xpet's ROMs aren't in the snapshot.
+        module PETMem
+          NAME = "PETMEM"
+          MAJOR = 1
+          MINOR = 3
+          DISCRETE = 0
+          CRTC40 = 1
+          CRTC80 = 2
+          SUPERPET = 3
+          CBM8096 = 4
+          CBM8296 = 5
+          # The byte after the header's control register, as xpet writes it.
+          HEADER_END = 0x05
+          # xpet's settings at the end, but for the second byte, which is
+          # SETTINGS_2001 on a 2001.
+          SETTINGS = [0x00, 0x00, 0x00, 0x00, 0xd6, 0x01, 0x00, 0x20, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x00,
+                      0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00].freeze
+          SETTINGS_2001 = 0x03
+          EXPANSION = 0x10000
+
+          module_function
+
+          def reads?(section) = section.major == MAJOR && section.minor == MINOR
+
+          def board(model)
+            return CBM8296 if model.cbm8296?
+            return CBM8096 if model.expansion
+
+            case model.video
+            when :crtc40 then CRTC40
+            when :crtc80 then CRTC80
+            else DISCRETE
+            end
+          end
+
+          def export(machine)
+            bus = machine.bus
+            expansion = bus.expansion
+            fields = FieldWriter.new.byte(board(machine.model)).byte(0).byte(machine.ram_kb)
+            fields.byte(expansion ? expansion.control : 0).byte(HEADER_END)
+            fields.bytes(machine.ram.snapshot).bytes(bus.screen.cells)
+            fields.bytes(expansion.cells) if expansion
+            settings = SETTINGS.dup
+            settings[1] = SETTINGS_2001 if machine.model.basic1?
+            fields.bytes(settings).section(NAME, MAJOR, MINOR)
+          end
+
+          # The board's number in the header.
+          def board_of(section) = FieldReader.new(section).byte
+
+          def ram_kb(section) = FieldReader.new(section).skip(2).byte
+
+          # Whether xpet's settings at the end name a 2001.
+          def pet2001?(section)
+            data = section.data
+            data.bytesize >= SETTINGS.length && data.getbyte(data.bytesize - SETTINGS.length + 1).to_i.anybits?(0x01)
+          end
+
+          # The RAM, the screen RAM and an 8096's or 8296's board and control
+          # register
+          # by their BL-RAM keys, in a keyed module's writer, for a machine
+          # with `screen_bytes` of screen RAM.
+          def import(section, out, screen_bytes)
+            fields = FieldReader.new(section)
+            board = fields.byte
+            fields.skip(1)
+            ram_kb = fields.byte
+            control = fields.byte
+            fields.skip(1)
+            out.bytes("ram", fields.string(ram_kb * 1024)).bytes("screen", fields.string(screen_bytes))
+            return unless [CBM8096, CBM8296].include?(board)
+
+            out.int("expansion.control", control).bytes("expansion.ram", fields.string(EXPANSION))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/snapshot/vice/pet_pias.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    module Vice
+      module PET
+        # PIA1 and PIA2 1.0: port A's output and direction registers and
+        # its control register as read, with the CA1 and CA2 flags in bits 7
+        # and 6, the same for port B, and the levels on CA2 and CB2 in bits
+        # 7 and 6 of the last byte, high while a line is an input.
+        #
+        # Read: each side's flags come from its control register, and a
+        # handshake under way from the level its C2 output is at. The levels
+        # outside on CA1 and CB1 aren't saved: they stay as the machine has
+        # them, with PIA 1's CB1 on the vertical drive line.
+        module PIAs
+          NAMES = %w[PIA1 PIA2].freeze
+          MAJOR = 1
+          MINOR = 0
+          CA2_HIGH = 0x80
+          CB2_HIGH = 0x40
+          HANDSHAKE = 0x20
+
+          module_function
+
+          def reads?(section) = section.major == MAJOR && section.minor == MINOR
+
+          # The PIA's module, from its BL-PIA1 or BL-PIA2 fields in `input`.
+          def export(name, pia, input)
+            fields = FieldWriter.new.byte(input.int("ora", 0)).byte(input.int("ddra", 0)).byte(pia.cra)
+            fields.byte(input.int("orb", 0)).byte(input.int("ddrb", 0)).byte(pia.crb)
+            fields.byte((pia.ca2_output ? CA2_HIGH : 0) | (pia.cb2_output ? CB2_HIGH : 0))
+            fields.section(name, MAJOR, MINOR)
+          end
+
+          # The registers and the control lines by their BL-PIA keys, in a
+          # keyed module's writer.
+          def import(section, out)
+            ora, ddra, cra, orb, ddrb, crb, lines = FieldReader.new(section).bytes(7)
+            out.int("ora", ora).int("ddra", ddra).int("orb", orb).int("ddrb", ddrb)
+            control_lines(out, "ca.", cra, lines.anybits?(CA2_HIGH))
+            control_lines(out, "cb.", crb, lines.anybits?(CB2_HIGH))
+          end
+
+          def control_lines(out, prefix, register, c2_high)
+            control = register & 0x3f
+            out.int("#{prefix}control", control).bool("#{prefix}c1_flag", register.anybits?(0x80))
+            out.bool("#{prefix}c2_flag", register.anybits?(0x40)).int("#{prefix}pulse", 0)
+            out.bool("#{prefix}handshake_low", control & 0x38 == HANDSHAKE && !c2_high)
+            out.bool("#{prefix}c2_high", c2_high) if control.nobits?(0x20)
+          end
+        end
+      end
+    end
+  end
+end