badline 0.2.0 → 0.3.0

data/lib/badline/kernal_trap/channel.rb

@@ -4,29 +4,139 @@ 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.
+    # time and flags the last one, so the bus can raise EOI with it. A
+    # channel cut short by a read error never flags one, and holds the
+    # error for the drive to report once its bytes run out.
     class Channel
-      attr_accessor :pointer
+      attr_accessor :buffer
+      attr_reader :error, :pointer
+      attr_writer :lead
 
-      def initialize(bytes = [])
+      def initialize(bytes = [], error: nil, writable: false, base: 0)
+        @base = base
         replace(bytes)
+        @error = error
+        @writable = writable
       end
 
-      def replace(bytes)
+      # A block buffer opened with "#", which reads and writes one of the
+      # drive's buffers in its RAM, so M-R and M-W reach the same bytes. It
+      # hands out the whole block unless a B-R sets a shorter end, and
+      # flags that byte as the last. The DOS opens it with the pointer at 1
+      # and the buffer's number as the byte to send, so the first read
+      # answers with the number and the next one moves on to the third
+      # byte.
+      def self.buffer(memory, number)
+        new(memory.ram, writable: true, base: Drive::Memory.buffer_address(number)).tap do |channel|
+          channel.buffer = number
+          channel.rewind(Drive::BLOCK_SIZE)
+          channel.pointer = 1
+          channel.lead = number
+        end
+      end
+
+      # A file's bytes, up to the first block its chain can't read. The
+      # drive reads a block ahead before sending the last byte of the one
+      # before, so a bad block holds that byte back too, and a bad first
+      # block or a missing file leaves nothing to send.
+      def self.for_file(storage, name, type)
+        data = storage.read_file(name, type:)
+        return new([], error: [Drive::FILE_NOT_FOUND]) unless data
+
+        failure = storage.respond_to?(:read_error) && storage.read_error(name, type:)
+        return new(data) unless failure
+
+        new(data[0, failure[:offset] - 1] || [], error: failure.values_at(:error, :track, :sector))
+      end
+
+      # The file an open names. The drive keeps the first block of the file
+      # a LOAD (secondary address 0) opens at $7E and $026F of its memory,
+      # and a LOAD of a name starting with "*" reopens that file rather than
+      # the first one on the disk. Loaders write the block there with M-W
+      # to load a file the directory doesn't list.
+      def self.for_name(storage, memory, secondary, name, type)
+        file = Storage.parse_name(name).first
+        return for_file(storage, file, type) unless secondary.zero? && storage.respond_to?(:first_block)
+
+        last = memory.last_program if name.start_with?("*")
+        return at_block(storage, *last) if last
+
+        block = storage.first_block(file, type:)
+        memory.last_program = block if block
+        for_file(storage, file, type)
+      end
+
+      # The file whose chain starts at the block.
+      def self.at_block(storage, track, sector)
+        data = storage.read_file_at(track, sector)
+        data ? new(data) : new([], error: [Drive::ILLEGAL_TRACK_OR_SECTOR, track, sector])
+      end
+
+      def replace(bytes, length = bytes.length)
         @bytes = bytes
-        @pointer = 0
+        rewind(length)
+      end
+
+      def rewind(length)
+        @length = length
+        self.pointer = 0
       end
 
+      def pointer=(position)
+        @pointer = position
+        @lead = nil
+      end
+
+      # A block read into the channel. A buffer channel takes it into its
+      # buffer, a file channel hands it out in place of the file.
+      def load(block, length)
+        return replace(block.dup, length) unless @writable
+
+        @bytes[@base, block.length] = block
+        rewind(length)
+      end
+
+      def writable? = @writable
+
       def exhausted?
-        @pointer >= @bytes.length
+        @pointer >= @length
+      end
+
+      # A file that holds nothing but its error never opened.
+      def failed?
+        exhausted? && !@error.nil?
+      end
+
+      # Each byte lands at the pointer, which wraps within the block.
+      def write(bytes)
+        @lead = nil
+        bytes.each do |byte|
+          @bytes[@base + @pointer] = byte
+          @pointer = (@pointer + 1) & 0xff
+        end
       end
 
       def read
+        return read_buffer if @writable
         return if exhausted?
 
-        byte = @bytes[@pointer]
+        byte = @lead || @bytes[@base + @pointer]
+        @lead = nil
         @pointer += 1
-        [byte, exhausted?]
+        [byte, exhausted? && !@error]
+      end
+
+      private
+
+      # A buffer never runs out. Past its last byte, which goes out with
+      # EOI, the pointer wraps back to the second, and a pointer set past
+      # the end runs on around the block to it.
+      def read_buffer
+        byte = @lead || @bytes[@base + @pointer]
+        @lead = nil
+        last = @pointer == @length - 1
+        @pointer = last ? 1 : (@pointer + 1) & 0xff
+        [byte, last]
       end
     end
   end

data/lib/badline/kernal_trap/drive/block_commands.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Badline
+  module KernalTrap
+    class Drive
+      # The commands that read and write a block through a buffer channel,
+      # and B-P, which moves its pointer.
+      module BlockCommands
+        private
+
+        def block_read(arguments, counted: false)
+          channel, _drive, track, sector = arguments
+          data = fetch_block(channel, track, sector)
+          return unless data
+
+          buffer = @channels[channel]
+          buffer.load(data, counted ? data[0] + 1 : data.length)
+          buffer.pointer = 1 if counted
+          report_block_error(track, sector)
+        end
+
+        # The disk is write-protected, so a block write that gets as far as
+        # the disk fails at the block it names.
+        def block_write(arguments, counted: false)
+          channel, _drive, track, sector = arguments
+          return unless fetch_block(channel, track, sector)
+
+          store_count(@channels[channel]) if counted
+          report(WRITE_PROTECT_ON, track, sector)
+        end
+
+        # B-W first stores the index of the last byte written, the pointer
+        # less one but at least 1, as the block's first byte, which leaves
+        # the pointer at 1. B-R reads that count back.
+        def counted_block_write(arguments)
+          block_write(arguments, counted: true)
+        end
+
+        def store_count(buffer)
+          count = [buffer.pointer - 1, 1].max
+          buffer.pointer = 0
+          buffer.write([count])
+        end
+
+        # Block access needs an open buffer channel, a disk and a block on it.
+        # Returns the block, or nil once it has reported why there is none.
+        def fetch_block(channel, track, sector)
+          return report(NO_CHANNEL) unless @channels[channel]
+          return report(DRIVE_NOT_READY) unless @storage.respond_to?(:read_block)
+
+          data = sector && @storage.read_block(track, sector)
+          data || report(ILLEGAL_TRACK_OR_SECTOR, 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 & 0xff
+          report(OK)
+        end
+      end
+    end
+  end
+end

data/lib/badline/kernal_trap/drive/channels.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Badline
+  module KernalTrap
+    class Drive
+      # The drive's open data channels by secondary address, and the five
+      # buffers they hold. The DOS hands out the highest free buffer.
+      # Reading the BAM when it initializes the disk takes buffer 4, so
+      # channels get 3 down to 0, and the fifth data channel finds none.
+      class Channels
+        BAM_BUFFER = 4
+
+        def initialize
+          @channels = {}
+        end
+
+        def [](secondary) = @channels[secondary]
+
+        def open?(secondary) = @channels.key?(secondary)
+
+        def close(secondary) = @channels.delete(secondary)
+
+        def clear = @channels.clear
+
+        # Opens a buffer channel on the buffer a "#n" name asks for, or on
+        # the highest free one. Returns nil when that buffer isn't free,
+        # which leaves a channel asking again for its own buffer open.
+        def open_buffer(secondary, number, memory)
+          return if number && !free_buffers.include?(number)
+
+          close(secondary)
+          number ||= free_buffers.max
+          @channels[secondary] = Channel.buffer(memory, number) if number
+        end
+
+        # A file that opens takes a buffer, though its bytes don't pass
+        # through drive RAM here. One that fails to open takes none. Returns
+        # nil, leaving the channel closed, when no buffer is free.
+        def open_file(secondary, channel)
+          close(secondary)
+          channel.buffer = free_buffers.max unless channel.failed?
+          @channels[secondary] = channel if channel.failed? || channel.buffer
+        end
+
+        private
+
+        def free_buffers
+          (0...BAM_BUFFER).to_a - @channels.values.map(&:buffer)
+        end
+      end
+    end
+  end
+end

data/lib/badline/kernal_trap/drive/memory.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Badline
+  module KernalTrap
+    class Drive
+      # The drive's 2K of RAM, as M-W and M-R reach it, with the job queue
+      # that runs a read job written into it: 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.
+      class Memory
+        SIZE = 0x800
+        JOBS = 5
+        READ_JOB = 0x80
+        JOB_OK = 1
+        HEADER_NOT_FOUND = 20
+
+        # The RAM itself, which buffer channels read and write in place.
+        attr_reader :ram
+
+        # The disk that read jobs read from.
+        attr_writer :storage
+
+        # Buffer n takes the page $0300 + n * $100.
+        def self.buffer_address(number)
+          0x300 + (number * BLOCK_SIZE)
+        end
+
+        def initialize
+          @storage = nil
+          @ram = Array.new(SIZE, 0)
+          @bam = false
+        end
+
+        # Writes past the RAM are dropped, since the rest of the address
+        # space is I/O and ROM.
+        def write(address, bytes)
+          bytes.each.with_index(address) do |byte, target|
+            @ram[target] = byte if target < SIZE
+          end
+          run_jobs
+        end
+
+        # Only the RAM reads back.
+        def read(address, count)
+          Array.new(count) { |i| @ram.fetch(address + i, 0) }
+        end
+
+        # A reset through the reset vector clears the RAM, and the BAM
+        # with it, until the next open initializes the disk again.
+        def clear
+          @ram.fill(0)
+          @bam = false
+        end
+
+        # Initializing the disk reads its BAM, the header block, into buffer
+        # 4, where M-R finds it. Storage without blocks has none.
+        def read_bam
+          @bam = true
+          block = @storage.respond_to?(:header_block) && @storage.read_block(*@storage.header_block)
+          load_buffer(Channels::BAM_BUFFER, block) if block
+        end
+
+        # Whether the BAM has been read since the last reset.
+        def bam? = @bam
+
+        def load_buffer(number, block)
+          @ram[Memory.buffer_address(number), block.length] = block
+        end
+
+        # The first block of the file the last LOAD read, which the DOS
+        # keeps at $7E and $026F, or nil while the track there is 0.
+        def last_program
+          [@ram[0x7e], @ram[0x26f]] unless @ram[0x7e].zero?
+        end
+
+        def last_program=(block)
+          @ram[0x7e], @ram[0x26f] = block
+        end
+
+        private
+
+        def run_jobs
+          JOBS.times do |job|
+            next unless @ram[job] == READ_JOB
+
+            track, sector = @ram[6 + (job * 2), 2]
+            @ram[job] = read_job(job, track, sector)
+          end
+        end
+
+        def read_job(number, track, sector)
+          data = @storage.respond_to?(:read_block) && @storage.read_block(track, sector)
+          return job_result(HEADER_NOT_FOUND) unless data
+
+          load_buffer(number, 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
+      end
+    end
+  end
+end

data/lib/badline/kernal_trap/drive/parameters.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Badline
+  module KernalTrap
+    class Drive
+      # The numbers a DOS command takes. The DOS skips spaces, commas and
+      # cursor-rights before a parameter, reads it from the characters $30
+      # to $3F that follow, the low nibble of each, and skips whatever
+      # character ends it. So "18,\x02" reads as 18 and 0, ":" to "?" are
+      # digits 10 to 15, and a run of digits keeps its last three.
+      module Parameters
+        # Space, comma and cursor-right
+        GAPS = [0x20, 0x2c, 0x1d].freeze
+
+        def self.parse(text)
+          rest = text.to_s.bytes
+          values = []
+          until (rest = rest.drop_while { |byte| GAPS.include?(byte) }).empty?
+            digits = rest.take_while { |byte| byte.between?(0x30, 0x3f) }
+            values << digits.last(3).reduce(0) { |value, digit| (value * 10) + (digit & 0x0f) }
+            rest = rest.drop(digits.length + 1)
+          end
+          values
+        end
+      end
+    end
+  end
+end

data/lib/badline/kernal_trap/drive/status.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Badline
+  module KernalTrap
+    class Drive
+      # The command channel's side of the drive: the last DOS error with the
+      # track and sector it happened at, or the bytes an M-R read. Once its
+      # last byte has been read, it holds OK again.
+      class Status
+        MESSAGES = [20, 21, 22, 23, 24, 27].to_h { |code| [code, "READ ERROR"] }.merge(
+          0 => " OK",
+          25 => "WRITE ERROR",
+          26 => "WRITE PROTECT ON",
+          28 => "WRITE ERROR",
+          29 => "DISK ID MISMATCH",
+          30 => "SYNTAX ERROR",
+          62 => "FILE NOT FOUND",
+          63 => "FILE EXISTS",
+          66 => "ILLEGAL TRACK OR SECTOR",
+          70 => "NO CHANNEL",
+          73 => "CBM DOS V2.6 1541",
+          74 => "DRIVE NOT READY"
+        ).freeze
+
+        def initialize
+          @channel = Channel.new
+        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)
+          @channel.replace(message.bytes)
+          nil
+        end
+
+        def replace(bytes)
+          @channel.replace(bytes)
+        end
+
+        def read
+          result = @channel.read
+          report(0) if result&.last
+          result
+        end
+      end
+    end
+  end
+end