badline 0.8.0 → 0.10.0

data/lib/badline/kernal_trap/serial.rb

@@ -12,17 +12,6 @@ module Badline
     class Serial < Routine
       attr_accessor :device
 
-      ROUTINES = {
-        0xed09 => :talk,
-        0xed0c => :listen,
-        0xedb9 => :second,
-        0xedc7 => :tksa,
-        0xeddd => :ciout,
-        0xedef => :untalk,
-        0xedfe => :unlisten,
-        0xee13 => :acptr
-      }.freeze
-
       # Frame type in the high nibble of the secondary address
       OPEN = 0xf0
       CLOSE = 0xe0
@@ -34,8 +23,8 @@ module Badline
 
       NO_DATA = [0x0d, EOI | READ_TIMEOUT].freeze
 
-      def initialize(cpu:, bus:, drive:, device: DEVICE)
-        super(cpu:, bus:)
+      def initialize(cpu:, bus:, layout:, drive:, device: DEVICE)
+        super(cpu:, bus:, layout:)
         @drive = drive
         @device = device
         @listening = false
@@ -63,14 +52,27 @@ module Badline
       end
 
       def install
-        ROUTINES.each do |address, routine|
-          @cpu.install_trap(address) { call_routine(routine) if kernal? }
+        routines.each do |address, routine|
+          @cpu.install_trap(address) { call_routine(routine) if kernal_mapped? }
         end
         self
       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
@@ -85,17 +87,24 @@ module Badline
       end
 
       # Addressing the bus starts a new frame. The channel number arrives
-      # in the secondary address that follows.
+      # in the secondary address that follows. Each byte sent under ATN,
+      # and each byte of a frame, times its handshake with the serial timer
+      # as ISOUR does.
       def talk
         @talk_channel = nil
         @talking = @cpu.a == @device
-        return_to_caller if @talking
+        sent_under_atn if @talking
       end
 
       def listen
         @listen_channel = nil
         @listening = @cpu.a == @device
-        return_to_caller if @listening
+        sent_under_atn if @listening
+      end
+
+      def sent_under_atn
+        time_serial_byte(ISOUR_TIMEOUT)
+        return_to_caller
       end
 
       def second
@@ -104,19 +113,22 @@ module Badline
         @frame = @cpu.a & 0xf0
         @listen_channel = @cpu.a & 0x0f
         @buffer = []
-        return_to_caller
+        sent_under_atn
       end
 
       def tksa
         return unless @talking
 
         @talk_channel = @cpu.a & 0x0f
-        return_to_caller
+        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
@@ -135,6 +147,7 @@ module Badline
 
         @listening = false
         deliver_frame
+        time_serial_byte(ISOUR_TIMEOUT)
         release_bus
       end
 
@@ -142,14 +155,14 @@ module Badline
         return unless @talking
 
         @talking = false
+        time_serial_byte(ISOUR_TIMEOUT)
         release_bus
       end
 
-      # UNLSN and UNTLK end by releasing ATN, the clock and the data line on
-      # CIA 2's port A, and leave the port's last read in the accumulator.
+      # 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
-        @bus.poke(0xdd00, @bus.peek(0xdd00) & 0xc7)
-        @cpu.a = @bus.peek(0xdd00) & 0xdf
+        @cpu.a = @layout.release_serial_lines(@bus)
         @cpu.status.negative = @cpu.a.anybits?(0x80)
         @cpu.status.zero = @cpu.a.zero?
         return_to_caller
@@ -159,6 +172,7 @@ module Badline
         return unless @talking
 
         byte, status = received
+        time_serial_byte(ACPTR_TIMEOUT)
         @cpu.a = byte
         update_status(status)
         @cpu.status.carry = false

data/lib/badline/kernal_trap.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "badline/kernal_trap/layout"
 require "badline/kernal_trap/routine"
 require "badline/kernal_trap/channel"
 require "badline/kernal_trap/drive"

data/lib/badline/keyboard.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module Badline
-  # The 8x8 key matrix spanning CIA 1's two ports: rows on port A, columns on
-  # port B.
+  # The key matrix spanning CIA 1's two ports: rows on port A, columns on
+  # port B. Row lines beyond the eighth sit above port A's bits in +rows+.
   #
   # A pressed key shorts its row line to its column line, so whichever side is
   # pulled low drags the other down with it. Scanning works in either
@@ -19,22 +19,25 @@ module Badline
       cursor_left: %i[lshift cursor_h]
     }.freeze
 
+    # The C64's wiring: one row of keys per port A line, in port B column
+    # order.
+    C64_MATRIX = [
+      %i[delete return cursor_h f7 f1 f3 f5 cursor_v],
+      %i[3 w a 4 z s e lshift],
+      %i[5 r d 6 c f t x],
+      %i[7 y g 8 b h u v],
+      %i[9 i j 0 m k o n],
+      %i[+ p l - . : @ ,],
+      %i[£ * ; clr_home rshift = up /],
+      %i[1 left control 2 space cbm q run_stop]
+    ].freeze
+
     attr_reader :keys, :matrix
 
-    def initialize
+    def initialize(matrix: C64_MATRIX)
       @keys = []
       @row_masks = nil
-
-      @matrix = [
-        %i[delete return cursor_h f7 f1 f3 f5 cursor_v],
-        %i[3 w a 4 z s e lshift],
-        %i[5 r d 6 c f t x],
-        %i[7 y g 8 b h u v],
-        %i[9 i j 0 m k o n],
-        %i[+ p l - . : @ ,],
-        %i[£ * ; clr_home rshift = up /],
-        %i[1 left control 2 space cbm q run_stop]
-      ]
+      @matrix = matrix
     end
 
     def press(key)

data/lib/badline/machine.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Badline
+  # = Machine
+  #
+  # The machines badline builds by family, as the command line's
+  # subcommand names them: the C64, Computer, and the VIC-20, Vic20.
+  #
+  # A machine answers what the front end, Media, the runners and the
+  # snapshots call on it:
+  #
+  # - Identity: +family+, the family it was built as.
+  # - Clocking: +run_cycles(n)+, +run_until(limit) { ... }+, +cycles+,
+  #   +on_init+ and +init_threshold+, the cycle its handlers run at.
+  # - Lifecycle: +reset!+ and +power_cycle!+.
+  # - Video: +video+, the chip the screen reads (+display+, +width+,
+  #   +dirty_lines+, +clear_dirty_lines!+ and +palette+), and +timing+, a
+  #   Timing.
+  # - Sound: +sound_source+, which answers +record(rate:)+,
+  #   +drain_samples+ and +model+.
+  # - Input: +keyboard+, +joystick1+, +joystick2+, +control_ports+,
+  #   +press_restore+ and +release_restore+.
+  # - Media: +ram+, +load_prg+, +type_text+, +mount+, +unmount+,
+  #   +mounted?+, +datasette+, +attach_cartridge+,
+  #   +press_cartridge_button+, +release_cartridge_button+,
+  #   +attach_drive1541+, +drive1541+, and +address_bus+ for its
+  #   +cartridge+ and +detach_cartridge+.
+  # - Snapshots and tests: +snapshot+, +restore+, +save_snapshot+,
+  #   +install_debug_register+ and +capture_output+.
+  #
+  # The VIC-20 answers the identity, clocking, lifecycle, video, sound and
+  # input parts, with its one joystick as both +joystick1+ and +joystick2+
+  # and nil for +control_ports+, and of the rest +ram+, +load_prg+,
+  # +type_text+, +mount+, +unmount+, +mounted?+, +datasette+, +attach_cartridge+,
+  # +attach_drive1541+, +drive1541+, +install_debug_register+ and
+  # +capture_output+.
+  module Machine
+    # A new machine of `family`, :c64 or :vic20, 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.
+    def self.build(family, model:, sid_model: nil, reu: nil, ram: nil)
+      return vic20(model, ram) if family == :vic20
+      raise ArgumentError, "no machine family named #{family}" unless family == :c64
+
+      profile = Model.named(model)
+      Computer.new(vic_model: profile.vic_model, cia_model: profile.cia_model,
+                   sid_model: sid_model || profile.sid_model, region: profile.region, reu:,
+                   kernal: profile.kernal, datasette: profile.datasette)
+    end
+
+    def self.vic20(model, ram)
+      raise ArgumentError, "no VIC-20 model named #{model}" unless model == "pal"
+
+      Vic20.new(ram: ram || :unexpanded)
+    end
+    private_class_method :vic20
+  end
+end

data/lib/badline/media/disk_list.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # A list of the disks of a set: an .m3u playlist, one path a line, or
+    # a VICE .vfl flip list, whose paths follow a `UNIT 8` line. Paths are
+    # relative to the list or absolute, and blank lines and lines starting
+    # with # are skipped. Only the disk images the list names that are
+    # there count.
+    module DiskList
+      # A list naming no disk image that's there.
+      class Error < ArgumentError; end
+
+      EXTENSIONS = %w[.m3u .vfl].freeze
+
+      def self.list?(path) = EXTENSIONS.include?(File.extname(path).downcase)
+
+      # The disk `path` puts in the drive: a list's first disk, or the
+      # path itself.
+      def self.disk(path)
+        return path unless list?(path)
+
+        disks = disks(path)
+        raise Error, "#{path} lists no disk image that's there" if disks.empty?
+
+        disks.first
+      end
+
+      # The disk images the list names that are there, in its order.
+      def self.disks(list)
+        directory = File.dirname(list)
+        found = []
+        entries(list).each do |entry|
+          disk = entry.start_with?("/") ? entry : File.join(directory, entry)
+          found << disk if DiskSet::EXTENSIONS.include?(File.extname(disk).downcase) && File.file?(disk)
+        end
+        found
+      end
+
+      # The paths of the list's lines, only unit 8's for a .vfl, which
+      # starts on unit 8.
+      def self.entries(list)
+        flip = File.extname(list).casecmp?(".vfl")
+        unit = true
+        found = []
+        File.foreach(list) do |line|
+          text = line.strip
+          next if text.empty? || text.start_with?("#")
+
+          if flip && text.match?(/\AUNIT\s+\d+\z/i)
+            unit = text.split.last.to_i == 8
+          elsif unit
+            found << text
+          end
+        end
+        found
+      rescue SystemCallError
+        []
+      end
+
+      # The disks of the first list in the disk's folder that names it,
+      # with the disk as given, or none.
+      def self.beside(path)
+        directory = File.dirname(path)
+        own = File.expand_path(path)
+        lists = DiskSet.children(directory).sort.select { |name| list?(name) }
+        sets = lists.map { |name| disks(File.join(directory, name)) }
+        set = sets.find { |listed| listed.any? { |disk| File.expand_path(disk) == own } }
+        return [] if set.nil?
+
+        set.map { |disk| File.expand_path(disk) == own ? path : disk }
+      end
+    end
+  end
+end

data/lib/badline/media/disk_set.rb

@@ -8,16 +8,26 @@ module Badline
     # by those markers. A name with no marker can end in a number or a
     # letter, as in game_1.d64 and game_2.d64, which counts only when the
     # folder has the first of the set too.
+    #
+    # A list in the disk's folder that names it (DiskList) gives its set
+    # ahead of the names.
     module DiskSet
       KINDS = %w[disk disc side part].freeze
       EXTENSIONS = %w[.d64 .d71 .d81 .g64].freeze
 
       # The paths of the set's disks in order, or just `path` when it
-      # belongs to none.
+      # belongs to none. A list's set is the disks it lists.
       def self.around(path)
-        extension = File.extname(path).downcase
-        return [path] unless EXTENSIONS.include?(extension)
+        return DiskList.disks(path) if DiskList.list?(path)
+        return [path] unless EXTENSIONS.include?(File.extname(path).downcase)
+
+        listed = DiskList.beside(path)
+        listed.empty? ? named(path) : listed
+      end
 
+      # The set of the disk's name.
+      def self.named(path)
+        extension = File.extname(path).downcase
         marked = !parse(stem(path))[1].negative?
         base = key(stem(path), marked)[0]
         found = siblings(File.dirname(path), extension, base, marked)

data/lib/badline/media/vic20_basic.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # A program loading into a VIC-20 once it has booted (Vic20Media).
+    module Vic20Basic
+      # Where BASIC starts with each RAM expansion it can start in, as
+      # TXTTAB holds it.
+      BASIC_STARTS = { 0x1001 => :unexpanded, 0x0401 => :"3k", 0x1201 => :"8k" }.freeze
+
+      class << self
+        # A BASIC program, one that loads at a start of BASIC or a byte
+        # ahead of it, goes to this machine's start of BASIC. Anything else
+        # goes where it says, and doesn't RUN.
+        def load_program(machine, data, autostart:)
+          load_addr = data[0] | (data[1] << 8)
+          basic_start = machine.basic_start
+          ahead = [0, 1].find { |offset| BASIC_STARTS.key?(load_addr + offset) || load_addr + offset == basic_start }
+          return machine.load_prg(data) unless ahead
+
+          load_basic(machine, data, basic_start - ahead, load_addr)
+          machine.type_text("run\r") if autostart
+        end
+
+        private
+
+        # Puts a BASIC program at `address`, relinking its lines when that
+        # isn't where it was saved from, as BASIC's LOAD does, and sets the
+        # end of the program, where BASIC's variables start, and the end
+        # address the KERNAL's LOAD leaves.
+        def load_basic(machine, data, address, saved_at)
+          ram = machine.ram
+          ram.write(address, data[2..])
+          end_addr = address + data.length - 2
+          relink(ram, machine.basic_start, end_addr) unless address == saved_at
+          [0x2d, 0xae].each { |pointer| ram.write(pointer, [end_addr & 0xff, end_addr >> 8]) }
+        end
+
+        # Points each line's link at the line after it, as BASIC's LINKPRG
+        # does: past the zero that ends the line's text. A link with a zero
+        # high byte ends the program.
+        def relink(ram, line, end_addr)
+          while line + 4 < end_addr && ram.peek(line + 1).positive?
+            following = line + 4
+            following += 1 while following < end_addr && ram.peek(following).positive?
+            following += 1
+            ram.write(line, [following & 0xff, following >> 8])
+            line = following
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/media/vic20_cartridge.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # A VIC-20 cartridge kept as programs, one per ROM chip, each loading
+    # at the block the chip goes in. The chip in BLK5 at $A000 starts the
+    # cartridge, and a bigger cartridge has more in BLK1 to BLK3. The files
+    # of one cartridge share a name, with each block's address in its
+    # extension (game.a0, game.60) or its name (game-a000.prg,
+    # game-6000.prg).
+    module Vic20Cartridge
+      BLOCKS = [0xa000, 0x2000, 0x4000, 0x6000].freeze
+
+      class << self
+        # The ROM chips, as CRTFile::Chips, of the cartridge `data`, the
+        # program at `path`, is a part of, or nil when it isn't one: a
+        # program loading at $A000, or one loading at the start of BLK1 to
+        # BLK3 with an $A000 part beside it.
+        def chips(path, data)
+          own = load_address(data)
+          return unless BLOCKS.include?(own)
+
+          parts = BLOCKS.filter_map { |address| address == own ? data : part(path, own, address) }
+          return unless parts.any? { |part| load_address(part) == 0xa000 }
+
+          parts.map { |part| rom_chip(part) }
+        end
+
+        # A program's bytes, unwrapped from a .p00.
+        def program_bytes(path)
+          bytes = File.binread(path).bytes
+          Storage::P00.wraps?(bytes) ? Storage::P00.data(bytes) : bytes
+        end
+
+        private
+
+        def load_address(data)
+          data[0] | (data[1] << 8) if data.length > 2
+        end
+
+        def part(path, own, address)
+          name = part_names(path, own, address).find { |candidate| File.file?(candidate) }
+          return unless name
+
+          part = program_bytes(name)
+          part if load_address(part) == address
+        end
+
+        # `path` with the block at `own` in its extension or its name
+        # swapped for the one at `address`, its letters in either case.
+        def part_names(path, own, address)
+          extension = File.extname(path)
+          base = path[0, path.length - extension.length]
+          own_tag = own.to_s(16)
+          tags = [address.to_s(16), address.to_s(16).upcase].uniq
+          return tags.map { |tag| "#{base}.#{tag[0, 2]}" } if extension.downcase == ".#{own_tag[0, 2]}"
+
+          name = File.basename(base)
+          at = name.downcase.index(own_tag)
+          return [] unless at
+
+          tags.map { |tag| File.join(File.dirname(base), name[0, at] + tag + name[(at + 4)..]) + extension }
+        end
+
+        # A ROM chip of whole pages, the last padded with $FF.
+        def rom_chip(part)
+          data = part[2..]
+          data += [0xff] * (-data.length % 0x100)
+          Storage::CRTFile::Chip.new(chip_type: 0, bank: 0, address: load_address(part), data:)
+        end
+      end
+    end
+  end
+end

data/lib/badline/media/vic20_media.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    # Media on a VIC-20. A program loads once the KERNAL has booted: a
+    # BASIC program at the start of BASIC, wherever the RAM puts it, and
+    # RUNs. A program that loads into BLK5 at $A000 is a cartridge's ROM
+    # instead, as are the parts of a set that includes one
+    # (Vic20Cartridge), and goes in with a power cycle, as a .crt does.
+    # Disks mount on device 8 through the KERNAL traps, or go in a true
+    # 1541 (TrueDrive), and tapes play on the datasette.
+    module Vic20Media
+      # The expansions that fill BLK1, BLK2 and BLK3 one block after
+      # another, each with the last address it fills.
+      BLOCK_EXPANSIONS = [[0x3fff, :"8k"], [0x5fff, :"16k"], [0x7fff, :"24k"]].freeze
+
+      # What a VIC-20 doesn't take.
+      UNSUPPORTED = %w[.sid].freeze
+
+      # The platform byte of a VIC-20 tape (Storage::TAP#platform).
+      TAPE_PLATFORM = 1
+
+      class << self
+        def attach(machine, path, autostart:, **options)
+          extension = File.extname(path).downcase
+          raise ArgumentError, "#{path} doesn't go in a VIC-20" if UNSUPPORTED.include?(extension)
+
+          if TrueDrive.takes?(machine, path)
+            attach_true_drive(machine, path, options.fetch(:disk, {}), autostart:)
+          elsif File.directory?(path)
+            machine.mount(Storage::HostDirectory.new(path))
+            "Mounted #{path} as device 8"
+          elsif extension == ".crt"
+            attach_cartridge(machine, path, Storage::CRTFile.new(path, machine: :vic20).chips)
+          elsif extension == ".tap"
+            attach_tape(machine, path, autostart:)
+          elsif MOUNT_TYPES.key?(extension)
+            attach_storage(machine, path, options.fetch(:disk, {}), autostart:)
+          else
+            attach_prg(machine, path, autostart:)
+          end
+        end
+
+        # The RAM expansion (Vic20::Bus::RAM_CONFIGURATIONS) a VIC-20 needs
+        # for the program at `path`, or for the first program on the disk
+        # or in the directory there, by where it loads. A BASIC program
+        # needs the expansion its start of BASIC comes with, and more of
+        # BLK1 to BLK3 when it runs past $3FFF. So does a machine-language
+        # program loading into those blocks. Anything else, cartridges
+        # included, runs unexpanded.
+        def ram_for(path)
+          data = first_program(path)
+          return :unexpanded unless data && data.length > 2 && !Vic20Cartridge.chips(path, data)
+
+          load_addr = data[0] | (data[1] << 8)
+          if load_addr == 0x1201 || load_addr.between?(0x2000, 0x7fff)
+            expansion_reaching(load_addr + data.length - 3)
+          else
+            Vic20Basic::BASIC_STARTS.fetch(load_addr, :unexpanded)
+          end
+        end
+
+        private
+
+        def expansion_reaching(last)
+          BLOCK_EXPANSIONS.each { |reach, ram| return ram if last <= reach }
+          BLOCK_EXPANSIONS.last.last
+        end
+
+        def first_program(path)
+          extension = File.extname(path).downcase
+          if File.directory?(path) || MOUNT_TYPES.key?(extension)
+            open_storage(path).read_file("*")
+          elsif File.file?(path) && !%w[.sid .crt .tap .g64].include?(extension)
+            Vic20Cartridge.program_bytes(path)
+          end
+        end
+
+        def open_storage(path, disk = {})
+          return Storage::HostDirectory.new(path) if File.directory?(path)
+
+          storage = MOUNT_TYPES.fetch(File.extname(path).downcase)
+          storage < Storage::DiskImage ? storage.new(path, **disk) : storage.new(path)
+        end
+
+        def attach_cartridge(machine, path, chips)
+          machine.attach_cartridge(chips)
+          "Attached cartridge #{path}"
+        end
+
+        # A tape made for another machine plays all the same, and says so.
+        def attach_tape(machine, path, autostart:)
+          tape = Storage::TAP.new(path)
+          machine.datasette.insert(tape)
+          machine.datasette.play!
+          machine.type_text(TAPE_AUTOSTART) if autostart
+          message = "Inserted #{path} in the datasette"
+          tape.platform == TAPE_PLATFORM ? message : "#{message}, a tape for another machine than the VIC-20"
+        end
+
+        def attach_true_drive(machine, path, disk, autostart:)
+          message = TrueDrive.insert(machine, path, read_only: disk.fetch(:read_only, false))
+          machine.type_text(disk_autostart(first_program(path))) if autostart
+          message
+        end
+
+        def attach_storage(machine, path, disk, autostart:)
+          storage = open_storage(path, disk)
+          machine.mount(storage)
+          machine.type_text(disk_autostart(storage.read_file("*"))) if autostart
+          "Mounted #{path} as device 8"
+        end
+
+        # A BASIC program loads relocated to the start of BASIC, and anything
+        # else where it says.
+        def disk_autostart(data)
+          basic = data && data.length > 2 && Vic20Basic::BASIC_STARTS.key?(data[0] | (data[1] << 8))
+          basic ? %(lO"*",8\rrun\r) : AUTOSTART
+        end
+
+        def attach_prg(machine, path, autostart:)
+          bytes = Vic20Cartridge.program_bytes(path)
+          chips = Vic20Cartridge.chips(path, bytes)
+          return attach_cartridge(machine, path, chips) if chips
+
+          machine.on_init { Vic20Basic.load_program(machine, bytes, autostart:) }
+          "Loading #{path}"
+        end
+      end
+    end
+  end
+end