badline 0.2.1 → 0.4.0

data/lib/badline/storage/disk_image/bam.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    class DiskImage
+      # The block availability map: a free count and a bitmap for each
+      # track, with a set bit for each free sector. Each format says where
+      # a track's count and bitmap sit, which tracks the map covers and
+      # which of them hold the directory. Files are laid out as the DOS
+      # does, on the tracks nearest the directory first, below it before
+      # above, with the format's sector interleave within a track.
+      module Bam
+        # Whether the BAM has an entry for the block.
+        def bam_block?(track, sector)
+          bam_tracks.cover?(track) && sector.between?(0, sectors_in(track) - 1) &&
+            block?(*bam_bitmap(track).first(2)) && block?(*bam_count(track).first(2))
+        end
+
+        # Whether the BAM marks the block free. A block it has no entry for
+        # never is.
+        def block_free?(track, sector)
+          bam_block?(track, sector) && @bytes[bitmap_offset(track) + (sector / 8)][sector % 8] == 1
+        end
+
+        # The first free block past the one given, on its track and then
+        # the tracks above it, for B-A to report when the block is taken.
+        # Empty when there is none.
+        def next_free_block(track, sector)
+          bam_tracks.each do |candidate|
+            next if candidate < track || reserved_tracks.include?(candidate)
+
+            first = candidate == track ? sector + 1 : 0
+            free = (first...sectors_in(candidate)).find { |s| block_free?(candidate, s) }
+            return [candidate, free] if free
+          end
+          []
+        end
+
+        private
+
+        def bitmap_offset(track)
+          block_track, block_sector, offset = bam_bitmap(track)
+          sector_offset(block_track, block_sector) + offset
+        end
+
+        def count_offset(track)
+          block_track, block_sector, offset = bam_count(track)
+          sector_offset(block_track, block_sector) + offset
+        end
+
+        # Marks the block free or in use, and moves the track's free count
+        # with it. A block the BAM doesn't cover is left alone.
+        def mark(track, sector, free)
+          return if !bam_block?(track, sector) || block_free?(track, sector) == free
+
+          byte = bitmap_offset(track) + (sector / 8)
+          bit = 1 << (sector % 8)
+          @bytes[byte] = free ? @bytes[byte] | bit : @bytes[byte] & ~bit
+          @bytes[count_offset(track)] = (@bytes[count_offset(track)] + (free ? 1 : -1)) & 0xff
+        end
+
+        # Takes blocks for a chain, each placed after the one before it.
+        # Raises DISK FULL when the disk runs out.
+        def allocate_chain(count)
+          block = nil
+          Array.new(count) do
+            block = next_block(*block) || raise(WriteError, WriteError::DISK_FULL)
+            mark(*block, false)
+            block
+          end
+        end
+
+        # A chain's first block goes on the free track nearest the
+        # directory. Each block after it goes the interleave further round
+        # the same track, or on the next track out once that one is full.
+        def next_block(track = nil, sector = nil)
+          candidates = track ? [track, *tracks_after(track)] : allocation_order
+          candidates.each do |candidate|
+            free = free_sector(candidate, candidate == track ? sector + interleave : 0)
+            return [candidate, free] if free
+          end
+          nil
+        end
+
+        def free_sector(track, first)
+          count = sectors_in(track)
+          (0...count).map { |i| (first + i) % count }.find { |s| block_free?(track, s) }
+        end
+
+        # The tracks a file can use, nearest the directory first, the one
+        # below before the one above.
+        def allocation_order
+          (bam_tracks.to_a - reserved_tracks).sort_by do |track|
+            [(track - directory_track).abs, track > directory_track ? 1 : 0]
+          end
+        end
+
+        # The tracks further from the directory on the same side, then the
+        # rest.
+        def tracks_after(track)
+          distance = (track - directory_track).abs
+          below = track < directory_track
+          further, rest = (allocation_order - [track]).partition do |candidate|
+            (candidate < directory_track) == below && (candidate - directory_track).abs > distance
+          end
+          further + rest
+        end
+      end
+    end
+  end
+end

data/lib/badline/storage/disk_image/directory.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    class DiskImage
+      # Directory entries as writes make them: a closed file's type, its
+      # first block and its length in blocks, under a name padded with
+      # shifted spaces. The directory grows a block at a time on its track.
+      module Directory
+        CLOSED = 0x80
+        NAME_LENGTH = 16
+
+        private
+
+        def entry_named(name)
+          wanted = decode_name(encode_name(name))
+          entries.find { |entry| entry[:name] == wanted }
+        end
+
+        def encode_name(name)
+          bytes = name.upcase.bytes.first(NAME_LENGTH)
+          bytes + Array.new(NAME_LENGTH - bytes.length, NAME_PADDING)
+        end
+
+        # The new chain is written before the old one is freed, so a
+        # replace that runs out of room leaves the old file.
+        def rewrite(entry, bytes, type)
+          blocks = write_chain(bytes)
+          free_chain(entry)
+          write_entry(entry[:offset], type, blocks)
+        end
+
+        def add_file(name, bytes, type)
+          blocks = write_chain(bytes)
+          offset = free_entry_offset
+          @bytes[offset + 5, NAME_LENGTH] = encode_name(name)
+          write_entry(offset, type, blocks)
+        end
+
+        # The slot's first two bytes link the directory block, so they
+        # stay. The name stays too, and what follows it up to the block
+        # count is cleared.
+        def write_entry(offset, type, blocks)
+          @bytes[offset + 2] = CLOSED | FILETYPES.fetch(type)
+          @bytes[offset + 3, 2] = blocks.first
+          @bytes[offset + 21, 9] = Array.new(9, 0)
+          @bytes[offset + 30, 2] = [blocks.length & 0xff, blocks.length >> 8]
+        end
+
+        # The first free slot in the directory, which grows by a block on
+        # the directory track when every slot is taken.
+        def free_entry_offset
+          last = nil
+          each_sector(directory_track, directory_sector) do |data, track, sector|
+            slot = (0...ENTRIES_PER_SECTOR).find { |i| data[(i * ENTRY_SIZE) + 2].zero? }
+            return sector_offset(track, sector) + (slot * ENTRY_SIZE) if slot
+
+            last = [track, sector]
+          end
+          sector_offset(*extend_directory(*last))
+        end
+
+        # A new directory block goes the directory interleave on from the
+        # last one. A full directory track fails as DISK FULL.
+        def extend_directory(track, sector)
+          count = sectors_in(directory_track)
+          free = (0...count).map { |i| (sector + directory_interleave + i) % count }
+                            .find { |s| block_free?(directory_track, s) }
+          raise WriteError, WriteError::DISK_FULL unless free
+
+          mark(directory_track, free, false)
+          @bytes[sector_offset(track, sector), 2] = [directory_track, free]
+          put_sector(directory_track, free, [0, 0xff])
+          [directory_track, free]
+        end
+      end
+    end
+  end
+end

data/lib/badline/storage/disk_image/writing.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Badline
+  module Storage
+    class DiskImage
+      # Writes to the image: files with their chains, directory entries and
+      # BAM, raw blocks, and BAM changes. Each write goes back to the host
+      # file at once. A write the disk refuses raises WriteError and leaves
+      # the image as it was, and so does one to a read-only image or one
+      # the host can't store, which fail as a write-protected disk does.
+      module Writing
+        # Whether the disk takes writes: the image wasn't opened read-only
+        # and the host file takes them.
+        def writable? = !read_only? && ::File.writable?(@path)
+
+        # Writes a new file, or with `replace` writes over the one of the
+        # same name in its directory entry. A name already on the disk
+        # fails as FILE EXISTS otherwise.
+        def write_file(name, bytes, type: :prg, replace: false)
+          existing = entry_named(name)
+          raise WriteError, WriteError::FILE_EXISTS if existing && !replace
+
+          update_image do
+            existing ? rewrite(existing, bytes, type) : add_file(name, bytes, type)
+          end
+        end
+
+        # Adds the bytes to the end of a file, which keeps its type and its
+        # directory entry.
+        def append_file(name, bytes, type: nil)
+          entry = find_entry(name, type)
+          raise WriteError, WriteError::FILE_NOT_FOUND unless entry
+
+          update_image { rewrite(entry, read_chain(entry[:track], entry[:sector]) + bytes, entry[:type]) }
+        end
+
+        # Scratches the files matching the pattern, of any type, except
+        # locked ones, and frees their blocks. Returns how many it
+        # scratched.
+        def scratch(name)
+          pattern = Storage.matcher(name)
+          files = entries.select { |entry| !entry[:locked] && pattern.match?(entry[:name]) }
+          return 0 if files.empty?
+
+          update_image do
+            files.each do |entry|
+              free_chain(entry)
+              @bytes[entry[:offset] + 2] = 0
+            end
+          end
+          files.length
+        end
+
+        # Raw block access for the DOS `U2` command. A block that the error
+        # table marks bad reads cleanly once written.
+        def write_block(track, sector, data)
+          update_image { put_sector(track, sector, data) } if block?(track, sector)
+        end
+
+        # Marks a block in use, as B-A does.
+        def allocate_block(track, sector) = update_image { mark(track, sector, false) }
+
+        # Marks a block free, as B-F does.
+        def free_block(track, sector) = update_image { mark(track, sector, true) }
+
+        private
+
+        def update_image
+          raise WriteError, WriteError::WRITE_PROTECT_ON unless writable?
+
+          saved = [@bytes.dup, @errors&.dup]
+          begin
+            yield
+            ::File.binwrite(@path, (@bytes + @errors.to_a).pack("C*"))
+          rescue WriteError, SystemCallError => e
+            @bytes, @errors = saved
+            raise e.is_a?(WriteError) ? e : WriteError.new(WriteError::WRITE_PROTECT_ON)
+          ensure
+            @entries = nil
+          end
+        end
+
+        # Every block links the next, and the last one holds the index of
+        # its last byte in place of a link. An empty file still takes one.
+        def write_chain(bytes)
+          chunks = bytes.each_slice(SECTOR_SIZE - 2).to_a
+          chunks = [[]] if chunks.empty?
+          blocks = allocate_chain(chunks.length)
+          blocks.each_with_index do |block, i|
+            link = blocks[i + 1] || [0, chunks[i].length + 1]
+            put_sector(*block, link + chunks[i])
+          end
+          blocks
+        end
+
+        def free_chain(entry)
+          each_sector(entry[:track], entry[:sector]) do |_data, track, sector|
+            mark(track, sector, true)
+          end
+        end
+
+        def put_sector(track, sector, data)
+          block = data.first(SECTOR_SIZE)
+          @bytes[sector_offset(track, sector), SECTOR_SIZE] = block + Array.new(SECTOR_SIZE - block.length, 0)
+          @errors[track_offset(track) + sector] = 1 if @errors
+        end
+      end
+    end
+  end
+end

data/lib/badline/storage/disk_image.rb

@@ -1,8 +1,20 @@
 # frozen_string_literal: true
 
+require "badline/storage/disk_image/bam"
+require "badline/storage/disk_image/directory"
+require "badline/storage/disk_image/writing"
+
 module Badline
   module Storage
+    # A disk image served as a drive. It reads files and blocks, and
+    # writes them back to the host file through Writing. One opened with
+    # `read_only` is a write-protected disk, and the host file is never
+    # written.
     class DiskImage
+      include Bam
+      include Directory
+      include Writing
+
       SECTOR_SIZE = 256
       ENTRY_SIZE = 32
       ENTRIES_PER_SECTOR = 8
@@ -13,11 +25,16 @@ module Badline
       # the read, write and ID errors, 74 is DRIVE NOT READY.
       DOS_ERRORS = (2..11).to_h { |code| [code, code + 18] }.merge(15 => 74).freeze
 
-      def initialize(path)
+      def initialize(path, read_only: false)
+        @path = path
+        @read_only = read_only
         @bytes = File.binread(path).bytes
         @errors = split_error_table
       end
 
+      # Whether the image was opened write-protected.
+      def read_only? = @read_only
+
       # A LOAD reads only PRG files. An OPEN names the type it wants, or
       # takes the first file of any type with a nil `type`.
       def read_file(name, type: :prg)
@@ -42,6 +59,28 @@ module Badline
         nil
       end
 
+      # The track and sector a file's chain starts at.
+      def first_block(name, type: :prg)
+        entry = find_entry(name, type)
+        [entry[:track], entry[:sector]] if entry
+      end
+
+      # The bytes of the chain that starts at the block, or nil when the
+      # block is outside the image's geometry.
+      def read_file_at(track, sector)
+        read_chain(track, sector) if block?(track, sector)
+      end
+
+      # The track and sector of the last block in a file's chain.
+      def last_block(name, type: :prg)
+        entry = find_entry(name, type)
+        return unless entry
+
+        last = nil
+        each_sector(entry[:track], entry[:sector]) { |_data, track, sector| last = [track, sector] }
+        last
+      end
+
       # Raw block access for the DOS `U1` command. Returns nil for blocks
       # outside the image's geometry.
       def read_block(track, sector)
@@ -101,12 +140,16 @@ module Badline
       def entries
         @entries ||= begin
           list = []
-          each_sector(directory_track, directory_sector) { |data| list.concat(parse_entries(data)) }
+          each_sector(directory_track, directory_sector) do |data, track, sector|
+            list.concat(parse_entries(data, sector_offset(track, sector)))
+          end
           list
         end
       end
 
-      def parse_entries(data)
+      # Each entry keeps the offset of its slot in the image, where a write
+      # updates it.
+      def parse_entries(data, offset)
         (0...ENTRIES_PER_SECTOR).filter_map do |i|
           entry = data[i * ENTRY_SIZE, ENTRY_SIZE]
           type = FILETYPES.key(entry[2] & 0x07)
@@ -115,7 +158,9 @@ module Badline
           { name: decode_name(entry[5, 16]),
             type:,
             track: entry[3],
-            sector: entry[4] }
+            sector: entry[4],
+            locked: entry[2].anybits?(0x40),
+            offset: offset + (i * ENTRY_SIZE) }
         end
       end
 

data/lib/badline/storage/host_directory.rb

@@ -3,9 +3,12 @@
 module Badline
   module Storage
     # A host directory served as a drive: .prg files by their host name,
-    # .p00 and .t64 entries by their embedded names. A host file that can't
-    # be read is left out, and a failed write reports false.
+    # .p00 and .t64 entries by their embedded names. A .prg the host can't
+    # read is still listed but fails to read, a .p00 or .t64 whose names
+    # can't be read is left out, and a failed write reports false.
     class HostDirectory
+      NO_SYNC = 21
+
       def initialize(path)
         @path = path
       end
@@ -15,10 +18,20 @@ module Badline
         return unless entry
 
         archive = entry[:archive]
-        archive ? archive.read_file(entry[:name]) : file_bytes(entry[:file])
+        archive ? archive.read_file(entry[:name]) : file_bytes(entry[:file]) || []
+      end
+
+      # A listed file the host can't read fails before its first byte, as
+      # a 1541 does on a disk it finds no sync on.
+      def read_error(name, **)
+        entry = find(name)
+        return unless entry && entry[:file] && !file_bytes(entry[:file])
+
+        { error: NO_SYNC, track: 0, sector: 0, offset: 0 }
       end
 
-      def write_file(name, bytes)
+      # Writes a .prg of any file type, over the one of the same name.
+      def write_file(name, bytes, **)
         host_name = "#{name.downcase.tr('/', '_')}.prg"
         File.binwrite(File.join(@path, host_name), bytes.pack("C*"))
         true

data/lib/badline/storage/sid_file.rb

@@ -13,6 +13,9 @@ module Badline
 
       V1_HEADER_SIZE = 0x76
 
+      # BASIC's RUN handler, where a BASIC tune starts.
+      BASIC_RUN = 0xa871
+
       # The 6502 stub that starts a tune: call init with the song number,
       # point the KERNAL's IRQ vector at a raster handler that calls play,
       # and spin. Both calls are wrapped in the `$01` save, bank and restore
@@ -171,6 +174,10 @@ module Badline
       # code.
       def mus? = psid? && flags[0] == 1
 
+      # Flag bit 1 marks an RSID body as a BASIC program, which RUN starts
+      # instead of a call to init.
+      def basic? = !psid? && flags[1] == 1
+
       # A v3 header can place a second SID at `$Dxx0` and a v4 header a
       # third, each given by its middle byte: even, and in `$d420-$d7e0` or
       # `$de00-$dfe0`. Anything else means the SID isn't there.
@@ -185,16 +192,22 @@ module Badline
       # 10 the 8580, 11 either and 00 unknown. Only an 8580-only tune gets one.
       def sid_model = flags[4, 2] == 0b10 ? :mos8580 : :mos6581
 
+      # Flag bits 2-3 name the video standard the same way: 01 PAL, 10 NTSC,
+      # 11 either and 00 unknown. Only an NTSC-only tune gets NTSC.
+      def ntsc? = flags[2, 2] == 0b10
+
       # HVSC keys its song length database on the whole file, header and all.
       def md5 = @md5 ||= Digest::MD5.hexdigest(@bytes.pack("C*"))
 
       # The `$01` value a routine at `address` has to run under, following
       # libsidplayfp's iomap: RAM under BASIC from `$a000`, RAM under both
       # ROMs and no I/O for a routine in the I/O window itself, RAM under the
-      # KERNAL from `$e000`. An RSID tune banks itself and gets nil.
+      # KERNAL from `$e000`. A routine below `$a000` still gets BASIC banked
+      # out when the image reaches into it, as VSID does, since it may call
+      # into the part that lies there. An RSID tune banks itself and gets nil.
       def bank_for(address)
         return unless psid?
-        return 0x37 if address < 0xa000
+        return (under_basic? ? 0x36 : 0x37) if address < 0xa000
         return 0x36 if address < 0xd000
         return 0x34 if address < 0xe000
 
@@ -227,6 +240,23 @@ module Badline
         Driver.new(self, song: song.clamp(1, songs) - 1, base: driver_address).bytes
       end
 
+      # What a booted machine needs in RAM besides the image before
+      # `boot_command` starts the tune, as address => bytes. A BASIC tune
+      # gets the end of its program in VARTAB, as LOAD leaves it, and the
+      # song in the A, X and Y that SYS loads from `$030c-$030e`, where the
+      # tune reads it with PEEK(780).
+      def boot_memory(song: start_song)
+        return { driver_address => driver(song:) } unless basic?
+
+        { 0x2d => [low_byte(end_address), high_byte(end_address)],
+          0x030c => [song.clamp(1, songs) - 1] * 3 }
+      end
+
+      def boot_command = basic? ? "run\r" : "sys#{driver_address}\r"
+
+      # Where the CPU first lands once `boot_command` has started the tune.
+      def entry_address = basic? ? BASIC_RUN : driver_address
+
       private
 
       def truncated?
@@ -237,6 +267,10 @@ module Badline
         @body ||= @bytes[data_offset..] || []
       end
 
+      def under_basic?
+        load_address < 0xc000 && end_address > 0xa000
+      end
+
       # The tape buffer and the free block below the stack page, neither
       # of which BASIC touches.
       def candidates

data/lib/badline/storage.rb

@@ -16,6 +16,21 @@ module Badline
   module Storage
     FILE_TYPES = { "S" => :seq, "P" => :prg, "U" => :usr }.freeze
 
+    # A write the disk refuses, with the DOS error it fails with.
+    class WriteError < StandardError
+      WRITE_PROTECT_ON = 26
+      FILE_NOT_FOUND = 62
+      FILE_EXISTS = 63
+      DISK_FULL = 72
+
+      attr_reader :code
+
+      def initialize(code)
+        @code = code
+        super("DOS error #{code}")
+      end
+    end
+
     class << self
       # Folds shifted PETSCII letters to their ASCII equivalents.
       def ascii(bytes)
@@ -36,8 +51,10 @@ module Badline
       end
 
       # CBM-style filename pattern: "*" and "?" wildcards, case-insensitive.
+      # The DOS stops comparing at the first "*", so whatever follows it
+      # is ignored.
       def matcher(name)
-        escaped = Regexp.escape(name.downcase)
+        escaped = Regexp.escape(name.downcase.sub(/\*.*/m, "*"))
                         .gsub('\*', ".*")
                         .gsub('\?', ".")
         Regexp.new("\\A#{escaped}\\z")

data/lib/badline/time_of_day.rb

@@ -2,8 +2,10 @@
 
 module Badline
   class TimeOfDay
-    CLOCK_HZ = 985_248 # PAL only for now.
-    MAINS_HZ = 50      # The TOD pin is fed from the AC supply.
+    # The TOD pin is fed from the AC supply. A CIA passes its region's
+    # clock and mains frequency, and these are PAL's.
+    CLOCK_HZ = Region::PAL.clock_hz
+    MAINS_HZ = Region::PAL.mains_hz
 
     def initialize(clock_hz: CLOCK_HZ, mains_hz: MAINS_HZ)
       # The accumulator advances mains_hz per cycle, so a TOD pin pulse has
@@ -49,6 +51,13 @@ module Badline
       @latch[:hours]
     end
 
+    # The clock and alarm as stored, read without latching the clock.
+    def registers
+      [@clock[:tenths], @clock[:seconds], @clock[:minutes], @clock[:hours],
+       @alarm[:tenths], @alarm[:seconds], @alarm[:minutes], @alarm[:hours],
+       @stopped ? 1 : 0, @latch ? 1 : 0]
+    end
+
     def write(field, value, alarm:)
       # The frequency counter is held clear while the clock is stopped, and
       # starts counting again from the write to tenths that restarts it.

data/lib/badline/version.rb

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

data/lib/badline/via/control_lines.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Badline
+  class VIA
+    # One port's pair of control lines, CA1 and CA2 or CB1 and CB2, set up
+    # by a nibble of the peripheral control register, and their two
+    # interrupt flags. Bit 0 picks the active edge of C1, rising when set.
+    # Bits 3-1 pick the C2 mode:
+    #
+    #   000 input, falling edge    100 handshake output
+    #   001 independent, falling   101 pulse output
+    #   010 input, rising edge     110 low output
+    #   011 independent, rising    111 high output
+    #
+    # A port access clears both flags, but an independent input keeps C2's.
+    # In handshake mode C2 goes low on a port access and back high on the
+    # next active C1 edge. In pulse mode it goes low for the cycle after the
+    # access. Port A handshakes on reads and writes, port B on writes only.
+    class ControlLines
+      attr_reader :control, :c1_high, :c2_high
+
+      # The level driven on C2, high while it is an input.
+      attr_reader :c2_output
+
+      def initialize(interrupts, c1_flag:, c2_flag:, handshake_on_read:)
+        @interrupts = interrupts
+        @c1_flag = c1_flag
+        @c2_flag = c2_flag
+        @handshake_on_read = handshake_on_read
+        @c1_high = @c2_high = true
+        reset!
+      end
+
+      # Back to input mode with both handshake outputs released. The input
+      # levels carry over.
+      def reset!
+        @control = 0
+        @handshake_low = false
+        @pulse = 0
+        drive
+      end
+
+      def control=(nibble)
+        @control = nibble & 0x0f
+        drive
+      end
+
+      # Only the pulse output needs the clock.
+      def pulsing? = @pulse.positive?
+
+      def cycle!
+        @pulse -= 1
+        drive if @pulse.zero?
+      end
+
+      def active_c1_edge?(high) = high == @control.anybits?(0x01)
+
+      # A new C1 level. An active edge sets the flag and ends a handshake.
+      def c1=(high)
+        return if high == @c1_high
+
+        @c1_high = high
+        return unless active_c1_edge?(high)
+
+        @handshake_low = false
+        drive
+        @interrupts.set(@c1_flag)
+      end
+
+      # A new C2 level. An active edge sets the flag while C2 is an input.
+      def c2=(high)
+        return if high == @c2_high
+
+        @c2_high = high
+        @interrupts.set(@c2_flag) if @control.nobits?(0x08) && high == @control.anybits?(0x04)
+      end
+
+      # A read or write of the handshaking port register.
+      def access!(write)
+        @interrupts.clear(independent? ? @c1_flag : @c1_flag | @c2_flag)
+        return unless write || @handshake_on_read
+
+        case @control >> 1
+        when 4 then @handshake_low = true
+        when 5 then @pulse = 2
+        end
+        drive
+      end
+
+      private
+
+      def independent? = @control & 0x0a == 0x02
+
+      def drive
+        @c2_output = case @control >> 1
+                     when 4 then !@handshake_low
+                     when 5 then @pulse.zero?
+                     when 6 then false
+                     else true
+                     end
+      end
+    end
+  end
+end