badline 0.15.1 → 0.16.0

data/lib/badline/pet.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require "badline/pet/rom_sets"
+require "badline/pet/model"
+require "badline/pet/cpu"
+require "badline/pet/via"
+require "badline/pet/via_ports"
+require "badline/pet/keyboard_ports"
+require "badline/pet/ieee_ports"
+require "badline/pet/ieee_traps"
+require "badline/pet/cassettes"
+require "badline/pet/characters"
+require "badline/pet/canvas"
+require "badline/pet/discrete_video"
+require "badline/pet/crtc_video"
+require "badline/pet/bus"
+require "badline/pet/sound"
+require "badline/snapshot/pet_setup"
+require "badline/pet/keyed_parts"
+require "badline/pet/keyed_state"
+require "badline/pet/keyed_modules"
+
+module Badline
+  # The Commodore PET and CBM: a 6502 at 1 MHz, two 6520 PIAs at $E810 and
+  # $E820, a 6522 VIA at $E840 and, from the 4032 on, a 6545 CRTC at
+  # $E880. Every chip's IRQ is wired to the CPU's, and nothing pulls NMI.
+  # Nothing halts the CPU either: the video reads the screen RAM between
+  # its accesses.
+  #
+  # The video's vertical drive line, low in the retrace, reaches PIA 1's
+  # CB1, whose falling edge is the editor's 50 or 60 Hz interrupt, and the
+  # VIA's PB5. The discrete boards count it out themselves
+  # (DiscreteVideo), and the CRTC boards take it from the CRTC's vertical
+  # sync, inverted.
+  #
+  # The key matrix hangs off PIA 1 (KeyboardPorts), the graphics one or
+  # the business one as the model has, and type_text types through the
+  # editor's keyboard buffer.
+  #
+  # The discrete boards paint their picture (DiscreteVideo) on a Canvas.
+  # The CRTC boards paint theirs from the CRTC's outputs (CRTCVideo).
+  # The VIA's CB2 is the sound (Sound).
+  #
+  # Device 8 answers through traps on the KERNAL's IEEE-488 primitives
+  # (IEEETraps), on a bus nothing else is plugged into (IEEEPorts), and
+  # each cassette port has a datasette (Cassettes). It runs headless.
+  class PET
+    include Machine::KeyboardBuffer
+    include Machine::Clocking
+    include Machine::Settling
+    include IEEETraps
+
+    attr_reader :model, :bus, :cpu, :pia1, :pia2, :via, :crtc, :keyboard, :ieee, :cassettes, :cycles, :init_threshold
+
+    # The editor's frame rate: 50 or 60 on a CRTC board, 60 on the others.
+    attr_reader :refresh_hz
+
+    # The RAM below $8000, in K.
+    attr_reader :ram_kb
+
+    def ram = @bus.ram
+
+    # Reads and writes memory as the CPU sees it, through the bus.
+    def peek(addr) = @bus.peek(addr)
+
+    def poke(addr, value) = @bus.poke(addr, value)
+
+    def install_debug_register(&) = @bus.install_debug_register(&)
+
+    def family = :pet
+
+    # The datasette on cassette port #1, where a tape goes in (Cassettes).
+    def datasette = @cassettes.datasette1
+
+    # +model+ names one of Model::ALL, with +ram_kb+ of RAM below $8000
+    # (Model::RAM_SIZES) in place of the model's own when not nil. A CRTC
+    # model runs its 50 Hz editor, or its 60 Hz one for +refresh_hz+ 60.
+    # +basic+ and +editor+ name ROMs the board takes in place of its own
+    # (Model.upgraded).
+    def initialize(model: Model::DEFAULT, ram_kb: nil, refresh_hz: 50, debug: false, basic: nil, editor: nil)
+      @model = Model.upgraded(Model.named(model), basic, editor)
+      ram_kb ||= @model.ram_kb
+      raise ArgumentError, "a PET has no #{ram_kb}K RAM board" unless Model::RAM_SIZES.include?(ram_kb)
+
+      @ram_kb = ram_kb
+
+      @refresh_hz = @model.crtc? ? refresh_hz : 60
+      @crtc_video = @model.crtc?
+      @vertical_drive = true
+      matrix = @model.keyboard == :business ? KeyboardPorts::BUSINESS_MATRIX : KeyboardPorts::GRAPHICS_MATRIX
+      @keyboard = Input::Keyboard.new(matrix:)
+      keyboard_ports = KeyboardPorts.new(@keyboard)
+      registers = Array.new(Chips::CRTC::MASKS.length, 0)
+      @pia1 = Chips::PIA.new(peripheral: keyboard_ports)
+      @ieee = IEEEPorts.new(Drives::IEEEBus.new)
+      @pia2 = Chips::PIA.new(peripheral: @ieee)
+      @via = VIA.new(start: 0xe800, peripheral: VIAPorts.new(self))
+      @sound = Sound.new(@via)
+      @cassettes = Cassettes.new(@pia1, @via)
+      keyboard_ports.connect(@pia1, @ieee, @cassettes)
+      characters = Characters.new(@model.characters)
+      @crtc_output = CRTCVideo.new(characters, @via, registers, columns80: @model.video == :crtc80)
+      @crtc = Chips::CRTC.new(@crtc_output, registers:)
+      @ieee.connect(@pia1, @pia2, @via)
+      @bus = Bus.new(model: @model, ram_kb:, editor: @model.editor(@refresh_hz), pia1: @pia1, pia2: @pia2,
+                     via: @via, crtc: @crtc)
+      @crtc_output.cells = @bus.screen.cells
+      @discrete = DiscreteVideo.new(@bus.screen.cells, characters, @via)
+      @canvas = @crtc_video ? @crtc_output.canvas : @discrete.canvas
+      cassettes = @cassettes
+      @bus.on_io_write { cassettes.lines_written }
+      @cpu = CPU.new(@bus, debug:)
+      @cycles = 0
+      @init_handlers = []
+      @pending_keys = nil
+      @dos = nil
+      @ieee_trap = nil
+      @capture_output = nil
+      @init_threshold = boot_cycles(ram_kb)
+    end
+
+    # The vertical drive line, high but in the retrace.
+    def vertical_drive? = @vertical_drive
+
+    # The model, its RAM and its editor's frame rate as the pause menu
+    # names them, such as "8032, 32K RAM, 50 HZ".
+    def model_label = "#{@model.name.upcase}, #{@ram_kb}K RAM, #{@refresh_hz} HZ"
+
+    # The Canvas a front end shows.
+    def video = @canvas
+
+    # The 1 MHz clock and the frame the editor sets up, and all of the
+    # Canvas. The CRTC editors' lines and frames are their ROM's
+    # (ROMSets.crtc_frame), which a program can change. 80 columns show
+    # two dots to a window pixel.
+    def timing
+      crop = [0, 0, @canvas.width, @canvas.height]
+      if @crtc_video
+        cycles_per_line, lines_per_frame = ROMSets.crtc_frame(@model.editor(@refresh_hz), @refresh_hz)
+        Timing.new(clock_hz: 1_000_000, cycles_per_line:, lines_per_frame:,
+                   crop:, pixel_width: 1, dots: @model.video == :crtc80 ? 2 : 1)
+      else
+        Timing.new(clock_hz: 1_000_000, cycles_per_line: DiscreteVideo::CYCLES_PER_LINE,
+                   lines_per_frame: DiscreteVideo::LINES_PER_FRAME, crop:, pixel_width: 1, dots: 1)
+      end
+    end
+
+    # The video counts and moves the vertical drive line, then the PIAs
+    # and the VIA clock, ahead of the CPU.
+    def cycle!
+      handle_init if @cycles == @init_threshold
+      feed_keyboard if @pending_keys
+
+      if @crtc_video
+        @crtc.cycle!
+        drive_retrace(!@crtc.vsync?)
+      else
+        @discrete.cycle!
+        drive_retrace(@discrete.vertical_drive?)
+      end
+      @pia1.cycle!
+      @pia2.cycle!
+      @via.cycle!
+      @sound.cycle! if @sound.recording?
+      @cassettes.cycle!
+      @cpu.irq = @pia1.irq? || @pia2.irq? || @via.irq?
+      @cpu.cycle!
+
+      @cycles += 1
+    end
+
+    # What a front end plays: the VIA's CB2 (Sound), which answers #record
+    # and #drain_samples.
+    def sound_source = @sound
+
+    # The RES line reaches the CPU, the PIAs, the VIA, the CRTC and the
+    # 8096's control register.
+    def reset!
+      @pia1.reset!
+      @pia2.reset!
+      @via.reset!
+      @crtc.reset!
+      @bus.reset!
+      @cpu.reset!
+    end
+
+    # Switches the machine off and on: RAM starts cleared, and the RES
+    # line resets everything else.
+    def power_cycle!
+      @bus.power_on!
+      reset!
+    end
+
+    # Puts a program file's bytes where its first two say, through the bus,
+    # and returns that address.
+    def load_prg(data)
+      load_addr = data[0] | (data[1] << 8)
+      bytes = data[2..] || []
+      bytes = bytes[0, 0x10000 - load_addr] if load_addr + bytes.length > 0x10000
+      bytes.each_with_index { |byte, i| @bus.poke(load_addr + i, byte) }
+      load_addr
+    end
+
+    # Where the editor keeps its keyboard buffer: in page 2 under BASIC 1,
+    # in the zero page and page 2 under BASIC 2 and 4.
+    def keyboard_buffer
+      @model.basic1? ? Machine::KeyboardBuffer::PET_BASIC1_LAYOUT : Machine::KeyboardBuffer::PET_LAYOUT
+    end
+
+    private
+
+    # The cycle by which the KERNAL has booted and BASIC printed READY,
+    # with a margin. The RAM test takes most of it, about 41,000 to
+    # 44,000 cycles a K, and the CRTC editors take another 600,000 or so
+    # before it: READY is up by about 440,000 on a 2001 with 8K, 1,450,000
+    # on a 3032 and 1,980,000 on an 8032.
+    def boot_cycles(ram_kb) = (@model.basic == "pet/basic4.rom" ? 700_000 : 150_000) + (46_000 * ram_kb)
+
+    def drive_retrace(high)
+      return if high == @vertical_drive
+
+      @vertical_drive = high
+      @pia1.cb1 = high
+    end
+  end
+end

data/lib/badline/plus4/keyed_state.rb

@@ -4,9 +4,9 @@ module Badline
   class Plus4
     # The machine's own fields in a keyed snapshot module (Snapshot::Keyed,
     # BL-MACHINE): the family, its setup by name (Snapshot::Plus4Setup), the
-    # cycle count, and the host's typing still to feed and on_init handlers
-    # still to run under host.*. The badline version that wrote it is
-    # written for reports and never read.
+    # cycle count, and the host's typing still to feed, on_init handlers
+    # still to run and the model plug_true_drive plugs in under host.*. The
+    # badline version that wrote it is written for reports and never read.
     module KeyedState
       # How many more on_init handlers the machine a snapshot was taken of had
       # yet to run than this one has. Nil until the machine is restored.
@@ -29,6 +29,7 @@ module Badline
         pending = @pending_keys
         out.ints("host.pending_keys", pending) if pending
         out.int("host.init_pending", booting? ? @init_handlers.length : 0)
+        out.text("host.true_drive_model", @true_drive_model)
       end
 
       def load_machine_fields(input)
@@ -36,6 +37,7 @@ module Badline
         pending = input.ints("host.pending_keys", [])
         @pending_keys = pending.empty? ? nil : pending.dup
         @init_handlers_lost = [input.int("host.init_pending", 0) - @init_handlers.length, 0].max
+        @true_drive_model = input.choice("host.true_drive_model", TCBMDrive::TRUE_DRIVE_MODELS, @true_drive_model)
       end
     end
 

data/lib/badline/plus4/tcbm_drive.rb

@@ -32,6 +32,7 @@ module Badline
         drive.host_clock_hz = timing.clock_hz
         @drive1551 = drive
         @bus.plug_tia(drive.device, drive.host_tia)
+        drive.on_renumber { |old| drive1551_renumbered(old) }
         @serial_trap&.device = serial_trap_device
         @init_threshold = [@init_threshold, Badline::Drives::Model1551::BOOT_CYCLES].max if @cycles < @init_threshold
       end
@@ -43,6 +44,7 @@ module Badline
         return unless drive
 
         @bus.plug_tia(drive.device, tcbm_tia(drive.device))
+        drive.on_renumber
         @drive1551 = nil
         @serial_trap&.device = serial_trap_device
       end
@@ -93,6 +95,18 @@ module Badline
         @drive1551.load_modules(modules, input, "BL-D#{device}")
       end
 
+      # The 1551's DEV line moved it from device +old+ to the other: its
+      # interface's TIA moves with it, and the TCBM interface's own takes
+      # its old place.
+      def drive1551_renumbered(old)
+        drive = @drive1551
+        return unless drive
+
+        @bus.plug_tia(old, tcbm_tia(old))
+        @bus.plug_tia(drive.device, drive.host_tia)
+        @serial_trap&.device = serial_trap_device
+      end
+
       # The TCBM interface's own TIA for +device+, or nil without one.
       def tcbm_tia(device)
         tias = @tias

data/lib/badline/plus4.rb

@@ -89,7 +89,7 @@ module Badline
       ntsc = profile == Chips::TED::NTSC
       Timing.new(clock_hz: profile.clock_hz, cycles_per_line: Chips::TED::Beam::CYCLES_PER_LINE,
                  lines_per_frame: ntsc ? 262 : 312, crop: ntsc ? [0, 248, 384, 242] : [0, 276, 384, 288],
-                 pixel_width: 1)
+                 pixel_width: 1, dots: 1)
     end
 
     # Reads and writes memory as the CPU sees it, through the bus.

data/lib/badline/roms/README

@@ -179,3 +179,140 @@ plus4/function-high.rom
 The Plus/4's 3-plus-1 function ROM, high half, 317054-01
 (3-plus-1.317054-01.bin), for $C000-$FFFF in ROM bank 1.
 SHA-1 0ad7ac2db7da692d972e586ca0dfd747d82c7693.
+
+Commodore PET/CBM ROMs
+======================
+
+Downloaded from
+https://www.zimmers.net/anonftp/pub/cbm/firmware/computers/pet/
+Each BASIC and KERNAL pair is one ROM set, and the editors and the
+character sets are files of their own, so a model's stock set and the
+upgrade ROMs Commodore sold can be picked apart. PET::ROMSets
+(pet/rom_sets.rb) names them for --basic and --editor and says which
+fit each model, and PET::Bus maps the ones fitted.
+
+pet/basic1.rom
+--------------
+BASIC 1 for $C000-$DFFF, four 2K chips concatenated:
+901447-09 (rom-2-c000.901447-09.bin, the revision that replaced
+901447-01), 901447-02, 901447-03 and 901447-04 (rom-1-c800, rom-1-d000,
+rom-1-d800).
+SHA-1 3be9cd41b646fefa00d80f1c3433a06146e97c59.
+
+pet/editor1.rom
+---------------
+The BASIC 1 screen editor, 901447-05 (rom-1-e000.901447-05.bin), for
+$E000-$E7FF.
+SHA-1 f02f5fb492ba93dbbd390f24c10f7a832dec432a.
+
+pet/kernal1.rom
+---------------
+The BASIC 1 KERNAL for $F000-$FFFF, 901447-06 and 901447-07
+(rom-1-f000.901447-06.bin, rom-1-f800.901447-07.bin) concatenated.
+SHA-1 32dc08828e88c74d6433156e64d402b564556308.
+
+pet/characters1.rom
+-------------------
+The 2001's character generator, 901447-08 (characters-1.901447-08.bin),
+with upper and lower case swapped against 901447-10.
+SHA-1 3e067cc621e4beafca2b90cb8f6dba975df2855b.
+
+pet/basic2.rom
+--------------
+BASIC 2 for $C000-$DFFF, 901465-01 and 901465-02
+(basic-2-c000.901465-01.bin, basic-2-d000.901465-02.bin) concatenated.
+The 2K chips of the 6540 boards (rom-3-*) hold the same bytes.
+SHA-1 9322a9f0354b9049847d98d3a045fbec860a6264.
+
+pet/kernal2.rom
+---------------
+The BASIC 2 KERNAL, 901465-03 (kernal-2.901465-03.bin), for $F000-$FFFF.
+SHA-1 38742bdf449f629bcba6276ef24d3daeb7da6e84.
+
+pet/editor2-n.rom
+-----------------
+The BASIC 2 editor for the graphics keyboard, 901447-24
+(edit-2-n.901447-24.bin), for $E000-$E7FF.
+SHA-1 5e5502ce32f5a7e387d65efe058916282041e54b.
+
+pet/editor2-b.rom
+-----------------
+The BASIC 2 editor for the business keyboard, 901474-01
+(edit-2-b.901474-01.bin), for $E000-$E7FF.
+SHA-1 174ace3a8c0348cd21d39cc864e2adc58b0101a9.
+
+pet/characters2.rom
+-------------------
+The character generator of BASIC 2 and 4 machines, 901447-10
+(characters-2.901447-10.bin).
+SHA-1 0157a2d55b7ac4eaeb38475889ebeea52e2593db.
+
+pet/basic4.rom
+--------------
+BASIC 4 for $B000-$DFFF, 901465-23, 901465-20 and 901465-21
+(basic-4-b000.901465-23.bin, basic-4-c000.901465-20.bin,
+basic-4-d000.901465-21.bin) concatenated. 901465-23 is the patched
+$B000 chip that replaced 901465-19. The 8296's 324746-01 holds the same
+four chips.
+SHA-1 d70bec479e1e3a0d0908a4897066e9959bbc11c8.
+
+pet/kernal4.rom
+---------------
+The BASIC 4 KERNAL, 901465-22 (kernal-4.901465-22.bin), for
+$F000-$FFFF.
+SHA-1 96a0fa56e0c937da92971d9c99d504e44e898806.
+
+pet/editor4-n.rom
+-----------------
+The BASIC 4 editor for the graphics keyboard without a CRTC, 901447-29
+(edit-4-n.901447-29.bin), for $E000-$E7FF.
+SHA-1 e88f56e5c54b0e8d8d4e8cb39a4647c803c1f51c.
+
+pet/editor4-b.rom
+-----------------
+The BASIC 4 editor for the business keyboard without a CRTC, 901474-02
+(edit-4-b.901474-02.bin), for $E000-$E7FF.
+SHA-1 0ca5c4e8f532f914cb0bf86ea9900f20f0a655ce.
+
+pet/editor4-40-n-50hz.rom
+-------------------------
+The 4032's 50 Hz editor, 40 columns on a CRTC, graphics keyboard,
+901498-01 (edit-4-40-n-50Hz.901498-01.bin), for $E000-$E7FF.
+SHA-1 05af284c914d53a52987b5f602466de75765f650.
+
+pet/editor4-40-n-60hz.rom
+-------------------------
+The 4032's 60 Hz editor, 901499-01 (edit-4-40-n-60Hz.901499-01.bin),
+for $E000-$E7FF.
+SHA-1 8cbf086c1ce4dfb2a2fe24c47476dfb878493dee.
+
+pet/editor4-80-b-50hz.rom
+-------------------------
+The 8032's 50 Hz editor, 80 columns on a CRTC, business keyboard,
+901474-04, the chip dated 3681
+(edit-4-80-b-50Hz.901474-04-3681.bin), for $E000-$E7FF.
+SHA-1 7040b283ba39e9630e3d147f7d076b7abc39bc70.
+
+zimmers.net has three dumps of 901474-04 that differ. This one is the
+60 Hz 901474-03 below with the 50 Hz jiffy clock patch at $E431-$E441
+and $E455, the CRTC's vertical registers (R4, R5 and R7) changed in both
+of its register tables at $E72A, and the byte at $E787 changed to keep
+the ROM's byte sum at $8A, the same as 901474-03's. The line length (R0)
+stays the 60 Hz editor's. A second chip, dated 0384, reads the same
+(8296/edit-50hz-324243-02b.txt). The -0283 dump changes R0 and sums to
+$AE, and the _alt dump changes R0 and $E787.
+
+pet/editor4-80-b-50hz-0283.rom
+------------------------------
+The 8032's other 50 Hz editor, 901474-04, the chip dated 0283
+(edit-4-80-b-50Hz.901474-04-0283.bin), for $E000-$E7FF, which
+--editor 4-80-b-50hz-0283 fits. It differs from the 3681 dump only in
+the CRTC's register tables at $E72A and $E73C: lines of 64 cycles (R0
+63) and frames of 313 lines, with nine scanlines a character row.
+SHA-1 81975eab31a8f4f51ae2a20d099a567c7b3f2dd1.
+
+pet/editor4-80-b-60hz.rom
+-------------------------
+The 8032's 60 Hz editor, 901474-03 (edit-4-80-b-60Hz.901474-03.bin),
+for $E000-$E7FF.
+SHA-1 c605fa343fd77c73cbe1e0e9567e2f014f6e7e30.

data/lib/badline/snapshot/container.rb

@@ -36,6 +36,8 @@ module Badline
       C128 = "C128"
       # xplus4 names its machine PLUS4, for the C16 too.
       PLUS4 = "PLUS4"
+      # xpet names its machine PET, for every model.
+      PET = "PET"
       GZIP_MAGIC = "\x1f\x8b".b
 
       # The VICE version block, when VICE wrote the file: four version

data/lib/badline/snapshot/field_doc/markdown.rb

@@ -7,7 +7,7 @@ module Badline
       # its default, with keys that differ only in a unit's number, such as
       # voice1 to voice3, on one row.
       class Markdown
-        NAMES = { "c64" => "C64", "vic20" => "VIC-20", "c128" => "C128", "plus4" => "Plus/4" }.freeze
+        NAMES = { "c64" => "C64", "vic20" => "VIC-20", "c128" => "C128", "plus4" => "Plus/4", "pet" => "PET" }.freeze
         TAG_TYPES = { Keyed::INT => "int", Keyed::BOOL => "bool", Keyed::BYTES => "bytes", Keyed::INTS => "ints",
                       Keyed::TEXT => "text" }.freeze
 

data/lib/badline/snapshot/field_doc.rb

@@ -36,8 +36,9 @@ module Badline
 
       # The machines the doc is made from: each family at power-on, the C64
       # with each kind of expansion, cartridge and media, and a second SID,
-      # and the 264 series' models, its TCBM interface, cartridge, tape and
-      # true drives, the 1541 and the 1551.
+      # the 264 series' models, its TCBM interface, cartridge, tape and
+      # true drives, the 1541 and the 1551, and a CRTC PET, a 2001, an 8096
+      # and a PET with a disk and tapes.
       def self.machines
         {
           "c64" => [C64.new, C64.new(ram_expansion: :plus256k), C64.new(reu: 512),
@@ -48,10 +49,22 @@ module Badline
           "plus4" => [Plus4.new, Plus4.new(model: "c16"), Plus4.new(tcbm: true), Plus4.new(sid_card: :mos6581),
                       Plus4.new(sid_card: :mos8580, sid_card_address: 0xfe80),
                       Plus4.new(ram_expansion: :csory256),
-                      plus4_with_cartridge, plus4_with_tape, plus4_with_drive, plus4_with_drive("1551")]
+                      plus4_with_cartridge, plus4_with_tape, plus4_with_drive, plus4_with_drive("1551")],
+          "pet" => [PET.new, PET.new(model: "2001"), PET.new(model: "8096"), pet_with_media]
         }
       end
 
+      # A PET with a disk in device 8 through the traps and a tape in each
+      # datasette.
+      def self.pet_with_media
+        bytes = "C64-TAPE-RAW".bytes + [1, 3, 0, 0, 4, 0, 0, 0, 0x30, 0x30, 0x30, 0x30]
+        PET.new.tap do |machine|
+          machine.mount(Storage::D64Image.new("", read_only: true, bytes: blank(174_848)))
+          machine.cassettes.datasette1.insert(Storage::TAP.new("", bytes:))
+          machine.cassettes.datasette2.insert(Storage::TAP.new("", bytes:))
+        end
+      end
+
       def self.blank(length) = Array.new(length, 0)
 
       def self.with_cartridge(type)

data/lib/badline/snapshot/image.rb

@@ -34,7 +34,7 @@ module Badline
     # of a machine in memory (.of).
     class Image
       MACHINE = "BL-MACHINE"
-      FAMILIES = { "c64" => "C64", "vic20" => "VIC-20", "c128" => "C128", "plus4" => "Plus/4" }.freeze
+      FAMILIES = { "c64" => "C64", "vic20" => "VIC-20", "c128" => "C128", "plus4" => "Plus/4", "pet" => "PET" }.freeze
 
       attr_reader :container
 
@@ -54,10 +54,11 @@ module Badline
       end
 
       # The snapshot with VICE's modules ahead of the BL-* ones for a C64,
-      # so x64sc opens it too. Raises FormatError for a Plus/4, whose
-      # snapshots badline doesn't write for xplus4.
+      # so x64sc opens it too. Raises FormatError for a Plus/4 or a PET,
+      # whose snapshots badline doesn't write for xplus4 or xpet.
       def self.exported(computer)
         raise FormatError, "badline doesn't export a Plus/4's snapshot for VICE" if computer.family == :plus4
+        raise FormatError, "badline doesn't export a PET's snapshot for VICE" if computer.family == :pet
 
         computer.settle_for_snapshot!
         sections = computer.save_modules
@@ -71,6 +72,7 @@ module Badline
         when :vic20 then Container::VIC20
         when :c128 then Container::C128
         when :plus4 then Container::PLUS4
+        when :pet then Container::PET
         else Container::MACHINE
         end
       end
@@ -82,6 +84,7 @@ module Badline
         when "vic20" then Vic20Setup.read_fields(machine)
         when "c128" then C128Setup.read_fields(machine)
         when "plus4" then Plus4Setup.read_fields(machine)
+        when "pet" then PETSetup.read_fields(machine)
         else C64Setup.read_fields(machine)
         end
       end
@@ -97,15 +100,16 @@ module Badline
 
       # A new machine, built as the snapshot's was and restored from it. A
       # badline snapshot restores from its BL-* modules alone, and a VICE
-      # one through the modules badline reads. xvic's, x128's and xplus4's own
-      # modules aren't read. Yields a line for each thing left out, or
-      # warns it without a block. `detached` restores it without the host's
-      # files (Keyed::Modules).
+      # one through the modules badline reads. xvic's, x128's, xplus4's and
+      # xpet's own modules aren't read. Yields a line for each thing left
+      # out, or warns it without a block. `detached` restores it without
+      # the host's files (Keyed::Modules).
       def load(detached: false, &)
         refuse_old_layout
         raise FormatError, "badline reads only its own VIC-20 snapshots, not xvic's" if vic20? && !badline?
         raise FormatError, "badline reads only its own C128 snapshots, not x128's" if c128? && !badline?
         raise FormatError, "badline reads only its own Plus/4 snapshots, not xplus4's" if plus4? && !badline?
+        raise FormatError, "badline reads only its own PET snapshots, not xpet's" if pet? && !badline?
         return load_vice(&) unless badline?
 
         modules = Keyed::Modules.new(sections, detached:)
@@ -123,6 +127,9 @@ module Badline
       # Whether the machine is of the 264 series, as the container names it.
       def plus4? = @container.machine == Container::PLUS4
 
+      # Whether the machine is a PET, as the container names it.
+      def pet? = @container.machine == Container::PET
+
       # Restores `computer` from the snapshot, and returns the Report. The
       # snapshot goes into a new machine first, so one that fails, or is of
       # a machine built another way, leaves `computer` as it was.