badline 0.16.1 → 0.17.0

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

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    module Vice
+      module CBM2
+        # Restores a CBM-II from a snapshot xcbm2 wrote. The modules badline
+        # reads become the machine's own keyed modules (Keyed), which it
+        # loads as it loads its own snapshot: the CIA and the SID are read
+        # into a machine of their own first, as the C64's are, and saved
+        # from there. Whatever they don't set stays as the machine has it
+        # at power-on, and the disk device 8 serves through the traps stays
+        # as it is.
+        module Restore
+          # MAINCPU and CBM2MEM hold the machine itself, so a version badline
+          # doesn't read fails the restore. The others are left out and
+          # reported.
+          READ = [MainCPU::NAME, CBM2Mem::NAME, CRTC::NAME, "CIA1", *TPI::NAMES, ACIA::NAME, SIDRegisters::NAME,
+                  SIDExtended::NAME].freeze
+          REQUIRED = [MainCPU::NAME, CBM2Mem::NAME].freeze
+          # TPI1's inputs: the mains on I0, the CIA on I2 and the ACIA on I4.
+          MAINS = 0x01
+          CIA = 0x04
+          ACIA_LINE = 0x10
+          # I1, the IEEE-488 bus's SRQ, and I3, the coprocessor's, which
+          # nothing pulls.
+          IDLE_LINES = 0x0a
+          # The modules read into a machine of their own first.
+          CHIPS = %w[BL-CIA BL-SID].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 == :cbm2
+              raise FormatError, "the snapshot is of a CBM-II, not a #{Image::FAMILIES.fetch(computer.family.to_s)}"
+            end
+
+            setup = CBM2.setup(container)
+            ours = CBM2Setup.of(computer)
+            raise FormatError, "the snapshot is of a #{setup}, not a #{ours}" unless setup == ours
+
+            apply(container, setup.build)
+            reapply(computer) { apply(container, computer) }
+          end
+
+          # Switches `computer` off and on and applies the snapshot with the
+          # block, then reports the disk the traps keep serving and a true
+          # drive taken off the bus.
+          def reapply(computer)
+            had_drive = computer.true_drive
+            computer.power_cycle!
+            report = yield
+            kept = computer.mounted? ? ["the disk mounted in device 8 stays mounted"] : []
+            if had_drive && !computer.true_drive.equal?(had_drive)
+              kept << "the #{had_drive.model_name} on device #{had_drive.device} is taken off the bus"
+            end
+            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)
+            raise FormatError, "the snapshot has no #{MainCPU::NAME} module" if container[MainCPU::NAME].nil?
+
+            applied = []
+            ignored = []
+            READ.each do |name|
+              section = container[name]
+              next if section.nil?
+
+              reason = refusal(section, container)
+              if reason.nil?
+                applied << name
+              else
+                raise FormatError, "#{section}: #{reason}" if REQUIRED.include?(name)
+
+                ignored << "#{section}: #{reason}, left out"
+              end
+            end
+            computer.load_modules(Keyed::Modules.new(modules(container, computer, applied, ignored)))
+            Report.new(applied:, ignored: ignored + left_out(container, applied))
+          end
+
+          # Why badline leaves the module out, or nil when it reads it.
+          def refusal(section, container)
+            return "badline doesn't read this version" unless reads?(section)
+
+            "another SID engine wrote it" if section.name == SIDExtended::NAME && !Vice::Restore.resid?(container)
+          end
+
+          def reads?(section)
+            case section.name
+            when MainCPU::NAME then PET::MainCPU.reads?(section)
+            when CBM2Mem::NAME then CBM2Mem.reads?(section)
+            when CRTC::NAME then CRTC.reads?(section)
+            when "CIA1" then CIAs.reads?(section)
+            when ACIA::NAME then ACIA.reads?(section)
+            when SIDRegisters::NAME then SIDRegisters.reads?(section)
+            when SIDExtended::NAME then SIDExtended.reads?(section)
+            else TPI.reads?(section)
+            end
+          end
+
+          # The machine's keyed modules: its own at power-on, with those the
+          # modules `applied` names stand for in their place.
+          def modules(container, computer, applied, ignored)
+            chips = chips(container, computer, applied)
+            own = {}
+            computer.save_modules.each { |section| own[section.name] = section }
+            drive(container, computer, applied, ignored, own)
+            chips.save_modules.each { |section| own[section.name] = section if CHIPS.include?(section.name) }
+            cycles = FieldReader.new(container[MainCPU::NAME]).qword
+            crtc = crtc(container, computer, applied, own)
+            high = machine(own, computer, cycles, crtc)
+            own["BL-RAM"] = Keyed.section("BL-RAM") do |out|
+              CBM2Mem.import(container[CBM2Mem::NAME], out, computer.model.ram_segments)
+            end
+            own["BL-CPU"] = Keyed.section("BL-CPU") { |out| PET::MainCPU.import(container[MainCPU::NAME], out) }
+            if applied.include?(ACIA::NAME)
+              own["BL-ACIA"] = Keyed.section("BL-ACIA") { |out| ACIA.import(container[ACIA::NAME], out, cycles) }
+            end
+            lines = IDLE_LINES | (high ? MAINS : 0) | (chips.cia.interrupted? ? 0 : CIA)
+            tpis(container, applied, own, acia_irq?(container, applied) ? lines : lines | ACIA_LINE)
+            own.values
+          end
+
+          # Puts the true drive's modules in `own` in place of badline's: the
+          # 2031, 8050 or 8250 the snapshot has, as xpet's are read
+          # (PET::Restore), with the disks badline's drive of that model has,
+          # or none.
+          def drive(container, computer, applied, ignored, own)
+            disks = PET::Restore::DISKS.filter_map { |name| own[name] }
+            own.delete_if { |name, _| name.match?(/\ABL-D\d+(-|\z)/) }
+            kept = PET::Restore.kept_disks(container, computer, disks)
+            PET::Restore.drive(container, applied, ignored, kept).each { |section| own[section.name] = section }
+          end
+
+          # A machine of its own with xcbm2's CIA and SID read into it.
+          def chips(container, computer, applied)
+            machine = CBM2Setup.of(computer).build
+            CIAs.import_into(container["CIA1"], machine.cia) if applied.include?("CIA1")
+            SIDRegisters.import(container[SIDRegisters::NAME], machine) if applied.include?(SIDRegisters::NAME)
+            SIDExtended.import(container[SIDExtended::NAME], machine) if applied.include?(SIDExtended::NAME)
+            machine
+          end
+
+          # Puts the CRTC's and the picture's modules in `own`, and returns
+          # the CRTC's fields.
+          def crtc(container, computer, applied, own)
+            return Keyed::Reader.parse(own.fetch("BL-CRTC")) unless applied.include?(CRTC::NAME)
+
+            section = CRTC.import(container[CRTC::NAME], computer)
+            fields = Keyed::Reader.parse(section)
+            own["BL-CRTC"] = section
+            own["BL-VIDEO"] = CRTC.video(container[CRTC::NAME], fields)
+            fields
+          end
+
+          # Puts BL-MACHINE in `own`, with the mains' next falling edge where
+          # xcbm2 ticks it for the CRTC's fields `crtc`, and returns whether
+          # the mains is high.
+          def machine(own, computer, cycles, crtc)
+            high = true
+            own["BL-MACHINE"] = Keyed.section("BL-MACHINE") do |out|
+              out.text("family", "cbm2")
+              CBM2Setup.of(computer).write_fields(out)
+              out.int("cycles", cycles)
+              high = Mains.write(out, Mains.next_tick(crtc), Badline::CBM2::CLOCK_HZ / (2 * computer.mains_hz))
+            end
+            high
+          end
+
+          # Puts both TPIs' modules in `own`, TPI1's with its interrupt
+          # inputs at `lines`, TPI2's all high.
+          def tpis(container, applied, own, lines)
+            TPI::NAMES.zip([lines, 0x1f]).each do |name, levels|
+              next unless applied.include?(name)
+
+              own["BL-#{name}"] = Keyed.section("BL-#{name}") { |out| TPI.import(container[name], out, levels) }
+            end
+          end
+
+          # Whether the ACIA pulls its IRQ line: its status has the
+          # interrupt, and DTR enables it.
+          def acia_irq?(container, applied)
+            return false unless applied.include?(ACIA::NAME)
+
+            fields = FieldReader.new(container[ACIA::NAME]).skip(2)
+            fields.byte.anybits?(ACIA::IRQ) && fields.byte.anybits?(0x01)
+          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

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    module Vice
+      module CBM2
+        # TPI1 and TPI2 1.0, the 6525s: PRA, PRB, PRC, DDRA, DDRB, DDRC, CR
+        # and the AIR, then the interrupts latched and not yet taken through
+        # the AIR, and CA in bit 7 and CB in bit 6 of the last byte. In mode
+        # 1 xcbm2 keeps the latches in PRC's low five bits and the mask in
+        # DDRC's.
+        #
+        # xcbm2 saves no priority stack: a TPI read from its snapshot has
+        # none in service, and one written for it loses the one it has. The
+        # levels on the interrupt inputs aren't saved either, so they are
+        # read as the machine drives them (CBM2::Restore).
+        #
+        # Written and read: the registers, the latches, the mask, the AIR,
+        # CA and CB.
+        module TPI
+          NAMES = %w[TPI1 TPI2].freeze
+          MAJOR = 1
+          MINOR = 0
+          LATCHES = 0x1f
+          CA = 0x80
+          CB = 0x40
+
+          module_function
+
+          def reads?(section) = section.major == MAJOR && section.minor == MINOR
+
+          # The module `name` from the TPI's BL-TPI fields in `input`.
+          def export(name, input)
+            pra, prb, prc = input.ints("ports", [0, 0, 0])
+            ddra, ddrb, ddrc = input.ints("directions", [0, 0, 0])
+            control = input.int("control", 0)
+            latches = input.int("latches", 0)
+            prc = (prc & ~LATCHES) | latches if control.anybits?(0x01)
+            lines = (input.bool("ca", false) ? CA : 0) | (input.bool("cb", false) ? CB : 0)
+            FieldWriter.new.bytes([pra, prb, prc, ddra, ddrb, ddrc, control, input.int("air", 0), latches, lines])
+                       .section(name, MAJOR, MINOR)
+          end
+
+          # The registers by their BL-TPI keys, in a keyed module's writer,
+          # with `lines` the levels on the interrupt inputs.
+          def import(section, out, lines)
+            pra, prb, prc, ddra, ddrb, ddrc, control, air, _taken, edges = FieldReader.new(section).bytes(10)
+            out.ints("ports", [pra, prb, prc]).ints("directions", [ddra, ddrb, ddrc]).int("control", control)
+            mode1 = control.anybits?(0x01)
+            out.int("latches", mode1 ? prc & LATCHES : 0)
+            out.int("air", mode1 ? air & LATCHES : 0).ints("stack", [])
+            out.bool("ca", edges.anybits?(CA)).bool("cb", edges.anybits?(CB)).int("lines", lines)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -28,13 +28,16 @@ module Badline
         module_function
 
         def export(computer)
-          [computer.cia1, computer.cia2].each_with_index.map do |cia, i|
-            fields = FieldWriter.new
-            registers(cia, fields)
-            time_of_day(cia.time_of_day, fields)
-            internals(cia, fields)
-            fields.section(NAMES[i], MAJOR, MINOR)
-          end
+          [computer.cia1, computer.cia2].each_with_index.map { |cia, i| section(cia, NAMES[i]) }
+        end
+
+        # One CIA's module, named `name`.
+        def section(cia, name)
+          fields = FieldWriter.new
+          registers(cia, fields)
+          time_of_day(cia.time_of_day, fields)
+          internals(cia, fields)
+          fields.section(name, MAJOR, MINOR)
         end
 
         def registers(cia, fields)
@@ -80,9 +83,10 @@ module Badline
         def reads?(section) = section.major == MAJOR && section.minor >= MINOR
 
         def import(section, computer)
-          cia = section.name == NAMES.first ? computer.cia1 : computer.cia2
-          Import.new(FieldReader.new(section)).apply(cia)
+          import_into(section, section.name == NAMES.first ? computer.cia1 : computer.cia2)
         end
+
+        def import_into(section, cia) = Import.new(FieldReader.new(section)).apply(cia)
       end
     end
   end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "badline/snapshot/vice/p500_vicii"
+
+module Badline
+  module Snapshot
+    module Vice
+      # xcbm5x0's modules for the P500, the CBM 510: the B series' CPU,
+      # CIA, TPIs, ACIA and SID modules (CBM2), CBM2MEM with segment 15's
+      # video matrix and colour RAM, xcbm5x0's own VIC-II (VICII) and
+      # C500DATA, the cycles to the mains' next tick as a dword, then 4
+      # bytes xcbm5x0 leaves 0. They go
+      # through the machine's keyed modules as the B series' do, and the
+      # VIC through badline's VIC as the C64's does.
+      module P500
+        # The modules xcbm5x0 resets the machine without, each as xcbm5x0
+        # leaves them with nothing attached.
+        BEFORE_VIC = [["FSDRIVE", 0, 0, Array.new(258, 0)]].freeze
+        AFTER_VIC = [["TAPEPORT", 1, 0, [0x01, 0x01]], ["JOYPORT0", 0, 0, [0x01]], ["JOYSTICK0", 1, 2, [0x00, 0x00]],
+                     ["JOYPORT1", 0, 0, [0x01]], ["JOYSTICK1", 1, 2, [0x00, 0x00]]].freeze
+        MAINS = "C500DATA"
+        # CBM2MEM's second byte, which names the P500.
+        P500_RAM = 0x40
+        MATRIX = 0x400
+        # How many cycles after C500DATA's count badline's mains falls, so
+        # that TPI1 latches it on xcbm5x0's cycle.
+        TICK_LEAD = 4
+
+        module_function
+
+        def export(machine, sections)
+          readers = {}
+          sections.each { |section| readers[section.name] = Keyed::Reader.parse(section) }
+          machine.sid.catch_up!
+          irqs = [machine.tpi1.irq?, machine.vic.interrupted?].count(true)
+          [PET::MainCPU.write(machine, irqs), memory(machine), fixed("CBM2CART", 0, 1, [0x00]),
+           CIAs.section(machine.cia, "CIA1"),
+           *CBM2::TPI::NAMES.map { |name| CBM2::TPI.export(name, CBM2.reader(readers, "BL-#{name}")) },
+           CBM2::ACIA.export(CBM2.reader(readers, "BL-ACIA"), machine.cycles),
+           SIDRegisters.export(machine), SIDExtended.export(machine), *CBM2.drives(machine, readers),
+           *BEFORE_VIC.map { |entry| fixed(*entry) },
+           VICII.export(machine), mains(CBM2.reader(readers, "BL-MACHINE")), *AFTER_VIC.map { |entry| fixed(*entry) }]
+        end
+
+        def fixed(name, major, minor, bytes) = FieldWriter.new.bytes(bytes).section(name, major, minor)
+
+        # CBM2MEM as xcbm5x0 writes it: 128K, the P500's byte, the model
+        # line, both segment registers, segment 15's RAM with the registers
+        # in its first two bytes, the video matrix, the colour RAM a nibble
+        # a byte, then segments 0 and 1.
+        def memory(machine)
+          bus = machine.bus
+          system = bus.ram.snapshot
+          system[0] = bus.execution_segment
+          system[1] = bus.indirect_segment
+          fields = FieldWriter.new.byte(1).byte(P500_RAM).byte(CBM2::CBM2Mem::M600_50HZ)
+          fields.byte(bus.execution_segment).byte(bus.indirect_segment).bytes(system).bytes(bus.screen.snapshot)
+          fields.bytes(Array.new(MATRIX) { |offset| machine.color_ram.nibble(0xd400 + offset) })
+          Badline::CBM2::P500::Model::RAM_SEGMENTS.each { |segment| fields.bytes(bus.segment_ram[segment].snapshot) }
+          fields.section(CBM2::CBM2Mem::NAME, CBM2::CBM2Mem::MAJOR, CBM2::CBM2Mem::MINOR)
+        end
+
+        # C500DATA: the cycles to the mains' next tick, TICK_LEAD less than
+        # to the falling edge BL-MACHINE's countdown and level put it at.
+        def mains(machine)
+          countdown = machine.int("mains_countdown", 1)
+          cycles = machine.bool("mains_high", true) ? countdown : countdown + half_period(machine)
+          FieldWriter.new.dword([cycles - TICK_LEAD, 0].max).zeros(4).section(MAINS, 0, 0)
+        end
+
+        def half_period(machine)
+          setup = CBM2Setup.read_fields(machine)
+          Badline::CBM2::P500::Model.named(setup.model).region.clock_hz / (2 * setup.mains_hz)
+        end
+
+        # The cycles to the mains' falling edge where xcbm5x0 ticks it.
+        def cycles_to_tick(section) = FieldReader.new(section).dword + TICK_LEAD
+
+        # How the machine xcbm5x0 saved was built: a 510, NTSC where
+        # xcbm5x0's picture has NTSC's lines, at its region's mains.
+        def setup(container)
+          memory = CBM2.memory(container)
+          unless CBM2::CBM2Mem.mapped(memory) == P500_RAM && CBM2::CBM2Mem.ram_kb(memory) == 128
+            raise FormatError, "#{memory}: a P500 built otherwise than badline's 510, with 128K of RAM"
+          end
+
+          vic = container[VICII::NAME]
+          ntsc = !vic.nil? && VICII.reads?(vic) && VICII.picture_lines(vic) == VICII::SIZES.fetch(263).last
+          model = ntsc ? "510ntsc" : "510"
+          CBM2Setup.new(model:, kernal: Badline::CBM2::P500::Model::KERNALS.keys.first,
+                        mains_hz: Badline::CBM2::P500::Model.named(model).region.mains_hz, refresh: false)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Badline
+  module Snapshot
+    module Vice
+      module P500
+        # Restores a P500 from a snapshot xcbm5x0 wrote, as CBM2::Restore
+        # restores a B series: the modules badline reads become the
+        # machine's keyed modules, the CIA, the SID and the VIC read into a
+        # machine of their own first. Whatever they don't set stays as the
+        # machine has it at power-on, and the disk device 8 serves through
+        # the traps stays as it is.
+        module Restore
+          READ = [MainCPU::NAME, CBM2::CBM2Mem::NAME, "CIA1", *CBM2::TPI::NAMES, CBM2::ACIA::NAME, SIDRegisters::NAME,
+                  SIDExtended::NAME, VICII::NAME, MAINS].freeze
+          REQUIRED = [MainCPU::NAME, CBM2::CBM2Mem::NAME].freeze
+          # The modules read into a machine of their own first.
+          CHIPS = %w[BL-CIA BL-SID BL-VIC BL-COLORRAM].freeze
+
+          module_function
+
+          def import(container, computer)
+            unless computer.is_a?(Badline::CBM2::P500)
+              raise FormatError, "the snapshot is of a P500, not a #{computer_name(computer)}"
+            end
+
+            setup = P500.setup(container)
+            ours = CBM2Setup.of(computer)
+            raise FormatError, "the snapshot is of a #{setup}, not a #{ours}" unless setup == ours
+
+            apply(container, setup.build)
+            CBM2::Restore.reapply(computer) { apply(container, computer) }
+          end
+
+          def computer_name(computer)
+            computer.family == :cbm2 ? "CBM-II's B series" : Image::FAMILIES.fetch(computer.family.to_s)
+          end
+
+          def apply(container, computer)
+            raise FormatError, "the snapshot has no #{MainCPU::NAME} module" if container[MainCPU::NAME].nil?
+
+            applied = []
+            ignored = []
+            READ.each do |name|
+              section = container[name]
+              next if section.nil?
+
+              reason = refusal(section, container)
+              if reason.nil?
+                applied << name
+              else
+                raise FormatError, "#{section}: #{reason}" if REQUIRED.include?(name)
+
+                ignored << "#{section}: #{reason}, left out"
+              end
+            end
+            computer.load_modules(Keyed::Modules.new(modules(container, computer, applied, ignored)))
+            Report.new(applied:, ignored: ignored + CBM2::Restore.left_out(container, applied))
+          end
+
+          def refusal(section, container)
+            case section.name
+            when VICII::NAME then VICII.reads?(section) ? nil : "badline doesn't read this version"
+            when MAINS then section.major.zero? && section.minor.zero? ? nil : "badline doesn't read this version"
+            else CBM2::Restore.refusal(section, container)
+            end
+          end
+
+          def modules(container, computer, applied, ignored)
+            chips = chips(container, computer, applied)
+            own = {}
+            computer.save_modules.each { |section| own[section.name] = section }
+            CBM2::Restore.drive(container, computer, applied, ignored, own)
+            chips.save_modules.each { |section| own[section.name] = section if CHIPS.include?(section.name) }
+            cycles = FieldReader.new(container[MainCPU::NAME]).qword
+            high = machine(own, container, computer, cycles, applied)
+            own["BL-RAM"] = Keyed.section("BL-RAM") { |out| memory(container[CBM2::CBM2Mem::NAME], out) }
+            own["BL-CPU"] = Keyed.section("BL-CPU") { |out| PET::MainCPU.import(container[MainCPU::NAME], out) }
+            if applied.include?(CBM2::ACIA::NAME)
+              own["BL-ACIA"] = Keyed.section("BL-ACIA") { |out| CBM2::ACIA.import(container[CBM2::ACIA::NAME], out, cycles) }
+            end
+            lines = CBM2::Restore::IDLE_LINES | (high ? CBM2::Restore::MAINS : 0)
+            lines |= CBM2::Restore::CIA unless chips.cia.interrupted?
+            lines |= CBM2::Restore::ACIA_LINE unless CBM2::Restore.acia_irq?(container, applied)
+            CBM2::Restore.tpis(container, applied, own, lines)
+            own.values
+          end
+
+          # A machine of its own with xcbm5x0's CIA, SID and VIC read into
+          # it.
+          def chips(container, computer, applied)
+            machine = CBM2::Restore.chips(container, computer, applied)
+            VICII.import(container[VICII::NAME], machine.vic, machine.color_ram) if applied.include?(VICII::NAME)
+            machine
+          end
+
+          # Puts BL-MACHINE in `own`, with the mains' next falling edge where
+          # C500DATA has xcbm5x0's tick, and returns whether the mains is
+          # high.
+          def machine(own, container, computer, cycles, applied)
+            half = computer.model.region.clock_hz / (2 * computer.mains_hz)
+            tick = applied.include?(MAINS) ? P500.cycles_to_tick(container[MAINS]) : half
+            high = true
+            own["BL-MACHINE"] = Keyed.section("BL-MACHINE") do |out|
+              out.text("family", "cbm2")
+              CBM2Setup.of(computer).write_fields(out)
+              out.int("cycles", cycles)
+              high = CBM2::Mains.write(out, [tick, 1].max, half)
+            end
+            high
+          end
+
+          # The RAM, segment 15's video matrix and the segment registers by
+          # their BL-RAM keys.
+          def memory(section, out)
+            fields = FieldReader.new(section).skip(3)
+            out.int("execution_segment", fields.byte & 0x0f).int("indirect_segment", fields.byte & 0x0f)
+            system = fields.string(CBM2::CBM2Mem::SYSTEM_RAM)
+            out.bytes("system", "\0\0".b + system.byteslice(2, CBM2::CBM2Mem::SYSTEM_RAM - 2))
+            out.bytes("screen", fields.string(MATRIX))
+            fields.skip(MATRIX)
+            Badline::CBM2::P500::Model::RAM_SEGMENTS.each do |segment|
+              out.bytes("segment#{segment}", fields.string(CBM2::CBM2Mem::SEGMENT))
+            end
+          end
+        end
+      end
+    end
+  end
+end