badline 0.13.0 → 0.14.0

data/lib/badline/drives/model1581/disk/saved_state.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Drives
-    class Model1581
-      class Disk
-        # Saving and restoring a Disk for a snapshot: the image by its path,
-        # and every track the head wrote since the disk went in, with those
-        # written since the last flush. The rest come from the image, read
-        # again from its host file where there still is one.
-        module SavedState
-          # The image's path, expanded, and whether it was opened read-only,
-          # for a disk from Disk.open. Nil for a disk made another way.
-          attr_reader :path, :read_only
-
-          # The disk a state from save_state describes: +current+ when it was
-          # opened from the same image the same way, and otherwise a disk for
-          # the image at the path the state names. Where no file is at that
-          # path, the disk has no image and is write-protected, and a
-          # detached reader always gets one without an image.
-          def self.load(input, current)
-            path = input.optional_string
-            read_only = input.boolean?
-            disk = current if current && !path.nil? && current.path == path && current.read_only == read_only
-            disk ||= fresh(path, read_only, input.detached?)
-            disk.load_tracks(input)
-            disk
-          end
-
-          def self.fresh(path, read_only, detached)
-            return Disk.new if path.nil? || detached
-            return Disk.new.opened(path, true) unless File.file?(path)
-
-            Disk.open(path, read_only:)
-          end
-
-          # Notes the image's path and how it was opened.
-          def opened(path, read_only)
-            @path = File.expand_path(path)
-            @read_only = read_only
-            self
-          end
-
-          def save_state(out)
-            out.optional_string(@path).boolean(@read_only)
-            changed = @changed.keys.sort
-            out.ints(changed)
-            changed.each { |index| save_track(@tracks[index], out) }
-            out.ints(@written.keys)
-          end
-
-          def load_tracks(input)
-            @changed.clear
-            input.ints.each do |index|
-              @tracks[index] = load_track(input)
-              @changed[index] = true
-            end
-            @written.clear
-            input.ints.each { |index| @written[index] = true }
-          end
-
-          private
-
-          def save_track(track, out)
-            out.int(track.sectors.length)
-            track.sectors.each do |sector|
-              save_field(sector.id, out)
-              out.boolean(!sector.data.nil?)
-              save_field(sector.data, out) if sector.data
-            end
-          end
-
-          def save_field(field, out)
-            out.int(field.mark).ints(field.bytes).boolean(field.good).boolean(field.deleted)
-          end
-
-          def load_track(input)
-            Track.new(Array.new(input.int) do
-              id = load_field(input)
-              Track::Sector.new(id, input.boolean? ? load_field(input) : nil)
-            end)
-          end
-
-          def load_field(input) = Track::Field.new(input.int, input.ints, input.boolean?, input.boolean?)
-        end
-      end
-    end
-  end
-end

data/lib/badline/drives/model1581/saved_state.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Drives
-    class Model1581
-      # The drive's state for a snapshot.
-      module SavedState
-        # The drive's whole state, as the 1541's (Drives::Model1541#save_state), with
-        # the 8520 and the WD1772 in place of the VIAs.
-        def save_state(out)
-          settle!
-          out.marker("DRIVE1581")
-          out.int(@phase).int(@cycles).boolean(@atn)
-          @serial_port.save_state(out)
-          @cia.save_state(out)
-          @fdc.save_state(out)
-          @bus.save_state(out)
-          @cpu.save_state(out)
-          @mechanism.save_state(out)
-        end
-
-        def load_state(input)
-          settle!
-          input.marker("DRIVE1581")
-          @phase = input.int
-          @cycles = input.int
-          @atn = input.boolean?
-          @serial_port.load_state(input)
-          @cia.load_state(input)
-          @fdc.load_state(input)
-          @bus.load_state(input)
-          @cpu.load_state(input)
-          @mechanism.load_state(input)
-          @fast_serial_out = @cia.port_b_lines.anybits?(FAST_SERIAL_OUT)
-          ports_written
-          push_fast_output(@fast_serial_out ? fast_pins : 0)
-          forget_orbits
-        end
-      end
-    end
-  end
-end

data/lib/badline/drives/model1581/wd1772/saved_state.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Drives
-    class Model1581
-      class WD1772
-        # Saving and restoring the WD1772 for a snapshot: its registers and
-        # lines, and the command running, down to the byte it is at.
-        module SavedState
-          def save_state(out)
-            [@now, @due, @phase, @command, @track, @sector, @data, @status, @steps, @count, @after_spin_up, @mode,
-             @deadline, @id_at, @found, @index, @crc, @write_id, @size].each { |value| out.int(value) }
-            [@type1, @drq, @intrq, @motor_on, @inward, @crc_good, @gate_open, @late,
-             @settling].each { |flag| out.boolean(flag) }
-            out.ints(@bytes).ints(@syncs.map { |sync| sync ? 1 : 0 })
-          end
-
-          def load_state(input)
-            load_registers(input)
-            load_command(input)
-            load_flags(input)
-            @bytes = input.ints
-            @syncs = input.ints.map { |sync| sync == 1 }
-          end
-
-          private
-
-          def load_registers(input)
-            @now = input.int
-            @due = input.int
-            @phase = input.int
-            @command = input.int
-            @track = input.int
-            @sector = input.int
-            @data = input.int
-            @status = input.int
-          end
-
-          def load_command(input)
-            @steps = input.int
-            @count = input.int
-            @after_spin_up = input.int
-            @mode = input.int
-            @deadline = input.int
-            @id_at = input.int
-            @found = input.int
-            @index = input.int
-            @crc = input.int
-            @write_id = input.int
-            @size = input.int
-          end
-
-          def load_flags(input)
-            @type1 = input.boolean?
-            @drq = input.boolean?
-            @intrq = input.boolean?
-            @motor_on = input.boolean?
-            @inward = input.boolean?
-            @crc_good = input.boolean?
-            @gate_open = input.boolean?
-            @late = input.boolean?
-            @settling = input.boolean?
-          end
-        end
-      end
-    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/snapshot/setup.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require "badline/snapshot/c64_setup"
-require "badline/snapshot/vic20_setup"
-require "badline/snapshot/c128_setup"
-
-module Badline
-  module Snapshot
-    # How the machine a State was taken of was built, so a machine to
-    # restore it into can be built first. A State starts with its family's
-    # marker, the stamp (StateWriter#stamp) and the family's setup:
-    # C64Setup, Vic20Setup or C128Setup. Each reads its setup from a State
-    # (.from) or from the fields after the stamp (.read), writes it
-    # (#write), builds a machine that way at power-on (#build) and names it
-    # (#to_s).
-    module Setup
-      # The setup of the family whose marker the State starts with.
-      def self.read(state)
-        family = StateReader.new(state).string
-        return Vic20Setup.from(state) if family == Vic20Setup::MARKER
-        return C128Setup.from(state) if family == C128Setup::MARKER
-
-        C64Setup.from(state)
-      end
-
-      # A new machine, built as the one a State was taken of, at that
-      # state.
-      def self.restored(state) = read(state).build.apply_state(state)
-    end
-  end
-end

data/lib/badline/snapshot/state.rb

@@ -1,179 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  module Snapshot
-    # A file that isn't a snapshot badline reads, is cut short, or holds a
-    # state that doesn't line up with the machine reading it.
-    class FormatError < StandardError; end
-
-    # A machine's state, held in memory: the Integers each chip writes in
-    # turn, and the byte strings for memories, names and paths. Booleans
-    # are written as 0 and 1. C64#snapshot takes one and
-    # C64#restore puts it back.
-    class State
-      # The layout the chips write their fields in. It goes up whenever a
-      # save_state writes something else, so a State in another layout
-      # fails before anything is read into a machine. A State only reads in
-      # the layout and the badline version that wrote it.
-      SCHEMA = 10
-
-      attr_reader :values, :strings
-
-      def initialize(values, strings)
-        @values = values
-        @strings = strings
-      end
-
-      def ==(other)
-        other.is_a?(State) && values == other.values && strings == other.strings
-      end
-    end
-
-    # Writes a State. Each chip's save_state writes its fields through one
-    # of these, and its load_state reads them back from a StateReader in
-    # the same order.
-    class StateWriter
-      attr_reader :state
-
-      def initialize
-        @values = []
-        @strings = []
-        @state = State.new(@values, @strings)
-      end
-
-      def int(value)
-        raise TypeError, "not an Integer: #{value.inspect}" unless value.is_a?(Integer)
-
-        @values << value.to_i
-        self
-      end
-
-      def boolean(value)
-        @values << (value ? 1 : 0)
-        self
-      end
-
-      def optional_int(value)
-        return boolean(false) if value.nil?
-
-        boolean(true).int(value)
-      end
-
-      def ints(values)
-        int(values.length)
-        values.each { |value| int(value) }
-        self
-      end
-
-      def booleans(values)
-        int(values.length)
-        values.each { |value| boolean(value) }
-        self
-      end
-
-      # Bytes, 0 to 255 each, kept as one string.
-      def blob(values)
-        @strings << values.pack("C*")
-        self
-      end
-
-      def string(value)
-        @strings << value.to_s.b
-        self
-      end
-
-      def optional_string(value)
-        return boolean(false) if value.nil?
-
-        boolean(true).string(value)
-      end
-
-      # A name a reader checks for, so a state that has gone out of step
-      # fails there instead of loading the wrong fields.
-      def marker(name) = string(name)
-
-      # The State's layout and the badline version writing it, which a
-      # reader checks first (StateReader#check_stamp).
-      def stamp = int(State::SCHEMA).string(VERSION)
-    end
-
-    # Reads a State back in the order a StateWriter wrote it.
-    #
-    # A detached reader restores a machine that opens no host file and
-    # writes none, for a copy the machine runs on its own: a disk image
-    # comes from the bytes the state holds, write-protected, a directory
-    # device 8 serves is left out, and a true drive's disk keeps the
-    # state's tracks without its image file.
-    class StateReader
-      def initialize(state, detached: false)
-        @values = state.values
-        @strings = state.strings
-        @value = 0
-        @string = 0
-        @detached = detached
-      end
-
-      def detached? = @detached
-
-      def int
-        raise FormatError, "the state ends early, at value #{@value}" if @value >= @values.length
-
-        value = @values[@value]
-        @value += 1
-        value
-      end
-
-      def boolean?
-        value = int
-        raise FormatError, "expected a boolean in the state, found #{value}" unless value.between?(0, 1)
-
-        value == 1
-      end
-
-      def optional_int = boolean? ? int : nil
-
-      def ints = Array.new(int) { int }
-
-      def booleans = Array.new(int) { boolean? }
-
-      # Reads into an existing array, in place, so whatever else holds it
-      # sees the values.
-      def ints_into(array) = array.replace(ints)
-
-      def booleans_into(array) = array.replace(booleans)
-
-      def blob = string.bytes
-
-      def blob_into(array) = array.replace(blob)
-
-      def string
-        raise FormatError, "the state ends early, at string #{@string}" if @string >= @strings.length
-
-        value = @strings[@string]
-        @string += 1
-        value
-      end
-
-      def optional_string = boolean? ? string : nil
-
-      def marker(name)
-        found = string
-        raise FormatError, "expected #{name} in the state, found #{found[0, 20].inspect}" unless found == name
-      end
-
-      # Fails unless the State was written in this layout by this badline
-      # version.
-      def check_stamp
-        schema = int
-        version = string
-        return if schema == State::SCHEMA && version == VERSION
-
-        raise FormatError, "the state was written by badline #{version.inspect} in layout #{schema}, " \
-                           "and this is badline #{VERSION}, layout #{State::SCHEMA}"
-      end
-
-      # Whether every value and string has been read.
-      def finished? = @value == @values.length && @string == @strings.length
-    end
-  end
-end

data/lib/badline/vic20/bus/saved_state.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Badline
-  class Vic20
-    class Bus
-      # The bus's state for a snapshot.
-      module SavedState
-        # The RAM, the colour RAM, the byte each side's data lines hold and the
-        # cartridge's ROM chips, for a snapshot. The expansion blocks are how
-        # the machine was built.
-        def save_state(out)
-          out.marker("VIC20 BUS")
-          @ram.save_state(out)
-          out.blob(@color_ram.cells).int(@data).int(@video_data).int(@roms.length)
-          @roms.each do |rom|
-            out.int(rom.start)
-            rom.save_state(out)
-          end
-        end
-
-        def load_state(input)
-          input.marker("VIC20 BUS")
-          @ram.load_state(input)
-          input.blob_into(@color_ram.cells)
-          @data = input.int
-          @video_data = input.int
-          chips = Array.new(input.int) { [input.int, input.blob] }
-          @roms = []
-          chips.each { |chip| @roms << ROM.new(chip[1], length: chip[1].length, start: chip[0]) }
-          map_pages
-        end
-      end
-    end
-  end
-end

data/lib/badline/vic20/saved_state.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-require "badline/snapshot/vic20_setup"
-
-module Badline
-  class Vic20
-    # How the machine a State from #snapshot was taken of was built.
-    def self.setup(state) = Snapshot::Vic20Setup.from(state)
-
-    # A new machine, built as the one a State from #snapshot was taken of,
-    # at that state.
-    def self.restored(state) = setup(state).build.apply_state(state)
-
-    # The whole machine's state for a snapshot, as C64's: the
-    # machine's own latches, the bus with its RAM and cartridge ROM, the
-    # VIC with its sound, both VIAs, the CPU, the datasette and its tape,
-    # the disk device 8 serves through the traps, and a true 1541. The
-    # serial lines go back into the bus from the restored VIAs. What the
-    # host holds stays out: the keyboard, the joystick, RESTORE, the traps
-    # and callbacks, whether the display renders, whether the sound
-    # records, and whether the datasette records.
-    module SavedState
-      # How many more on_init handlers the machine a State was taken of had
-      # yet to run than this one has. Nil until the machine is restored.
-      attr_reader :init_handlers_lost
-
-      def snapshot
-        out = Snapshot::StateWriter.new
-        save_state(out)
-        out.state
-      end
-
-      # Takes the machine back to a State from #snapshot, trying it on a new
-      # machine first, so one that fails leaves this machine as it was.
-      # Raises Snapshot::FormatError for a state of another machine or RAM
-      # expansion.
-      def restore(state)
-        check_setup(Vic20.setup(state))
-        Vic20.restored(state)
-        apply_state(state)
-      end
-
-      # Puts a State into the machine without trying it on a new one first.
-      def apply_state(state)
-        input = Snapshot::StateReader.new(state)
-        load_state(input)
-        raise Snapshot::FormatError, "the state goes on past the machine" unless input.finished?
-
-        self
-      end
-
-      def save_state(out)
-        out.marker(Snapshot::Vic20Setup::MARKER).stamp
-        Snapshot::Vic20Setup.new(ram: @ram_configuration).write(out)
-        out.int(@cycles).boolean(@nmi_asserted).boolean(!@pending_keys.nil?)
-        out.ints(@pending_keys) if @pending_keys
-        out.int(@cycles <= @init_threshold ? @init_handlers.length : 0)
-        @bus.save_state(out)
-        @vic.save_state(out)
-        @sound.save_state(out)
-        @via1.save_state(out)
-        @via2.save_state(out)
-        @cpu.save_state(out)
-        @datasette.save_state(out)
-        save_trap_dos(out)
-        save_drive1541(out)
-        save_drive1581(out)
-      end
-
-      def load_state(input)
-        input.marker(Snapshot::Vic20Setup::MARKER)
-        input.check_stamp
-        check_setup(Snapshot::Vic20Setup.read(input))
-        @cycles = input.int
-        @nmi_asserted = input.boolean?
-        @pending_keys = nil
-        @pending_keys = input.ints if input.boolean?
-        @init_handlers_lost = [input.int - @init_handlers.length, 0].max
-        @bus.load_state(input)
-        @vic.load_state(input)
-        @sound.load_state(input)
-        @via1.load_state(input)
-        @via2.load_state(input)
-        @cpu.load_state(input)
-        via_written
-        @datasette.load_state(input)
-        load_trap_dos(input)
-        load_drive1541(input)
-        load_drive1581(input)
-      end
-
-      private
-
-      # A true 1541 on the serial bus, with its device number.
-      def save_drive1541(out)
-        out.boolean(!@drive1541.nil?)
-        return unless @drive1541
-
-        out.int(@drive1541.device)
-        @drive1541.save_state(out)
-      end
-
-      def check_setup(setup)
-        return if setup.ram == @ram_configuration
-
-        raise Snapshot::FormatError, "the state is of a VIC-20 with #{setup.ram} RAM, not #{@ram_configuration}"
-      end
-    end
-  end
-end