badline 0.16.0 → 0.17.0

data/lib/badline/frontend/menu/menu_ports.rb

@@ -6,8 +6,9 @@ module Badline
     # control port has plugged in, a joystick or a pot device, and whether
     # the keys type or drive the joysticks. The VIC-20 has one port, a
     # joystick's, and the Plus/4 two joysticks and no pot devices. The PET
-    # has no ports, and the page, KEYBOARD there, says where its keys are
-    # instead.
+    # and the CBM-II's B series have no ports, and the page, KEYBOARD
+    # there, says where their keys are instead. The P500 has two joysticks,
+    # and the page says where its keys are while they type.
     module MenuPorts
       PORT_DEVICES = %i[joystick mouse paddles].freeze
       PORT_NAMES = %w[JOY MOUSE PADDLES].freeze
@@ -21,15 +22,21 @@ module Badline
       PET_GRAPHICS_KEYS = ["ESC: RUN/STOP", "SHIFT+LETTER: GRAPHIC", "ALT+SYMBOL: GRAPHIC"].freeze
       PET_BUSINESS_KEYS = ["ESC: ESC", "TAB: TAB", "PAGE UP: REPEAT", "KEYPAD: KEYPAD", "ALT+KEY: SHIFT+KEY"].freeze
 
+      # Where the CBM-II's keys without a character of their own are.
+      CBM2_KEYS = ["ESC: ESC", "F12: RUN/STOP", "HOME: CLR/HOME", "BACKSPACE: INST/DEL", "F1-F8: F1-F8",
+                   "ALT+F9, ALT+F10: F9, F10", "KEYPAD: KEYPAD", "ALT+0: KEYPAD 00", "ALT+C: C=  ALT+E: CE",
+                   "ALT+G: NORM/GRAPH", "ALT+R: OFF/RVS  ALT+P: PI", "_: LEFT ARROW"].freeze
+
       private
 
       def draw_ports
         return draw_vic20_port if @computer.family == :vic20
         return draw_plus4_ports if @computer.family == :plus4
         return draw_pet_keys if @computer.family == :pet
+        return draw_p500_ports if Controls.p500?(@computer)
+        return draw_cbm2_keys if @computer.family == :cbm2
 
-        toggle("PORT 1", :port1, [PORT_NAMES, PORT_ACTIONS[0], PORT_DEVICES.index(port_device(1))])
-        toggle("PORT 2", :port2, [PORT_NAMES, PORT_ACTIONS[1], PORT_DEVICES.index(port_device(2))])
+        draw_pot_ports
         return unless draw_keys(@computer.family == :c128 ? "C128" : "C64")
 
         row("SWAP JOYSTICKS", :swap)
@@ -70,6 +77,35 @@ module Badline
         end
       end
 
+      # What each control port has plugged in, a joystick, a mouse or
+      # paddles.
+      def draw_pot_ports
+        toggle("PORT 1", :port1, [PORT_NAMES, PORT_ACTIONS[0], PORT_DEVICES.index(port_device(1))])
+        toggle("PORT 2", :port2, [PORT_NAMES, PORT_ACTIONS[1], PORT_DEVICES.index(port_device(2))])
+      end
+
+      # The P500's two ports, its joysticks one for each set of keys, and
+      # while the keys type, where its keys are.
+      def draw_p500_ports
+        draw_pot_ports
+        return draw_cbm2_keys unless draw_keys("P500")
+
+        row("SWAP JOYSTICKS", :swap)
+        skip
+        arrows = @controls.arrows_port
+        info("ARROWS, SPACE", "JOYSTICK #{arrows}")
+        info("WASD, LEFT SHIFT", "JOYSTICK #{3 - arrows}")
+      end
+
+      # The CBM-II's keyboard, which types as the PET's does, and the keys
+      # that stand for the rest of its keys.
+      def draw_cbm2_keys
+        CBM2_KEYS.each do |line|
+          @painter.text(@left, @top, line, MenuTheme::TEXT)
+          @top += MenuPages::LINE
+        end
+      end
+
       # The toggle between the keyboard named and the joysticks, and
       # whether the keys drive the joysticks.
       def draw_keys(keyboard)

data/lib/badline/frontend/menu/pause_menu.rb

@@ -238,7 +238,7 @@ module Badline
       def draw_sections
         top = @top + 32
         SECTIONS.each_with_index do |name, index|
-          name = "KEYBOARD" if PAGES[index] == :ports && @pages.pet?
+          name = "KEYBOARD" if PAGES[index] == :ports && (@pages.pet? || @pages.b_series?)
           @buttons.plain(@left + 6, top, name.ljust(14), PAGES[index], on: index == @section)
           top += Buttons::HEIGHT + 2
         end

data/lib/badline/frontend/pet_keyboard.rb

@@ -12,16 +12,22 @@ module Badline
     # With either Alt down, a key that types a character presses the PET
     # key its unshifted character is on with the PET's SHIFT, so the
     # graphics on the graphics keyboard's symbol keys can be typed.
+    #
+    # The CBM-II's keyboard goes the same way (Keys.cbm2_key), and there
+    # Alt with a key presses one of the keys the host has none for
+    # (Keys.cbm2_alt_key).
     class PETKeyboard
       LSHIFT = 225
       RSHIFT = 229
       LALT = 226
       RALT = 230
 
-      # +layout+ is the PET's keyboard, :graphics or :business.
+      # +layout+ is the PET's keyboard, :graphics or :business, or :cbm2
+      # for the CBM-II's.
       def initialize(keyboard, layout)
         @keyboard = keyboard
         @layout = layout
+        @shift = layout == :cbm2 ? :shift : :lshift
         @held = {}
         @left_shift = false
         @right_shift = false
@@ -43,6 +49,11 @@ module Badline
         end
       end
 
+      # Whether a key the scancode pressed is still down.
+      def holds?(scancode) = @held.key?(scancode)
+
+      def alt? = @left_alt || @right_alt
+
       # Lets go of every key, SHIFT among them.
       def release_all
         @held.each_value { |key| @keyboard.release(key) }
@@ -59,7 +70,7 @@ module Badline
 
       def key_down(scancode)
         key_up(scancode) if @held.key?(scancode)
-        key, shift = alt? ? shifted_key(scancode) : Keys.pet_key(scancode, shifted?, @layout)
+        key, shift = alt? ? shifted_key(scancode) : layout_key(scancode, shifted?)
         return if key == :none
 
         unless shift == :host
@@ -99,10 +110,17 @@ module Badline
         end
       end
 
+      def layout_key(scancode, shift)
+        @layout == :cbm2 ? Keys.cbm2_key(scancode, shift) : Keys.pet_key(scancode, shift, @layout)
+      end
+
       # The PET key for the scancode with Alt down: for a letter or a key
       # that types a character, the key its unshifted character is on, with
-      # SHIFT, and for any other key the one it presses without Alt.
+      # SHIFT, and for any other key the one it presses without Alt. The
+      # CBM-II's is the one Keys.cbm2_alt_key names.
       def shifted_key(scancode)
+        return Keys.cbm2_alt_key(scancode) if @layout == :cbm2
+
         key, shift = Keys.pet_key(scancode, false, @layout)
         return [key, shift] if key == :none
         return [key, shift] unless scancode.between?(4, 29) || Keys::US_CHARACTERS.key?(scancode)
@@ -112,12 +130,10 @@ module Badline
 
       def shifted? = @left_shift || @right_shift
 
-      def alt? = @left_alt || @right_alt
-
       def sync_shift
         shift = @forced == -1 ? shifted? : @forced_shift
-        @keyboard.release(:lshift)
-        @keyboard.press(:lshift) if shift
+        @keyboard.release(@shift)
+        @keyboard.press(@shift) if shift
       end
     end
   end

data/lib/badline/frontend/timeline.rb

@@ -25,7 +25,8 @@ module Badline
       LOCKS = %w[caps_lock forty_eighty].freeze
 
       # What's wrong with the events for the family's machine, the first
-      # key or menu page that names nothing, or an empty string.
+      # key or menu page that names nothing, or an empty string. The
+      # CBM-II's P500 is family :p500 here, for its joysticks.
       def self.error(events, family)
         event = events.find { |candidate| candidate.action == "key" && !key?(candidate.argument, family) }
         return "no such key: #{event.argument}" unless event.nil?
@@ -38,23 +39,26 @@ module Badline
       # sound. An empty one is its first.
       def self.page?(name) = name.empty? || PauseMenu::PAGES.any? { |page| page.to_s == name }
 
-      # Whether the family's machine has a key of the name. The Plus/4 has
-      # no RESTORE, and the PET neither that nor joysticks.
+      # Whether the family's machine has a key of the name, the CBM-II's
+      # P500's as family :p500. The Plus/4 has no RESTORE, the P500 none
+      # either, and the PET and the CBM-II's B series neither that nor
+      # joysticks.
       def self.key?(name, family)
-        pet = family == :pet
-        (name == "restore" && !pet && family != :plus4) || (family == :c128 && LOCKS.include?(name)) ||
+        pet = %i[pet cbm2].include?(family)
+        (name == "restore" && !pet && !%i[plus4 p500].include?(family)) || (family == :c128 && LOCKS.include?(name)) ||
           !keyboard_key(name, family).nil? || (!pet && !joystick_direction(name).nil?)
       end
 
       # The family's Keyboard key for a name such as space, return or a,
       # on the C128 esc or keypad1, on the Plus/4 help or crsr_up, or on
-      # the PET rvs or kp1, of either of its keyboards. The shifted cursor
-      # keys, such as cursor_up, are the C64's and the C128's.
+      # the PET rvs or kp1, of either of its keyboards, or on the CBM-II
+      # escape, norm_graph or kp00. The shifted cursor keys, such as
+      # cursor_up, are the C64's and the C128's.
       def self.keyboard_key(name, family)
         return nil if name == "none"
 
         key = keyboard_matrix(family).flatten.find { |candidate| candidate.to_s == name }
-        return key unless key.nil? && !%i[plus4 pet].include?(family)
+        return key unless key.nil? && !%i[plus4 pet cbm2 p500].include?(family)
 
         Input::Keyboard::COMBINATIONS.keys.find { |candidate| candidate.to_s == name }
       end
@@ -64,6 +68,7 @@ module Badline
         when :c128 then C128::KEYBOARD_MATRIX
         when :plus4 then Plus4::KeyboardPort::MATRIX
         when :pet then PET::KeyboardPorts::GRAPHICS_MATRIX + PET::KeyboardPorts::BUSINESS_MATRIX
+        when :cbm2, :p500 then CBM2::KeyboardPorts::MATRIX
         else Input::Keyboard::C64_MATRIX
         end
       end
@@ -228,9 +233,13 @@ module Badline
       end
 
       # Whether there's one in to eject. A VIC-20 has no cartridge to take
-      # out yet, and a PET no expansion port.
+      # out yet, a PET no expansion port, and a CBM-II no datasette, and
+      # its cartridge stays in.
       def ejectable?(computer, what)
-        (what != "cartridge" || !%i[vic20 pet].include?(computer.family)) && inserted?(computer, what)
+        family = computer.family
+        return false if family == :cbm2 && what != "disk"
+
+        (what != "cartridge" || !%i[vic20 pet].include?(family)) && inserted?(computer, what)
       end
 
       def inserted?(computer, what)

data/lib/badline/kernal_trap/dos/disk_commands.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Badline
+  module KernalTrap
+    class DOS
+      # N, R and C: the commands that format a disk, rename a file and copy
+      # files. Each takes its names after a colon. A name can't hold a
+      # wildcard, and R and C take their new name before an "=". The DOS
+      # here has one drive, so a file on drive 1 is never found, and C
+      # without a colon, which copies a whole disk between the drives of a
+      # dual drive, and D, which duplicates one, are invalid commands, as on
+      # a single drive.
+      module DiskCommands
+        WILDCARD = /[*?]/
+        OTHER_DRIVE = /\A[1-9]\d*:/
+        DRIVE_ZERO = /\A0+:/
+
+        private
+
+        # N with an ID after a comma formats the disk, and without one only
+        # clears it. The ID is the two bytes after the comma, which takes the
+        # carriage return PRINT# ends the command with when the ID is one
+        # character. A comma with nothing after it gives no ID.
+        def new_disk(text)
+          colon = text.index(":")
+          return report(NO_FILE_GIVEN) unless colon
+
+          command = text.chomp("\r")
+          name, id = command[(colon + 1)..].split(",", 2)
+          return report(SYNTAX_ERROR) if name.to_s.match?(/[*?=]/)
+          return report(WRITE_PROTECT_ON) unless @storage.respond_to?(:format)
+
+          id = id.to_s.empty? ? nil : text.bytes[(command.index(",") + 1), 2]
+          writing { @storage.format(name.to_s, id && (id + [Storage::DiskImage::NAME_PADDING]).first(2)) }
+        end
+
+        # R takes the new name, then the file's.
+        def rename_file(text)
+          new_name, old_names = file_names(text, NO_FILE_GIVEN)
+          return unless new_name
+          return report(SYNTAX_ERROR) unless old_names.one?
+          return report(WRITE_PROTECT_ON) unless @storage.respond_to?(:rename)
+          return report(FILE_NOT_FOUND) if old_names.first.match?(OTHER_DRIVE)
+
+          writing { @storage.rename(Storage.strip_drive_prefix(old_names.first), new_name) }
+        end
+
+        # C takes the new name, then the files it joins, separated by
+        # commas. A first file named with drive 0 that is the new file
+        # itself has the others added to its end.
+        def copy_file(text)
+          new_name, old_names = file_names(text, INVALID_COMMAND)
+          return unless new_name
+          return report(WRITE_PROTECT_ON) unless @storage.respond_to?(:copy)
+          return report(FILE_NOT_FOUND) if old_names.any? { |name| name.match?(OTHER_DRIVE) }
+
+          names = old_names.map { |name| Storage.strip_drive_prefix(name) }
+          in_place = old_names.first.match?(DRIVE_ZERO) && names.first == new_name
+          writing { in_place ? @storage.concat(new_name, names.drop(1)) : @storage.copy(new_name, names) }
+        end
+
+        # The new name and the old ones of "new=old,...", or nil once it
+        # has reported what's wrong.
+        def file_names(text, missing_colon)
+          colon = text.index(":")
+          return report(missing_colon) unless colon
+
+          new_name, rest = text[(colon + 1)..].split("=", 2)
+          new_name = new_name.to_s
+          return report(SYNTAX_ERROR) if rest.nil? || new_name.include?(",")
+
+          old_names = rest.empty? ? [""] : rest.split(",", -1)
+          return report(SYNTAX_ERROR) if [new_name, *old_names].any? { |name| name.match?(WILDCARD) }
+
+          [new_name, old_names]
+        end
+      end
+    end
+  end
+end

data/lib/badline/kernal_trap/dos/status.rb

@@ -15,8 +15,11 @@ module Badline
           28 => "WRITE ERROR",
           29 => "DISK ID MISMATCH",
           30 => "SYNTAX ERROR",
+          31 => "SYNTAX ERROR",
+          34 => "SYNTAX ERROR",
           62 => "FILE NOT FOUND",
           63 => "FILE EXISTS",
+          64 => "FILE TYPE MISMATCH",
           65 => "NO BLOCK",
           66 => "ILLEGAL TRACK OR SECTOR",
           70 => "NO CHANNEL",

data/lib/badline/kernal_trap/dos.rb

@@ -3,6 +3,7 @@
 require "badline/kernal_trap/dos/block_commands"
 require "badline/kernal_trap/dos/channel"
 require "badline/kernal_trap/dos/channels"
+require "badline/kernal_trap/dos/disk_commands"
 require "badline/kernal_trap/dos/memory"
 require "badline/kernal_trap/dos/parameters"
 require "badline/kernal_trap/dos/status"
@@ -15,10 +16,12 @@ module Badline
     # command channel and its status message. `U1` reads a raw block into a
     # buffer channel, which is how block-access loaders bypass the KERNAL's
     # LOAD. A disk image whose host file takes writes takes files, blocks
-    # and BAM changes too. Other disks are write-protected, though storage
-    # that can write files still takes a SAVE handed over whole.
+    # and BAM changes too, and N, R and C format it, rename and copy files.
+    # Other disks are write-protected, though storage that can write files
+    # still takes a SAVE handed over whole.
     class DOS
       include BlockCommands
+      include DiskCommands
       include Writes
 
       COMMAND_CHANNEL = 15
@@ -28,6 +31,8 @@ module Badline
       FILES_SCRATCHED = 1
       WRITE_PROTECT_ON = 26
       SYNTAX_ERROR = 30
+      INVALID_COMMAND = 31
+      NO_FILE_GIVEN = 34
       FILE_NOT_FOUND = 62
       FILE_EXISTS = 63
       NO_BLOCK = 65
@@ -60,11 +65,15 @@ module Badline
         /\AV/i => :initialized,
         /\AB-A\s*:?\s*(.*)/i => :block_allocate,
         /\AB-F\s*:?\s*(.*)/i => :block_free,
-        /\AS[^:]*:(.*)/im => :scratch
+        /\AS[^:]*:(.*)/im => :scratch,
+        /\AN(.*)/im => :new_disk,
+        /\AR(.*)/im => :rename_file,
+        /\AC(.*)/im => :copy_file,
+        /\AD/i => :invalid
       }.freeze
 
       # Commands that take their argument as text rather than numbers.
-      TEXT_COMMANDS = %i[scratch].freeze
+      TEXT_COMMANDS = %i[scratch new_disk rename_file copy_file].freeze
 
       # A drive powers on reporting its DOS version, as a reset does. It
       # can take the RAM of a drive it replaces, and initializes its disk.
@@ -197,7 +206,7 @@ module Badline
         return report(SYNTAX_ERROR) unless action
 
         action = USER_TABLE[(command.getbyte(1) - 1) & 0x0f] if action == :user
-        argument = pattern.match(command)[1]
+        argument = pattern.match(action == :new_disk ? text.lstrip : command)[1]
         run_command(action, TEXT_COMMANDS.include?(action) ? argument : Parameters.parse(argument))
       end
 
@@ -218,6 +227,10 @@ module Badline
         when :block_allocate then block_allocate(arguments)
         when :block_free then block_free(arguments)
         when :scratch then scratch(arguments)
+        when :new_disk then new_disk(arguments)
+        when :rename_file then rename_file(arguments)
+        when :copy_file then copy_file(arguments)
+        when :invalid then report(INVALID_COMMAND)
         when :cold_reset then reset(cold: true)
         when :warm_reset then reset(cold: false)
         when :memory_write then memory_write(arguments)

data/lib/badline/kernal_trap/ieee.rb

@@ -23,6 +23,9 @@ module Badline
       UNTALK_COMMAND = 0x5f
       UNLISTEN_COMMAND = 0x3f
 
+      # The device the traps serve, or nil to serve none.
+      attr_accessor :device
+
       def initialize(cpu:, bus:, layout:, dos:)
         @cpu = cpu
         @bus = bus
@@ -51,7 +54,9 @@ module Badline
         address_device if @listening
       end
 
-      def addressed? = @bus.peek(zero_page.device) == @device
+      # The device TALK or LISTEN addresses: the one in A or in FA, as the
+      # layout says.
+      def addressed? = (@layout.device_in_a ? @cpu.a : @bus.peek(zero_page.device)) == @device
 
       # TALK and LISTEN end with the command sent under ATN, which stays
       # low, and A holding $FF.
@@ -113,7 +118,7 @@ module Badline
       def acptr
         return unless @talking
 
-        @layout.listen_to_talker(@bus)
+        @layout.byte_received(@bus)
         byte, status = received
         time_serial_byte(Routine::ACPTR_TIMEOUT)
         @cpu.a = byte

data/lib/badline/kernal_trap/ieee_layout.rb

@@ -2,70 +2,122 @@
 
 module Badline
   module KernalTrap
-    # Where a PET KERNAL keeps the eight IEEE-488 bus primitives, which are
-    # internal routines, not jump table entries, and the ZeroPage of its
-    # file variables. Each ROM set has its own.
-    #
-    # TALK and LISTEN take no device number in A: they send $40 or $20
-    # ORed with FA. UNTALK and UNLISTEN send $5F and $3F through the same
-    # code, and SECOND, TKSA, UNTALK and UNLISTEN end by letting go of ATN
-    # (VIA PB2) themselves. Each handshake times out on VIA timer 1, which
-    # the ROM starts with a write of $FF to $E845. LOAD and SAVE run in the
-    # ROM, through the primitives. +overwrites_device+ says UNTALK and
-    # UNLISTEN store their command in FA before they send it.
+    # The +keep+ of an IEEELineStep that only reads its register.
+    IEEE_LINE_READ = -1
+
+    # One step a KERNAL takes on the IEEE-488 bus's lines: a write of +set+
+    # to the register at +address+, or with a +keep+ mask the register read
+    # first, its +keep+ bits kept and +set+ ORed in, or with keep
+    # IEEE_LINE_READ only a read. Returns the value written, or read.
+    IEEELineStep = Data.define(:address, :keep, :set) do
+      def act_on(bus)
+        return bus.peek(address) if keep == IEEE_LINE_READ
+
+        value = keep.zero? ? set : (bus.peek(address) & keep) | set
+        bus.poke(address, value)
+        value
+      end
+    end
+
+    # The steps a KERNAL takes on the bus's lines at each moment the traps
+    # stand in for, each run in order (#run_steps), the last one's value
+    # returned: +timer+ starts the timer that times out each byte's
+    # handshake, +attention+ readies the bus and pulls ATN low for TALK
+    # and LISTEN, +byte_sent+ ends a byte sent, +release_attention+ ends
+    # SECOND, TKSA, UNTALK and UNLISTEN by letting ATN go, +listen_to_talker+
+    # ends TKSA with the computer listening, +byte_received+ ends ACPTR,
+    # and +release+ ends UNTALK and UNLISTEN.
+    IEEELines = Data.define(:timer, :attention, :byte_sent, :release_attention, :listen_to_talker, :byte_received,
+                            :release) do
+      def run_steps(steps, bus)
+        value = 0
+        steps.each { |step| value = step.act_on(bus) }
+        value
+      end
+    end
+
+    # Where a KERNAL keeps the eight IEEE-488 bus primitives, which are
+    # internal routines, not jump table entries, the ZeroPage of its file
+    # variables, and the steps it takes on the bus's lines (IEEELines).
+    # Each ROM set has its own.
     #
-    # The ROM drives the bus's control lines from three chips: ATN from VIA
-    # PB2 and NRFD from PB1 at $E840, NDAC from PIA 2's CA2 and DAV from its
-    # CB2, through the control registers at $E821 and $E823, which the ROM
-    # writes $34 to pull a line low and $3C to let it go, and the data lines
-    # from PIA 2's port B at $E822. The steps below leave the lines as each
-    # primitive leaves them.
+    # On a PET, TALK and LISTEN take no device number in A: they send $40
+    # or $20 ORed with FA. UNTALK and UNLISTEN send $5F and $3F through the
+    # same code, and SECOND, TKSA, UNTALK and UNLISTEN end by letting go of
+    # ATN themselves. LOAD and SAVE run in the ROM, through the primitives.
+    # +overwrites_device+ says UNTALK and UNLISTEN store their command in
+    # FA before they send it. +device_in_a+ says TALK and LISTEN take the
+    # device in A, as the CBM-II's do, where a PET's ignore A and read FA.
     IEEELayout = Data.define(:talk, :listen, :second, :tksa, :ciout, :untalk, :unlisten, :acptr, :overwrites_device,
-                             :zero_page) do
-      # The KERNAL is mapped unless an 8096's board lies over it.
+                             :device_in_a, :zero_page, :lines) do
+      # The KERNAL is mapped unless something lies over it.
       def kernal_mapped?(bus) = bus.kernal_mapped?
 
-      # Starts VIA timer 1, which times out the handshake of each byte.
+      # Starts the timer that times out the handshake of each byte.
       def time_serial_byte(bus, _timer_high)
-        bus.poke(0xe845, 0xff)
+        lines.run_steps(lines.timer, bus)
       end
 
-      # TALK and LISTEN: NRFD and NDAC let go, then ATN pulled low.
+      # TALK and LISTEN: the handshake lines let go, then ATN pulled low.
       def attention(bus)
-        bus.poke(0xe840, bus.peek(0xe840) | 0x02)
-        bus.poke(0xe821, 0x3c)
-        bus.poke(0xe840, bus.peek(0xe840) & 0xfb)
+        lines.run_steps(lines.attention, bus)
       end
 
       # The end of a byte sent: DAV and the data lines let go.
       def byte_sent(bus)
-        bus.poke(0xe823, 0x3c)
-        bus.poke(0xe822, 0xff)
+        lines.run_steps(lines.byte_sent, bus)
       end
 
       # The end of SECOND, TKSA, UNTALK and UNLISTEN: ATN let go. Returns
       # the value written, which the ROM leaves in A.
       def release_attention(bus)
-        value = bus.peek(0xe840) | 0x04
-        bus.poke(0xe840, value)
-        value
+        lines.run_steps(lines.release_attention, bus)
       end
 
-      # TKSA and ACPTR end listening: NRFD and NDAC pulled low.
+      # TKSA ends listening: NRFD and NDAC pulled low.
       def listen_to_talker(bus)
-        bus.poke(0xe840, bus.peek(0xe840) & 0xfd)
-        bus.poke(0xe821, 0x34)
+        lines.run_steps(lines.listen_to_talker, bus)
+      end
+
+      # ACPTR ends listening as well.
+      def byte_received(bus)
+        lines.run_steps(lines.byte_received, bus)
       end
 
       # The end of UNTALK and UNLISTEN, which address the bus as TALK and
-      # LISTEN do, send their command and let ATN go.
+      # LISTEN do, send their command and let ATN go. Returns the value
+      # the ROM leaves in A.
       def release_serial_lines(bus)
-        attention(bus)
-        byte_sent(bus)
-        release_attention(bus)
+        lines.run_steps(lines.release, bus)
       end
     end
 
+    # A PET drives the bus's control lines from three chips: ATN from VIA
+    # PB2 and NRFD from PB1 at $E840, NDAC from PIA 2's CA2 and DAV from its
+    # CB2, through the control registers at $E821 and $E823, which the ROM
+    # writes $34 to pull a line low and $3C to let it go, and the data lines
+    # from PIA 2's port B at $E822. Each handshake times out on VIA timer 1,
+    # which the ROM starts with a write of $FF to $E845. The steps leave the
+    # lines as each primitive leaves them.
+    PET_ATTENTION = [
+      IEEELineStep.new(address: 0xe840, keep: 0xff, set: 0x02),
+      IEEELineStep.new(address: 0xe821, keep: 0, set: 0x3c),
+      IEEELineStep.new(address: 0xe840, keep: 0xfb, set: 0)
+    ].freeze
+    PET_BYTE_SENT = [
+      IEEELineStep.new(address: 0xe823, keep: 0, set: 0x3c),
+      IEEELineStep.new(address: 0xe822, keep: 0, set: 0xff)
+    ].freeze
+    PET_RELEASE_ATTENTION = [IEEELineStep.new(address: 0xe840, keep: 0xff, set: 0x04)].freeze
+    PET_LISTEN = [IEEELineStep.new(address: 0xe840, keep: 0xfd, set: 0),
+                  IEEELineStep.new(address: 0xe821, keep: 0, set: 0x34)].freeze
+    PET_LINES = IEEELines.new(
+      timer: [IEEELineStep.new(address: 0xe845, keep: 0, set: 0xff)].freeze,
+      attention: PET_ATTENTION, byte_sent: PET_BYTE_SENT, release_attention: PET_RELEASE_ATTENTION,
+      listen_to_talker: PET_LISTEN, byte_received: PET_LISTEN,
+      release: (PET_ATTENTION + PET_BYTE_SENT + PET_RELEASE_ATTENTION).freeze
+    )
+
     # The file variables of the BASIC 2 and BASIC 4 KERNALs, which keep
     # them at the same addresses. SAVE copies STAL at $FB to SAL at $C7 and
     # walks SAL up to EAL at $C9. LOAD keeps no MEMUSS: it stores each byte
@@ -90,24 +142,24 @@ module Badline
     # LISTEN without a secondary address.
     PET_BASIC1_LAYOUT = IEEELayout.new(
       talk: 0xf0b6, listen: 0xf0ba, second: 0xf12c, tksa: 0xf15b,
-      ciout: 0xf167, untalk: 0xf17a, unlisten: 0xf17e, acptr: 0xf187, overwrites_device: true,
-      zero_page: PET_BASIC1_ZERO_PAGE
+      ciout: 0xf167, untalk: 0xf17a, unlisten: 0xf17e, acptr: 0xf187, overwrites_device: true, device_in_a: false,
+      zero_page: PET_BASIC1_ZERO_PAGE, lines: PET_LINES
     )
 
     # BASIC 2, 901465-03. Its LOAD sends the secondary address after TALK
     # with SECOND, not TKSA.
     PET_BASIC2_LAYOUT = IEEELayout.new(
       talk: 0xf0b6, listen: 0xf0ba, second: 0xf128, tksa: 0xf164,
-      ciout: 0xf16f, untalk: 0xf17f, unlisten: 0xf183, acptr: 0xf18c, overwrites_device: false,
-      zero_page: PET_ZERO_PAGE
+      ciout: 0xf16f, untalk: 0xf17f, unlisten: 0xf183, acptr: 0xf18c, overwrites_device: false, device_in_a: false,
+      zero_page: PET_ZERO_PAGE, lines: PET_LINES
     )
 
     # BASIC 4, 901465-22. LISTEN at $F0D5 is the operand of the BIT
     # instruction that skips it on the way from TALK.
     PET_BASIC4_LAYOUT = IEEELayout.new(
       talk: 0xf0d2, listen: 0xf0d5, second: 0xf143, tksa: 0xf193,
-      ciout: 0xf19e, untalk: 0xf1ae, unlisten: 0xf1b9, acptr: 0xf1c0, overwrites_device: false,
-      zero_page: PET_ZERO_PAGE
+      ciout: 0xf19e, untalk: 0xf1ae, unlisten: 0xf1b9, acptr: 0xf1c0, overwrites_device: false, device_in_a: false,
+      zero_page: PET_ZERO_PAGE, lines: PET_LINES
     )
   end
 end