badline 0.16.1 → 0.18.0

data/lib/badline/frontend/pet_keyboard.rb

@@ -12,16 +12,28 @@ 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.
+    #
+    # While the SuperPET shows its APL characters the keys go by position
+    # instead (#positional=): a key that types a character presses the PET
+    # key its unshifted character is on, and the PET's SHIFT follows the
+    # host's, so a key types the APL symbol on the SuperPET's keycap in the
+    # same place, shifted or not.
+    #
+    # 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
@@ -29,8 +41,12 @@ module Badline
         @right_alt = false
         @forced = -1
         @forced_shift = false
+        @positional = false
       end
 
+      # Whether the keys go by position, for the SuperPET's APL characters.
+      attr_writer :positional
+
       def key(scancode, down)
         if [LSHIFT, RSHIFT].include?(scancode)
           shift_key(scancode, down)
@@ -43,6 +59,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 +80,10 @@ 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 = if alt? then shifted_key(scancode)
+                     elsif @positional then positional_key(scancode)
+                     else layout_key(scancode, shifted?)
+                     end
         return if key == :none
 
         unless shift == :host
@@ -99,10 +123,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)
@@ -110,14 +141,21 @@ module Badline
         [key, :on]
       end
 
-      def shifted? = @left_shift || @right_shift
+      # The PET key for the scancode by position: the one its unshifted
+      # character is on, with the host's SHIFT.
+      def positional_key(scancode)
+        key, shift = Keys.pet_key(scancode, false, @layout)
+        return [key, shift] if key == :none || !Keys::US_CHARACTERS.key?(scancode)
 
-      def alt? = @left_alt || @right_alt
+        [key, :host]
+      end
+
+      def shifted? = @left_shift || @right_shift
 
       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/screen.rb

@@ -15,7 +15,7 @@ module Badline
     # least MIN_WIDTH window pixels wide, and at least as high as PAL's C64
     # crop, 272 lines, so a C64 shows in the same window whatever its
     # region. A crop with fewer lines or pixels sits in the middle of the
-    # texture, between black bands. The VIC-20's 284 by 284 crop and the
+    # texture, between black bands. The PAL VIC-20's 284 by 284 crop and the
     # TED's 384 by 288 fill their own.
     #
     # With `frame_lines`, the crop's lines run on past the frame's last

data/lib/badline/frontend/screens.rb

@@ -10,6 +10,10 @@ module Badline
     # On the C128, #follow switches to the screen the machine prints to
     # (C128#active_screen) each time it moves there, and #show_vdc's choice
     # holds until the next move.
+    #
+    # The KIM-1 has no video chip, and shows its panel (KIM1Panel), or with
+    # its TTY/KB jumper fitted its teletype's page (TeletypePane), which
+    # #follow brings up to the machine each frame.
     class Screens
       # The frames a move holds before #follow takes it. The C128 KERNAL's
       # reset clears the 80 column screen with the editor on it for over a
@@ -18,8 +22,17 @@ module Badline
 
       attr_reader :screen
 
+      # The KIM-1's panel, the picture a KIM-1 shows.
+      attr_reader :kim1_panel
+
+      # The KIM-1's teletype's page, which it shows with the jumper fitted.
+      attr_reader :teletype_pane
+
       def initialize(computer)
         @computer = computer
+        @kim1_panel = KIM1Panel.new
+        @teletype_pane = TeletypePane.new
+        @built_tty = false
         @vdc_shown = false
         @vdc_shape = []
         forget_screen
@@ -31,6 +44,8 @@ module Badline
       # Shows another machine's video chip, once #build builds its screen.
       def computer=(computer)
         @computer = computer
+        @kim1_panel = KIM1Panel.new
+        @teletype_pane = TeletypePane.new
         @vdc_shown = false
         forget_screen
       end
@@ -38,6 +53,7 @@ module Badline
       # Shows the screen a C128 has moved its output to once the move has
       # held for FOLLOW_FRAMES calls, one a frame. #build then builds it.
       def follow
+        return follow_kim1 if @computer.family == :kim1
         return unless @computer.family == :c128
 
         vdc = @computer.active_screen == :vdc
@@ -60,11 +76,17 @@ module Badline
 
       # Whether the screen was built for the other chip, or the VDC's
       # display has changed size or crop since the screen was built for it.
-      def stale? = @built_vdc != @vdc_shown || (@vdc_shown && vdc_shape(@computer.vdc) != @vdc_shape)
+      def stale?
+        return @built_tty != @computer.tty? if @computer.family == :kim1
+
+        @built_vdc != @vdc_shown || (@vdc_shown && vdc_shape(@computer.vdc) != @vdc_shape)
+      end
 
       def build
         @built_vdc = @vdc_shown
-        if @vdc_shown
+        if @computer.family == :kim1
+          build_kim1
+        elsif @vdc_shown
           vdc = @computer.vdc
           @vdc_shape = vdc_shape(vdc)
           @screen = Screen.new(vdc, vdc.crop, dots: 2)
@@ -78,6 +100,22 @@ module Badline
 
       private
 
+      # The panel and the teletype's page both follow the machine, the
+      # LEDs' brightness and the page's lines going on behind the other.
+      def follow_kim1
+        @kim1_panel.follow(@computer)
+        @teletype_pane.follow(@computer)
+      end
+
+      def build_kim1
+        @built_tty = @computer.tty?
+        @screen = if @built_tty
+                    Screen.new(@teletype_pane, @teletype_pane.crop)
+                  else
+                    Screen.new(@kim1_panel, @kim1_panel.crop)
+                  end
+      end
+
       # The machine's output counts as on the VIC-IIe's screen, the one
       # shown.
       def forget_screen

data/lib/badline/frontend/teletype_pane.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Badline
+  module Frontend
+    # The KIM-1's teletype as the window shows it with the TTY/KB jumper
+    # fitted: a page of COLUMNS by ROWS characters in the character ROM's
+    # font, printed as the teletype prints (KIM1::Teletype#output), with a
+    # line of the host keys that type what the window's keys don't. RETURN
+    # goes back to the line's start, LINE FEED down a line, the page
+    # scrolling up from the last, and a line full at COLUMNS goes on to the
+    # next. It answers what a Screen reads of a video chip, as KIM1Panel
+    # does.
+    class TeletypePane
+      COLUMNS = 72
+      ROWS = 24
+      LINE = 10
+      MARGIN = 8
+      TOP = 22
+
+      WIDTH = (COLUMNS * 8) + (2 * MARGIN)
+      HEIGHT = 272
+
+      PAPER = 0
+      INK = 1
+      HINT = 2
+      CURSOR = 3
+      PALETTE = [0xf2ecd8, 0x202020, 0x6c6858, 0x9c9480].freeze
+
+      HINTS = "BACKSPACE: RUBOUT  DOWN: LINE FEED  F9: MENU"
+
+      attr_reader :display, :dirty_lines
+
+      def initialize
+        @display = Array.new(WIDTH * HEIGHT, PAPER)
+        @dirty_lines = Array.new(HEIGHT, true)
+        @font = ROM.read("character.rom")
+        @page = Array.new(ROWS) { Array.new(COLUMNS, 0x20) }
+        @column = 0
+        @row = 0
+        @printed = 0
+        @baud = 0
+        draw_cursor(CURSOR)
+      end
+
+      def width = WIDTH
+
+      def height = HEIGHT
+
+      def palette = PALETTE
+
+      def crop = [0, 0, WIDTH, HEIGHT]
+
+      def clear_dirty_lines!
+        @dirty_lines.map! { false }
+      end
+
+      # The characters on the page, a line each, without trailing spaces.
+      def lines = @page.map { |row| row.map(&:chr).join.rstrip }
+
+      # Prints what the KIM-1 `computer`'s teletype has printed since the
+      # last call.
+      def follow(computer)
+        teletype = computer.teletype
+        title(teletype.baud) if teletype.baud != @baud
+        output = teletype.output
+        return if output.size == @printed
+
+        draw_cursor(PAPER)
+        output[@printed, output.size - @printed].bytes.each { |byte| print_byte(byte) }
+        @printed = output.size
+        draw_cursor(CURSOR)
+      end
+
+      private
+
+      def title(baud)
+        @baud = baud
+        box(0, 0, WIDTH, TOP, PAPER)
+        text(MARGIN, 6, "KIM-1 TELETYPE, #{baud} BAUD", HINT)
+        text(WIDTH - MARGIN - (HINTS.size * 8), 6, HINTS, HINT)
+      end
+
+      def print_byte(byte)
+        case byte
+        when 0x0d then @column = 0
+        when 0x0a then line_feed
+        when 0x20..0x7e then print_character(byte)
+        end
+      end
+
+      def print_character(byte)
+        if @column == COLUMNS
+          @column = 0
+          line_feed
+        end
+        @page[@row][@column] = byte
+        glyph(MARGIN + (@column * 8), TOP + (@row * LINE), byte, INK)
+        @column += 1
+      end
+
+      def line_feed
+        if @row < ROWS - 1
+          @row += 1
+          return
+        end
+
+        @page.shift
+        @page << Array.new(COLUMNS, 0x20)
+        redraw_page
+      end
+
+      def redraw_page
+        box(0, TOP, WIDTH, ROWS * LINE, PAPER)
+        @page.each_with_index do |characters, row|
+          characters.each_with_index do |byte, column|
+            glyph(MARGIN + (column * 8), TOP + (row * LINE), byte, INK) unless byte == 0x20
+          end
+        end
+      end
+
+      def draw_cursor(color)
+        column = [@column, COLUMNS - 1].min
+        box(MARGIN + (column * 8), TOP + (@row * LINE) + 8, 8, 1, color)
+      end
+
+      def box(left, top, width, height, color)
+        height.times do |row|
+          line = top + row
+          @display.fill(color, (line * WIDTH) + left, width)
+          @dirty_lines[line] = true
+        end
+      end
+
+      def text(left, top, string, color)
+        string.bytes.each_with_index { |byte, index| glyph(left + (index * 8), top, byte, color) }
+      end
+
+      # Draws the glyph for the ASCII `byte` over a cleared cell.
+      def glyph(left, top, byte, color)
+        code = Painter::SCREEN_CODES[byte & 0x7f]
+        8.times do |row|
+          bits = @font[0x800 + (code * 8) + row]
+          line = top + row
+          8.times do |dot|
+            @display[(line * WIDTH) + left + dot] = bits.anybits?(0x80 >> dot) ? color : PAPER
+          end
+          @dirty_lines[line] = true
+        end
+      end
+    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,28 @@ 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)) ||
+        return !kim1_key(name).empty? if family == :kim1
+
+        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,10 +70,18 @@ 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
 
+      # The KIM-1's key for a name such as go, a or plus, as
+      # KIM1::Panel::KEYS names it, with st and rs, or an empty string.
+      def self.kim1_key(name)
+        key = name == "plus" ? "+" : name.upcase
+        KIM1::Panel::KEYS.include?(key) || %w[ST RS].include?(key) ? key : ""
+      end
+
       # The direction of joy1-NAME or joy2-NAME, such as up or fire.
       def self.joystick_direction(name)
         return nil unless name.start_with?("joy1-") || name.start_with?("joy2-")
@@ -145,7 +159,7 @@ module Badline
       def perform(computer, event)
         case event.action
         when "key" then press(computer, event)
-        when "type" then computer.type_text(event.argument.gsub("\\n", "\r").gsub("\\r", "\r"))
+        when "type" then type(computer, event.argument)
         when "insert" then insert(computer, event.argument)
         when "eject" then eject(computer, event.argument)
         when "reset" then computer.reset!
@@ -153,8 +167,15 @@ module Badline
         end
       end
 
+      # Types the text, which on the KIM-1 goes to its teletype, or with
+      # none presses the keys it names (KIM1#type_text).
+      def type(computer, text)
+        computer.type_text(text.gsub("\\n", "\r").gsub("\\r", "\r"))
+      end
+
       def press(computer, event)
         name = event.argument
+        return press_kim1(computer, event) if computer.family == :kim1
         return lock(computer, name) if LOCKS.include?(name)
 
         if name == "restore"
@@ -171,6 +192,17 @@ module Badline
         hold(event)
       end
 
+      # ST and RS act as they go down, and the KIM-1's other keys are held.
+      def press_kim1(computer, event)
+        case (key = Timeline.kim1_key(event.argument))
+        when "ST" then computer.press_stop
+        when "RS" then computer.press_reset
+        else
+          computer.press_key(key)
+          hold(event)
+        end
+      end
+
       # CAPS LOCK and 40/80 DISPLAY lock: a push puts one down if it was up,
       # and up if it was down.
       def lock(computer, name)
@@ -194,6 +226,8 @@ module Badline
       def release(computer, event)
         return computer.release_cartridge_button if event.action == "freeze" && computer.family == :c64
 
+        return computer.release_key if computer.family == :kim1
+
         name = event.argument
         return computer.release_restore if name == "restore"
 
@@ -228,9 +262,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 == :kim1 || (family == :cbm2 && what != "disk")
+
+        (what != "cartridge" || !%i[vic20 pet].include?(family)) && inserted?(computer, what)
       end
 
       def inserted?(computer, what)

data/lib/badline/frontend.rb

@@ -4,6 +4,8 @@ require "badline/sdl"
 require "badline/frontend/boot"
 require "badline/frontend/frame_rate"
 require "badline/frontend/screen"
+require "badline/frontend/kim1_panel"
+require "badline/frontend/teletype_pane"
 require "badline/frontend/screens"
 require "badline/frontend/drive_led"
 require "badline/frontend/keys"
@@ -42,6 +44,7 @@ require "badline/frontend/menu/pause_menu"
 require "badline/frontend/menu/file_browser"
 require "badline/frontend/menu/confirmation"
 require "badline/frontend/menu/name_field"
+require "badline/frontend/menu/drive_types"
 require "badline/frontend/menu/menu_dialogs"
 require "badline/frontend/menu/menu_media"
 require "badline/frontend/menu/menu_ports"

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)