badline 0.13.0 → 0.14.0

data/lib/badline/snapshot/keyed.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "zlib"
+require "badline/snapshot/container"
+
+module Badline
+  module Snapshot
+    # A snapshot module as keyed, typed records, which a later badline
+    # reads by name: one it doesn't know is skipped, and one that isn't
+    # there leaves the value a freshly built machine has.
+    #
+    # The payload is deflated. Inside, each record is the key's length and
+    # the key (ASCII, lower snake case with dots between sub-units), a
+    # one-byte type tag, then the value's length and the value. Lengths are
+    # BER-compressed (Ruby's pack "w"), and so are integers, each folded to
+    # a natural number (0, -1, 1, -2 ... as 0, 1, 2, 3 ...). The value's
+    # length lets a reader skip a tag it doesn't know.
+    #
+    # A module's header version is MAJOR.MINOR. The major number is this
+    # record encoding, and a reader refuses another one. Fields carry no
+    # version: a changed meaning gets a new key.
+    module Keyed
+      MAJOR = 1
+      MINOR = 0
+
+      INT = 0x01
+      BOOL = 0x02
+      BYTES = 0x03
+      INTS = 0x04
+      TEXT = 0x05
+
+      KEY = /\A[a-z0-9_]+(\.[a-z0-9_]+)*\z/
+
+      # The values an int record holds: what a 64-bit integer holds once
+      # zigzag doubles it, which a native build's integers can't exceed.
+      VALUES = (-(1 << 62))..((1 << 62) - 1)
+
+      module_function
+
+      def ber(number) = [number].pack("w")
+
+      # Folds an Integer in VALUES to a natural number, as a
+      # native build's 64-bit integers hold it.
+      def zigzag(value) = value.negative? ? ((-value - 1) << 1) | 1 : value << 1
+
+      def unzigzag(folded) = folded.odd? ? -(folded >> 1) - 1 : folded >> 1
+
+      # The module `name`, with the records the block writes to the Writer
+      # it yields.
+      def section(name)
+        out = Writer.new
+        yield out
+        out.section(name)
+      end
+    end
+  end
+end
+
+require "badline/snapshot/keyed/cursor"
+require "badline/snapshot/keyed/writer"
+require "badline/snapshot/keyed/report"
+require "badline/snapshot/keyed/reader"
+require "badline/snapshot/keyed/recorder"
+require "badline/snapshot/keyed/modules"

data/lib/badline/snapshot/machine_state.rb

@@ -2,83 +2,36 @@
 
 module Badline
   module Snapshot
-    # The BADLINE module: a State from C64#snapshot, which restores the
-    # machine exactly where it was saved. VICE skips a module it doesn't
-    # know.
+    # The BADLINE module badline 0.13 and earlier saved the machine in, a
+    # positional layout only the version that wrote it reads. All that is
+    # left of it is reading which version that was, for the refusal
+    # (Image#load).
     #
     # The payload is deflated. Inside, a little-endian 32-bit length leads
     # a run of BER-compressed integers (Ruby's pack "w"): the number of
-    # values and of strings, each string's length, then the values, each
-    # folded to a natural number (0, -1, 1, -2 ... as 0, 1, 2, 3 ...). The
-    # strings follow, one after another.
-    #
-    # A State only restores in the badline version that wrote it, since
-    # each chip writes its fields as it holds them.
+    # values and of strings, each string's length, then the values. The
+    # strings follow, one after another: the family's marker first, then
+    # the badline version.
     module MachineState
       NAME = "BADLINE"
-      MAJOR = 2
-      MINOR = 0
-
-      # The values a 64-bit integer holds once encode doubles them, which a
-      # native build's integers can't exceed.
-      VALUES = (-(1 << 62))..((1 << 62) - 1)
 
       module_function
 
-      def section(state)
-        Section.new(name: NAME, major: MAJOR, minor: MINOR, data: Zlib.deflate(encode(state)))
-      end
-
-      def state(section)
-        unless section.major == MAJOR
-          raise FormatError, "#{NAME} #{section.version} was written by another badline version, " \
-                             "and this one reads #{MAJOR}.#{MINOR}"
-        end
-
-        decode(Zlib.inflate(section.data))
-      rescue Zlib::Error => e
-        raise FormatError, "#{NAME} is damaged: #{e.message}"
-      end
-
-      def encode(state)
-        values = state.values
-        strings = state.strings
-        numbers = [values.length, strings.length]
-        strings.each { |string| numbers << string.bytesize }
-        values.each do |value|
-          raise RangeError, "#{value} is too large for a snapshot" unless VALUES.cover?(value)
-
-          numbers << (value.negative? ? (-2 * value) - 1 : 2 * value)
-        end
-        index = numbers.pack("w*")
-        [index.bytesize].pack("V") + index + strings.join
-      end
-
-      def decode(bytes)
-        raise FormatError, "#{NAME} ends early" if bytes.bytesize < 4
+      # The badline version that saved the module, or an empty string when
+      # it is too damaged to say.
+      def written_by(section)
+        bytes = Zlib.inflate(section.data)
+        return "" if bytes.bytesize < 4
 
         length = bytes.byteslice(0, 4).unpack1("V").to_i
         numbers = bytes.byteslice(4, length).to_s.unpack("w*").map(&:to_i)
-        value_count = numbers.fetch(0, 0)
         string_count = numbers.fetch(1, 0)
-        raise FormatError, "#{NAME} ends early" if numbers.length != 2 + string_count + value_count
-
-        State.new(values(numbers, 2 + string_count), strings(bytes, 4 + length, numbers.slice(2, string_count)))
-      end
-
-      def values(numbers, from)
-        Array.new(numbers.length - from) do |i|
-          folded = numbers[from + i]
-          folded.odd? ? -((folded + 1) / 2) : folded / 2
-        end
-      end
-
-      def strings(bytes, pos, lengths)
-        lengths.map do |length|
-          raise FormatError, "#{NAME} ends early" if pos + length > bytes.bytesize
+        return "" if string_count < 2 || numbers.length < 4
 
-          bytes.byteslice(pos, length).to_s.tap { pos += length }
-        end
+        pos = 4 + length + numbers[2]
+        bytes.byteslice(pos, numbers[3]).to_s
+      rescue Zlib::Error
+        ""
       end
     end
   end

data/lib/badline/snapshot/storage_setup.rb

@@ -2,7 +2,7 @@
 
 module Badline
   module Snapshot
-    # The storage device 8 serves through the traps, as a State holds it:
+    # The storage device 8 serves through the traps, as a snapshot holds it:
     # its kind, its path and, for an archive or a disk image, its bytes, so
     # it opens again without the host file.
     module StorageSetup
@@ -14,23 +14,6 @@ module Badline
 
       module_function
 
-      # The same directory by its path, an archive with the bytes it held,
-      # or a disk image with its path, whether it is write-protected, and
-      # its bytes with the error table after them.
-      def write(storage, out)
-        if storage.is_a?(Storage::HostDirectory)
-          out.int(HOST_DIRECTORY).string(File.expand_path(storage.path))
-        elsif storage.is_a?(Storage::T64)
-          out.int(T64_ARCHIVE).string(File.expand_path(storage.path)).blob(storage.bytes)
-        else
-          write_image(storage, out)
-        end
-      end
-
-      def write_image(image, out)
-        out.int(image_kind(image)).string(File.expand_path(image.path)).boolean(image.read_only?).blob(image.contents)
-      end
-
       def image_kind(image)
         return D71 if image.is_a?(Storage::D71Image)
         return D64 if image.is_a?(Storage::D64Image)
@@ -39,28 +22,40 @@ module Badline
         raise ArgumentError, "#{image.class} can't go in a snapshot"
       end
 
-      # Opens the storage `write` wrote: the same directory by its path, an
-      # archive with the bytes it held, or a disk image with the bytes it
-      # held, writes and all. A detached reader gets the image
-      # write-protected, and Storage::Unavailable for a directory.
-      def read(input)
-        kind = input.int
-        path = input.string
-        case kind
-        when HOST_DIRECTORY then input.detached? ? Storage::Unavailable.new : Storage::HostDirectory.new(path)
-        when T64_ARCHIVE then Storage::T64.new(path, bytes: input.blob)
-        else read_image(kind, path, input)
+      # The storage's kind by name, in a keyed snapshot module, under
+      # storage.*: its path, and for an archive or a disk image whether it
+      # is write-protected and its bytes.
+      def write_fields(storage, out)
+        out.text("storage.path", File.expand_path(storage.path))
+        if storage.is_a?(Storage::HostDirectory)
+          out.text("storage.kind", "directory")
+        elsif storage.is_a?(Storage::T64)
+          out.text("storage.kind", "t64").bytes("storage.bytes", storage.bytes)
+        else
+          out.text("storage.kind", KIND_NAMES.fetch(image_kind(storage))).bool("storage.read_only", storage.read_only?)
+          out.bytes("storage.bytes", storage.contents)
         end
       end
 
-      def read_image(kind, path, input)
-        read_only = input.boolean? || input.detached?
-        bytes = input.blob
+      KIND_NAMES = %w[directory d64 d71 d81 t64].freeze
+
+      # Opens the storage write_fields wrote: the same directory by its
+      # path, an archive with the bytes it held, or a disk image with the
+      # bytes it held, writes and all. A detached reader gets the image
+      # write-protected, and Storage::Unavailable for a directory.
+      def read_fields(input, detached: false)
+        kind = KIND_NAMES.index(input.choice("storage.kind", KIND_NAMES, "directory")).to_i
+        path = input.text("storage.path", "")
+        return (detached ? Storage::Unavailable.new : Storage::HostDirectory.new(path)) if kind == HOST_DIRECTORY
+
+        bytes = input.bytes("storage.bytes", "".b).bytes
+        return Storage::T64.new(path, bytes:) if kind == T64_ARCHIVE
+
+        read_only = input.bool("storage.read_only", false) || detached
         case kind
         when D64 then Storage::D64Image.new(path, read_only:, bytes:)
         when D71 then Storage::D71Image.new(path, read_only:, bytes:)
-        when D81 then Storage::D81Image.new(path, read_only:, bytes:)
-        else raise FormatError, "unknown storage #{kind} in the state"
+        else Storage::D81Image.new(path, read_only:, bytes:)
         end
       end
     end

data/lib/badline/snapshot/vic20_setup.rb

@@ -7,25 +7,16 @@ module Badline
     Vic20Setup = Data.define(:ram)
 
     class Vic20Setup
-      MARKER = "VIC20"
       RAM_CONFIGURATIONS = Vic20::Bus::RAM_CONFIGURATIONS.keys.freeze
 
-      # The setup a VIC-20's State starts with.
-      def self.from(state)
-        input = StateReader.new(state)
-        input.marker(MARKER)
-        input.check_stamp
-        read(input)
+      # The RAM expansion by name, in a keyed snapshot module.
+      def write_fields(out)
+        out.text("ram", ram.to_s)
       end
 
-      def self.read(input)
-        new(ram: RAM_CONFIGURATIONS.fetch(input.int))
-      rescue IndexError
-        raise FormatError, "the state names a VIC-20 RAM expansion badline doesn't know"
-      end
-
-      def write(out)
-        out.int(RAM_CONFIGURATIONS.index(ram))
+      def self.read_fields(input)
+        text = input.choice("ram", RAM_CONFIGURATIONS.map(&:to_s), "unexpanded")
+        new(ram: RAM_CONFIGURATIONS.find { |name| name.to_s == text } || :unexpanded)
       end
 
       # A machine built this way, at power-on.

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

@@ -9,8 +9,8 @@ module Badline
       # from $DF00, and the RAM.
       #
       # Written: the registers and the RAM. VICE saves between transfers,
-      # so badline's copy of the machine runs a transfer in flight to its
-      # end first (Vice.settled).
+      # so a save runs a transfer in flight to its end first
+      # (Machine::Settling).
       #
       # Read: the registers, as the values the counters run from and
       # start from, and the RAM. The status register's interrupt, end of

data/lib/badline/snapshot/vice.rb

@@ -22,43 +22,19 @@ module Badline
     # machine at power-on with nothing attached, and applies the modules it
     # has, in the order x64sc writes them.
     module Vice
-      # Cycles a copy of the machine may run to reach an instruction
-      # boundary: the longest instruction, stretched by the VIC's longest
-      # hold on the bus.
-      BOUNDARY_CYCLES = 100
-      # Cycles more it may run for an REU transfer in flight to end: a
-      # swap of 64K, two cycles a byte, stretched by the VIC's holds on
-      # the bus.
-      TRANSFER_CYCLES = 0x40000
-
-      # The modules a badline snapshot carries for VICE, in x64sc's order.
-      # They describe a copy of the machine restored from `state`, so saving
-      # leaves the machine itself alone. VICE saves between instructions,
-      # and resumes by fetching an opcode at the program counter, so when
-      # badline's CPU is inside an instruction, or an REU transfer holds
-      # the bus, the copy runs on to the end of both. The copy's SID
-      # catches up, so its registers and voices stand as of that cycle.
-      def self.export(state)
-        machine = settled(state)
+      # The modules a badline snapshot carries for VICE, in x64sc's order,
+      # describing `machine`, which Machine::Settling has brought between
+      # instructions with no REU transfer under way: VICE saves between
+      # instructions, and resumes by fetching an opcode at the program
+      # counter. Its SID has caught up, so the registers and voices stand
+      # as of that cycle.
+      def self.export(machine)
         sections = [MainCPU.export(machine), C64Mem.export(machine), Peripherals.cartridge_port(machine)]
         sections << REU1764.export(machine) if machine.reu
         sections + [*CIAs.export(machine), SIDRegisters.export(machine), SIDExtended.export(machine),
                     Peripherals.drives, VICII.export(machine), Peripherals.glue(machine), *Peripherals.rest]
       end
 
-      # The copy is detached from the host's files (Snapshot::StateReader),
-      # so it reads none and its traps write none.
-      def self.settled(state)
-        copy = C64.restored(state, detached: true)
-        (BOUNDARY_CYCLES + TRANSFER_CYCLES).times do
-          break if copy.cpu.boundary? && !copy.reu&.dma?
-
-          copy.cycle!
-        end
-        copy.sid.catch_up!
-        copy
-      end
-
       # How the machine the snapshot was saved from was built: the VIC
       # model and the region from the VIC-II's model, and an REU from
       # REU1764. VICE doesn't save the CIA model; the 8565 and 8562 go

data/lib/badline/snapshot.rb

@@ -1,23 +1,22 @@
 # frozen_string_literal: true
 
 require "zlib"
-require "badline/snapshot/state"
-require "badline/snapshot/setup"
 require "badline/snapshot/container"
+require "badline/snapshot/c64_setup"
 require "badline/snapshot/machine_state"
+require "badline/snapshot/keyed"
 require "badline/snapshot/vice"
 require "badline/snapshot/image"
 
 module Badline
   # Saves and restores the whole machine in VICE's .vsf snapshot format.
   #
-  # A snapshot badline writes carries VICE's modules for what both
-  # emulators model, and a BADLINE module holding the State
-  # C64#snapshot takes, with everything badline needs to carry on
-  # exactly where it stopped. VICE skips modules it doesn't know. Restoring
-  # a badline snapshot uses the BADLINE module alone; a snapshot from VICE
-  # restores through its modules, as far as they map, and reports the
-  # modules badline doesn't take.
+  # A snapshot badline writes holds the machine as BL-* modules, one per
+  # unit, each a list of keyed records (Snapshot::Keyed), which later
+  # badlines read: doc/snapshot-format.md lists them. VICE skips modules it
+  # doesn't know. An export for VICE puts VICE's own modules for the C64
+  # ahead of them. A snapshot from VICE restores through its modules, as
+  # far as they map, and reports the modules badline doesn't take.
   module Snapshot
     module_function
 
@@ -26,17 +25,21 @@ module Badline
       path
     end
 
-    # A VIC-20's or a C128's snapshot holds the BADLINE module alone, in a
-    # container named as xvic or x128 names its machine.
-    def dump(computer)
-      state = computer.snapshot
-      return Container.new([MachineState.section(state)], machine: Container::VIC20).to_s if computer.family == :vic20
-      return Container.new([MachineState.section(state)], machine: Container::C128).to_s if computer.family == :c128
-
-      Container.new(Vice.export(state) + [MachineState.section(state)]).to_s
+    # Saves the machine's snapshot with VICE's modules ahead of its own for
+    # a C64, so x64sc opens it too.
+    def export(computer, path)
+      File.binwrite(path, Image.exported(computer).to_s)
+      path
     end
 
-    def read(path) = Image.new(Container.parse(File.binread(path)))
+    # The machine's snapshot file. Saving first runs the machine on to the
+    # end of the instruction its CPU is in, and of an REU transfer under
+    # way (Machine::Settling), so a save advances it by a few cycles, and a
+    # second save straight after runs none. A VIC-20's or a C128's snapshot
+    # is in a container named as xvic or x128 names its machine.
+    def dump(computer) = Image.of(computer).to_s
+
+    def read(path) = Image.new(Container.parse(File.binread(path)), name: File.basename(path))
 
     # A new machine, built as the snapshot's was and restored from it.
     # Yields a line for each thing it leaves out.
@@ -47,12 +50,32 @@ module Badline
     # snapshot that fails leaves the machine as it was.
     def restore(computer, path, &) = read(path).restore(computer, &)
 
-    # A machine's snapshots as .vsf files. C64, Vic20 and C128 each
-    # include it.
+    # A machine's snapshots, as .vsf files and in memory. C64, Vic20 and
+    # C128 each include it.
     module Files
       def save_snapshot(path) = Snapshot.save(self, path)
 
+      # Saves the snapshot with VICE's modules too, for a C64, so x64sc
+      # opens it as well as badline.
+      def export_snapshot(path) = Snapshot.export(self, path)
+
       def restore_snapshot(path, &) = Snapshot.restore(self, path, &)
+
+      # The machine's snapshot in memory (Image.of), which settles it as a
+      # save does.
+      def snapshot = Image.of(self)
+
+      # Takes the machine back to an Image from #snapshot. The machine keeps
+      # its chips, its traps and its callbacks, and puts in the cartridge,
+      # drives and tape the image has, taking out any it hasn't. Raises
+      # Snapshot::FormatError for an image of a machine built another way.
+      # The image goes into a new machine first, so one that fails leaves
+      # this machine as it was. What it leaves out goes unsaid:
+      # Image#restore returns it in a Report.
+      def restore(image)
+        image.restore(self) { nil }
+        self
+      end
     end
   end
 

data/lib/badline/storage/crt_file.rb

@@ -7,6 +7,7 @@ module Badline
 
       SIGNATURE = "C64 CARTRIDGE   ".b
       VIC20_SIGNATURE = "VIC20 CARTRIDGE ".b
+      PLUS4_SIGNATURE = "PLUS4 CARTRIDGE ".b
       CHIP_SIGNATURE = "CHIP".b
       CHIP_HEADER_SIZE = 0x10
       RAM_CHIP = 1
@@ -35,7 +36,7 @@ module Badline
       end
 
       # `bytes` stands in for the file's contents. `machine` is the one the
-      # image has to be for, :c64 or :vic20, or nil for either.
+      # image has to be for, :c64, :vic20 or :plus4, or nil for any.
       def initialize(path = nil, bytes: nil, machine: :c64)
         parse(bytes || File.binread(path))
         return if machine.nil? || @machine == machine
@@ -58,6 +59,7 @@ module Badline
       def signed_machine(bytes)
         return :c64 if bytes.start_with?(SIGNATURE)
         return :vic20 if bytes.start_with?(VIC20_SIGNATURE)
+        return :plus4 if bytes.start_with?(PLUS4_SIGNATURE)
 
         raise FormatError, "Missing CRT signature"
       end

data/lib/badline/storage/g64_image.rb

@@ -66,15 +66,20 @@ module Badline
         [bytes.length].pack("v") + bytes.pack("C*").ljust(size, "\x00".b)
       end
 
-      attr_reader :half_tracks, :max_track_size
+      attr_reader :half_tracks, :max_track_size, :path
 
-      def initialize(path, read_only: false)
+      # `bytes` stands in for the host file's contents, as a snapshot
+      # restores the image as it was.
+      def initialize(path, read_only: false, bytes: nil)
         @path = path
         @read_only = read_only
-        @data = File.binread(path)
+        @data = bytes ? bytes.pack("C*") : File.binread(path)
         parse
       end
 
+      # The image as its file holds it.
+      def contents = @data.bytes
+
       # Whether the image was opened write-protected.
       def read_only? = @read_only
 

data/lib/badline/storage/tap.rb

@@ -5,11 +5,14 @@ module Badline
     # Raw datasette pulse stream. The header holds the signature, the
     # version at $0c, the platform at $0d (0 C64, 1 VIC-20, 2 C16) and the
     # data size at $10; the data runs from $14, every byte the time to the
-    # next falling edge on the tape read line, in units of 8 cycles.
+    # next falling edge on the tape read line, in units of 8 cycles. A
+    # version 2 tape, the C16's and the Plus/4's, times half waves instead,
+    # so it takes two bytes to the next falling edge.
     class TAP
       class FormatError < StandardError; end
 
       SIGNATURE = "C64-TAPE-RAW".bytes.freeze
+      C16_SIGNATURE = "C16-TAPE-RAW".bytes.freeze
       HEADER_SIZE = 0x14
       OVERFLOW = 0x100 * 8
 
@@ -28,10 +31,11 @@ module Badline
       def initialize(path, bytes: nil)
         @path = File.expand_path(path)
         @bytes = bytes || File.binread(path).bytes
-        raise FormatError, "Missing TAP signature" unless @bytes[0, SIGNATURE.length] == SIGNATURE
+        signature = @bytes[0, SIGNATURE.length]
+        raise FormatError, "Missing TAP signature" unless [SIGNATURE, C16_SIGNATURE].include?(signature)
 
         @version = @bytes[0x0c].to_i
-        raise FormatError, "Unsupported TAP version #{@version}" if @version > 1
+        raise FormatError, "Unsupported TAP version #{@version}" if @version > 2
 
         @platform = @bytes[0x0d].to_i
 
@@ -55,17 +59,16 @@ module Badline
       # Records a pulse `cycles` long at the position, in place of the rest
       # of the tape: a byte of units of 8 cycles, or a zero and the 24-bit
       # cycle count for a long one (a lone zero, an overflow, on a version 0
-      # tape).
+      # tape). A version 2 tape records it as two equal halves.
       def record_pulse(cycles)
-        units = (cycles + 4) / 8
-        encoded = if units.between?(1, 0xff) then [units]
-                  elsif version.zero? then [0]
-                  else
-                    count = [cycles, 0xffffff].min
-                    [0, count & 0xff, (count >> 8) & 0xff, count >> 16]
-                  end
         @bytes.slice!(@pos..)
-        @bytes.concat(encoded)
+        if version == 2
+          half = cycles / 2
+          @bytes.concat(encode(cycles - half))
+          @bytes.concat(encode(half))
+        else
+          @bytes.concat(encode(cycles))
+        end
         @pos = @end = @bytes.length
       end
 
@@ -77,20 +80,45 @@ module Badline
         File.binwrite(@path, @bytes.pack("C*"))
       end
 
+      # Whether each byte times a half wave, as on a version 2 tape.
+      def half_waves? = version == 2
+
       # Cycles until the next falling edge, or nil once the tape has run out.
+      # On a version 2 tape that is two half waves, or one left at the end.
       def next_pulse
         return if end?
+        return next_time unless half_waves?
+
+        first = next_time
+        end? ? first : first + next_time
+      end
+
+      # Cycles until the read line's next edge on a version 2 tape, or nil
+      # once the tape has run out.
+      def next_half_wave
+        next_time unless end?
+      end
 
+      private
+
+      def next_time
         byte = @bytes[@pos]
         @pos += 1
         return byte * 8 unless byte.zero?
 
-        # $00 is an overflow in version 0 and a 24-bit cycle count in
-        # version 1.
+        # $00 is an overflow in version 0 and a 24-bit cycle count from
+        # version 1 on.
         version.zero? ? OVERFLOW : long_pulse
       end
 
-      private
+      def encode(cycles)
+        units = (cycles + 4) / 8
+        return [units] if units.between?(1, 0xff)
+        return [0] if version.zero?
+
+        count = [cycles, 0xffffff].min
+        [0, count & 0xff, (count >> 8) & 0xff, count >> 16]
+      end
 
       # The stated size disagrees with the file in the wild, and a few dumps
       # leave it zeroed altogether.

data/lib/badline/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Badline
-  VERSION = "0.13.0"
+  VERSION = "0.14.0"
 end

data/lib/badline/vic20/attachments.rb

@@ -34,6 +34,9 @@ module Badline
       # The VIC-20's KERNAL, which the traps stand in for.
       def trap_layout = KernalTrap::VIC20_LAYOUT
 
+      # The VIC-20's KERNAL keeps its keyboard buffer where the C64's does.
+      def keyboard_buffer = Machine::KeyboardBuffer::C64_LAYOUT
+
       def trap_bus = @bus
 
       # A drive that powers on with the machine takes longer to boot than