badline 0.1.0

data/lib/badline/keyboard_buffer.rb

@@ -0,0 +1,33 @@
+# 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/media.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Badline
+  module Media
+    AUTOSTART = %(lO"*",8,1\rrun\r)
+    BASIC_START = 0x0801
+
+    DISK_TYPES = {
+      ".d64" => Storage::D64Image,
+      ".d71" => Storage::D71Image,
+      ".d81" => Storage::D81Image
+    }.freeze
+
+    class << self
+      def attach(computer, path, autostart: true)
+        if File.directory?(path)
+          computer.mount(Storage::HostDirectory.new(path))
+          "Mounted #{path} as device 8"
+        elsif File.extname(path).downcase == ".crt"
+          attach_cartridge(computer, path)
+        elsif (image = DISK_TYPES[File.extname(path).downcase])
+          attach_disk(computer, image.new(path), path, autostart:)
+        else
+          attach_prg(computer, path, autostart:)
+        end
+      end
+
+      private
+
+      def attach_cartridge(computer, path)
+        computer.attach_cartridge(Cartridge.from_file(path))
+        "Attached cartridge #{path}"
+      end
+
+      def attach_disk(computer, image, path, autostart:)
+        computer.mount(image)
+        computer.type_text(AUTOSTART) if autostart
+        "Mounted #{path} as device 8"
+      end
+
+      def attach_prg(computer, path, autostart:)
+        bytes = File.binread(path).bytes
+        bytes = Storage::P00.data(bytes) if Storage::P00.wraps?(bytes)
+        computer.on_init { start_prg(computer, bytes, autostart:) }
+        "Loading #{path}"
+      end
+
+      def start_prg(computer, data, autostart:)
+        load_addr = computer.load_prg(data)
+        # Run only makes sense for programs at BASIC start.
+        return unless autostart && load_addr == BASIC_START
+
+        end_addr = load_addr + data.length - 2
+        computer.ram.write(0x2d, [end_addr & 0xff, end_addr >> 8])
+        computer.type_text("run\r")
+      end
+    end
+  end
+end

data/lib/badline/memory.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Badline
+  class Memory
+    include Addressable
+
+    def initialize(initial = [], length: 2**16, start: 0)
+      addressable_at(start, length:)
+      @storage = zero_fill(initial)
+    end
+
+    def peek(addr)
+      @storage[index(addr)]
+    end
+
+    def poke(addr, value)
+      @storage[index(addr)] = value
+      value
+    end
+
+    def read(addr, length)
+      (addr...(addr + length)).to_a.map { |a| peek(a) }
+    end
+
+    def write(addr, bytes)
+      Array(bytes).each_with_index { |b, i| poke(addr + i, b) }
+    end
+
+    private
+
+    def blank_value
+      0
+    end
+
+    def zero_fill(initial)
+      array = initial.dup
+      0.upto(length - 1) do |i|
+        array[i] ||= blank_value
+      end
+      array
+    end
+  end
+end

data/lib/badline/rom.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Badline
+  class ROM < Memory
+    class << self
+      def load(filename, start = 0x0)
+        data = File.read(file_path(filename)).bytes
+        new(data, length: data.length, start: start)
+      end
+
+      private
+
+      def file_path(filename)
+        File.join(File.dirname(__FILE__), "roms", filename)
+      end
+    end
+
+    def poke(_addr, _value)
+      raise ReadOnlyMemoryError
+    end
+    alias []= poke
+  end
+end

data/lib/badline/roms/README

@@ -0,0 +1,18 @@
+Commodore 64 ROMs
+=================
+
+Downloaded from http://www.unusedino.de/ec64/technical2.html
+Credited in turn to ftp://ftp.funet.fi/pub/cbm
+
+basic.rom
+---------
+Commodore 64 BASIC V2. The first and only revision.
+
+kernal.rom
+----------
+Commodore 64 KERNAL ROM Revision 3. The last revision, also used in
+the C128's C64 mode.
+
+character.rom
+-------------
+The character generator ROM.

data/lib/badline/sid.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Badline
+  class SID
+    include Addressable
+
+    def initialize
+      addressable_at(0xd400, length: 2**10)
+      @registers = Memory.new(length: 2**5)
+    end
+
+    def peek(addr)
+      i = index(addr) % (2**5)
+      case i
+      when 0x1d..0x1f then 0xff # Unused memory
+      else @registers.peek(i)
+      end
+    end
+
+    def poke(addr, value)
+      i = index(addr) % (2**5)
+      @registers.poke(i, value)
+    end
+  end
+end

data/lib/badline/status.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Badline
+  class Status
+    attr_reader :value, :flags, :bitmask, :low_mask, :high_mask
+
+    def initialize(flags = [], value: 0x0)
+      @flags = flags
+
+      @bitmask = create_mask { |f| f.is_a?(Symbol) }
+      @low_mask = create_mask { |f| f.is_a?(Integer) && f.zero? }
+      @high_mask = create_mask { |f| f.is_a?(Integer) && f == 1 }
+
+      self.value = value
+
+      define_accessors!
+    end
+
+    def value=(new_value)
+      @value = (new_value | high_mask) & ~low_mask
+    end
+
+    private
+
+    def create_mask(&predicate)
+      flags.each.with_index.inject(0) do |mask, (flag, i)|
+        mask + (predicate.call(flag) ? 1 << i : 0)
+      end
+    end
+
+    def define_accessors!
+      flags.each_with_index do |name, i|
+        next unless name.is_a?(Symbol)
+
+        mask = 1 << i
+        define_singleton_method("#{name}=") do |enabled|
+          update(mask, enabled)
+        end
+        define_singleton_method("#{name}?") do
+          !@value.nobits?(mask)
+        end
+        define_singleton_method(name) do
+          @value.nobits?(mask) ? 0 : 1
+        end
+      end
+    end
+
+    def update(mask, enabled)
+      self.value = if enabled && enabled != 0
+                     value | mask
+                   else
+                     value & ~mask
+                   end
+    end
+  end
+end

data/lib/badline/storage/crt_file.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    class CRTFile
+      class FormatError < StandardError; end
+
+      SIGNATURE = "C64 CARTRIDGE   ".b
+      CHIP_SIGNATURE = "CHIP".b
+      CHIP_HEADER_SIZE = 0x10
+      RAM_CHIP = 1
+
+      Chip = Data.define(:chip_type, :bank, :address, :data)
+
+      attr_reader :hardware_type, :exrom, :game, :name, :chips
+
+      def initialize(path)
+        parse(File.binread(path))
+      end
+
+      private
+
+      def parse(bytes)
+        raise FormatError, "Missing CRT signature" unless bytes.start_with?(SIGNATURE)
+
+        @hardware_type = bytes[0x16, 2].unpack1("n")
+        @exrom = bytes.getbyte(0x18)
+        @game = bytes.getbyte(0x19)
+        @name = bytes[0x20, 32].unpack1("Z*")
+        @chips = parse_chips(bytes, bytes[0x10, 4].unpack1("N"))
+      end
+
+      def parse_chips(bytes, offset)
+        chips = []
+        while offset < bytes.length
+          chip, offset = parse_chip(bytes, offset)
+          chips << chip
+        end
+        chips
+      end
+
+      def parse_chip(bytes, offset)
+        raise FormatError, "Bad CHIP packet at offset #{offset}" unless bytes[offset, 4] == CHIP_SIGNATURE
+
+        packet_length = bytes[offset + 4, 4].unpack1("N")
+        chip_type, bank, address, size = bytes[offset + 8, 8].unpack("n4")
+        data = chip_type == RAM_CHIP ? [] : bytes[offset + CHIP_HEADER_SIZE, size].bytes
+        [Chip.new(chip_type:, bank:, address:, data:),
+         offset + [packet_length, CHIP_HEADER_SIZE + data.length].max]
+      end
+    end
+  end
+end

data/lib/badline/storage/d64_image.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    class D64Image < DiskImage
+      private
+
+      def directory_track = 18
+      def directory_sector = 1
+
+      def sectors_in(track)
+        case track
+        when 1..17 then 21
+        when 18..24 then 19
+        when 25..30 then 18
+        else 17
+        end
+      end
+    end
+  end
+end

data/lib/badline/storage/d71_image.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    class D71Image < D64Image
+      private
+
+      def sectors_in(track)
+        track > 35 ? super(track - 35) : super
+      end
+    end
+  end
+end

data/lib/badline/storage/d81_image.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    class D81Image < DiskImage
+      private
+
+      def directory_track = 40
+      def directory_sector = 3
+
+      def sectors_in(_track) = 40
+    end
+  end
+end

data/lib/badline/storage/disk_image.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    class DiskImage
+      SECTOR_SIZE = 256
+      ENTRY_SIZE = 32
+      ENTRIES_PER_SECTOR = 8
+      FILETYPE_PRG = 0x02
+      NAME_PADDING = 0xa0
+
+      def initialize(path)
+        @bytes = File.binread(path).bytes
+      end
+
+      def read_file(name)
+        pattern = Storage.matcher(name)
+        entry = entries.find { |e| pattern.match?(e[:name]) }
+        read_chain(entry[:track], entry[:sector]) if entry
+      end
+
+      private
+
+      def entries
+        @entries ||= each_sector(directory_track, directory_sector)
+                     .flat_map { |data| parse_entries(data) }
+      end
+
+      def parse_entries(data)
+        (0...ENTRIES_PER_SECTOR).filter_map do |i|
+          entry = data[i * ENTRY_SIZE, ENTRY_SIZE]
+          next unless (entry[2] & 0x07) == FILETYPE_PRG
+
+          { name: decode_name(entry[5, 16]),
+            track: entry[3],
+            sector: entry[4] }
+        end
+      end
+
+      def decode_name(bytes)
+        Storage.ascii(bytes.take_while { |b| b != NAME_PADDING }).downcase
+      end
+
+      def read_chain(track, sector)
+        each_sector(track, sector).flat_map do |data|
+          data[0].zero? ? data[2..data[1]] : data[2..]
+        end
+      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
+          track, sector = data[0, 2]
+        end
+      end
+
+      def sector_at(track, sector)
+        @bytes[sector_offset(track, sector), SECTOR_SIZE]
+      end
+
+      def sector_offset(track, sector)
+        ((1...track).sum { |t| sectors_in(t) } + sector) * SECTOR_SIZE
+      end
+    end
+  end
+end

data/lib/badline/storage/host_directory.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    class HostDirectory
+      def initialize(path)
+        @path = path
+      end
+
+      def read_file(name)
+        entry = find(name)
+        return unless entry
+
+        bytes = File.binread(File.join(@path, entry[:file])).bytes
+        P00.wraps?(bytes) ? P00.data(bytes) : bytes
+      end
+
+      def write_file(name, bytes)
+        host_name = "#{name.downcase.tr('/', '_')}.prg"
+        File.binwrite(File.join(@path, host_name), bytes.pack("C*"))
+      end
+
+      private
+
+      def find(name)
+        pattern = Storage.matcher(name)
+        entries.find { |e| pattern.match?(e[:name]) }
+      end
+
+      def entries
+        Dir.children(@path).sort.filter_map { |f| entry_for(f) }
+      end
+
+      def entry_for(file)
+        case File.extname(file).downcase
+        when ".prg"
+          { name: File.basename(file, ".*").downcase, file: }
+        when ".p00"
+          p00_entry(file)
+        end
+      end
+
+      def p00_entry(file)
+        header = File.binread(File.join(@path, file), P00::HEADER_SIZE).bytes
+        { name: P00.name(header), file: } if P00.wraps?(header)
+      end
+    end
+  end
+end

data/lib/badline/storage/p00.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    module P00
+      MAGIC = "C64File\x00".bytes.freeze
+      HEADER_SIZE = 26
+
+      class << self
+        def wraps?(bytes)
+          bytes[0, 8] == MAGIC
+        end
+
+        def name(bytes)
+          Storage.ascii(bytes[8, 16].take_while(&:positive?)).downcase
+        end
+
+        def data(bytes)
+          bytes[HEADER_SIZE..]
+        end
+      end
+    end
+  end
+end

data/lib/badline/storage.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "badline/storage/p00"
+require "badline/storage/host_directory"
+require "badline/storage/disk_image"
+require "badline/storage/d64_image"
+require "badline/storage/d71_image"
+require "badline/storage/d81_image"
+require "badline/storage/crt_file"
+
+module Badline
+  module Storage
+    class << self
+      # Folds shifted PETSCII letters to their ASCII equivalents.
+      def ascii(bytes)
+        bytes.map { |b| b.between?(0xc1, 0xda) ? b - 0x80 : b }.pack("C*")
+      end
+
+      # CBM-style filename pattern: "*" and "?" wildcards, case-insensitive.
+      def matcher(name)
+        escaped = Regexp.escape(name.downcase)
+                        .gsub('\*', ".*")
+                        .gsub('\?', ".")
+        Regexp.new("\\A#{escaped}\\z")
+      end
+    end
+  end
+end

data/lib/badline/time_of_day.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Badline
+  class TimeOfDay
+    include IntegerHelper
+
+    CLOCK_HZ = 985_248 # PAL only for now.
+
+    def initialize(clock_hz: CLOCK_HZ)
+      # The accumulator advances 10 per cycle, so a tenth of a second has
+      # passed when it reaches clock_hz. Integer math keeps it exact.
+      @cycles_per_tenth = clock_hz
+      @accumulator = 0
+      @clock = { tenths: 0, seconds: 0, minutes: 0, hours: 12, pm: false }
+      @alarm = { tenths: 0, seconds: 0, minutes: 0, hours: 0, pm: false }
+      @latch = nil
+      @stopped = false
+    end
+
+    def cycle!
+      return if @stopped
+
+      @accumulator += 10
+      return if @accumulator < @cycles_per_tenth
+
+      @accumulator -= @cycles_per_tenth
+      advance
+      yield if block_given? && alarm?
+    end
+
+    def tenths
+      value = (@latch || @clock)[:tenths]
+      @latch = nil
+      bcd(value)
+    end
+
+    def seconds
+      bcd((@latch || @clock)[:seconds])
+    end
+
+    def minutes
+      bcd((@latch || @clock)[:minutes])
+    end
+
+    def hours
+      @latch ||= @clock.dup
+      bcd(@latch[:hours]) | (@latch[:pm] ? 0x80 : 0)
+    end
+
+    def write(field, value, alarm:)
+      (alarm ? @alarm : @clock)[field] = bcd_to_i(value)
+      # Start the clock again when writing tenths.
+      resume if field == :tenths && !alarm
+    end
+
+    # 12-hour BCD value, bit 7 is the AM/PM flag.
+    def write_hours(value, alarm:)
+      target = alarm ? @alarm : @clock
+      target[:hours] = bcd_to_i(value & 0x7f)
+      target[:pm] = value.anybits?(0x80)
+      # Halt the clock when writing hours, so that it doesn't
+      # advance mid-update.
+      @stopped = true unless alarm
+    end
+
+    private
+
+    def resume
+      @stopped = false
+      @accumulator = 0
+    end
+
+    def advance
+      @clock[:tenths] += 1
+      return if @clock[:tenths] < 10
+
+      @clock[:tenths] = 0
+      @clock[:seconds] += 1
+      return if @clock[:seconds] < 60
+
+      @clock[:seconds] = 0
+      @clock[:minutes] += 1
+      return if @clock[:minutes] < 60
+
+      @clock[:minutes] = 0
+      advance_hour
+    end
+
+    def advance_hour
+      @clock[:hours] += 1
+      @clock[:pm] = !@clock[:pm] if @clock[:hours] == 12
+      @clock[:hours] = 1 if @clock[:hours] > 12
+    end
+
+    def alarm?
+      %i[tenths seconds minutes hours pm].all? do |field|
+        @clock[field] == @alarm[field]
+      end
+    end
+  end
+end

data/lib/badline/traps.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Badline
+  module Traps
+    def install_trap(addr, &handler)
+      (@traps ||= {})[addr] = handler
+    end
+
+    private
+
+    def run_traps
+      @traps[@program_counter]&.call if @traps
+    end
+  end
+end

data/lib/badline/version.rb

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