badline 0.12.0 → 0.12.1

data/lib/badline/computer/true_drives.rb

@@ -2,23 +2,24 @@
 
 module Badline
   class Computer
-    # The true drives on the C64's serial bus: a Drive1541, and a Drive1581
-    # (Drive1581::Slot), each in a field of its own, and their state for a
-    # snapshot.
+    # The true drives on the machine's serial bus: a Drive1541, and a
+    # Drive1581 (Drive1581::Slot), each in a field of its own. Computer,
+    # Vic20 and C128 each include it.
     module TrueDrives
       include Drive1581::Slot
 
-      # Plugs in a Drive1541, which then runs alongside the C64 on its own
-      # clock and talks to it over the serial bus. The serial traps stop
+      # Plugs in a Drive1541, which then runs alongside the machine on its
+      # own clock and talks to it over the serial bus. The serial traps stop
       # answering the drive's device number, so the KERNAL's TALK, LISTEN and
       # byte transfers reach the drive. The LOAD and SAVE traps stay, and
       # still serve a mounted image.
       def attach_drive1541(drive)
         @iec_bus.detach(@drive1541) if @drive1541
-        drive.host_clock_hz = region.clock_hz
+        drive.host_clock_hz = timing.clock_hz
         @drive1541 = drive
-        drive.connect(iec_bus)
+        drive.connect(@iec_bus)
         @serial_trap&.device = serial_trap_device
+        drive1541_attached
       end
 
       # The true drive on the serial bus: the Drive1581 ahead of the
@@ -50,23 +51,11 @@ module Badline
         @drive1541&.device == device || drive1581_on_device8? ? nil : device
       end
 
-      # A true 1541 on the serial bus, then a 1581. The leading flag is the
-      # bus itself, which every machine now has.
-      def save_serial_bus(out)
-        out.boolean(true).boolean(!@drive1541.nil?)
-        if @drive1541
-          out.int(@drive1541.device)
-          @drive1541.save_state(out)
-        end
-        save_drive1581(out)
-      end
-
-      def load_serial_bus(input)
-        input.boolean?
-        load_drive1541(input)
-        load_drive1581(input)
-      end
+      # What the machine does as a 1541 goes on its bus. The VIC-20 waits
+      # for its DOS to boot before typing.
+      def drive1541_attached = nil
 
+      # A true 1541 on the serial bus, with its device number.
       def load_drive1541(input)
         return detach_drive1541 unless input.boolean?
 

data/lib/badline/computer.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "badline/computer/common"
 require "badline/computer/true_drives"
 require "badline/computer/attachments"
 require "badline/computer/kernal_traps"
@@ -9,16 +10,14 @@ module Badline
   class Computer
     include IntegerHelper
     include KeyboardBuffer
+    include Machine::Clocking
+    include Common
     include Attachments
     include KernalTraps
     include SavedState
 
     attr_reader :address_bus, :cpu, :cycles, :drive1541
 
-    # The path of the disk or directory device 8 serves through the traps
-    # (Attachments), or an empty one.
-    def mounted_path = @drive.nil? ? "" : @drive.path
-
     def family = :c64
 
     def region = address_bus.region
@@ -108,46 +107,17 @@ module Badline
       @cycles += 1
     end
 
-    # Runs `count` cycles, one #cycle! after another.
-    def run_cycles(count)
-      i = 0
-      while i < count
-        cycle!
-        i += 1
-      end
-    end
-
-    # Runs cycles until the block returns true or the cycle count passes
-    # `limit`, checking before each cycle.
-    def run_until(limit)
-      cycle! until yield || @cycles > limit
-    end
-
     # The cycle at which #on_init's handlers run, once the KERNAL has booted.
     def init_threshold
       INIT_THRESHOLD
     end
 
-    # The clock, the raster and the crop of the machine's region, a pixel
-    # to a window pixel.
-    def timing
-      region = address_bus.region
-      Timing.new(clock_hz: region.clock_hz, cycles_per_line: region.cycles_per_line,
-                 lines_per_frame: region.lines_per_frame, crop: region.crop, pixel_width: 1)
-    end
-
     # The chip whose #display a front end shows.
     def video = @vic
 
     # The chip a front end records the machine's sound from.
     def sound_source = @sid
 
-    def load_prg(data)
-      uint16(data[0], data[1]).tap do |load_addr|
-        ram.write(load_addr, data[2..])
-      end
-    end
-
     def attach_cartridge(cartridge)
       connect_cartridge(cartridge)
       power_cycle!
@@ -208,37 +178,12 @@ module Badline
     # The one-shot has pulsed already, so letting go does nothing.
     def release_restore; end
 
-    def capture_output
-      @capture_output ||= ChroutTrap.new(cpu:, bus: address_bus, layout: KernalTrap::C64_LAYOUT).tap do |trap|
-        cpu.install_trap(ChroutTrap::ADDRESS) { trap.call }
-      end
-    end
-
-    def inspect
-      "#<#{self.class.name} cycles=#{@cycles} cpu=(#{@cpu.inspect})>"
-    end
-
-    def on_init(&block)
-      if booting?
-        @init_handlers << block
-      else
-        block.call
-      end
-    end
-
     private
 
-    # The KERNAL the traps stand in for (Attachments#mount).
+    # The KERNAL the traps stand in for (KernalTraps#mount).
     def trap_layout = KernalTrap::C64_LAYOUT
 
-    # The NMI line is wired-OR between CIA 2, the cartridge and the RESTORE
-    # key, and the CPU takes an interrupt on its falling edge.
-    def drive_nmi
-      nmi = @cia2.interrupted? || @cartridge_nmi || @restore_pulse
-      @restore_pulse = false
-      @cpu.nmi = true if nmi && !@nmi_asserted
-      @nmi_asserted = nmi
-    end
+    def trap_bus = address_bus
 
     def plug_reu(size_kb)
       reu = REU.new(size_kb, bus: @address_bus, vic: @vic)
@@ -278,13 +223,5 @@ module Badline
       @freezing = false
       address_bus.cartridge.freeze!
     end
-
-    def booting?
-      @cycles < init_threshold
-    end
-
-    def handle_init
-      @init_handlers.each(&:call)
-    end
   end
 end

data/lib/badline/core.rb

@@ -15,6 +15,7 @@ require "badline/memory"
 require "badline/color_memory"
 require "badline/rom"
 require "badline/ram_expansion"
+require "badline/cpu_port"
 require "badline/address_bus"
 require "badline/instruction"
 require "badline/instruction_set"
@@ -23,7 +24,6 @@ require "badline/keyboard"
 require "badline/joystick"
 require "badline/control_ports"
 require "badline/input"
-require "badline/cycleable"
 require "badline/datasette"
 require "badline/time_of_day"
 require "badline/cia"
@@ -42,6 +42,7 @@ require "badline/drive1581"
 require "badline/drive1581/slot"
 require "badline/snapshot/state"
 require "badline/snapshot/setup"
+require "badline/machine"
 require "badline/computer"
 require "badline/vic20"
 require "badline/checkpoint"
@@ -50,4 +51,3 @@ require "badline/cartridge"
 require "badline/kernal_trap"
 require "badline/chrout_trap"
 require "badline/media"
-require "badline/machine"

data/lib/badline/cpu_port.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Badline
+  # The I/O port of the 6510 and the 8502 at $00 (direction) and $01
+  # (data). An input pin reads its pull-up, P4 reads the datasette's sense
+  # line, and a pin without a pull-up holds the charge last driven onto
+  # it. P5 drives the datasette motor through an inverter: low runs it.
+  #
+  # The 6510 has pull-ups on P0-P2 and P4 and leaves P3, P6 and P7
+  # floating. The 8502 adds a CAPS LOCK pin on P6, high while the key is
+  # up.
+  class CPUPort
+    TAPE_SENSE = 0b0001_0000
+
+    # The direction and output registers, and the charge on the floating
+    # pins.
+    attr_reader :ddr, :data, :floating
+
+    # The port as the banking logic reads it (PortStatus).
+    attr_reader :status
+
+    # Whether CAPS LOCK is down, holding its pin low.
+    attr_reader :caps_lock
+
+    # +pullups+ and +floating+ are the masks of the pins with a pull-up and
+    # of the floating ones, and +caps_lock+ the CAPS LOCK pin's, 0 where
+    # there is none.
+    def initialize(datasette, pullups:, floating:, caps_lock: 0)
+      @datasette = datasette
+      @pullups = pullups
+      @floating_mask = floating
+      @caps_lock_pin = caps_lock
+      @caps_lock = false
+      @ddr = 0x00
+      @data = 0x00
+      @floating = 0x00
+      @change_handler = nil
+      @status = PortStatus.new(%i[basic kernal io tape_out tape_switch tape_motor], value: input_value)
+    end
+
+    # Calls the block after every write to the port, for the bus to remap
+    # its banks.
+    def on_change(&handler)
+      @change_handler = handler
+    end
+
+    # What a read of $01 sees.
+    def value = @status.value
+
+    def write_ddr(value)
+      @ddr = value
+      update
+    end
+
+    def write_data(value)
+      @data = value
+      update
+    end
+
+    # The RES line clears the direction and output registers. The floating
+    # pins keep their charge.
+    def reset!
+      @ddr = 0x00
+      @data = 0x00
+      update
+    end
+
+    # Sets the registers and the charge, as a snapshot restores them, and
+    # drives the motor and calls the change handler as a write does.
+    def restore(ddr, data, floating)
+      load(ddr, data, floating)
+      update
+    end
+
+    # Sets the registers and the charge, as a snapshot loads them, without
+    # driving the motor or calling the change handler.
+    def load(ddr, data, floating)
+      @ddr = ddr
+      @data = data
+      @floating = floating
+      refresh
+    end
+
+    # Holds CAPS LOCK down, or lets it up.
+    def caps_lock=(down)
+      @caps_lock = down
+      refresh
+    end
+
+    # Reads the inputs again, after the datasette's sense line changes.
+    def refresh
+      @status.value = input_value
+    end
+
+    private
+
+    def update
+      driven = @ddr & @floating_mask
+      @floating = (@floating & ~driven) | (@data & driven)
+      refresh
+      @datasette.motor = !@status.tape_motor?
+      @change_handler&.call
+    end
+
+    def input_value
+      input = @pullups | (@floating & @floating_mask)
+      input |= @caps_lock_pin unless @caps_lock
+      input &= ~TAPE_SENSE if @datasette.sense_low?
+      (@data & @ddr) | (input & ~@ddr & 0xff)
+    end
+  end
+end

data/lib/badline/drive1541/disk.rb

@@ -35,20 +35,10 @@ module Badline
       # The half track entries a side of a .g71 holds.
       G71_SIDE_ENTRIES = 84
 
-      # GCR bytes around a track in each speed zone: 200 ms of rotation at
-      # 300 rpm, in bytes of 32, 30, 28 and 26 µs.
+      # GCR bytes around a track in each speed zone (Storage::D64Image.zone):
+      # 200 ms of rotation at 300 rpm, in bytes of 32, 30, 28 and 26 µs.
       TRACK_LENGTHS = [6250, 6666, 7142, 7692].freeze
 
-      # The speed zone each track is written in: 3 for the 21 sectors of
-      # tracks 1-17, 2 for 18-24, 1 for 25-30 and 0 from 31 on.
-      def self.zone(track)
-        if track <= 17 then 3
-        elsif track <= 24 then 2
-        elsif track <= 30 then 1
-        else 0
-        end
-      end
-
       # How far round the DOS's N: starts each track from the one before,
       # in each zone, in 1/10000 of a turn: it steps in and starts writing
       # the next track that long after it started the last.
@@ -69,10 +59,17 @@ module Badline
       # a .d71 formatted on both sides, and anything else as a .d64,
       # formatted. `read_only` opens the image write-protected.
       def self.open(path, read_only: false)
-        return from_g64(Storage::G64Image.new(path, read_only:)).opened(path, read_only) if State.g64?(path)
-        return from_d64(Storage::D71Image.new(path, read_only:)).opened(path, read_only) if State.d71?(path)
+        image = image_for(path, read_only)
+        (State.g64?(path) ? from_g64(image) : from_d64(image)).opened(path, read_only)
+      end
+
+      # The image at +path+, by its name: a .g64 or .g71, a .d71, and
+      # anything else a .d64.
+      def self.image_for(path, read_only)
+        return Storage::G64Image.new(path, read_only:) if State.g64?(path)
+        return Storage::D71Image.new(path, read_only:) if File.extname(path).casecmp?(".d71")
 
-        from_d64(Storage::D64Image.new(path, read_only:)).opened(path, read_only)
+        Storage::D64Image.new(path, read_only:)
       end
 
       # A disk from a G64 or G71 image, each half track as the image stores
@@ -141,7 +138,7 @@ module Badline
         angle = 0
         (1..image.track_count).each do |track|
           half_track = d64_half_track(image, track)
-          zone = zone((half_track % SIDE) / 2)
+          zone = Storage::D64Image.zone((half_track % SIDE) / 2)
           angle = half_track == SIDE + 2 ? 0 : (angle + SKEWS[zone]) % SKEW_TURN if track > 1
           bytes = format_track(image, track, id, zone)
           disk.write(half_track, Track.new(bytes.rotate(-(bytes.length * angle / SKEW_TURN)), zone))
@@ -149,7 +146,7 @@ module Badline
         disk
       end
 
-      def self.format_track(image, track, id, zone = zone(track))
+      def self.format_track(image, track, id, zone = Storage::D64Image.zone(track))
         sectors = image.sectors_in(track)
         length = TRACK_LENGTHS[zone]
         gap = (length - (sectors * SECTOR_LENGTH)) / sectors

data/lib/badline/drive1541/disk_state.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "badline/media/extensions"
+
 module Badline
   class Drive1541
     class Disk
@@ -12,22 +14,12 @@ module Badline
         # for a disk from Disk.open. Nil for a disk made another way.
         attr_reader :path, :read_only
 
-        # A .g64 or .g71 image by its name, a .d71 by its name, and anything
-        # else a .d64.
-        def self.g64?(path) = %w[.g64 .g71].include?(File.extname(path).downcase)
-
-        def self.d71?(path) = File.extname(path).casecmp?(".d71")
+        # Whether the image is a .g64 or .g71, by its name.
+        def self.g64?(path) = Media::Extensions.kind(path) == :gcr
 
-        # A disk for the image at the path, its tracks left for the state.
-        def self.reopen(path, read_only)
-          if g64?(path)
-            Disk.new(Storage::G64Image.new(path, read_only:)).opened(path, read_only)
-          elsif d71?(path)
-            Disk.new(Storage::D71Image.new(path, read_only:)).opened(path, read_only)
-          else
-            Disk.new(Storage::D64Image.new(path, read_only:)).opened(path, read_only)
-          end
-        end
+        # A disk for the image at the path (Disk.image_for), its tracks left
+        # for the state.
+        def self.reopen(path, read_only) = Disk.new(Disk.image_for(path, read_only)).opened(path, read_only)
 
         # The disk a state from save_state describes: +current+ when it was
         # opened from the same image the same way, and otherwise a disk for

data/lib/badline/drive1581/wd1772.rb

@@ -51,7 +51,7 @@ module Badline
       STEP_RATES = [12_000, 24_000, 4_000, 6_000].freeze
       SETTLE = 30_000
 
-      NEVER = 1 << 62
+      NEVER = 1 << 60
 
       # Status bits. Bits 1 and 2 report the index pulse and track 0 after
       # a type I command, and DRQ and lost data after the others; bit 5

data/lib/badline/frontend/boot.rb

@@ -33,7 +33,7 @@ module Badline
     def self.media_problem
       yield
       ""
-    rescue Unsupported, Media::TrueDrive::Error, Media::DiskList::Error, Media::NotDisk, Datasette::Missing,
+    rescue Machine::Unsupported, Media::TrueDrive::Error, Media::DiskList::Error, Media::NotDisk, Datasette::Missing,
            SystemCallError, Storage::SIDFile::FormatError, Storage::T64::FormatError, Storage::TAP::FormatError,
            Storage::CRTFile::FormatError, Storage::G64Image::FormatError, Cartridge::UnsupportedTypeError,
            Snapshot::FormatError => e
@@ -53,11 +53,10 @@ module Badline
       start(options, media, options.writable?)
     end
 
-    # A new machine built from the options, with `media`, if not nil,
-    # attached and started as the command line does, its disk writable if
-    # `writable`. The family and model give the machine, and a .sid tune
-    # or --sid the SID. The VIC-20 raises Unsupported for a .sid
-    # tune.
+    # A new machine built from the options (Machine.for_options), with
+    # `media`, if not nil, attached and started as the command line does,
+    # its disk writable if `writable`. The VIC-20 raises
+    # Machine::Unsupported for a .sid tune.
     def self.start(options, media, writable)
       computer = build(options, media)
       Media::TrueDrive.plug(computer) if options.true_drive?
@@ -68,60 +67,10 @@ module Badline
       computer
     end
 
+    # The machine the options name, built for `media`, which says the RAM
+    # expansion a VIC-20 gets for it.
     def self.build(options, media)
-      case options.family
-      when :vic20 then vic20(options, media)
-      when :c128 then c128(options, media)
-      else c64(options, media)
-      end
-    end
-
-    def self.c64(options, media)
-      sid_model = options.sid_model || Media.sid_model(media, otherwise: nil)
-      Machine.build(:c64, model: options.model, sid_model:, reu: options.reu)
-    end
-
-    # A C128 in C128 mode. With --c64, or media only C64 mode runs, a .sid
-    # tune or a program that loads at the C64's BASIC start, C= is held
-    # through the reset, so the C128 KERNAL starts C64 mode.
-    def self.c128(options, media)
-      sid_model = options.sid_model || Media.sid_model(media, otherwise: nil)
-      machine = C128.new(model: options.model, sid_model:, mode: :c128)
-      machine.hold_commodore_key if options.c64_mode? || c64_media?(media)
-      machine
-    end
-
-    def self.c64_media?(media)
-      return false if media.nil? || !File.file?(media)
-
-      extension = File.extname(media).downcase
-      return true if extension == ".sid"
-      return false unless %w[.prg .p00].include?(extension)
-
-      [Media::BASIC_START, Media::BASIC_START - 1].include?(Storage::P00.load_address(media))
+      Machine.for_options(options, media) { |line| puts line }
     end
-
-    # A VIC-20 with the RAM --ram names, or else the RAM `media` needs
-    # (Media::Vic20Media.ram_for), which it says. Raises Unsupported for
-    # media a VIC-20 doesn't take.
-    def self.vic20(options, media)
-      ram = options.ram
-      unless media.nil?
-        unsupported = Media::Vic20Media::UNSUPPORTED.include?(File.extname(media).downcase)
-        raise Unsupported, "doesn't go in a VIC-20" if unsupported
-
-        ram ||= vic20_ram(media)
-      end
-      Machine.build(:vic20, model: options.model, ram:)
-    end
-
-    def self.vic20_ram(media)
-      ram = Media::Vic20Media.ram_for(media)
-      puts "RAM expansion: #{ram}"
-      ram
-    end
-
-    # Media the machine the options name doesn't take.
-    class Unsupported < ArgumentError; end
   end
 end

data/lib/badline/kernal_trap/{file.rb → file_routine.rb}

@@ -2,7 +2,7 @@
 
 module Badline
   module KernalTrap
-    class File < Routine
+    class FileRoutine < Routine
       private
 
       def active?

data/lib/badline/kernal_trap/load.rb

@@ -12,7 +12,7 @@ module Badline
     # below $0334, into the zero page, the stack or the KERNAL vectors: the
     # ROM's byte loop then loads it through the serial traps, and a loader
     # that overwrites ISTOP takes over mid-load as it does on a real drive.
-    class Load < File
+    class Load < FileRoutine
       # ST bits at $90
       EOI = 0x40
       VERIFY_MISMATCH = 0x10

data/lib/badline/kernal_trap/save.rb

@@ -15,7 +15,7 @@ module Badline
     # write: the drive stops listening, so ST reads DEVICE NOT PRESENT,
     # and the ROM returns without an error. A "@" before the drive prefix
     # writes over a file of the same name.
-    class Save < File
+    class Save < FileRoutine
       SECONDARY = 0x61
 
       # ST bit at $90

data/lib/badline/kernal_trap.rb

@@ -4,7 +4,7 @@ require "badline/kernal_trap/layout"
 require "badline/kernal_trap/routine"
 require "badline/kernal_trap/channel"
 require "badline/kernal_trap/drive"
-require "badline/kernal_trap/file"
+require "badline/kernal_trap/file_routine"
 require "badline/kernal_trap/load"
 require "badline/kernal_trap/save"
 require "badline/kernal_trap/serial"

data/lib/badline/machine/clocking.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Badline
+  module Machine
+    # Running a machine from outside its own #cycle!, and the handlers that
+    # wait for its KERNAL to boot. Computer, Vic20 and C128 each include it
+    # and answer #cycle!, #cycles and #init_threshold, the cycle at which
+    # #on_init's handlers run, and keep the handlers in @init_handlers.
+    module Clocking
+      # Runs `count` cycles, one #cycle! after another.
+      def run_cycles(count)
+        i = 0
+        while i < count
+          cycle!
+          i += 1
+        end
+      end
+
+      # Runs cycles until the block returns true or the cycle count passes
+      # `limit`, checking before each cycle.
+      def run_until(limit)
+        cycle! until yield || @cycles > limit
+      end
+
+      # Runs the block once the KERNAL has booted (see init_threshold), or
+      # now if it has.
+      def on_init(&block)
+        if booting?
+          @init_handlers << block
+        else
+          block.call
+        end
+      end
+
+      def inspect
+        "#<#{self.class.name} cycles=#{@cycles} cpu=(#{@cpu.inspect})>"
+      end
+
+      private
+
+      def booting?
+        @cycles < init_threshold
+      end
+
+      def handle_init
+        @init_handlers.each(&:call)
+      end
+    end
+  end
+end