badline 0.9.0 → 0.10.0

data/lib/badline/frontend/pause_menu.rb

@@ -16,7 +16,6 @@ module Badline
     class PauseMenu
       SECTIONS = ["SNAPSHOTS", "DRIVE 8", "DATASETTE", "EXPANSION PORT", "PORTS", "SOUND", "POWER"].freeze
       PAGES = %i[snapshots drive datasette expansion ports sound power].freeze
-      DISKS = %w[.d64 .d71 .d81 .g64 .t64].freeze
 
       PANEL = 0x1d2230
       EDGE = 0x3a4256
@@ -25,11 +24,10 @@ module Badline
       DIM = 0x6b7489
       FILL = 0x343c50
 
-      LEFT = 16
-      TOP = 16
-      WIDTH = Screen::WIDTH - 32
-      HEIGHT = Screen::HEIGHT - 32
-      BODY = 154
+      MARGIN = 16
+      WIDTH = 352
+      HEIGHT = 240
+      BODY = 138
 
       ESCAPE = 41
       RETURN = 40
@@ -48,20 +46,15 @@ module Badline
         @dialogs = MenuDialogs.new(painter, @buttons, @pages.media, options, snapshots)
         @open = false
         @section = 0
-      end
-
-      # The path of the disk the command line puts in device 8, a list's
-      # first, or an empty one for other media.
-      def self.disk_path(path)
-        return "" if path.empty?
-        return path if File.directory?(path)
-        return Media::DiskList.disks(path).first.to_s if Media::DiskList.list?(path)
-
-        DISKS.include?(File.extname(path).downcase) ? path : ""
+        @left = MARGIN
+        @top = MARGIN
       end
 
       def open? = @open
 
+      # The index in PAGES of the page #show opens on.
+      attr_writer :section
+
       # The machine Quick open started, which the app runs in place of the
       # one before once #frame returns :swap.
       def computer = @dialogs.computer
@@ -116,10 +109,10 @@ module Badline
       end
 
       # Handles the events that came in, draws the menu over the frozen
-      # picture, dimmed, and returns the action the app has to take on, if
-      # any, leaving the events after one for the machine. Key releases
-      # still reach the machine, so no key stays held down while it stands
-      # still.
+      # picture, dimmed, for the app to present, and returns the action the
+      # app has to take on, if any, leaving the events after one for the
+      # machine. Key releases still reach the machine, so no key stays held
+      # down while it stands still.
       def frame(renderer, texture, controls)
         action = nil
         action = event(SDL.event_type(SDL.event), controls) while action.nil? && SDL.SDL_PollEvent(SDL.event) != 0
@@ -129,26 +122,30 @@ module Badline
         SDL.SDL_SetTextureColorMod(texture, 255, 255, 255)
         draw
         SDL.SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255)
-        SDL.SDL_RenderPresent(renderer)
-        SDL.SDL_Delay(10)
         action
       end
 
+      # Centres the menu on a screen `width` by `height`.
+      def center(width, height)
+        @left = (width - WIDTH) / 2
+        @top = (height - HEIGHT) / 2
+      end
+
       def draw
         painter = @painter
         @buttons.forget
-        painter.box(LEFT, TOP, WIDTH, HEIGHT, PANEL)
-        painter.box(LEFT, TOP + 24, WIDTH, 1, EDGE)
-        painter.text(LEFT + 8, TOP + 9, "PAUSED", BRIGHT)
+        painter.box(@left, @top, WIDTH, HEIGHT, PANEL)
+        painter.box(@left, @top + 24, WIDTH, 1, EDGE)
+        painter.text(@left + 8, @top + 9, "PAUSED", BRIGHT)
         resume = "RESUME"
-        @buttons.plain(LEFT + WIDTH - 8 - Painter.width(resume) - (Buttons::PAD * 2), TOP + 7, resume, :resume)
-        return @dialogs.draw(LEFT + 8, TOP + 34, WIDTH - 16) if @dialogs.open?
+        @buttons.plain(@left + WIDTH - 8 - Painter.width(resume) - (Buttons::PAD * 2), @top + 7, resume, :resume)
+        return @dialogs.draw(@left + 8, @top + 34, WIDTH - 16) if @dialogs.open?
 
-        painter.box(BODY - 8, TOP + 32, 1, HEIGHT - 56, EDGE)
+        painter.box(@left + BODY - 8, @top + 32, 1, HEIGHT - 56, EDGE)
         draw_sections
-        @buttons.plain(LEFT + 6, TOP + HEIGHT - 28, "QUICK OPEN...", :quick_open)
-        painter.text(LEFT + 8, TOP + HEIGHT - 12, "F9/ESC: RESUME", DIM)
-        @pages.draw(PAGES[@section], BODY, TOP + 34)
+        @buttons.plain(@left + 6, @top + HEIGHT - 28, "QUICK OPEN...", :quick_open)
+        painter.text(@left + 8, @top + HEIGHT - 12, "F9/ESC: RESUME", DIM)
+        @pages.draw(PAGES[@section], @left + BODY, @top + 34)
       end
 
       private
@@ -253,9 +250,9 @@ module Badline
       end
 
       def draw_sections
-        top = TOP + 32
+        top = @top + 32
         SECTIONS.each_with_index do |name, index|
-          @buttons.plain(LEFT + 6, top, name.ljust(14), PAGES[index], on: index == @section)
+          @buttons.plain(@left + 6, top, name.ljust(14), PAGES[index], on: index == @section)
           top += Buttons::HEIGHT + 2
         end
       end

data/lib/badline/frontend/player_screen.rb

@@ -10,7 +10,7 @@ module Badline
       HEADER = 64
       SCALE = 2
       TITLE = "Badline"
-      BACKGROUND = Screen::COLORS[6]
+      BACKGROUND = VIC::PALETTE[6]
 
       attr_reader :buttons, :info
 

data/lib/badline/frontend/player_window.rb

@@ -23,7 +23,7 @@ module Badline
       UP = 82
       DOWN = 81
 
-      WARNING = Screen::COLORS[10]
+      WARNING = VIC::PALETTE[10]
 
       CHIPS = PlayerHeader::CHIPS
 

data/lib/badline/frontend/screen.rb

@@ -2,60 +2,62 @@
 
 module Badline
   module Frontend
-    # The visible part of the VIC's display, the crop of the machine's
-    # region, repacked for an SDL texture in XRGB8888. Spinel hands an
-    # Array of Integers to C as 64-bit words, as badline/ffi does on CRuby,
-    # so each word carries two neighbouring pixels, the left one in the low
-    # half. The texture is PAL's crop, 384x272, and a region with fewer
-    # lines to show sits in the middle of it, between black bands.
+    # The visible part of the video chip's display, the crop of the
+    # machine's timing, repacked for an SDL texture in XRGB8888 in the
+    # chip's palette. Spinel hands an Array of Integers to C as 64-bit
+    # words, as badline/ffi does on CRuby, so each word carries two
+    # neighbouring pixels, the left one in the low half.
+    #
+    # The texture is as wide as the crop and at least as high as PAL's
+    # C64 crop, 272 lines, so a C64 shows in the same window whatever its
+    # region: a crop with fewer lines sits in the middle of the texture,
+    # between black bands. The VIC-20's 284 by 284 crop fills its own.
     class Screen
-      WIDTH = Region::PAL.crop[2]
-      HEIGHT = Region::PAL.crop[3]
-      ROW_BYTES = WIDTH * 4
-      ROW_WORDS = WIDTH / 2
+      MIN_HEIGHT = Region::PAL.crop[3]
 
-      COLORS = [
-        0x000000, 0xffffff, 0x924a40, 0x84c5cc,
-        0x9351b6, 0x72b14b, 0x483aaa, 0xd5df7c,
-        0x675200, 0xc33d00, 0xc18178, 0x606060,
-        0x8a8a8a, 0xb3ec91, 0x867ade, 0xb3b3b3
-      ].freeze
+      attr_reader :pixels, :width, :height
 
-      PAIRS = Array.new(256) { |pair| COLORS[pair & 0x0f] | (COLORS[pair >> 4] << 32) }.freeze
-
-      attr_reader :pixels
-
-      def initialize(vic)
-        @vic = vic
-        crop = vic.region.crop
+      def initialize(video, crop)
+        @video = video
         @col_offset = crop[0]
         @row_offset = crop[1]
-        @height = crop[3]
-        @band = (HEIGHT - @height) / 2
-        @pixels = Array.new(HEIGHT * ROW_WORDS, 0)
+        @lines = crop[3]
+        @width = crop[2]
+        @stride = video.width.to_i
+        @height = [@lines, MIN_HEIGHT].max
+        @row_words = @width / 2
+        @band = (@height - @lines) / 2
+        palette = video.palette
+        @pairs = Array.new(256) { |pair| palette[pair & 0x0f] | (palette[pair >> 4] << 32) }
+        @pixels = Array.new(@height * @row_words, 0)
       end
 
-      # Repacks only the lines the VIC has changed since the last frame.
+      # The bytes of one row of the texture.
+      def row_bytes = @width * 4
+
+      # Repacks only the lines the chip has changed since the last frame.
       def update
-        dirty = @vic.dirty_lines
+        video = @video
+        dirty = video.dirty_lines
+        display = video.display
         row = 0
-        while row < @height
-          pack_row(row) if dirty[row + @row_offset]
+        while row < @lines
+          pack_row(display, row) if dirty[row + @row_offset]
           row += 1
         end
-        @vic.clear_dirty_lines!
+        video.clear_dirty_lines!
       end
 
       private
 
-      def pack_row(row)
-        display = @vic.display
+      def pack_row(display, row)
         pixels = @pixels
-        from = ((row + @row_offset) * @vic.width) + @col_offset
-        to = (row + @band) * ROW_WORDS
-        last = to + ROW_WORDS
+        pairs = @pairs
+        from = ((row + @row_offset) * @stride) + @col_offset
+        to = (row + @band) * @row_words
+        last = to + @row_words
         while to < last
-          pixels[to] = PAIRS[(display[from] & 0x0f) | ((display[from + 1] & 0x0f) << 4)]
+          pixels[to] = pairs[(display[from] & 0x0f) | ((display[from + 1] & 0x0f) << 4)]
           from += 2
           to += 1
         end

data/lib/badline/frontend/sid_view.rb

@@ -8,7 +8,7 @@ module Badline
     # a tune on more than one gets a row of buttons above the voices that
     # pick it, which makes the view PICKER taller.
     class SIDView
-      COLORS = Screen::COLORS
+      COLORS = VIC::PALETTE
       TEXT = COLORS[14]
       BRIGHT = COLORS[1]
       DIM = COLORS[11]

data/lib/badline/frontend/sound.rb

@@ -2,7 +2,9 @@
 
 module Badline
   module Frontend
-    # The SID's output on SDL's audio queue, as mono signed 16-bit samples.
+    # The machine's sound source, the C64's SID or the VIC-20's VIC, on
+    # SDL's audio queue, as mono signed 16-bit samples. Both take
+    # #record(rate:, clock_hz:) and #drain_samples.
     # Once the device plays, it is the clock: #wait holds each frame until
     # the queue is down to `AHEAD`, so the machine runs at the device's pace.
     #
@@ -13,7 +15,7 @@ module Badline
     # only happens unpaced.
     #
     # Each frame's samples go to SDL through an IO::Buffer of 16-bit values.
-    # The SID's cycles are converted at `clock_hz`, the machine's clock, so
+    # The chip's cycles are converted at `clock_hz`, the machine's clock, so
     # an NTSC or Drean machine plays at its own pitch.
     class Sound
       RATE = 44_100
@@ -22,8 +24,8 @@ module Badline
 
       attr_reader :rate, :underruns, :dropped, :queued, :low, :high
 
-      def initialize(sid, clock_hz, wanted, verbose)
-        @sid = sid
+      def initialize(source, clock_hz, wanted, verbose)
+        @source = source
         @clock_hz = clock_hz
         @verbose = verbose
         @device = 0
@@ -40,9 +42,9 @@ module Badline
 
       def on? = @device != 0
 
-      # Plays another machine's SID from here on, at that machine's clock.
-      def switch(sid, clock_hz)
-        @sid = sid
+      # Plays another machine's sound from here on, at that machine's clock.
+      def switch(source, clock_hz)
+        @source = source
         @clock_hz = clock_hz
         record if on?
       end
@@ -54,7 +56,7 @@ module Badline
       def feed
         return unless on?
 
-        samples = @sid.drain_samples
+        samples = @source.drain_samples
         return if @muted || samples.empty?
 
         level = queued_seconds
@@ -110,7 +112,7 @@ module Badline
         puts "Sound at #{@rate} Hz" if @verbose
       end
 
-      def record = @sid.record(rate: @rate, clock_hz: @clock_hz)
+      def record = @source.record(rate: @rate, clock_hz: @clock_hz)
 
       def queued_seconds = SDL.SDL_GetQueuedAudioSize(@device) / (2.0 * @rate)
 

data/lib/badline/frontend/timeline.rb

@@ -21,13 +21,20 @@ module Badline
         @failed = false
       end
 
-      # What's wrong with the events, the first key that names nothing,
-      # or an empty string.
+      # What's wrong with the events, the first key or menu page that
+      # names nothing, or an empty string.
       def self.error(events)
         event = events.find { |candidate| candidate.action == "key" && !key?(candidate.argument) }
-        event.nil? ? "" : "no such key: #{event.argument}"
+        return "no such key: #{event.argument}" unless event.nil?
+
+        event = events.find { |candidate| candidate.action == "menu" && !page?(candidate.argument) }
+        event.nil? ? "" : "no such menu page: #{event.argument}"
       end
 
+      # Whether the pause menu has a page of the name, such as drive or
+      # sound. An empty one is its first.
+      def self.page?(name) = name.empty? || PauseMenu::PAGES.any? { |page| page.to_s == name }
+
       def self.key?(name) = name == "restore" || !keyboard_key(name).nil? || !joystick_direction(name).nil?
 
       # The Keyboard's key for a name such as space, return or a.
@@ -67,6 +74,22 @@ module Badline
       # events do.
       def press_freeze(computer, frame) = freeze(computer, Options::Event.new(frame, "freeze", ""))
 
+      # Whether the pause menu opens at the frame, or turns to another page.
+      def menu?(frame) = @events.any? { |event| event.frame == frame && event.action == "menu" }
+
+      # The index in PauseMenu::PAGES of the page the frame's menu event
+      # names, 0 for the first.
+      def menu_section(frame)
+        page = ""
+        @events.each { |event| page = event.argument if event.frame == frame && event.action == "menu" }
+        section = 0
+        PauseMenu::PAGES.each_with_index { |name, index| section = index if name.to_s == page }
+        section
+      end
+
+      # Whether the pause menu closes at the frame.
+      def resume?(frame) = @events.any? { |event| event.frame == frame && event.action == "resume" }
+
       # Whether the run ends at the frame: at a quit, or once an event failed.
       def quit?(frame) = @failed || @events.any? { |event| event.frame == frame && event.action == "quit" }
 
@@ -98,7 +121,7 @@ module Badline
         name = event.argument
         if name == "restore"
           computer.press_restore
-          return
+          return hold(event)
         end
 
         direction = Timeline.joystick_direction(name)
@@ -110,7 +133,10 @@ module Badline
         hold(event)
       end
 
+      # The VIC-20 has no cartridge with a button yet.
       def freeze(computer, event)
+        return if computer.family == :vic20
+
         computer.press_cartridge_button
         hold(event)
       end
@@ -123,6 +149,8 @@ module Badline
         return computer.release_cartridge_button if event.action == "freeze"
 
         name = event.argument
+        return computer.release_restore if name == "restore"
+
         direction = Timeline.joystick_direction(name)
         if direction.nil?
           computer.keyboard.release(Timeline.keyboard_key(name))
@@ -141,7 +169,7 @@ module Badline
       end
 
       def eject(computer, what)
-        return puts "No #{what} to eject" unless inserted?(computer, what)
+        return puts "No #{what} to eject" unless ejectable?(computer, what)
 
         if what == "disk"
           eject_disk(computer)
@@ -154,6 +182,9 @@ module Badline
         puts "Ejected the #{what}"
       end
 
+      # Whether there's one in to eject. A VIC-20 has no cartridge to take out yet.
+      def ejectable?(computer, what) = (computer.family == :c64 || what != "cartridge") && inserted?(computer, what)
+
       def inserted?(computer, what)
         return !computer.datasette.tape.nil? if what == "tape"
         return !computer.address_bus.cartridge.nil? if what == "cartridge"

data/lib/badline/frontend.rb

@@ -15,6 +15,7 @@ require "badline/frontend/frame_report"
 require "badline/frontend/controls"
 require "badline/frontend/pad_port"
 require "badline/frontend/gamepads"
+require "badline/frontend/machine_window"
 require "badline/frontend/app"
 require "badline/frontend/audio_sink"
 require "badline/frontend/painter"
@@ -37,4 +38,5 @@ require "badline/frontend/confirmation"
 require "badline/frontend/name_field"
 require "badline/frontend/menu_dialogs"
 require "badline/frontend/menu_media"
+require "badline/frontend/menu_ports"
 require "badline/frontend/menu_pages"

data/lib/badline/iec_bus.rb

@@ -3,13 +3,14 @@
 module Badline
   # The serial bus between the C64 and its drives: ATN, CLK and DATA, each
   # an open-collector line with a pull-up. A line is low while any device
-  # pulls it (wired-AND), and high otherwise. The bus holds no state of its
-  # own: every read works the levels out from what each side drives now.
+  # pulls it (wired-AND), and high otherwise. Every read works the levels
+  # out from what each side drives now.
   #
   # The C64 drives the lines from CIA 2's port A through 7406 inverters, so
   # an output bit of 1 pulls its line low: PA3 ATN, PA4 CLK and PA5 DATA.
-  # PA6 and PA7 read CLK and DATA directly, 1 for a released line. The bus
-  # stands in as CIA 2's peripheral for those two inputs.
+  # The machine pushes those bits into the bus (host_lines=), which holds
+  # them. PA6 and PA7 read CLK and DATA directly, 1 for a released line.
+  # The bus stands in as CIA 2's peripheral for those two inputs.
   #
   # A drive drives CLK and DATA from VIA 1's PB3 and PB1, the same way. It
   # also pulls DATA while ATN IN differs from its ATN acknowledge on PB4
@@ -33,30 +34,21 @@ module Badline
     CLK = 0x02
     DATA = 0x04
 
-    attr_reader :host, :drives
+    attr_reader :drives, :host_lines
 
-    # +host+ is CIA 2, or nil for a bus with only drives on it.
-    def initialize(host: nil)
-      @host = host
+    def initialize
       @drives = []
-      @notifies = false
+      @host_lines = 0
     end
 
-    # Stands in as the host's peripheral, CIA 2's, and has it say when it
-    # writes port A (see notifies?).
-    def plug_in!
-      @host.peripheral = self
-      @host.on_port_a_write { host_written }
-      @notifies = true
+    # The machine pushes the lines it pulls, as port A bits, whenever they
+    # may have moved: its output bits, with input bits floating high as the
+    # 7406 inputs see them. A bus with only drives on it keeps 0.
+    def host_lines=(lines)
+      @host_lines = lines
+      @drives.each(&:host_written!)
     end
 
-    # Whether the host says when it may have moved a line (see plug_in!).
-    # Without, a drive asleep checks ATN every cycle.
-    def notifies? = @notifies
-
-    # CIA 2 wrote its port A, which may have moved a line.
-    def host_written = @drives.each(&:host_written!)
-
     def attach(drive)
       @drives << drive unless @drives.include?(drive)
     end
@@ -68,7 +60,7 @@ module Badline
     # One pass over everything on the bus, for a reader that wants more
     # than one line. +host+ is the C64's port A lines as the reader sees
     # them, which a drive takes a cycle late (see Drive1541::SerialPort).
-    def low_lines(host = host_lines)
+    def low_lines(host = @host_lines)
       atn = host.anybits?(HOST_ATN_OUT)
       low = atn ? ATN : 0
       low |= CLK if host.anybits?(HOST_CLK_OUT)
@@ -83,7 +75,7 @@ module Badline
       low
     end
 
-    def atn_low?(host = host_lines) = host.anybits?(HOST_ATN_OUT)
+    def atn_low?(host = @host_lines) = host.anybits?(HOST_ATN_OUT)
 
     def clk_low? = low_lines.anybits?(CLK)
 
@@ -101,9 +93,5 @@ module Badline
 
     # Port B goes to the user port, not the serial bus.
     def read_b(_port_a, _port_b) = 0xff
-
-    # What the C64 pulls, as port A bits: its output bits, with input bits
-    # floating high as the 7406 inputs see them.
-    def host_lines = @host ? @host.port_a_lines : 0
   end
 end

data/lib/badline/kernal_trap/drive.rb

@@ -84,6 +84,9 @@ module Badline
         @memory.read_bam
       end
 
+      # The path of the disk or directory in the drive.
+      def path = @storage.path
+
       # Whether the disk takes a SAVE handed over whole.
       def saves? = @storage.respond_to?(:write_file)
 

data/lib/badline/kernal_trap/file.rb

@@ -6,7 +6,7 @@ module Badline
       private
 
       def active?
-        kernal? && @bus.peek(0xba) == DEVICE
+        kernal_mapped? && @bus.peek(0xba) == DEVICE
       end
 
       def filename

data/lib/badline/kernal_trap/layout.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Badline
+  module KernalTrap
+    # Where a machine's KERNAL keeps the routines the traps stand in for,
+    # and the ROM code they hand over to, with the steps that depend on the
+    # machine around it: whether the KERNAL is mapped in, the timer that
+    # times each serial byte and the release of the serial lines.
+    #
+    # +load+ and +save+ are the default ILOAD and ISAVE vector targets.
+    # LOAD hands over to the SEARCHING FOR and LOADING/VERIFYING messages,
+    # the byte loop that retries a timed-out byte until RUN/STOP, the
+    # successful return (CLC, LDX $AE, LDY $AF, RTS) and the FILE NOT FOUND
+    # and MISSING FILE NAME error exits. SAVE hands over to the SAVING
+    # message, the two line releases that end UNLISTEN (clock, then data,
+    # leaving A as read from the port), the successful return (CLC, RTS)
+    # and the MISSING FILE NAME exit. The rest are the serial bus
+    # primitives' entry points.
+    #
+    # +banked+ says whether the 6510 port can bank the KERNAL out, and so
+    # whether RAM lies under every ROM and the I/O. 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
+    # start it (a CIA's), or nil where the write to the high byte starts it
+    # (a VIA's timer 2). 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.
+    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) do
+      # Whether the CPU reads the KERNAL ROM at the trapped addresses: on a
+      # banked machine, the 6510 port's banking bits select it.
+      def kernal_mapped?(bus)
+        !banked || bus.io_port.kernal?
+      end
+
+      # Stores a loaded file's bytes from +address+ on: on a banked machine
+      # into the RAM under whatever is banked in, and otherwise where the
+      # ROM's byte loop would store them, through the bus.
+      def store_file(bus, address, bytes)
+        return bus.ram.write(address, bytes) if banked
+
+        bytes.each_with_index { |byte, i| bus.poke(address + i, byte) }
+      end
+
+      # Starts the timer the ROM times a serial byte with, its count's high
+      # byte +timer_high+.
+      def time_serial_byte(bus, timer_high)
+        bus.poke(serial_timer, timer_high)
+        start = serial_timer_start
+        bus.poke(start, TIMER_ONE_SHOT_START) if start
+      end
+
+      # The ROM's release of the serial bus: ATN, then the clock, then the
+      # data line, each a read of its port, a mask and a write back, so the
+      # input bits written back follow the lines as each one is let go.
+      # Returns the last value written, which the ROM leaves in A.
+      def release_serial_lines(bus)
+        release_line(bus, atn_port, atn_mask)
+        release_line(bus, clock_port, clock_mask)
+        release_line(bus, data_port, data_mask)
+      end
+
+      private
+
+      def release_line(bus, port, mask)
+        value = bus.peek(port) & mask
+        bus.poke(port, value)
+        value
+      end
+    end
+
+    # A CIA's control value that starts its timer: force load, one-shot,
+    # start.
+    TIMER_ONE_SHOT_START = 0x19
+
+    # The C64 KERNAL, revision 3. The SX-64's, 251104-04, differs from it
+    # only in bytes none of these addresses reach. It times serial bytes
+    # with CIA 1's timer B, and drives the lines from CIA 2's port A
+    # ($EE03: ATN $EDBE, clock $EE85, data $EE97).
+    C64_LAYOUT = Layout.new(
+      load: 0xf4a5, save: 0xf5ed,
+      searching_message: 0xf5af, loading_message: 0xf5d2, load_byte_loop: 0xf4f3, load_done: 0xf5a9,
+      file_not_found_exit: 0xf704, missing_file_name_exit: 0xf710,
+      saving_message: 0xf68f, clock_release: 0xee85, data_release: 0xee97, save_done: 0xf657,
+      talk: 0xed09, listen: 0xed0c, second: 0xedb9, tksa: 0xedc7,
+      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
+    )
+
+    # The VIC-20 KERNAL, 901486-07 (PAL). The NTSC one, 901486-06, differs
+    # from it only at $E475, $EDE4-$EDE5, $FE3F, $FE44 and $FF5C-$FF70,
+    # none of them here. Nothing banks it out. It times serial bytes with
+    # VIA 2's timer 2 ($9129), drives ATN from VIA 1's PA7 ($911F) and the
+    # clock and data lines from VIA 2's CA2 and CB2 ($912C), and UNLISTEN
+    # lets them go at $EF09: ATN $EEC5, clock $EF84, data $E4A0.
+    VIC20_LAYOUT = Layout.new(
+      load: 0xf549, save: 0xf685,
+      searching_message: 0xf647, loading_message: 0xf66a, load_byte_loop: 0xf58a, load_done: 0xf641,
+      file_not_found_exit: 0xf787, missing_file_name_exit: 0xf793,
+      saving_message: 0xf728, clock_release: 0xef84, data_release: 0xe4a0, save_done: 0xf6ef,
+      talk: 0xee14, listen: 0xee17, second: 0xeec0, tksa: 0xeece,
+      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
+    )
+  end
+end