badline 0.17.0 → 0.19.0

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

@@ -5,14 +5,24 @@ module Badline
     module Vice
       module PET
         # PETMEM 1.3: the board, the RAM below $8000 in K and the 8096's
-        # control register at $FFF0, then the RAM, the screen RAM, 1K or 2K
-        # as the board has, or on the 8296 its 32K from $8000, an 8096's or
-        # 8296's 64K board, and 24 bytes of xpet's own settings, which name
-        # the 2001.
+        # control register at $FFF0, a byte for the SuperPET's latches, then
+        # the RAM, the screen RAM, 1K or 2K as the board has, or on the 8296
+        # its 32K from $8000, an 8096's, 8296's or SuperPET's 64K board, and
+        # 24 bytes of xpet's own settings, which name the 2001, and on the
+        # SuperPET the CPU that has the bus and the 6702.
         #
         # The board is 0 for the discrete video, 1 for a 40-column CRTC, 2
         # for an 80-column one, 3 for the SuperPET, 4 for the 8096 and 5 for
         # the 8296. xpet's ROMs aren't in the snapshot.
+        #
+        # The SuperPET's latch byte holds the bank at $9000 in its high
+        # nibble, and sets bit 0 while the bank RAM is there rather than the
+        # empty socket, and bit 2 always. Its settings hold 1 at offset 2
+        # while the 6809 has the bus. Both were inferred from xpet 3.10's
+        # snapshots after writes to the bank latch and $EFFE, and in both
+        # modes. xpet has no system latch, so the bank latch's bit 7 and the
+        # system latch aren't saved, and a restore clears them. The 6702 is
+        # in the settings from their fifth byte (Dongle).
         module PETMem
           NAME = "PETMEM"
           MAJOR = 1
@@ -30,6 +40,14 @@ module Badline
           SETTINGS = [0x00, 0x00, 0x00, 0x00, 0xd6, 0x01, 0x00, 0x20, 0x00, 0x04, 0x00, 0x40, 0x00, 0x00, 0x00,
                       0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00].freeze
           SETTINGS_2001 = 0x03
+          # The SuperPET's settings byte for the CPU, and its value while the
+          # 6809 has the bus.
+          SETTINGS_CPU = 2
+          SETTINGS_M6809 = 0x01
+          # The SuperPET's latch byte: the bit always set, and the one for
+          # the bank RAM at $9000.
+          LATCHES = 0x04
+          BANK_RAM = 0x01
           EXPANSION = 0x10000
 
           module_function
@@ -37,6 +55,7 @@ module Badline
           def reads?(section) = section.major == MAJOR && section.minor == MINOR
 
           def board(model)
+            return SUPERPET if model.superpet?
             return CBM8296 if model.cbm8296?
             return CBM8096 if model.expansion
 
@@ -50,15 +69,46 @@ module Badline
           def export(machine)
             bus = machine.bus
             expansion = bus.expansion
+            superpet = machine.superpet?
             fields = FieldWriter.new.byte(board(machine.model)).byte(0).byte(machine.ram_kb)
-            fields.byte(expansion ? expansion.control : 0).byte(HEADER_END)
+            fields.byte(expansion ? expansion.control : 0).byte(superpet ? latches(machine.board) : HEADER_END)
             fields.bytes(machine.ram.snapshot).bytes(bus.screen.cells)
             fields.bytes(expansion.cells) if expansion
+            fields.bytes(machine.board.cells) if superpet
             settings = SETTINGS.dup
             settings[1] = SETTINGS_2001 if machine.model.basic1?
+            if superpet
+              settings[SETTINGS_CPU] = SETTINGS_M6809 if machine.m6809_running?
+              dongle = machine.dongle
+              settings[Dongle::AT, Dongle::LENGTH] = Dongle.export(dongle.settled_registers, dongle.latch)
+            end
             fields.bytes(settings).section(NAME, MAJOR, MINOR)
           end
 
+          def latches(board) = (board.bank << 4) | LATCHES | (board.socket.zero? ? BANK_RAM : 0)
+
+          # Whether a SuperPET's settings say the 6809 has the bus.
+          def m6809?(section)
+            data = section.data
+            offset = data.bytesize - SETTINGS.length + SETTINGS_CPU
+            offset >= 0 && data.getbyte(offset).to_i.anybits?(SETTINGS_M6809)
+          end
+
+          # A SuperPET's bank latch, socket bit, 64K board and 6702 by their
+          # BL-SUPERPET keys, in a keyed module's writer.
+          def import_superpet(section, out)
+            fields = FieldReader.new(section).skip(4)
+            latches = fields.byte
+            fields.skip(fields_before_board(section))
+            out.int("bank_latch", latches >> 4).int("socket", latches.anybits?(BANK_RAM) ? 0 : 1)
+            out.int("system_latch", 0).bytes("ram", fields.string(EXPANSION))
+            fields.skip(Dongle::AT)
+            Dongle.import(fields.bytes(Dongle::LENGTH), out)
+          end
+
+          # The RAM and the screen RAM before a SuperPET's board.
+          def fields_before_board(section) = (ram_kb(section) * 1024) + 0x800
+
           # The board's number in the header.
           def board_of(section) = FieldReader.new(section).byte
 

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

@@ -8,18 +8,23 @@ module Badline
         # reads become the PET's own keyed modules (Keyed), which it loads
         # as it loads its own snapshot. Whatever they don't set stays as the
         # machine has it at power-on, and the datasettes' tapes and the
-        # disk device 8 serves stay as they are. A snapshot with a true 2031,
-        # 8050 or 8250 puts one on the bus, with the disks badline's drive
-        # of that model had in it, and one without takes badline's off.
+        # disk device 8 serves stay as they are. A snapshot with a true drive
+        # puts one on the bus, with the disks badline's drive of that model
+        # had in it (Drive2031, Drive8050), and one without takes badline's
+        # off.
         module Restore
           # MAINCPU and PETMEM hold the machine itself, so a version badline
           # doesn't read fails the restore. The others are left out and
           # reported.
           READ = [MainCPU::NAME, PETMem::NAME, CRTC::NAME, "PIA1", "PIA2", VIA::NAME].freeze
+          # The SuperPET's too: its 6809 and its ACIA. A SuperPET's board
+          # comes from PETMEM.
+          SUPERPET_READ = [CPU6809::NAME, CBM2::ACIA::NAME].freeze
           # The host's media, which a restore keeps.
           KEPT = %w[BL-TAPE1 BL-TAPE2 BL-TRAPDOS].freeze
-          # The disks in a true drive's drives, which a restore keeps.
-          DISKS = %w[BL-D8-DISK BL-D8-DISK1].freeze
+          # The disks in a true drive's drives, and a hard disk's controller
+          # with its image, which a restore keeps.
+          DISKS = %w[BL-D8-DISK BL-D8-DISK1 BL-D8-SASI].freeze
 
           module_function
 
@@ -53,7 +58,8 @@ module Badline
             applied = []
             ignored = []
             sections = []
-            READ.each do |name|
+            names = read_names(computer)
+            names.each do |name|
               section = container[name]
               next if section.nil?
 
@@ -72,17 +78,20 @@ module Badline
             end
             sections += drive(container, applied, ignored, kept_disks(container, computer, disks))
             computer.load_modules(Keyed::Modules.new(modules(container, computer, applied) + sections))
-            Report.new(applied:, ignored: ignored + left_out(container, applied))
+            Report.new(applied:, ignored: ignored + left_out(container, names, applied))
           end
 
+          def read_names(computer) = computer.superpet? ? READ + SUPERPET_READ : READ
+
           # The disks badline's true drive has, which stay in the drive the
-          # snapshot puts on the bus when it is of the same model.
+          # snapshot puts on the bus when it is of the same model, or of the
+          # same xpet type.
           def kept_disks(container, computer, disks)
             drive = computer.true_drive
             return [] if drive.nil?
 
             if Drive8050.present?(container)
-              Drive8050.model(container) == drive.model_name ? disks : []
+              Drive8050.same_type?(Drive8050.model(container), drive.model_name) ? disks : []
             else
               drive.model_name == "2031" ? disks.first(1) : []
             end
@@ -113,6 +122,7 @@ module Badline
             end
 
             applied.concat(Drive8050::NAMES)
+            model = Drive8050.hard_disk_model(disks) if Drive8050.hard_disk?(model)
             Drive8050.import(container, Drive8050.reference(model), disks)
           end
 
@@ -134,6 +144,8 @@ module Badline
             when PETMem::NAME then PETMem.reads?(section)
             when CRTC::NAME then CRTC.reads?(section)
             when VIA::NAME then VIA.reads?(section)
+            when CPU6809::NAME then CPU6809.reads?(section)
+            when CBM2::ACIA::NAME then CBM2::ACIA.reads?(section)
             else PIAs.reads?(section)
             end
           end
@@ -160,9 +172,26 @@ module Badline
             if applied.include?(VIA::NAME)
               sections << Keyed.section("BL-VIA") { |out| VIA.import(container[VIA::NAME], out) }
             end
+            sections += superpet(container, applied) if computer.superpet?
             sections + video
           end
 
+          # The SuperPET's board, and its 6809 while it has the bus and its
+          # ACIA where the snapshot has them. The 6809 the 6502 has the bus
+          # from, and a module left out, stay as the machine has them at
+          # power-on.
+          def superpet(container, applied)
+            cycles = FieldReader.new(container[MainCPU::NAME]).qword
+            memory = container[PETMem::NAME]
+            sections = [Keyed.section("BL-SUPERPET") { |out| PETMem.import_superpet(memory, out) }]
+            if applied.include?(CPU6809::NAME) && PETMem.m6809?(memory)
+              sections << Keyed.section("BL-M6809") { |out| CPU6809.import(container[CPU6809::NAME], out, cycles) }
+            end
+            return sections unless applied.include?(CBM2::ACIA::NAME)
+
+            sections << Keyed.section("BL-ACIA") { |out| CBM2::ACIA.import(container[CBM2::ACIA::NAME], out, cycles) }
+          end
+
           def machine(out, container, computer, drive)
             out.text("family", "pet")
             PETSetup.of(computer).write_fields(out)
@@ -203,8 +232,8 @@ module Badline
             [Keyed.section("BL-CRTC") { |out| CRTC.copy(fields, out) }]
           end
 
-          def left_out(container, applied)
-            container.sections.reject { |section| READ.include?(section.name) || applied.include?(section.name) }
+          def left_out(container, names, applied)
+            container.sections.reject { |section| names.include?(section.name) || applied.include?(section.name) }
                      .map { |section| "#{section}: badline doesn't read this module, left out" }
           end
         end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "badline/snapshot/vice/vic20_cpu"
+require "badline/snapshot/vice/vic20_mem"
+require "badline/snapshot/vice/vic20_vici"
+require "badline/snapshot/vice/vic20_restore"
+
+module Badline
+  module Snapshot
+    module Vice
+      # xvic's modules for the VIC-20, PAL and NTSC: the CPU, the RAM, the
+      # VIC-I with the colour RAM, and both VIAs, written from badline's
+      # machine and read into it. Each module's file says what maps and
+      # what is approximated. The VIAs' are xpet's (PET::VIA). They go
+      # through the machine's own keyed fields (Keyed), which a save writes
+      # and a load reads.
+      module Vic20
+        # The modules xvic 3.10 resets the machine without, each as xvic
+        # leaves them with nothing attached: no cartridge, no file system
+        # drive open, the cassette port on with a datasette in it, the
+        # control port on with the joystick released, and nothing in the
+        # user port. With no drive modules xvic keeps its own drives as they
+        # are.
+        CARTRIDGE = ["VIC20CART", 2, 1, [0xff, 0xff, 0xff, 0xff, 0x00]].freeze
+        PERIPHERALS = [
+          ["FSDRIVE", 0, 0, Array.new(258, 0)], ["TAPEPORT", 1, 0, [0x01, 0x01]], ["JOYPORT0", 0, 0, [0x01]],
+          ["JOYSTICK0", 1, 2, [0x00, 0x00]], ["USERPORT", 1, 0, [0x01, 0x00]]
+        ].freeze
+
+        module_function
+
+        # The modules xvic 3.10 needs, 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) }
+          [MainCPU.export(machine), Mem.export(machine, reader(readers, "BL-MACHINE")), section(*CARTRIDGE),
+           VICI.export(machine, reader(readers, "BL-VICI"), reader(readers, "BL-COLORRAM")),
+           PET::VIA.export(reader(readers, "BL-VIA1"), "VIA1"), PET::VIA.export(reader(readers, "BL-VIA2"), "VIA2")] +
+            PERIPHERALS.map { |entry| section(*entry) }
+        end
+
+        def section(name, major, minor, bytes) = FieldWriter.new.bytes(bytes).section(name, major, minor)
+
+        def reader(readers, name) = readers[name] || Keyed::Reader.missing(name)
+
+        # How the machine xvic saved was built: the RAM from VIC20MEM's
+        # blocks, and the model from the lines of the VIC-I's picture.
+        def setup(container)
+          memory = container[Mem::NAME]
+          raise FormatError, "the snapshot has no #{Mem::NAME} module" if memory.nil?
+          raise FormatError, "#{memory}: badline doesn't read this version" unless Mem.reads?(memory)
+
+          ram = Mem.ram_configuration(memory)
+          raise FormatError, "#{memory}: RAM in blocks badline doesn't fit together" if ram.nil?
+
+          Vic20Setup.new(ram:, model: model(container))
+        end
+
+        def model(container)
+          vic = container[VICI::NAME]
+          return "pal" if vic.nil? || !VICI.reads?(vic)
+
+          VICI.model(vic) || raise(FormatError, "#{vic}: a picture of a size badline's VIC-Is don't draw")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    module Vice
+      module Vic20
+        # The 6502 as xvic 3.10 saves it, MAINCPU 1.4, 83 bytes: the clock,
+        # the registers, four dwords (the last opcode and three xvic keeps
+        # at 0 between instructions), five clocks of the IRQ and NMI
+        # bookkeeping, then the IRQ and NMI source counts and the pending
+        # interrupts. It is x64sc's MAINCPU 1.4 without the BA flags and
+        # the two clocks at its end, and xpet's MAINCPU 1.3 with one more
+        # dword. The layout was inferred from xvic's snapshots against its
+        # monitor's registers and clock.
+        #
+        # Written: the clock and the registers, which between instructions
+        # are the whole CPU, with VIA 2 counted as an IRQ source while it
+        # pulls the line, and VIA 1 as an NMI source. VICE's interrupt
+        # clocks are written as long past.
+        #
+        # Read: the clock and the registers. The CPU starts on an
+        # instruction boundary, as xvic's snapshot is taken on one.
+        module MainCPU
+          NAME = "MAINCPU"
+          MAJOR = 1
+          MINOR = 4
+          SIZE = 83
+          IK_IRQ = 0x02
+
+          module_function
+
+          def reads?(section) = section.major == MAJOR && section.minor == MINOR && section.data.bytesize == SIZE
+
+          def export(machine)
+            cpu = machine.cpu
+            fields = FieldWriter.new.qword(machine.cycles)
+            [cpu.a, cpu.x, cpu.y, cpu.stack_pointer].each { |register| fields.byte(register) }
+            fields.word(cpu.program_counter).byte(cpu.p)
+            4.times { fields.dword(0) }
+            5.times { fields.qword(0) }
+            irqs = machine.via2.irq? ? 1 : 0
+            fields.dword(irqs).dword(machine.via1.irq? ? 1 : 0).dword(irqs.positive? ? IK_IRQ : 0)
+            fields.section(NAME, MAJOR, MINOR)
+          end
+
+          # The clock and the registers by their BL-CPU keys, in a keyed
+          # module's writer, and the clock.
+          def import(section, out)
+            fields = FieldReader.new(section)
+            clock = fields.qword
+            out.int("a", fields.byte).int("x", fields.byte).int("y", fields.byte).int("sp", fields.byte)
+            out.int("pc", fields.word).int("p", fields.byte).int("cycles", clock)
+            clock
+          end
+
+          def clock(section) = FieldReader.new(section).qword
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    module Vice
+      module Vic20
+        # The VIC-20's RAM as xvic 3.10 saves it, VIC20MEM 1.1: a byte of
+        # the expansion blocks that hold RAM (bit 0 the 3K at $0400, bits
+        # 1-3 BLK1-BLK3, bit 5 BLK5), the bytes the CPU's and the VIC's
+        # data lines last held, a byte badline doesn't model (0, 1 or 6 in
+        # xvic's snapshots, not following the blocks), then the RAM: $0000-$03FF, $1000-$1FFF, the 3K at
+        # $0400-$0FFF, and BLK1, BLK2, BLK3 and BLK5 in turn, each only if
+        # it holds RAM. The layout was inferred from xvic's snapshots of
+        # each -memory setting, with each block filled with a byte of its
+        # own and the data lines left at a byte the monitor wrote. Colour
+        # RAM is in the VIC-I's module (VICI).
+        #
+        # Written and read: the RAM and both data lines' bytes. The fourth
+        # byte is written as 0, and not read.
+        module Mem
+          NAME = "VIC20MEM"
+          MAJOR = 1
+          MINOR = 1
+          # Each expansion block's bit in the first byte, and the bytes it
+          # holds, as Badline::Vic20::Bus::BLOCKS names them.
+          BLOCK_BITS = { ram123: 0x01, blk1: 0x02, blk2: 0x04, blk3: 0x08, blk5: 0x20 }.freeze
+          INTERNAL = [[0x0000, 0x0400], [0x1000, 0x1000]].freeze
+
+          module_function
+
+          def reads?(section) = section.major == MAJOR && section.minor == MINOR
+
+          # The blocks the first byte names, or nil for bits no block has.
+          def blocks(section)
+            bits = FieldReader.new(section).byte
+            names = BLOCK_BITS.select { |_, bit| bits.anybits?(bit) }.keys
+            names.sum { |name| BLOCK_BITS[name] } == bits ? names : nil
+          end
+
+          # The RAM configuration (Badline::Vic20::Bus::RAM_CONFIGURATIONS)
+          # whose blocks the module has, or nil.
+          def ram_configuration(section)
+            names = blocks(section)
+            return nil if names.nil?
+
+            Badline::Vic20::Bus::RAM_CONFIGURATIONS.find { |_, blocks| blocks.sort == names.sort }&.first
+          end
+
+          # The regions the RAM comes in, as [address, length].
+          def regions(names)
+            INTERNAL + Badline::Vic20::Bus::BLOCKS.filter_map do |name, (page, pages)|
+              [page << 8, pages << 8] if names.include?(name)
+            end
+          end
+
+          # The module for `machine`, with the data lines' bytes from its
+          # BL-MACHINE fields, `machine_fields`.
+          def export(machine, machine_fields)
+            names = Badline::Vic20::Bus::RAM_CONFIGURATIONS.fetch(machine.ram_configuration)
+            fields = FieldWriter.new.byte(names.sum { |name| BLOCK_BITS[name] })
+            fields.byte(machine_fields.int("bus.data", 0)).byte(machine_fields.int("bus.video_data", 0))
+            fields.byte(0)
+            ram = machine.ram
+            regions(names).each do |address, length|
+              fields.bytes(Array.new(length) { |offset| ram.peek(address + offset) })
+            end
+            fields.section(NAME, MAJOR, MINOR)
+          end
+
+          # The RAM into `ram`, the machine's 48K at power-on, and the data
+          # lines' bytes into BL-MACHINE's writer `out`.
+          def import(section, ram, out)
+            fields = FieldReader.new(section)
+            names = blocks(section) || []
+            fields.skip(1)
+            out.int("bus.data", fields.byte).int("bus.video_data", fields.byte)
+            fields.skip(1)
+            regions(names).each { |address, length| ram[address, length] = fields.bytes(length) }
+            ram
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    module Vice
+      module Vic20
+        # Restores a VIC-20 from a snapshot xvic wrote. The modules badline
+        # reads become the machine's own keyed modules (Keyed), which it
+        # loads as it loads its own snapshot. Whatever they don't set stays
+        # as the machine has it at power-on: the VIC-I's sound and picture,
+        # which it paints afresh, a cartridge, the datasette's tape, the
+        # disk device 8 serves and a true drive, which xvic's drive modules
+        # don't reach.
+        module Restore
+          # MAINCPU and VIC20MEM hold the machine itself, so a version badline
+          # doesn't read fails the restore. The others are left out and
+          # reported.
+          READ = [MainCPU::NAME, Mem::NAME, VICI::NAME, "VIA1", "VIA2"].freeze
+          REQUIRED = [MainCPU::NAME, Mem::NAME].freeze
+
+          module_function
+
+          # Applies the modules badline reads to `computer`, and returns a
+          # Report. The snapshot goes into a new machine first, so one that
+          # fails leaves `computer` as it was, and one of a machine built
+          # another way fails too.
+          def import(container, computer)
+            unless computer.family == :vic20
+              raise FormatError, "the snapshot is of a VIC-20, not a #{Image::FAMILIES.fetch(computer.family.to_s)}"
+            end
+
+            setup = Vic20.setup(container)
+            ours = Vic20Setup.new(ram: computer.ram_configuration, model: computer.model)
+            raise FormatError, "the snapshot is of a VIC-20 with #{setup}, not #{ours}" unless setup == ours
+
+            apply(container, setup.build)
+            computer.power_cycle!
+            report = apply(container, computer)
+            kept = computer.mounted? ? ["the disk mounted in device 8 stays mounted"] : []
+            Report.new(applied: report.applied, ignored: report.ignored + kept)
+          end
+
+          # Applies the modules badline reads to `computer`, a machine built
+          # as the snapshot's was, and returns the Report.
+          def apply(container, computer)
+            applied = []
+            ignored = []
+            READ.each do |name|
+              section = container[name]
+              next if section.nil?
+
+              if reads?(section)
+                applied << name
+              else
+                raise FormatError, "#{section}: badline doesn't read this version" if REQUIRED.include?(name)
+
+                ignored << "#{section}: badline doesn't read this version, left out"
+              end
+            end
+            REQUIRED.each do |name|
+              raise FormatError, "the snapshot has no #{name} module" unless applied.include?(name)
+            end
+            computer.load_modules(Keyed::Modules.new(modules(container, computer, applied)))
+            Report.new(applied:, ignored: ignored + left_out(container, applied))
+          end
+
+          def reads?(section)
+            case section.name
+            when MainCPU::NAME then MainCPU.reads?(section)
+            when Mem::NAME then Mem.reads?(section)
+            when VICI::NAME then VICI.reads?(section)
+            else PET::VIA.reads?(section)
+            end
+          end
+
+          # The machine's keyed modules: its own as they stand, with those
+          # the modules `applied` names stand for in their place.
+          def modules(container, computer, applied)
+            own = {}
+            computer.save_modules.each { |section| own[section.name] = section }
+            ram = Keyed::Reader.parse(own.fetch("BL-RAM")).bytes("ram", "".b).bytes
+            own["BL-MACHINE"] = Keyed.section("BL-MACHINE") do |out|
+              out.text("family", "vic20")
+              Vic20Setup.new(ram: computer.ram_configuration, model: computer.model).write_fields(out)
+              out.int("cycles", MainCPU.clock(container[MainCPU::NAME]))
+              out.bool("nmi_asserted", via_irq?(container, "VIA1", applied))
+              Mem.import(container[Mem::NAME], ram, out)
+            end
+            own["BL-RAM"] = Keyed.section("BL-RAM") { |out| out.bytes("ram", ram) }
+            own["BL-CPU"] = Keyed.section("BL-CPU") { |out| MainCPU.import(container[MainCPU::NAME], out) }
+            vic(container, computer, applied, own)
+            %w[VIA1 VIA2].each do |name|
+              next unless applied.include?(name)
+
+              own["BL-#{name}"] = Keyed.section("BL-#{name}") { |out| PET::VIA.import(container[name], out) }
+            end
+            own.values
+          end
+
+          def vic(container, computer, applied, own)
+            return unless applied.include?(VICI::NAME)
+
+            section = container[VICI::NAME]
+            own["BL-VICI"] = Keyed.section("BL-VICI") { |out| VICI.import(section, out, computer.vic.profile) }
+            own["BL-COLORRAM"] = Keyed.section("BL-COLORRAM") { |out| out.bytes("ram", VICI.colors(section)) }
+          end
+
+          # Whether the VIA pulls its interrupt line: a flag it has enabled.
+          def via_irq?(container, name, applied)
+            return false unless applied.include?(name)
+
+            bytes = FieldReader.new(container[name]).bytes(PET::VIA::SIZE)
+            bytes[0x12].anybits?(bytes[0x13] & 0x7f)
+          end
+
+          def left_out(container, applied)
+            container.sections.reject { |section| applied.include?(section.name) }
+                     .map { |section| "#{section}: badline doesn't read this module, left out" }
+          end
+        end
+      end
+    end
+  end
+end