badline 0.1.0 → 0.2.1

data/lib/badline/kernal_trap/drive.rb

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+require "badline/kernal_trap/drive/status"
+
+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
+      FILE_EXISTS = 63
+      ILLEGAL_TRACK_OR_SECTOR = 66
+      NO_CHANNEL = 70
+      DOS_VERSION = 73
+      DRIVE_NOT_READY = 74
+
+      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
+
+      # A U command jumps through the user table at $FFEA, indexed by the
+      # low nibble of its second character less one, so UA and UQ are U1.
+      # U1 and U2 read and write a block. U3 to U8 run code in the buffer
+      # at $0500, and the five entries past the table's end take vectors
+      # from the job queue. Neither runs here, so they report OK as a
+      # routine that returns does. U9 (UI) takes the NMI vector and U; the
+      # IRQ one, which restart the DOS with its RAM intact, except that a
+      # + or - after U9 only switches the bus speed. U: takes the reset
+      # vector, which runs the RAM test. U0 restores the table.
+      USER_TABLE = [:block_read, :write_protected, *[:initialized] * 6,
+                    :warm_reset, :cold_reset, :warm_reset, *[:initialized] * 5].freeze
+
+      COMMANDS = {
+        /\AU[9IY)][+-]/i => :initialized,
+        /\AU.\s*:?\s*(.*)/i => :user,
+        /\AB-R\s*:?\s*(.*)/i => :counted_block_read,
+        /\AB-P\s*:?\s*(.*)/i => :buffer_pointer,
+        /\A[IV]/i => :initialized,
+        /\AB-[WAF]/i => :write_protected
+      }.freeze
+
+      # A drive powers on reporting its DOS version, as a reset does.
+      def initialize(storage)
+        @storage = storage
+        @channels = {}
+        @status = Status.new
+        @ram = Array.new(RAM_SIZE, 0)
+        report(DOS_VERSION)
+      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 command(bytes) if secondary == COMMAND_CHANNEL
+
+        report(WRITE_PROTECT_ON) if listening?(secondary)
+      end
+
+      # Whether data sent on the channel reaches the drive. The command
+      # channel always listens, other channels once they are open.
+      def listening?(secondary)
+        secondary == COMMAND_CHANNEL || @channels.key?(secondary)
+      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)
+        return @status.read if secondary == COMMAND_CHANNEL
+
+        channel = @channels[secondary]
+        result = channel&.read
+        report(*channel.error) if result && channel.error && channel.exhausted?
+        result
+      end
+
+      private
+
+      # 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)
+        return refuse_write(secondary, name, file) if writing?(secondary, name)
+
+        type ||= :prg if secondary < 2
+        channel = @channels[secondary] = Channel.for_file(@storage, file, type)
+        channel.exhausted? && channel.error ? report(*channel.error) : report(OK)
+      end
+
+      # SAVE's secondary address 1 and a W mode open a file for writing.
+      def writing?(secondary, name)
+        secondary == 1 || name.split(",").drop(1).any? { |field| field.strip.match?(/\AW/i) }
+      end
+
+      # The disk is write-protected, so an open for writing fails and leaves
+      # the channel closed. A name already on the disk fails as FILE EXISTS
+      # unless @ asks to replace it, anything else as WRITE PROTECT ON.
+      def refuse_write(secondary, name, file)
+        @channels.delete(secondary)
+        return report(FILE_EXISTS) if !name.start_with?("@") && @storage.read_file(file, type: nil)
+
+        report(WRITE_PROTECT_ON, *protected_block(secondary))
+      end
+
+      # SAVE's channel fails at the directory block its entry would go to,
+      # a W mode open at the disk's header block.
+      def protected_block(secondary)
+        return [] unless @storage.respond_to?(:header_block)
+
+        secondary == 1 ? @storage.new_entry_block : @storage.header_block
+      end
+
+      def execute(text)
+        command = text.strip
+        pattern, action = COMMANDS.find { |candidate, _| candidate.match?(command) }
+        return report(SYNTAX_ERROR) unless action
+
+        action = USER_TABLE[(command.getbyte(1) - 1) & 0x0f] if action == :user
+        run_command(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 ? run_command(action, bytes[3..]) : execute(Storage.ascii(bytes))
+      end
+
+      def run_command(action, arguments)
+        case action
+        when :block_read then block_read(arguments)
+        when :counted_block_read then counted_block_read(arguments)
+        when :buffer_pointer then buffer_pointer(arguments)
+        when :initialized then report(OK)
+        when :write_protected then write_protected(arguments)
+        when :cold_reset then reset(cold: true)
+        when :warm_reset then reset(cold: false)
+        when :memory_write then memory_write(arguments)
+        when :memory_read then memory_read(arguments)
+        end
+      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 write_protected(_arguments)
+        report(WRITE_PROTECT_ON)
+      end
+
+      def reset(cold:)
+        @ram.fill(0) if cold
+        @channels.clear
+        report(DOS_VERSION)
+      end
+
+      def report(...) = @status.report(...)
+    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
+      def initialize(cpu:, bus:, storage: nil)
+        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

@@ -3,41 +3,112 @@
 module Badline
   module KernalTrap
     # PC trap on the KERNAL serial LOAD routine ($F4A5, the default ILOAD
-    # vector target). Serves device 8 requests from a storage backend and
-    # returns to the caller with the routine's register/zeropage contract;
-    # other devices fall through to the ROM.
+    # vector target). Reads device 8 requests from the virtual drive's
+    # channel 0, then hands over to the ROM's own tail so it prints
+    # SEARCHING FOR and LOADING (or VERIFYING) in direct mode, reports
+    # errors and returns with the routine's register/zeropage contract;
+    # other devices fall through to the ROM. So does a load that reaches
+    # below $0334, into the zero page, the stack or the KERNAL vectors: the
+    # ROM's byte loop then loads it through the serial traps, and a loader
+    # that overwrites ISTOP takes over mid-load as it does on a real drive.
     class Load < File
       ADDRESS = 0xf4a5
 
-      FILE_NOT_FOUND = 0x04
+      # ROM entry points: the SEARCHING FOR and LOADING/VERIFYING messages,
+      # the byte loop that retries a timed-out byte until RUN/STOP, the
+      # successful return (CLC, LDX $AE, LDY $AF, RTS) and the
+      # FILE NOT FOUND and MISSING FILE NAME error exits
+      SEARCHING_MESSAGE = 0xf5af
+      LOADING_MESSAGE = 0xf5d2
+      BYTE_LOOP = 0xf4f3
+      LOAD_DONE = 0xf5a9
+      FILE_NOT_FOUND_EXIT = 0xf704
+      MISSING_FILE_NAME_EXIT = 0xf710
+
+      # ST bits at $90
+      EOI = 0x40
+      VERIFY_MISMATCH = 0x10
+      READ_TIMEOUT = 0x02
+
+      def initialize(cpu:, bus:, drive:)
+        super(cpu:, bus:)
+        @drive = drive
+      end
 
       def call
         return unless active?
 
+        @bus.poke(0x93, @cpu.a)
+        @bus.poke(0x90, 0x00)
         name = filename
-        if name.empty?
-          error(MISSING_FILENAME)
-        elsif (data = @storage.read_file(name))
-          deliver(data)
+        return @cpu.program_counter = MISSING_FILE_NAME_EXIT if Storage.parse_name(name).first.empty?
+
+        data, complete = receive(name)
+        if low_memory?(data)
+          @drive.close(0)
         else
-          error(FILE_NOT_FOUND)
+          finish(data, complete)
         end
-        return_to_caller
       end
 
       private
 
-      # A=0 is LOAD, A=1 is VERIFY
+      # Reads the file the way the ROM's byte loop would, up to the byte
+      # flagged EOI. A read error in the file's chain stops the bytes early,
+      # with no EOI.
+      def receive(name)
+        @drive.open(0, name)
+        data = []
+        loop do
+          byte, eoi = @drive.read(0)
+          return [data, false] unless byte
+
+          data << byte
+          return [data, true] if eoi
+        end
+      end
+
+      # No first byte means the file isn't there, or its first block didn't
+      # read. A later read error leaves the ROM retrying the next byte
+      # until RUN/STOP breaks the load, as on a real drive.
+      def finish(data, complete)
+        if data.empty?
+          @bus.poke(0x90, EOI | READ_TIMEOUT)
+          continue_with(SEARCHING_MESSAGE, FILE_NOT_FOUND_EXIT)
+        else
+          deliver(data)
+          @bus.poke(0x90, @bus.peek(0x90) & ~EOI) unless complete
+          continue_with(SEARCHING_MESSAGE, LOADING_MESSAGE, complete ? LOAD_DONE : BYTE_LOOP)
+        end
+      end
+
+      def low_memory?(data)
+        load? && data.length > 2 && load_address(data) < 0x0334
+      end
+
+      # A=0 is LOAD, A=1 is VERIFY, kept at $93 (VERCK)
       def load?
-        @cpu.a.zero?
+        @bus.peek(0x93).zero?
       end
 
       def deliver(data)
         addr = load_address(data)
         payload = data[2..] || []
         payload = payload[0, 0x10000 - addr] if addr + payload.length > 0x10000
-        @bus.ram.write(addr, payload) if load?
-        finish((addr + payload.length) & 0xffff)
+        if load?
+          @bus.ram.write(addr, payload)
+          @bus.poke(0x90, EOI)
+        else
+          verify(addr, payload)
+        end
+        end_addr = (addr + payload.length) & 0xffff
+        @bus.poke(0xae, low_byte(end_addr))
+        @bus.poke(0xaf, high_byte(end_addr))
+      end
+
+      def verify(addr, payload)
+        match = payload.each_with_index.all? { |byte, i| @bus.peek(addr + i) == byte }
+        @bus.poke(0x90, match ? EOI : EOI | VERIFY_MISMATCH)
       end
 
       # Secondary address $B9 zero relocates to the caller-supplied address
@@ -46,18 +117,9 @@ module Badline
         if @bus.peek(0xb9).zero?
           uint16(@bus.peek(0xc3), @bus.peek(0xc4))
         else
-          uint16(data[0], data[1])
+          uint16(data[0], data[1].to_i)
         end
       end
-
-      def finish(end_addr)
-        @bus.poke(0x90, 0x40)
-        @bus.poke(0xae, low_byte(end_addr))
-        @bus.poke(0xaf, high_byte(end_addr))
-        @cpu.x = low_byte(end_addr)
-        @cpu.y = high_byte(end_addr)
-        @cpu.status.carry = false
-      end
     end
   end
 end

data/lib/badline/kernal_trap/routine.rb

@@ -0,0 +1,51 @@
+# 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
+
+      # 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/save.rb

@@ -5,25 +5,62 @@ module Badline
     # PC trap on the KERNAL serial SAVE routine ($F5ED, the default ISAVE
     # vector target). Writes device 8 saves to a storage backend as a PRG
     # (load address followed by the memory range); other devices fall
-    # through to the ROM.
+    # through to the ROM. The ROM prints SAVING in direct mode and returns
+    # into the trap, which then writes the file and leaves through the
+    # ROM's own tail with the registers its UNLISTEN and return leave. A
+    # host write that fails ends the way a 1541 ends a SAVE it can't
+    # write: the drive stops listening, so ST reads DEVICE NOT PRESENT,
+    # and the ROM returns without an error.
     class Save < File
       ADDRESS = 0xf5ed
 
+      # ROM entry points: the SAVING message, the two line releases that
+      # end UNLISTEN (clock, then data, leaving A as read from $DD00), the
+      # successful return (CLC, RTS) and the MISSING FILE NAME error exit
+      SAVING_MESSAGE = 0xf68f
+      CLOCK_RELEASE = 0xee85
+      DATA_RELEASE = 0xee97
+      SAVE_DONE = 0xf657
+      MISSING_FILE_NAME_EXIT = 0xf710
+
+      SECONDARY = 0x61
+
+      # ST bit at $90
+      DEVICE_NOT_PRESENT = 0x80
+
+      def initialize(cpu:, bus:, storage:)
+        super
+        @saving = false
+      end
+
       def call
         return unless active?
+        return finish if @saving
+
+        @bus.poke(0xb9, SECONDARY)
+        return @cpu.program_counter = MISSING_FILE_NAME_EXIT if name.empty?
 
-        name = filename
-        if name.empty?
-          error(MISSING_FILENAME)
-        else
-          @storage.write_file(name, payload)
-          finish
-        end
-        return_to_caller
+        @bus.poke(0x90, 0x00)
+        @saving = true
+        continue_with(SAVING_MESSAGE, ADDRESS)
       end
 
       private
 
+      def name
+        Storage.parse_name(filename).first
+      end
+
+      def finish
+        @saving = false
+        @bus.poke(0x90, DEVICE_NOT_PRESENT) unless @storage.write_file(name, payload)
+        @bus.poke(0xac, @bus.peek(0xae))
+        @bus.poke(0xad, @bus.peek(0xaf))
+        @cpu.y = 0
+        @cpu.status.overflow = true
+        continue_with(CLOCK_RELEASE, DATA_RELEASE, SAVE_DONE)
+      end
+
       # Start address at $C1/$C2 (STAL), end address (exclusive) at
       # $AE/$AF (EAL)
       def payload
@@ -32,11 +69,6 @@ module Badline
         [low_byte(start), high_byte(start)] +
           Array.new(length) { |i| @bus.peek((start + i) & 0xffff) }
       end
-
-      def finish
-        @bus.poke(0x90, 0x00)
-        @cpu.status.carry = false
-      end
     end
   end
 end