badline 0.10.1 → 0.11.1

data/lib/badline/media/true_drive.rb

@@ -2,51 +2,54 @@
 
 module Badline
   module Media
-    # Device 8 as a true 1541 instead of the KERNAL traps. Once a Drive1541
-    # is plugged in as device 8, disk media go into it rather than into the
-    # traps, so a LOAD runs the DOS and every byte crosses the serial bus.
-    # A .g64 holds the disk's raw GCR, which only a true drive reads, so it
-    # plugs one in when there's none yet. The 1541 reads only .d64 and .g64
-    # images, so the traps' other disk media, a .d71, .d81 or .t64 or a host
-    # directory, raise Error.
+    # Device 8 as a true drive instead of the KERNAL traps: a 1541, or on
+    # the C128 its 1571. Once a true drive is plugged in as device 8, disk
+    # media go into it rather than into the traps, so a LOAD runs the DOS
+    # and every byte crosses the serial bus. A .g64 holds the disk's raw
+    # GCR, which only a true drive reads, so it plugs one in when there's
+    # none yet. The 1541 reads only .d64 and .g64 images, and the 1571
+    # .d71 and .g71 as well, so the traps' other disk media, a .d81 or
+    # .t64 or a host directory, raise Error.
     module TrueDrive
       class Error < ArgumentError; end
 
       class << self
-        # Plugs a Drive1541 in as device 8, unless one is there already, and
-        # returns it.
+        # Plugs the machine's true drive in as device 8, unless one is there
+        # already, and returns it.
         def plug(computer)
-          drive(computer) || Drive1541.new.tap { |drive| computer.attach_drive1541(drive) }
+          drive(computer) || computer.plug_true_drive
         end
 
-        # The Drive1541 on device 8, or nil.
+        # The true drive on device 8, or nil.
         def drive(computer)
-          drive = computer.drive1541
+          drive = computer.true_drive
           drive if drive && drive.device == KernalTrap::Routine::DEVICE
         end
 
-        # Whether the path goes in a true drive: a .g64 always, and other
-        # disk media, which the traps would mount, when a true drive is
-        # device 8.
+        # Whether the path goes in a true drive: a .g64 or .g71 always, and
+        # other disk media, which the traps would mount, when a true drive
+        # is device 8.
         def takes?(computer, path)
-          return true if File.extname(path).casecmp?(".g64")
+          return true if %w[.g64 .g71].include?(File.extname(path).downcase)
 
           !drive(computer).nil? && (File.directory?(path) || MOUNT_TYPES.key?(File.extname(path).downcase))
         end
 
-        # Puts the .d64 or .g64 in the drive on device 8, plugging one in
-        # when there's none, and takes out what was mounted through the
-        # traps, so LOAD and SAVE reach the drive too. `read_only` puts it
-        # in write-protected.
+        # Puts the image in the drive on device 8, plugging one in when
+        # there's none, and takes out what was mounted through the traps,
+        # so LOAD and SAVE reach the drive too. `read_only` puts it in
+        # write-protected.
         def insert(computer, path, read_only: false)
-          unless %w[.d64 .g64].include?(File.extname(path).downcase)
-            raise Error, "#{path} is not a .d64 or .g64 image, which the 1541 reads"
+          name = drive(computer)&.model_name || (computer.family == :c128 ? "1571" : "1541")
+          types = name == "1571" ? %w[.d64 .g64 .d71 .g71] : %w[.d64 .g64]
+          unless types.include?(File.extname(path).downcase)
+            raise Error, "#{path} is not a #{types[0..-2].join(', ')} or #{types.last} image, which the #{name} reads"
           end
 
           disk = Drive1541::Disk.open(path, read_only:)
           computer.unmount
           plug(computer).insert(disk)
-          "Inserted #{path} in the 1541 as device 8"
+          "Inserted #{path} in the #{name} as device 8"
         end
       end
     end

data/lib/badline/media.rb

@@ -33,11 +33,11 @@ module Badline
       # autostart then loads through it.
       #
       # An .m3u or .vfl list of disks attaches the first disk it lists
-      # (DiskList). A machine other than the C64 takes its own media
-      # (Vic20Media).
+      # (DiskList). The VIC-20 takes its own media (Vic20Media), and the
+      # C128 in C64 mode a C64's.
       def attach(computer, path, autostart: true, subtune: nil, **)
         path = DiskList.disk(path)
-        return Vic20Media.attach(computer, path, autostart:, **) unless computer.is_a?(Computer)
+        return Vic20Media.attach(computer, path, autostart:, **) if computer.family == :vic20
 
         attach_c64(computer, path, autostart:, subtune:, **)
       end
@@ -160,13 +160,15 @@ module Badline
       def start_prg(computer, data, autostart:)
         load_addr = computer.load_prg(data)
         # Run only makes sense for programs at BASIC start, or a byte ahead
-        # of it, where BASIC keeps the zero before its first line.
-        return unless autostart && (load_addr == BASIC_START || load_addr == BASIC_START - 1)
+        # of it, where BASIC keeps the zero before its first line. BASIC 7.0
+        # starts at $1C01 and keeps the end of its text at $1210.
+        start, text_end = computer.family == :c128 && computer.mode == :c128 ? [0x1c01, 0x1210] : [BASIC_START, 0x2d]
+        return unless autostart && (load_addr == start || load_addr == start - 1)
 
         # The end of the program, where BASIC's variables start, and where
         # the KERNAL's LOAD leaves its end address.
         end_addr = load_addr + data.length - 2
-        [0x2d, 0xae].each { |pointer| computer.ram.write(pointer, [end_addr & 0xff, end_addr >> 8]) }
+        [text_end, 0xae].each { |pointer| computer.ram.write(pointer, [end_addr & 0xff, end_addr >> 8]) }
         computer.type_text("run\r")
       end
     end

data/lib/badline/options/event.rb

@@ -10,7 +10,7 @@ module Badline
       # left out.
       ACTIONS = {
         "key" => true, "type" => true, "insert" => true, "eject" => true, "screenshot" => true, "menu" => true,
-        "reset" => false, "freeze" => false, "resume" => false, "quit" => false
+        "display" => true, "reset" => false, "freeze" => false, "resume" => false, "quit" => false
       }.freeze
 
       # The frames a key or the freeze button is held for.
@@ -18,6 +18,9 @@ module Badline
 
       EJECTABLE = %w[disk tape cartridge].freeze
 
+      # The C128's screens display shows: the VIC-IIe's or the VDC's.
+      DISPLAYS = %w[vic vdc].freeze
+
       # What insert takes: disk images, tapes and cartridges, or an .m3u
       # or .vfl list of disks or a directory to mount as device 8.
       INSERTABLE = %w[.d64 .d71 .d81 .g64 .t64 .tap .crt].freeze
@@ -83,6 +86,7 @@ module Badline
         return true if action == "menu"
         return argument.empty? unless ACTIONS[action]
         return EJECTABLE.include?(argument) if action == "eject"
+        return DISPLAYS.include?(argument) if action == "display"
         return insertable?(argument) if action == "insert"
 
         !argument.empty?

data/lib/badline/options/family.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Badline
+  class Options
+    # The machine family: the subcommand that names it, or else the media,
+    # and the models of each.
+    module Family
+      # Where C128 BASIC starts, which a program for the C128 loads at.
+      C128_BASIC_START = 0x1c01
+
+      private
+
+      # Takes `sid`, `c64`, `vic20` or `c128` when given first.
+      def subcommand(args)
+        case args.first
+        when "sid" then @sid_command = true
+        when "c64" then @family = :c64
+        when "vic20" then @family = :vic20
+        when "c128" then @family = :c128
+        else return
+        end
+        @family_named = !@sid_command
+        args.shift
+      end
+
+      def family_models
+        case @family
+        when :vic20 then VIC20_MODELS
+        when :c128 then C128_MODELS
+        else MODELS
+        end
+      end
+
+      # Without a family named, a program that loads at C128_BASIC_START is
+      # the C128's.
+      def pick_family
+        return if @family_named || @sid_command || @media_path.nil?
+        return unless %w[.prg .p00].include?(File.extname(@media_path).downcase) && File.file?(@media_path)
+
+        @family = :c128 if load_address(@media_path) == C128_BASIC_START
+      end
+
+      # The load address of a .prg, or of the program a .p00 wraps after its
+      # 26-byte header.
+      def load_address(path)
+        offset = File.extname(path).casecmp?(".p00") ? 26 : 0
+        bytes = File.binread(path).bytes
+        bytes.size >= offset + 2 ? bytes[offset] | (bytes[offset + 1] << 8) : -1
+      end
+    end
+  end
+end

data/lib/badline/options/help.rb

@@ -39,6 +39,7 @@ module Badline
       <<~BANNER
         Usage: #{@program} [c64] [options] [media]
                #{@program} vic20 [options] [media]
+               #{@program} c128 [options] [media]
                #{@program} --headless [options] tune.sid
                #{@program} [options] tune.sid --audio-out FILE
                #{@program} sid [options] FILE|DIR...
@@ -46,6 +47,7 @@ module Badline
         Commands:
             c64                              Run a C64, the one --model names (the default)
             vic20                            Run a PAL VIC-20, with the RAM --ram names
+            c128                             Run a C128 in C128 mode, the one --model names
             sid                              Play .sid tunes and directories of them
 
         Media can be a .prg/.p00 program, a .d64/.d71/.d81 disk image, a
@@ -58,7 +60,8 @@ module Badline
         window also autosaves every two minutes of play, which only the
         pause menu loads. Device 8 answers through traps on the KERNAL's
         disk routines, unless --true-drive puts an emulated 1541 there,
-        which runs its own DOS and reads .d64 and .g64 images only. A .sid
+        which runs its own DOS and reads .d64 and .g64 images only, or on
+        the C128 the C128D's 1571, which reads .d71 and .g71 too. A .sid
         tune opens in the SID player, as `sid` plays it, unless an option
         of the emulator's window asks for the machine.
 
@@ -89,7 +92,9 @@ module Badline
         the frame as a .bmp, with the frame's number in place of %d. menu
         opens the pause menu, and menu=PAGE opens it on snapshots, drive,
         datasette, expansion, ports, sound or power. Its frames still count,
-        and resume closes it. reset, freeze and quit take no argument.
+        and resume closes it. display=vdc or display=vic shows the C128's
+        80 or 40 column screen, as F8 switches them. reset, freeze and quit
+        take no argument.
       BANNER
     end
 

data/lib/badline/options/table.rb

@@ -11,6 +11,9 @@ module Badline
     # emulated.
     VIC20_MODELS = %w[pal ntsc].freeze
 
+    # The C128's models, as C128::Model names them.
+    C128_MODELS = %w[c128 c128ntsc c128dcr c128dcrntsc].freeze
+
     # The VIC-20 RAM expansions --ram takes, in the order the help lists
     # them.
     RAM_NAMES = %w[unexpanded 3k 8k 16k 24k 32k all].freeze
@@ -32,13 +35,16 @@ module Badline
       Option.new("--sound", "Play the SID through the host's audio device (F10 mutes)",
                  section: "Window options", needs: :window),
       Option.new("--no-sound", "Don't play the SID", section: "Window options", needs: :window, build: :native),
-      Option.new("--true-drive", "Put a true 1541 on device 8 instead of the KERNAL traps",
+      Option.new("--true-drive", "Put a true 1541 on device 8 instead of the KERNAL traps, a 1571 on the C128",
                  section: "Window options", needs: :window),
       Option.new("--reu SIZE", "Plug in an REU of SIZE K: 128, 256, 512 (a 1750) or up to 16384",
                  section: "Window options", needs: :window),
-      Option.new("--model NAME", "C64 to run: #{MODELS.join(', ')} (default: #{MODELS.first}); VIC-20: pal",
+      Option.new("--model NAME", "C64 to run: #{MODELS.join(', ')} (default: #{MODELS.first}); VIC-20: pal; " \
+                                 "C128: #{C128_MODELS.join(', ')}",
                  section: "Window options", needs: :window),
       Option.new("--ntsc", "Run an NTSC C64, as --model ntsc does", section: "Window options", needs: :window),
+      Option.new("--c64", "Start the C128 in C64 mode, holding C= at power-on",
+                 section: "Window options", needs: :window),
       Option.new("--ram SIZE", "VIC-20 RAM expansion: #{RAM_NAMES.join(', ')} (default: unexpanded)",
                  section: "Window options", needs: :window),
       Option.new("--no-vsync", "Pace frames by the timer or the sound instead of the display",

data/lib/badline/options/validation.rb

@@ -64,6 +64,19 @@ module Badline
         elsif !@ram.nil?
           raise Error, "--ram needs vic20"
         end
+        if @family == :c128
+          validate_c128
+        elsif @c64_mode
+          raise Error, "--c64 needs c128"
+        end
+      end
+
+      # The C128 runs in the window, without an REU, and its NTSC models
+      # have names of their own.
+      def validate_c128
+        raise Error, "--ntsc needs the C64; the NTSC C128 is --model c128ntsc" if @models.include?("ntsc")
+        raise Error, "--reu needs the C64" unless @reu.nil?
+        raise Error, "the C128 needs the window" if headless?
       end
 
       # The VIC-20 is a PAL one, in the window, without the C64's SID and
@@ -87,7 +100,7 @@ module Badline
       # --model and --ntsc may be given more than once, but only for one
       # model.
       def validate_models
-        names = @family == :vic20 ? VIC20_MODELS : MODELS
+        names = family_models
         unknown = @models.find { |name| !names.include?(name) }
         raise Error, "invalid argument: --model #{unknown}" unless unknown.nil?
         raise Error, "conflicting models: #{@models.uniq.join(' and ')}" unless @models.uniq.size <= 1

data/lib/badline/options.rb

@@ -5,16 +5,17 @@ require "badline/options/event"
 require "badline/options/table"
 require "badline/options/help"
 require "badline/options/validation"
+require "badline/options/family"
 
 module Badline
   # The command line of both builds, badline-ruby and the native badline.
   # Either opens the window for any media, or with --headless or
   # --audio-out plays or renders a .sid tune without one. `sid`, given
   # first, plays .sid tunes and directories of them in the terminal.
-  # `c64` or `vic20`, given first, names the machine family, and without
-  # either the family is the C64. The
-  # native build adds --no-sound and --version, and badline-ruby adds
-  # --disable-jit.
+  # `c64`, `vic20` or `c128`, given first, names the machine family, and
+  # without one the family is the C64, or the C128 for a program that loads
+  # where C128 BASIC starts. The native build adds --no-sound and
+  # --version, and badline-ruby adds --disable-jit.
   #
   # TABLE lists the options, and both the parser and the help read it. It
   # parses by hand, inside the subset of Ruby Spinel compiles. Values come
@@ -23,6 +24,7 @@ module Badline
   # arguments before paying for the emulator.
   class Options
     include Validation
+    include Family
 
     class Error < StandardError; end
 
@@ -55,7 +57,8 @@ module Badline
     attr_reader :program, :media_path, :tune_paths, :subtune, :sid_model, :reu, :frames, :screenshot, :save_snapshot,
                 :audio_out, :seconds, :songlengths, :filter_chunk, :timeline
 
-    # The machine family to build (Badline::Machine), :c64 or :vic20.
+    # The machine family to build (Badline::Machine), :c64, :vic20 or
+    # :c128.
     attr_reader :family
 
     # The VIC-20's RAM expansion --ram names, a key of
@@ -72,6 +75,8 @@ module Badline
       @program = native ? "badline" : "badline-ruby"
       @media_path = nil
       @family = :c64
+      @family_named = false
+      @c64_mode = false
       @sid_command = false
       @tune_paths = []
       @subtune = nil
@@ -110,6 +115,7 @@ module Badline
       args = argv.dup
       subcommand(args)
       argument(args.shift, args) until args.empty?
+      pick_family
       play_lone_tune
       validate unless help? || version?
       self
@@ -167,9 +173,14 @@ module Badline
 
     def jit? = @jit
 
-    # The name of the model to build: a C64 Badline::Model names, or a
-    # VIC-20 of VIC20_MODELS. --ntsc is short for --model ntsc.
-    def model = @models.first || (@family == :vic20 ? VIC20_MODELS.first : MODELS.first)
+    # The name of the model to build: a C64 Badline::Model names, a VIC-20
+    # of VIC20_MODELS or a C128 of C128_MODELS. --ntsc is short for --model
+    # ntsc.
+    def model = @models.first || family_models.first
+
+    # Whether --c64 asks the C128 to start in C64 mode, holding C= at
+    # power-on.
+    def c64_mode? = @c64_mode
 
     def help? = @help
 
@@ -183,17 +194,6 @@ module Badline
       [:both, @native ? :native : :ruby].include?(option.build)
     end
 
-    # Takes `sid`, `c64` or `vic20` when given first.
-    def subcommand(args)
-      case args.first
-      when "sid" then @sid_command = true
-      when "c64" then @family = :c64
-      when "vic20" then @family = :vic20
-      else return
-      end
-      args.shift
-    end
-
     # A .sid on its own plays in the SID player, as `sid` would, unless an
     # option of the emulator's window asks for the machine.
     def play_lone_tune
@@ -273,6 +273,7 @@ module Badline
       when "--verbose" then @verbose = true
       when "--true-drive" then @true_drive = true
       when "--ntsc" then @models << "ntsc"
+      when "--c64" then @c64_mode = true
       when "--unpaced" then @paced = false
       when "--disable-jit" then @jit = false
       when "--help" then @help = true

data/lib/badline/roms/README

@@ -61,6 +61,15 @@ https://www.zimmers.net/anonftp/pub/cbm/firmware/drives/new/1541/
 (1541-c000.325302-01.bin and 1541-e000.901229-05.bin) and concatenated.
 SHA-1 ab16f56989b27d89babe5f89c5a8cb3da71a82f0.
 
+dos1571.rom
+-----------
+The 1571 disk drive's DOS 3.0, 310654-05, 32 KB for $8000-$FFFF.
+Drive1571 loads it.
+
+Downloaded from
+https://www.zimmers.net/anonftp/pub/cbm/firmware/drives/new/1571/1571-rom.310654-05.bin
+SHA-1 f1be619c106641a685f6609e4d43d6fc9eac1e70.
+
 Commodore VIC-20 ROMs
 =====================
 
@@ -87,3 +96,30 @@ vic20/character.rom
 -------------------
 The character generator ROM, 901460-03, for $8000-$8FFF.
 SHA-1 4fd85ab6647ee2ac7ba40f729323f2472d35b9b4.
+
+Commodore 128 ROMs
+==================
+
+Downloaded from
+https://www.zimmers.net/anonftp/pub/cbm/firmware/computers/c128/
+C128::Bus maps them in C128 mode. C64 mode runs basic.rom, kernal.rom
+and character.rom above.
+
+c128/basic.rom
+--------------
+BASIC 7.0, 318022-02 (basic.318022-02.bin), 32 KB: the low half for
+$4000-$7FFF followed by the high half for $8000-$BFFF.
+SHA-1 953dcdf5784a6b39ef84dd6fd968c7a03d8d6816.
+
+c128/kernal.rom
+---------------
+318020-05 (kernal.318020-05.bin), 16 KB: the screen editor for
+$C000-$CFFF, the Z80 BIOS for $D000-$DFFF and the KERNAL for
+$E000-$FFFF.
+SHA-1 ceb6e1a1bf7e08eb9cbc651afa29e26adccf38ab.
+
+c128/character.rom
+------------------
+The character generator ROM, 390059-01 (characters.390059-01.bin),
+8 KB: the C64's set, the same as character.rom, followed by the C128's.
+SHA-1 29ed066d513f2d5c09ff26d9166ba23c2afb2b3f.

data/lib/badline/snapshot/container.rb

@@ -28,6 +28,8 @@ module Badline
       MACHINE = "C64SC"
       # xvic names its machine VIC20.
       VIC20 = "VIC20"
+      # x128 names its machine C128.
+      C128 = "C128"
       GZIP_MAGIC = "\x1f\x8b".b
 
       # The VICE version block, when VICE wrote the file: four version

data/lib/badline/snapshot/image.rb

@@ -29,6 +29,7 @@ module Badline
       # warns it without a block.
       def load(&)
         return load_vic20(&) if vic20?
+        return load_c128(&) if c128?
 
         computer = badline? ? opening { Computer.restored(state) } : Vice.setup(@container).build
         tell(badline? ? state_report(computer) : Vice::Restore.apply(@container, computer), &)
@@ -38,6 +39,9 @@ module Badline
       # Whether the machine is a VIC-20, as the container names it.
       def vic20? = @container.machine == Container::VIC20
 
+      # Whether the machine is a C128, as the container names it.
+      def c128? = @container.machine == Container::C128
+
       # Restores `computer` from the snapshot, and returns the Report. A
       # snapshot that fails leaves the machine as it was.
       def restore(computer, &)
@@ -60,6 +64,16 @@ module Badline
         machine
       end
 
+      # A C128 restores from its BADLINE module alone. x128's own modules
+      # aren't read.
+      def load_c128(&)
+        raise FormatError, "badline reads only its own C128 snapshots, not x128's" unless badline?
+
+        machine = C128.restored(state)
+        tell(state_report(machine), &)
+        machine
+      end
+
       def tell(report)
         report.ignored.each { |line| block_given? ? yield(line) : warn("badline: #{line}") }
       end

data/lib/badline/snapshot.rb

@@ -27,11 +27,12 @@ module Badline
       path
     end
 
-    # A VIC-20's snapshot holds the BADLINE module alone, in a container
-    # named as xvic names its machine.
+    # 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
     end
@@ -59,4 +60,10 @@ module Badline
 
     def restore_snapshot(path, &) = Snapshot.restore(self, path, &)
   end
+
+  class C128
+    def save_snapshot(path) = Snapshot.save(self, path)
+
+    def restore_snapshot(path, &) = Snapshot.restore(self, path, &)
+  end
 end

data/lib/badline/storage/d64_image.rb

@@ -17,6 +17,9 @@ module Badline
 
       def storage_kind = D64
 
+      # The sides of a disk the image's tracks fill.
+      def sides = 1
+
       def sectors_in(track)
         case track
         when 1..17 then 21

data/lib/badline/storage/d71_image.rb

@@ -7,6 +7,15 @@ module Badline
 
       def storage_kind = D71
 
+      # Tracks 1-35 on the first side and 36-70 on the second.
+      def track_count = 70
+
+      def sides = 2
+
+      def sectors_in(track)
+        track > 35 ? super(track - 35) : super
+      end
+
       private
 
       def error_tables = ERROR_TABLES
@@ -22,10 +31,6 @@ module Badline
       def bam_bitmap(track) = track > 35 ? [53, 0, 3 * (track - 36)] : super
 
       def double_sided? = @bytes[sector_offset(18, 0) + 3].anybits?(0x80)
-
-      def sectors_in(track)
-        track > 35 ? super(track - 35) : super
-      end
     end
   end
 end

data/lib/badline/storage/g64_image.rb

@@ -5,7 +5,9 @@ module Badline
     # A .g64 image: a 1541 disk's flux as raw GCR, track by track, for the
     # true drive to read the way it reads a real disk, copy protection and
     # all. It has no file system of its own, so only the true drive
-    # (Drive1541::Disk.from_g64) can use it.
+    # (Drive1541::Disk.from_g64) can use it. A .g71 holds a 1571 disk the
+    # same way, with "GCR-1571" for its signature and 168 half tracks,
+    # the first side's 84 and then the second's.
     #
     # The header is the signature "GCR-1541", a version byte ($00), the
     # number of half tracks the tables cover (84, tracks 1 to 42.5) and
@@ -36,6 +38,7 @@ module Badline
       class FormatError < StandardError; end
 
       SIGNATURE = "GCR-1541"
+      SIGNATURE_1571 = "GCR-1571"
       HEADER_SIZE = 12
       HALF_TRACKS = 84
       MAX_TRACK_SIZE = 7928
@@ -124,7 +127,9 @@ module Badline
       private
 
       def parse
-        raise FormatError, "Missing G64 signature" unless @data.start_with?(SIGNATURE)
+        unless @data.start_with?(SIGNATURE) || @data.start_with?(SIGNATURE_1571)
+          raise FormatError, "Missing G64 signature"
+        end
         raise FormatError, "G64 header is cut short" if @data.bytesize < HEADER_SIZE
 
         version, @half_tracks, @max_track_size = @data.byteslice(8, 4).unpack("CCv")

data/lib/badline/time_of_day.rb

@@ -52,6 +52,15 @@ module Badline
       @latch = input.boolean? ? FIELDS.to_h { |field| [field, input.int] } : nil
     end
 
+    # Whether the clock is stopped with no alarm to raise, so its cycles
+    # move only the divider's phase.
+    def quiet? = @stopped && !@alarm_pending
+
+    # Runs +cycles+ quiet cycles at once.
+    def fast_forward(cycles)
+      @accumulator = (@accumulator + (cycles * @mains_hz)) % @cycles_per_pulse
+    end
+
     def cycle!
       @accumulator += @mains_hz
       pulse! if @accumulator >= @cycles_per_pulse

data/lib/badline/version.rb

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

data/lib/badline/via/fast_forward.rb

@@ -3,14 +3,14 @@
 module Badline
   class VIA
     # Running a VIA a stretch of cycles at once while nothing but its
-    # counters would change, for Drive1541::Idle.
+    # counters would change, for Drive::Idle.
     module FastForward
       # quiet_cycles for a VIA that will never set a flag of its own.
       QUIET = 1 << 40
 
       # How many cycles the VIA can run with nothing but its counters
       # changing: no flag set, no pulse on a control line and no bit
-      # shifted. See Drive1541::Idle.
+      # shifted. See Drive::Idle.
       def quiet_cycles
         return 0 if @sr_uses_t2 || @shift_register.clocking? || @ca.pulsing? || @cb.pulsing?
 
@@ -26,7 +26,7 @@ module Badline
         @t2.fast_forward(cycles)
       end
 
-      # The counters an orbit (see Drive1541::Idle) has to bring back: those
+      # The counters an orbit (see Drive::Idle) has to bring back: those
       # of the armed timers, and of the timers +touched+ names (bit 0 for
       # timer 1, bit 1 for timer 2). The others only count.
       def counter_state(touched)