badline 0.12.1 → 0.13.0

data/lib/badline/instruction_set/transfer.rb

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module InstructionSet
-    module Transfer
-      # +begin_src ruby
-      # Load accumulator with memory.
-      #
-      # Opcodes:
-      #   $A1 - indirect_x - 6 cycles
-      #   $A5 - zeropage   - 3 cycles
-      #   $A9 - immediate  - 2 cycles
-      #   $AD - absolute   - 4 cycles
-      #   $B1 - indirect_y - 5+ cycles
-      #   $B5 - zeropage_x - 4 cycles
-      #   $B9 - absolute_y - 4+ cycles
-      #   $BD - absolute_x - 4+ cycles
-      def lda(_addr, value)
-        @a = value
-        update_number_flags(@a)
-      end
-
-      # Load X register with memory.
-      #
-      # Opcodes:
-      #   $A2 - immediate  - 2 cycles
-      #   $A6 - zeropage   - 3 cycles
-      #   $AE - absolute   - 4 cycles
-      #   $B6 - zeropage_y - 4 cycles
-      #   $BE - absolute_y - 4+ cycles
-      def ldx(_addr, value)
-        @x = value
-        update_number_flags(@x)
-      end
-
-      # Load Y register with memory.
-      #
-      # Opcodes:
-      #   $A0 - immediate  - 2 cycles
-      #   $A4 - zeropage   - 3 cycles
-      #   $AC - absolute   - 4 cycles
-      #   $B4 - zeropage_x - 4 cycles
-      #   $BC - absolute_x - 4+ cycles
-      def ldy(_addr, value)
-        @y = value
-        update_number_flags(@y)
-      end
-
-      # Store accumulator in memory.
-      #
-      # Opcodes:
-      #   $81 - indirect_x - 6 cycles
-      #   $85 - zeropage   - 3 cycles
-      #   $8D - absolute   - 4 cycles
-      #   $91 - indirect_y - 6 cycles
-      #   $95 - zeropage_x - 4 cycles
-      #   $99 - absolute_y - 5 cycles
-      #   $9D - absolute_x - 5 cycles
-      def sta(addr, _value)
-        write_byte(addr, @a)
-      end
-
-      # Store X register in memory.
-      #
-      # Opcodes:
-      #   $86 - zeropage   - 3 cycles
-      #   $8E - absolute   - 4 cycles
-      #   $96 - zeropage_y - 4 cycles
-      def stx(addr, _value)
-        write_byte(addr, @x)
-      end
-
-      # Store Y register in memory.
-      #
-      # Opcodes:
-      #   $84 - zeropage   - 3 cycles
-      #   $8C - absolute   - 4 cycles
-      #   $94 - zeropage_x - 4 cycles
-      def sty(addr, _value)
-        write_byte(addr, @y)
-      end
-
-      # Transfer accumulator to X register.
-      #
-      # Opcodes:
-      #   $AA - implied - 2 cycles
-      def tax(_addr, _value)
-        @x = a
-        update_number_flags(@x)
-      end
-
-      # Transfer accumulator to Y register.
-      #
-      # Opcodes:
-      #   $A8 - implied - 2 cycles
-      def tay(_addr, _value)
-        @y = a
-        update_number_flags(@y)
-      end
-
-      # Transfer stack pointer to X register.
-      #
-      # Opcodes:
-      #   $BA - implied - 2 cycles
-      def tsx(_addr, _value)
-        @x = stack_pointer
-        update_number_flags(@x)
-      end
-
-      # Transfer X register to accumulator.
-      #
-      # Opcodes:
-      #   $8A - implied - 2 cycles
-      def txa(_addr, _operand)
-        @a = x
-        update_number_flags(@a)
-      end
-
-      # Transfer X register to stack pointer.
-      #
-      # Opcodes:
-      #   $9A - implied - 2 cycles
-      def txs(_addr, _operand)
-        @stack_pointer = x
-      end
-
-      # Transfer Y register to accumulator.
-      #
-      # Opcodes:
-      #   $98 - implied - 2 cycles
-      def tya(_addr, _operand)
-        @a = y
-        update_number_flags(@a)
-      end
-    end
-  end
-end

data/lib/badline/instruction_set.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require "badline/instruction_set/arithmetic"
-require "badline/instruction_set/bitwise"
-require "badline/instruction_set/branch"
-require "badline/instruction_set/inc_dec"
-require "badline/instruction_set/flag"
-require "badline/instruction_set/illegal"
-require "badline/instruction_set/stack"
-require "badline/instruction_set/transfer"
-
-module Badline
-  # http://www.6502.org/tutorials/6502opcodes.html
-  # http://www.e-tradition.net/bytes/6502/6502_instruction_set.html
-  module InstructionSet
-    include InstructionSet::Arithmetic
-    include InstructionSet::Bitwise
-    include InstructionSet::Branch
-    include InstructionSet::IncDec
-    include InstructionSet::Flag
-    include InstructionSet::Illegal
-    include InstructionSet::Stack
-    include InstructionSet::Transfer
-
-    # No operation. The illegal forms with an operand still read it, in
-    # the steps before this is called.
-    #
-    # Opcodes:
-    #   $EA                          - implied    - 2 cycles
-    #   $04, $44, $64                - zeropage   - 3 cycles  (illegal)
-    #   $14, $34, $54, $74, $D4, $F4 - zeropage_x - 4 cycles  (illegal)
-    #   $0C                          - absolute   - 4 cycles  (illegal)
-    #   $1C, $3C, $5C, $7C, $DC, $FC - absolute_x - 4+ cycles (illegal)
-    #   $1A, $3A, $5A, $7A, $DA, $FA - implied    - 2 cycles  (illegal)
-    def nop(_addr, _value); end
-
-    private
-
-    def update_number_flags(value)
-      status.zero = value.zero?
-      status.negative = value & 0x80 != 0
-      value
-    end
-
-    # Stores a read-modify-write result. For memory, the write happens in
-    # the steps that follow (see Operations#op_rmw_read).
-    def write_modified(addr, result)
-      if addr == :accumulator
-        @a = result
-      else
-        @rmw_result = result
-      end
-    end
-  end
-end

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/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