badline 0.12.1 → 0.14.0

data/lib/badline/interrupts.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Interrupts
-    BREAK_MASK = 0x10
-
-    private
-
-    # Samples the IRQ line and the NMI latch once per cycle. An instruction
-    # boundary commits the sample taken on its second-to-last cycle.
-    def poll
-      if @skip_poll
-        @skip_poll = false
-        return
-      end
-      @irq_pending = @irq_sample
-      @nmi_pending = @nmi_sample
-      @irq_sample = @irq && !@status.interrupt?
-      @nmi_sample = @nmi
-    end
-
-    # A cycle the VIC stalls through BA keeps sampling the lines, OR-ed with
-    # the sample it already holds, but the boundary pipeline doesn't advance
-    # and a skipped poll stays owed to the next real cycle.
-    def sample_while_stalled
-      @irq_sample ||= @irq && !interrupt_disabled_after_stall?
-      @nmi_sample = true if @nmi
-    end
-
-    # A stalled CLI or SEI execute cycle masks with the I it is about to
-    # set. Every other step masks with the current I, PLP included: its
-    # pulled I only arrives with the stalled stack read.
-    def interrupt_disabled_after_stall?
-      return @status.interrupt? unless @plan.equal?(CPU::IMPLIED_PLAN)
-
-      case @operation
-      when :cli then false
-      when :sei then true
-      else @status.interrupt?
-      end
-    end
-
-    # Runs in the opcode fetch cycle in place of the fetch, with no bus
-    # access, and switches to the interrupt plan.
-    def start_interrupt
-      @interrupt = @boundary_nmi ? 0xfffa : 0xfffe
-      @brk = false
-      @plan = CPU::INTERRUPT_PLAN
-      @writes = CPU::INTERRUPT_WRITES
-      @index = 1
-    end
-
-    # BRK reads the byte after its opcode and ignores it, and selects the
-    # IRQ vector.
-    def op_brk_dummy
-      @memory.peek(@program_counter)
-      @interrupt = 0xfffe
-      @brk = true
-    end
-
-    def op_int_push_pch
-      @address = @brk ? (@program_counter + 1) & 0xffff : @program_counter
-      @memory.poke(stack_address, high_byte(@address))
-      @stack_pointer = (@stack_pointer - 1) & 0xff
-    end
-
-    def op_int_push_pcl
-      @memory.poke(stack_address, low_byte(@address))
-      @stack_pointer = (@stack_pointer - 1) & 0xff
-    end
-
-    def op_int_push_status
-      value = @brk ? @status.value | BREAK_MASK : @status.value & ~BREAK_MASK
-      @memory.poke(stack_address, value)
-      @stack_pointer = (@stack_pointer - 1) & 0xff
-      @status.interrupt = true
-      # An NMI that arrives before cycle 4 of a BRK or IRQ takes it over:
-      # the sequence finishes with the NMI vector.
-      @interrupt = 0xfffa if @interrupt == 0xfffe && @nmi_pending
-      @nmi = false if @interrupt == 0xfffa
-    end
-
-    def op_int_vector_low
-      @address = @memory.peek(@interrupt)
-    end
-
-    # Clears any interrupt that is pending, so the handler's first
-    # instruction always runs before the next interrupt. This applies to
-    # BRK too.
-    def op_int_vector_high
-      high = @memory.peek((@interrupt + 1) & 0xffff)
-      @program_counter = @address | (high << 8)
-      @irq_sample = @irq_pending = false
-      @nmi_sample = @nmi_pending = false
-      @interrupt = nil
-      if @brk
-        @status.break = false
-        end_instruction
-      else
-        end_sequence
-      end
-    end
-  end
-end

data/lib/badline/joystick.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Joystick
-    DIRECTIONS = { up: 0, down: 1, left: 2, right: 3, fire: 4 }.freeze
-
-    # Kept up to date as switches move, since the CIA samples the fire line
-    # every cycle to drive the light pen input.
-    attr_reader :port_bits
-
-    def initialize
-      @port_bits = 0xff
-    end
-
-    def press(direction)
-      bit = DIRECTIONS[direction]
-      @port_bits &= ~(1 << bit) if bit
-    end
-
-    def release(direction)
-      bit = DIRECTIONS[direction]
-      @port_bits |= 1 << bit if bit
-    end
-  end
-end

data/lib/badline/kernal_trap/channel.rb

@@ -1,181 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module KernalTrap
-    # One open channel on the virtual drive, holding a file, a block buffer
-    # or the command channel's status message. It gives out one byte at a
-    # time and flags the last one, so the bus can raise EOI with it. A
-    # channel cut short by a read error never flags one, and holds the
-    # error for the drive to report once its bytes run out.
-    class Channel
-      attr_accessor :buffer
-      attr_reader :error, :pointer
-      attr_writer :lead
-
-      def initialize(bytes = [], error: nil, writable: false, base: 0)
-        @base = base
-        replace(bytes)
-        @error = error
-        @writable = writable
-      end
-
-      # A block buffer opened with "#", which reads and writes one of the
-      # drive's buffers in its RAM, so M-R and M-W reach the same bytes. It
-      # hands out the whole block unless a B-R sets a shorter end, and
-      # flags that byte as the last. The DOS opens it with the pointer at 1
-      # and the buffer's number as the byte to send, so the first read
-      # answers with the number and the next one moves on to the third
-      # byte.
-      def self.buffer(memory, number)
-        new(memory.ram, writable: true, base: Drive::Memory.buffer_address(number)).tap do |channel|
-          channel.buffer = number
-          channel.rewind(Drive::BLOCK_SIZE)
-          channel.pointer = 1
-          channel.lead = number
-        end
-      end
-
-      # A file's bytes, up to the first block its chain can't read. The
-      # drive reads a block ahead before sending the last byte of the one
-      # before, so a bad block holds that byte back too, and a bad first
-      # block or a missing file leaves nothing to send.
-      def self.for_file(storage, name, type)
-        data = storage.read_file(name, type:)
-        return new([], error: [Drive::FILE_NOT_FOUND]) unless data
-
-        failure = storage.respond_to?(:read_error) && storage.read_error(name, type:)
-        return new(data) unless failure
-
-        new(data[0, failure[:offset] - 1] || [], error: failure.values_at(:error, :track, :sector))
-      end
-
-      # The file an open names. The drive keeps the first block of the file
-      # a LOAD (secondary address 0) opens at $7E and $026F of its memory,
-      # and a LOAD of a name starting with "*" reopens that file rather than
-      # the first one on the disk. Loaders write the block there with M-W
-      # to load a file the directory doesn't list. A LOAD of "$" reads the
-      # directory as a BASIC program, which a pattern after a colon narrows
-      # to the files it names.
-      def self.for_name(storage, memory, secondary, name, type)
-        return new(storage.directory.bytes(name)) if listing?(storage, secondary, name)
-
-        file = Storage.parse_name(name).first
-        return for_file(storage, file, type) unless secondary.zero? && storage.respond_to?(:first_block)
-
-        last = memory.last_program if name.start_with?("*")
-        return at_block(storage, *last) if last
-
-        block = storage.first_block(file, type:)
-        memory.last_program = block if block
-        for_file(storage, file, type)
-      end
-
-      def self.listing?(storage, secondary, name)
-        secondary.zero? && name.start_with?("$") && storage.respond_to?(:directory)
-      end
-
-      # The file whose chain starts at the block.
-      def self.at_block(storage, track, sector)
-        data = storage.read_file_at(track, sector)
-        data ? new(data) : new([], error: [Drive::ILLEGAL_TRACK_OR_SECTOR, track, sector])
-      end
-
-      # Reads what save_state wrote after the flag that marks a file open
-      # for writing (Drive::Channels.channel_from_state). A buffer channel
-      # takes its block in `ram`, the drive's RAM, again.
-      def self.from_state(input, ram)
-        new.tap { |channel| channel.load_state(input, ram) }
-      end
-
-      # A buffer channel's bytes are the drive's RAM, which the drive
-      # writes itself.
-      def save_state(out)
-        out.boolean(false).boolean(@writable).int(@base).int(@length).int(@pointer)
-        out.optional_int(@lead).optional_int(@buffer).boolean(!@error.nil?)
-        out.ints(@error) if @error
-        out.blob(@bytes) unless @writable
-      end
-
-      def load_state(input, ram)
-        @writable = input.boolean?
-        @base = input.int
-        @length = input.int
-        @pointer = input.int
-        @lead = input.optional_int
-        @buffer = input.optional_int
-        @error = input.boolean? ? input.ints : nil
-        @bytes = @writable ? ram : input.blob
-      end
-
-      def replace(bytes, length = bytes.length)
-        @bytes = bytes
-        rewind(length)
-      end
-
-      def rewind(length)
-        @length = length
-        self.pointer = 0
-      end
-
-      def pointer=(position)
-        @pointer = position
-        @lead = nil
-      end
-
-      # A block read into the channel. A buffer channel takes it into its
-      # buffer, a file channel hands it out in place of the file.
-      def load(block, length)
-        return replace(block.dup, length) unless @writable
-
-        @bytes[@base, block.length] = block
-        rewind(length)
-      end
-
-      def writable? = @writable
-
-      # A buffer channel's block, as a block write puts it on the disk.
-      def block = @bytes[@base, Drive::BLOCK_SIZE]
-
-      def exhausted?
-        @pointer >= @length
-      end
-
-      # A file that holds nothing but its error never opened.
-      def failed?
-        exhausted? && !@error.nil?
-      end
-
-      # Each byte lands at the pointer, which wraps within the block.
-      def write(bytes)
-        @lead = nil
-        bytes.each do |byte|
-          @bytes[@base + @pointer] = byte
-          @pointer = (@pointer + 1) & 0xff
-        end
-      end
-
-      def read
-        return read_buffer if @writable
-        return if exhausted?
-
-        byte = @lead || @bytes[@base + @pointer]
-        @lead = nil
-        @pointer += 1
-        [byte, exhausted? && !@error]
-      end
-
-      private
-
-      # A buffer never runs out. Past its last byte, which goes out with
-      # EOI, the pointer wraps back to the second, and a pointer set past
-      # the end runs on around the block to it.
-      def read_buffer
-        byte = @lead || @bytes[@base + @pointer]
-        @lead = nil
-        last = @pointer == @length - 1
-        @pointer = last ? 1 : (@pointer + 1) & 0xff
-        [byte, last]
-      end
-    end
-  end
-end

data/lib/badline/keyboard.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  # The key matrix spanning CIA 1's two ports: rows on port A, columns on
-  # port B. Row lines beyond the eighth sit above port A's bits in +rows+.
-  #
-  # A pressed key shorts its row line to its column line, so whichever side is
-  # pulled low drags the other down with it. Scanning works in either
-  # direction, and chains of keys sharing a line propagate the pulldown -- the
-  # ghost keys real hardware reports.
-  class Keyboard
-    include IntegerHelper
-
-    # Keys the C64 types as a combination: cursor up and cursor left are the
-    # shifted cursor keys. Pressing one holds both of its matrix keys, while
-    # a shift key held on its own stays down when it is released.
-    COMBINATIONS = {
-      cursor_up: %i[lshift cursor_v],
-      cursor_left: %i[lshift cursor_h]
-    }.freeze
-
-    # The C64's wiring: one row of keys per port A line, in port B column
-    # order.
-    C64_MATRIX = [
-      %i[delete return cursor_h f7 f1 f3 f5 cursor_v],
-      %i[3 w a 4 z s e lshift],
-      %i[5 r d 6 c f t x],
-      %i[7 y g 8 b h u v],
-      %i[9 i j 0 m k o n],
-      %i[+ p l - . : @ ,],
-      %i[£ * ; clr_home rshift = up /],
-      %i[1 left control 2 space cbm q run_stop]
-    ].freeze
-
-    attr_reader :keys, :matrix
-
-    def initialize(matrix: C64_MATRIX)
-      @keys = []
-      @row_masks = nil
-      @matrix = matrix
-      @connected = true
-    end
-
-    # Whether the machine has a keyboard. The C64GS has none: no key goes
-    # down on it.
-    def connected? = @connected
-
-    def connected=(connected)
-      @connected = connected
-      @keys.clear unless connected
-      @row_masks = nil
-    end
-
-    def press(key)
-      return unless @connected && valid_key?(key)
-
-      @keys << key
-      @row_masks = nil
-    end
-
-    def release(key)
-      @keys.reject! { |k| k == key }
-      @row_masks = nil
-    end
-
-    # Settles the row (port A) and column (port B) lines against each other
-    # until no key contact pulls a line low any more, and returns both.
-    def scan(rows, cols)
-      return [rows, cols] if keys.empty?
-
-      loop do
-        settled_rows = rows
-        settled_cols = cols
-
-        row_masks.each_with_index do |mask, row|
-          bit = 1 << row
-          next if mask.zero? || (rows.allbits?(bit) && cols.allbits?(mask))
-
-          rows &= ~bit
-          cols &= ~mask
-        end
-
-        return [rows, cols] if rows == settled_rows && cols == settled_cols
-      end
-    end
-
-    def read_a(port_a, port_b) = scan(port_a, port_b).first
-
-    def read_b(port_a, port_b) = scan(port_a, port_b).last
-
-    private
-
-    # Columns held down per row, as a bit mask of port B lines.
-    def row_masks
-      @row_masks ||= begin
-        pressed = held
-        matrix.map do |row|
-          row.each_with_index.sum { |key, column| pressed.include?(key) ? 1 << column : 0 }
-        end
-      end
-    end
-
-    # The matrix keys held down, with each combination expanded.
-    def held
-      keys.flat_map { |key| COMBINATIONS[key] || [key] }
-    end
-
-    def valid_key?(key)
-      COMBINATIONS.key?(key) || matrix.flatten.include?(key)
-    end
-  end
-end

data/lib/badline/keyboard_buffer.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module KeyboardBuffer
-    ADDRESS = 0x0277
-    COUNT = 0xc6
-    CAPACITY = 10
-
-    def type_text(text)
-      codes = text.bytes.map { |b| ascii_to_petscii(b) }
-      on_init { @pending_keys = codes }
-    end
-
-    private
-
-    def feed_keyboard
-      return unless ram.peek(COUNT).zero?
-
-      chunk = @pending_keys.shift(CAPACITY)
-      ram.write(ADDRESS, chunk)
-      ram.poke(COUNT, chunk.length)
-      @pending_keys = nil if @pending_keys.empty?
-    end
-
-    def ascii_to_petscii(byte)
-      case byte
-      when 0x61..0x7a then byte - 0x20
-      when 0x41..0x5a then byte + 0x80
-      else byte
-      end
-    end
-  end
-end

data/lib/badline/ram_expansion/banking.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module RAMExpansion
-    # The register and page mapping the expansions share. #map lays the
-    # selected banks out in the address bus's page tables, and #map_io puts
-    # the register over the VIC's I/O page at $D100.
-    module Banking
-      attr_reader :low_ram, :high_ram, :video_ram
-
-      # The block runs whenever the register moves a bank.
-      def on_change(&block)
-        @on_change = block
-      end
-
-      def peek(_addr) = 0xff
-
-      def map(read_pages, write_pages)
-        [read_pages, write_pages].each do |pages|
-          pages.fill(@low_ram, 0x00, 0x10)
-          pages.fill(@high_ram, 0x10, 0xf0)
-        end
-      end
-
-      def map_io(read_pages, write_pages)
-        read_pages[0xd1] = write_pages[0xd1] = self
-      end
-    end
-  end
-end

data/lib/badline/ram_expansion/plus256k.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module RAMExpansion
-    # The +256K: four 64K banks, the first of them the machine's own RAM.
-    # $D100 picks one for $0000-$0FFF (bits 0-1), one for the VIC (bits 2-3)
-    # and one for $1000-$FFFF (bits 6-7). Setting bit 4 locks the register
-    # until the next reset.
-    class Plus256k
-      include Banking
-
-      def initialize(ram)
-        @banks = [ram, Memory.new, Memory.new, Memory.new]
-        @on_change = nil
-        reset!
-      end
-
-      def poke(_addr, value)
-        return if @locked
-
-        @low_ram = @banks[value & 0b11]
-        @video_ram = @banks[(value >> 2) & 0b11]
-        @high_ram = @banks[value >> 6]
-        @locked = value.anybits?(0x10)
-        @on_change&.call
-      end
-
-      def reset!
-        @low_ram = @video_ram = @high_ram = @banks[0]
-        @locked = false
-      end
-
-      def type = :plus256k
-
-      def save_state(out)
-        [@low_ram, @video_ram, @high_ram].each { |bank| out.int(@banks.index(bank)) }
-        out.boolean(@locked)
-        @banks.drop(1).each { |bank| bank.save_state(out) }
-      end
-
-      def load_state(input)
-        @low_ram = @banks.fetch(input.int)
-        @video_ram = @banks.fetch(input.int)
-        @high_ram = @banks.fetch(input.int)
-        @locked = input.boolean?
-        @banks.drop(1).each { |bank| bank.load_state(input) }
-      end
-
-      def power_on!
-        @banks.drop(1).each(&:clear!)
-      end
-    end
-  end
-end

data/lib/badline/ram_expansion/plus60k.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module RAMExpansion
-    # The +60K: a second bank of RAM behind $1000-$FFFF, selected by bit 7
-    # of $D100. $0000-$0FFF stays the machine's own RAM, and so does all of
-    # what the VIC sees.
-    class Plus60k
-      include Banking
-
-      def initialize(ram)
-        @low_ram = @video_ram = @high_ram = ram
-        @banks = [ram, Memory.new]
-        @on_change = nil
-      end
-
-      def poke(_addr, value)
-        @high_ram = @banks[value >> 7]
-        @on_change&.call
-      end
-
-      def reset!
-        @high_ram = @banks[0]
-      end
-
-      def type = :plus60k
-
-      def save_state(out)
-        out.int(@banks.index(@high_ram))
-        @banks[1].save_state(out)
-      end
-
-      def load_state(input)
-        @high_ram = @banks.fetch(input.int)
-        @banks[1].load_state(input)
-      end
-
-      def power_on!
-        @banks[1].clear!
-      end
-    end
-  end
-end

data/lib/badline/ram_expansion/unexpanded.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module RAMExpansion
-    # The machine with no expansion fitted: its own RAM everywhere, and
-    # $D100 left to the VIC.
-    class Unexpanded
-      include Banking
-
-      def initialize(ram)
-        @low_ram = @video_ram = @high_ram = ram
-        @on_change = nil
-      end
-
-      def type = nil
-
-      def map_io(_read_pages, _write_pages); end
-
-      def save_state(_out); end
-
-      def load_state(_input); end
-
-      def reset!; end
-
-      def power_on!; end
-    end
-  end
-end

data/lib/badline/ram_expansion.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require "badline/ram_expansion/banking"
-require "badline/ram_expansion/unexpanded"
-require "badline/ram_expansion/plus60k"
-require "badline/ram_expansion/plus256k"
-
-module Badline
-  # RAM expansions that bank extra memory in under the CPU through a
-  # register at $D100, in the VIC's I/O page. Any write to $D100-$D1FF
-  # sets the register, which reads back as $FF.
-  module RAMExpansion
-    TYPES = { plus60k: Plus60k, plus256k: Plus256k }.freeze
-
-    def self.build(type, ram, &)
-      expansion = type ? TYPES.fetch(type).new(ram) : Unexpanded.new(ram)
-      expansion.on_change(&)
-      expansion
-    end
-  end
-end

data/lib/badline/reu/dma/saved_state.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class REU
-    class DMA
-      # A transfer's state for a snapshot (REU::SavedState).
-      module SavedState
-        # Everything a transfer holds between cycles. Before the first
-        # transfer, the fields it sets on starting are empty.
-        def save_state(out)
-          out.int(@c64).int(@expansion).int(@length).int(@events)
-          [@type, @c64_step, @expansion_step, @last, @ba_low_after_writes, @swap_byte, @held_read].each do |value|
-            out.optional_int(value)
-          end
-          [@holding, @waiting, @stopped_after_write, @swap_write_due, @swap_read_again, @moved_all,
-           @extra_cycle].each do |flag|
-            out.boolean(flag)
-          end
-        end
-
-        def load_state(input)
-          @c64 = input.int
-          @expansion = input.int
-          @length = input.int
-          @events = input.int
-          load_steps(input)
-          @holding = input.boolean?
-          @waiting = input.boolean?
-          @stopped_after_write = input.boolean?
-          @swap_write_due = input.boolean?
-          @swap_read_again = input.boolean?
-          @moved_all = input.boolean?
-          @extra_cycle = input.boolean?
-        end
-
-        private
-
-        def load_steps(input)
-          @type = input.optional_int
-          @c64_step = input.optional_int
-          @expansion_step = input.optional_int
-          @last = input.optional_int
-          @ba_low_after_writes = input.optional_int
-          @swap_byte = input.optional_int
-          @held_read = input.optional_int
-        end
-      end
-    end
-  end
-end