badline 0.2.1 → 0.4.0

data/lib/badline/kernal_trap/channel.rb

@@ -8,12 +8,31 @@ module Badline
     # 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_reader :error
+      attr_accessor :buffer
+      attr_reader :error, :pointer
+      attr_writer :lead
 
-      def initialize(bytes = [], error: nil)
+      def initialize(bytes = [], error: nil, writable: false, base: 0)
+        @base = base
         replace(bytes)
         @error = error
+        @writable = writable
+      end
+
+      # 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
@@ -30,22 +49,98 @@ module Badline
         new(data[0, failure[:offset] - 1] || [], error: failure.values_at(:error, :track, :sector))
       end
 
-      def replace(bytes)
+      # 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
+
+      # A buffer channel's block, as a block write puts it on the disk.
+      def block = @bytes[@base, Drive::BLOCK_SIZE]
+
       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? && !@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
 end

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

@@ -0,0 +1,108 @@
+# 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
+
+        # A block write puts the buffer's block on the disk. On a
+        # write-protected disk it fails at the block it names.
+        def block_write(arguments, counted: false)
+          channel, _drive, track, sector = arguments
+          return unless fetch_block(channel, track, sector)
+
+          buffer = @channels[channel]
+          store_count(buffer) if counted
+          return report(WRITE_PROTECT_ON, track, sector) unless writable_disk?
+
+          writing { @storage.write_block(track, sector, buffer.block) }
+        end
+
+        # B-A marks a block in use. One already in use fails as NO BLOCK,
+        # naming the next free one.
+        def block_allocate(arguments)
+          _drive, track, sector = arguments
+          return unless bam_entry(track, sector)
+          return report(NO_BLOCK, *@storage.next_free_block(track, sector)) unless @storage.block_free?(track, sector)
+
+          writing { @storage.allocate_block(track, sector) }
+        end
+
+        # B-F marks a block free.
+        def block_free(arguments)
+          _drive, track, sector = arguments
+          writing { @storage.free_block(track, sector) } if bam_entry(track, sector)
+        end
+
+        # A BAM change needs a disk that takes writes and a block the BAM
+        # has an entry for. Returns whether both hold, once it has reported
+        # why not.
+        def bam_entry(track, sector)
+          return report(WRITE_PROTECT_ON) unless writable_disk?
+          return true if sector && @storage.bam_block?(track, sector)
+
+          report(ILLEGAL_TRACK_OR_SECTOR, 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

@@ -9,6 +9,7 @@ module Badline
       class Status
         MESSAGES = [20, 21, 22, 23, 24, 27].to_h { |code| [code, "READ ERROR"] }.merge(
           0 => " OK",
+          1 => " FILES SCRATCHED",
           25 => "WRITE ERROR",
           26 => "WRITE PROTECT ON",
           28 => "WRITE ERROR",
@@ -16,8 +17,10 @@ module Badline
           30 => "SYNTAX ERROR",
           62 => "FILE NOT FOUND",
           63 => "FILE EXISTS",
+          65 => "NO BLOCK",
           66 => "ILLEGAL TRACK OR SECTOR",
           70 => "NO CHANNEL",
+          72 => "DISK FULL",
           73 => "CBM DOS V2.6 1541",
           74 => "DRIVE NOT READY"
         ).freeze

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Badline
+  module KernalTrap
+    class Drive
+      # A channel open for writing a file. It gathers the bytes sent to it,
+      # and the drive writes the file to the disk when the channel closes.
+      # An append starts from the file's end, a replace writes over the
+      # file of the same name.
+      class WriteFile
+        attr_accessor :buffer
+        attr_reader :name, :type, :mode
+
+        def initialize(name, type, mode: :write)
+          @name = name
+          @type = type
+          @mode = mode
+          @bytes = []
+        end
+
+        def write(bytes) = @bytes.concat(bytes)
+
+        def writable? = true
+
+        def failed? = false
+
+        # A file open for writing has nothing to send.
+        def read = nil
+
+        # Writes the gathered bytes to the storage.
+        def store(storage)
+          if @mode == :append
+            storage.append_file(@name, @bytes, type: @type)
+          else
+            storage.write_file(@name, @bytes, type: @type, replace: @mode == :replace)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Badline
+  module KernalTrap
+    class Drive
+      # Opens for writing, the S command and the reports a write makes. A
+      # file open for writing takes the type its name asks for, or SEQ on a
+      # data channel. On a write-protected disk, or storage that doesn't
+      # write files through channels, an open for writing fails.
+      module Writes
+        private
+
+        # A name already on the disk fails as FILE EXISTS unless @ asks to
+        # replace it. A write-protected disk fails anything else and leaves
+        # the channel closed.
+        def open_write(secondary, name, file, type)
+          replace = name.start_with?("@")
+          if !replace && @storage.read_file(file, type: nil)
+            @channels.close(secondary)
+            return report(FILE_EXISTS)
+          end
+          return refuse_write(secondary) unless writable_disk?
+
+          open_writer(secondary, WriteFile.new(file, type || :seq, mode: replace ? :replace : :write))
+        end
+
+        # An A mode open needs the file on the disk.
+        def open_append(secondary, file, type)
+          unless @storage.read_file(file, type:)
+            @channels.close(secondary)
+            return report(FILE_NOT_FOUND)
+          end
+          return refuse_append(secondary, file, type) unless writable_disk?
+
+          open_writer(secondary, WriteFile.new(file, type, mode: :append))
+        end
+
+        def open_writer(secondary, channel)
+          @channels.open_file(secondary, channel) ? report(OK) : report(NO_CHANNEL)
+        end
+
+        def writable_disk? = @storage.respond_to?(:writable?) && @storage.writable?
+
+        # Runs a write to the disk and reports how it went. Returns whether
+        # the disk took it.
+        def writing
+          written = yield != false
+          @memory.read_bam if @memory.bam?
+          written ? report(OK) : report(WRITE_PROTECT_ON)
+          written
+        rescue Storage::WriteError => e
+          report(e.code)
+          false
+        end
+
+        # An open for writing on a write-protected disk fails as WRITE
+        # PROTECT ON.
+        def refuse_write(secondary)
+          @channels.close(secondary)
+          report(WRITE_PROTECT_ON, *protected_block(secondary))
+        end
+
+        # An append on a write-protected disk fails at the file's last block,
+        # the first one an append writes back.
+        def refuse_append(secondary, file, type)
+          @channels.close(secondary)
+          report(WRITE_PROTECT_ON, *(@storage.last_block(file, type:) if @storage.respond_to?(:last_block)))
+        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
+
+        # S takes names separated by commas, each of which can be a pattern,
+        # and reports how many files it scratched.
+        def scratch(names)
+          return report(WRITE_PROTECT_ON) unless writable_disk?
+
+          count = 0
+          scratched = writing do
+            names.split(",").each { |name| count += @storage.scratch(Storage.strip_drive_prefix(name)) }
+          end
+          report(FILES_SCRATCHED, count) if scratched
+        end
+      end
+    end
+  end
+end