badline 0.17.0 → 0.19.0

data/lib/badline/media/kim1_media.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # What a KIM-1 loads (Media.attach): a MOS papertape, a .ptp or .pap
+    # (Storage::Papertape), at the addresses its records give, or a .bin
+    # of bare bytes, which says nothing of where it goes, at its Loading's
+    # load address.
+    #
+    # Once the monitor runs, the bytes go straight into memory, after
+    # the NMI and IRQ vectors at $17FA and $17FE, which nothing sets at
+    # power-on, are pointed at the monitor's $1C00, so ST and BRK stop
+    # the program and show where (User Manual, section 4.1). A papertape
+    # can go in through the teletype instead, as the monitor's L command
+    # reads it, in real time. The program then starts at its Loading's
+    # start address, or else where it loads, as the user would start it:
+    # AD, the address and GO on the keypad, or the address, a space and G
+    # on the teletype. Without autostart the monitor stops at the
+    # address.
+    #
+    # A .wav, a recording of a KIM tape (Storage::KIMTape), goes in the
+    # cassette deck, for the monitor's LOADT to read once PLAY is down.
+    module KIM1Media
+      PAPERTAPES = Extensions.of(%i[papertape])
+
+      # A .bin, bare bytes.
+      BINARY = ".bin"
+
+      # A recording of a tape.
+      TAPE = ".wav"
+
+      # What a KIM-1 takes.
+      EXTENSIONS = (PAPERTAPES + [BINARY, TAPE]).freeze
+
+      # Where a .bin loads without a load address, as most of the First
+      # Book of KIM's programs do.
+      DEFAULT_LOAD_ADDRESS = 0x0200
+
+      # Where the monitor saves the registers and shows the PC, for the
+      # NMI and IRQ vectors.
+      MONITOR = 0x1c00
+
+      NMI_VECTOR = 0x17fa
+      IRQ_VECTOR = 0x17fe
+
+      # How a KIM-1 loads and starts a program: at `load_address`, a .bin's,
+      # or -1 for DEFAULT_LOAD_ADDRESS, from `start_address`, or -1 for
+      # where it loads, and through the teletype's L command if
+      # `teletype`.
+      class Loading
+        attr_reader :load_address, :start_address
+
+        def initialize(load_address: -1, start_address: -1, teletype: false)
+          @load_address = load_address
+          @start_address = start_address
+          @teletype = teletype
+        end
+
+        def teletype? = @teletype
+      end
+
+      # Loads straight into memory, from where it loads.
+      DIRECT = Loading.new
+
+      class << self
+        # The Loading the command line's `options` ask for, with
+        # --load-address, --start-address and --tty-load.
+        def loading(options)
+          load_address = options.load_address
+          start_address = options.start_address
+          Loading.new(load_address: load_address.nil? ? -1 : load_address,
+                      start_address: start_address.nil? ? -1 : start_address, teletype: options.tty_load?)
+        end
+
+        # Whether a KIM-1 takes the file at `path`.
+        def takes?(path) = EXTENSIONS.include?(File.extname(path).downcase)
+
+        # Loads the program at `path` into the KIM-1 `machine` as
+        # `loading` says, and starts it if `autostart`. Raises
+        # Machine::Unsupported when it loads outside the RAM.
+        def attach(machine, path, loading, autostart:)
+          raise Machine::Unsupported, "doesn't go in a KIM-1" unless takes?(path)
+          return insert_tape(machine, path) if File.extname(path).downcase == TAPE
+
+          papertape = PAPERTAPES.include?(File.extname(path).downcase)
+          tape = papertape ? Storage::Papertape.read(path) : nil
+          records = tape.nil? ? [binary(path, loading.load_address)] : tape.records
+          refuse_outside_ram(machine, records)
+          start = loading.start_address.negative? ? records.first.address : loading.start_address
+          if !tape.nil? && loading.teletype? && machine.tty?
+            machine.teletype.type("L#{tape.text}")
+          else
+            machine.on_init { deposit(machine, records) }
+          end
+          machine.on_init { machine.type_text(start_keys(machine, start, autostart)) }
+          "Loading #{path} at $#{hex(records.first.address)}"
+        end
+
+        private
+
+        def insert_tape(machine, path)
+          machine.tape.insert_tape(Storage::KIMTape.read(path))
+          "Inserted #{path} in the tape deck"
+        end
+
+        def binary(path, load_address)
+          Storage::Papertape::Record.new(load_address.negative? ? DEFAULT_LOAD_ADDRESS : load_address,
+                                         File.binread(path).bytes)
+        end
+
+        def refuse_outside_ram(machine, records)
+          records.each do |record|
+            address = record.address
+            last = address + record.bytes.size - 1
+            raise Machine::Unsupported, "has no bytes to load" if last < address
+            next if last <= 0xffff && (address..last).all? { |byte_address| machine.bus.ram?(byte_address) }
+
+            raise Machine::Unsupported, "loads at $#{hex(address)}-$#{hex(last)}, outside the KIM-1's " \
+                                        "#{machine.bus.ram_kb}K of RAM; --ram 5k or --ram expanded adds more"
+          end
+        end
+
+        def deposit(machine, records)
+          [NMI_VECTOR, IRQ_VECTOR].each do |vector|
+            machine.poke(vector, MONITOR & 0xff)
+            machine.poke(vector + 1, MONITOR >> 8)
+          end
+          records.each do |record|
+            address = record.address
+            record.bytes.each_with_index { |byte, offset| machine.poke(address + offset, byte) }
+          end
+        end
+
+        # What starts the program at `start`, or stops at it without
+        # `autostart`.
+        def start_keys(machine, start, autostart)
+          if machine.tty?
+            opened = "#{hex(start)} "
+            return autostart ? "#{opened}G" : opened
+          end
+
+          keys = "AD #{hex(start).chars.join(' ')}"
+          autostart ? "#{keys} GO" : keys
+        end
+
+        def hex(value) = value.to_s(16).upcase.rjust(4, "0")
+      end
+    end
+  end
+end

data/lib/badline/media/pet_media.rb

@@ -27,8 +27,10 @@ module Badline
         # 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, which the block gives, goes in as a program file does,
-        # once the KERNAL has booted.
+        # once the KERNAL has booted. The SuperPET's 6809 starts its own
+        # menu instead.
         def disk_autostart(machine)
+          return unless machine.boots_basic?
           return machine.type_text(AUTOSTART) unless machine.model.basic1?
 
           data = yield

data/lib/badline/media/true_drive.rb

@@ -4,17 +4,22 @@ module Badline
   module Media
     # Device 8 as a true drive instead of the KERNAL traps: a 1541, or on
     # the C128 its 1571, or on the Plus/4 a 1551 if it asks for one, or a
-    # 1581, or on the PET or the CBM-II a 2031 on the IEEE-488 bus, or for
-    # a .d80 or .d82 an 8050 or 8250. Once a true drive is plugged in as device 8, disk media go into
-    # it rather than into the traps, so a LOAD runs the DOS and every byte
-    # crosses the serial bus or TCBM. A .g64 holds the
-    # disk's raw GCR, which only a true drive reads, so it plugs one in
-    # when there's none yet. The 1541 reads only .d64 and .g64 images, the
-    # 1571 .d71 and .g71 as well, and the 1581 only .d81, so a .d81 swaps
-    # the drive on device 8 for a 1581 (Drives::Model1581::Slot), and another disk
-    # image swaps a 1581 back for the machine's own drive. The PET and the
-    # CBM-II have no 1581, and their 2031 reads .d64 and .g64 images only.
-    # The traps' other disk media, a .t64 or a host directory, raise Error.
+    # 1581, or on the PET or the CBM-II a drive on the IEEE-488 bus. Once a
+    # true drive is plugged in as device 8, disk media go into it rather
+    # than into the traps, so a LOAD runs the DOS and every byte crosses the
+    # serial bus, TCBM or the IEEE-488 bus. A .g64 holds the disk's raw
+    # GCR, which only a true drive reads, so it plugs one in when there's
+    # none yet. The 1541 reads only .d64 and .g64 images, the 1571 .d71 and
+    # .g71 as well, and the 1581 only .d81, so a .d81 swaps the drive on
+    # device 8 for a 1581 (Drives::Model1581::Slot), and another disk image
+    # swaps a 1581 back for the machine's own drive. On the PET and
+    # the CBM-II an image goes in the drive on device 8 if it reads it, or
+    # else in a drive of the machine's own model, plug_true_drive's, if
+    # that reads it, or else in the model made for it, swapped in
+    # (Drives::IEEEModels): a 2031 for a .d64, an 8050 for a .d80 and an
+    # 8250 for a .d82, in the drive of a dual unit the machine names
+    # (disk_drive_number): drive 1 on a SuperPET running its 6809. The
+    # traps' other disk media, a .t64 or a host directory, raise Error.
     module TrueDrive
       class Error < ArgumentError; end
 
@@ -25,21 +30,31 @@ module Badline
         # Plugs the machine's true drive in as device 8, unless one is there
         # already, and returns it.
         def plug(computer)
+          refuse_portless(computer, "A true drive")
           drive(computer) || computer.plug_true_drive
         end
 
+        # Raises Machine::Unsupported over `what`, a disk or a drive, on a
+        # C64 whose board has no serial port to plug a drive into.
+        def refuse_portless(computer, what)
+          board = computer.portless_board
+          return if board.nil?
+
+          raise Machine::Unsupported, "#{what} needs the serial port, and #{board} has none"
+        end
+
         # The true drive on device 8, or nil.
         def drive(computer)
           drive = computer.true_drive
           drive if drive && drive.device == KernalTrap::Routine::DEVICE
         end
 
-        # Whether the path goes in a true drive: a .g64 or .g71 always, and
-        # other disk media, which the traps would mount, when a true drive
+        # Whether the path goes in a true drive: a .g64, .g71 or .d90 always,
+        # and other disk media, which the traps would mount, when a true drive
         # is device 8.
         def takes?(computer, path)
           kind = Extensions.kind(path)
-          return true if kind == :gcr
+          return true if %i[gcr hard_disk].include?(kind)
 
           !drive(computer).nil? && (File.directory?(path) || %i[disk archive ieee_disk].include?(kind))
         end
@@ -49,16 +64,13 @@ module Badline
         # mounted through the traps, so LOAD and SAVE reach the drive too.
         # `read_only` puts it in write-protected.
         def insert(computer, path, read_only: false)
-          swapped = insert_swapping(computer, path, read_only)
-          return swapped if swapped
+          return insert_ieee(computer, path, read_only) if IEEE_FAMILIES.include?(computer.family)
+          return insert_d81(computer, path, read_only) if File.extname(path).casecmp?(".d81")
 
-          pet = IEEE_FAMILIES.include?(computer.family)
           drive = own_drive(computer)
           name = drive&.model_name || default_model(computer)
           types = name == "1571" ? %w[.d64 .g64 .d71 .g71] : %w[.d64 .g64]
           unless types.include?(File.extname(path).downcase)
-            raise Error, "#{path} is not a #{types.join(' or ')} image, which the #{name} reads" if pet
-
             raise Error, "#{path} is not a #{types.join(', ')} or .d81 image, which the #{name} and the 1581 read"
           end
 
@@ -71,39 +83,34 @@ module Badline
         private
 
         # The model plug_true_drive plugs in.
-        def default_model(computer)
-          case computer.family
-          when :c128 then "1571"
-          when :pet, :cbm2 then "2031"
-          else "1541"
-          end
-        end
+        def default_model(computer) = computer.family == :c128 ? "1571" : "1541"
 
-        # The drive on device 8 unless it's a 1581, or an 8050 or 8250,
-        # which a .d64 swaps back out.
+        # The drive on device 8 unless it's a 1581, which a .d64 swaps back
+        # out.
         def own_drive(computer)
           drive = drive(computer)
-          drive unless %w[1581 8050 8250].include?(drive&.model_name)
+          drive unless drive&.model_name == "1581"
         end
 
-        # A .d81 in a 1581, and on the PET or the CBM-II a .d80 or .d82 in
-        # an 8050 or 8250, each swapped in for the drive there, or nil for
-        # the rest.
-        def insert_swapping(computer, path, read_only)
-          extension = File.extname(path).downcase
-          if IEEE_FAMILIES.include?(computer.family)
-            insert_d80(computer, path, read_only) if %w[.d80 .d82].include?(extension)
-          elsif extension == ".d81"
-            insert_d81(computer, path, read_only)
+        # The image in the model Drives::IEEEModels.taking picks, swapped in
+        # for the drive on device 8 unless it's that model already.
+        def insert_ieee(computer, path, read_only)
+          drive = drive(computer)
+          model = Drives::IEEEModels.taking(path, drive&.model_name, computer.true_drive_model)
+          unless model
+            name = computer.true_drive_model
+            types = Drives::IEEEModels::MEDIA.fetch(name)
+            raise Error, "#{path} is not a #{types.join(' or ')} image, which the #{name} reads"
+          end
+
+          drive = computer.plug_ieee_drive(model) unless drive&.model_name == model
+          number = computer.disk_drive_number
+          if number.positive? && drive.is_a?(Drives::Model8050)
+            drive.insert_image(path, drive: number, read_only:)
+            computer.unmount
+            return "Inserted #{path} in the #{model}'s drive #{number} as device 8"
           end
-        end
 
-        # An 8050 for a .d80 and an 8250 for a .d82, swapped in for the
-        # drive on device 8 unless it's that model already.
-        def insert_d80(computer, path, read_only)
-          model = File.extname(path).casecmp?(".d82") ? "8250" : "8050"
-          drive = drive(computer)
-          drive = computer.plug_drive8050(model) unless drive&.model_name == model
           drive.insert_image(path, read_only:)
           computer.unmount
           "Inserted #{path} in the #{model} as device 8"

data/lib/badline/media/vic20_media.rb

@@ -41,11 +41,13 @@ module Badline
         end
 
         # The program at `path`, or the first on the disk or in the
-        # directory there, or nil.
+        # directory there, or nil, as for a disk with no program on it.
         def first_program(path)
           kind = Extensions.kind(path)
-          if File.directory?(path) || %i[disk archive].include?(kind)
+          if File.directory?(path) || %i[disk archive ieee_disk].include?(kind)
             Media.open_storage(path).read_file("*")
+          elsif kind == :hard_disk
+            Storage::D90Image.new(path, read_only: true).read_file("*")
           elsif File.file?(path) && !%i[tune cartridge tape gcr].include?(kind)
             Media.program_bytes(path)
           end

data/lib/badline/media.rb

@@ -13,6 +13,7 @@ require "badline/media/vic20_media"
 require "badline/media/plus4_media"
 require "badline/media/pet_media"
 require "badline/media/cbm2_media"
+require "badline/media/kim1_media"
 require "badline/media/tune"
 require "badline/media/program"
 
@@ -29,7 +30,8 @@ module Badline
       ".d81" => Storage::D81Image,
       ".t64" => Storage::T64,
       ".d80" => Storage::D80Image,
-      ".d82" => Storage::D82Image
+      ".d82" => Storage::D82Image,
+      ".d67" => Storage::D67Image
     }.freeze
 
     class << self
@@ -56,8 +58,11 @@ module Badline
       # and .d82 disks too, which no other machine takes, and has no
       # cartridges, tunes or true drives (PETMedia), and so does the CBM-II,
       # which takes its own .crt cartridges and no tapes (CBM2Media). The
-      # C128 in C64 mode takes a C64's.
-      def attach(computer, path, autostart: true, subtune: nil, **)
+      # C128 in C64 mode takes a C64's. The KIM-1 takes only its programs,
+      # which load as `kim1`, a KIM1Media::Loading, says (KIM1Media).
+      def attach(computer, path, autostart: true, subtune: nil, kim1: KIM1Media::DIRECT, **)
+        return KIM1Media.attach(computer, path, kim1, autostart:) if computer.family == :kim1
+
         path = DiskList.disk(path)
         refuse_unsupported(computer, path)
 
@@ -75,6 +80,7 @@ module Badline
       # read, raise TrueDrive::Error, an ArgumentError. Anything else
       # raises NotDisk.
       def insert_disk(computer, path, read_only: false)
+        TrueDrive.refuse_portless(computer, path)
         return TrueDrive.insert(computer, path, read_only:) if TrueDrive.takes?(computer, path)
 
         raise NotDisk, "#{path} is not a disk image or a directory" unless disk?(path)
@@ -128,11 +134,15 @@ module Badline
       private
 
       # The VIC-20 and the 264 series have no SID to play a .sid tune on,
-      # and only the PET and the CBM-II have the IEEE-488 drive a .d80 or
-      # .d82 goes in.
+      # only the PET and the CBM-II have the IEEE-488 drive a .d80, .d82
+      # or .d90 goes in, and only the KIM-1 reads papertape. The C64GS and
+      # the MAX Machine have no serial port for what goes in device 8.
       def refuse_unsupported(computer, path)
         family = computer.family
-        if Extensions.kind(path) == :ieee_disk && !%i[pet cbm2].include?(family)
+        device8 = File.directory?(path) || Extensions::DEVICE8.include?(File.extname(path).downcase)
+        TrueDrive.refuse_portless(computer, path) if device8
+        raise Machine::Unsupported, "#{path} needs a KIM-1" if Extensions.kind(path) == :papertape
+        if %i[ieee_disk hard_disk].include?(Extensions.kind(path)) && !%i[pet cbm2].include?(family)
           raise ArgumentError, "#{path} needs a PET's or a CBM-II's IEEE-488 drive"
         end
 

data/lib/badline/memory.rb

@@ -46,10 +46,8 @@ module Badline
     end
 
     def zero_fill(initial)
-      array = initial.dup
-      0.upto(length - 1) do |i|
-        array[i] ||= blank_value
-      end
+      array = Array.new(length, blank_value)
+      initial.each_with_index { |v, i| array[i] = v.to_i unless v.nil? }
       array
     end
   end

data/lib/badline/options/family.rb

@@ -12,10 +12,94 @@ module Badline
       # Where C128 BASIC starts, which a program for the C128 loads at.
       C128_BASIC_START = 0x1c01
 
+      # Whether the KIM-1 talks to a teletype: with --tty or --tty-load,
+      # and always on the terminal with --headless.
+      def tty? = @tty || @tty_load || kim1_terminal?
+
+      # The KIM-1 teletype's baud.
+      def baud = @baud
+
+      # Whether the KIM-1 loads a papertape through its monitor's L
+      # command, with --tty-load.
+      def tty_load? = @tty_load
+
+      # Where the KIM-1 loads a .bin, and where it starts its program, as
+      # --load-address and --start-address give them, or nil.
+      def load_address = @load_address
+
+      def start_address = @start_address
+
+      # Whether the KIM-1 runs on the terminal, its teletype there.
+      def kim1_terminal? = @family == :kim1 && @headless
+
       private
 
-      # Takes `sid`, `c64`, `vic20`, `c128`, `plus4`, `pet` or `cbm2` when
-      # given first.
+      # The KIM-1's keypad, until --tty or --baud name its teletype, and
+      # its programs where they load.
+      def initialize_kim1
+        @tty = false
+        @tty_load = false
+        @baud = 9600
+        @load_address = nil
+        @start_address = nil
+      end
+
+      # The KIM-1 teletype's baud, and where it loads a .bin and starts a
+      # program.
+      def kim1_option(name, flag, value)
+        case name
+        when "--baud" then @baud = baud_for(value)
+        when "--load-address" then @load_address = address(flag, value)
+        else @start_address = address(flag, value)
+        end
+      end
+
+      def kim1_switch(name)
+        if name == "--tty"
+          @tty = true
+        else
+          @tty_load = true
+        end
+      end
+
+      # An address in hex, with or without a $ or 0x before it.
+      def address(flag, value)
+        digits = value.delete_prefix("$").delete_prefix("0x").delete_prefix("0X")
+        raise Error, "invalid argument: #{flag} #{value}" unless digits.match?(/\A[0-9a-fA-F]{1,4}\z/)
+
+        digits.to_i(16)
+      end
+
+      def kim1_ram(value)
+        raise Error, "invalid argument: --ram #{value}" unless KIM1_RAM.key?(value)
+
+        KIM1_RAM[value]
+      end
+
+      # The KIM-1 runs in the window, or with --headless on the terminal,
+      # without the C64's SID and REU. Only a papertape goes in through
+      # the teletype, and only a .bin has a load address to give.
+      def validate_kim1
+        raise Error, "--ntsc needs the C64" if @models.include?("ntsc")
+        raise Error, "--sid needs the C64" unless @sid_model.nil?
+        raise Error, "--reu needs the C64" unless @reu.nil?
+        raise Error, "--audio-out needs a .sid tune" unless @audio_out.nil?
+
+        extension = @media_path.nil? ? "" : File.extname(@media_path).downcase
+        raise Error, "--tty-load needs a .ptp or .pap" if @tty_load && !%w[.ptp .pap].include?(extension)
+        raise Error, "--load-address needs a .bin" unless @load_address.nil? || extension == ".bin"
+      end
+
+      # Only the KIM-1 has a teletype, and programs without a load address.
+      def refuse_kim1_options
+        raise Error, "#{@tty ? '--tty' : '--baud'} needs kim1" if @tty || @baud != 9600
+        raise Error, "--tty-load needs kim1" if @tty_load
+        raise Error, "--load-address needs kim1" unless @load_address.nil?
+        raise Error, "--start-address needs kim1" unless @start_address.nil?
+      end
+
+      # Takes `sid`, `c64`, `vic20`, `c128`, `plus4`, `pet`, `cbm2` or `kim1`
+      # when given first.
       def subcommand(args)
         case args.first
         when "sid" then @sid_command = true
@@ -25,6 +109,7 @@ module Badline
         when "plus4" then @family = :plus4
         when "pet" then @family = :pet
         when "cbm2" then @family = :cbm2
+        when "kim1" then @family = :kim1
         else return
         end
         @family_named = !@sid_command
@@ -38,18 +123,22 @@ module Badline
         when :plus4 then PLUS4_MODELS
         when :pet then PET_MODELS
         when :cbm2 then CBM2_MODELS
+        when :kim1 then KIM1_MODELS
         else MODELS
         end
       end
 
       # Without a family named, a program that loads at C128_BASIC_START is
-      # the C128's, an 8050's or 8250's disk or a PET tape the PET's, and a
-      # cartridge signed as a CBM-II's the CBM-II's. A program that loads
-      # where PET BASIC starts could be a VIC-20's too.
+      # the C128's, an 8050's or 8250's disk or a PET tape the PET's, a
+      # cartridge signed as a CBM-II's the CBM-II's, and a papertape the
+      # KIM-1'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? || !File.file?(@media_path)
 
-        if pet_media?
+        if Media::Extensions.kind(@media_path) == :papertape
+          @family = :kim1
+        elsif pet_media?
           @family = :pet
         elsif cbm2_cartridge?
           @family = :cbm2
@@ -63,10 +152,11 @@ module Badline
         Media::Extensions.kind(@media_path) == :cartridge && Storage::CRTFile.cbm2?(@media_path)
       end
 
-      # Whether the media is an 8050's or 8250's disk or a PET tape.
+      # Whether the media is an 8050's or 8250's disk, a D9060's or D9090's
+      # hard 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)
+        %i[ieee_disk hard_disk].include?(kind) || (kind == :tape && Storage::TAP.platform_of(@media_path) == Storage::TAP::PET_PLATFORM)
       end
     end
   end