badline 0.12.1 → 0.14.0

data/lib/badline/kernal_trap/{drive → dos}/channels.rb

@@ -2,7 +2,7 @@
 
 module Badline
   module KernalTrap
-    class Drive
+    class DOS
       # 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
@@ -22,31 +22,6 @@ module Badline
 
         def clear = @channels.clear
 
-        # Each open channel with its secondary address, in the order they
-        # opened.
-        def save_state(out)
-          out.int(@channels.length)
-          @channels.each do |secondary, channel|
-            out.int(secondary)
-            channel.save_state(out)
-          end
-        end
-
-        # Buffer channels take their block in the drive's RAM again.
-        def load_state(input, memory)
-          @channels.clear
-          input.int.times do
-            secondary = input.int
-            @channels[secondary] = Channels.channel_from_state(input, memory.ram)
-          end
-        end
-
-        # A channel save_state wrote: a file open for writing, or a Channel
-        # whose buffer, if it has one, is in `ram`.
-        def self.channel_from_state(input, ram)
-          input.boolean? ? WriteFile.from_state(input) : Channel.from_state(input, ram)
-        end
-
         # 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.

data/lib/badline/kernal_trap/{drive → dos}/memory.rb

@@ -2,7 +2,7 @@
 
 module Badline
   module KernalTrap
-    class Drive
+    class DOS
       # 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
@@ -62,15 +62,6 @@ module Badline
           load_buffer(Channels::BAM_BUFFER, block) if block
         end
 
-        def save_state(out)
-          out.blob(@ram).boolean(@bam)
-        end
-
-        def load_state(input)
-          input.blob_into(@ram)
-          @bam = input.boolean?
-        end
-
         # Whether the BAM has been read since the last reset.
         def bam? = @bam
 

data/lib/badline/kernal_trap/{drive → dos}/parameters.rb

@@ -2,7 +2,7 @@
 
 module Badline
   module KernalTrap
-    class Drive
+    class DOS
       # 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

data/lib/badline/kernal_trap/{drive → dos}/status.rb

@@ -2,7 +2,7 @@
 
 module Badline
   module KernalTrap
-    class Drive
+    class DOS
       # 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.
@@ -37,14 +37,6 @@ module Badline
           nil
         end
 
-        def save_state(out)
-          @channel.save_state(out)
-        end
-
-        def load_state(input)
-          @channel = Channels.channel_from_state(input, [])
-        end
-
         def replace(bytes)
           @channel.replace(bytes)
         end

data/lib/badline/kernal_trap/{drive → dos}/write_file.rb

@@ -2,7 +2,7 @@
 
 module Badline
   module KernalTrap
-    class Drive
+    class DOS
       # 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
@@ -14,14 +14,6 @@ module Badline
         TYPES = %i[del seq prg usr rel].freeze
         MODES = %i[write replace append].freeze
 
-        # Reads what save_state wrote after the flag that marks a file
-        # open for writing.
-        def self.from_state(input)
-          name = input.string
-          type = TYPES.fetch(input.int).to_sym
-          new(name, type, mode: MODES.fetch(input.int).to_sym).tap { |file| file.load_state(input) }
-        end
-
         def initialize(name, type, mode: :write)
           @name = name
           @type = type
@@ -29,16 +21,6 @@ module Badline
           @bytes = []
         end
 
-        def save_state(out)
-          out.boolean(true).string(@name).int(TYPES.index(@type)).int(MODES.index(@mode))
-          out.blob(@bytes).optional_int(@buffer)
-        end
-
-        def load_state(input)
-          @bytes = input.blob
-          @buffer = input.optional_int
-        end
-
         def write(bytes) = @bytes.concat(bytes)
 
         def writable? = true

data/lib/badline/kernal_trap/{drive → dos}/writes.rb

@@ -2,7 +2,7 @@
 
 module Badline
   module KernalTrap
-    class Drive
+    class DOS
       # 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

data/lib/badline/kernal_trap/{drive.rb → dos.rb}

@@ -1,12 +1,13 @@
 # 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"
-require "badline/kernal_trap/drive/writes"
-require "badline/kernal_trap/drive/write_file"
+require "badline/kernal_trap/dos/block_commands"
+require "badline/kernal_trap/dos/channel"
+require "badline/kernal_trap/dos/channels"
+require "badline/kernal_trap/dos/memory"
+require "badline/kernal_trap/dos/parameters"
+require "badline/kernal_trap/dos/status"
+require "badline/kernal_trap/dos/writes"
+require "badline/kernal_trap/dos/write_file"
 
 module Badline
   module KernalTrap
@@ -16,7 +17,7 @@ module Badline
     # 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
+    class DOS
       include BlockCommands
       include Writes
 
@@ -146,25 +147,6 @@ module Badline
       # vector, as U: does.
       def reset! = reset(cold: true)
 
-      # The mounted storage's setup, for Storage.reopen, then the drive's
-      # RAM, its status and its open channels.
-      def save_state(out)
-        @storage.save_setup(out)
-        out.marker("TRAP DRIVE")
-        @memory.save_state(out)
-        @status.save_state(out)
-        @channels.save_state(out)
-      end
-
-      # Takes the state after the storage's setup, into a drive mounted on
-      # the reopened storage.
-      def load_state(input)
-        input.marker("TRAP DRIVE")
-        @memory.load_state(input)
-        @status.load_state(input)
-        @channels.load_state(input, @memory)
-      end
-
       # Returns the next byte and whether it is the channel's last, or nil
       # when there is nothing left to send.
       def read(secondary)

data/lib/badline/kernal_trap/file_routine.rb

@@ -6,17 +6,17 @@ module Badline
       private
 
       def active?
-        kernal_mapped? && @bus.peek(0xba) == DEVICE
+        kernal_mapped? && @bus.peek(zero_page.device) == DEVICE
       end
 
       def filename
         Storage.strip_drive_prefix(full_filename)
       end
 
-      # Filename pointer at $BB/$BC, length at $B7
+      # The file name FNADR points to, FNLEN bytes long.
       def full_filename
-        pointer = uint16(@bus.peek(0xbb), @bus.peek(0xbc))
-        bytes = Array.new(@bus.peek(0xb7)) do |i|
+        pointer = peek_word(zero_page.filename_address)
+        bytes = Array.new(@bus.peek(zero_page.filename_length)) do |i|
           @layout.filename_byte(@bus, (pointer + i) & 0xffff)
         end
         Storage.ascii(bytes)

data/lib/badline/kernal_trap/keyed_state.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Badline
+  module KernalTrap
+    class DOS
+      class Channel
+        # A channel's fields under `prefix`: whether it is a buffer in the
+        # drive's RAM, where it starts and ends, the pointer, the byte it
+        # leads with and its buffer's number, the error it reports once its
+        # bytes run out, and a file's bytes.
+        def save_fields(out, prefix)
+          out.text("#{prefix}kind", "channel").bool("#{prefix}writable", @writable).int("#{prefix}base", @base)
+          out.int("#{prefix}length", @length).int("#{prefix}pointer", @pointer).optional_int("#{prefix}lead", @lead)
+          out.optional_int("#{prefix}buffer", @buffer)
+          error = @error
+          out.ints("#{prefix}error", error) if error
+          out.bytes("#{prefix}bytes", @bytes) unless @writable
+        end
+
+        # A buffer channel's bytes are the drive's `ram`.
+        def load_fields(input, prefix, ram)
+          @writable = input.bool("#{prefix}writable", false)
+          @base = input.int("#{prefix}base", 0)
+          @length = input.int("#{prefix}length", 0)
+          @pointer = input.int("#{prefix}pointer", 0)
+          @lead = input.optional_int("#{prefix}lead")
+          @buffer = input.optional_int("#{prefix}buffer")
+          error = input.ints("#{prefix}error", [])
+          @error = error.empty? ? nil : error.dup
+          @bytes = @writable ? ram : input.bytes("#{prefix}bytes", "".b).bytes
+          self
+        end
+      end
+
+      class WriteFile
+        # A file open for writing, under `prefix`: its name, type and mode,
+        # the bytes written so far and the byte held back.
+        def save_fields(out, prefix)
+          out.text("#{prefix}kind", "write_file").bytes("#{prefix}name", @name.b).text("#{prefix}type", @type.to_s)
+          out.text("#{prefix}mode", @mode.to_s).bytes("#{prefix}bytes", @bytes).optional_int("#{prefix}held", @buffer)
+        end
+
+        def self.from_fields(input, prefix)
+          type = input.choice("#{prefix}type", TYPES.map(&:to_s), "prg")
+          mode = input.choice("#{prefix}mode", MODES.map(&:to_s), "write")
+          new(input.bytes("#{prefix}name", "".b), TYPES.find { |each| each.to_s == type } || :prg,
+              mode: MODES.find { |each| each.to_s == mode } || :write).tap do |file|
+            file.load_fields(input, prefix)
+          end
+        end
+
+        def load_fields(input, prefix)
+          @bytes = input.bytes("#{prefix}bytes", "".b).bytes
+          @buffer = input.optional_int("#{prefix}held")
+        end
+      end
+
+      class Channels
+        # The channels open, by secondary address, each under channel<SA>.
+        def save_fields(out)
+          out.ints("channels", @channels.keys)
+          @channels.each { |secondary, channel| channel.save_fields(out, "channel#{secondary}.") }
+        end
+
+        def load_fields(input, ram)
+          @channels.clear
+          input.ints("channels", []).each do |secondary|
+            @channels[secondary] = Channels.channel_from_fields(input, "channel#{secondary}.", ram)
+          end
+        end
+
+        def self.channel_from_fields(input, prefix, ram)
+          return WriteFile.from_fields(input, prefix) if input.text("#{prefix}kind", "channel") == "write_file"
+
+          Channel.new.load_fields(input, prefix, ram)
+        end
+      end
+
+      class Status
+        # The error channel, under status.
+        def save_fields(out) = @channel.save_fields(out, "status.")
+
+        def load_fields(input)
+          input.choice("status.kind", ["channel"], "channel")
+          @channel = Channel.new.load_fields(input, "status.", [])
+        end
+      end
+
+      class Memory
+        # The drive's RAM, and whether the BAM has been read.
+        def save_fields(out)
+          out.bytes("ram", @ram).bool("bam", @bam)
+        end
+
+        def load_fields(input)
+          input.bytes_into("ram", @ram)
+          @bam = input.bool("bam", @bam)
+        end
+      end
+
+      # The storage device 8 serves.
+      attr_reader :storage
+
+      # The DOS's fields in a keyed snapshot module (BL-TRAPDOS), after the
+      # storage's under storage.*: its RAM, the error channel and the
+      # channels open.
+      def save_fields(out)
+        @memory.save_fields(out)
+        @status.save_fields(out)
+        @channels.save_fields(out)
+      end
+
+      def load_fields(input)
+        @memory.load_fields(input)
+        @status.load_fields(input)
+        @channels.load_fields(input, @memory.ram)
+      end
+    end
+
+    class Serial
+      # The serial trap's fields under `prefix`: whether device 8 listens
+      # or talks, on which channel, the frame it is in and the bytes it has
+      # gathered.
+      def save_fields(out, prefix)
+        out.bool("#{prefix}listening", @listening).bool("#{prefix}talking", @talking)
+        out.optional_int("#{prefix}listen_channel", @listen_channel)
+        out.optional_int("#{prefix}talk_channel", @talk_channel).int("#{prefix}frame", @frame)
+        out.bytes("#{prefix}buffer", @buffer)
+      end
+
+      def load_fields(input, prefix)
+        @listening = input.bool("#{prefix}listening", @listening)
+        @talking = input.bool("#{prefix}talking", @talking)
+        @listen_channel = input.optional_int("#{prefix}listen_channel")
+        @talk_channel = input.optional_int("#{prefix}talk_channel")
+        @frame = input.int("#{prefix}frame", @frame)
+        @buffer = input.bytes("#{prefix}buffer", "".b).bytes
+      end
+    end
+
+    class Save
+      # Whether a SAVE is under way, under `prefix`.
+      def save_fields(out, prefix) = out.bool("#{prefix}saving", @saving)
+
+      def load_fields(input, prefix)
+        @saving = input.bool("#{prefix}saving", @saving)
+      end
+    end
+  end
+end

data/lib/badline/kernal_trap/layout.rb

@@ -20,7 +20,11 @@ module Badline
     # +banked+ says whether the 6510 port can bank the KERNAL out, and so
     # whether RAM lies under every ROM and the I/O. +mmu+ says the C128's
     # MMU maps the KERNAL instead, and that the file name and the file's
-    # bytes lie in the banks the KERNAL keeps at FNBANK and BA. Each
+    # bytes lie in the banks the KERNAL keeps at FNBANK and BA.
+    # +rom_select+ says the 264 series' TED selects ROM or RAM and its
+    # latch the ROM banks, so the KERNAL is in while ROM is selected with
+    # the KERNAL's bank, and the ROM reads the file name and the file's
+    # bytes from RAM, under any ROM, through its bank fetch at $07D9. Each
     # serial byte starts a one-shot timer by writing the high byte of its
     # count to +serial_timer+, and the control value TIMER_ONE_SHOT_START
     # to +serial_timer_start+ where the timer has a control register to
@@ -29,16 +33,19 @@ module Badline
     # +serial_timer+. The ROM lets go of each serial line by reading a
     # port, masking the line's bit off and writing it back: ATN at
     # +atn_port+ with +atn_mask+, then the clock and the data line.
+    # +zero_page+ is a ZeroPage, where the KERNAL keeps the file's
+    # parameters and the status the traps read and set.
     Layout = Data.define(:load, :save, :searching_message, :loading_message, :load_byte_loop, :load_done,
                          :file_not_found_exit, :missing_file_name_exit, :saving_message, :clock_release,
                          :data_release, :save_done, :talk, :listen, :second, :tksa, :ciout, :untalk,
                          :unlisten, :acptr, :banked, :serial_timer, :serial_timer_start, :atn_port, :atn_mask,
-                         :clock_port, :clock_mask, :data_port, :data_mask, :mmu) do
+                         :clock_port, :clock_mask, :data_port, :data_mask, :mmu, :rom_select, :zero_page) do
       # Whether the CPU reads the KERNAL ROM at the trapped addresses: on a
-      # banked machine, the 6510 port's banking bits select it, and on the
-      # C128 the MMU.
+      # banked machine, the 6510 port's banking bits select it, on the
+      # C128 the MMU, and on the 264 series the ROM select and bank latch.
       def kernal_mapped?(bus)
         return bus.system_rom_mapped? if mmu
+        return bus.kernal_selected? if rom_select
 
         !banked || bus.io_port.kernal?
       end
@@ -55,15 +62,21 @@ module Badline
       end
 
       # The file name's byte at +address+, in the bank at FNBANK on the
-      # C128.
+      # C128 and in RAM on the 264 series.
       def filename_byte(bus, address)
-        mmu ? bus.peek_bank(bus.peek(FILENAME_BANK), address) : bus.peek(address)
+        return bus.peek_bank(bus.peek(FILENAME_BANK), address) if mmu
+        return bus.ram_view.peek(address) if rom_select
+
+        bus.peek(address)
       end
 
       # The byte at +address+ a SAVE writes or a VERIFY compares, in the bank
-      # at BA on the C128.
+      # at BA on the C128 and in RAM on the 264 series.
       def file_byte(bus, address)
-        mmu ? bus.peek_bank(bus.peek(BANK), address) : bus.peek(address)
+        return bus.peek_bank(bus.peek(BANK), address) if mmu
+        return bus.ram_view.peek(address) if rom_select
+
+        bus.peek(address)
       end
 
       # Starts the timer the ROM times a serial byte with, its count's high
@@ -95,6 +108,32 @@ module Badline
       end
     end
 
+    # The zero-page variables of a KERNAL's file routines, by address:
+    # +status+ (ST), +verify+ (VERCK, 0 for LOAD and 1 for VERIFY),
+    # +start_address+ (SAL), +end_address+ (EAL), +filename_length+
+    # (FNLEN), +secondary_address+ (SA), +device+ (FA), +filename_address+
+    # (FNADR), +save_start+ (STAL) and +load_address+ (MEMUSS, where LOAD
+    # puts a file loaded with secondary address 0). Each two-byte one names
+    # its low byte, and the high byte follows it.
+    ZeroPage = Data.define(:status, :verify, :start_address, :end_address, :filename_length, :secondary_address,
+                           :device, :filename_address, :save_start, :load_address)
+
+    # The C64's file variables. The VIC-20 and C128 KERNALs keep theirs at
+    # the same addresses.
+    C64_ZERO_PAGE = ZeroPage.new(
+      status: 0x90, verify: 0x93, start_address: 0xac, end_address: 0xae, filename_length: 0xb7,
+      secondary_address: 0xb9, device: 0xba, filename_address: 0xbb, save_start: 0xc1, load_address: 0xc3
+    )
+
+    # The 264 series KERNAL's file variables, as its LOAD ($F04A) and SAVE
+    # ($F1A4) use them: SAVE walks SAL at $9B from STAL at $B2 up to EAL at
+    # $9D, and LOAD ends with EAL at $9D, or starts it from MEMUSS at $B4
+    # for secondary address 0.
+    PLUS4_ZERO_PAGE = ZeroPage.new(
+      status: 0x90, verify: 0x93, start_address: 0x9b, end_address: 0x9d, filename_length: 0xab,
+      secondary_address: 0xad, device: 0xae, filename_address: 0xaf, save_start: 0xb2, load_address: 0xb4
+    )
+
     # A CIA's control value that starts its timer: force load, one-shot,
     # start.
     TIMER_ONE_SHOT_START = 0x19
@@ -117,7 +156,7 @@ module Badline
       ciout: 0xeddd, untalk: 0xedef, unlisten: 0xedfe, acptr: 0xee13,
       banked: true, serial_timer: 0xdc07, serial_timer_start: 0xdc0f,
       atn_port: 0xdd00, atn_mask: 0xf7, clock_port: 0xdd00, clock_mask: 0xef, data_port: 0xdd00, data_mask: 0xdf,
-      mmu: false
+      mmu: false, rom_select: false, zero_page: C64_ZERO_PAGE
     )
 
     # The VIC-20 KERNAL, 901486-07 (PAL). The NTSC one, 901486-06, differs
@@ -135,7 +174,7 @@ module Badline
       ciout: 0xeee4, untalk: 0xeef6, unlisten: 0xef04, acptr: 0xef19,
       banked: false, serial_timer: 0x9129, serial_timer_start: nil,
       atn_port: 0x911f, atn_mask: 0x7f, clock_port: 0x912c, clock_mask: 0xfd, data_port: 0x912c, data_mask: 0xdf,
-      mmu: false
+      mmu: false, rom_select: false, zero_page: C64_ZERO_PAGE
     )
 
     # The C128 KERNAL, 318020-05, in C128 mode: the jump table's targets
@@ -156,7 +195,32 @@ module Badline
       ciout: 0xe503, untalk: 0xe515, unlisten: 0xe526, acptr: 0xe43e,
       banked: true, serial_timer: nil, serial_timer_start: nil,
       atn_port: 0xdd00, atn_mask: 0xf7, clock_port: 0xdd00, clock_mask: 0xef, data_port: 0xdd00, data_mask: 0xdf,
-      mmu: true
+      mmu: true, rom_select: false, zero_page: C64_ZERO_PAGE
+    )
+
+    # The 264 series KERNAL, 318004-05 (PAL), the same at every address
+    # here in the NTSC 318005-05: ILOAD's and ISAVE's default targets and
+    # the jump table's targets for the serial primitives, each of which
+    # tries a 1551's TCBM interface for devices 8 and 9 before the serial
+    # bus. LOAD prints SEARCHING FOR at $F160 and LOADING or VERIFYING at
+    # $F189, which ends CLC, retries a byte from $F09F and returns at $F0EB
+    # (LDX $9D, LDY $9E, RTS). FILE NOT FOUND leaves through $F27C and
+    # MISSING FILE NAME through $F288. SAVE prints SAVING at $F228 and
+    # returns at $F226 (CLC, RTS). The port at $01 drives the lines, ATN
+    # from bit 2, the clock from bit 1 ($E2B8 lets it go) and the data line
+    # from bit 0 ($E2C6). Its serial bytes are timed with TED timer 2, but
+    # its timeouts differ from the C64's, so the traps leave the timer
+    # alone.
+    PLUS4_LAYOUT = Layout.new(
+      load: 0xf04a, save: 0xf1a4,
+      searching_message: 0xf160, loading_message: 0xf189, load_byte_loop: 0xf09f, load_done: 0xf0eb,
+      file_not_found_exit: 0xf27c, missing_file_name_exit: 0xf288,
+      saving_message: 0xf228, clock_release: 0xe2b8, data_release: 0xe2c6, save_done: 0xf226,
+      talk: 0xedfa, listen: 0xee2c, second: 0xee4d, tksa: 0xee1a,
+      ciout: 0xecdf, untalk: 0xef3b, unlisten: 0xef23, acptr: 0xec8b,
+      banked: false, serial_timer: nil, serial_timer_start: nil,
+      atn_port: 0x01, atn_mask: 0xfb, clock_port: 0x01, clock_mask: 0xfd, data_port: 0x01, data_mask: 0xfe,
+      mmu: false, rom_select: true, zero_page: PLUS4_ZERO_PAGE
     )
   end
 end

data/lib/badline/kernal_trap/load.rb

@@ -23,22 +23,22 @@ module Badline
       # address even when the first one relocated.
       LOAD_SECONDARY = 0x60
 
-      def initialize(cpu:, bus:, layout:, drive:)
+      def initialize(cpu:, bus:, layout:, dos:)
         super(cpu:, bus:, layout:)
-        @drive = drive
+        @dos = dos
       end
 
       def call
         return unless active?
 
-        @bus.poke(0x93, @cpu.a)
-        @bus.poke(0x90, 0x00)
+        @bus.poke(zero_page.verify, @cpu.a)
+        @bus.poke(zero_page.status, 0x00)
         name = filename
         return @cpu.program_counter = @layout.missing_file_name_exit if Storage.parse_name(name).first.empty?
 
         data, complete = receive(name)
         if low_memory?(data)
-          @drive.close(0)
+          @dos.close(0)
         else
           finish(data, complete)
         end
@@ -50,10 +50,10 @@ module Badline
       # flagged EOI. A read error in the file's chain stops the bytes early,
       # with no EOI.
       def receive(name)
-        @drive.open(0, name)
+        @dos.open(0, name)
         data = []
         loop do
-          byte, eoi = @drive.read(0)
+          byte, eoi = @dos.read(0)
           return [data, false] unless byte
 
           data << byte
@@ -66,17 +66,17 @@ module Badline
       # until RUN/STOP breaks the load, as on a real drive.
       def finish(data, complete)
         if data.empty?
-          @bus.poke(0x90, EOI | READ_TIMEOUT)
+          @bus.poke(zero_page.status, EOI | READ_TIMEOUT)
           leave_bus(ACPTR_TIMEOUT)
           continue_with(@layout.searching_message, @layout.file_not_found_exit)
         else
           deliver(data)
-          @bus.poke(0x90, @bus.peek(0x90) & ~EOI) unless complete
+          @bus.poke(zero_page.status, @bus.peek(zero_page.status) & ~EOI) unless complete
           leave_bus(ISOUR_TIMEOUT)
           continue_with(@layout.searching_message, @layout.loading_message,
                         complete ? @layout.load_done : @layout.load_byte_loop)
         end
-        @bus.poke(0xb9, LOAD_SECONDARY)
+        @bus.poke(zero_page.secondary_address, LOAD_SECONDARY)
       end
 
       # A load ends with the UNLISTEN that closes the file, a byte sent,
@@ -91,9 +91,9 @@ module Badline
         load? && data.length > 2 && load_address(data) < 0x0334
       end
 
-      # A=0 is LOAD, A=1 is VERIFY, kept at $93 (VERCK)
+      # A=0 is LOAD, A=1 is VERIFY, kept at VERCK
       def load?
-        @bus.peek(0x93).zero?
+        @bus.peek(zero_page.verify).zero?
       end
 
       def deliver(data)
@@ -102,25 +102,23 @@ module Badline
         payload = payload[0, 0x10000 - addr] if addr + payload.length > 0x10000
         if load?
           @layout.store_file(@bus, addr, payload)
-          @bus.poke(0x90, EOI)
+          @bus.poke(zero_page.status, EOI)
         else
           verify(addr, payload)
         end
-        end_addr = (addr + payload.length) & 0xffff
-        @bus.poke(0xae, low_byte(end_addr))
-        @bus.poke(0xaf, high_byte(end_addr))
+        poke_word(zero_page.end_address, (addr + payload.length) & 0xffff)
       end
 
       def verify(addr, payload)
         match = payload.each_with_index.all? { |byte, i| @layout.file_byte(@bus, addr + i) == byte }
-        @bus.poke(0x90, match ? EOI : EOI | VERIFY_MISMATCH)
+        @bus.poke(zero_page.status, match ? EOI : EOI | VERIFY_MISMATCH)
       end
 
-      # Secondary address $B9 zero relocates to the caller-supplied address
-      # stashed at $C3/$C4 (MEMUSS)
+      # Secondary address zero relocates to the caller-supplied address
+      # stashed at MEMUSS
       def load_address(data)
-        if @bus.peek(0xb9).zero?
-          uint16(@bus.peek(0xc3), @bus.peek(0xc4))
+        if @bus.peek(zero_page.secondary_address).zero?
+          peek_word(zero_page.load_address)
         else
           uint16(data[0], data[1].to_i)
         end

data/lib/badline/kernal_trap/routine.rb

@@ -26,6 +26,18 @@ module Badline
         @layout.kernal_mapped?(@bus)
       end
 
+      def zero_page = @layout.zero_page
+
+      # The two-byte value whose low byte is at +address+.
+      def peek_word(address)
+        uint16(@bus.peek(address), @bus.peek(address + 1))
+      end
+
+      def poke_word(address, value)
+        @bus.poke(address, low_byte(value))
+        @bus.poke(address + 1, high_byte(value))
+      end
+
       # The ROM times each byte on the serial bus with a one-shot timer
       # (Layout#time_serial_byte): ISOUR_TIMEOUT for a byte sent,
       # ACPTR_TIMEOUT for one received.