badline 0.2.1 → 0.3.0

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.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require "badline/kernal_trap/drive/block_commands"
+require "badline/kernal_trap/drive/channels"
+require "badline/kernal_trap/drive/memory"
+require "badline/kernal_trap/drive/parameters"
 require "badline/kernal_trap/drive/status"
 
 module Badline
@@ -9,6 +13,8 @@ module Badline
     # buffer channel, which is how block-access loaders bypass the KERNAL's
     # LOAD.
     class Drive
+      include BlockCommands
+
       COMMAND_CHANNEL = 15
       BLOCK_SIZE = 256
 
@@ -24,17 +30,6 @@ module Badline
 
       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
@@ -44,7 +39,7 @@ module Badline
       # 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,
+      USER_TABLE = [:block_read, :block_write, *[:initialized] * 6,
                     :warm_reset, :cold_reset, :warm_reset, *[:initialized] * 5].freeze
 
       COMMANDS = {
@@ -52,50 +47,76 @@ module Badline
         /\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
+        /\AB-W\s*:?\s*(.*)/i => :counted_block_write,
+        /\AI/i => :initialize_disk,
+        /\AV/i => :initialized,
+        /\AB-[AF]/i => :write_protected
       }.freeze
 
-      # A drive powers on reporting its DOS version, as a reset does.
-      def initialize(storage)
+      # A drive powers on reporting its DOS version, as a reset does. It
+      # takes the RAM of the drive it replaces when the disk changes, and
+      # initializes the new disk.
+      def initialize(storage, memory = Memory.new)
         @storage = storage
-        @channels = {}
+        @channels = Channels.new
         @status = Status.new
-        @ram = Array.new(RAM_SIZE, 0)
+        @memory = memory
+        memory.storage = storage
+        memory.read_bam
         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.
+      # Opening a data channel initializes a disk a reset left uninitialized.
       def open(secondary, name)
+        @memory.read_bam unless @memory.bam? || secondary == COMMAND_CHANNEL
         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)
+          opened = @channels.open_buffer(secondary, Parameters.parse(name[1..]).first, @memory)
+          report(opened ? OK : NO_CHANNEL)
         else
-          open_file(secondary, Storage.ascii(name.bytes))
+          open_file(secondary, Storage.ascii(without_return(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)
+        secondary == COMMAND_CHANNEL ? @channels.clear : @channels.close(secondary)
       end
 
+      # A buffer channel takes the bytes into its block. A file channel is
+      # open for reading, so writing to it fails as the disk is protected.
       def write(secondary, bytes)
         return command(bytes) if secondary == COMMAND_CHANNEL
 
-        report(WRITE_PROTECT_ON) if listening?(secondary)
+        channel = @channels[secondary]
+        return unless channel
+
+        channel.writable? ? channel.write(bytes) : report(WRITE_PROTECT_ON)
+      end
+
+      # A SAVE the trap hands over whole, to storage that can write files.
+      # A write the host refuses fails as a write-protected disk does.
+      # Returns whether the file was written.
+      def save(name, bytes)
+        saved = @storage.write_file(name, bytes)
+        saved ? report(OK) : report(WRITE_PROTECT_ON)
+        saved
       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)
+        secondary == COMMAND_CHANNEL || @channels.open?(secondary)
       end
 
+      # The serial bus's RESET line restarts the DOS through its reset
+      # vector, as U: does.
+      def reset! = reset(cold: true)
+
       # Returns the next byte and whether it is the channel's last, or nil
       # when there is nothing left to send.
       def read(secondary)
@@ -109,33 +130,51 @@ module Badline
 
       private
 
+      # The DOS cuts a name of two or more bytes at a carriage return in
+      # its last or second-to-last byte, as PRINT# ends a line with one.
+      def without_return(bytes)
+        cut = bytes.rindex(0x0d)
+        cut && bytes.length > 1 && cut >= bytes.length - 2 ? bytes[0, cut] : bytes
+      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)
-        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)
+        return refuse_write(secondary, name, file) if secondary == 1 || mode?(name, "W")
+        return refuse_append(secondary, file, type) if mode?(name, "A")
+
+        channel = @channels.open_file(secondary, Channel.for_name(@storage, @memory, secondary, name, type))
+        return report(NO_CHANNEL) unless channel
+
+        channel.failed? ? 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) }
+      def mode?(name, mode)
+        name.split(",").drop(1).any? { |field| field.strip[0]&.upcase == mode }
       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)
+        @channels.close(secondary)
         return report(FILE_EXISTS) if !name.start_with?("@") && @storage.read_file(file, type: nil)
 
         report(WRITE_PROTECT_ON, *protected_block(secondary))
       end
 
+      # An A mode open needs the file on the disk. It fails at the file's
+      # last block, the first one an append writes back.
+      def refuse_append(secondary, file, type)
+        @channels.close(secondary)
+        return report(FILE_NOT_FOUND) unless @storage.read_file(file, type:)
+
+        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)
@@ -150,11 +189,7 @@ module Badline
         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)
+        run_command(action, Parameters.parse(pattern.match(command)[1]))
       end
 
       def command(bytes)
@@ -165,9 +200,12 @@ module Badline
       def run_command(action, arguments)
         case action
         when :block_read then block_read(arguments)
+        when :block_write then block_write(arguments)
+        when :counted_block_write then counted_block_write(arguments)
         when :counted_block_read then counted_block_read(arguments)
         when :buffer_pointer then buffer_pointer(arguments)
         when :initialized then report(OK)
+        when :initialize_disk then initialize_disk
         when :write_protected then write_protected(arguments)
         when :cold_reset then reset(cold: true)
         when :warm_reset then reset(cold: false)
@@ -176,61 +214,19 @@ module Badline
         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.
+      # M-W takes an address, a count and that many bytes.
       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
+        @memory.write(word(arguments), arguments[3, arguments[2].to_i].to_a)
         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.
+      # ends a line with, it reads one byte.
       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) })
+        @status.replace(@memory.read(word(arguments), count))
         nil
       end
 
@@ -238,39 +234,21 @@ module Badline
         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 write_protected(_arguments) = report(WRITE_PROTECT_ON)
 
       def reset(cold:)
-        @ram.fill(0) if cold
+        @memory.clear if cold
         @channels.clear
         report(DOS_VERSION)
       end
 
+      # I closes the data channels and reads the BAM again.
+      def initialize_disk
+        @channels.clear
+        @memory.read_bam
+        report(OK)
+      end
+
       def report(...) = @status.report(...)
     end
   end

data/lib/badline/kernal_trap/file.rb

@@ -5,11 +5,6 @@ module Badline
     class File < Routine
       MISSING_FILENAME = 0x08
 
-      def initialize(cpu:, bus:, storage: nil)
-        super(cpu:, bus:)
-        @storage = storage
-      end
-
       private
 
       def active?

data/lib/badline/kernal_trap/load.rb

@@ -30,6 +30,11 @@ module Badline
       VERIFY_MISMATCH = 0x10
       READ_TIMEOUT = 0x02
 
+      # The ROM opens the file with secondary address $60 and leaves it in
+      # $B9, so a second LOAD without a SETLFS loads to the file's own
+      # address even when the first one relocated.
+      LOAD_SECONDARY = 0x60
+
       def initialize(cpu:, bus:, drive:)
         super(cpu:, bus:)
         @drive = drive
@@ -80,6 +85,7 @@ module Badline
           @bus.poke(0x90, @bus.peek(0x90) & ~EOI) unless complete
           continue_with(SEARCHING_MESSAGE, LOADING_MESSAGE, complete ? LOAD_DONE : BYTE_LOOP)
         end
+        @bus.poke(0xb9, LOAD_SECONDARY)
       end
 
       def low_memory?(data)

data/lib/badline/kernal_trap/save.rb

@@ -3,7 +3,7 @@
 module Badline
   module KernalTrap
     # 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
+    # vector target). Hands device 8 saves to the virtual drive as a PRG
     # (load address followed by the memory range); other devices fall
     # 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
@@ -28,8 +28,9 @@ module Badline
       # ST bit at $90
       DEVICE_NOT_PRESENT = 0x80
 
-      def initialize(cpu:, bus:, storage:)
-        super
+      def initialize(cpu:, bus:, drive:)
+        super(cpu:, bus:)
+        @drive = drive
         @saving = false
       end
 
@@ -53,7 +54,7 @@ module Badline
 
       def finish
         @saving = false
-        @bus.poke(0x90, DEVICE_NOT_PRESENT) unless @storage.write_file(name, payload)
+        @bus.poke(0x90, DEVICE_NOT_PRESENT) unless @drive.save(name, payload)
         @bus.poke(0xac, @bus.peek(0xae))
         @bus.poke(0xad, @bus.peek(0xaf))
         @cpu.y = 0

data/lib/badline/media.rb

@@ -59,8 +59,8 @@ module Badline
 
       def start_tune(computer, tune, autostart:, song:)
         computer.ram.write(tune.load_address, tune.data)
-        computer.ram.write(tune.driver_address, tune.driver(song:))
-        computer.type_text("sys#{tune.driver_address}\r") if autostart
+        tune.boot_memory(song:).each { |address, bytes| computer.ram.write(address, bytes) }
+        computer.type_text(tune.boot_command) if autostart
       end
 
       def attach_tape(computer, path, autostart:)

data/lib/badline/memory.rb

@@ -10,11 +10,11 @@ module Badline
     end
 
     def peek(addr)
-      @storage[index(addr)]
+      @storage[offset_of(addr)]
     end
 
     def poke(addr, value)
-      @storage[index(addr)] = value
+      @storage[offset_of(addr)] = value
       value
     end
 

data/lib/badline/rom.rb

@@ -1,17 +1,26 @@
 # frozen_string_literal: true
 
 module Badline
+  class << self
+    attr_writer :rom_path
+
+    # The directory ROM images and other bundled binaries load from.
+    # Defaults to $BADLINE_ROM_PATH, then to the roms directory next to this
+    # file. Assigning nil restores the default.
+    def rom_path
+      @rom_path ||= ENV.fetch("BADLINE_ROM_PATH", File.expand_path("roms", __dir__))
+    end
+  end
+
   class ROM < Memory
     class << self
       def load(filename, start = 0x0)
-        data = File.read(file_path(filename)).bytes
+        data = read(filename)
         new(data, length: data.length, start: start)
       end
 
-      private
-
-      def file_path(filename)
-        File.join(File.dirname(__FILE__), "roms", filename)
+      def read(filename)
+        File.binread(File.join(Badline.rom_path, filename)).bytes
       end
     end