badline 0.16.1 → 0.17.0

data/lib/badline/snapshot/image.rb

@@ -34,7 +34,15 @@ module Badline
     # of a machine in memory (.of).
     class Image
       MACHINE = "BL-MACHINE"
-      FAMILIES = { "c64" => "C64", "vic20" => "VIC-20", "c128" => "C128", "plus4" => "Plus/4", "pet" => "PET" }.freeze
+      FAMILIES = { "c64" => "C64", "vic20" => "VIC-20", "c128" => "C128", "plus4" => "Plus/4", "pet" => "PET",
+                   "cbm2" => "CBM-II" }.freeze
+
+      # The snapshots VICE's emulators write that badline doesn't read, by
+      # the machine their container names.
+      UNREAD = {
+        Container::VIC20 => "VIC-20 snapshots, not xvic's", Container::C128 => "C128 snapshots, not x128's",
+        Container::PLUS4 => "Plus/4 snapshots, not xplus4's"
+      }.freeze
 
       attr_reader :container
 
@@ -53,21 +61,38 @@ module Badline
         new(Container.new(computer.save_modules, machine: machine_name(computer)))
       end
 
-      # The snapshot with VICE's modules ahead of the BL-* ones for a C64
-      # or a PET, so x64sc or xpet opens it too. Raises FormatError for a
-      # Plus/4, whose snapshots badline doesn't write for xplus4.
+      # The snapshot with VICE's modules ahead of the BL-* ones for a C64,
+      # a PET, a CBM-II's B series or a P500, so x64sc, xpet, xcbm2 or
+      # xcbm5x0 opens it too. Raises FormatError for a Plus/4, whose
+      # snapshots badline doesn't write for xplus4.
       def self.exported(computer)
         raise FormatError, "badline doesn't export a Plus/4's snapshot for VICE" if computer.family == :plus4
 
-        computer.settle_for_snapshot!
+        computer.settle_for_vice!
         sections = computer.save_modules
         case computer.family
         when :c64 then sections = Vice.export(computer) + sections
         when :pet then sections = Vice::PET.export(computer, sections) + sections
+        when :cbm2 then sections = cbm2_export(computer, sections) + sections
         end
         new(Container.new(sections, machine: machine_name(computer)))
       end
 
+      # xcbm2's or xcbm5x0's modules for a CBM-II.
+      def self.cbm2_export(computer, sections)
+        computer.is_a?(CBM2::P500) ? Vice::P500.export(computer, sections) : Vice::CBM2.export(computer, sections)
+      end
+
+      # The VICE emulator a machine's VICE modules are for.
+      def self.vice_emulator(computer)
+        case machine_name(computer)
+        when Container::PET then "xpet"
+        when Container::CBM2 then "xcbm2"
+        when Container::CBM2_5X0 then "xcbm5x0"
+        else "x64sc"
+        end
+      end
+
       # The machine as VICE's emulators name it.
       def self.machine_name(computer)
         case computer.family
@@ -75,6 +100,7 @@ module Badline
         when :c128 then Container::C128
         when :plus4 then Container::PLUS4
         when :pet then Container::PET
+        when :cbm2 then computer.is_a?(CBM2::P500) ? Container::CBM2_5X0 : Container::CBM2
         else Container::MACHINE
         end
       end
@@ -87,6 +113,7 @@ module Badline
         when "c128" then C128Setup.read_fields(machine)
         when "plus4" then Plus4Setup.read_fields(machine)
         when "pet" then PETSetup.read_fields(machine)
+        when "cbm2" then CBM2Setup.read_fields(machine)
         else C64Setup.read_fields(machine)
         end
       end
@@ -102,16 +129,16 @@ module Badline
 
       # A new machine, built as the snapshot's was and restored from it. A
       # badline snapshot restores from its BL-* modules alone, and a VICE
-      # one through the modules badline reads, x64sc's or xpet's. xvic's,
+      # one through the modules badline reads, x64sc's, xpet's, xcbm2's or xcbm5x0's. xvic's,
       # x128's and xplus4's own modules aren't read. Yields a line for
       # each thing left out, or warns it without a block. `detached`
       # restores it without the host's files (Keyed::Modules).
       def load(detached: false, &)
         refuse_old_layout
-        raise FormatError, "badline reads only its own VIC-20 snapshots, not xvic's" if vic20? && !badline?
-        raise FormatError, "badline reads only its own C128 snapshots, not x128's" if c128? && !badline?
-        raise FormatError, "badline reads only its own Plus/4 snapshots, not xplus4's" if plus4? && !badline?
+        refuse_unread
         return load_xpet(&) if pet? && !badline?
+        return load_xcbm2(&) if cbm2? && !badline?
+        return load_xcbm5x0(&) if p500? && !badline?
         return load_vice(&) unless badline?
 
         modules = Keyed::Modules.new(sections, detached:)
@@ -132,6 +159,13 @@ module Badline
       # Whether the machine is a PET, as the container names it.
       def pet? = @container.machine == Container::PET
 
+      # Whether the machine is a CBM-II's B series, as the container names
+      # it.
+      def cbm2? = @container.machine == Container::CBM2
+
+      # Whether the machine is a P500, as the container names it.
+      def p500? = @container.machine == Container::CBM2_5X0
+
       # Restores `computer` from the snapshot, and returns the Report. The
       # snapshot goes into a new machine first, so one that fails, or is of
       # a machine built another way, leaves `computer` as it was.
@@ -139,6 +173,8 @@ module Badline
         refuse_old_layout
         report = if badline? then restore_modules(computer)
                  elsif pet? then Vice::PET::Restore.import(@container, computer)
+                 elsif cbm2? then Vice::CBM2::Restore.import(@container, computer)
+                 elsif p500? then Vice::P500::Restore.import(@container, computer)
                  else Vice::Restore.import(@container, computer)
                  end
         tell(report, &)
@@ -159,6 +195,18 @@ module Badline
         computer
       end
 
+      def load_xcbm2(&)
+        computer = Vice::CBM2.setup(@container).build
+        tell(Vice::CBM2::Restore.apply(@container, computer), &)
+        computer
+      end
+
+      def load_xcbm5x0(&)
+        computer = Vice::P500.setup(@container).build
+        tell(Vice::P500::Restore.apply(@container, computer), &)
+        computer
+      end
+
       # The snapshot goes into a new machine first, so one that fails
       # leaves `computer` as it was.
       def restore_modules(computer)
@@ -175,6 +223,11 @@ module Badline
         report(modules, computer)
       end
 
+      def refuse_unread
+        unread = UNREAD[@container.machine]
+        raise FormatError, "badline reads only its own #{unread}" if unread && !badline?
+      end
+
       # A snapshot from a badline before the keyed modules, which only the
       # version that saved it reads.
       def refuse_old_layout

data/lib/badline/snapshot/vice/cbm2.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "badline/snapshot/vice/cbm2_mem"
+require "badline/snapshot/vice/cbm2_tpi"
+require "badline/snapshot/vice/cbm2_acia"
+require "badline/snapshot/vice/cbm2_crtc"
+require "badline/snapshot/vice/cbm2_mains"
+require "badline/snapshot/vice/cbm2_restore"
+
+module Badline
+  module Snapshot
+    module Vice
+      # xcbm2's modules for the CBM-II's B series: the CPU, the RAM, the
+      # CRTC, the CIA, both TPIs, the ACIA and the SID, written from
+      # badline's machine and read into it. Each module's file says what
+      # maps and what is approximated. The CPU's, the CIA's and the SID's
+      # are the PET's and the C64's. They go through the machine's own
+      # keyed fields (Keyed), which a save writes and a load reads, but for
+      # the CIA and the SID, which go through the chips as the C64's do.
+      module CBM2
+        # The models badline builds by the RAM board's size in K and
+        # whether the model line is a 700's.
+        MODELS = { [128, false] => "610", [256, false] => "620", [128, true] => "710", [256, true] => "720" }.freeze
+        # The modules xcbm2 resets the machine without, each as xcbm2 leaves
+        # them with nothing attached: no cartridge, no file system drive
+        # open, the cassette port on with a datasette in it, and nothing in
+        # the user port.
+        PERIPHERALS = [["CBM2CART", 0, 1, [0x00]], ["FSDRIVE", 0, 0, Array.new(258, 0)],
+                       ["TAPEPORT", 1, 0, [0x01, 0x01]], ["USERPORT", 1, 0, [0x01, 0x00]]].freeze
+
+        module_function
+
+        # The modules xcbm2 3.10 reads, in its order, describing `machine`,
+        # which Machine::Settling has brought between instructions, from
+        # its keyed modules, `sections`.
+        def export(machine, sections)
+          readers = {}
+          sections.each { |section| readers[section.name] = Keyed::Reader.parse(section) }
+          machine.sid.catch_up!
+          cart, *rest = PERIPHERALS.map do |name, major, minor, bytes|
+            FieldWriter.new.bytes(bytes).section(name, major, minor)
+          end
+          [PET::MainCPU.write(machine, machine.tpi1.irq? ? 1 : 0), CBM2Mem.export(machine), cart,
+           CRTC.export(machine, reader(readers, "BL-CRTC"), reader(readers, "BL-VIDEO")),
+           CIAs.section(machine.cia, "CIA1"),
+           *TPI::NAMES.map { |name| TPI.export(name, reader(readers, "BL-#{name}")) },
+           ACIA.export(reader(readers, "BL-ACIA"), machine.cycles),
+           SIDRegisters.export(machine), SIDExtended.export(machine), *drives(machine, readers), *rest]
+        end
+
+        # The true drive's modules, as xpet's (PET::Drive2031,
+        # PET::Drive8050), or with no true drive, DRIVE8 to DRIVE11 as
+        # xcbm2 and xcbm5x0 save no drive.
+        def drives(machine, readers)
+          return no_drives unless machine.true_drive
+
+          PET::Drive2031.export(machine, readers) + PET::Drive8050.export(machine, readers)
+        end
+
+        def no_drives = PET::Drive2031::UNITS.map { |name| PET::Drive2031.unit(PET::Drive2031::NONE, name) }
+
+        def reader(readers, name) = readers[name] || Keyed::Reader.missing(name)
+
+        # How the machine xcbm2 saved was built: the model from the RAM
+        # board's size and the model line, and the mains from the model
+        # line too, 60 Hz on a 600 whose line says so and 50 Hz otherwise:
+        # xcbm2 has no 700 at 60 Hz. xcbm2 doesn't save its ROMs, so the
+        # KERNAL is 901244-04a, xcbm2's own.
+        def setup(container)
+          memory = memory(container)
+          ram_kb = CBM2Mem.ram_kb(memory)
+          line = CBM2Mem.line(memory)
+          unless CBM2Mem.mapped(memory).zero?
+            raise FormatError, "#{memory}: RAM in segment 15 beyond the B series', which badline doesn't build"
+          end
+
+          model = MODELS[[ram_kb, line == CBM2Mem::M700]]
+          raise FormatError, "#{memory}: a CBM-II with #{ram_kb}K of RAM, which badline doesn't build" if model.nil?
+
+          CBM2Setup.new(model:, kernal: "04a", mains_hz: line == CBM2Mem::M600_60HZ ? 60 : 50, refresh: true)
+        end
+
+        def memory(container)
+          section = container[CBM2Mem::NAME]
+          raise FormatError, "the snapshot has no #{CBM2Mem::NAME} module" if section.nil?
+          raise FormatError, "#{section}: badline doesn't read this version" unless CBM2Mem.reads?(section)
+
+          section
+        end
+      end
+    end
+  end
+end

data/lib/badline/snapshot/vice/cbm2_acia.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    module Vice
+      module CBM2
+        # Acia1 1.1, the 6551: the transmitter's and the receiver's data
+        # registers, the status, the command and control registers, the
+        # transmitter's state (0 idle, 2 a byte waiting), then four clocks:
+        # the cycles to the transmitter's next character end, a clock
+        # xcbm2 leaves 0, the cycles to its next receiver poll and another
+        # 0.
+        #
+        # Written: the registers, the status as a read finds it, and while
+        # the transmitter is on, the cycles to its character's end in both
+        # clocks. Read: the registers, the receiver full, the transmitter
+        # empty, the interrupt and the errors from the status, and the
+        # transmitter's character end from its clock, or one a character's
+        # time on when the clock has run out. Nothing is plugged
+        # in, in either, and a character being shifted out is lost.
+        module ACIA
+          NAME = "Acia1"
+          MAJOR = 1
+          MINOR = 1
+          WAITING = 2
+          ERRORS = 0x07
+          RECEIVER_FULL = 0x08
+          TRANSMITTER_EMPTY = 0x10
+          IRQ = 0x80
+
+          module_function
+
+          def reads?(section) = section.major == MAJOR && section.minor == MINOR
+
+          # The module from the ACIA's BL-ACIA fields in `input`, for a
+          # machine at `cycles`.
+          def export(input, cycles)
+            empty = input.bool("transmitter_empty", true)
+            status = input.int("errors", 0) | Chips::ACIA::DCD | Chips::ACIA::DSR
+            status |= RECEIVER_FULL if input.bool("receiver_full", false)
+            status |= TRANSMITTER_EMPTY if empty
+            status |= IRQ if input.bool("irq", false)
+            at = input.int("transmit_at", Chips::ACIA::NEVER)
+            due = at == Chips::ACIA::NEVER ? 0 : [at - cycles, 0].max
+            FieldWriter.new.byte(input.int("transmit_data", 0)).byte(input.int("receive_data", 0)).byte(status)
+                       .byte(input.int("command", 0)).byte(input.int("control", 0)).byte(empty ? 0 : WAITING)
+                       .dword(due).dword(0).dword(due).dword(0).section(NAME, MAJOR, MINOR)
+          end
+
+          # The ACIA by its BL-ACIA keys, in a keyed module's writer, for a
+          # machine at `cycles`.
+          def import(section, out, cycles)
+            fields = FieldReader.new(section)
+            transmit, receive, status, command, control = fields.bytes(5)
+            fields.skip(1)
+            due = fields.dword
+            out.int("command", command).int("control", control).int("errors", status & ERRORS)
+            out.bool("receiver_full", status.anybits?(RECEIVER_FULL))
+            out.bool("transmitter_empty", status.anybits?(TRANSMITTER_EMPTY)).bool("irq", status.anybits?(IRQ))
+            out.int("receive_data", receive).int("transmit_data", transmit).int("shifting", Chips::ACIA::IDLE)
+            out.int("transmit_remainder", 0)
+            return out.int("transmit_at", Chips::ACIA::NEVER) unless transmitting?(command)
+
+            out.optional_int("transmit_at", due.positive? ? cycles + due : nil)
+          end
+
+          def transmitting?(command)
+            control = command & 0x0c
+            control != 0 && control != 0x0c
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/snapshot/vice/cbm2_crtc.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    module Vice
+      module CBM2
+        # CRTC 1.2 as xcbm2 saves it, laid out as xpet's (PET::CRTC): the
+        # board's screen settings, the registers, the one selected, the
+        # beam, the picture's size and the frame's lines, then xcbm2's
+        # picture. xcbm2's board has the 6845's cursor and reads one byte a
+        # character from 2K of screen RAM. After the beam's line come the
+        # fields left in the cursor's blink phase, counted down from 32, and
+        # whether the cursor shows: xcbm2 blinks it 32 fields on and 32 off,
+        # where badline's 6845 blinks it 16 and 16, or 8 and 8.
+        #
+        # xcbm2 ticks the mains once a frame, as vertical sync ends, so its
+        # mains follows the CRTC (Mains).
+        #
+        # Written: the registers and the beam as badline's CRTC has them,
+        # and the cursor shown as badline's is, its phase scaled to xcbm2's.
+        # The picture is left blank, as xcbm2 paints it again. Read: the
+        # registers and the beam as xpet's are (PET::CRTC), the cursor shown
+        # as xcbm2's is, its phase scaled to badline's, and where the
+        # picture is in its frame. The picture starts again with the next
+        # frame.
+        module CRTC
+          NAME = PET::CRTC::NAME
+          SETTINGS = [0xff, 0x07, 0x00, 0x10, 0x00, 0x20, 0x00, 0xe0, 0xff, 0x3f].freeze
+          # The 6845's cursor, one byte a character, and not a 2001.
+          BOARD = [0x01, 0x01, 0x00].freeze
+          WIDTH = 704
+          # The picture's lines and the line its first row starts on, for a
+          # 600 and a 700.
+          FRAMES = { false => [266, 33], true => [366, 8] }.freeze
+          BLINK = 32
+          # Where R10 is in the module, and the blink's fields left.
+          R10_AT = PET::CRTC::SETTINGS.length + 5 + 10
+          BLINK_AT = PET::CRTC::SELECTED + 4
+          # R10's blink of 8 fields on and 8 off.
+          FAST_BLINK = 0x40
+
+          module_function
+
+          def reads?(section) = PET::CRTC.reads?(section)
+
+          def fresh_crtc(machine) = CBM2Setup.of(machine).build.crtc
+
+          # The module from the BL-CRTC and BL-VIDEO fields in `crtc_input`
+          # and `video_input`.
+          def export(machine, crtc_input, video_input)
+            registers = PET::CRTC.crtc_registers(crtc_input)
+            beam = beam(machine, crtc_input, registers)
+            height, top = FRAMES.fetch(machine.model.high_profile)
+            fields = FieldWriter.new.bytes(SETTINGS).word(0).bytes(BOARD).bytes(registers)
+            fields.byte(crtc_input.int("selected", 0)).byte(beam.column).byte(beam.row).byte(beam.raster)
+            fields.bytes(blink(video_input.int("frames", 0), registers[10])).byte(1)
+            fields.word(0).word(beam.start & PET::CRTC::SCREEN_BITS).byte(beam.vsync).byte(0).flag(beam.shown)
+            fields.word(WIDTH).word(height).byte(PET::CRTC::AFTER_SIZE).zeros(3).byte(top).byte(0)
+            fields.word(PET::CRTC.frame_lines(registers)).word(beam.frame_line).byte(1)
+            fields.dword(0).dword(WIDTH).dword(height).dword(WIDTH).zeros(WIDTH * (height + 4))
+            fields.section(NAME, PET::CRTC::MAJOR, PET::CRTC::MINOR)
+          end
+
+          # The beam where xcbm2's is with badline's CRTC where `input` has
+          # it (PET::CRTC::CRTC_LEAD). On a line's last character xcbm2's
+          # beam has moved on to the next line, a cycle before it starts.
+          def beam(machine, input, registers)
+            cycles = -PET::CRTC::CRTC_LEAD % PET::CRTC.frame_cycles(registers)
+            beam = PET::CRTC.crtc_beam(PET::CRTC.run_on(fresh_crtc(machine), input, cycles), registers)
+            return beam unless beam.column == registers[0]
+
+            PET::CRTC.crtc_beam(PET::CRTC.run_on(fresh_crtc(machine), input, cycles + 1), registers).with(column: 0xff)
+          end
+
+          # The fields left in xcbm2's blink phase and whether its cursor
+          # shows, for badline's fields counted, `frames`, and R10.
+          def blink(frames, r10)
+            fast = r10 & 0x60 == FAST_BLINK
+            shown = frames.nobits?(fast ? 0x08 : 0x10)
+            phase = fast ? (frames & 0x07) << 1 : frames & 0x0f
+            [BLINK - (phase << 1), shown ? 1 : 0]
+          end
+
+          # badline's fields counted for xcbm2's blink in `section`.
+          def frames(section)
+            r10 = FieldReader.new(section).skip(R10_AT).byte
+            left, shown = FieldReader.new(section).skip(BLINK_AT).bytes(2)
+            phase = ((BLINK - [left, BLINK].min) >> 1) & 0x0f
+            return (shown.zero? ? 0x08 : 0) | (phase >> 1) if r10 & 0x60 == FAST_BLINK
+
+            (shown.zero? ? 0x10 : 0) | phase
+          end
+
+          # The BL-CRTC module, run on from xcbm2's beam as xpet's is.
+          def import(section, machine)
+            counters = Keyed.section("BL-CRTC") { |out| PET::CRTC.import(section, out, 1, 0) }
+            frame = PET::CRTC.frame_cycles(PET::CRTC.registers(section))
+            cycles = (PET::CRTC::CRTC_LEAD + PET::CRTC.column_of(section)) % frame
+            fields = PET::CRTC.run_on(fresh_crtc(machine), Keyed::Reader.parse(counters), cycles)
+            Keyed.section("BL-CRTC") { |out| PET::CRTC.copy(fields, out) }
+          end
+
+          # The BL-VIDEO module for a CRTC whose BL-CRTC fields `crtc` holds:
+          # the cursor's blink, the line the frame paints next and the frame's
+          # layout. The picture stays as the machine has it.
+          def video(section, crtc)
+            registers = PET::CRTC.crtc_registers(crtc)
+            Keyed.section("BL-VIDEO") do |out|
+              out.int("frames", frames(section)).int("line", painted(crtc, registers)).bool("line_shown", false)
+              out.int("origin", Badline::CBM2::CRTCVideo::LEFT - ((registers[0] + 1 - registers[2]) << 3))
+              out.ints("layout", registers.values_at(0, 1, 2, 4, 5, 6, 9, 12, 13))
+            end
+          end
+
+          # The lines the frame has displayed so far.
+          def painted(crtc, registers)
+            lines = registers[9] + 1
+            shown = registers[6] * lines
+            return shown if crtc.bool("adjusting", false) || !crtc.bool("row_display", true)
+
+            [(crtc.int("row", 0) * lines) + crtc.int("line", 0), shown].min
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/snapshot/vice/cbm2_mains.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    module Vice
+      module CBM2
+        # The mains on TPI1's I0. xcbm2 saves no mains: it ticks it once a
+        # frame of its CRTC, as vertical sync ends, whatever the mains is
+        # set to. A machine read from its snapshot has its mains' next
+        # falling edge where xcbm2's tick would come, and runs it at its own
+        # 50 or 60 Hz from there. A snapshot written for xcbm2 ticks where
+        # its CRTC says.
+        module Mains
+          # The cycle of the line where vertical sync ends that the tick
+          # latches on, counted as badline's CRTC counts columns.
+          TICK_COLUMN = 0
+
+          module_function
+
+          # The cycles to the mains' next falling edge for a CRTC whose
+          # BL-CRTC fields `crtc` holds.
+          def next_tick(crtc)
+            registers = crtc.bytes("registers", "".b).bytes
+            regs = Array.new(Chips::CRTC::MASKS.length) { |index| registers[index] || 0 }
+            line_cycles = regs[0] + 1
+            lines = regs[9] + 1
+            rows = regs[4] + 1
+            frame_lines = (rows * lines) + regs[5]
+            line = crtc.int("line", 0)
+            line += crtc.bool("adjusting", false) ? rows * lines : crtc.int("row", 0) * lines
+            tick_line = ((regs[7] * lines) + Chips::CRTC::VSYNC_LINES) % frame_lines
+            frame = line_cycles * frame_lines
+            cycles = ((tick_line * line_cycles) + TICK_COLUMN - ((line * line_cycles) + crtc.int("column", 0))) % frame
+            cycles.zero? ? frame : cycles
+          end
+
+          # The BL-MACHINE mains fields for a mains `half_period` cycles high
+          # and as long low, whose next falling edge is `cycles` away.
+          def write(out, cycles, half_period)
+            high = cycles <= half_period
+            countdown = high ? cycles : [cycles - half_period, half_period].min
+            out.int("mains_countdown", countdown).bool("mains_high", high)
+            high
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/snapshot/vice/cbm2_mem.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    module Vice
+      module CBM2
+        # CBM2MEM 1.0: the RAM board's size in units of 128K, the RAM xcbm2
+        # maps into segment 15 beyond the B series' own (none on a B series
+        # as built, $40 on a P500), its model line (0 a 700, 1 a 600 at
+        # 60 Hz, 2 a 600 at 50 Hz), the execution and indirection segment
+        # registers, then segment 15's 2K of RAM, the 2K of screen RAM, and
+        # the board's segments from segment 1 up.
+        #
+        # xcbm2 keeps the segment registers in segment 15's bytes $0000 and
+        # $0001 too, and they are written there. Under the registers
+        # badline's RAM is never written, so those two bytes read as 0.
+        # xcbm2's ROMs aren't in the snapshot.
+        module CBM2Mem
+          NAME = "CBM2MEM"
+          MAJOR = 1
+          MINOR = 0
+          SEGMENT = 0x10000
+          SYSTEM_RAM = 0x800
+          SCREEN_RAM = 0x800
+          HEADER = 5
+          # The model lines.
+          M700 = 0
+          M600_60HZ = 1
+          M600_50HZ = 2
+
+          module_function
+
+          def reads?(section) = section.major == MAJOR && section.minor == MINOR
+
+          def model_line(machine)
+            return M700 if machine.model.high_profile
+
+            machine.mains_hz == 60 ? M600_60HZ : M600_50HZ
+          end
+
+          def export(machine)
+            bus = machine.bus
+            system = bus.ram.snapshot
+            system[0] = bus.execution_segment
+            system[1] = bus.indirect_segment
+            fields = FieldWriter.new.byte(machine.model.ram_segments.length / 2).byte(0).byte(model_line(machine))
+            fields.byte(bus.execution_segment).byte(bus.indirect_segment)
+            fields.bytes(system).bytes(bus.screen.snapshot)
+            machine.model.ram_segments.each { |segment| fields.bytes(bus.segment_ram[segment].snapshot) }
+            fields.section(NAME, MAJOR, MINOR)
+          end
+
+          # The RAM in K, the RAM mapped into segment 15 and the model line.
+          def ram_kb(section) = FieldReader.new(section).byte * 128
+
+          def mapped(section) = FieldReader.new(section).skip(1).byte
+
+          def line(section) = FieldReader.new(section).skip(2).byte
+
+          # The RAM and the segment registers by their BL-RAM keys, in a
+          # keyed module's writer, for a machine whose board fills
+          # `segments`.
+          def import(section, out, segments)
+            fields = FieldReader.new(section).skip(3)
+            out.int("execution_segment", fields.byte & 0x0f).int("indirect_segment", fields.byte & 0x0f)
+            system = fields.string(SYSTEM_RAM)
+            out.bytes("system", "\0\0".b + system.byteslice(2, SYSTEM_RAM - 2))
+            out.bytes("screen", fields.string(SCREEN_RAM))
+            segments.each { |segment| out.bytes("segment#{segment}", fields.string(SEGMENT)) }
+          end
+        end
+      end
+    end
+  end
+end