badline 0.2.0 → 0.2.1

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,27 @@ 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
+
       # Raw block access for the DOS `U1` command. Returns nil for blocks
       # outside the image's geometry.
       def read_block(track, sector)
@@ -44,15 +58,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 +91,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 +124,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,6 +2,9 @@
 
 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 host file that can't
+    # be read is left out, and a failed write reports false.
     class HostDirectory
       def initialize(path)
         @path = path
@@ -18,6 +21,9 @@ module Badline
       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 +35,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 +53,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

data/lib/badline/version.rb

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

data/lib/badline/vic.rb

@@ -57,20 +57,33 @@ module Badline
 
       @width = 504
       @height = 312
+      @columns_per_line = @width / 8
+      @last_line = @height - 1
+      @display = Array.new(@width * @height, 0)
+      @lines = Array.new(@height) { Array.new(@width, 0) }
+      @dirty_lines = Array.new(@height, true)
+      @render = true
+
+      power_on!
+      super()
+    end
 
+    # The VIC has no reset pin, so only a power cycle brings back the
+    # registers, the raster position and the fetch and sprite state it
+    # starts with. The display keeps its buffers, cleared to black.
+    def power_on!
       @registers = VIC::Registers.new
       @register_bytes = @registers.bytes
       @display_state = VIC::DisplayState.new(@registers)
       @sequencer = VIC::Sequencer.new(@width, @registers, @vic_bank)
+      @sequencer.render = @render
       @sprites = VIC::Sprites.new(@registers, @vic_bank, @width)
-      @display = Array.new(@width * @height, 0)
-      @lines = Array.new(@height) { Array.new(@width, 0) }
-      @dirty_lines = Array.new(@height, true)
+      @display.fill(0)
+      @lines.each { |line| line.fill(0) }
+      @dirty_lines.fill(true)
 
       @column = 0
       @rasterline = 0
-      @columns_per_line = @width / 8
-      @last_line = @height - 1
 
       @character_buffer = Array.new(40, 0)
       @color_buffer = Array.new(40, 0)
@@ -87,9 +100,6 @@ module Badline
       @lp_triggered = false
       @lp_low = false
       @raster_match = false
-      @render = true
-
-      super()
     end
 
     def cycle!

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: badline
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Inge Jørgensen
@@ -145,6 +145,7 @@ files:
 - lib/badline/kernal_trap.rb
 - lib/badline/kernal_trap/channel.rb
 - lib/badline/kernal_trap/drive.rb
+- lib/badline/kernal_trap/drive/status.rb
 - lib/badline/kernal_trap/file.rb
 - lib/badline/kernal_trap/load.rb
 - lib/badline/kernal_trap/routine.rb