badline 0.15.1 → 0.16.0

data/lib/badline/options/help.rb

@@ -49,7 +49,8 @@ module Badline
     # wrapped as the banner is.
     def media_kinds
       text = "Media can be #{listed(Media::Extensions::PROGRAMS)} program, #{listed(%i[disk])} disk image, " \
-             "#{listed(%i[gcr])} disk image for a true drive, #{listed(%i[disk_list])} list of disk images, " \
+             "#{listed(%i[ieee_disk])} disk image for a PET, #{listed(%i[gcr])} disk image for a true drive, " \
+             "#{listed(%i[disk_list])} list of disk images, " \
              "#{listed(%i[archive])} tape archive, #{listed(%i[tape])} tape, #{listed(%i[cartridge])} " \
              "cartridge, #{listed(%i[tune])} tune, #{listed(%w[.vsf])} snapshot, or a directory to mount as device 8."
       wrap(text)
@@ -84,6 +85,7 @@ module Badline
                #{@program} vic20 [options] [media]
                #{@program} c128 [options] [media]
                #{@program} plus4 [options] [media]
+               #{@program} pet [options] [media]
                #{@program} --headless [options] tune.sid
                #{@program} [options] tune.sid --audio-out FILE
                #{@program} sid [options] FILE|DIR...
@@ -93,6 +95,7 @@ module Badline
             vic20                            Run a PAL VIC-20, with the RAM --ram names
             c128                             Run a C128 in C128 mode, the one --model names
             plus4                            Run a Plus/4 or a C16, the one --model names
+            pet                              Run a PET or a CBM, the one --model names
             sid                              Play .sid tunes and directories of them
 
         #{media_kinds}
@@ -116,6 +119,18 @@ module Badline
         --drive-type 1541 a 1541 on the serial bus instead. There Escape is
         ESC, Page Down RUN/STOP and F4 HELP.
 
+        The PET and the CBM take programs, disks, .d80 and .d82 among them,
+        and tapes, and a .d80, a .d82 or a PET tape starts one without
+        `pet`. Their keys type what the host's keys type, Alt with a key
+        presses the PET's SHIFT and the key its unshifted character is on,
+        and the pause menu's KEYBOARD page says where the rest are. --basic
+        and --editor fit the upgrades Commodore sold, as in --model 2001
+        --basic 2. BASIC 1 can't LOAD from a disk drive, though a disk still
+        starts its first program, and BASIC 2 can. The 8032 and the 8096
+        have two 50 Hz editors: 4-80-b-50hz, the default, and
+        4-80-b-50hz-0283, another chip's, with 64-cycle lines and 313 lines
+        a frame.
+
         --headless plays a .sid tune on the host's audio device without the
         window, and --audio-out renders it to 16-bit PCM instead. The
         container follows the file's extension, .wav or .aiff. Played on a
@@ -136,8 +151,9 @@ module Badline
         --at and --script run events once a number of frames has run, as
         in --at 3500:key=space or --at 250,500:screenshot=shot%05d.bmp.
         key=NAME presses a key (space, return, a, f1, run_stop, restore, and
-        on the C128 esc, help, keypad1 and the rest, and on the Plus/4
-        esc, help and f1 to f3) or a joystick's
+        on the C128 esc, help, keypad1 and the rest, on the Plus/4
+        esc, help and f1 to f3, and on the PET rvs, escape and kp1) or a
+        joystick's
         direction or fire (joy1-up, joy2-fire) for #{Event::HOLD} frames, and
         pushes the C128's caps_lock or forty_eighty, which lock. type=TEXT
         types it, with \\n for RETURN. insert=FILE swaps in a disk, a list's

data/lib/badline/options/table.rb

@@ -18,6 +18,10 @@ module Badline
     # another name for the C16.
     PLUS4_MODELS = %w[plus4 plus4ntsc c16 c16ntsc c116].freeze
 
+    # The PETs and CBMs, as PET::Model names them, the 8032 first, the
+    # default.
+    PET_MODELS = %w[8032 8096 4032 3032 3032b 2001].freeze
+
     # The true drives --drive-type names for the Plus/4.
     PLUS4_DRIVE_TYPES = %w[1541 1551].freeze
 
@@ -50,13 +54,21 @@ module Badline
       Option.new("--reu SIZE", "Plug in an REU of SIZE K: 128, 256, 512 (a 1750) or up to 16384",
                  section: "Window options", needs: :window),
       Option.new("--model NAME", "C64 to run: #{MODELS.join(', ')} (default: #{MODELS.first}); VIC-20: pal; " \
-                                 "C128: #{C128_MODELS.join(', ')}; Plus/4: #{PLUS4_MODELS.join(', ')}",
+                                 "C128: #{C128_MODELS.join(', ')}; Plus/4: #{PLUS4_MODELS.join(', ')}; " \
+                                 "PET: #{PET_MODELS.join(', ')}",
                  section: "Window options", needs: :window),
       Option.new("--ntsc", "Run an NTSC C64, as --model ntsc does", section: "Window options", needs: :window),
       Option.new("--c64", "Start the C128 in C64 mode, holding C= at power-on",
                  section: "Window options", needs: :window),
       Option.new("--ram SIZE", "VIC-20 RAM expansion: #{RAM_NAMES.join(', ')} (default: unexpanded); " \
-                               "Plus/4 RAM: 16k, 32k or 64k (default: the model's own)",
+                               "Plus/4 RAM: 16k, 32k or 64k; PET RAM: 4k, 8k, 16k or 32k (default: the model's own)",
+                 section: "Window options", needs: :window),
+      Option.new("--60hz", "Run a CRTC PET's 60 Hz editor instead of its 50 Hz one",
+                 section: "Window options", needs: :window),
+      Option.new("--basic VERSION", "Fit a PET with BASIC 1, 2 or 4, as its board takes (default: its own)",
+                 section: "Window options", needs: :window),
+      Option.new("--editor NAME", "Fit a PET with an editor ROM its board and BASIC take: " \
+                                  "#{PET::ROMSets::EDITORS.keys.join(', ')}",
                  section: "Window options", needs: :window),
       Option.new("--c1lo FILE", "Put a .bin ROM image in the Plus/4's cartridge 1, low slot ($8000)",
                  section: "Window options", needs: :window),

data/lib/badline/options/validation.rb

@@ -39,6 +39,12 @@ module Badline
         PLUS4_RAM[value]
       end
 
+      def pet_ram(value)
+        raise Error, "invalid argument: --ram #{value}" unless PET_RAM.key?(value)
+
+        PET_RAM[value]
+      end
+
       def plus4_ram_expansion(value)
         raise Error, "invalid argument: --ram-expansion #{value}" unless PLUS4_RAM_EXPANSIONS.key?(value)
 
@@ -92,12 +98,10 @@ module Badline
       end
 
       def validate_family
-        if @family == :vic20
-          validate_vic20
-        elsif !@ram.nil?
-          raise Error, "--ram needs vic20 or plus4"
-        end
+        ram_option
+        validate_vic20 if @family == :vic20
         @family == :plus4 ? validate_plus4 : refuse_plus4_options
+        @family == :pet ? validate_pet : refuse_pet_options
         if @family == :c128
           validate_c128
         elsif @c64_mode
@@ -105,6 +109,19 @@ module Badline
         end
       end
 
+      # --ram names the VIC-20's RAM expansion, or the Plus/4's or the PET's
+      # RAM.
+      def ram_option
+        return if @ram_name.nil?
+
+        case @family
+        when :vic20 then @ram = ram_configuration(@ram_name)
+        when :plus4 then @ram_kb = plus4_ram(@ram_name)
+        when :pet then @ram_kb = pet_ram(@ram_name)
+        else raise Error, "--ram needs vic20, plus4 or pet"
+        end
+      end
+
       # The C128 runs in the window, without an REU, and its NTSC models
       # have names of their own.
       def validate_c128
@@ -153,6 +170,52 @@ module Badline
         raise Error, "--sid-card-address needs --sid-card" unless @sid_card_address.nil? || @sid_card
       end
 
+      # Only the PET has a frame rate to pick and BASIC and editor ROMs to
+      # fit.
+      def refuse_pet_options
+        raise Error, "--60hz needs pet" unless @refresh_hz.nil?
+        raise Error, "--basic needs pet" unless @basic.nil?
+        raise Error, "--editor needs pet" unless @editor.nil?
+      end
+
+      # The PET runs in the window, without the C64's SID and REU or a true
+      # drive, at the frame rate its editor sets.
+      def validate_pet
+        raise Error, "--ntsc needs the C64; a CRTC PET's 60 Hz editor is --60hz" if @models.include?("ntsc")
+        raise Error, "--sid needs the C64" unless @sid_model.nil?
+        raise Error, "--reu needs the C64" unless @reu.nil?
+        raise Error, "the PET has no true drive yet" if @true_drive
+        raise Error, "the PET needs the window" if headless?
+
+        validate_pet_roms if PET_MODELS.include?(model)
+      end
+
+      # --basic and --editor name ROMs the model's board takes
+      # (PET::ROMSets), and an editor named sets the frame rate.
+      def validate_pet_roms
+        raise Error, "invalid argument: --basic #{@basic}" unless @basic.nil? || PET::ROMSets::BASICS.key?(@basic)
+        raise Error, "invalid argument: --editor #{@editor}" unless @editor.nil? || PET::ROMSets::EDITORS.key?(@editor)
+
+        basic = @basic || PET::ROMSets.stock_basic(model)
+        fitting = PET::ROMSets.editors(model, basic)
+        raise Error, "the #{model} takes no BASIC #{basic}" if fitting.empty?
+        return if @editor.nil?
+        raise Error, "the #{model} with BASIC #{basic} takes no editor #{@editor}" unless fitting.include?(@editor)
+
+        editor_rate(fitting)
+      end
+
+      # The frame rate of the editor named, on a CRTC board, which has a 50
+      # Hz and a 60 Hz one.
+      def editor_rate(fitting)
+        return if fitting.size == 1
+
+        editor_hz = @editor == fitting.last ? 60 : 50
+        raise Error, "--60hz takes a 60 Hz editor, not #{@editor}" if @refresh_hz == 60 && editor_hz == 50
+
+        @refresh_hz = editor_hz
+      end
+
       # `sid` takes directories as well as tunes.
       def validate_tune(path)
         return if !File.exist?(path) || File.extname(path).casecmp?(".sid")

data/lib/badline/options.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "badline/pet/rom_sets"
 require "badline/options/option"
 require "badline/options/event"
 require "badline/options/table"
@@ -12,10 +13,12 @@ module Badline
   # Either opens the window for any media, or with --headless or
   # --audio-out plays or renders a .sid tune without one. `sid`, given
   # first, plays .sid tunes and directories of them in the terminal.
-  # `c64`, `vic20`, `c128` or `plus4`, given first, names the machine
-  # family, and without one the family is the C64, or the C128 for a program
-  # that loads where C128 BASIC starts. The native build adds --no-sound and
-  # --version, and badline-ruby adds --disable-jit.
+  # `c64`, `vic20`, `c128`, `plus4` or `pet`, given first, names the
+  # machine family, and without one the family is the C64, the C128 for a
+  # program that loads where C128 BASIC starts, or the PET for an 8050's
+  # or 8250's disk or a PET tape.
+  # The native build adds --no-sound and --version, and badline-ruby adds
+  # --disable-jit.
   #
   # TABLE lists the options, and both the parser and the help read it. It
   # parses by hand, inside the subset of Ruby Spinel compiles. Values come
@@ -51,6 +54,9 @@ module Badline
     # The Plus/4's RAM sizes as --ram names them, in K.
     PLUS4_RAM = { "16k" => 16, "32k" => 32, "64k" => 64 }.freeze
 
+    # The PET's, below $8000.
+    PET_RAM = { "4k" => 4, "8k" => 8, "16k" => 16, "32k" => 32 }.freeze
+
     # Where --sid-card-address puts the Plus/4's SID card.
     SID_CARD_ADDRESSES = { "fd40" => 0xfd40, "fe80" => 0xfe80 }.freeze
 
@@ -70,16 +76,20 @@ module Badline
     attr_reader :program, :media_path, :tune_paths, :subtune, :sid_model, :reu, :frames, :screenshot, :save_snapshot,
                 :audio_out, :seconds, :songlengths, :filter_chunk, :timeline
 
-    # The machine family to build (Badline::Machine), :c64, :vic20, :c128
-    # or :plus4.
+    # The machine family to build (Badline::Machine), :c64, :vic20, :c128,
+    # :plus4 or :pet.
     attr_reader :family
 
+    # The ROMs --basic and --editor fit a PET with, keys of
+    # PET::ROMSets::BASICS and PET::ROMSets::EDITORS, or nil for its own.
+    attr_reader :basic, :editor
+
     # The VIC-20's RAM expansion --ram names, a key of
     # Vic20::Bus::RAM_CONFIGURATIONS, or nil without --ram.
     attr_reader :ram
 
-    # The Plus/4's RAM in K --ram names, one of PLUS4_RAM's, or nil without
-    # --ram.
+    # The Plus/4's or the PET's RAM in K --ram names, one of PLUS4_RAM's or
+    # PET_RAM's, or nil without --ram.
     attr_reader :ram_kb
 
     # The Plus/4's cartridge ROM images --c1lo, --c1hi, --c2lo and --c2hi
@@ -121,6 +131,10 @@ module Badline
       @reu = nil
       @ram = nil
       @ram_kb = nil
+      @ram_name = nil
+      @refresh_hz = nil
+      @basic = nil
+      @editor = nil
       @cartridges = {}
       @autostart = true
       @writable = false
@@ -229,6 +243,10 @@ module Badline
     # power-on.
     def c64_mode? = @c64_mode
 
+    # The frame rate of a CRTC PET's editor: 60 with --60hz or a 60 Hz
+    # --editor, else 50.
+    def refresh_hz = @refresh_hz || 50
+
     def help? = @help
 
     def version? = @version
@@ -244,7 +262,7 @@ module Badline
     # A .sid on its own plays in the SID player, as `sid` would, unless an
     # option of the emulator's window asks for the machine.
     def play_lone_tune
-      return if @sid_command || %i[vic20 plus4].include?(@family) || headless? || !@window_only.empty?
+      return if @sid_command || %i[vic20 plus4 pet].include?(@family) || headless? || !@window_only.empty?
       return if @media_path.nil?
 
       @sid_command = File.extname(@media_path).casecmp?(".sid")
@@ -303,7 +321,9 @@ module Badline
       when "--ram-expansion" then @ram_expansion = plus4_ram_expansion(value)
       when "--model" then @models << value
       when "--reu" then @reu = reu_size(value)
-      when "--ram" then ram_option(value)
+      when "--ram" then @ram_name = value
+      when "--basic" then @basic = value
+      when "--editor" then @editor = value
       when "--drive-type" then @drive_type = drive_type_for(value)
       when "--c1lo", "--c1hi", "--c2lo", "--c2hi" then @cartridges[CARTRIDGE_SLOTS.fetch(name)] = value
       when "--frames" then @frames = number(flag, value)
@@ -318,15 +338,6 @@ module Badline
       end
     end
 
-    # --ram names the VIC-20's RAM expansion, or the Plus/4's RAM.
-    def ram_option(value)
-      if @family == :plus4
-        @ram_kb = plus4_ram(value)
-      else
-        @ram = ram_configuration(value)
-      end
-    end
-
     def switch(name)
       case name
       when "--no-autostart" then @autostart = false
@@ -339,6 +350,7 @@ module Badline
       when "--vice" then @vice = true
       when "--ntsc" then @models << "ntsc"
       when "--c64" then @c64_mode = true
+      when "--60hz" then @refresh_hz = 60
       when "--unpaced" then @paced = false
       when "--disable-jit" then @jit = false
       when "--help" then @help = true

data/lib/badline/pet/bus/expansion.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Badline
+  class PET
+    class Bus
+      # The 8096's 64K board: four 16K banks, which a write-only control
+      # register at $FFF0 lays over $8000-$FFFF, two at a time:
+      #
+      #   bit 7  the board on; when clear, a plain 8032 and the rest ignored
+      #   bit 6  I/O shows through at $E800-$EFFF
+      #   bit 5  the screen shows through at $8000-$8FFF
+      #   bit 3  bank 3 at $C000-$FFFF, else bank 1
+      #   bit 2  bank 2 at $8000-$BFFF, else bank 0
+      #   bit 1  writes to $C000-$FFFF go nowhere
+      #   bit 0  writes to $8000-$BFFF go nowhere
+      #
+      # A write to $FFF0 lands where $FFF0 was before it, too. The RES line
+      # clears the register, so the 8096 starts as an 8032.
+      class Expansion
+        # A 16K bank of the board, seen from +start+.
+        class Window
+          attr_accessor :read_only
+
+          def initialize(cells, offset, start)
+            @cells = cells
+            @offset = offset - start
+            @read_only = false
+          end
+
+          def peek(addr) = @cells[addr + @offset]
+
+          def poke(addr, value)
+            @cells[addr + @offset] = value unless @read_only
+          end
+        end
+
+        # Page $FF's writes, which pass to what the page holds and set the
+        # control register at $FFF0.
+        class ControlPort
+          attr_accessor :under
+
+          def initialize(expansion, under)
+            @expansion = expansion
+            @under = under
+          end
+
+          def poke(addr, value)
+            @under.poke(addr, value)
+            @expansion.control = value if addr == 0xfff0
+          end
+        end
+
+        attr_reader :cells, :control
+
+        def initialize(bus)
+          @bus = bus
+          @cells = Array.new(0x10000, 0)
+          @banks = [0x8000, 0xc000, 0x8000, 0xc000].each_with_index.map do |start, bank|
+            Window.new(@cells, bank * 0x4000, start)
+          end
+          @port = ControlPort.new(self, @banks[1])
+          @control = 0
+        end
+
+        def control=(value)
+          @control = value
+          @bus.map_pages
+        end
+
+        def reset!
+          self.control = 0
+        end
+
+        def power_on!
+          @cells.fill(0)
+        end
+
+        # Lays the banks the register picks over the pages, and the
+        # control register over page $FF's writes.
+        def map(reads, writes)
+          map_banks(reads, writes) if @control.anybits?(0x80)
+          @port.under = writes[0xff]
+          writes[0xff] = @port
+        end
+
+        private
+
+        def map_banks(reads, writes)
+          low = @banks[@control.anybits?(0x04) ? 2 : 0]
+          high = @banks[@control.anybits?(0x08) ? 3 : 1]
+          low.read_only = @control.anybits?(0x01)
+          high.read_only = @control.anybits?(0x02)
+          first = @control.anybits?(0x20) ? 0x90 : 0x80
+          reads.fill(low, first, 0xc0 - first)
+          writes.fill(low, first, 0xc0 - first)
+          [[0xc0, 0x28], [0xe8, 0x08], [0xf0, 0x10]].each do |page, count|
+            next if page == 0xe8 && @control.anybits?(0x40)
+
+            reads.fill(high, page, count)
+            writes.fill(high, page, count)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/pet/bus.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "badline/pet/bus/expansion"
+
+module Badline
+  class PET
+    # The CPU's bus:
+    #
+    # $0000-$7FFF - RAM, 4K, 8K, 16K or 32K of it from $0000, then nothing
+    # $8000-$8FFF - screen RAM, repeated (Model), then nothing
+    # $9000-$AFFF - two empty ROM sockets
+    # $B000-$DFFF - BASIC 4, or BASIC 1 or 2 from $C000
+    # $E000-$E7FF - the screen editor ROM
+    # $E800-$E8FF - I/O (IO)
+    # $E900-$EFFF - nothing
+    # $F000-$FFFF - the KERNAL ROM
+    #
+    # The data lines hold the last byte they carried, so a read from an
+    # empty spot finds it, mostly the high byte of the address just
+    # fetched, as PET/unconnected shows on a real 3016. Writes to ROM and
+    # to empty spots go nowhere. An 8096 banks its 64K board over
+    # $8000-$FFFF (Expansion).
+    class Bus
+      include Addressable
+
+      # The last byte the CPU moved, which an empty spot reads back.
+      class OpenBus
+        def initialize(bus)
+          @bus = bus
+        end
+
+        def peek(_addr) = @bus.data
+        def poke(_addr, _value); end
+      end
+
+      # Screen RAM, repeated over the pages it answers in.
+      class ScreenRAM
+        attr_reader :cells
+
+        def initialize(size)
+          @cells = Array.new(size, 0)
+          @mask = size - 1
+        end
+
+        def peek(addr) = @cells[addr & @mask]
+
+        def poke(addr, value)
+          @cells[addr & @mask] = value
+        end
+      end
+
+      # $E800-$E8FF. Each chip answers on one address line, with its
+      # registers repeated: A4 selects PIA 1, A5 PIA 2, A6 the VIA and A7
+      # the CRTC, where there is one. Where more than one chip answers a
+      # read, each pulls the lines it drives low, so the CPU reads the AND
+      # of them, and a write reaches them all. Where none answers, as in
+      # $E800-$E80F, the CPU reads the last byte on the bus.
+      class IO
+        def initialize(bus, pia1:, pia2:, via:, crtc:, crtc_fitted:)
+          @bus = bus
+          @pia1 = pia1
+          @pia2 = pia2
+          @via = via
+          @crtc = crtc
+          @lines = crtc_fitted ? 0xf0 : 0x70
+        end
+
+        def peek(addr)
+          return @bus.data if addr.nobits?(@lines)
+
+          value = 0xff
+          value &= @pia1.peek(addr) if addr.anybits?(0x10)
+          value &= @pia2.peek(addr) if addr.anybits?(0x20)
+          value &= @via.peek(addr) if addr.anybits?(0x40)
+          value &= @crtc.peek(addr) if addr.anybits?(@lines & 0x80)
+          value
+        end
+
+        def poke(addr, value)
+          @pia1.poke(addr, value) if addr.anybits?(0x10)
+          @pia2.poke(addr, value) if addr.anybits?(0x20)
+          @via.poke(addr, value) if addr.anybits?(0x40)
+          @crtc.poke(addr, value) if addr.anybits?(@lines & 0x80)
+          @bus.io_written
+        end
+      end
+
+      # VICE's debug cartridge register at $8BFF, which a write calls the
+      # handler with, the exit code the VICE testprogs report. It answers
+      # on every model, ahead of the 2001's screen RAM there and the
+      # 8096's banks, and every other write to its page passes to what
+      # the page holds.
+      class DebugRegister
+        ADDRESS = 0x8bff
+
+        attr_accessor :under
+
+        def initialize(&handler)
+          @handler = handler
+          @under = nil
+        end
+
+        def poke(addr, value)
+          return @handler.call(value) if addr == ADDRESS
+
+          @under.poke(addr, value)
+        end
+      end
+
+      attr_reader :ram, :screen, :expansion
+
+      # The last byte the CPU read or wrote.
+      attr_reader :data
+
+      # +model+ is a Model::Profile, +ram_kb+ the RAM below $8000 and
+      # +editor+ the editor ROM's file. The CRTC answers only on a board
+      # the model fits one on.
+      def initialize(model:, ram_kb:, editor:, pia1:, pia2:, via:, crtc:)
+        addressable_at(0, length: 2**16)
+        @ram = Memory.new([], length: ram_kb * 1024, start: 0)
+        @screen = ScreenRAM.new(model.screen_bytes)
+        @screen_pages = model.screen_pages
+        basic = ROM.read(model.basic)
+        @basic_rom = ROM.new(basic, length: basic.length, start: 0xe000 - basic.length)
+        @editor_rom = ROM.load(editor, 0xe000)
+        @kernal_rom = ROM.load(model.kernal, 0xf000)
+        @io = IO.new(self, pia1:, pia2:, via:, crtc:, crtc_fitted: model.crtc?)
+        @open_bus = OpenBus.new(self)
+        @data = 0
+        @read_pages = Array.new(256, @open_bus)
+        @write_pages = Array.new(256, @open_bus)
+        @expansion = model.expansion ? Expansion.new(self) : nil
+        @debug_register = nil
+        @io_write_handler = nil
+        map_pages
+      end
+
+      # Calls the block after each write to the I/O chips, which may have
+      # moved the lines their ports drive.
+      def on_io_write(&handler)
+        @io_write_handler = handler
+      end
+
+      def io_written
+        @io_write_handler&.call
+      end
+
+      # The RES line reaches the 8096's control register.
+      def reset!
+        @expansion&.reset!
+      end
+
+      def power_on!
+        @ram.clear!
+        @screen.cells.fill(0)
+        @expansion&.power_on!
+      end
+
+      def peek(addr)
+        @data = @read_pages[addr >> 8].peek(addr)
+      end
+
+      def poke(addr, value)
+        @data = value
+        @write_pages[addr >> 8].poke(addr, value)
+      end
+
+      # Whether the CPU reads the KERNAL ROM at $F000-$FFFF, which an 8096's
+      # board covers while its control register turns it on.
+      def kernal_mapped? = @expansion.nil? || @expansion.control.nobits?(0x80)
+
+      # Calls the block with each byte written to $8BFF (DebugRegister).
+      def install_debug_register(&)
+        @debug_register = DebugRegister.new(&)
+        map_pages
+      end
+
+      # Lays the pages out again, for the 8096's control register.
+      def map_pages
+        map(@open_bus, 0x00, 0x100)
+        map(@ram, 0x00, @ram.length >> 8)
+        map(@screen, 0x80, @screen_pages)
+        @read_pages.fill(@basic_rom, @basic_rom.start >> 8, @basic_rom.length >> 8)
+        @read_pages.fill(@editor_rom, 0xe0, 0x08)
+        map(@io, 0xe8, 0x01)
+        @read_pages.fill(@kernal_rom, 0xf0, 0x10)
+        @expansion&.map(@read_pages, @write_pages)
+        map_debug_register if @debug_register
+      end
+
+      private
+
+      def map_debug_register
+        @debug_register.under = @write_pages[0x8b]
+        @write_pages[0x8b] = @debug_register
+      end
+
+      def map(chip, first, count)
+        @read_pages.fill(chip, first, count)
+        @write_pages.fill(chip, first, count)
+      end
+    end
+  end
+end