badline 0.17.0 → 0.18.0

data/lib/badline/machine/ieee_drives.rb

@@ -1,16 +1,21 @@
 # frozen_string_literal: true
 
+require "badline/drives/ieee_models"
 require "badline/drives/model2031"
 require "badline/drives/model8050"
+require "badline/drives/model9060"
+require "badline/drives/model1001"
+require "badline/drives/model4040"
 
 module Badline
   module Machine
-    # A machine's true drive on its IEEE-488 bus: a Drives::Model2031,
-    # Model8050 or Model8250, one at a time, clocked after the CPU each
-    # cycle at the machine's clock (ieee_host_clock_hz) and reset with it,
-    # as the machine's RES line reaches IFC. The traps on the KERNAL's
-    # primitives leave device 8 to the drive while it is device 8
-    # (trap_device). The PET (PET::IEEEDrive) and the CBM-II
+    # A machine's true drive on its IEEE-488 bus, one at a time, of a model
+    # Drives::IEEEModels names: a Drives::Model2031, Model8050, Model8250,
+    # Model1001, Model4040, Model3040, Model2040, Model9060 or Model9090. It
+    # is clocked after the CPU each cycle at the machine's clock
+    # (ieee_host_clock_hz) and reset with it, as the machine's RES line
+    # reaches IFC. The traps on the KERNAL's primitives leave device 8 to
+    # the drive while it is device 8 (trap_device). The PET (PET::IEEEDrive) and the CBM-II
     # (CBM2::IEEEDrive) include it.
     #
     # The machine's @ieee is its side of the bus: #bus, the
@@ -18,142 +23,126 @@ module Badline
     # machine pulls now, and #cycle_lines, which does so once a cycle if
     # the machine doesn't push them as its chips are written.
     module IEEEDrives
-      # The 2031 on the bus, or nil.
-      attr_reader :drive2031
-
-      # The 8050 or 8250 on the bus, or nil.
-      attr_reader :drive8050
-
-      # Plugs in a Drives::Model2031, in place of the drive there.
-      def attach_drive2031(drive)
-        detach_true_drives
-        connect_drive(drive)
-        @drive2031 = drive
-        @ieee_trap&.device = trap_device
-        @init_threshold = [@init_threshold, Badline::Drives::Model2031::BOOT_CYCLES].max if @cycles < @init_threshold
-      end
-
-      # Unplugs the 2031, leaving it on a bus of its own.
-      def detach_drive2031
-        drive = @drive2031
-        return unless drive
+      # The true drive on the bus, or nil.
+      attr_reader :true_drive
 
-        drive.connect(Badline::Drives::IEEEBus.new)
-        @drive2031 = nil
-        @ieee_trap&.device = trap_device
-      end
+      # The model plug_true_drive plugs in, one Drives::IEEEModels names.
+      attr_reader :true_drive_model
 
-      # Plugs in a Drives::Model8050 or Model8250, in place of the drive
-      # there.
-      def attach_drive8050(drive)
-        detach_true_drives
-        connect_drive(drive)
-        @drive8050 = drive
+      # Plugs in the drive, in place of the drive there.
+      def attach_ieee_drive(drive)
+        detach_ieee_drive
+        drive.host_clock_hz = ieee_host_clock_hz
+        drive.connect(@ieee.bus)
+        @ieee.push_lines
+        @true_drive = drive
         @ieee_trap&.device = trap_device
-        @init_threshold = [@init_threshold, Badline::Drives::Model8050::BOOT_CYCLES].max if @cycles < @init_threshold
+        @init_threshold = [@init_threshold, drive.boot_cycles].max if @cycles < @init_threshold
       end
 
-      # Unplugs the 8050 or 8250, leaving it on a bus of its own.
-      def detach_drive8050
-        drive = @drive8050
+      # Unplugs the true drive, leaving it on a bus of its own.
+      def detach_ieee_drive
+        drive = @true_drive
         return unless drive
 
         drive.connect(Badline::Drives::IEEEBus.new)
-        @drive8050 = nil
+        @true_drive = nil
         @ieee_trap&.device = trap_device
       end
 
-      # Plugs in an 8050, or an 8250 for +model+ "8250", as device 8, in
-      # place of the drive there, and returns it.
-      def plug_drive8050(model = "8050")
-        drive = model == "8250" ? Badline::Drives::Model8250.new : Badline::Drives::Model8050.new
-        drive.tap { |unit| attach_drive8050(unit) }
+      # Plugs in the model as +device+, in place of the drive there, and
+      # returns it.
+      def plug_ieee_drive(model, device: 8)
+        build_ieee_drive(model, device).tap { |drive| attach_ieee_drive(drive) }
       end
 
-      # The true drive on the bus, or nil.
-      def true_drive = @drive8050 || @drive2031
+      # The drive of a dual unit a disk image given on its own goes in
+      # (Media::TrueDrive): drive 0.
+      def disk_drive_number = 0
 
-      # Plugs in a 2031 as device 8, in place of the drive there, and
-      # returns it.
-      def plug_true_drive
-        Badline::Drives::Model2031.new.tap { |drive| attach_drive2031(drive) }
-      end
+      # Plugs in the model true_drive_model names as device 8, in place of
+      # the drive there, and returns it.
+      def plug_true_drive = plug_ieee_drive(@true_drive_model)
 
-      # Settles for a snapshot, then runs on until a 2031's CPU, or an
-      # 8050's interface processor with its controller at the start of its
-      # idle loop, is between instructions with the machine's, as VICE
-      # saves them, or for so many cycles, then on to the machine's next
-      # instruction. It stands in for Machine::Settling's, which the
+      # Settles for a snapshot, then runs on until the true drive is where
+      # VICE saves it (the drive's settled_for_vice?) between instructions
+      # with the machine's, or for so many cycles, then on to the machine's
+      # next instruction. It stands in for Machine::Settling's, which the
       # machines include first.
       def settle_for_vice!
         ran = settle_for_snapshot!
-        return ran if @drive2031.nil? && @drive8050.nil?
+        drive = @true_drive
+        return ran if drive.nil?
 
-        until ran >= Machine::Settling::LIMIT || (drive_settled_for_vice? && settled_for_snapshot?)
+        until ran >= Machine::Settling::LIMIT || (drive.settled_for_vice? && settled_for_snapshot?)
           cycle!
           ran += 1
         end
         ran + settle_for_snapshot!
       end
 
-      # Whether the true drive is where VICE saves it (#settle_for_vice!).
-      def drive_settled_for_vice?
-        return @drive2031.cpu.boundary? if @drive2031
-
-        fdc = @drive8050.fdc_cpu
-        @drive8050.ip_cpu.boundary? && fdc.boundary? && fdc.program_counter == Badline::Drives::Model8050::Idle::FDC_LOOP
-      end
-
       private
 
-      def init_ieee_drives
-        @drive2031 = nil
-        @drive8050 = nil
-      end
-
-      def detach_true_drives
-        detach_drive2031
-        detach_drive8050
-      end
+      def init_ieee_drives(true_drive_model)
+        unless Badline::Drives::IEEEModels::NAMES.include?(true_drive_model)
+          raise ArgumentError, "no true drive model #{true_drive_model} for the IEEE-488 bus"
+        end
 
-      def connect_drive(drive)
-        drive.host_clock_hz = ieee_host_clock_hz
-        drive.connect(@ieee.bus)
-        @ieee.push_lines
+        @true_drive_model = true_drive_model
+        @true_drive = nil
+      end
+
+      # A new drive of the model as +device+.
+      def build_ieee_drive(model, device)
+        case model
+        when "8050" then Badline::Drives::Model8050.new(device:)
+        when "8250" then Badline::Drives::Model8250.new(device:)
+        when "1001" then Badline::Drives::Model1001.new(device:)
+        when "4040" then Badline::Drives::Model4040.new(device:)
+        when "3040" then Badline::Drives::Model3040.new(device:)
+        when "2040" then Badline::Drives::Model2040.new(device:)
+        when "9060" then Badline::Drives::Model9060.new(device:)
+        when "9090" then Badline::Drives::Model9090.new(device:)
+        else Badline::Drives::Model2031.new(device:)
+        end
       end
 
       # The true drive's cycles for one of the machine's, after the lines
       # it pulls.
       def clock_ieee_drives
-        drive2031 = @drive2031
-        drive8050 = @drive8050
-        return unless drive2031 || drive8050
+        drive = @true_drive
+        return unless drive
 
         @ieee.cycle_lines
-        drive2031&.host_cycle!
-        drive8050&.host_cycle!
+        drive.host_cycle!
       end
 
       # The RES line reaches the true drive as IFC.
       def reset_ieee_drives
-        @drive2031&.reset!
-        @drive8050&.reset!
+        @true_drive&.reset!
+      end
+
+      def save_ieee_drive_fields(out)
+        out.text("host.ieee_drive_model", @true_drive_model)
+      end
+
+      def load_ieee_drive_fields(input)
+        @true_drive_model = input.choice("host.ieee_drive_model", Badline::Drives::IEEEModels::NAMES,
+                                         @true_drive_model)
       end
 
       # The true drive as keyed snapshot modules named from its device
       # number: BL-D8, BL-D8-CPU and so on for device 8.
       def save_drive_modules(sections)
-        drive2031 = @drive2031
-        drive2031&.save_modules(sections, "BL-D#{drive2031.device}")
-        drive8050 = @drive8050
-        drive8050&.save_modules(sections, "BL-D#{drive8050.device}")
+        drive = @true_drive
+        drive&.save_modules(sections, "BL-D#{drive.device}")
         sections
       end
 
-      # The true drive a snapshot's modules hold, a 2031, an 8050 or an
-      # 8250 by its model, built afresh unless the same model is on the bus
-      # as the same device, or none when they hold no drive. The bus then
-      # carries the machine's lines as its chips left them.
+      # The true drive a snapshot's modules hold, of the model they name,
+      # built afresh unless the same model is on the bus as the same
+      # device, or none when they hold no drive. The bus then carries the
+      # machine's lines as its chips left them.
       def load_drive_modules(modules)
         device = 8
         input = modules.optional("BL-D8")
@@ -161,33 +150,21 @@ module Badline
           device += 1
           input = modules.optional("BL-D#{device}")
         end
-        model = input&.text("model", "2031")
-        if %w[8050 8250].include?(model)
-          load_drive8050_modules(modules, input, model, device)
-        elsif input
-          load_drive2031_modules(modules, input, device)
+        if input
+          load_ieee_drive_modules(modules, input, device)
         else
-          detach_true_drives
+          detach_ieee_drive
         end
         @ieee.push_lines
       end
 
-      def load_drive2031_modules(modules, input, device)
-        detach_drive8050
-        detach_drive2031 if @drive2031 && @drive2031.device != device
-        attach_drive2031(Badline::Drives::Model2031.new(device:)) unless @drive2031
-        @drive2031.load_modules(modules, input, "BL-D#{device}")
-      end
-
-      def load_drive8050_modules(modules, input, model, device)
-        detach_drive2031
-        drive = @drive8050
-        detach_drive8050 if drive && (drive.device != device || drive.model_name != model)
-        unless @drive8050
-          unit = model == "8250" ? Badline::Drives::Model8250.new(device:) : Badline::Drives::Model8050.new(device:)
-          attach_drive8050(unit)
-        end
-        @drive8050.load_modules(modules, input, "BL-D#{device}")
+      def load_ieee_drive_modules(modules, input, device)
+        model = input.text("model", Badline::Drives::IEEEModels::DEFAULT)
+        model = Badline::Drives::IEEEModels::DEFAULT unless Badline::Drives::IEEEModels::NAMES.include?(model)
+        drive = @true_drive
+        detach_ieee_drive if drive && (drive.device != device || drive.model_name != model)
+        drive = @true_drive || plug_ieee_drive(model, device:)
+        drive.load_modules(modules, input, "BL-D#{device}")
       end
     end
   end

data/lib/badline/machine/keyboard_buffer.rb

@@ -28,13 +28,30 @@ module Badline
       # 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 }
+      def type_text(text) = type_on_init(text.bytes.map { |b| ascii_to_petscii(b) })
+
+      # The keys type_text left for the KERNAL to boot first, under
+      # host.init_keys, so that a machine restored before then types them.
+      def save_init_keys(out)
+        keys = @init_keys
+        out.ints("host.init_keys", keys) if keys
+      end
+
+      def load_init_keys(input)
+        keys = input.ints("host.init_keys", [])
+        type_on_init(keys.dup) unless keys.empty?
       end
 
       private
 
+      def type_on_init(codes)
+        @init_keys = codes if booting?
+        on_init do
+          @init_keys = nil
+          @pending_keys = codes
+        end
+      end
+
       def feed_keyboard
         buffer = keyboard_buffer
         return unless ram.peek(buffer.count).zero?

data/lib/badline/machine/line_sound.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Badline
+  module Machine
+    # The sound of one logic line a machine drives into its speaker or
+    # audio output, such as the PET's CB2 or the KIM-1's PB7. The class
+    # that includes it answers #line_high?, the line's level this cycle.
+    #
+    # The machine calls #cycle! once a cycle while #recording?, from #record
+    # on, so a sound nobody records costs only that check. Each sample is
+    # the share of its cycles the line spent high, through the output
+    # stage: a one-pole low-pass at 5 kHz and a one-pole high-pass at
+    # 100 Hz, so a line left high or low settles to silence.
+    module LineSound
+      LOW_PASS_HZ = 5_000
+      HIGH_PASS_HZ = 100
+
+      # A swing from the line low to the line high, as a signed 16-bit
+      # sample.
+      SCALE = 24_000.0
+
+      attr_reader :recording
+      alias recording? recording
+
+      # Starts collecting the output, averaged down to `rate` samples a
+      # second at `clock_hz` cycles a second, for #drain_samples. The
+      # output stage takes the line's level now as settled.
+      def record(rate:, clock_hz: 1_000_000)
+        @rate = rate
+        @clock_hz = clock_hz
+        @remainder = 0
+        @window = next_window
+        @left = @window
+        @sum = 0
+        @high = line_high?
+        @run = 0
+        @low = @drift = @high ? 1.0 : 0.0
+        @low_pass = 1.0 - Math.exp(-2.0 * Math::PI * LOW_PASS_HZ / rate)
+        @high_pass = 1.0 - Math.exp(-2.0 * Math::PI * HIGH_PASS_HZ / rate)
+        @samples = []
+        @recording = true
+      end
+
+      # Takes the line's level for this cycle, while recording.
+      def cycle!
+        high = line_high?
+        if high == @high
+          @run += 1
+        else
+          hold(@high, @run)
+          @high = high
+          @run = 1
+        end
+      end
+
+      # The samples closed since the last drain.
+      def drain_samples
+        return [] unless @recording
+
+        hold(@high, @run)
+        @run = 0
+        samples = @samples
+        @samples = []
+        samples
+      end
+
+      private
+
+      def init_line_sound
+        @recording = false
+        @high = true
+        @run = 0
+        @rate = 0
+        @clock_hz = 0
+        @remainder = 0
+        @window = 0
+        @left = 0
+        @sum = 0
+        @low = 0.0
+        @drift = 0.0
+        @low_pass = 0.0
+        @high_pass = 0.0
+        @samples = []
+      end
+
+      # Adds `cycles` cycles with the line high or low, closing every
+      # sample they finish.
+      def hold(high, cycles)
+        left = @left
+        while cycles >= left
+          @sum += left if high
+          cycles -= left
+          close
+          left = @left
+        end
+        @sum += cycles if high
+        @left = left - cycles
+      end
+
+      def close
+        @low += @low_pass * (@sum.fdiv(@window) - @low)
+        @drift += @high_pass * (@low - @drift)
+        sample = ((@low - @drift) * SCALE).round
+        sample = 32_767 if sample > 32_767
+        sample = -32_768 if sample < -32_768
+        @samples << sample
+        @sum = 0
+        @window = next_window
+        @left = @window
+      end
+
+      # Each window is a whole number of cycles, and they add up to the
+      # clock's cycles over a second.
+      def next_window
+        @remainder += @clock_hz
+        cycles = @remainder / @rate
+        @remainder -= cycles * @rate
+        cycles
+      end
+    end
+  end
+end

data/lib/badline/machine.rb

@@ -2,6 +2,7 @@
 
 require "badline/machine/clocking"
 require "badline/machine/keyboard_buffer"
+require "badline/machine/line_sound"
 require "badline/machine/settling"
 
 module Badline
@@ -58,6 +59,11 @@ module Badline
   # and +capture_output+, and besides +model_label+, +cartridge_slots+ and
   # +detach_cartridges+ for its two cartridges.
   #
+  # The KIM-1 answers the identity, clocking, lifecycle and sound parts,
+  # with no video chip: a front end draws its panel (KIM1::Panel), and
+  # #true_drive is nil. Its keys are the panel's, through +press_key+,
+  # +release_key+, +type_keys+, +press_stop+ and +press_reset+.
+  #
   # 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+,
@@ -69,22 +75,26 @@ module Badline
     # Media the machine named doesn't take.
     class Unsupported < ArgumentError; end
 
-    # A new machine of `family`, :c64, :vic20, :c128, :plus4, :pet or :cbm2, the
+    # A new machine of `family`, :c64, :vic20, :c128, :plus4, :pet, :cbm2 or :kim1, 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
+    # A VIC-20's is "pal" or "ntsc", 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. A PET's is one of PET::Model::ALL, with its own
-    # RAM and ROMs, its CRTC's editor the 50 Hz one. A CBM-II's is one of
+    # RAM and ROMs, its CRTC's editor the 50 Hz one, the superpet a
+    # PET::SuperPET with its CPU switch at 6502. A CBM-II's is one of
     # CBM2::Model::ALL, with VICE's KERNAL, 901244-04a, at 50 Hz, or a 510,
-    # one of CBM2::P500::Model::ALL, with its region's mains.
+    # one of CBM2::P500::Model::ALL, with its region's mains. A KIM-1 is
+    # the one model, with the RAM `ram` names
+    # (KIM1::Bus::RAM_CONFIGURATIONS), 1K when nil.
     def self.build(family, model:, sid_model: nil, reu: nil, ram: nil)
+      return KIM1.new(ram:) if family == :kim1
       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
+      return model == "superpet" ? PET::SuperPET.new : PET.new(model:) if family == :pet
       return CBM2::P500.new(model:) if family == :cbm2 && model.start_with?("510")
       return CBM2.new(model:) if family == :cbm2
       raise ArgumentError, "no machine family named #{family}" unless family == :c64
@@ -110,6 +120,7 @@ module Badline
       return plus4_for(media, options) if family == :plus4
       return pet_for(media, options) if family == :pet
       return cbm2_for(media, options) if family == :cbm2
+      return kim1_for(media, options) if family == :kim1
 
       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
@@ -119,11 +130,7 @@ module Badline
       machine
     end
 
-    def self.vic20(model, ram)
-      raise ArgumentError, "no VIC-20 model named #{model}" unless model == "pal"
-
-      Vic20.new(ram: ram || :unexpanded)
-    end
+    def self.vic20(model, ram) = Vic20.new(ram: ram || :unexpanded, model:)
     private_class_method :vic20
 
     def self.c128(model, sid_model, mode) = C128.new(model:, sid_model:, mode:)
@@ -160,27 +167,51 @@ module Badline
     # 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, the ROMs --basic, --editor and --characters fit it
-    # with, and the 8296 board's jumpers --jumpers names.
+    # with, the 8296 board's jumpers --jumpers names, and the true drive
+    # --drive-type names. The SuperPET takes the frame rate, the 8032's
+    # BASIC and editors, the true drive, the CPU --cpu names and the bank
+    # RAM switch --bank-ram sets, and with the 6809 disks alone.
     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
 
+      if options.model == "superpet"
+        disk = media.nil? || File.directory?(media) || %i[disk ieee_disk].include?(Media::Extensions.kind(media))
+        raise Unsupported, "doesn't go in the SuperPET's 6809 side" unless disk || options.cpu == "6502"
+
+        return PET::SuperPET.new(refresh_hz: options.refresh_hz, basic: options.basic, editor: options.editor,
+                                 cpu: options.cpu, bank_ram: options.bank_ram, true_drive_model: options.drive_type)
+      end
+
       PET.new(model: options.model, ram_kb: options.ram_kb, refresh_hz: options.refresh_hz, basic: options.basic,
-              editor: options.editor, characters: options.characters, jumpers: options.jumpers)
+              editor: options.editor, characters: options.characters, jumpers: options.jumpers,
+              true_drive_model: options.drive_type)
     end
     private_class_method :pet_for
 
     # A CBM-II with the KERNAL --kernal names, on the mains --60hz asks
-    # for: a B series' 50 Hz without it, and a P500's its region's.
+    # for: a B series' 50 Hz without it, and a P500's its region's, and
+    # the true drive --drive-type names.
     def self.cbm2_for(media, options)
       unsupported = !media.nil? && Media::CBM2Media::UNSUPPORTED.include?(File.extname(media).downcase)
       raise Unsupported, "doesn't go in a CBM-II" if unsupported
-      return CBM2::P500.new(model: options.model, mains_hz: options.mains_hz) if options.p500?
 
-      CBM2.new(model: options.model, kernal: options.kernal, mains_hz: options.mains_hz || 50)
+      drive = options.drive_type
+      return CBM2::P500.new(model: options.model, mains_hz: options.mains_hz, true_drive_model: drive) if options.p500?
+
+      CBM2.new(model: options.model, kernal: options.kernal, mains_hz: options.mains_hz || 50, true_drive_model: drive)
     end
     private_class_method :cbm2_for
 
+    # A KIM-1 with the RAM --ram names, on a teletype at --baud with
+    # --tty, for media it takes (Media::KIM1Media).
+    def self.kim1_for(media, options)
+      raise Unsupported, "doesn't go in a KIM-1" unless media.nil? || Media::KIM1Media.takes?(media)
+
+      KIM1.new(tty: options.tty?, baud: options.baud, ram: options.ram)
+    end
+    private_class_method :kim1_for
+
     def self.c64_media?(media)
       return false if media.nil? || !File.file?(media)
 

data/lib/badline/media/extensions.rb

@@ -7,17 +7,21 @@ 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
+    # - :ieee_disk, an 8050's, 8250's or 2040's disk image, for a PET's
+    #   IEEE-488 drive
+    # - :hard_disk, a D9060's or D9090's hard disk, which only a PET's or a
+    #   CBM-II's true drive reads
     # - :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
+    # - :papertape, a MOS papertape, which only the KIM-1 loads
     # - :disk_list, a list of the disks of a set (DiskList)
     module Extensions
       KINDS = {
         ".d64" => :disk, ".d71" => :disk, ".d81" => :disk, ".g64" => :gcr, ".g71" => :gcr, ".t64" => :archive,
-        ".d80" => :ieee_disk, ".d82" => :ieee_disk, ".tap" => :tape, ".crt" => :cartridge, ".sid" => :tune,
-        ".m3u" => :disk_list, ".vfl" => :disk_list
+        ".d80" => :ieee_disk, ".d82" => :ieee_disk, ".d67" => :ieee_disk, ".d90" => :hard_disk, ".tap" => :tape,
+        ".crt" => :cartridge, ".sid" => :tune, ".m3u" => :disk_list, ".vfl" => :disk_list, ".ptp" => :papertape,
+        ".pap" => :papertape
       }.freeze
 
       # The kind of the medium at `path`, by its extension.