badline 0.3.0 → 0.4.1

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

data/lib/badline/kernal_trap/drive.rb

@@ -5,24 +5,31 @@ require "badline/kernal_trap/drive/channels"
 require "badline/kernal_trap/drive/memory"
 require "badline/kernal_trap/drive/parameters"
 require "badline/kernal_trap/drive/status"
+require "badline/kernal_trap/drive/writes"
+require "badline/kernal_trap/drive/write_file"
 
 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.
+    # LOAD. A disk image whose host file takes writes takes files, blocks
+    # and BAM changes too. Other disks are write-protected, though storage
+    # that can write files still takes a SAVE handed over whole.
     class Drive
       include BlockCommands
+      include Writes
 
       COMMAND_CHANNEL = 15
       BLOCK_SIZE = 256
 
       OK = 0
+      FILES_SCRATCHED = 1
       WRITE_PROTECT_ON = 26
       SYNTAX_ERROR = 30
       FILE_NOT_FOUND = 62
       FILE_EXISTS = 63
+      NO_BLOCK = 65
       ILLEGAL_TRACK_OR_SECTOR = 66
       NO_CHANNEL = 70
       DOS_VERSION = 73
@@ -50,22 +57,36 @@ module Badline
         /\AB-W\s*:?\s*(.*)/i => :counted_block_write,
         /\AI/i => :initialize_disk,
         /\AV/i => :initialized,
-        /\AB-[AF]/i => :write_protected
+        /\AB-A\s*:?\s*(.*)/i => :block_allocate,
+        /\AB-F\s*:?\s*(.*)/i => :block_free,
+        /\AS[^:]*:(.*)/im => :scratch
       }.freeze
 
+      # Commands that take their argument as text rather than numbers.
+      TEXT_COMMANDS = %i[scratch].freeze
+
       # 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.
+      # can take the RAM of a drive it replaces, and initializes its disk.
       def initialize(storage, memory = Memory.new)
-        @storage = storage
         @channels = Channels.new
         @status = Status.new
         @memory = memory
-        memory.storage = storage
-        memory.read_bam
+        insert(storage)
         report(DOS_VERSION)
       end
 
+      # Changes the disk. The drive keeps its RAM and its status, closes
+      # its channels, and initializes the new disk.
+      def insert(storage)
+        @storage = storage
+        @channels.clear
+        @memory.storage = storage
+        @memory.read_bam
+      end
+
+      # Whether the disk takes a SAVE handed over whole.
+      def saves? = @storage.respond_to?(:write_file)
+
       # 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.
@@ -82,13 +103,19 @@ module Badline
         end
       end
 
-      # Closing the command channel closes every other channel with it.
+      # Closing the command channel closes every other channel with it,
+      # and a file open for writing is lost. Closing a file open for
+      # writing writes it to the disk.
       def close(secondary)
-        secondary == COMMAND_CHANNEL ? @channels.clear : @channels.close(secondary)
+        return @channels.clear if secondary == COMMAND_CHANNEL
+
+        channel = @channels.close(secondary)
+        writing { channel.store(@storage) } if channel.is_a?(WriteFile)
       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.
+      # A buffer channel takes the bytes into its block, and a file open for
+      # writing gathers them. A file open for reading fails as a
+      # write-protected disk does.
       def write(secondary, bytes)
         return command(bytes) if secondary == COMMAND_CHANNEL
 
@@ -99,12 +126,11 @@ module Badline
       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
+      # A disk image refuses a name it already has unless `replace` asks to
+      # write over it, and a write the host refuses fails as a
+      # write-protected disk does. Returns whether the file was written.
+      def save(name, bytes, replace: false)
+        writing { @storage.write_file(name, bytes, type: :prg, replace:) }
       end
 
       # Whether data sent on the channel reaches the drive. The command
@@ -139,12 +165,12 @@ module Badline
 
       # 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.
+      # type the name doesn't pin down, and write a SEQ file.
       def open_file(secondary, name)
         file, type = Storage.parse_name(name)
         type ||= :prg if secondary < 2
-        return refuse_write(secondary, name, file) if secondary == 1 || mode?(name, "W")
-        return refuse_append(secondary, file, type) if mode?(name, "A")
+        return open_write(secondary, name, file, type) if secondary == 1 || mode?(name, "W")
+        return open_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
@@ -156,40 +182,14 @@ module Badline
         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.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)
-        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, Parameters.parse(pattern.match(command)[1]))
+        argument = pattern.match(command)[1]
+        run_command(action, TEXT_COMMANDS.include?(action) ? argument : Parameters.parse(argument))
       end
 
       def command(bytes)
@@ -206,7 +206,9 @@ module Badline
         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 :block_allocate then block_allocate(arguments)
+        when :block_free then block_free(arguments)
+        when :scratch then scratch(arguments)
         when :cold_reset then reset(cold: true)
         when :warm_reset then reset(cold: false)
         when :memory_write then memory_write(arguments)
@@ -234,8 +236,6 @@ module Badline
         arguments[0].to_i | (arguments[1].to_i << 8)
       end
 
-      def write_protected(_arguments) = report(WRITE_PROTECT_ON)
-
       def reset(cold:)
         @memory.clear if cold
         @channels.clear

data/lib/badline/kernal_trap/file.rb

@@ -3,26 +3,23 @@
 module Badline
   module KernalTrap
     class File < Routine
-      MISSING_FILENAME = 0x08
-
       private
 
       def active?
         kernal? && @bus.peek(0xba) == DEVICE
       end
 
-      # Filename pointer at $BB/$BC, length at $B7
       def filename
+        Storage.strip_drive_prefix(full_filename)
+      end
+
+      # Filename pointer at $BB/$BC, length at $B7
+      def full_filename
         pointer = uint16(@bus.peek(0xbb), @bus.peek(0xbc))
         bytes = Array.new(@bus.peek(0xb7)) do |i|
           @bus.peek((pointer + i) & 0xffff)
         end
-        Storage.strip_drive_prefix(Storage.ascii(bytes))
-      end
-
-      def error(code)
-        @cpu.a = code
-        @cpu.status.carry = true
+        Storage.ascii(bytes)
       end
     end
   end

data/lib/badline/kernal_trap/save.rb

@@ -5,12 +5,15 @@ module Badline
     # PC trap on the KERNAL serial SAVE routine ($F5ED, the default ISAVE
     # 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
+    # through to the ROM, and so do saves to a disk that doesn't take them
+    # whole. 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 that fails, to a full disk, a name already on it or a host file
+    # that can't be written, 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.
+    # and the ROM returns without an error. A "@" before the drive prefix
+    # writes over a file of the same name.
     class Save < File
       ADDRESS = 0xf5ed
 
@@ -37,6 +40,7 @@ module Badline
       def call
         return unless active?
         return finish if @saving
+        return unless @drive.saves?
 
         @bus.poke(0xb9, SECONDARY)
         return @cpu.program_counter = MISSING_FILE_NAME_EXIT if name.empty?
@@ -54,7 +58,8 @@ module Badline
 
       def finish
         @saving = false
-        @bus.poke(0x90, DEVICE_NOT_PRESENT) unless @drive.save(name, payload)
+        saved = @drive.save(name, payload, replace: full_filename.start_with?("@"))
+        @bus.poke(0x90, DEVICE_NOT_PRESENT) unless saved
         @bus.poke(0xac, @bus.peek(0xae))
         @bus.poke(0xad, @bus.peek(0xaf))
         @cpu.y = 0

data/lib/badline/keyboard.rb

@@ -11,6 +11,14 @@ module Badline
   class Keyboard
     include IntegerHelper
 
+    # Keys the C64 types as a combination: cursor up and cursor left are the
+    # shifted cursor keys. Pressing one holds both of its matrix keys, while
+    # a shift key held on its own stays down when it is released.
+    COMBINATIONS = {
+      cursor_up: %i[lshift cursor_v],
+      cursor_left: %i[lshift cursor_h]
+    }.freeze
+
     attr_reader :keys, :matrix
 
     def initialize
@@ -70,13 +78,21 @@ module Badline
 
     # Columns held down per row, as a bit mask of port B lines.
     def row_masks
-      @row_masks ||= matrix.map do |row|
-        row.each_with_index.sum { |key, column| keys.include?(key) ? 1 << column : 0 }
+      @row_masks ||= begin
+        pressed = held
+        matrix.map do |row|
+          row.each_with_index.sum { |key, column| pressed.include?(key) ? 1 << column : 0 }
+        end
       end
     end
 
+    # The matrix keys held down, with each combination expanded.
+    def held
+      keys.flat_map { |key| COMBINATIONS[key] || [key] }
+    end
+
     def valid_key?(key)
-      matrix.flatten.include?(key)
+      COMBINATIONS.key?(key) || matrix.flatten.include?(key)
     end
   end
 end

data/lib/badline/media.rb

@@ -14,25 +14,39 @@ module Badline
     }.freeze
 
     class << self
-      # `cartridge` sets the jumpers of a .crt cartridge that has them, such
-      # as `{ flash_jumper: true }` for the Retro Replay's flash mode.
-      def attach(computer, path, autostart: true, song: nil, cartridge: {})
+      # The options are the medium's own. `cartridge:` sets the jumpers of a
+      # .crt cartridge that has them, such as `{ flash_jumper: true }` for
+      # the Retro Replay's flash mode, and `disk: { read_only: true }` mounts
+      # a disk image write-protected, so nothing the program does writes to
+      # its file. Media they don't apply to ignore them.
+      def attach(computer, path, autostart: true, song: nil, **options)
         if File.directory?(path)
           computer.mount(Storage::HostDirectory.new(path))
           "Mounted #{path} as device 8"
         elsif File.extname(path).downcase == ".crt"
-          attach_cartridge(computer, path, cartridge)
+          attach_cartridge(computer, path, options.fetch(:cartridge, {}))
         elsif File.extname(path).downcase == ".sid"
           attach_sid(computer, path, autostart:, song:)
         elsif File.extname(path).downcase == ".tap"
           attach_tape(computer, path, autostart:)
-        elsif (storage = MOUNT_TYPES[File.extname(path).downcase])
-          attach_storage(computer, storage.new(path), path, autostart:)
+        elsif MOUNT_TYPES.key?(File.extname(path).downcase)
+          attach_storage(computer, path, options.fetch(:disk, {}), autostart:)
         else
           attach_prg(computer, path, autostart:)
         end
       end
 
+      # Swaps the disk in device 8 for a disk image or a host directory,
+      # while the machine runs, without loading anything. The drive keeps
+      # its RAM and its status. `read_only` inserts a disk image
+      # write-protected.
+      def insert_disk(computer, path, read_only: false)
+        raise ArgumentError, "#{path} is not a disk image or a directory" unless disk?(path)
+
+        computer.mount(open_storage(path, { read_only: }))
+        "Inserted #{path} in device 8"
+      end
+
       # The SID a machine for `path` should be built with. A .sid tune names
       # its own; everything else gets the 6581.
       def sid_model(path)
@@ -43,6 +57,20 @@ module Badline
 
       private
 
+      def disk?(path)
+        storage = MOUNT_TYPES[File.extname(path).downcase]
+        File.directory?(path) || (!storage.nil? && storage < Storage::DiskImage)
+      end
+
+      # Disk images take the `disk` options. A .t64 is read-only whatever
+      # it's given.
+      def open_storage(path, disk)
+        return Storage::HostDirectory.new(path) if File.directory?(path)
+
+        storage = MOUNT_TYPES[File.extname(path).downcase]
+        storage < Storage::DiskImage ? storage.new(path, **disk) : storage.new(path)
+      end
+
       def attach_cartridge(computer, path, options)
         computer.attach_cartridge(Cartridge.from_file(path, **options))
         "Attached cartridge #{path}"
@@ -70,8 +98,8 @@ module Badline
         "Inserted #{path} in the datasette"
       end
 
-      def attach_storage(computer, storage, path, autostart:)
-        computer.mount(storage)
+      def attach_storage(computer, path, disk, autostart:)
+        computer.mount(open_storage(path, disk))
         computer.type_text(AUTOSTART) if autostart
         "Mounted #{path} as device 8"
       end
@@ -85,11 +113,14 @@ module Badline
 
       def start_prg(computer, data, autostart:)
         load_addr = computer.load_prg(data)
-        # Run only makes sense for programs at BASIC start.
-        return unless autostart && load_addr == BASIC_START
+        # Run only makes sense for programs at BASIC start, or a byte ahead
+        # of it, where BASIC keeps the zero before its first line.
+        return unless autostart && (load_addr == BASIC_START || load_addr == BASIC_START - 1)
 
+        # The end of the program, where BASIC's variables start, and where
+        # the KERNAL's LOAD leaves its end address.
         end_addr = load_addr + data.length - 2
-        computer.ram.write(0x2d, [end_addr & 0xff, end_addr >> 8])
+        [0x2d, 0xae].each { |pointer| computer.ram.write(pointer, [end_addr & 0xff, end_addr >> 8]) }
         computer.type_text("run\r")
       end
     end