badline 0.15.1 → 0.16.0

data/lib/badline/kernal_trap/serial.rb

@@ -5,23 +5,15 @@ module Badline
     # PC traps on the KERNAL's serial bus primitives. Frames addressed to
     # device 8 go to a virtual drive instead of out over the IEC lines, so
     # OPEN/CHKIN/CHRIN reach a CBM DOS, and so do the block reads that
-    # loaders make through them. Other devices fall through to the ROM.
+    # loaders make through them (Frames). Other devices fall through to the
+    # ROM.
     #
     # With +device+ nil the traps answer no device, and every frame goes
     # out over the bus, to a true drive if one is plugged in.
     class Serial < Routine
-      attr_accessor :device
-
-      # Frame type in the high nibble of the secondary address
-      OPEN = 0xf0
-      CLOSE = 0xe0
-
-      # ST bits at $90
-      DEVICE_NOT_PRESENT = 0x80
-      EOI = 0x40
-      READ_TIMEOUT = 0x02
+      include Frames
 
-      NO_DATA = [0x0d, EOI | READ_TIMEOUT].freeze
+      attr_accessor :device
 
       def initialize(cpu:, bus:, layout:, dos:, device: DEVICE)
         super(cpu:, bus:, layout:)
@@ -35,46 +27,8 @@ module Badline
         @buffer = []
       end
 
-      def install
-        routines.each do |address, routine|
-          @cpu.install_trap(address) { call_routine(routine) if kernal_mapped? }
-        end
-        self
-      end
-
-      # Takes the traps out again, so the KERNAL's own routines run.
-      def uninstall
-        routines.each_key { |address| @cpu.remove_trap(address) }
-      end
-
       private
 
-      def routines
-        {
-          @layout.talk => :talk,
-          @layout.listen => :listen,
-          @layout.second => :second,
-          @layout.tksa => :tksa,
-          @layout.ciout => :ciout,
-          @layout.untalk => :untalk,
-          @layout.unlisten => :unlisten,
-          @layout.acptr => :acptr
-        }
-      end
-
-      def call_routine(routine)
-        case routine
-        when :talk then talk
-        when :listen then listen
-        when :second then second
-        when :tksa then tksa
-        when :ciout then ciout
-        when :untalk then untalk
-        when :unlisten then unlisten
-        when :acptr then acptr
-        end
-      end
-
       # Addressing the bus starts a new frame. The channel number arrives
       # in the secondary address that follows. Each byte sent under ATN,
       # and each byte of a frame, times its handshake with the serial timer
@@ -112,25 +66,6 @@ module Badline
         sent_under_atn
       end
 
-      # CIOUT holds each byte back until the next one, or the UNLISTEN,
-      # comes, so the first byte of a frame sends nothing.
-      def ciout
-        return unless @listening
-
-        time_serial_byte(ISOUR_TIMEOUT) if !@buffer.empty? && accepted?
-        @buffer << @cpu.a
-        update_status(DEVICE_NOT_PRESENT) unless accepted?
-        @cpu.status.carry = false
-        return_to_caller
-      end
-
-      # The drive acknowledges every byte of an open or close frame, but
-      # takes data only on a channel it has open. Otherwise nothing holds
-      # the data line when a byte starts, so the KERNAL finds no device.
-      def accepted?
-        [OPEN, CLOSE].include?(@frame) || @dos.listening?(@listen_channel)
-      end
-
       def unlisten
         return unless @listening
 
@@ -148,15 +83,6 @@ module Badline
         release_bus
       end
 
-      # UNLSN and UNTLK end by releasing ATN, the clock and the data line,
-      # and leave the port's last read in the accumulator.
-      def release_bus
-        @cpu.a = @layout.release_serial_lines(@bus)
-        @cpu.status.negative = @cpu.a.anybits?(0x80)
-        @cpu.status.zero = @cpu.a.zero?
-        return_to_caller
-      end
-
       def acptr
         return unless @talking
 
@@ -167,30 +93,6 @@ module Badline
         @cpu.status.carry = false
         return_to_caller
       end
-
-      def deliver_frame
-        return unless @listen_channel
-
-        case @frame
-        when OPEN then @dos.open(@listen_channel, @buffer.pack("C*"))
-        when CLOSE then @dos.close(@listen_channel)
-        else @dos.write(@listen_channel, @buffer)
-        end
-        @buffer = []
-      end
-
-      def received
-        byte, eoi = @dos.read(@talk_channel)
-        return NO_DATA unless byte
-
-        [byte, eoi ? EOI : 0]
-      end
-
-      def update_status(bits)
-        return if bits.zero?
-
-        @bus.poke(zero_page.status, @bus.peek(zero_page.status) | bits)
-      end
     end
   end
 end

data/lib/badline/kernal_trap/steps.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Badline
+  module KernalTrap
+    # The steps the PC traps on KERNAL routines share, on the @cpu, @bus
+    # and @layout of the trap that includes them, which includes
+    # IntegerHelper too: the layout's checks and timer, the zero page's
+    # words, and the return that stands in for the trapped routine's RTS.
+    # Routine includes them, and so does each trap that isn't a Routine,
+    # so every trap class keeps its own layout's type.
+    module Steps
+      private
+
+      def kernal_mapped?
+        @layout.kernal_mapped?(@bus)
+      end
+
+      def zero_page = @layout.zero_page
+
+      # The two-byte value whose low byte is at +address+.
+      def peek_word(address)
+        uint16(@bus.peek(address), @bus.peek(address + 1))
+      end
+
+      def poke_word(address, value)
+        @bus.poke(address, low_byte(value))
+        @bus.poke(address + 1, high_byte(value))
+      end
+
+      # The ROM times each byte on the serial bus with a one-shot timer
+      # (Layout#time_serial_byte): Routine::ISOUR_TIMEOUT for a byte sent,
+      # Routine::ACPTR_TIMEOUT for one received.
+      def time_serial_byte(timer_high)
+        @layout.time_serial_byte(@bus, timer_high)
+      end
+
+      def return_to_caller
+        @cpu.program_counter = (uint16(pull_byte, pull_byte) + 1) & 0xffff
+      end
+
+      # Runs the ROM routines in order, each returning into the next, and
+      # the last one to the trapped routine's caller
+      def continue_with(first, *rest)
+        rest.reverse_each { |address| push_address((address - 1) & 0xffff) }
+        @cpu.program_counter = first
+      end
+
+      def push_address(address)
+        push_byte(high_byte(address))
+        push_byte(low_byte(address))
+      end
+
+      def push_byte(value)
+        @bus.poke(0x0100 + @cpu.stack_pointer, value)
+        @cpu.stack_pointer = (@cpu.stack_pointer - 1) & 0xff
+      end
+
+      def pull_byte
+        @cpu.stack_pointer = (@cpu.stack_pointer + 1) & 0xff
+        @bus.peek(0x0100 + @cpu.stack_pointer)
+      end
+    end
+  end
+end

data/lib/badline/kernal_trap.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
 
 require "badline/kernal_trap/layout"
+require "badline/kernal_trap/ieee_layout"
+require "badline/kernal_trap/steps"
 require "badline/kernal_trap/routine"
 require "badline/kernal_trap/dos"
 require "badline/kernal_trap/file_routine"
 require "badline/kernal_trap/load"
 require "badline/kernal_trap/save"
+require "badline/kernal_trap/frames"
 require "badline/kernal_trap/serial"
+require "badline/kernal_trap/ieee"
 require "badline/kernal_trap/chrout"
 require "badline/kernal_trap/keyed_state"

data/lib/badline/machine/keyboard_buffer.rb

@@ -20,6 +20,14 @@ module Badline
       # ($D86E).
       PLUS4_LAYOUT = Layout.new(address: 0x0527, count: 0xef, capacity: 10)
 
+      # The PET's, under BASIC 2 and BASIC 4. Every editor's GETIN takes
+      # ten keys from it, though the CRTC editors' keyboard scans stop at
+      # nine (XMAX).
+      PET_LAYOUT = Layout.new(address: 0x026f, count: 0x9e, capacity: 10)
+
+      # The PET's under BASIC 1, outside the zero page.
+      PET_BASIC1_LAYOUT = Layout.new(address: 0x020f, count: 0x020d, capacity: 10)
+
       def type_text(text)
         codes = text.bytes.map { |b| ascii_to_petscii(b) }
         on_init { @pending_keys = codes }

data/lib/badline/machine/settling.rb

@@ -4,7 +4,7 @@ module Badline
   module Machine
     # Brings the machine to the point a snapshot file is saved at: the main
     # CPU between instructions, or jammed, with no REU transfer holding the
-    # bus. C64, Vic20, C128 and Plus4 each include it, and answer
+    # bus. C64, Vic20, C128, Plus4 and PET each include it, and answer
     # #settled_for_snapshot? and #settle_chips_for_snapshot, which brings
     # what each chip defers up to the cycle without running one.
     module Settling

data/lib/badline/machine.rb

@@ -8,8 +8,9 @@ module Badline
   # = Machine
   #
   # The machines badline builds by family, as the command line's
-  # subcommand names them: the C64, Badline::C64, the VIC-20, Vic20, and the
-  # C128 in C64 mode, C128, and the 264 series, Plus4.
+  # subcommand names them: the C64, Badline::C64, the VIC-20, Vic20, the
+  # C128 in C64 mode, C128, the 264 series, Plus4, and the PET and CBM,
+  # PET.
   #
   # A machine answers what the front end, Media, the runners and the
   # snapshots call on it:
@@ -57,23 +58,31 @@ module Badline
   # and +capture_output+, and besides +model_label+, +cartridge_slots+ and
   # +detach_cartridges+ for its two cartridges.
   #
+  # The PET answers the identity, clocking, lifecycle, video, sound and
+  # keyboard parts, with no joysticks, RESTORE or control ports, and of
+  # the rest +ram+, +load_prg+, +type_text+, +mount+, +unmount+,
+  # +mounted?+, +datasette+, +true_drive+, nil, +install_debug_register+
+  # and +capture_output+, and besides +model_label+ and +ram_kb+.
+  #
   # Each machine includes Machine::Clocking for the clocking part.
   module Machine
     # Media the machine named doesn't take.
     class Unsupported < ArgumentError; end
 
-    # A new machine of `family`, :c64, :vic20, :c128 or :plus4, the model
-    # of it `model` names. A C64's model is one of Model::ALL, with its SID
+    # A new machine of `family`, :c64, :vic20, :c128, :plus4 or :pet, the
+    # model of it `model` names. A C64's model is one of Model::ALL, with its SID
     # `sid_model` when not nil and an REU of `reu` K when not nil. A
     # VIC-20's is "pal", with the RAM expansion `ram` names
     # (Vic20::Bus::RAM_CONFIGURATIONS), unexpanded when nil. A C128's is
     # one of C128::Model::ALL, with its SID `sid_model` when not nil, built
     # for C64 mode. A Plus/4's is one of Plus4::Model::ALL or c116, with
-    # the model's own RAM.
+    # the model's own RAM. A PET's is one of PET::Model::ALL, with its own
+    # RAM and ROMs, its CRTC's editor the 50 Hz one.
     def self.build(family, model:, sid_model: nil, reu: nil, ram: nil)
       return vic20(model, ram) if family == :vic20
       return c128(model, sid_model, :c64) if family == :c128
       return Plus4.new(model:) if family == :plus4
+      return PET.new(model:) if family == :pet
       raise ArgumentError, "no machine family named #{family}" unless family == :c64
 
       profile = Model.named(model)
@@ -89,11 +98,12 @@ module Badline
     # only C64 mode runs: a .sid tune or a program that loads at the C64's
     # BASIC start. A VIC-20 without RAM named gets the expansion the media
     # needs (Media::Vic20Media.ram_for) and yields a line saying so. Raises
-    # Unsupported for media a VIC-20 or a Plus/4 doesn't take.
+    # Unsupported for media a VIC-20, a Plus/4 or a PET doesn't take.
     def self.for_options(options, media, &)
       family = options.family
       return vic20_for(media, options.model, options.ram, &) if family == :vic20
       return plus4_for(media, options) if family == :plus4
+      return pet_for(media, options) if family == :pet
 
       sid_model = options.sid_model || Media.sid_model(media, otherwise: nil)
       return build(:c64, model: options.model, sid_model:, reu: options.reu) unless family == :c128
@@ -141,6 +151,18 @@ module Badline
     end
     private_class_method :plus4_for
 
+    # A PET with the RAM --ram names (PET::Model::RAM_SIZES), or with the
+    # model's own without it, the editor at the frame rate --60hz or
+    # --editor asks for, and the ROMs --basic and --editor fit it with.
+    def self.pet_for(media, options)
+      unsupported = !media.nil? && Media::PETMedia::UNSUPPORTED.include?(File.extname(media).downcase)
+      raise Unsupported, "doesn't go in a PET" if unsupported
+
+      PET.new(model: options.model, ram_kb: options.ram_kb, refresh_hz: options.refresh_hz, basic: options.basic,
+              editor: options.editor)
+    end
+    private_class_method :pet_for
+
     def self.c64_media?(media)
       return false if media.nil? || !File.file?(media)
 

data/lib/badline/media/extensions.rb

@@ -7,6 +7,8 @@ module Badline
     # It loads on its own, for Options.
     #
     # - :disk, a disk image that the traps mount and a true drive reads
+    # - :ieee_disk, an 8050's or 8250's disk image, for a PET's IEEE-488
+    #   drive
     # - :gcr, a disk's raw GCR, which only a true drive reads
     # - :archive, a .t64, which the traps mount read-only
     # - :tape, :cartridge and :tune
@@ -14,7 +16,8 @@ module Badline
     module Extensions
       KINDS = {
         ".d64" => :disk, ".d71" => :disk, ".d81" => :disk, ".g64" => :gcr, ".g71" => :gcr, ".t64" => :archive,
-        ".tap" => :tape, ".crt" => :cartridge, ".sid" => :tune, ".m3u" => :disk_list, ".vfl" => :disk_list
+        ".d80" => :ieee_disk, ".d82" => :ieee_disk, ".tap" => :tape, ".crt" => :cartridge, ".sid" => :tune,
+        ".m3u" => :disk_list, ".vfl" => :disk_list
       }.freeze
 
       # The kind of the medium at `path`, by its extension.
@@ -27,7 +30,7 @@ module Badline
       DISKS = of(%i[disk gcr])
 
       # What goes in device 8 through the traps.
-      MOUNTABLE = of(%i[disk archive])
+      MOUNTABLE = of(%i[disk archive ieee_disk])
 
       # What goes in device 8, a true drive's or the traps', and the lists
       # of disks to put there.

data/lib/badline/media/pet_media.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # What a PET does with media of its own (Media.attach). Disks of every
+    # kind, .d80 and .d82 among them, directories and .t64 archives mount
+    # on device 8 through the traps on the KERNAL's IEEE-488 primitives
+    # (PET::IEEETraps), programs load at the start of BASIC, $0401
+    # (Program), and tapes play on the datasette at cassette port #1. There
+    # is no cartridge port and no SID, and the true drives are serial ones.
+    module PETMedia
+      # What a PET doesn't take.
+      UNSUPPORTED = Extensions.of(%i[tune cartridge gcr])
+
+      # What loads and runs the first program on the disk in device 8.
+      AUTOSTART = %(load"*",8\rrun\r)
+
+      # What loads and runs the first program on the tape in cassette #1.
+      TAPE_AUTOSTART = "load\rrun\r"
+
+      class << self
+        # A tape made for another machine plays all the same, and says so.
+        def tape_message(tape, message)
+          tape.platform == Storage::TAP::PET_PLATFORM ? message : "#{message}, a tape for another machine than the PET"
+        end
+
+        # BASIC 2 and 4 load the first program off the disk and run it.
+        # BASIC 1's LOAD finds no device on the IEEE-488 bus, so the first
+        # program goes in as a program file does, once the KERNAL has
+        # booted.
+        def disk_autostart(machine, storage)
+          return machine.type_text(AUTOSTART) unless machine.model.basic1?
+
+          data = storage.read_file("*")
+          machine.on_init { Program.load(machine, data, autostart: true) } if data
+        end
+      end
+    end
+  end
+end

data/lib/badline/media/program.rb

@@ -2,12 +2,16 @@
 
 module Badline
   module Media
-    # A program loading into a C64, a C128 or a 264 series machine once it
-    # has booted (Media.attach). The VIC-20 has its own (Vic20Basic).
+    # A program loading into a C64, a C128, a 264 series machine or a PET
+    # once it has booted (Media.attach). The VIC-20 has its own
+    # (Vic20Basic).
     module Program
       # Where BASIC 3.5 starts on the 264 series.
       PLUS4_BASIC_START = 0x1001
 
+      # Where BASIC starts on every PET.
+      PET_BASIC_START = 0x0401
+
       class << self
         # Loads the program where it says, and RUNs one that loads at the
         # start of BASIC.
@@ -30,12 +34,20 @@ module Badline
         # Where BASIC starts, the pointer to the end of its text and the
         # KERNAL's end address (EAL). BASIC 7.0 starts at $1C01 and keeps
         # the end of its text at $1210, and the 264 KERNAL keeps EAL at $9D.
+        # PET BASIC 2 and 4 keep the end of their text at $2A and EAL at
+        # $C9, and BASIC 1 at $7C and $E5.
         def basic(computer)
           return [PLUS4_BASIC_START, 0x2d, KernalTrap::PLUS4_ZERO_PAGE.end_address] if computer.family == :plus4
+          return pet_basic(computer) if computer.family == :pet
           return [0x1c01, 0x1210, 0xae] if computer.family == :c128 && computer.mode == :c128
 
           [BASIC_START, 0x2d, 0xae]
         end
+
+        def pet_basic(computer)
+          model = computer.model
+          [PET_BASIC_START, model.basic1? ? 0x7c : 0x2a, model.trap_layout.zero_page.end_address]
+        end
       end
     end
   end

data/lib/badline/media/vic20_media.rb

@@ -61,11 +61,11 @@ module Badline
 
         # Loads the program, `bytes` from the file at `path`, as Vic20Basic
         # has it once the KERNAL has booted, or attaches the cartridge it's
-        # a part of (Vic20Cartridge), and says which.
+        # a part of (Vic20Cartridge), named after the file, and says which.
         def attach_program(machine, path, bytes, autostart:)
           chips = Vic20Cartridge.chips(path, bytes)
           if chips
-            machine.attach_cartridge(chips)
+            machine.attach_cartridge(chips, File.basename(path, File.extname(path)))
             return "Attached cartridge #{path}"
           end
 

data/lib/badline/media.rb

@@ -11,6 +11,7 @@ require "badline/media/vic20_basic"
 require "badline/media/vic20_cartridge"
 require "badline/media/vic20_media"
 require "badline/media/plus4_media"
+require "badline/media/pet_media"
 require "badline/media/tune"
 require "badline/media/program"
 
@@ -25,7 +26,9 @@ module Badline
       ".d64" => Storage::D64Image,
       ".d71" => Storage::D71Image,
       ".d81" => Storage::D81Image,
-      ".t64" => Storage::T64
+      ".t64" => Storage::T64,
+      ".d80" => Storage::D80Image,
+      ".d82" => Storage::D82Image
     }.freeze
 
     class << self
@@ -48,8 +51,10 @@ module Badline
       # disk autostart of its own, and takes no .sid tunes, and the 264
       # series loads programs at the start of its BASIC (Program), takes
       # .crt cartridges and raw .bin ROM images in its two cartridges'
-      # slots (Plus4Media), and no .sid tunes either. The
-      # C128 in C64 mode takes a C64's.
+      # slots (Plus4Media), and no .sid tunes either. The PET mounts .d80
+      # and .d82 disks too, which no other machine takes, and has no
+      # cartridges, tunes or true drives (PETMedia). The C128 in C64 mode
+      # takes a C64's.
       def attach(computer, path, autostart: true, subtune: nil, **)
         path = DiskList.disk(path)
         refuse_unsupported(computer, path)
@@ -99,7 +104,7 @@ module Badline
         return :cartridge if computer.family == :plus4 && Plus4Media.rom_image?(path)
 
         kind = Extensions.kind(path)
-        %i[disk archive].include?(kind) ? :storage : kind
+        %i[disk archive ieee_disk].include?(kind) ? :storage : kind
       end
 
       # What device 8 serves through the traps for a host directory, a disk
@@ -120,14 +125,21 @@ module Badline
 
       private
 
-      # The VIC-20 and the 264 series have no SID to play a .sid tune on.
+      # The VIC-20 and the 264 series have no SID to play a .sid tune on,
+      # and only the PET has the IEEE-488 drive a .d80 or .d82 goes in.
       def refuse_unsupported(computer, path)
-        return unless Vic20Media::UNSUPPORTED.include?(File.extname(path).downcase)
-
-        case computer.family
-        when :vic20 then raise ArgumentError, "#{path} doesn't go in a VIC-20"
-        when :plus4 then raise ArgumentError, "#{path} doesn't go in a Plus/4"
+        family = computer.family
+        if Extensions.kind(path) == :ieee_disk && family != :pet
+          raise ArgumentError, "#{path} needs a PET's IEEE-488 drive"
         end
+
+        refused, name = case family
+                        when :vic20 then [Vic20Media::UNSUPPORTED, "a VIC-20"]
+                        when :plus4 then [Vic20Media::UNSUPPORTED, "a Plus/4"]
+                        when :pet then [PETMedia::UNSUPPORTED, "a PET"]
+                        else [[], ""]
+                        end
+        raise ArgumentError, "#{path} doesn't go in #{name}" if refused.include?(File.extname(path).downcase)
       end
 
       def attach_kind(computer, path, autostart:, subtune:, **options)
@@ -143,7 +155,7 @@ module Badline
         end
       end
 
-      def disk?(path) = File.directory?(path) || Extensions.kind(path) == :disk
+      def disk?(path) = File.directory?(path) || %i[disk ieee_disk].include?(Extensions.kind(path))
 
       def attach_true_drive(computer, path, disk, autostart:)
         message = TrueDrive.insert(computer, path, read_only: disk.fetch(:read_only, false))
@@ -154,7 +166,11 @@ module Badline
       def mount(computer, path, disk, autostart:)
         storage = open_storage(path, disk)
         computer.mount(storage)
-        computer.type_text(disk_autostart(computer) { storage.read_file("*") }) if autostart
+        if autostart && computer.family == :pet
+          PETMedia.disk_autostart(computer, storage)
+        elsif autostart
+          computer.type_text(disk_autostart(computer) { storage.read_file("*") })
+        end
         "Mounted #{path} as device 8"
       end
 
@@ -170,7 +186,9 @@ module Badline
       # (Plus4Media.cartridge_chips).
       def attach_cartridge(computer, path, options)
         case computer.family
-        when :vic20 then computer.attach_cartridge(Storage::CRTFile.new(path, machine: :vic20).chips)
+        when :vic20
+          crt = Storage::CRTFile.new(path, machine: :vic20)
+          computer.attach_cartridge(crt.chips, crt.name.empty? ? File.basename(path, File.extname(path)) : crt.name)
         when :plus4 then computer.attach_cartridge(Plus4Media.cartridge_chips(path, slot: options.fetch(:slot, nil)))
         else
           computer.attach_cartridge(C64::Cartridge.from_file(path, **options))
@@ -178,17 +196,19 @@ module Badline
         "Attached cartridge #{path}"
       end
 
-      # A VIC-20 or a 264 says when the tape was made for another machine
-      # (Vic20Media.tape_message, Plus4Media.tape_message).
+      # A VIC-20, a 264 or a PET says when the tape was made for another
+      # machine (Vic20Media.tape_message, Plus4Media.tape_message,
+      # PETMedia.tape_message).
       def attach_tape(computer, path, autostart:)
         tape = Storage::TAP.new(path)
         computer.datasette.insert(tape)
         computer.datasette.play!
-        computer.type_text(TAPE_AUTOSTART) if autostart
+        computer.type_text(computer.family == :pet ? PETMedia::TAPE_AUTOSTART : TAPE_AUTOSTART) if autostart
         message = "Inserted #{path} in the datasette"
         case computer.family
         when :vic20 then Vic20Media.tape_message(tape, message)
         when :plus4 then Plus4Media.tape_message(tape, message)
+        when :pet then PETMedia.tape_message(tape, message)
         else message
         end
       end

data/lib/badline/options/family.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "badline/storage/p00"
+require "badline/storage/tap"
 
 module Badline
   class Options
@@ -12,7 +13,7 @@ module Badline
 
       private
 
-      # Takes `sid`, `c64`, `vic20`, `c128` or `plus4` when given first.
+      # Takes `sid`, `c64`, `vic20`, `c128`, `plus4` or `pet` when given first.
       def subcommand(args)
         case args.first
         when "sid" then @sid_command = true
@@ -20,6 +21,7 @@ module Badline
         when "vic20" then @family = :vic20
         when "c128" then @family = :c128
         when "plus4" then @family = :plus4
+        when "pet" then @family = :pet
         else return
         end
         @family_named = !@sid_command
@@ -31,19 +33,28 @@ module Badline
         when :vic20 then VIC20_MODELS
         when :c128 then C128_MODELS
         when :plus4 then PLUS4_MODELS
+        when :pet then PET_MODELS
         else MODELS
         end
       end
 
       # Without a family named, a program that loads at C128_BASIC_START is
-      # the C128's.
+      # the C128's, and an 8050's or 8250's disk or a PET tape the PET's. A
+      # program that loads where PET BASIC starts could be a VIC-20's too.
       def pick_family
-        return if @family_named || @sid_command || @media_path.nil?
+        return if @family_named || @sid_command || @media_path.nil? || !File.file?(@media_path)
 
-        program = Media::Extensions::PROGRAMS.include?(File.extname(@media_path).downcase)
-        return unless program && File.file?(@media_path)
+        if pet_media?
+          @family = :pet
+        elsif Media::Extensions::PROGRAMS.include?(File.extname(@media_path).downcase)
+          @family = :c128 if Storage::P00.load_address(@media_path) == C128_BASIC_START
+        end
+      end
 
-        @family = :c128 if Storage::P00.load_address(@media_path) == C128_BASIC_START
+      # Whether the media is an 8050's or 8250's disk or a PET tape.
+      def pet_media?
+        kind = Media::Extensions.kind(@media_path)
+        kind == :ieee_disk || (kind == :tape && Storage::TAP.platform_of(@media_path) == Storage::TAP::PET_PLATFORM)
       end
     end
   end