badline 0.2.0 → 0.3.0

data/lib/badline/status.rb

@@ -1,41 +1,12 @@
 # frozen_string_literal: true
 
 module Badline
+  # A register of flag bits. +flags+ names each bit from bit 0 up: a
+  # symbol for a flag, or 0 or 1 for a bit that always reads as that. The
+  # subclasses below carry the accessors for each register layout.
   class Status
     attr_reader :value, :flags, :bitmask, :low_mask, :high_mask
 
-    class << self
-      # Each flag layout gets a subclass of its own, with the flag accessors
-      # compiled as ordinary methods rather than closures.
-      def new(flags = [], value: 0x0)
-        return super unless equal?(Status)
-
-        layout(flags).new(flags, value:)
-      end
-
-      private
-
-      def layout(flags)
-        @layouts ||= {}
-        @layouts[flags] ||= Class.new(Status) { define_accessors(flags) }
-      end
-
-      def define_accessors(flags)
-        flags.each_with_index do |name, i|
-          next unless name.is_a?(Symbol)
-
-          mask = 1 << i
-          class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-            def #{name}=(enabled)                                                   # def carry=(enabled)
-              @value = enabled && enabled != 0 ? @value | #{mask} : @value & #{~mask} #   @value = ... | 0x01 : ... & ~0x01
-            end                                                                     # end
-            def #{name}? = @value & #{mask} != 0                                    # def carry? = @value & 0x01 != 0
-            def #{name} = @value & #{mask} == 0 ? 0 : 1                             # def carry = ... ? 0 : 1
-          RUBY
-        end
-      end
-    end
-
     def initialize(flags = [], value: 0x0)
       @flags = flags
 
@@ -58,4 +29,256 @@ module Badline
       end
     end
   end
+
+  # The 6510 processor status register.
+  class CPUStatus < Status
+    def carry=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x01 : @value & ~0x01
+    end
+
+    def carry? = @value & 0x01 != 0
+
+    def carry = @value.nobits?(0x01) ? 0 : 1
+
+    def zero=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x02 : @value & ~0x02
+    end
+
+    def zero? = @value & 0x02 != 0
+
+    def zero = @value.nobits?(0x02) ? 0 : 1
+
+    def interrupt=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x04 : @value & ~0x04
+    end
+
+    def interrupt? = @value & 0x04 != 0
+
+    def interrupt = @value.nobits?(0x04) ? 0 : 1
+
+    def decimal=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x08 : @value & ~0x08
+    end
+
+    def decimal? = @value & 0x08 != 0
+
+    def decimal = @value.nobits?(0x08) ? 0 : 1
+
+    def break=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x10 : @value & ~0x10
+    end
+
+    def break? = @value & 0x10 != 0
+
+    def break = @value.nobits?(0x10) ? 0 : 1
+
+    def overflow=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x40 : @value & ~0x40
+    end
+
+    def overflow? = @value & 0x40 != 0
+
+    def overflow = @value.nobits?(0x40) ? 0 : 1
+
+    def negative=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x80 : @value & ~0x80
+    end
+
+    def negative? = @value & 0x80 != 0
+
+    def negative = @value.nobits?(0x80) ? 0 : 1
+  end
+
+  # The 6510 I/O port at $01.
+  class PortStatus < Status
+    def basic=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x01 : @value & ~0x01
+    end
+
+    def basic? = @value & 0x01 != 0
+
+    def basic = @value.nobits?(0x01) ? 0 : 1
+
+    def kernal=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x02 : @value & ~0x02
+    end
+
+    def kernal? = @value & 0x02 != 0
+
+    def kernal = @value.nobits?(0x02) ? 0 : 1
+
+    def io=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x04 : @value & ~0x04
+    end
+
+    def io? = @value & 0x04 != 0
+
+    def io = @value.nobits?(0x04) ? 0 : 1
+
+    def tape_out=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x08 : @value & ~0x08
+    end
+
+    def tape_out? = @value & 0x08 != 0
+
+    def tape_out = @value.nobits?(0x08) ? 0 : 1
+
+    def tape_switch=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x10 : @value & ~0x10
+    end
+
+    def tape_switch? = @value & 0x10 != 0
+
+    def tape_switch = @value.nobits?(0x10) ? 0 : 1
+
+    def tape_motor=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x20 : @value & ~0x20
+    end
+
+    def tape_motor? = @value & 0x20 != 0
+
+    def tape_motor = @value.nobits?(0x20) ? 0 : 1
+  end
+
+  # A CIA timer control register, CRA or CRB. Bits 5-7 differ between the two.
+  class ControlRegister < Status
+    def start=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x01 : @value & ~0x01
+    end
+
+    def start? = @value & 0x01 != 0
+
+    def start = @value.nobits?(0x01) ? 0 : 1
+
+    def output=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x02 : @value & ~0x02
+    end
+
+    def output? = @value & 0x02 != 0
+
+    def output = @value.nobits?(0x02) ? 0 : 1
+
+    def out_mode=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x04 : @value & ~0x04
+    end
+
+    def out_mode? = @value & 0x04 != 0
+
+    def out_mode = @value.nobits?(0x04) ? 0 : 1
+
+    def run_mode=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x08 : @value & ~0x08
+    end
+
+    def run_mode? = @value & 0x08 != 0
+
+    def run_mode = @value.nobits?(0x08) ? 0 : 1
+
+    def load=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x10 : @value & ~0x10
+    end
+
+    def load? = @value & 0x10 != 0
+
+    def load = @value.nobits?(0x10) ? 0 : 1
+
+    def in_mode=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x20 : @value & ~0x20
+    end
+
+    def in_mode? = @value & 0x20 != 0
+
+    def in_mode = @value.nobits?(0x20) ? 0 : 1
+
+    def serial_mode=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x40 : @value & ~0x40
+    end
+
+    def serial_mode? = @value & 0x40 != 0
+
+    def serial_mode = @value.nobits?(0x40) ? 0 : 1
+
+    def clock_frequency=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x80 : @value & ~0x80
+    end
+
+    def clock_frequency? = @value & 0x80 != 0
+
+    def clock_frequency = @value.nobits?(0x80) ? 0 : 1
+
+    def in_cnt=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x20 : @value & ~0x20
+    end
+
+    def in_cnt? = @value & 0x20 != 0
+
+    def in_cnt = @value.nobits?(0x20) ? 0 : 1
+
+    def in_timer_a=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x40 : @value & ~0x40
+    end
+
+    def in_timer_a? = @value & 0x40 != 0
+
+    def in_timer_a = @value.nobits?(0x40) ? 0 : 1
+
+    def alarm=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x80 : @value & ~0x80
+    end
+
+    def alarm? = @value & 0x80 != 0
+
+    def alarm = @value.nobits?(0x80) ? 0 : 1
+  end
+
+  # The CIA interrupt sources, as flags or as their mask.
+  class InterruptFlags < Status
+    def timer_a=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x01 : @value & ~0x01
+    end
+
+    def timer_a? = @value & 0x01 != 0
+
+    def timer_a = @value.nobits?(0x01) ? 0 : 1
+
+    def timer_b=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x02 : @value & ~0x02
+    end
+
+    def timer_b? = @value & 0x02 != 0
+
+    def timer_b = @value.nobits?(0x02) ? 0 : 1
+
+    def alarm=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x04 : @value & ~0x04
+    end
+
+    def alarm? = @value & 0x04 != 0
+
+    def alarm = @value.nobits?(0x04) ? 0 : 1
+
+    def serial=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x08 : @value & ~0x08
+    end
+
+    def serial? = @value & 0x08 != 0
+
+    def serial = @value.nobits?(0x08) ? 0 : 1
+
+    def flag=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x10 : @value & ~0x10
+    end
+
+    def flag? = @value & 0x10 != 0
+
+    def flag = @value.nobits?(0x10) ? 0 : 1
+
+    def interrupt=(enabled)
+      @value = enabled && enabled != 0 ? @value | 0x80 : @value & ~0x80
+    end
+
+    def interrupt? = @value & 0x80 != 0
+
+    def interrupt = @value.nobits?(0x80) ? 0 : 1
+  end
 end

data/lib/badline/storage/d64_image.rb

@@ -3,8 +3,14 @@
 module Badline
   module Storage
     class D64Image < DiskImage
+      # Image sizes with an error table, mapped to its length: 35 tracks
+      # (174848 bytes without one), 40 tracks (196608) and 42 tracks (205312)
+      ERROR_TABLES = { 175_531 => 683, 197_376 => 768, 206_114 => 802 }.freeze
+
       private
 
+      def error_tables = ERROR_TABLES
+
       def directory_track = 18
       def directory_sector = 1
 

data/lib/badline/storage/d71_image.rb

@@ -3,8 +3,12 @@
 module Badline
   module Storage
     class D71Image < D64Image
+      ERROR_TABLES = { 351_062 => 1366 }.freeze
+
       private
 
+      def error_tables = ERROR_TABLES
+
       def sectors_in(track)
         track > 35 ? super(track - 35) : super
       end

data/lib/badline/storage/d81_image.rb

@@ -3,8 +3,12 @@
 module Badline
   module Storage
     class D81Image < DiskImage
+      ERROR_TABLES = { 822_400 => 3200 }.freeze
+
       private
 
+      def error_tables = ERROR_TABLES
+
       def directory_track = 40
       def directory_sector = 3
 

data/lib/badline/storage/disk_image.rb

@@ -21,13 +21,49 @@ module Badline
       # 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)
-        pattern = Storage.matcher(name)
-        entry = entries.find do |e|
-          (type.nil? || e[:type] == type) && pattern.match?(e[:name])
-        end
+        entry = find_entry(name, type)
         read_chain(entry[:track], entry[:sector]) if entry
       end
 
+      # The first block in a file's chain that the error table marks bad:
+      # its DOS error, its track and sector, and how many of the file's
+      # bytes come before it. Nil when the whole chain reads cleanly.
+      def read_error(name, type: :prg)
+        entry = find_entry(name, type)
+        return unless @errors && entry
+
+        offset = 0
+        each_sector(entry[:track], entry[:sector]) do |data, track, sector|
+          error = block_error(track, sector)
+          return { error:, track:, sector:, offset: } if error
+
+          offset += data[0].zero? ? data[1] - 1 : SECTOR_SIZE - 2
+        end
+        nil
+      end
+
+      # The track and sector a file's chain starts at.
+      def first_block(name, type: :prg)
+        entry = find_entry(name, type)
+        [entry[:track], entry[:sector]] if entry
+      end
+
+      # The bytes of the chain that starts at the block, or nil when the
+      # block is outside the image's geometry.
+      def read_file_at(track, sector)
+        read_chain(track, sector) if block?(track, sector)
+      end
+
+      # The track and sector of the last block in a file's chain.
+      def last_block(name, type: :prg)
+        entry = find_entry(name, type)
+        return unless entry
+
+        last = nil
+        each_sector(entry[:track], entry[:sector]) { |_data, track, sector| last = [track, sector] }
+        last
+      end
+
       # Raw block access for the DOS `U1` command. Returns nil for blocks
       # outside the image's geometry.
       def read_block(track, sector)
@@ -44,15 +80,30 @@ module Badline
         DOS_ERRORS[@errors[track_offset(track) + sector]]
       end
 
+      # The block holding the disk name and ID, at the start of the
+      # directory track.
+      def header_block = [directory_track, 0]
+
+      # The directory block a new file's entry goes into: the first with a
+      # free slot, or the last one when every slot is taken.
+      def new_entry_block
+        last = nil
+        each_sector(directory_track, directory_sector) do |data, track, sector|
+          return [track, sector] if (0...ENTRIES_PER_SECTOR).any? { |i| data[(i * ENTRY_SIZE) + 2].zero? }
+
+          last = [track, sector]
+        end
+        last
+      end
+
       private
 
-      # An error table holds one byte per block, so the image is 257 bytes
-      # per block rather than 256.
+      # An error table holds one byte per block after the last one. The image
+      # sizes that carry one are listed exactly, since a 40-track D64 with a
+      # table is also a whole number of 256-byte blocks.
       def split_error_table
-        return unless (@bytes.length % (SECTOR_SIZE + 1)).zero? &&
-                      !(@bytes.length % SECTOR_SIZE).zero?
-
-        @bytes.pop(@bytes.length / (SECTOR_SIZE + 1))
+        blocks = error_tables[@bytes.length]
+        @bytes.pop(blocks) if blocks
       end
 
       def block?(track, sector)
@@ -62,9 +113,19 @@ module Badline
         sector_offset(track, sector) + SECTOR_SIZE <= @bytes.length
       end
 
+      def find_entry(name, type)
+        pattern = Storage.matcher(name)
+        entries.find do |e|
+          (type.nil? || e[:type] == type) && pattern.match?(e[:name])
+        end
+      end
+
       def entries
-        @entries ||= each_sector(directory_track, directory_sector)
-                     .flat_map { |data| parse_entries(data) }
+        @entries ||= begin
+          list = []
+          each_sector(directory_track, directory_sector) { |data| list.concat(parse_entries(data)) }
+          list
+        end
       end
 
       def parse_entries(data)
@@ -85,19 +146,19 @@ module Badline
       end
 
       def read_chain(track, sector)
-        each_sector(track, sector).flat_map do |data|
-          data[0].zero? ? data[2..data[1]] : data[2..]
+        bytes = []
+        each_sector(track, sector) do |data|
+          bytes.concat(data[0].zero? ? data[2..data[1]] : data[2..])
         end
+        bytes
       end
 
       def each_sector(track, sector)
-        return to_enum(:each_sector, track, sector) unless block_given?
-
         visited = {}
         while track != 0 && !visited[[track, sector]]
           visited[[track, sector]] = true
           data = sector_at(track, sector)
-          yield data
+          yield data, track, sector
           track, sector = data[0, 2]
         end
       end

data/lib/badline/storage/host_directory.rb

@@ -2,7 +2,13 @@
 
 module Badline
   module Storage
+    # A host directory served as a drive: .prg files by their host name,
+    # .p00 and .t64 entries by their embedded names. A .prg the host can't
+    # read is still listed but fails to read, a .p00 or .t64 whose names
+    # can't be read is left out, and a failed write reports false.
     class HostDirectory
+      NO_SYNC = 21
+
       def initialize(path)
         @path = path
       end
@@ -12,12 +18,24 @@ module Badline
         return unless entry
 
         archive = entry[:archive]
-        archive ? archive.read_file(entry[:name]) : file_bytes(entry[:file])
+        archive ? archive.read_file(entry[:name]) : file_bytes(entry[:file]) || []
+      end
+
+      # A listed file the host can't read fails before its first byte, as
+      # a 1541 does on a disk it finds no sync on.
+      def read_error(name, **)
+        entry = find(name)
+        return unless entry && entry[:file] && !file_bytes(entry[:file])
+
+        { error: NO_SYNC, track: 0, sector: 0, offset: 0 }
       end
 
       def write_file(name, bytes)
         host_name = "#{name.downcase.tr('/', '_')}.prg"
         File.binwrite(File.join(@path, host_name), bytes.pack("C*"))
+        true
+      rescue SystemCallError
+        false
       end
 
       private
@@ -29,6 +47,8 @@ module Badline
 
       def entries
         Dir.children(@path).sort.flat_map { |f| entry_for(f) }.compact
+      rescue SystemCallError
+        []
       end
 
       def entry_for(file)
@@ -45,18 +65,22 @@ module Badline
       def p00_entry(file)
         header = File.binread(File.join(@path, file), P00::HEADER_SIZE).bytes
         { name: P00.name(header), file: } if P00.wraps?(header)
+      rescue SystemCallError
+        nil
       end
 
       def t64_entries(file)
         archive = T64.new(File.join(@path, file))
         archive.names.map { |name| { name:, archive: } }
-      rescue T64::FormatError
+      rescue T64::FormatError, SystemCallError
         nil
       end
 
       def file_bytes(file)
         bytes = File.binread(File.join(@path, file)).bytes
         P00.wraps?(bytes) ? P00.data(bytes) : bytes
+      rescue SystemCallError
+        nil
       end
     end
   end

data/lib/badline/storage/sid_file.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "digest/md5"
+require "digest"
 
 module Badline
   module Storage
@@ -13,6 +13,9 @@ module Badline
 
       V1_HEADER_SIZE = 0x76
 
+      # BASIC's RUN handler, where a BASIC tune starts.
+      BASIC_RUN = 0xa871
+
       # The 6502 stub that starts a tune: call init with the song number,
       # point the KERNAL's IRQ vector at a raster handler that calls play,
       # and spin. Both calls are wrapped in the `$01` save, bank and restore
@@ -171,6 +174,10 @@ module Badline
       # code.
       def mus? = psid? && flags[0] == 1
 
+      # Flag bit 1 marks an RSID body as a BASIC program, which RUN starts
+      # instead of a call to init.
+      def basic? = !psid? && flags[1] == 1
+
       # A v3 header can place a second SID at `$Dxx0` and a v4 header a
       # third, each given by its middle byte: even, and in `$d420-$d7e0` or
       # `$de00-$dfe0`. Anything else means the SID isn't there.
@@ -185,16 +192,22 @@ module Badline
       # 10 the 8580, 11 either and 00 unknown. Only an 8580-only tune gets one.
       def sid_model = flags[4, 2] == 0b10 ? :mos8580 : :mos6581
 
+      # Flag bits 2-3 name the video standard the same way: 01 PAL, 10 NTSC,
+      # 11 either and 00 unknown. Only an NTSC-only tune gets NTSC.
+      def ntsc? = flags[2, 2] == 0b10
+
       # HVSC keys its song length database on the whole file, header and all.
       def md5 = @md5 ||= Digest::MD5.hexdigest(@bytes.pack("C*"))
 
       # The `$01` value a routine at `address` has to run under, following
       # libsidplayfp's iomap: RAM under BASIC from `$a000`, RAM under both
       # ROMs and no I/O for a routine in the I/O window itself, RAM under the
-      # KERNAL from `$e000`. An RSID tune banks itself and gets nil.
+      # KERNAL from `$e000`. A routine below `$a000` still gets BASIC banked
+      # out when the image reaches into it, as VSID does, since it may call
+      # into the part that lies there. An RSID tune banks itself and gets nil.
       def bank_for(address)
         return unless psid?
-        return 0x37 if address < 0xa000
+        return (under_basic? ? 0x36 : 0x37) if address < 0xa000
         return 0x36 if address < 0xd000
         return 0x34 if address < 0xe000
 
@@ -227,6 +240,23 @@ module Badline
         Driver.new(self, song: song.clamp(1, songs) - 1, base: driver_address).bytes
       end
 
+      # What a booted machine needs in RAM besides the image before
+      # `boot_command` starts the tune, as address => bytes. A BASIC tune
+      # gets the end of its program in VARTAB, as LOAD leaves it, and the
+      # song in the A, X and Y that SYS loads from `$030c-$030e`, where the
+      # tune reads it with PEEK(780).
+      def boot_memory(song: start_song)
+        return { driver_address => driver(song:) } unless basic?
+
+        { 0x2d => [low_byte(end_address), high_byte(end_address)],
+          0x030c => [song.clamp(1, songs) - 1] * 3 }
+      end
+
+      def boot_command = basic? ? "run\r" : "sys#{driver_address}\r"
+
+      # Where the CPU first lands once `boot_command` has started the tune.
+      def entry_address = basic? ? BASIC_RUN : driver_address
+
       private
 
       def truncated?
@@ -237,6 +267,10 @@ module Badline
         @body ||= @bytes[data_offset..] || []
       end
 
+      def under_basic?
+        load_address < 0xc000 && end_address > 0xa000
+      end
+
       # The tape buffer and the free block below the stack page, neither
       # of which BASIC touches.
       def candidates

data/lib/badline/storage.rb

@@ -36,8 +36,10 @@ module Badline
       end
 
       # CBM-style filename pattern: "*" and "?" wildcards, case-insensitive.
+      # The DOS stops comparing at the first "*", so whatever follows it
+      # is ignored.
       def matcher(name)
-        escaped = Regexp.escape(name.downcase)
+        escaped = Regexp.escape(name.downcase.sub(/\*.*/m, "*"))
                         .gsub('\*', ".*")
                         .gsub('\?', ".")
         Regexp.new("\\A#{escaped}\\z")

data/lib/badline/time_of_day.rb

@@ -49,6 +49,13 @@ module Badline
       @latch[:hours]
     end
 
+    # The clock and alarm as stored, read without latching the clock.
+    def registers
+      [@clock[:tenths], @clock[:seconds], @clock[:minutes], @clock[:hours],
+       @alarm[:tenths], @alarm[:seconds], @alarm[:minutes], @alarm[:hours],
+       @stopped ? 1 : 0, @latch ? 1 : 0]
+    end
+
     def write(field, value, alarm:)
       # The frequency counter is held clear while the clock is stopped, and
       # starts counting again from the write to tenths that restarts it.

data/lib/badline/version.rb

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