badline 0.13.0 → 0.15.0

data/lib/badline/kernal_trap/dos.rb

@@ -147,25 +147,6 @@ module Badline
       # vector, as U: does.
       def reset! = reset(cold: true)
 
-      # The mounted storage's setup (Snapshot::StorageSetup), then the drive's
-      # RAM, its status and its open channels.
-      def save_state(out)
-        Snapshot::StorageSetup.write(@storage, 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

@@ -31,8 +31,8 @@ module Badline
       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?
 
@@ -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.

data/lib/badline/kernal_trap/save.rb

@@ -18,7 +18,7 @@ module Badline
     class Save < FileRoutine
       SECONDARY = 0x61
 
-      # ST bit at $90
+      # ST bit
       DEVICE_NOT_PRESENT = 0x80
 
       def initialize(cpu:, bus:, layout:, dos:)
@@ -27,23 +27,15 @@ module Badline
         @saving = false
       end
 
-      def save_state(out)
-        out.boolean(@saving)
-      end
-
-      def load_state(input)
-        @saving = input.boolean?
-      end
-
       def call
         return unless active?
         return finish if @saving
         return unless @dos.saves?
 
-        @bus.poke(0xb9, SECONDARY)
+        @bus.poke(zero_page.secondary_address, SECONDARY)
         return @cpu.program_counter = @layout.missing_file_name_exit if name.empty?
 
-        @bus.poke(0x90, 0x00)
+        @bus.poke(zero_page.status, 0x00)
         @saving = true
         continue_with(@layout.saving_message, @layout.save)
       end
@@ -57,19 +49,17 @@ module Badline
       def finish
         @saving = false
         saved = @dos.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))
+        @bus.poke(zero_page.status, DEVICE_NOT_PRESENT) unless saved
+        poke_word(zero_page.start_address, peek_word(zero_page.end_address))
         @cpu.y = 0
         @cpu.status.overflow = true
         continue_with(@layout.clock_release, @layout.data_release, @layout.save_done)
       end
 
-      # Start address at $C1/$C2 (STAL), end address (exclusive) at
-      # $AE/$AF (EAL)
+      # Start address at STAL, end address (exclusive) at EAL
       def payload
-        start = uint16(@bus.peek(0xc1), @bus.peek(0xc2))
-        length = (uint16(@bus.peek(0xae), @bus.peek(0xaf)) - start) & 0xffff
+        start = peek_word(zero_page.save_start)
+        length = (peek_word(zero_page.end_address) - start) & 0xffff
         [low_byte(start), high_byte(start)] +
           Array.new(length) { |i| @layout.file_byte(@bus, (start + i) & 0xffff) }
       end

data/lib/badline/kernal_trap/serial.rb

@@ -35,22 +35,6 @@ module Badline
         @buffer = []
       end
 
-      # The frame under way, with the channels and the bytes it gathered.
-      # The device it answers is the machine's to set.
-      def save_state(out)
-        out.boolean(@listening).boolean(@talking).optional_int(@listen_channel).optional_int(@talk_channel)
-        out.int(@frame).blob(@buffer)
-      end
-
-      def load_state(input)
-        @listening = input.boolean?
-        @talking = input.boolean?
-        @listen_channel = input.optional_int
-        @talk_channel = input.optional_int
-        @frame = input.int
-        @buffer = input.blob
-      end
-
       def install
         routines.each do |address, routine|
           @cpu.install_trap(address) { call_routine(routine) if kernal_mapped? }
@@ -205,7 +189,7 @@ module Badline
       def update_status(bits)
         return if bits.zero?
 
-        @bus.poke(0x90, @bus.peek(0x90) | bits)
+        @bus.poke(zero_page.status, @bus.peek(zero_page.status) | bits)
       end
     end
   end

data/lib/badline/kernal_trap.rb

@@ -7,3 +7,5 @@ require "badline/kernal_trap/file_routine"
 require "badline/kernal_trap/load"
 require "badline/kernal_trap/save"
 require "badline/kernal_trap/serial"
+require "badline/kernal_trap/chrout"
+require "badline/kernal_trap/keyed_state"

data/lib/badline/machine/keyboard_buffer.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Badline
+  module Machine
+    # Typing into the KERNAL's keyboard buffer once the machine has booted.
+    # The machine that includes it answers #keyboard_buffer, the Layout of
+    # the KERNAL it runs, and #ram.
+    module KeyboardBuffer
+      # Where a KERNAL keeps its keyboard buffer (KEYD), the count of
+      # characters in it (NDX), and how many it holds.
+      Layout = Data.define(:address, :count, :capacity)
+
+      # The C64's and the VIC-20's.
+      C64_LAYOUT = Layout.new(address: 0x0277, count: 0xc6, capacity: 10)
+
+      # BASIC 7.0's, in C128 mode.
+      C128_LAYOUT = Layout.new(address: 0x034a, count: 0xd0, capacity: 10)
+
+      # The 264 series KERNAL's, which sets its capacity at $053F to 10
+      # ($D86E).
+      PLUS4_LAYOUT = Layout.new(address: 0x0527, count: 0xef, capacity: 10)
+
+      def type_text(text)
+        codes = text.bytes.map { |b| ascii_to_petscii(b) }
+        on_init { @pending_keys = codes }
+      end
+
+      private
+
+      def feed_keyboard
+        buffer = keyboard_buffer
+        return unless ram.peek(buffer.count).zero?
+
+        chunk = @pending_keys.shift(buffer.capacity)
+        ram.write(buffer.address, chunk)
+        ram.poke(buffer.count, chunk.length)
+        @pending_keys = nil if @pending_keys.empty?
+      end
+
+      def ascii_to_petscii(byte)
+        case byte
+        when 0x61..0x7a then byte - 0x20
+        when 0x41..0x5a then byte + 0x80
+        else byte
+        end
+      end
+    end
+  end
+end

data/lib/badline/machine/settling.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Badline
+  module Machine
+    # Brings the machine to the point a snapshot file is saved at: the main
+    # CPU between instructions, or jammed, with no REU transfer holding the
+    # bus. C64, Vic20, C128 and Plus4 each include it, and answer
+    # #settled_for_snapshot? and #settle_chips_for_snapshot, which brings
+    # what each chip defers up to the cycle without running one.
+    module Settling
+      # The cycles settling may run: the longest instruction stretched by
+      # the VIC's longest hold on the bus, and an REU swap of 64K, two
+      # cycles a byte, stretched the same way.
+      LIMIT = 100 + 0x40000
+
+      # Runs the machine on, through its own #cycle!, to the settle point,
+      # and returns the cycles that took. A settled machine runs none.
+      def settle_for_snapshot!
+        ran = 0
+        while ran < LIMIT && !settled_for_snapshot?
+          cycle!
+          ran += 1
+        end
+        settle_chips_for_snapshot
+        ran
+      end
+    end
+  end
+end