n65 0.5.0 → 1.0.0

data/lib/n65/instruction.rb

@@ -1,153 +1,150 @@
+# frozen_string_literal: true
+
 require_relative 'opcodes'
 require_relative 'regexes'
 
 module N65
-
-  ####
-  ##  Represents a single 6502 Instruction
+  # Represents a single 6502 Instruction
   class Instruction
-    attr_reader :op, :arg, :mode, :hex, :description, :length, :cycle, :boundry_add, :flags, :address
+    attr_reader :op, :arg, :mode, :hex, :description, :length, :cycles, :boundry_add, :flags, :address
 
-    ##  Custom Exceptions
+    # Custom Exceptions
     class InvalidInstruction < StandardError; end
     class UnresolvedSymbols < StandardError; end
     class InvalidAddressingMode < StandardError; end
     class AddressOutOfRange < StandardError; end
     class ArgumentTooLarge < StandardError; end
 
-    ##  Include Regexes 
+    # Include Regexes
     include Regexes
 
-    AddressingModes = {
-      :relative => {
-        :example     => 'B** my_label',
-        :display     => '%s $%.4X',
-        :regex       => /$^/i,  #  Will never match this one
-        :regex_label => /^#{Branches}\s+#{Sym}$/
+    ADDRESSING_MODES = {
+      relative: {
+        example: 'B** my_label',
+        display: '%s $%.4X',
+        regex: /$^/i,
+        regex_label: /^#{Branches}\s+#{Sym}$/
       },
 
-      :immediate => { 
-        :example     => 'AAA #$FF',
-        :display     => '%s #$%.2X',
-        :regex       => /^#{Mnemonic}\s+#{Immediate}$/,
-        :regex_label => /^#{Mnemonic}\s+#(<|>)#{Sym}$/
+      immediate: {
+        example: 'AAA #$FF',
+        display: '%s #$%.2X',
+        regex: /^#{Mnemonic}\s+#{Immediate}$/,
+        regex_label: /^#{Mnemonic}\s+#(<|>)#{Sym}$/
       },
 
-      :implied => {
-        :example     => 'AAA',
-        :display     => '%s',
-        :regex       => /^#{Mnemonic}$/
+      implied: {
+        example: 'AAA',
+        display: '%s',
+        regex: /^#{Mnemonic}$/
       },
 
-      :zero_page => {
-        :example     => 'AAA $FF',
-        :display     => '%s $%.2X',
-        :regex       => /^#{Mnemonic}\s+#{Num8}$/,
-        :regex_label => /^#{Mnemonic}\s+#{Sym}\s+zp$/
+      zero_page: {
+        example: 'AAA $FF',
+        display: '%s $%.2X',
+        regex: /^#{Mnemonic}\s+#{Num8}$/,
+        regex_label: /^#{Mnemonic}\s+#{Sym}\s+zp$/
       },
 
-      :zero_page_x => {
-        :example     => 'AAA $FF, X',
-        :display     => '%s $%.2X, X',
-        :regex       => /^#{Mnemonic}\s+#{Num8}\s?,\s?#{XReg}$/,
-        :regex_label => /^#{Mnemonic}\s+#{Sym}\s?,\s?#{XReg}\s+zp$/
+      zero_page_x: {
+        example: 'AAA $FF, X',
+        display: '%s $%.2X, X',
+        regex: /^#{Mnemonic}\s+#{Num8}\s?,\s?#{XReg}$/,
+        regex_label: /^#{Mnemonic}\s+#{Sym}\s?,\s?#{XReg}\s+zp$/
       },
 
-      :zero_page_y => {
-        :example     => 'AAA $FF, Y',
-        :display     => '%s $%.2X, Y',
-        :regex       => /^#{Mnemonic}\s+#{Num8}\s?,\s?#{YReg}$/,
-        :regex_label => /^#{Mnemonic}\s+#{Sym}\s?,\s?#{YReg} zp$/
+      zero_page_y: {
+        example: 'AAA $FF, Y',
+        display: '%s $%.2X, Y',
+        regex: /^#{Mnemonic}\s+#{Num8}\s?,\s?#{YReg}$/,
+        regex_label: /^#{Mnemonic}\s+#{Sym}\s?,\s?#{YReg}\s+zp$/
       },
 
-      :absolute => {
-        :example     => 'AAA $FFFF',
-        :display     => '%s $%.4X',
-        :regex       => /^#{Mnemonic}\s+#{Num16}$/,
-        :regex_label => /^#{Mnemonic}\s+#{Sym}$/
+      absolute: {
+        example: 'AAA $FFFF',
+        display: '%s $%.4X',
+        regex: /^#{Mnemonic}\s+#{Num16}$/,
+        regex_label: /^#{Mnemonic}\s+#{Sym}$/
       },
 
-      :absolute_x => {
-        :example     => 'AAA $FFFF, X',
-        :display     => '%s $%.4X, X',
-        :regex       => /^#{Mnemonic}\s+#{Num16}\s?,\s?#{XReg}$/,
-        :regex_label => /^#{Mnemonic}\s+#{Sym}\s?,\s?#{XReg}$/
+      absolute_x: {
+        example: 'AAA $FFFF, X',
+        display: '%s $%.4X, X',
+        regex: /^#{Mnemonic}\s+#{Num16}\s?,\s?#{XReg}$/,
+        regex_label: /^#{Mnemonic}\s+#{Sym}\s?,\s?#{XReg}$/
       },
 
-      :absolute_y => {
-        :example     => 'AAA $FFFF, Y',
-        :display     => '%s $%.4X, Y',
-        :regex       => /^#{Mnemonic}\s+#{Num16}\s?,\s?#{YReg}$/,
-        :regex_label => /^#{Mnemonic}\s+#{Sym}\s?,\s?#{YReg}$/
+      absolute_y: {
+        example: 'AAA $FFFF, Y',
+        display: '%s $%.4X, Y',
+        regex: /^#{Mnemonic}\s+#{Num16}\s?,\s?#{YReg}$/,
+        regex_label: /^#{Mnemonic}\s+#{Sym}\s?,\s?#{YReg}$/
       },
 
-      :indirect => {
-        :example     => 'AAA ($FFFF)',
-        :display     => '%s ($%.4X)',
-        :regex       => /^#{Mnemonic}\s+\(#{Num16}\)$/,
-        :regex_label => /^#{Mnemonic}\s+\(#{Sym}\)$/
+      indirect: {
+        example: 'AAA ($FFFF)',
+        display: '%s ($%.4X)',
+        regex: /^#{Mnemonic}\s+\(#{Num16}\)$/,
+        regex_label: /^#{Mnemonic}\s+\(#{Sym}\)$/
       },
 
-      :indirect_x => {
-        :example     => 'AAA ($FF, X)',
-        :display     => '%s ($%.2X, X)',
-        :regex       => /^#{Mnemonic}\s+\(#{Num8}\s?,\s?#{XReg}\)$/,
-        :regex_label => /^#{Mnemonic}\s+\(#{Sym}\s?,\s?#{XReg}\)$/
+      indirect_x: {
+        example: 'AAA ($FF, X)',
+        display: '%s ($%.2X, X)',
+        regex: /^#{Mnemonic}\s+\(#{Num8}\s?,\s?#{XReg}\)$/,
+        regex_label: /^#{Mnemonic}\s+\(#{Sym}\s?,\s?#{XReg}\)$/
       },
 
-      :indirect_y => {
-        :example     => 'AAA ($FF), Y)',
-        :display => '%s ($%.2X), Y',
-        :regex       => /^#{Mnemonic}\s+\(#{Num8}\)\s?,\s?#{YReg}$/,
-        :regex_label => /^#{Mnemonic}\s+\(#{Sym}\)\s?,\s?#{YReg}$/
+      indirect_y: {
+        example: 'AAA ($FF), Y)',
+        display: '%s ($%.2X), Y',
+        regex: /^#{Mnemonic}\s+\(#{Num8}\)\s?,\s?#{YReg}$/,
+        regex_label: /^#{Mnemonic}\s+\(#{Sym}\)\s?,\s?#{YReg}$/
       }
-    }
+    }.freeze
 
-    ####
-    ##  Parse one line of assembly, returns nil if the line
-    ##  is ultimately empty of asm instructions
-    ##  Raises SyntaxError if the line is malformed in some way
+    # Parse one line of assembly, returns nil if the line
+    # is ultimately empty of asm instructions
+    # Raises SyntaxError if the line is malformed in some way
     def self.parse(line)
-
-      ##  Try to parse this line in each addressing mode
-      AddressingModes.each do |mode, parse_info|
-
-        ##  We have regexes that match each addressing mode
+      # Try to parse this line in each addressing mode
+      ADDRESSING_MODES.each do |mode, parse_info|
+        # We have regexes that match each addressing mode
         match_data = parse_info[:regex].match(line)
 
         unless match_data.nil?
-          ##  We must have a straight instruction without symbols, construct 
-          ##  an Instruction from the match_data, and return it
+          # We must have a straight instruction without symbols, construct
+          # an Instruction from the match_data, and return it
           _, op, arg_hex, arg_bin = match_data.to_a
 
-          ##  Until I think of something better, it seems that the union regex
-          ##  puts a hexidecimal argument in one capture, and a binary in the next
-          ##  This is annoying, but still not as annoying as using Treetop to parse
-          if arg_hex != nil
+          # Until I think of something better, it seems that the union regex
+          # puts a hexidecimal argument in one capture, and a binary in the next
+          # This is annoying, but still not as annoying as using Treetop to parse
+          if !arg_hex.nil?
             return Instruction.new(op, arg_hex.to_i(16), mode)
-          elsif arg_bin != nil
+          elsif !arg_bin.nil?
             return Instruction.new(op, arg_bin.to_i(2), mode)
           else
             return Instruction.new(op, nil, mode)
           end
 
         else
-          ##  Can this addressing mode even use labels?
+          # Can this addressing mode even use labels?
           unless parse_info[:regex_label].nil?
 
-            ##  See if it does in fact have a symbolic argument
+            # See if it does in fact have a symbolic argument
             match_data = parse_info[:regex_label].match(line)
 
             unless match_data.nil?
-              ##  We have found an assembly instruction containing a symbolic 
-              ##  argument.  We can resolve this symbol later by looking at the
-              ##  symbol table in the #exec method
+              # We have found an assembly instruction containing a symbolic
+              # argument.  We can resolve this symbol later by looking at the
+              # symbol table in the #exec method
               match_array = match_data.to_a
 
-              ##  If we have a 4 element array, this means we matched something 
-              ##  like LDA #<label, which is a legal immediate one byte value
-              ##  by taking the msb.  We need to make that distinction in the
-              ##  Instruction, by passing an extra argument
+              # If we have a 4 element array, this means we matched something
+              # like LDA #<label, which is a legal immediate one byte value
+              # by taking the msb.  We need to make that distinction in the
+              # Instruction, by passing an extra argument
               if match_array.size == 4
                 _, op, byte_selector, arg = match_array
                 return Instruction.new(op, arg, mode, byte_selector.to_sym)
@@ -160,88 +157,75 @@ module N65
         end
       end
 
-      ##  We just don't recognize this line of asm, it must be a Syntax Error
-      fail(SyntaxError, line)
+      # We just don't recognize this line of asm, it must be a Syntax Error
+      raise(SyntaxError, line)
     end
 
-
-    ####
-    ##  Create an instruction.  Having the instruction op a downcased symbol is nice
-    ##  because that can later be used to index into our opcodes hash in OpCodes
-    ##  OpCodes contains the definitions of each OpCode
+    # Create an instruction.  Having the instruction op a downcased symbol is nice
+    # because that can later be used to index into our opcodes hash in OpCodes
+    # OpCodes contains the definitions of each OpCode
     def initialize(op, arg, mode, byte_selector = nil)
-
-      ##  Lookup the definition of this opcode, otherwise it is an invalid instruction
       @byte_selector = byte_selector.nil? ? nil : byte_selector.to_sym
-      fail(InvalidInstruction, "Bad Byte selector: #{byte_selector}") unless [:>, :<, nil].include?(@byte_selector)
+      raise(InvalidInstruction, "Bad Byte selector: #{byte_selector}") unless [:>, :<, nil].include?(@byte_selector)
 
+      ##  Lookup the definition of this opcode, otherwise it is an invalid instruction
       @op = op.downcase.to_sym
       definition = OpCodes[@op]
-      fail(InvalidInstruction, op) if definition.nil?
+      raise(InvalidInstruction, op) if definition.nil?
 
       @arg = arg
 
-      ##  Be sure the mode is an actually supported mode.
+      # Be sure the mode is an actually supported mode.
       @mode = mode.to_sym
-      fail(InvalidAddressingMode, mode) unless AddressingModes.has_key?(@mode)
-
-      if definition[@mode].nil?
-        fail(InvalidInstruction, "#{op} cannot be used in #{mode} mode")
-      end
+      raise(InvalidAddressingMode, mode) unless ADDRESSING_MODES.key?(@mode)
+      raise(InvalidInstruction, "#{op} cannot be used in #{mode} mode") if definition[@mode].nil?
 
       @description, @flags = definition.values_at(:description, :flags)
       @hex, @length, @cycles, @boundry_add = definition[@mode].values_at(:hex, :len, :cycles, :boundry_add)
     end
 
-
-    ####
-    ##  Return if this instruction is a zero page instruction
+    # Is this instruction a zero page instruction?
     def zero_page_instruction?
-      [:zero_page, :zero_page_x, :zero_page_y].include?(@mode)
+      %i[zero_page zero_page_x zero_page_y].include?(@mode)
     end
 
-
-    ####
-    ##  Execute writes the emitted bytes to virtual memory, and updates PC
-    ##  If there is a symbolic argument, we can try to resolve it now, or
-    ##  promise to resolve it later.
+    # Execute writes the emitted bytes to virtual memory, and updates PC
+    # If there is a symbolic argument, we can try to resolve it now, or
+    # promise to resolve it later.
     def exec(assembler)
-
       promise = assembler.with_saved_state do |saved_assembler|
         @arg = saved_assembler.symbol_table.resolve_symbol(@arg)
 
-        ##  If the instruction uses a byte selector, we need to apply that.
+        # If the instruction uses a byte selector, we need to apply that.
         @arg = apply_byte_selector(@byte_selector, @arg)
 
-        ##  If the instruction is relative we need to work out how far away it is
+        # If the instruction is relative we need to work out how far away it is
         @arg = @arg - saved_assembler.program_counter - 2 if @mode == :relative
 
         saved_assembler.write_memory(emit_bytes)
       end
 
       case @arg
-      when Fixnum, NilClass
+      when Integer, NilClass
         assembler.write_memory(emit_bytes)
       when String
         begin
-          ##  This is a bug, I don't believe it will ever get here.
-          ##  I think it always resolves every symbol later.
+          # This works correctly now :)
           promise.call
         rescue SymbolTable::UndefinedSymbol
           placeholder = [@hex, 0xDE, 0xAD][0...@length]
-          ##  I still have to write a placeholder instruction of the right
-          ##  length.  The promise will come back and resolve the address.
+          # I still have to write a placeholder instruction of the right
+          # length.  The promise will come back and resolve the address.
           assembler.write_memory(placeholder)
-          return promise
+          promise
         end
       end
     end
 
-
-    ####
-    ##  Apply a byte selector to an argument
+    # Apply a byte selector to an argument
     def apply_byte_selector(byte_selector, value)
       return value if byte_selector.nil?
+
       case byte_selector
       when :>
         high_byte(value)
@@ -250,59 +234,39 @@ module N65
       end
     end
 
-
-    ####
-    ##  Emit bytes from asm structure
+    # Emit bytes from asm structure
     def emit_bytes
       case @length
       when 1
         [@hex]
       when 2
-        if zero_page_instruction? && @arg < 0 || @arg > 0xff
-          fail(ArgumentTooLarge, "For #{@op} in #{@mode} mode, only 8-bit values are allowed")
+        if zero_page_instruction? && @arg.negative? || @arg > 0xff
+          raise(ArgumentTooLarge, "For #{@op} in #{@mode} mode, only 8-bit values are allowed")
         end
+
         [@hex, @arg]
       when 3
         [@hex] + break_16(@arg)
       else
-        fail("Can't handle instructions > 3 bytes")
+        raise("Can't handle instructions > 3 bytes")
       end
     end
 
-
-    ####
-    ##  Pretty Print
-    def to_s
-      #display = AddressingModes[@mode][:display]
-      #if @arg.kind_of?(String)
-        #sprintf("#{display} (#{@mode}, #{@arg})", @op, 0x0)
-      #else
-        #sprintf("#{display} (#{@mode})", @op, @arg)
-      #end
-    end
-
-
     private
-    ####
-    ##  Break an integer into two 8-bit parts
+
+    # Break an integer into two 8-bit parts
     def break_16(integer)
       [integer & 0x00FF, (integer & 0xFF00) >> 8]
     end
 
-
-    ####
-    ##  Take the high byte of a 16-bit integer
+    # Take the high byte of a 16-bit integer
     def high_byte(word)
       (word & 0xFF00) >> 8
     end
 
-
-    ####
-    ##  Take the low byte of a 16-bit integer
+    # Take the low byte of a 16-bit integer
     def low_byte(word)
       word & 0xFF
     end
-
   end
-
 end

data/lib/n65/instruction_base.rb

@@ -1,29 +1,17 @@
+# frozen_string_literal: true
 
 module N65
-
   class InstructionBase
-
-
-    #####
-    ##  Sort of a "pure virtual" class method, not really tho.
-    def self.parse(line)
-      fail(NotImplementedError, "#{self.class.name} must implement self.parse")
+    def self.parse(_line)
+      raise(NotImplementedError, "#{self.class.name} must implement #{__method__}")
     end
 
+    def exec(_assembler)
+      raise(NotImplementedError, "#{self.class.name} must implement #{__method__}")
+    end
 
-    ####
-    ##  Does this instruction have unresolved symbols?
     def unresolved_symbols?
       false
     end
-
-
-    ####
-    ##  Another method subclasses will be expected to implement
-    def exec(assembler)
-      fail(NotImplementedError, "#{self.class.name} must implement exec")
-    end
-
   end
-
 end

data/lib/n65/memory_space.rb

@@ -1,58 +1,42 @@
+# frozen_string_literal: true
 
 module N65
-
-  ####
-  ##  Let's use this to simulate a virtual address space
-  ##  Either a 16kb prog rom or 8kb char rom space.
-  ##  It can also be used to create arbitrary sized spaces
-  ##  for example to build the final binary ROM in.
+  # Let's use this to simulate a virtual address space
+  # Either a 16kb prog rom or 8kb char rom space.
+  # It can also be used to create arbitrary sized spaces
+  # for example to build the final binary ROM in.
   class MemorySpace
-
-    ####  Custom exceptions
     class AccessOutsideProgRom < StandardError; end
     class AccessOutsideCharRom < StandardError; end
     class AccessOutOfBounds < StandardError; end
 
+    # Some constants, the size of PROG and CHAR ROM
+    BANK_SIZES = {
+      ines: 0x10,
+      prog: 0x4000,
+      char: 0x2000
+    }.freeze
 
-    ####  Some constants, the size of PROG and CHAR ROM
-    BankSizes = {
-      :ines => 0x10,     #  16b
-      :prog => 0x4000,   #  16kb
-      :char => 0x2000,   #   8kb
-    }
-
-
-    ####
-    ##  Create a new PROG ROM
     def self.create_prog_rom
-      self.create_bank(:prog)
+      create_bank(:prog)
     end
 
-
-    ####
-    ##  Create a new CHAR ROM
     def self.create_char_rom
-      self.create_bank(:char)
+      create_bank(:char)
     end
 
-
-    ####
-    ##  Create a new bank
     def self.create_bank(type)
-      self.new(BankSizes[type], type)
+      new(BANK_SIZES[type], type)
     end
 
-
-    ####
-    ##  Create a completely zeroed memory space
+    # Create a completely zeroed memory space
     def initialize(size, type)
       @type = type
       @memory = Array.new(size, 0x0)
+      @bytes_written = 0
     end
 
-
-    ####
-    ##  Normalized read from memory
+    # Normalized read from memory
     def read(address, count)
       from_normalized = normalize_address(address)
       to_normalized = normalize_address(address + (count - 1))
@@ -61,9 +45,7 @@ module N65
       @memory[from_normalized..to_normalized]
     end
 
-
-    ####
-    ##  Normalized write to memory
+    # Normalized write to memory
     def write(address, bytes)
       from_normalized = normalize_address(address)
       to_normalized = normalize_address(address + bytes.size - 1)
@@ -71,80 +53,78 @@ module N65
 
       bytes.each_with_index do |byte, index|
         @memory[from_normalized + index] = byte
+        @bytes_written += 1
       end
       bytes.size
     end
 
-
-    ####
-    ##  Return the memory as an array of bytes to write to disk
+    # Return the memory as an array of bytes to write to disk
     def emit_bytes
       @memory
     end
 
+    # Bank Usage information
+    def usage_info
+      percent_used = @bytes_written / @memory.size.to_f * 100
+      percent_string = format('%0.2f', percent_used)
+      bytes_written_hex = format('$%04x', @bytes_written)
+      memory_size_hex = format('$%04x', @memory.size)
+      "(#{bytes_written_hex} / #{memory_size_hex}) #{percent_string}%"
+    end
 
     private
 
-    ####
-    ##  Are the given addresses in bounds?  If not blow up.
+    # Are the given addresses in bounds?  If not blow up.
     def ensure_addresses_in_bounds!(addresses)
       addresses.each do |address|
         unless address >= 0 && address < @memory.size
-          fail(AccessOutOfBounds, sprintf("Address $%.4X is out of bounds in this #{@type} bank"))
+          raise(AccessOutOfBounds, format("Address $%.4X is out of bounds in this #{@type} bank"))
         end
       end
       true
     end
 
-
-    ####
-    ##  Since prog rom can be loaded at either 0x8000 or 0xC000
-    ##  We should normalize the addresses to fit properly into
-    ##  these banks, basically it acts like it is mirroring addresses
-    ##  in those segments.  Char rom doesn't need this.  This will also
-    ##  fail if you are accessing outside of the address space.
+    # Since prog rom can be loaded at either 0x8000 or 0xC000
+    # We should normalize the addresses to fit properly into
+    # these banks, basically it acts like it is mirroring addresses
+    # in those segments.  Char rom doesn't need this.  This will also
+    # fail if you are accessing outside of the address space.
     def normalize_address(address)
       case @type
       when :prog
-        if address_inside_prog_rom1?(address)
-          return address - 0x8000
-        end
-        if address_inside_prog_rom2?(address)
-          return address - 0xC000
-        end
-        fail(AccessOutsideProgRom, sprintf("Address $%.4X is outside PROG ROM", address))
+        normalize_prog_rom_address(address)
       when :char
-        unless address_inside_char_rom?(address)
-          fail(AccessOutsideCharRom, sprintf("Address $%.4X is outside CHAR ROM", address))
-        end
-        address
+        normalize_char_rom_address(address)
       else
         address
       end
     end
 
+    def normalize_prog_rom_address(address)
+      return (address - 0x8000) if address_inside_prog_rom1?(address)
+      return (address - 0xC000) if address_inside_prog_rom2?(address)
+
+      message = 'Address $%.4X is outside PROG ROM'
+      raise(AccessOutsideProgRom, format(message, address))
+    end
+
+    def normalize_char_rom_address(address)
+      return address if address_inside_char_rom?(address)
+
+      message = 'Address $%.4X is outside CHAR ROM'
+      raise(AccessOutsideCharRom, format(message, address))
+    end
 
-    ####
-    ##  Is this address inside the prog rom 1 area?
     def address_inside_prog_rom1?(address)
       address >= 0x8000 && address < 0xC000
     end
 
-
-    ####
-    ##  Is this address inside the prog rom 2 area?
     def address_inside_prog_rom2?(address)
       address >= 0xC000 && address <= 0xffff
     end
 
-
-    ####
-    ##  Is this address inside the char rom area?
     def address_inside_char_rom?(address)
       address >= 0x0000 && address <= 0x1fff
     end
-
   end
-
 end
-

data/lib/n65/opcodes.rb

@@ -1,9 +1,7 @@
+# frozen_string_literal: true
+
 require 'yaml'
 
 module N65
-
-  ##  Load OpCode definitions into this module
-  MyDirectory = File.expand_path(File.dirname(__FILE__))
-  OpCodes = YAML.load_file("#{MyDirectory}/../../data/opcodes.yaml")
-
+  OpCodes = YAML.load_file(File.join(__dir__, '../../data/opcodes.yaml'))
 end