badline 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c4f6f2a45538629646db2ddd5ff47971f36580cf1982879a6f8db7d4dc410cf4
-  data.tar.gz: e668de00c0a93c4f7f7f9ff9494a1f875ea820bbc18ef67203382862967753e3
+  metadata.gz: 7150f883c604da9d4f9bd4712412a020f9352dbbdba08a5051fee95e7f8bce30
+  data.tar.gz: cac44823e8c8afcc4637ad40383da5c624f51d29a60a45084b2ba6b81d6ae68e
 SHA512:
-  metadata.gz: a4ccdf301a0d5f35e87e3ac8777bbc79b1214cbde95da1cf90db901aa40ffc05eef3dd3954fd9217137bc0892359da2123c09299a47473bf7a762a7d1754914a
-  data.tar.gz: b16f94cd511939d43132c936047280de9114ee01a3bef13ed24af13d069a04e7d86ba1d736b544ef6957f3307de856fd625a631082a58a51deec91d2581c1204
+  metadata.gz: d09600dbf17cfa3df1d32e6ca5b8b25cd6f3cb012fd54c0cc0f7a4f700d98aaa45e9b0ba6cde95fa6c37e7310368f692e75c0f332f55fad84c5181a07df5da61
+  data.tar.gz: e3b2796713ab7701ab0a536276b6e845bb1751586c7706bdbe19a918129bb978927aef395062c98331c493af515a8ef77455446ca21289e434360753bf1aa89a

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [0.2.1](https://github.com/elektronaut/badline/compare/v0.2.0...v0.2.1) (2026-09-23)
+
+
+### Bug Fixes
+
+* decode U commands by the 1541's user table index ([4d37a92](https://github.com/elektronaut/badline/commit/4d37a928f9109d8214294fdac21bce25f201549b))
+* detect disk image error tables by exact image size ([baa2091](https://github.com/elektronaut/badline/commit/baa20918b345723003ff61936c791f476e478fe8))
+* detect the error table on 42-track D64 images ([9d8be41](https://github.com/elektronaut/badline/commit/9d8be41ffd23f0984f26e8e2c3ec0ba692629df9))
+* end a SAVE the host directory can't write like a failed drive write ([4d15efe](https://github.com/elektronaut/badline/commit/4d15efe815d809fb7eba84cc9d59aebb4964f4ad))
+* fail writes to a disk image like a write-protected 1541 ([c4ccb46](https://github.com/elektronaut/badline/commit/c4ccb46382166a896875a4f081c13db7841aaf7d))
+* hand LOADs that reach below $0334 to the ROM's byte loop ([948b816](https://github.com/elektronaut/badline/commit/948b8163d0ba16d4eb4c71ee03ab4fe59297ba56))
+* power-cycle the machine when a cartridge is attached ([2e1d7a4](https://github.com/elektronaut/badline/commit/2e1d7a472f00e0ccbd7a3245db7c685162e40786))
+* print the KERNAL's SAVING message from the SAVE trap ([c912986](https://github.com/elektronaut/badline/commit/c912986e1702ba9907a097aaebd62b36e83b1fe5))
+* print the KERNAL's SEARCHING and LOADING messages from the LOAD trap ([fc7e719](https://github.com/elektronaut/badline/commit/fc7e719e0856b8eddafbb96402893570cf757842))
+* report the DOS version on the command channel at drive power-on ([016ad3f](https://github.com/elektronaut/badline/commit/016ad3f884a2fb1160f30372acd1ae972d0b9702))
+* reset the virtual drive on the U-command reset forms ([a558314](https://github.com/elektronaut/badline/commit/a558314e7f116a28c8341ca82acce65c94469b9d))
+* stop LOADs and file reads at a block the error table marks bad ([457be18](https://github.com/elektronaut/badline/commit/457be18351af7241a26f76631ec9bfad0ce2306e))
+
 ## [0.2.0](https://github.com/elektronaut/badline/compare/v0.1.0...v0.2.0) (2026-09-23)
 
 

data/lib/badline/address_bus.rb

@@ -45,12 +45,14 @@ module Badline
     PORT_FLOATING = 0b1100_1000
     TAPE_SENSE    = 0b0001_0000
 
+    RAM_POWER_ON = [0xff, 0x07].freeze
+
     attr_reader :io_port, :ram, :basic_rom, :character_rom, :kernal_rom,
                 :vic, :sid, :color_ram, :cia1, :cia2, :keyboard, :joystick1, :joystick2,
                 :control_ports, :cartridge, :ultimax, :phi1_ultimax, :datasette
 
     def initialize(sid_model: :mos6581)
-      @ram = Memory.new([0xff, 0x07], length: 2**16, start: 0)
+      @ram = Memory.new(RAM_POWER_ON, length: 2**16, start: 0)
       @cartridge = nil
       @debug_register = nil
 
@@ -79,7 +81,7 @@ module Badline
       @port_ddr = 0x00
       @port_out = 0x00
       @port_floating = 0x00
-      @io_port = Status.new(%i[basic kernal io tape_out tape_switch tape_motor], value: port_value)
+      @io_port = PortStatus.new(%i[basic kernal io tape_out tape_switch tape_motor], value: port_value)
 
       @read_pages = Array.new(256)
       @write_pages = Array.new(256)
@@ -93,6 +95,10 @@ module Badline
       update_overlays!
     end
 
+    def power_on!
+      @ram.clear!(RAM_POWER_ON)
+    end
+
     # The 6510's RES line clears the port's direction and output registers.
     # The floating bits keep their charge.
     def reset_port!

data/lib/badline/cartridge.rb

@@ -35,12 +35,12 @@ module Badline
     BANK_SIZE = 0x2000
 
     HARDWARE_TYPES = {
-      0 => :Standard, 1 => :ActionReplay, 2 => :KCSPower, 3 => :FinalCartridge3,
-      4 => :SimonsBasic, 5 => :Ocean, 7 => :FunPlay, 8 => :SuperGames,
-      9 => :AtomicPower, 10 => :EpyxFastload, 11 => :Westermann,
-      12 => :RexUtility, 15 => :GameSystem, 17 => :Dinamic, 18 => :Zaxxon,
-      19 => :MagicDesk, 21 => :Comal80, 32 => :EasyFlash, 36 => :RetroReplay,
-      51 => :Mach5, 53 => :Pagefox, 57 => :RGCD, 60 => :GMod2
+      0 => Standard, 1 => ActionReplay, 2 => KCSPower, 3 => FinalCartridge3,
+      4 => SimonsBasic, 5 => Ocean, 7 => FunPlay, 8 => SuperGames,
+      9 => AtomicPower, 10 => EpyxFastload, 11 => Westermann,
+      12 => RexUtility, 15 => GameSystem, 17 => Dinamic, 18 => Zaxxon,
+      19 => MagicDesk, 21 => Comal80, 32 => EasyFlash, 36 => RetroReplay,
+      51 => Mach5, 53 => Pagefox, 57 => RGCD, 60 => GMod2
     }.freeze
 
     # The EXROM and GAME line levels of each memory configuration. The lines
@@ -62,11 +62,11 @@ module Badline
       end
 
       def from_crt(crt, **)
-        type = HARDWARE_TYPES.fetch(crt.hardware_type) do
+        mapper = HARDWARE_TYPES.fetch(crt.hardware_type) do
           raise UnsupportedTypeError,
                 "Unsupported cartridge hardware type #{crt.hardware_type}"
         end
-        const_get(type).new(crt, **)
+        mapper.new(crt, **)
       end
     end
 

data/lib/badline/cia/interrupt_register.rb

@@ -9,8 +9,8 @@ module Badline
       attr_reader :status, :mask, :quiet
 
       def initialize
-        @mask = Status.new([:timer_a, :timer_b, :alarm, :serial, :flag, 0, 0, 0])
-        @status = Status.new([:timer_a, :timer_b, :alarm, :serial, :flag, 0, 0, :interrupt])
+        @mask = InterruptFlags.new([:timer_a, :timer_b, :alarm, :serial, :flag, 0, 0, 0])
+        @status = InterruptFlags.new([:timer_a, :timer_b, :alarm, :serial, :flag, 0, 0, :interrupt])
         @pending = 0
         @read = @read_last_cycle = @read_two_cycles_ago = nil
         @timer_b_bug = false
@@ -40,8 +40,9 @@ module Badline
 
       # Latch a source, pulling the interrupt line if it is armed.
       def flag(source)
-        status.public_send(:"#{source}=", true)
-        assert! if mask.public_send(:"#{source}?")
+        bit = source_bit(source)
+        @status.value |= bit
+        assert! if mask.value.anybits?(bit)
       end
 
       # The 6526 timer B bug: an underflow on the cycle after a read still
@@ -70,9 +71,9 @@ module Badline
       # Bit 7 picks between setting and clearing the mask bits given.
       def write(value)
         if value.nobits?(0x80)
-          mask.value &= ~(value & 0x1f)
+          @mask.value &= ~(value & 0x1f)
         else
-          mask.value |= (value & 0x1f)
+          @mask.value |= (value & 0x1f)
         end
         if mask.value.anybits?(status.value & 0x1f)
           assert!(2) unless interrupted?
@@ -83,6 +84,19 @@ module Badline
           @pending = 0
         end
       end
+
+      private
+
+      def source_bit(source)
+        case source
+        when :timer_a then 0x01
+        when :timer_b then 0x02
+        when :alarm then 0x04
+        when :serial then 0x08
+        when :flag then 0x10
+        else raise ArgumentError, "unknown interrupt source #{source}"
+        end
+      end
     end
   end
 end

data/lib/badline/cia.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "forwardable"
 require "badline/cia/interrupt_register"
 require "badline/cia/serial"
 require "badline/cia/timer"
@@ -9,22 +8,38 @@ module Badline
   # CIA (Complex Interface Adapter) chip
   class CIA
     include Addressable
-    extend Forwardable
 
     attr_reader :start, :control_a, :control_b, :peripheral, :serial
 
-    def_delegator :@icr, :status, :interrupt_status
-    def_delegator :@icr, :mask,   :interrupt_control
-    def_delegator :@icr, :assert!, :interrupt!
+    def interrupt_status = @icr.status
 
-    def_delegator :@ta, :counter,  :timer_a
-    def_delegator :@ta, :counter=, :timer_a=
-    def_delegator :@ta, :latch,    :timer_a_latch
-    def_delegator :@ta, :latch=,   :timer_a_latch=
-    def_delegator :@tb, :counter,  :timer_b
-    def_delegator :@tb, :counter=, :timer_b=
-    def_delegator :@tb, :latch,    :timer_b_latch
-    def_delegator :@tb, :latch=,   :timer_b_latch=
+    def interrupt_control = @icr.mask
+
+    def interrupt!(delay = 1) = @icr.assert!(delay)
+
+    def timer_a = @ta.counter
+
+    def timer_a=(value)
+      @ta.counter = value
+    end
+
+    def timer_a_latch = @ta.latch
+
+    def timer_a_latch=(value)
+      @ta.latch = value
+    end
+
+    def timer_b = @tb.counter
+
+    def timer_b=(value)
+      @tb.counter = value
+    end
+
+    def timer_b_latch = @tb.latch
+
+    def timer_b_latch=(value)
+      @tb.latch = value
+    end
 
     def initialize(start: 0, peripheral: nil)
       addressable_at(start, length: 2**8)
@@ -49,10 +64,10 @@ module Badline
       @tod = TimeOfDay.new
       @icr = InterruptRegister.new
       @icr_status = @icr.status
-      @control_a = Status.new(%i[start output out_mode run_mode load
-                                 in_mode serial_mode clock_frequency])
-      @control_b = Status.new(%i[start output out_mode run_mode load
-                                 in_cnt in_timer_a alarm])
+      @control_a = ControlRegister.new(%i[start output out_mode run_mode load
+                                          in_mode serial_mode clock_frequency])
+      @control_b = ControlRegister.new(%i[start output out_mode run_mode load
+                                          in_cnt in_timer_a alarm])
       @ta = Timer.new(@control_a)
       @tb = Timer.new(@control_b)
       @serial = Serial.new(@control_a)

data/lib/badline/computer.rb

@@ -1,17 +1,33 @@
 # frozen_string_literal: true
 
-require "forwardable"
-
 module Badline
   class Computer
     include IntegerHelper
     include KeyboardBuffer
-    extend Forwardable
 
     attr_reader :address_bus, :cpu, :cycles
 
-    def_delegators :address_bus, :vic, :cia1, :cia2, :sid, :ram, :keyboard, :joystick1, :joystick2,
-                   :control_ports, :datasette, :install_debug_register
+    def vic = address_bus.vic
+
+    def cia1 = address_bus.cia1
+
+    def cia2 = address_bus.cia2
+
+    def sid = address_bus.sid
+
+    def ram = address_bus.ram
+
+    def keyboard = address_bus.keyboard
+
+    def joystick1 = address_bus.joystick1
+
+    def joystick2 = address_bus.joystick2
+
+    def control_ports = address_bus.control_ports
+
+    def datasette = address_bus.datasette
+
+    def install_debug_register(&) = address_bus.install_debug_register(&)
 
     def initialize(debug: false, sid_model: :mos6581)
       @address_bus = AddressBus.new(sid_model:)
@@ -64,6 +80,15 @@ module Badline
       cartridge.clock = -> { @cycles }
       cartridge.on_nmi_change { |level| @cartridge_nmi = level }
       address_bus.attach_cartridge(cartridge)
+      power_cycle!
+    end
+
+    # A cartridge goes in with the power off, so attaching one switches the
+    # machine off and on: the VIC and RAM start from their power-on state,
+    # and the RES line resets everything else.
+    def power_cycle!
+      vic.power_on!
+      address_bus.power_on!
       reset!
     end
 
@@ -96,9 +121,9 @@ module Badline
     end
 
     def mount(storage)
-      load_trap = KernalTrap::Load.new(cpu:, bus: address_bus, storage:)
-      cpu.install_trap(KernalTrap::Load::ADDRESS) { load_trap.call }
       drive = KernalTrap::Drive.new(storage)
+      load_trap = KernalTrap::Load.new(cpu:, bus: address_bus, drive:)
+      cpu.install_trap(KernalTrap::Load::ADDRESS) { load_trap.call }
       KernalTrap::Serial.new(cpu:, bus: address_bus, drive:).install
       return unless storage.respond_to?(:write_file)
 

data/lib/badline/cpu/microcode.rb

@@ -107,60 +107,58 @@ module Badline
     # - +optional_dummy+: true for indexed reads, which skip the extra
     #   cycle unless indexing crosses a page
     Microcode = Struct.new(:operation, :plan, :writes, :optional_dummy) do
-      class << self
-        def table
-          Array.new(256) do |opcode|
-            instruction = Instruction.find(opcode)
-            raise InvalidOpcodeError, format("$%02x", opcode) unless instruction
-
-            build(instruction)
-          end.freeze
-        end
+      def self.table
+        Array.new(256) do |opcode|
+          instruction = Instruction.find(opcode)
+          raise InvalidOpcodeError, format("$%02x", opcode) unless instruction
 
-        def write_mask(plan)
-          plan.map { |step| WRITE_STEPS.include?(step) }.freeze
-        end
+          build(instruction)
+        end.freeze
+      end
 
-        private
+      def self.write_mask(plan)
+        plan.map { |step| WRITE_STEPS.include?(step) }.freeze
+      end
 
-        def build(instruction)
-          plan = plan_for(instruction)
-          new(instruction.name, plan, write_mask(plan),
-              instruction.boundary_cycle?)
-        end
+      def self.build(instruction)
+        plan = plan_for(instruction)
+        new(instruction.name, plan, write_mask(plan),
+            instruction.boundary_cycle?)
+      end
 
-        def plan_for(instruction)
-          case instruction.name
-          when :jmp
-            if instruction.addressing_mode == :indirect
-              JMP_INDIRECT_PLAN
-            else
-              JMP_ABSOLUTE_PLAN
-            end
-          when *BRANCHES then BRANCH_PLAN
-          else SPECIAL_PLANS[instruction.name] || addressed_plan(instruction)
+      def self.plan_for(instruction)
+        case instruction.name
+        when :jmp
+          if instruction.addressing_mode == :indirect
+            JMP_INDIRECT_PLAN
+          else
+            JMP_ABSOLUTE_PLAN
           end
+        when *BRANCHES then BRANCH_PLAN
+        else SPECIAL_PLANS[instruction.name] || addressed_plan(instruction)
         end
+      end
 
-        def addressed_plan(instruction)
-          mode = instruction.addressing_mode
-          case mode
-          when :implied then IMPLIED_PLAN
-          when :accumulator then ACCUMULATOR_PLAN
-          when :immediate then IMMEDIATE_PLAN
-          else
-            [:op_fetch, *ADDRESSING_STEPS.fetch(mode),
-             *OPERATION_STEPS.fetch(operation_kind(instruction.name))].freeze
-          end
+      def self.addressed_plan(instruction)
+        mode = instruction.addressing_mode
+        case mode
+        when :implied then IMPLIED_PLAN
+        when :accumulator then ACCUMULATOR_PLAN
+        when :immediate then IMMEDIATE_PLAN
+        else
+          [:op_fetch, *ADDRESSING_STEPS.fetch(mode),
+           *OPERATION_STEPS.fetch(operation_kind(instruction.name))].freeze
         end
+      end
 
-        def operation_kind(name)
-          return :write if STORES.include?(name)
-          return :rmw if READ_MODIFY_WRITES.include?(name)
+      def self.operation_kind(name)
+        return :write if STORES.include?(name)
+        return :rmw if READ_MODIFY_WRITES.include?(name)
 
-          :read
-        end
+        :read
       end
+
+      private_class_method :build, :plan_for, :addressed_plan, :operation_kind
     end
 
     FETCH_WRITES = Microcode.write_mask(FETCH_PLAN)

data/lib/badline/cpu.rb

@@ -28,7 +28,7 @@ module Badline
       @debug = debug
       @ane_constant = ane_constant
       @memory = memory || Memory.new
-      @status = Status.new(STATUS_FLAGS, value: 0b00100000)
+      @status = CPUStatus.new(STATUS_FLAGS, value: 0b00100000)
       reset_registers
 
       @nmi = @irq = false

data/lib/badline/kernal_trap/channel.rb

@@ -4,12 +4,30 @@ 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_reader :error
 
-      def initialize(bytes = [])
+      def initialize(bytes = [], error: nil)
         replace(bytes)
+        @error = error
+      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
 
       def replace(bytes)
@@ -26,7 +44,7 @@ module Badline
 
         byte = @bytes[@pointer]
         @pointer += 1
-        [byte, exhausted?]
+        [byte, exhausted? && !@error]
       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