badline 0.4.1 → 0.5.0

data/lib/badline/storage/d64_image.rb

@@ -7,10 +7,28 @@ module Badline
       # (174848 bytes without one), 40 tracks (196608) and 42 tracks (205312)
       ERROR_TABLES = { 175_531 => 683, 197_376 => 768, 206_114 => 802 }.freeze
 
+      # The tracks the image holds: 35, 40 or 42.
+      def track_count
+        blocks = @bytes.length / SECTOR_SIZE
+        count = 0
+        count += 1 while count < 42 && track_offset(count + 2) <= blocks
+        count
+      end
+
+      def sectors_in(track)
+        case track
+        when 1..17 then 21
+        when 18..24 then 19
+        when 25..30 then 18
+        else 17
+        end
+      end
+
       private
 
       def error_tables = ERROR_TABLES
 
+      def header_name = 0x90
       def directory_track = 18
       def directory_sector = 1
       def directory_interleave = 3
@@ -23,15 +41,6 @@ module Badline
       def bam_tracks = 1..35
       def bam_count(track) = [18, 0, 4 * track]
       def bam_bitmap(track) = [18, 0, (4 * track) + 1]
-
-      def sectors_in(track)
-        case track
-        when 1..17 then 21
-        when 18..24 then 19
-        when 25..30 then 18
-        else 17
-        end
-      end
     end
   end
 end

data/lib/badline/storage/d81_image.rb

@@ -9,6 +9,7 @@ module Badline
 
       def error_tables = ERROR_TABLES
 
+      def header_name = 0x04
       def directory_track = 40
       def directory_sector = 3
       def directory_interleave = 1

data/lib/badline/storage/disk_image/catalog.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    class DiskImage
+      # The directory as LOAD"$" lists it: the disk name and ID from the
+      # header block, every entry with a type, and the free blocks the BAM
+      # counts outside the directory track.
+      module Catalog
+        HEADER_ID = 18
+        ID_LENGTH = 5
+        TYPE_MASK = 0x07
+
+        def directory
+          header = sector_at(*header_block)
+          Listing.new(name: header[header_name, DiskImage::Directory::NAME_LENGTH],
+                      id: header[header_name + HEADER_ID, ID_LENGTH],
+                      entries: catalog_entries,
+                      blocks_free:)
+        end
+
+        private
+
+        # A slot whose type byte is zero is empty or scratched.
+        def catalog_entries
+          list = []
+          each_sector(directory_track, directory_sector) do |data|
+            (0...ENTRIES_PER_SECTOR).each do |i|
+              entry = data[i * ENTRY_SIZE, ENTRY_SIZE]
+              list << catalog_entry(entry) unless entry[2].zero?
+            end
+          end
+          list
+        end
+
+        def catalog_entry(entry)
+          Listing::Entry.new(name: entry[5, DiskImage::Directory::NAME_LENGTH],
+                             type: entry[2] & TYPE_MASK,
+                             blocks: entry[30] | (entry[31] << 8),
+                             closed: entry[2].anybits?(DiskImage::Directory::CLOSED),
+                             locked: entry[2].anybits?(0x40))
+        end
+
+        def blocks_free
+          (bam_tracks.to_a - reserved_tracks).sum do |track|
+            block?(*bam_count(track).first(2)) ? @bytes[count_offset(track)] : 0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/badline/storage/disk_image/writing.rb

@@ -57,6 +57,22 @@ module Badline
           update_image { put_sector(track, sector, data) } if block?(track, sector)
         end
 
+        # Stores blocks as a true drive read them back off its disk, in one
+        # write to the host file. Each is [track, sector, data, error]: nil
+        # data leaves the block's bytes as they were, and the error, the
+        # DOS error a read of it raises or nil, goes into the error table
+        # when the image has one.
+        def store_blocks(blocks)
+          update_image do
+            blocks.each do |track, sector, data, error|
+              next unless block?(track, sector)
+
+              put_sector(track, sector, data) if data
+              @errors[track_offset(track) + sector] = error ? DOS_ERRORS.key(error) : 1 if @errors
+            end
+          end
+        end
+
         # Marks a block in use, as B-A does.
         def allocate_block(track, sector) = update_image { mark(track, sector, false) }
 

data/lib/badline/storage/disk_image.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "badline/storage/disk_image/bam"
+require "badline/storage/disk_image/catalog"
 require "badline/storage/disk_image/directory"
 require "badline/storage/disk_image/writing"
 
@@ -12,6 +13,7 @@ module Badline
     # written.
     class DiskImage
       include Bam
+      include Catalog
       include Directory
       include Writing
 

data/lib/badline/storage/g64_image.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    # 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.
+    #
+    # 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
+    # the longest track a block may hold, a little-endian word. Two tables
+    # of little-endian longs follow, one entry per half track from track
+    # 1: the file offset of each half track's block, 0 for one without
+    # data, and its speed zone. A block is the track's length in bytes, a
+    # word, and then its bytes.
+    #
+    # A speed entry of 0 to 3 is the zone the whole track was written in.
+    # A larger one is the offset of a speed map, two bits a byte, four
+    # track bytes to a map byte, the first byte's in the top two bits, for
+    # a track whose zone changes along it. The drive passes each byte
+    # under the head at its own zone's rate (Drive1541::Track).
+    #
+    # The drive writes a track at one zone, so a track written back takes
+    # that zone as its speed entry. Writing it puts it in its own block,
+    # where it fits, and otherwise appends a block to the file for it, as
+    # for a half track that had no data. A track longer than the header's longest raises
+    # it, so the header stays true of every block. A half track beyond
+    # the tables stays on the disk alone. One opened with `read_only` is a
+    # write-protected disk, and the host file is never written.
+    #
+    # Opening an image checks that its header and tables are whole, and
+    # that every block and speed map lies past the tables and inside the
+    # file, and raises FormatError where one doesn't.
+    class G64Image
+      class FormatError < StandardError; end
+
+      SIGNATURE = "GCR-1541"
+      HEADER_SIZE = 12
+      HALF_TRACKS = 84
+      MAX_TRACK_SIZE = 7928
+
+      # A new image of +tracks+, {entry => [bytes, zone]} with entry 0 for
+      # track 1 and 1 for track 1.5, laid out as VICE lays one out: every
+      # block as long as the longest track.
+      def self.create(path, tracks, half_tracks: HALF_TRACKS)
+        max = [MAX_TRACK_SIZE, *tracks.values.map { |bytes, _| bytes.length }].max
+        offsets = Array.new(half_tracks, 0)
+        zones = Array.new(half_tracks, 0)
+        blocks = +"".b
+        position = HEADER_SIZE + (half_tracks * 8)
+        tracks.keys.sort.each do |entry|
+          bytes, zones[entry] = tracks[entry]
+          offsets[entry] = position + blocks.bytesize
+          blocks << block(bytes, max)
+        end
+        header = SIGNATURE.b + [0, half_tracks, max].pack("CCv")
+        File.binwrite(path, header + offsets.pack("V*") + zones.pack("V*") + blocks)
+        new(path)
+      end
+
+      def self.block(bytes, size)
+        [bytes.length].pack("v") + bytes.pack("C*").ljust(size, "\x00".b)
+      end
+
+      attr_reader :half_tracks, :max_track_size
+
+      def initialize(path, read_only: false)
+        @path = path
+        @read_only = read_only
+        @data = File.binread(path)
+        parse
+      end
+
+      # Whether the image was opened write-protected.
+      def read_only? = @read_only
+
+      # Whether the host file takes writes.
+      def writable? = !read_only? && File.writable?(@path)
+
+      # The track at table entry +entry+ (0 for track 1) as [bytes, zone],
+      # or nil where it has no data. A speed-mapped track's zone is the one
+      # most of its bytes were written in.
+      def track(entry)
+        offset = @offsets[entry].to_i
+        return if offset.zero?
+
+        length = block_length(offset)
+        return if length.zero?
+
+        speeds = mapped_speeds(entry, length)
+        [@data.byteslice(offset + 2, length).bytes, speeds ? majority(speeds) : @speeds[entry]]
+      end
+
+      # Each byte's zone of the track at table entry +entry+, where its
+      # speed map changes along it, and nil otherwise.
+      def speeds(entry)
+        offset = @offsets[entry].to_i
+        return if offset.zero?
+
+        speeds = mapped_speeds(entry, block_length(offset))
+        speeds unless speeds.nil? || speeds.uniq.one?
+      end
+
+      # Stores tracks the drive wrote, {entry => [bytes, zone]}, in one
+      # write to the host file. Each takes its zone as its speed entry.
+      def store_tracks(tracks)
+        raise WriteError, WriteError::WRITE_PROTECT_ON unless writable?
+
+        data = @data.dup
+        tracks.each do |entry, (bytes, zone)|
+          next unless entry < @half_tracks
+
+          store_track(data, entry, bytes, zone)
+        end
+        File.binwrite(@path, data)
+        @data = data
+        parse
+      rescue SystemCallError
+        parse
+        raise WriteError, WriteError::WRITE_PROTECT_ON
+      end
+
+      private
+
+      def parse
+        raise FormatError, "Missing G64 signature" unless @data.start_with?(SIGNATURE)
+        raise FormatError, "G64 header is cut short" if @data.bytesize < HEADER_SIZE
+
+        version, @half_tracks, @max_track_size = @data.byteslice(8, 4).unpack("CCv")
+        raise FormatError, "Unsupported G64 version #{version}" unless version.zero?
+
+        tables = @data.byteslice(HEADER_SIZE, @half_tracks * 8).to_s
+        raise FormatError, "G64 track tables are cut short" if tables.bytesize < @half_tracks * 8
+
+        @offsets = tables.byteslice(0, @half_tracks * 4).unpack("V*")
+        @speeds = tables.byteslice(@half_tracks * 4, @half_tracks * 4).unpack("V*")
+        @half_tracks.times { |entry| check_block(entry) }
+      end
+
+      def tables_end = HEADER_SIZE + (@half_tracks * 8)
+
+      def block_length(offset) = @data.byteslice(offset, 2).unpack1("v")
+
+      def check_block(entry)
+        offset = @offsets[entry]
+        return if offset.zero?
+
+        problem = misplaced(offset, 2) || misplaced(offset, 2 + block_length(offset))
+        raise FormatError, "G64 track entry #{entry} #{problem}" if problem
+
+        check_speed_map(entry, block_length(offset))
+      end
+
+      def check_speed_map(entry, length)
+        speed = @speeds[entry]
+        return if speed <= 3
+
+        problem = misplaced(speed, (length + 3) / 4)
+        raise FormatError, "G64 speed map of track entry #{entry} #{problem}" if problem
+      end
+
+      # What's wrong with +size+ bytes at +offset+, or nil where they lie
+      # past the tables and inside the file.
+      def misplaced(offset, size)
+        if offset < tables_end then "points into the header or its tables"
+        elsif offset + size > @data.bytesize then "runs past the end of the image"
+        end
+      end
+
+      # Each byte's zone from the track's speed map, or nil where its speed
+      # entry is a zone.
+      def mapped_speeds(entry, length)
+        speed = @speeds[entry]
+        return if speed <= 3
+
+        map = @data.byteslice(speed, (length + 3) / 4).to_s.bytes
+        Array.new(length) { |index| (map[index >> 2] >> (6 - ((index & 3) * 2))) & 3 }
+      end
+
+      # The zone most of the bytes were written in.
+      def majority(speeds)
+        counts = [0, 0, 0, 0]
+        speeds.each { |zone| counts[zone] += 1 }
+        counts.index(counts.max)
+      end
+
+      def store_track(data, entry, bytes, zone)
+        offset = @offsets[entry]
+        if offset.zero? || bytes.length > capacity(offset)
+          offset = data.bytesize
+          grow(data, bytes.length)
+          data << self.class.block(bytes, @max_track_size)
+        else
+          data[offset, bytes.length + 2] = [bytes.length].pack("v") + bytes.pack("C*")
+        end
+        set_entry(data, entry, offset, zone)
+      end
+
+      # The most bytes the block at +offset+ holds without running into
+      # the next block or speed map, or off the end of the file.
+      def capacity(offset)
+        ends = (@offsets + @speeds.select { |speed| speed > 3 }).select { |start| start > offset }
+        ends.push(@data.bytesize).min - offset - 2
+      end
+
+      def grow(data, length)
+        return if length <= @max_track_size
+
+        @max_track_size = length
+        data[10, 2] = [length].pack("v")
+      end
+
+      def set_entry(data, entry, offset, zone)
+        @offsets[entry] = offset
+        @speeds[entry] = zone
+        data[HEADER_SIZE + (entry * 4), 4] = [offset].pack("V")
+        data[HEADER_SIZE + ((@half_tracks + entry) * 4), 4] = [zone].pack("V")
+      end
+    end
+  end
+end

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.1"
+  VERSION = "0.5.0"
 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,38 @@
+# 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
+
+      # 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