badline 0.4.2 → 0.5.1

data/lib/badline/storage/host_directory.rb

@@ -8,6 +8,7 @@ module Badline
     # can't be read is left out, and a failed write reports false.
     class HostDirectory
       NO_SYNC = 21
+      ID = "DIR".bytes.freeze
 
       def initialize(path)
         @path = path
@@ -39,8 +40,27 @@ module Badline
         false
       end
 
+      # The directory as LOAD"$" lists it, under its host name: every file
+      # as a PRG, of the blocks it would take on a disk. A host directory
+      # counts no free blocks.
+      def directory
+        Listing.new(name: Listing.encode(File.basename(@path)), id: ID,
+                    entries: entries.map { |entry| listing_entry(entry) }, blocks_free: 0)
+      end
+
       private
 
+      def listing_entry(entry)
+        entry[:listed] || Listing.program(entry[:name], file_length(entry[:file]))
+      end
+
+      def file_length(file)
+        size = File.size(File.join(@path, file))
+        File.extname(file).casecmp?(".p00") ? size - P00::HEADER_SIZE : size
+      rescue SystemCallError
+        0
+      end
+
       def find(name)
         pattern = Storage.matcher(name)
         entries.find { |e| pattern.match?(e[:name]) }
@@ -72,7 +92,7 @@ module Badline
 
       def t64_entries(file)
         archive = T64.new(File.join(@path, file))
-        archive.names.map { |name| { name:, archive: } }
+        archive.names.zip(archive.listing_entries).map { |name, listed| { name:, archive:, listed: } }
       rescue T64::FormatError, SystemCallError
         nil
       end

data/lib/badline/storage/listing.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    # A directory as a 1541 sends it for LOAD"$",8: a BASIC program loaded
+    # at $0401. The header line is line 0, the disk's name and ID in
+    # reverse video, the name quoted. Each file is a line numbered by its
+    # length in blocks, with the name quoted and padded to 16 characters,
+    # then the type, marked `*` when the file was never closed and `<` when
+    # it is locked. The last line numbers the free blocks. Lines are
+    # padded with spaces to the drive's fixed widths, 27 characters for a
+    # file and 25 for the others, and shifted spaces print as plain ones.
+    #
+    # Names come as the bytes on the disk, padded with shifted spaces to 16.
+    # A file's name ends at its first shifted space, where the closing
+    # quote goes, and whatever follows it in the entry shows after the
+    # quote, as it does on a 1541.
+    class Listing
+      LOAD_ADDRESS = 0x0401
+      NAME_LENGTH = 16
+      NAME_PADDING = 0xa0
+      SPACE = 0x20
+      QUOTE = 0x22
+      REVERSE_ON = 0x12
+      FILE_WIDTH = 27
+      WIDTH = 25
+      TYPES = %w[DEL SEQ PRG USR REL CBM].freeze
+      PRG = 2
+
+      # One directory entry: its name's bytes, its type code (0 DEL to
+      # 4 REL, and the 1581's 5 CBM), its length in blocks, and whether it
+      # was closed and is locked.
+      Entry = Data.define(:name, :type, :blocks, :closed, :locked)
+
+      attr_reader :name, :id, :entries, :blocks_free
+
+      def initialize(name:, id:, entries:, blocks_free:)
+        @name = name
+        @id = id
+        @entries = entries
+        @blocks_free = blocks_free
+      end
+
+      # Name bytes padded with shifted spaces, from ASCII text in upper
+      # case, as a host file's name is listed.
+      def self.encode(text)
+        bytes = text.upcase.bytes.first(NAME_LENGTH)
+        bytes + Array.new(NAME_LENGTH - bytes.length, NAME_PADDING)
+      end
+
+      # A host file listed as a closed PRG, named in ASCII, of the blocks
+      # its bytes would take on a disk, 254 to a block.
+      def self.program(name, length)
+        Entry.new(name: encode(name), type: PRG, blocks: (length + 253) / 254, closed: true, locked: false)
+      end
+
+      # The file's bytes, load address first. A `$:NAME` or `$0:A*,B*`
+      # pattern lists only the files that match one of its names.
+      def bytes(request = "$")
+        lines = [[0, padded(header, WIDTH)]]
+        lines.concat(listed(request).map { |entry| [entry.blocks, file_line(entry)] })
+        lines << [@blocks_free, padded("BLOCKS FREE.".bytes, WIDTH)]
+        program(lines)
+      end
+
+      private
+
+      def listed(request)
+        patterns = request.sub(/\A\$\d*/, "")
+        return @entries unless patterns.start_with?(":")
+
+        matchers = patterns[1..].split(",").map { |pattern| Storage.matcher(pattern) }
+        @entries.select do |entry|
+          name = Storage.ascii(entry.name.take_while { |byte| byte != NAME_PADDING }).downcase
+          matchers.any? { |matcher| matcher.match?(name) }
+        end
+      end
+
+      def header
+        [REVERSE_ON, QUOTE, *spaced(@name.first(NAME_LENGTH)), QUOTE, SPACE, *spaced(@id.first(5))]
+      end
+
+      # A block count under 10 or 100 takes more spaces before the name, so
+      # the names line up.
+      def file_line(entry)
+        indent = 1 + (entry.blocks < 100 ? 1 : 0) + (entry.blocks < 10 ? 1 : 0)
+        line = Array.new(indent, SPACE) + quoted(entry.name) + [entry.closed ? SPACE : "*".ord]
+        line.concat(TYPES.fetch(entry.type, "???").bytes)
+        line << (entry.locked ? "<".ord : SPACE)
+        padded(line, FILE_WIDTH)
+      end
+
+      # The closing quote takes the first shifted space's place, or follows
+      # a name that fills all 16.
+      def quoted(name)
+        name = name.first(NAME_LENGTH)
+        name += Array.new(NAME_LENGTH - name.length, NAME_PADDING)
+        cut = name.index(NAME_PADDING)
+        name = cut ? [*name[0, cut], QUOTE, *name[(cut + 1)..], SPACE] : [*name, QUOTE]
+        [QUOTE, *spaced(name)]
+      end
+
+      def padded(line, width) = line + Array.new([width - line.length, 0].max, SPACE)
+
+      def spaced(bytes) = bytes.map { |byte| byte == NAME_PADDING ? SPACE : byte }
+
+      def program(lines)
+        address = LOAD_ADDRESS
+        bytes = [address & 0xff, address >> 8]
+        lines.each do |number, text|
+          address += text.length + 5
+          bytes.push(address & 0xff, address >> 8, number & 0xff, (number >> 8) & 0xff, *text, 0)
+        end
+        bytes.push(0, 0)
+      end
+    end
+  end
+end

data/lib/badline/storage/t64.rb

@@ -9,6 +9,8 @@ module Badline
       HEADER_SIZE = 0x40
       ENTRY_SIZE = 32
       NORMAL_FILE = 1
+      TAPE_NAME = 0x28
+      ID = "T64".bytes.freeze
 
       def initialize(path)
         @bytes = File.binread(path).bytes
@@ -29,6 +31,18 @@ module Badline
         entries.map { |e| e[:name] }
       end
 
+      # The archive as LOAD"$" lists it: the tape's name, and each file as
+      # a PRG of the blocks it would take on a disk, load address and all.
+      # An archive has no free blocks.
+      def directory
+        Listing.new(name: Listing.encode(decode_name(@bytes[TAPE_NAME, Listing::NAME_LENGTH].to_a)),
+                    id: ID, entries: listing_entries, blocks_free: 0)
+      end
+
+      def listing_entries
+        entries.map { |e| Listing.program(e[:name], e[:length] + 2) }
+      end
+
       private
 
       def entries

data/lib/badline/storage.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
+require "badline/storage/listing"
 require "badline/storage/p00"
 require "badline/storage/host_directory"
 require "badline/storage/disk_image"
 require "badline/storage/d64_image"
 require "badline/storage/d71_image"
 require "badline/storage/d81_image"
+require "badline/storage/g64_image"
 require "badline/storage/t64"
 require "badline/storage/tap"
 require "badline/storage/crt_file"

data/lib/badline/traps.rb

@@ -6,6 +6,10 @@ module Badline
       (@traps ||= {})[addr] = handler
     end
 
+    def remove_trap(addr)
+      @traps&.delete(addr)
+    end
+
     private
 
     def run_traps

data/lib/badline/version.rb

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

data/lib/badline/via/control_lines.rb

@@ -55,6 +55,9 @@ module Badline
 
       def active_c1_edge?(high) = high == @control.anybits?(0x01)
 
+      # Everything the lines hold, for comparing them at two points.
+      def state = [@control, @c1_high, @c2_high, @handshake_low, @pulse, @c2_output]
+
       # A new C1 level. An active edge sets the flag and ends a handshake.
       def c1=(high)
         return if high == @c1_high

data/lib/badline/via/fast_forward.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Badline
+  class VIA
+    # Running a VIA a stretch of cycles at once while nothing but its
+    # counters would change, for Drive1541::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.
+      def quiet_cycles
+        return 0 if @sr_uses_t2 || @shift_register.clocking? || @ca.pulsing? || @cb.pulsing?
+
+        [@t1.quiet_cycles, @t2.quiet_cycles].min
+      end
+
+      # Runs +cycles+ cycles at once, as many as quiet_cycles allows, which
+      # moves only the counters.
+      def fast_forward(cycles)
+        return if cycles.zero?
+
+        @t1.fast_forward(cycles)
+        @t2.fast_forward(cycles)
+      end
+
+      # The counters an orbit (see Drive1541::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)
+        [(@t1.count_state if @t1.armed? || touched.anybits?(1)),
+         (@t2.count_state if @t2.armed? || touched.anybits?(2))]
+      end
+
+      # Runs +cycles+ cycles of whole orbits at once: the counters
+      # counter_state leaves out move on, and the rest come back round.
+      def skip_orbits(cycles, touched)
+        @t1.fast_forward(cycles) unless @t1.armed? || touched.anybits?(1)
+        @t2.fast_forward(cycles) unless @t2.armed? || touched.anybits?(2)
+      end
+
+      # Everything the VIA holds but its counters, for comparing it at two
+      # points. Timer 1's PB7 level counts only while ACR bit 7 puts it on
+      # the pin: nothing reads it otherwise.
+      def idle_state
+        [@ora, @orb, @ddra, @ddrb, @latch_a, @latch_b, @acr, @pcr, @pb6_high, @ifr.flags, @ifr.enable,
+         @acr.anybits?(0x80) && @t1.pb7, *@t1.state, *@t2.state, *@ca.state, *@cb.state, *@shift_register.state]
+      end
+    end
+  end
+end

data/lib/badline/via/shift_register.rb

@@ -35,8 +35,6 @@ module Badline
       OUT_PHI2 = 6
       OUT_EXTERNAL = 7
 
-      BITS = 8
-
       attr_reader :mode, :data
       attr_accessor :cb2_input
 
@@ -62,9 +60,16 @@ module Badline
       # Every read or write of the data register (re)starts the count of
       # eight bits.
       def access!
-        @bits = BITS
+        @bits = 8
       end
 
+      # Whether the register is counting bits off its own clock, which
+      # changes it from cycle to cycle.
+      def clocking? = @bits.nonzero? && internal_clock?
+
+      # Everything the register holds, for comparing it at two points.
+      def state = [@mode, @data, @bits, @clock, @cb2, @cb2_input]
+
       # The CB1 level the register drives, or nil when CB1 is an input.
       def cb1_output
         internal_clock? ? @clock : nil

data/lib/badline/via/timer1.rb

@@ -66,6 +66,42 @@ module Badline
         @counter == 0xffff && timeout(free_run)
       end
 
+      # How many cycles the timer can run without setting its flag: until
+      # an armed timer's timeout, and forever for an unarmed one, whose
+      # timeouts only reload the counter. None while an armed timer loads
+      # or reloads.
+      def quiet_cycles
+        return FastForward::QUIET unless @armed
+        return 0 if @hold || @reload
+
+        @counter
+      end
+
+      # Runs +cycles+ cycles at once, as many as quiet_cycles allows. An
+      # unarmed timer goes round its period of latch + 2 cycles: the
+      # timeout at $FFFF, the reload, and latch down to 0.
+      def fast_forward(cycles)
+        if @hold || @reload
+          cycle!(false)
+          cycles -= 1
+        end
+        return @counter -= cycles if cycles <= @counter
+
+        phase = (cycles - @counter - 1) % (@latch + 2)
+        @reload = phase.zero?
+        @counter = @reload ? 0xffff : @latch - phase + 1
+      end
+
+      # What the counter and PB7 don't hold, for comparing the timer at two
+      # points.
+      def state = [@latch, @armed]
+
+      # Whether a timeout sets the flag.
+      def armed? = @armed
+
+      # The count, for comparing the timer at two points where it matters.
+      def count_state = [@counter, @hold, @reload]
+
       private
 
       # The counter reloads either way. Armed, PB7 inverts and the flag

data/lib/badline/via/timer2.rb

@@ -63,6 +63,37 @@ module Badline
       # A falling edge on PB6. Returns true when it sets the flag.
       def pulse! = @counting_pulses && decrement
 
+      # How many cycles the timer can run without setting its flag, taken
+      # without the shift register clocking off it: until an armed timer
+      # underflows, and forever for one counting pulses or unarmed, which
+      # only rolls on. None while a load or a switch of mode is under way.
+      def quiet_cycles
+        return 0 if @hold || @counting_pulses != @count_pulses
+        return FastForward::QUIET if @counting_pulses || !@armed
+
+        @counter
+      end
+
+      # Runs +cycles+ cycles at once, as many as quiet_cycles allows. The
+      # low byte's underflow is set when the last cycle took it from $00.
+      def fast_forward(cycles)
+        @low_underflowed = false
+        return if @counting_pulses
+
+        @counter = (@counter - cycles) & 0xffff
+        @low_underflowed = @counter.allbits?(0xff)
+      end
+
+      # What the counter and the low byte's underflow don't hold, for
+      # comparing the timer at two points.
+      def state = [@latch_low, @armed, @hold, @low_reload, @count_pulses, @counting_pulses]
+
+      # Whether the next underflow sets the flag.
+      def armed? = @armed
+
+      # The count, for comparing the timer at two points where it matters.
+      def count_state = [@counter, @low_underflowed]
+
       private
 
       # A cycle while counting pulses, or held after a load or a low byte

data/lib/badline/via.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "badline/via/control_lines"
+require "badline/via/fast_forward"
 require "badline/via/interrupt_register"
 require "badline/via/shift_register"
 require "badline/via/timer1"
@@ -16,6 +17,7 @@ module Badline
   # feed the counter.
   class VIA
     include Addressable
+    include FastForward
 
     attr_reader :start, :peripheral, :shift_register, :acr, :pcr
 

data/lib/badline/vic/display_state.rb

@@ -12,10 +12,6 @@ module Badline
       LAST_LINE  = 0xf7 # 247
       COLUMNS_PER_ROW = 40
 
-      # The last column of a rasterline already compares against the line
-      # about to start, the same wrap the raster IRQ latch uses.
-      WRAP_COLUMN = 62
-
       # AEC follows BA three cycles later; the c-accesses before it read
       # the bus the CPU still drives.
       BA_DELAY = 3
@@ -32,12 +28,16 @@ module Badline
       LOAD_COLUMN = 12
       RC_COLUMN = 56
 
-      GRAPHICS_COLUMNS = Array.new(63) { |column| column.between?(GRAPHICS_FIRST, GRAPHICS_LAST) }.freeze
+      GRAPHICS_COLUMNS = Array.new(65) { |column| column.between?(GRAPHICS_FIRST, GRAPHICS_LAST) }.freeze
 
       attr_reader :vc_base, :vc, :vmli, :rc
 
-      def initialize(registers)
+      # The wrap column is the last column of a rasterline, 62 on the 6569,
+      # which already compares against the line about to start, the same
+      # wrap the raster IRQ latch uses.
+      def initialize(registers, wrap_column = 62)
         @registers = registers
+        @wrap_column = wrap_column
         @vc_base = 0
         @vc = 0
         @vmli = 0
@@ -77,7 +77,7 @@ module Badline
 
       # Returns true when this compare opened display state.
       def cycle(rasterline, column)
-        match = column == WRAP_COLUMN ? wrap_match(rasterline + 1) : line_match
+        match = column == @wrap_column ? wrap_match(rasterline + 1) : line_match
         @matched = match
         opened = false
         if match

data/lib/badline/vic/sprite/internal_bus.rb

@@ -10,12 +10,15 @@ module Badline
       # the CPU reads or writes a VIC register in that cycle, and the middle
       # one is the idle fetch at $3fff (sbsprf24's readme).
       class InternalBus
-        # The columns of a raster line.
-        attr_reader :columns
+        # The columns of a raster line, and where the region puts the
+        # sprites in it.
+        attr_reader :columns, :timing
 
-        def initialize(bank, columns)
+        def initialize(bank, timing)
           @bank = bank
-          @columns = columns
+          @timing = timing
+          @columns = timing.columns
+          @sprite_cycle = timing.sprite_cycle
           @lines = 0
           @ghost = 0xff
           @value = Array.new(columns, 0xff)
@@ -37,10 +40,11 @@ module Badline
           @line[column] = column.zero? ? @lines + 1 : @lines
         end
 
-        # The row sprite `index` (3-7) fetched this line, in Bauer cycles
-        # 2n-5 and 2n-4.
+        # The row sprite `index` (3-7) fetched this line, in the phi2 halves
+        # of the two cycles from its p-access: Bauer cycles 2n-5 and 2n-4 on
+        # the 6569.
         def row(index)
-          column = (2 * index) - 6
+          column = (@sprite_cycle + (2 * index) - 1) % @columns
           (phi2(column) << 16) | (@ghost << 8) | phi2(column + 1)
         end
 

data/lib/badline/vic/sprite/shifter.rb

@@ -6,18 +6,13 @@ module Badline
       # The X comparator and the 24-bit shift register behind it: where a
       # line fires the sprite, and the pixels each firing shifts out.
       module Shifter
-        EMPTY = [].freeze
-
         private
 
         # The first pixel of every comparator match along the line. Writes to
         # $d000/$d010 move the compare value mid-line, so a sprite can miss
         # its match entirely and pick up a later one, a second one, or none.
         def comparator_hits(log)
-          unless log
-            match = compare_x(@registers)
-            return match ? [(match + 1) % @width] : EMPTY
-          end
+          return compare_x(@registers) unless log
 
           hits = []
           log.rewind
@@ -25,8 +20,10 @@ module Badline
           from = 0
           while from < @width
             upto = [log.next_x, @width].min
-            match = compare_x(log)
-            hits << ((match + 1) % @width) if match && match >= from && match < upto
+            compare_x(log).each do |start|
+              match = (start - 1) % @width
+              hits << start if match >= from && match < upto
+            end
             break if upto >= @width
 
             from = upto
@@ -35,15 +32,13 @@ module Badline
           hits
         end
 
-        # The VIC's X counter only runs to 503, so the eight coordinates above
-        # it never match and the sprite stays dark — the gap the spritegap
-        # tests find at $1f8.
+        # The pixels the sprite starts at, one past each comparator match.
+        # The 6569's X counter only runs to 503, so the eight coordinates
+        # above it never match and the sprite stays dark — the gap the
+        # spritegap tests find at $1f8.
         def compare_x(view)
           msb = view[0x10].anybits?(@bit) ? 0x100 : 0
-          xpos = msb | view[index * 2]
-          return if xpos >= @width
-
-          (xpos + COMPARE_OFFSET) % @width
+          @timing.x_pixels[msb | view[index * 2]]
         end
 
         # Pixels from the X match to the next reload.

data/lib/badline/vic/sprite/timing.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Badline
+  class VIC < Cycleable
+    class Sprite
+      # = Timing
+      #
+      # Where a region puts the sprites in the line: the cycles of their
+      # fetches and of the display compare, the pixels those land on, and
+      # the raster pixels the X counter reads each coordinate at. Where the
+      # fetches or the compare run a cycle later than on the 6569, what
+      # hangs off them moves 8 pixels with them.
+      class Timing
+        # The X counter's value where it holds on a raster of more than 512
+        # pixels, and the four values it repeats from there.
+        HOLD_AT = 0x188
+        HOLD_BASE = 0x184
+
+        attr_reader :columns, :sprite_cycle, :display_off_x, :x_pixels
+
+        def initialize(region)
+          @columns = region.cycles_per_line
+          @sprite_cycle = region.sprite_cycle
+          @shift = region.sprite_cycle - Region::PAL.sprite_cycle
+          @display_off_x = DISPLAY_OFF_X + (8 * (region.sprite_display_cycle - Region::PAL.sprite_display_cycle))
+          @x_pixels = Timing.x_pixels(@columns * 8, region.x_hold)
+        end
+
+        # The column BA falls in for a sprite's own fetch: 55 for sprite 0 on
+        # the 6569, and two later for each sprite after it.
+        def ba_column(index) = 55 + @shift + (2 * index)
+
+        # The raster pixel of a sprite's reload, counted from the start of
+        # the line it is fetched on, so past the end of it for sprites 3-7
+        # on the 6569.
+        def reload_x(index) = RELOAD_X + (8 * @shift) + (RELOAD_STEP * index)
+
+        # The X counter at a raster pixel: X_OFFSET behind it, wrapping at
+        # the end of the line, less the pixels it held for past HOLD_AT,
+        # where it ran over $184-$187 again instead.
+        def self.xpos(pixel, width, hold)
+          count = (pixel - X_OFFSET) % width
+          return count if count < HOLD_AT
+          return count - hold if count >= HOLD_AT + hold
+
+          HOLD_BASE + ((count - HOLD_AT) % 4)
+        end
+
+        # The raster pixels at which the X counter reads each coordinate, 512
+        # lists. A sprite starts at one where its X matches. On the 6569 the
+        # coordinates past 503 have none.
+        def self.x_pixels(width, hold)
+          pixels = Array.new(512) { [] }
+          width.times { |pixel| pixels[xpos(pixel, width, hold)] << pixel }
+          pixels.each(&:freeze).freeze
+        end
+      end
+    end
+  end
+end