badline 0.3.0 → 0.4.1

data/lib/badline/storage/d64_image.rb

@@ -13,6 +13,16 @@ module Badline
 
       def directory_track = 18
       def directory_sector = 1
+      def directory_interleave = 3
+      def interleave = 10
+      def reserved_tracks = [18]
+
+      # The BAM in the header block covers the 35 tracks of a standard
+      # disk. The layouts that extend it to 40 tracks differ between DOS
+      # versions, so the tracks past 35 stay unused.
+      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

data/lib/badline/storage/d71_image.rb

@@ -9,6 +9,18 @@ module Badline
 
       def error_tables = ERROR_TABLES
 
+      def interleave = 6
+      def reserved_tracks = [18, 53]
+
+      # The header block flags a double-sided disk. The second side's free
+      # counts follow the first side's BAM there, and its bitmaps take the
+      # first block of track 53.
+      def bam_tracks = double_sided? ? 1..70 : super
+      def bam_count(track) = track > 35 ? [18, 0, 0xdd + track - 36] : super
+      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

data/lib/badline/storage/d81_image.rb

@@ -11,6 +11,15 @@ module Badline
 
       def directory_track = 40
       def directory_sector = 3
+      def directory_interleave = 1
+      def interleave = 1
+      def reserved_tracks = [40]
+
+      # Blocks 1 and 2 of track 40 hold the BAM for tracks 1 to 40 and 41
+      # to 80, six bytes a track from offset 16.
+      def bam_tracks = 1..80
+      def bam_count(track) = [40, track > 40 ? 2 : 1, 0x10 + (((track - 1) % 40) * 6)]
+      def bam_bitmap(track) = [40, track > 40 ? 2 : 1, 0x11 + (((track - 1) % 40) * 6)]
 
       def sectors_in(_track) = 40
     end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    class DiskImage
+      # The block availability map: a free count and a bitmap for each
+      # track, with a set bit for each free sector. Each format says where
+      # a track's count and bitmap sit, which tracks the map covers and
+      # which of them hold the directory. Files are laid out as the DOS
+      # does, on the tracks nearest the directory first, below it before
+      # above, with the format's sector interleave within a track.
+      module Bam
+        # Whether the BAM has an entry for the block.
+        def bam_block?(track, sector)
+          bam_tracks.cover?(track) && sector.between?(0, sectors_in(track) - 1) &&
+            block?(*bam_bitmap(track).first(2)) && block?(*bam_count(track).first(2))
+        end
+
+        # Whether the BAM marks the block free. A block it has no entry for
+        # never is.
+        def block_free?(track, sector)
+          bam_block?(track, sector) && @bytes[bitmap_offset(track) + (sector / 8)][sector % 8] == 1
+        end
+
+        # The first free block past the one given, on its track and then
+        # the tracks above it, for B-A to report when the block is taken.
+        # Empty when there is none.
+        def next_free_block(track, sector)
+          bam_tracks.each do |candidate|
+            next if candidate < track || reserved_tracks.include?(candidate)
+
+            first = candidate == track ? sector + 1 : 0
+            free = (first...sectors_in(candidate)).find { |s| block_free?(candidate, s) }
+            return [candidate, free] if free
+          end
+          []
+        end
+
+        private
+
+        def bitmap_offset(track)
+          block_track, block_sector, offset = bam_bitmap(track)
+          sector_offset(block_track, block_sector) + offset
+        end
+
+        def count_offset(track)
+          block_track, block_sector, offset = bam_count(track)
+          sector_offset(block_track, block_sector) + offset
+        end
+
+        # Marks the block free or in use, and moves the track's free count
+        # with it. A block the BAM doesn't cover is left alone.
+        def mark(track, sector, free)
+          return if !bam_block?(track, sector) || block_free?(track, sector) == free
+
+          byte = bitmap_offset(track) + (sector / 8)
+          bit = 1 << (sector % 8)
+          @bytes[byte] = free ? @bytes[byte] | bit : @bytes[byte] & ~bit
+          @bytes[count_offset(track)] = (@bytes[count_offset(track)] + (free ? 1 : -1)) & 0xff
+        end
+
+        # Takes blocks for a chain, each placed after the one before it.
+        # Raises DISK FULL when the disk runs out.
+        def allocate_chain(count)
+          block = nil
+          Array.new(count) do
+            block = next_block(*block) || raise(WriteError, WriteError::DISK_FULL)
+            mark(*block, false)
+            block
+          end
+        end
+
+        # A chain's first block goes on the free track nearest the
+        # directory. Each block after it goes the interleave further round
+        # the same track, or on the next track out once that one is full.
+        def next_block(track = nil, sector = nil)
+          candidates = track ? [track, *tracks_after(track)] : allocation_order
+          candidates.each do |candidate|
+            free = free_sector(candidate, candidate == track ? sector + interleave : 0)
+            return [candidate, free] if free
+          end
+          nil
+        end
+
+        def free_sector(track, first)
+          count = sectors_in(track)
+          (0...count).map { |i| (first + i) % count }.find { |s| block_free?(track, s) }
+        end
+
+        # The tracks a file can use, nearest the directory first, the one
+        # below before the one above.
+        def allocation_order
+          (bam_tracks.to_a - reserved_tracks).sort_by do |track|
+            [(track - directory_track).abs, track > directory_track ? 1 : 0]
+          end
+        end
+
+        # The tracks further from the directory on the same side, then the
+        # rest.
+        def tracks_after(track)
+          distance = (track - directory_track).abs
+          below = track < directory_track
+          further, rest = (allocation_order - [track]).partition do |candidate|
+            (candidate < directory_track) == below && (candidate - directory_track).abs > distance
+          end
+          further + rest
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    class DiskImage
+      # Directory entries as writes make them: a closed file's type, its
+      # first block and its length in blocks, under a name padded with
+      # shifted spaces. The directory grows a block at a time on its track.
+      module Directory
+        CLOSED = 0x80
+        NAME_LENGTH = 16
+
+        private
+
+        def entry_named(name)
+          wanted = decode_name(encode_name(name))
+          entries.find { |entry| entry[:name] == wanted }
+        end
+
+        def encode_name(name)
+          bytes = name.upcase.bytes.first(NAME_LENGTH)
+          bytes + Array.new(NAME_LENGTH - bytes.length, NAME_PADDING)
+        end
+
+        # The new chain is written before the old one is freed, so a
+        # replace that runs out of room leaves the old file.
+        def rewrite(entry, bytes, type)
+          blocks = write_chain(bytes)
+          free_chain(entry)
+          write_entry(entry[:offset], type, blocks)
+        end
+
+        def add_file(name, bytes, type)
+          blocks = write_chain(bytes)
+          offset = free_entry_offset
+          @bytes[offset + 5, NAME_LENGTH] = encode_name(name)
+          write_entry(offset, type, blocks)
+        end
+
+        # The slot's first two bytes link the directory block, so they
+        # stay. The name stays too, and what follows it up to the block
+        # count is cleared.
+        def write_entry(offset, type, blocks)
+          @bytes[offset + 2] = CLOSED | FILETYPES.fetch(type)
+          @bytes[offset + 3, 2] = blocks.first
+          @bytes[offset + 21, 9] = Array.new(9, 0)
+          @bytes[offset + 30, 2] = [blocks.length & 0xff, blocks.length >> 8]
+        end
+
+        # The first free slot in the directory, which grows by a block on
+        # the directory track when every slot is taken.
+        def free_entry_offset
+          last = nil
+          each_sector(directory_track, directory_sector) do |data, track, sector|
+            slot = (0...ENTRIES_PER_SECTOR).find { |i| data[(i * ENTRY_SIZE) + 2].zero? }
+            return sector_offset(track, sector) + (slot * ENTRY_SIZE) if slot
+
+            last = [track, sector]
+          end
+          sector_offset(*extend_directory(*last))
+        end
+
+        # A new directory block goes the directory interleave on from the
+        # last one. A full directory track fails as DISK FULL.
+        def extend_directory(track, sector)
+          count = sectors_in(directory_track)
+          free = (0...count).map { |i| (sector + directory_interleave + i) % count }
+                            .find { |s| block_free?(directory_track, s) }
+          raise WriteError, WriteError::DISK_FULL unless free
+
+          mark(directory_track, free, false)
+          @bytes[sector_offset(track, sector), 2] = [directory_track, free]
+          put_sector(directory_track, free, [0, 0xff])
+          [directory_track, free]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    class DiskImage
+      # Writes to the image: files with their chains, directory entries and
+      # BAM, raw blocks, and BAM changes. Each write goes back to the host
+      # file at once. A write the disk refuses raises WriteError and leaves
+      # the image as it was, and so does one to a read-only image or one
+      # the host can't store, which fail as a write-protected disk does.
+      module Writing
+        # Whether the disk takes writes: the image wasn't opened read-only
+        # and the host file takes them.
+        def writable? = !read_only? && ::File.writable?(@path)
+
+        # Writes a new file, or with `replace` writes over the one of the
+        # same name in its directory entry. A name already on the disk
+        # fails as FILE EXISTS otherwise.
+        def write_file(name, bytes, type: :prg, replace: false)
+          existing = entry_named(name)
+          raise WriteError, WriteError::FILE_EXISTS if existing && !replace
+
+          update_image do
+            existing ? rewrite(existing, bytes, type) : add_file(name, bytes, type)
+          end
+        end
+
+        # Adds the bytes to the end of a file, which keeps its type and its
+        # directory entry.
+        def append_file(name, bytes, type: nil)
+          entry = find_entry(name, type)
+          raise WriteError, WriteError::FILE_NOT_FOUND unless entry
+
+          update_image { rewrite(entry, read_chain(entry[:track], entry[:sector]) + bytes, entry[:type]) }
+        end
+
+        # Scratches the files matching the pattern, of any type, except
+        # locked ones, and frees their blocks. Returns how many it
+        # scratched.
+        def scratch(name)
+          pattern = Storage.matcher(name)
+          files = entries.select { |entry| !entry[:locked] && pattern.match?(entry[:name]) }
+          return 0 if files.empty?
+
+          update_image do
+            files.each do |entry|
+              free_chain(entry)
+              @bytes[entry[:offset] + 2] = 0
+            end
+          end
+          files.length
+        end
+
+        # Raw block access for the DOS `U2` command. A block that the error
+        # table marks bad reads cleanly once written.
+        def write_block(track, sector, data)
+          update_image { put_sector(track, sector, data) } if block?(track, sector)
+        end
+
+        # Marks a block in use, as B-A does.
+        def allocate_block(track, sector) = update_image { mark(track, sector, false) }
+
+        # Marks a block free, as B-F does.
+        def free_block(track, sector) = update_image { mark(track, sector, true) }
+
+        private
+
+        def update_image
+          raise WriteError, WriteError::WRITE_PROTECT_ON unless writable?
+
+          saved = [@bytes.dup, @errors&.dup]
+          begin
+            yield
+            ::File.binwrite(@path, (@bytes + @errors.to_a).pack("C*"))
+          rescue WriteError, SystemCallError => e
+            @bytes, @errors = saved
+            raise e.is_a?(WriteError) ? e : WriteError.new(WriteError::WRITE_PROTECT_ON)
+          ensure
+            @entries = nil
+          end
+        end
+
+        # Every block links the next, and the last one holds the index of
+        # its last byte in place of a link. An empty file still takes one.
+        def write_chain(bytes)
+          chunks = bytes.each_slice(SECTOR_SIZE - 2).to_a
+          chunks = [[]] if chunks.empty?
+          blocks = allocate_chain(chunks.length)
+          blocks.each_with_index do |block, i|
+            link = blocks[i + 1] || [0, chunks[i].length + 1]
+            put_sector(*block, link + chunks[i])
+          end
+          blocks
+        end
+
+        def free_chain(entry)
+          each_sector(entry[:track], entry[:sector]) do |_data, track, sector|
+            mark(track, sector, true)
+          end
+        end
+
+        def put_sector(track, sector, data)
+          block = data.first(SECTOR_SIZE)
+          @bytes[sector_offset(track, sector), SECTOR_SIZE] = block + Array.new(SECTOR_SIZE - block.length, 0)
+          @errors[track_offset(track) + sector] = 1 if @errors
+        end
+      end
+    end
+  end
+end

data/lib/badline/storage/disk_image.rb

@@ -1,8 +1,20 @@
 # frozen_string_literal: true
 
+require "badline/storage/disk_image/bam"
+require "badline/storage/disk_image/directory"
+require "badline/storage/disk_image/writing"
+
 module Badline
   module Storage
+    # A disk image served as a drive. It reads files and blocks, and
+    # writes them back to the host file through Writing. One opened with
+    # `read_only` is a write-protected disk, and the host file is never
+    # written.
     class DiskImage
+      include Bam
+      include Directory
+      include Writing
+
       SECTOR_SIZE = 256
       ENTRY_SIZE = 32
       ENTRIES_PER_SECTOR = 8
@@ -13,11 +25,16 @@ module Badline
       # the read, write and ID errors, 74 is DRIVE NOT READY.
       DOS_ERRORS = (2..11).to_h { |code| [code, code + 18] }.merge(15 => 74).freeze
 
-      def initialize(path)
+      def initialize(path, read_only: false)
+        @path = path
+        @read_only = read_only
         @bytes = File.binread(path).bytes
         @errors = split_error_table
       end
 
+      # Whether the image was opened write-protected.
+      def read_only? = @read_only
+
       # A LOAD reads only PRG files. An OPEN names the type it wants, or
       # takes the first file of any type with a nil `type`.
       def read_file(name, type: :prg)
@@ -123,12 +140,16 @@ module Badline
       def entries
         @entries ||= begin
           list = []
-          each_sector(directory_track, directory_sector) { |data| list.concat(parse_entries(data)) }
+          each_sector(directory_track, directory_sector) do |data, track, sector|
+            list.concat(parse_entries(data, sector_offset(track, sector)))
+          end
           list
         end
       end
 
-      def parse_entries(data)
+      # Each entry keeps the offset of its slot in the image, where a write
+      # updates it.
+      def parse_entries(data, offset)
         (0...ENTRIES_PER_SECTOR).filter_map do |i|
           entry = data[i * ENTRY_SIZE, ENTRY_SIZE]
           type = FILETYPES.key(entry[2] & 0x07)
@@ -137,7 +158,9 @@ module Badline
           { name: decode_name(entry[5, 16]),
             type:,
             track: entry[3],
-            sector: entry[4] }
+            sector: entry[4],
+            locked: entry[2].anybits?(0x40),
+            offset: offset + (i * ENTRY_SIZE) }
         end
       end
 

data/lib/badline/storage/host_directory.rb

@@ -30,7 +30,8 @@ module Badline
         { error: NO_SYNC, track: 0, sector: 0, offset: 0 }
       end
 
-      def write_file(name, bytes)
+      # Writes a .prg of any file type, over the one of the same name.
+      def write_file(name, bytes, **)
         host_name = "#{name.downcase.tr('/', '_')}.prg"
         File.binwrite(File.join(@path, host_name), bytes.pack("C*"))
         true

data/lib/badline/storage.rb

@@ -16,6 +16,21 @@ module Badline
   module Storage
     FILE_TYPES = { "S" => :seq, "P" => :prg, "U" => :usr }.freeze
 
+    # A write the disk refuses, with the DOS error it fails with.
+    class WriteError < StandardError
+      WRITE_PROTECT_ON = 26
+      FILE_NOT_FOUND = 62
+      FILE_EXISTS = 63
+      DISK_FULL = 72
+
+      attr_reader :code
+
+      def initialize(code)
+        @code = code
+        super("DOS error #{code}")
+      end
+    end
+
     class << self
       # Folds shifted PETSCII letters to their ASCII equivalents.
       def ascii(bytes)

data/lib/badline/time_of_day.rb

@@ -2,8 +2,10 @@
 
 module Badline
   class TimeOfDay
-    CLOCK_HZ = 985_248 # PAL only for now.
-    MAINS_HZ = 50      # The TOD pin is fed from the AC supply.
+    # The TOD pin is fed from the AC supply. A CIA passes its region's
+    # clock and mains frequency, and these are PAL's.
+    CLOCK_HZ = Region::PAL.clock_hz
+    MAINS_HZ = Region::PAL.mains_hz
 
     def initialize(clock_hz: CLOCK_HZ, mains_hz: MAINS_HZ)
       # The accumulator advances mains_hz per cycle, so a TOD pin pulse has

data/lib/badline/version.rb

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

data/lib/badline/via/control_lines.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Badline
+  class VIA
+    # One port's pair of control lines, CA1 and CA2 or CB1 and CB2, set up
+    # by a nibble of the peripheral control register, and their two
+    # interrupt flags. Bit 0 picks the active edge of C1, rising when set.
+    # Bits 3-1 pick the C2 mode:
+    #
+    #   000 input, falling edge    100 handshake output
+    #   001 independent, falling   101 pulse output
+    #   010 input, rising edge     110 low output
+    #   011 independent, rising    111 high output
+    #
+    # A port access clears both flags, but an independent input keeps C2's.
+    # In handshake mode C2 goes low on a port access and back high on the
+    # next active C1 edge. In pulse mode it goes low for the cycle after the
+    # access. Port A handshakes on reads and writes, port B on writes only.
+    class ControlLines
+      attr_reader :control, :c1_high, :c2_high
+
+      # The level driven on C2, high while it is an input.
+      attr_reader :c2_output
+
+      def initialize(interrupts, c1_flag:, c2_flag:, handshake_on_read:)
+        @interrupts = interrupts
+        @c1_flag = c1_flag
+        @c2_flag = c2_flag
+        @handshake_on_read = handshake_on_read
+        @c1_high = @c2_high = true
+        reset!
+      end
+
+      # Back to input mode with both handshake outputs released. The input
+      # levels carry over.
+      def reset!
+        @control = 0
+        @handshake_low = false
+        @pulse = 0
+        drive
+      end
+
+      def control=(nibble)
+        @control = nibble & 0x0f
+        drive
+      end
+
+      # Only the pulse output needs the clock.
+      def pulsing? = @pulse.positive?
+
+      def cycle!
+        @pulse -= 1
+        drive if @pulse.zero?
+      end
+
+      def active_c1_edge?(high) = high == @control.anybits?(0x01)
+
+      # A new C1 level. An active edge sets the flag and ends a handshake.
+      def c1=(high)
+        return if high == @c1_high
+
+        @c1_high = high
+        return unless active_c1_edge?(high)
+
+        @handshake_low = false
+        drive
+        @interrupts.set(@c1_flag)
+      end
+
+      # A new C2 level. An active edge sets the flag while C2 is an input.
+      def c2=(high)
+        return if high == @c2_high
+
+        @c2_high = high
+        @interrupts.set(@c2_flag) if @control.nobits?(0x08) && high == @control.anybits?(0x04)
+      end
+
+      # A read or write of the handshaking port register.
+      def access!(write)
+        @interrupts.clear(independent? ? @c1_flag : @c1_flag | @c2_flag)
+        return unless write || @handshake_on_read
+
+        case @control >> 1
+        when 4 then @handshake_low = true
+        when 5 then @pulse = 2
+        end
+        drive
+      end
+
+      private
+
+      def independent? = @control & 0x0a == 0x02
+
+      def drive
+        @c2_output = case @control >> 1
+                     when 4 then !@handshake_low
+                     when 5 then @pulse.zero?
+                     when 6 then false
+                     else true
+                     end
+      end
+    end
+  end
+end

data/lib/badline/via/interrupt_register.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Badline
+  class VIA
+    # The interrupt flag and enable registers. Each source has a flag bit,
+    # and IRQ is pulled low while any flag is set with its enable bit.
+    class InterruptRegister
+      CA2 = 0x01
+      CA1 = 0x02
+      SR = 0x04
+      CB2 = 0x08
+      CB1 = 0x10
+      TIMER2 = 0x20
+      TIMER1 = 0x40
+
+      attr_reader :flags, :enable
+
+      def initialize
+        reset!
+      end
+
+      def reset!
+        @flags = 0x00
+        @enable = 0x00
+      end
+
+      def set(bits)
+        @flags |= bits
+      end
+
+      def clear(bits)
+        @flags &= ~bits
+      end
+
+      def irq? = @flags.anybits?(@enable)
+
+      # Bit 7 reads the IRQ output.
+      def read = irq? ? @flags | 0x80 : @flags
+
+      # Writing 1s clears the flags; bit 7 is ignored.
+      def write(value)
+        clear(value & 0x7f)
+      end
+
+      # Bit 7 reads as 1.
+      def read_enable = @enable | 0x80
+
+      # Bit 7 picks between setting and clearing the enable bits given.
+      def write_enable(value)
+        if value.anybits?(0x80)
+          @enable |= value & 0x7f
+        else
+          @enable &= ~value & 0x7f
+        end
+      end
+    end
+  end
+end