badline 0.2.0 → 0.2.1

data/lib/badline/kernal_trap/drive.rb

@@ -1,5 +1,7 @@
 # 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
@@ -14,29 +16,12 @@ module Badline
       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
 
-      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
@@ -50,20 +35,34 @@ module Badline
       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[1A]\s*:?\s*(.*)/i => :block_read,
+        /\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,
-        /\A(?:U[2B]|B-[WAF])/i => :write_protected
+        /\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 = Channel.new
+        @status = Status.new
         @ram = Array.new(RAM_SIZE, 0)
-        report(OK)
+        report(DOS_VERSION)
       end
 
       # A name on the command channel is a command, "#" opens a block
@@ -86,35 +85,63 @@ module Badline
       end
 
       def write(secondary, bytes)
-        return report(WRITE_PROTECT_ON) unless secondary == COMMAND_CHANNEL
+        return command(bytes) if secondary == COMMAND_CHANNEL
+
+        report(WRITE_PROTECT_ON) if listening?(secondary)
+      end
 
-        command(bytes)
+      # 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)
-        secondary == COMMAND_CHANNEL ? read_status : @channels[secondary]&.read
-      end
-
-      private
-
-      def read_status
-        result = @status.read
-        report(OK) if result&.last
+        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
-        data = @storage.read_file(file, type:)
-        @channels[secondary] = Channel.new(data || [])
-        report(data ? OK : FILE_NOT_FOUND)
+        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)
@@ -122,7 +149,8 @@ module Badline
         pattern, action = COMMANDS.find { |candidate, _| candidate.match?(command) }
         return report(SYNTAX_ERROR) unless action
 
-        send(action, arguments(pattern.match(command)[1]))
+        action = USER_TABLE[(command.getbyte(1) - 1) & 0x0f] if action == :user
+        run_command(action, arguments(pattern.match(command)[1]))
       end
 
       def arguments(text)
@@ -131,7 +159,21 @@ module Badline
 
       def command(bytes)
         action = MEMORY_COMMANDS[bytes[0, 3].pack("C*")]
-        action ? send(action, bytes[3..]) : execute(Storage.ascii(bytes))
+        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)
@@ -219,21 +261,17 @@ module Badline
         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
+      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

@@ -5,7 +5,7 @@ module Badline
     class File < Routine
       MISSING_FILENAME = 0x08
 
-      def initialize(cpu:, bus:, storage:)
+      def initialize(cpu:, bus:, storage: nil)
         super(cpu:, bus:)
         @storage = storage
       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?
 
-        name, type = Storage.parse_name(filename)
-        if name.empty?
-          error(MISSING_FILENAME)
-        elsif (data = @storage.read_file(name, type: type || :prg))
-          deliver(data)
+        @bus.poke(0x93, @cpu.a)
+        @bus.poke(0x90, 0x00)
+        name = filename
+        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

@@ -25,6 +25,23 @@ module Badline
         @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)

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 = Storage.parse_name(filename).first
-        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

data/lib/badline/kernal_trap/serial.rb

@@ -23,6 +23,7 @@ module Badline
       CLOSE = 0xe0
 
       # ST bits at $90
+      DEVICE_NOT_PRESENT = 0x80
       EOI = 0x40
       READ_TIMEOUT = 0x02
 
@@ -41,13 +42,26 @@ module Badline
 
       def install
         ROUTINES.each do |address, routine|
-          @cpu.install_trap(address) { send(routine) if kernal? }
+          @cpu.install_trap(address) { call_routine(routine) if kernal? }
         end
         self
       end
 
       private
 
+      def call_routine(routine)
+        case routine
+        when :talk then talk
+        when :listen then listen
+        when :second then second
+        when :tksa then tksa
+        when :ciout then ciout
+        when :untalk then untalk
+        when :unlisten then unlisten
+        when :acptr then acptr
+        end
+      end
+
       # Addressing the bus starts a new frame. The channel number arrives
       # in the secondary address that follows.
       def talk
@@ -82,22 +96,40 @@ module Badline
         return unless @listening
 
         @buffer << @cpu.a
+        update_status(DEVICE_NOT_PRESENT) unless accepted?
         @cpu.status.carry = false
         return_to_caller
       end
 
+      # The drive acknowledges every byte of an open or close frame, but
+      # takes data only on a channel it has open. Otherwise nothing holds
+      # the data line when a byte starts, so the KERNAL finds no device.
+      def accepted?
+        [OPEN, CLOSE].include?(@frame) || @drive.listening?(@listen_channel)
+      end
+
       def unlisten
         return unless @listening
 
         @listening = false
         deliver_frame
-        return_to_caller
+        release_bus
       end
 
       def untalk
         return unless @talking
 
         @talking = false
+        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.
+      def release_bus
+        @bus.poke(0xdd00, @bus.peek(0xdd00) & 0xc7)
+        @cpu.a = @bus.peek(0xdd00) & 0xdf
+        @cpu.status.negative = @cpu.a.anybits?(0x80)
+        @cpu.status.zero = @cpu.a.zero?
         return_to_caller
       end
 

data/lib/badline/memory.rb

@@ -26,6 +26,11 @@ module Badline
       Array(bytes).each_with_index { |b, i| poke(addr + i, b) }
     end
 
+    # Refills the whole memory as if newly built with `initial`
+    def clear!(initial = [])
+      @storage.replace(zero_fill(initial))
+    end
+
     private
 
     def blank_value