badline 0.1.0 → 0.2.0

data/lib/badline/kernal_trap/channel.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Badline
+  module KernalTrap
+    # One open channel on the virtual drive, holding a file, a block buffer
+    # or the command channel's status message. It gives out one byte at a
+    # time and flags the last one, so the bus can raise EOI with it.
+    class Channel
+      attr_accessor :pointer
+
+      def initialize(bytes = [])
+        replace(bytes)
+      end
+
+      def replace(bytes)
+        @bytes = bytes
+        @pointer = 0
+      end
+
+      def exhausted?
+        @pointer >= @bytes.length
+      end
+
+      def read
+        return if exhausted?
+
+        byte = @bytes[@pointer]
+        @pointer += 1
+        [byte, exhausted?]
+      end
+    end
+  end
+end

data/lib/badline/kernal_trap/drive.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+module Badline
+  module KernalTrap
+    # The CBM DOS side of the serial bus. Keeps the open channels, the
+    # command channel and its status message. `U1` reads a raw block into a
+    # buffer channel, which is how block-access loaders bypass the KERNAL's
+    # LOAD.
+    class Drive
+      COMMAND_CHANNEL = 15
+      BLOCK_SIZE = 256
+
+      OK = 0
+      WRITE_PROTECT_ON = 26
+      SYNTAX_ERROR = 30
+      FILE_NOT_FOUND = 62
+      ILLEGAL_TRACK_OR_SECTOR = 66
+      NO_CHANNEL = 70
+      DRIVE_NOT_READY = 74
+
+      MESSAGES = {
+        OK => " OK",
+        20 => "READ ERROR",
+        21 => "READ ERROR",
+        22 => "READ ERROR",
+        23 => "READ ERROR",
+        24 => "READ ERROR",
+        25 => "WRITE ERROR",
+        WRITE_PROTECT_ON => "WRITE PROTECT ON",
+        27 => "READ ERROR",
+        28 => "WRITE ERROR",
+        29 => "DISK ID MISMATCH",
+        SYNTAX_ERROR => "SYNTAX ERROR",
+        FILE_NOT_FOUND => "FILE NOT FOUND",
+        ILLEGAL_TRACK_OR_SECTOR => "ILLEGAL TRACK OR SECTOR",
+        NO_CHANNEL => "NO CHANNEL",
+        DRIVE_NOT_READY => "DRIVE NOT READY"
+      }.freeze
+
+      MEMORY_COMMANDS = { "M-W" => :memory_write, "M-R" => :memory_read }.freeze
+
+      RAM_SIZE = 0x800
+
+      # The job queue: a job code for each of five buffers at $00, their
+      # track and sector pairs from $06, and the buffers from $0300. A job
+      # code is replaced by its result, 1 for success or an error table
+      # code: the DOS error less 18, or 15 for DRIVE NOT READY.
+      JOBS = 5
+      READ_JOB = 0x80
+      JOB_OK = 1
+      HEADER_NOT_FOUND = 20
+
+      COMMANDS = {
+        /\AU[1A]\s*:?\s*(.*)/i => :block_read,
+        /\AB-R\s*:?\s*(.*)/i => :counted_block_read,
+        /\AB-P\s*:?\s*(.*)/i => :buffer_pointer,
+        /\A[IV]/i => :initialized,
+        /\A(?:U[2B]|B-[WAF])/i => :write_protected
+      }.freeze
+
+      def initialize(storage)
+        @storage = storage
+        @channels = {}
+        @status = Channel.new
+        @ram = Array.new(RAM_SIZE, 0)
+        report(OK)
+      end
+
+      # A name on the command channel is a command, "#" opens a block
+      # buffer, anything else opens a file for reading. The name comes as
+      # the bytes sent, because a memory command's arguments are binary.
+      def open(secondary, name)
+        if secondary == COMMAND_CHANNEL
+          command(name.bytes) unless name.empty?
+        elsif name.start_with?("#")
+          @channels[secondary] = Channel.new(Array.new(BLOCK_SIZE, 0))
+          report(OK)
+        else
+          open_file(secondary, Storage.ascii(name.bytes))
+        end
+      end
+
+      # Closing the command channel closes every other channel with it.
+      def close(secondary)
+        secondary == COMMAND_CHANNEL ? @channels.clear : @channels.delete(secondary)
+      end
+
+      def write(secondary, bytes)
+        return report(WRITE_PROTECT_ON) unless secondary == COMMAND_CHANNEL
+
+        command(bytes)
+      end
+
+      # Returns the next byte and whether it is the channel's last, or nil
+      # when there is nothing left to send.
+      def read(secondary)
+        secondary == COMMAND_CHANNEL ? read_status : @channels[secondary]&.read
+      end
+
+      private
+
+      def read_status
+        result = @status.read
+        report(OK) if result&.last
+
+        result
+      end
+
+      # Secondary addresses 0 and 1 are LOAD and SAVE, which look for a PRG
+      # file unless the name asks for another type. Other channels take any
+      # type the name doesn't pin down.
+      def open_file(secondary, name)
+        file, type = Storage.parse_name(name)
+        type ||= :prg if secondary < 2
+        data = @storage.read_file(file, type:)
+        @channels[secondary] = Channel.new(data || [])
+        report(data ? OK : FILE_NOT_FOUND)
+      end
+
+      def execute(text)
+        command = text.strip
+        pattern, action = COMMANDS.find { |candidate, _| candidate.match?(command) }
+        return report(SYNTAX_ERROR) unless action
+
+        send(action, arguments(pattern.match(command)[1]))
+      end
+
+      def arguments(text)
+        text.to_s.scan(/\d+/).map(&:to_i)
+      end
+
+      def command(bytes)
+        action = MEMORY_COMMANDS[bytes[0, 3].pack("C*")]
+        action ? send(action, bytes[3..]) : execute(Storage.ascii(bytes))
+      end
+
+      def block_read(arguments, counted: false)
+        channel, _drive, track, sector = arguments
+        buffer = @channels[channel]
+        return report(NO_CHANNEL) unless buffer
+        return report(DRIVE_NOT_READY) unless @storage.respond_to?(:read_block)
+
+        data = sector && @storage.read_block(track, sector)
+        return report(ILLEGAL_TRACK_OR_SECTOR, track, sector) unless data
+
+        buffer.replace(counted ? data[0, data[0] + 1] : data)
+        buffer.pointer = 1 if counted
+        report_block_error(track, sector)
+      end
+
+      # A block the image's error table marks bad still fills the buffer,
+      # but the read reports its error, which copy protection checks for.
+      def report_block_error(track, sector)
+        error = @storage.block_error(track, sector)
+        error ? report(error, track, sector) : report(OK)
+      end
+
+      # B-R takes the block's first byte as the index of its last one, and
+      # hands out the bytes from the second up to there.
+      def counted_block_read(arguments)
+        block_read(arguments, counted: true)
+      end
+
+      def buffer_pointer(arguments)
+        channel, position = arguments
+        buffer = @channels[channel]
+        return report(NO_CHANNEL) unless buffer
+
+        buffer.pointer = position.to_i
+        report(OK)
+      end
+
+      # M-W takes an address, a count and that many bytes. Writes past the
+      # RAM are dropped, since the rest of the address space is I/O and ROM.
+      def memory_write(arguments)
+        address = word(arguments)
+        arguments[3, arguments[2].to_i].to_a.each.with_index(address) do |byte, target|
+          @ram[target] = byte if target < RAM_SIZE
+        end
+        run_jobs
+        report(OK)
+      end
+
+      # M-R takes an address and a count, and answers on the command
+      # channel. Without a count, or with only the carriage return PRINT#
+      # ends a line with, it reads one byte. Only the RAM reads back.
+      def memory_read(arguments)
+        address = word(arguments)
+        count = arguments[2..] == ["\r".ord] ? 1 : arguments.fetch(2, 1)
+        count = BLOCK_SIZE if count.zero?
+        @status.replace(Array.new(count) { |i| @ram.fetch(address + i, 0) })
+        nil
+      end
+
+      def word(arguments)
+        arguments[0].to_i | (arguments[1].to_i << 8)
+      end
+
+      def run_jobs
+        JOBS.times do |job|
+          next unless @ram[job] == READ_JOB
+
+          track, sector = @ram[6 + (job * 2), 2]
+          @ram[job] = read_job(0x300 + (job * BLOCK_SIZE), track, sector)
+        end
+      end
+
+      def read_job(buffer, track, sector)
+        data = @storage.respond_to?(:read_block) && @storage.read_block(track, sector)
+        return job_result(HEADER_NOT_FOUND) unless data
+
+        @ram[buffer, BLOCK_SIZE] = data
+        job_result(@storage.block_error(track, sector))
+      end
+
+      def job_result(error)
+        return JOB_OK unless error
+
+        error == DRIVE_NOT_READY ? 15 : error - 18
+      end
+
+      def initialized(_arguments)
+        report(OK)
+      end
+
+      def write_protected(_arguments)
+        report(WRITE_PROTECT_ON)
+      end
+
+      def report(code, track = 0, sector = 0)
+        message = format("%<code>02d,%<message>s,%<track>02d,%<sector>02d\r",
+                         code:, message: MESSAGES.fetch(code),
+                         track: track.to_i, sector: sector.to_i)
+        @status.replace(message.bytes)
+        nil
+      end
+    end
+  end
+end

data/lib/badline/kernal_trap/file.rb

@@ -2,23 +2,18 @@
 
 module Badline
   module KernalTrap
-    class File
-      include IntegerHelper
-
-      DEVICE = 8
-
+    class File < Routine
       MISSING_FILENAME = 0x08
 
       def initialize(cpu:, bus:, storage:)
-        @cpu = cpu
-        @bus = bus
+        super(cpu:, bus:)
         @storage = storage
       end
 
       private
 
       def active?
-        @bus.io_port.kernal? && @bus.peek(0xba) == DEVICE
+        kernal? && @bus.peek(0xba) == DEVICE
       end
 
       # Filename pointer at $BB/$BC, length at $B7
@@ -27,28 +22,13 @@ module Badline
         bytes = Array.new(@bus.peek(0xb7)) do |i|
           @bus.peek((pointer + i) & 0xffff)
         end
-        strip_drive_prefix(Storage.ascii(bytes))
-      end
-
-      # CBM DOS drive prefix — "0:NAME" selects a drive, "@0:NAME" is
-      # save-with-replace
-      def strip_drive_prefix(name)
-        name.sub(/\A@?\d*:/, "")
+        Storage.strip_drive_prefix(Storage.ascii(bytes))
       end
 
       def error(code)
         @cpu.a = code
         @cpu.status.carry = true
       end
-
-      def return_to_caller
-        @cpu.program_counter = (uint16(pull_byte, pull_byte) + 1) & 0xffff
-      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/load.rb

@@ -14,10 +14,10 @@ module Badline
       def call
         return unless active?
 
-        name = filename
+        name, type = Storage.parse_name(filename)
         if name.empty?
           error(MISSING_FILENAME)
-        elsif (data = @storage.read_file(name))
+        elsif (data = @storage.read_file(name, type: type || :prg))
           deliver(data)
         else
           error(FILE_NOT_FOUND)

data/lib/badline/kernal_trap/routine.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Badline
+  module KernalTrap
+    # Base class for the PC traps on KERNAL routines. Holds the device
+    # number they answer for and the return that stands in for the trapped
+    # routine's RTS.
+    class Routine
+      include IntegerHelper
+
+      DEVICE = 8
+
+      def initialize(cpu:, bus:)
+        @cpu = cpu
+        @bus = bus
+      end
+
+      private
+
+      def kernal?
+        @bus.io_port.kernal?
+      end
+
+      def return_to_caller
+        @cpu.program_counter = (uint16(pull_byte, pull_byte) + 1) & 0xffff
+      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/save.rb

@@ -12,7 +12,7 @@ module Badline
       def call
         return unless active?
 
-        name = filename
+        name = Storage.parse_name(filename).first
         if name.empty?
           error(MISSING_FILENAME)
         else

data/lib/badline/kernal_trap/serial.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Badline
+  module KernalTrap
+    # 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.
+    class Serial < Routine
+      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
+
+      # ST bits at $90
+      EOI = 0x40
+      READ_TIMEOUT = 0x02
+
+      NO_DATA = [0x0d, EOI | READ_TIMEOUT].freeze
+
+      def initialize(cpu:, bus:, drive:)
+        super(cpu:, bus:)
+        @drive = drive
+        @listening = false
+        @talking = false
+        @listen_channel = nil
+        @talk_channel = nil
+        @frame = OPEN
+        @buffer = []
+      end
+
+      def install
+        ROUTINES.each do |address, routine|
+          @cpu.install_trap(address) { send(routine) if kernal? }
+        end
+        self
+      end
+
+      private
+
+      # Addressing the bus starts a new frame. The channel number arrives
+      # in the secondary address that follows.
+      def talk
+        @talk_channel = nil
+        @talking = @cpu.a == DEVICE
+        return_to_caller if @talking
+      end
+
+      def listen
+        @listen_channel = nil
+        @listening = @cpu.a == DEVICE
+        return_to_caller if @listening
+      end
+
+      def second
+        return unless @listening
+
+        @frame = @cpu.a & 0xf0
+        @listen_channel = @cpu.a & 0x0f
+        @buffer = []
+        return_to_caller
+      end
+
+      def tksa
+        return unless @talking
+
+        @talk_channel = @cpu.a & 0x0f
+        return_to_caller
+      end
+
+      def ciout
+        return unless @listening
+
+        @buffer << @cpu.a
+        @cpu.status.carry = false
+        return_to_caller
+      end
+
+      def unlisten
+        return unless @listening
+
+        @listening = false
+        deliver_frame
+        return_to_caller
+      end
+
+      def untalk
+        return unless @talking
+
+        @talking = false
+        return_to_caller
+      end
+
+      def acptr
+        return unless @talking
+
+        byte, status = received
+        @cpu.a = byte
+        update_status(status)
+        @cpu.status.carry = false
+        return_to_caller
+      end
+
+      def deliver_frame
+        return unless @listen_channel
+
+        case @frame
+        when OPEN then @drive.open(@listen_channel, @buffer.pack("C*"))
+        when CLOSE then @drive.close(@listen_channel)
+        else @drive.write(@listen_channel, @buffer)
+        end
+        @buffer = []
+      end
+
+      def received
+        byte, eoi = @drive.read(@talk_channel)
+        return NO_DATA unless byte
+
+        [byte, eoi ? EOI : 0]
+      end
+
+      def update_status(bits)
+        return if bits.zero?
+
+        @bus.poke(0x90, @bus.peek(0x90) | bits)
+      end
+    end
+  end
+end

data/lib/badline/kernal_trap.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require "badline/kernal_trap/routine"
+require "badline/kernal_trap/channel"
+require "badline/kernal_trap/drive"
 require "badline/kernal_trap/file"
 require "badline/kernal_trap/load"
 require "badline/kernal_trap/save"
+require "badline/kernal_trap/serial"

data/lib/badline/keyboard.rb

@@ -1,6 +1,13 @@
 # frozen_string_literal: true
 
 module Badline
+  # The 8x8 key matrix spanning CIA 1's two ports: rows on port A, columns on
+  # port B.
+  #
+  # 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
+  # direction, and chains of keys sharing a line propagate the pulldown -- the
+  # ghost keys real hardware reports.
   class Keyboard
     include IntegerHelper
 
@@ -8,9 +15,10 @@ module Badline
 
     def initialize
       @keys = []
+      @row_masks = nil
 
       @matrix = [
-        %i[delete return cursor_h f7 f1 f3 cursor_v],
+        %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],
@@ -22,35 +30,51 @@ module Badline
     end
 
     def press(key)
-      @keys << key if valid_key?(key)
+      return unless valid_key?(key)
+
+      @keys << key
+      @row_masks = nil
     end
 
-    def read_a(_port_a, _port_b)
-      0xff
+    def release(key)
+      @keys.reject! { |k| k == key }
+      @row_masks = nil
     end
 
-    def read_b(port_a, _port_b)
-      return 0xff unless keys.any?
+    # Settles the row (port A) and column (port B) lines against each other
+    # until no key contact pulls a line low any more, and returns both.
+    def scan(rows, cols)
+      return [rows, cols] if keys.empty?
 
-      output = 0xff
+      loop do
+        settled_rows = rows
+        settled_cols = cols
 
-      matrix.each_with_index do |row, a|
-        next unless port_a[a].zero?
+        row_masks.each_with_index do |mask, row|
+          bit = 1 << row
+          next if mask.zero? || (rows.allbits?(bit) && cols.allbits?(mask))
 
-        row.each_with_index do |key, b|
-          output -= (1 << b) if keys.include?(key)
+          rows &= ~bit
+          cols &= ~mask
         end
-      end
 
-      output
+        return [rows, cols] if rows == settled_rows && cols == settled_cols
+      end
     end
 
-    def release(key)
-      @keys.reject! { |k| k == key }
-    end
+    def read_a(port_a, port_b) = scan(port_a, port_b).first
+
+    def read_b(port_a, port_b) = scan(port_a, port_b).last
 
     private
 
+    # Columns held down per row, as a bit mask of port B lines.
+    def row_masks
+      @row_masks ||= matrix.map do |row|
+        row.each_with_index.sum { |key, column| keys.include?(key) ? 1 << column : 0 }
+      end
+    end
+
     def valid_key?(key)
       matrix.flatten.include?(key)
     end