n65 0.5.0 → 1.0.0

data/lib/n65.rb

@@ -1,65 +1,82 @@
+# frozen_string_literal: true
+
 require_relative 'n65/version'
 require_relative 'n65/symbol_table'
 require_relative 'n65/memory_space'
 require_relative 'n65/parser'
 
 module N65
-
   class Assembler
     attr_reader :program_counter, :current_segment, :current_bank, :symbol_table, :virtual_memory, :promises
 
-    #####  Custom exceptions
     class AddressOutOfRange < StandardError; end
     class InvalidSegment < StandardError; end
     class WriteOutOfBounds < StandardError; end
     class INESHeaderAlreadySet < StandardError; end
     class FileNotFound < StandardError; end
 
+    State = Data.define(:program_counter, :segment, :bank, :scope)
 
-    ####
-    ##  Assemble from an asm file to a nes ROM
-    def self.from_file(infile, outfile)
-      fail(FileNotFound, infile) unless File.exists?(infile)
+    # Assemble from an asm file to a NES ROM
+    # TODO: This really needs a logger instead of all these unless quiet conditions
+    def self.from_file(infile, options)
+      raise(FileNotFound, infile) unless File.exist?(infile)
 
-      assembler = self.new
+      assembler = new
       program = File.read(infile)
+      output_file = options[:output_file]
 
-      puts "Building #{infile}"
-      ##  Process each line in the file
-      program.split(/\n/).each_with_index do |line, line_number|
+      puts "Building #{infile}" unless options[:quiet]
+      # Process each line in the file
+      program.each_line.each_with_index do |line, line_number|
         begin
           assembler.assemble_one_line(line)
         rescue StandardError => e
-          STDERR.puts("\n\n#{e.class}\n#{line}\n#{e}\nOn line #{line_number}")
+          warn("\n\n#{e.class}\n#{line}\n#{e}\nOn line #{line_number}")
           exit(1)
         end
-        print '.'
+        print '.' unless options[:quiet]
       end
-      puts
+      puts unless options[:quiet]
 
-      ##  Second pass to resolve any missing symbols.
-      print "Second pass, resolving symbols..."
+      # Second pass to resolve any missing symbols.
+      print 'Second pass, resolving symbols...' unless options[:quiet]
       assembler.fulfill_promises
-      puts " Done."
-
-      ##  Let's not export the symbol table to a file anymore
-      ##  Will add an option for this later.
-      #print "Writing symbol table to #{outfile}.yaml..."
-      #File.open("#{outfile}.yaml", 'w') do |fp|
-        #fp.write(assembler.symbol_table.export_to_yaml)
-      #end
-      #puts "Done."
-
-      ##  For right now, let's just emit the first prog bank
-      File.open(outfile, 'w') do |fp|
-        fp.write(assembler.emit_binary_rom)
+      puts ' Done.' unless options[:quiet]
+
+      # Optionally write out a symbol map
+      if options[:write_symbol_table]
+        print "Writing symbol table to #{output_file}.yaml..." unless options[:quiet]
+        File.open("#{output_file}.yaml", 'w') do |fp|
+          fp.write(assembler.symbol_table.export_to_yaml)
+        end
+        puts 'Done.' unless options[:quiet]
       end
-      puts "All Done :)"
-    end
 
+      # Optionally write out cycle count for subroutines
+      if options[:cycle_count]
+        print "Writing subroutine cycle counts to #{output_file}.cycles.yaml..." unless options[:quiet]
+        File.open("#{output_file}.cycles.yaml", 'w') do |fp|
+          fp.write(assembler.symbol_table.export_cycle_count_yaml)
+        end
+        puts 'Done.' unless options[:quiet]
+      end
+
+      # Emit the complete binary ROM
+      rom = assembler.emit_binary_rom
+      File.open(output_file, 'w') do |fp|
+        fp.write(rom)
+      end
+
+      return if options[:quiet]
 
-    ####
-    ##  Initialize with a bank 1 of prog space for starters
+      rom_size = rom.size
+      rom_size_hex = format('%x', rom_size)
+      assembler.print_bank_usage
+      puts "Total size: $#{rom_size_hex}, #{rom_size} bytes"
+    end
+
+    # Initialize with a bank 1 of prog space for starters
     def initialize
       @ines_header = nil
       @program_counter = 0x0
@@ -68,176 +85,158 @@ module N65
       @symbol_table = SymbolTable.new
       @promises = []
       @virtual_memory = {
-        :prog => [MemorySpace.create_prog_rom],
-        :char => []
+        prog: [MemorySpace.create_prog_rom],
+        char: []
       }
     end
 
-
-    ####
-    ##  Return an object that contains the assembler's current state
+    # Return an object that contains the assembler's current state
     def get_current_state
       saved_program_counter, saved_segment, saved_bank = @program_counter, @current_segment, @current_bank
       saved_scope = symbol_table.scope_stack.dup
-      OpenStruct.new(program_counter: saved_program_counter, segment: saved_segment, bank: saved_bank, scope: saved_scope)
+      State.new(saved_program_counter, saved_segment, saved_bank, saved_scope)
     end
 
-
-    ####
-    ##  Set the current state from an OpenStruct
-    def set_current_state(struct)
-      @program_counter, @current_segment, @current_bank = struct.program_counter, struct.segment, struct.bank
-      symbol_table.scope_stack = struct.scope.dup
+    # Set the current state
+    def set_current_state(state)
+      @program_counter, @current_segment, @current_bank = state.program_counter, state.segment, state.bank
+      symbol_table.scope_stack = state.scope.dup
     end
 
-
-    ####
-    ##  This is the main assemble method, it parses one line into an object
-    ##  which when given a reference to this assembler, controls the assembler
-    ##  itself through public methods, executing assembler directives, and 
-    ##  emitting bytes into our virtual memory spaces.  Empty lines or lines
-    ##  with only comments parse to nil, and we just ignore them.
+    # This is the main assemble method, it parses one line into an object
+    # which when given a reference to this assembler, controls the assembler
+    # itself through public methods, executing assembler directives, and
+    # emitting bytes into our virtual memory spaces.  Empty lines or lines
+    # with only comments parse to nil, and we just ignore them.
     def assemble_one_line(line)
       parsed_object = Parser.parse(line)
+      return if parsed_object.nil?
 
-      unless parsed_object.nil?
-        exec_result = parsed_object.exec(self)
+      exec_result = parsed_object.exec(self)
 
-        ##  If we have returned a promise save it for the second pass
-        @promises << exec_result if exec_result.kind_of?(Proc)
+      # TODO: I could perhaps keep a tally of cycles used per top level scope here
+      if parsed_object.respond_to?(:cycles)
+        @symbol_table.add_cycles(parsed_object.cycles)
       end
-    end
 
+      # If we have returned a promise save it for the second pass
+      @promises << exec_result if exec_result.is_a?(Proc)
+    end
 
-    ####
-    ##  This will empty out our promise queue and try to fullfil operations
-    ##  that required an undefined symbol when first encountered.
-    def fulfill_promises
-      while promise = @promises.pop
-        promise.call
+    # Assemble the given string
+    def assemble_string(string)
+      string.each_line do |line|
+        assemble_one_line(line)
       end
+      fulfill_promises
+      self
     end
 
+    # This will empty out our promise queue and try to fullfil operations
+    # that required an undefined symbol when first encountered.
+    def fulfill_promises
+      @promises.pop.call while @promises.any?
+    end
 
-    ####
-    ##  This rewinds the state of the assembler, so a promise can be 
-    ##  executed with a previous state, for example if we can't resolve
-    ##  a symbol right now, and want to try during the second pass
+    # This rewinds the state of the assembler, so a promise can be
+    # executed with a previous state, for example if we can't resolve
+    # a symbol right now, and want to try during the second pass
     def with_saved_state(&block)
-      ##  Save the current state of the assembler
-      old_state = get_current_state
-
+      saved_state = get_current_state
       lambda do
-
-        ##  Set the assembler state back to the old state and run the block like that
-        set_current_state(old_state)
+        set_current_state(saved_state)
         block.call(self)
       end
     end
 
-
-    ####
-    ##  Write to memory space. Typically, we are going to want to write
-    ##  to the location of the current PC, current segment, and current bank.
-    ##  Bounds check is inside MemorySpace#write
+    # Write to memory space. Typically, we are going to want to write
+    # to the location of the current PC, current segment, and current bank.
     def write_memory(bytes, pc = @program_counter, segment = @current_segment, bank = @current_bank)
       memory_space = get_virtual_memory_space(segment, bank)
       memory_space.write(pc, bytes)
       @program_counter += bytes.size
     end
 
-
-    ####
-    ##  Set the iNES header
+    # Set the iNES header
     def set_ines_header(ines_header)
-      fail(INESHeaderAlreadySet) unless @ines_header.nil?
+      raise(INESHeaderAlreadySet) unless @ines_header.nil?
+
       @ines_header = ines_header
     end
 
-
-    ####
-    ##  Set the program counter
+    # Set the program counter
     def program_counter=(address)
-      fail(AddressOutOfRange) unless address_within_range?(address)
+      raise(AddressOutOfRange) unless address_within_range?(address)
+
       @program_counter = address
     end
 
-
-    ####
-    ##  Set the current segment, prog or char.
+    # Set the current segment, prog or char.
     def current_segment=(segment)
       segment = segment.to_sym
-      unless valid_segment?(segment)
-        fail(InvalidSegment, "#{segment} is not a valid segment.  Try prog or char")
-      end
+      raise(InvalidSegment, "#{segment} is not a valid segment.  Try prog or char") unless valid_segment?(segment)
+
       @current_segment = segment
     end
 
-
-    ####
-    ##  Set the current bank, create it if it does not exist
+    # Set the current bank, create it if it does not exist
     def current_bank=(bank_number)
       memory_space = get_virtual_memory_space(@current_segment, bank_number)
-      if memory_space.nil?
-        @virtual_memory[@current_segment][bank_number] = MemorySpace.create_bank(@current_segment)
-      end
+      @virtual_memory[@current_segment][bank_number] = MemorySpace.create_bank(@current_segment) if memory_space.nil?
       @current_bank = bank_number
     end
 
-
-    ####
-    ##  Emit a binary ROM
     def emit_binary_rom
       progs = @virtual_memory[:prog]
       chars = @virtual_memory[:char]
-      puts "iNES Header"
-      puts "+ #{progs.size} PROG ROM bank#{progs.size != 1 ? 's' : ''}"
-      puts "+ #{chars.size} CHAR ROM bank#{chars.size != 1 ? 's' : ''}"
 
-      rom_size  = 0x10 
-      rom_size += MemorySpace::BankSizes[:prog] * progs.size
-      rom_size += MemorySpace::BankSizes[:char] * chars.size
+      rom_size  = 0x10
+      rom_size += MemorySpace::BANK_SIZES[:prog] * progs.size
+      rom_size += MemorySpace::BANK_SIZES[:char] * chars.size
 
-      puts "= Output ROM will be #{rom_size} bytes"
       rom = MemorySpace.new(rom_size, :rom)
 
       offset = 0x0
       offset += rom.write(0x0, @ines_header.emit_bytes)
 
       progs.each do |prog|
-        offset += rom.write(offset, prog.read(0x8000, MemorySpace::BankSizes[:prog]))
+        offset += rom.write(offset, prog.read(0x8000, MemorySpace::BANK_SIZES[:prog]))
       end
 
       chars.each do |char|
-        offset += rom.write(offset, char.read(0x0, MemorySpace::BankSizes[:char]))
+        offset += rom.write(offset, char.read(0x0, MemorySpace::BANK_SIZES[:char]))
       end
       rom.emit_bytes.pack('C*')
     end
 
+    # TODO: Use StringIO to build output
+    def print_bank_usage
+      puts
+      puts 'ROM Structure {'
+      puts '  iNES 1.0 Header: $10 bytes'
 
-    private
+      @virtual_memory[:prog].each_with_index do |prog_rom, bank_number|
+        puts "  PROG ROM bank #{bank_number}: #{prog_rom.usage_info}"
+      end
 
+      @virtual_memory[:char].each_with_index do |char_rom, bank_number|
+        puts "  CHAR ROM bank #{bank_number}: #{char_rom.usage_info}"
+      end
+      puts '}'
+    end
+
+    private
 
-    ####
-    ##  Get virtual memory space
     def get_virtual_memory_space(segment, bank_number)
       @virtual_memory[segment][bank_number]
     end
 
-
-    ####
-    ##  Is this a 16-bit address within range?
     def address_within_range?(address)
       address >= 0 && address < 2**16
     end
 
-
-    ####
-    ##  Is this a valid segment?
     def valid_segment?(segment)
-      [:prog, :char].include?(segment)
+      %i[prog char].include?(segment)
     end
-
   end
-
 end

data/n65.gemspec

@@ -1,23 +1,28 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'n65/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "n65"
+  spec.name          = 'n65'
   spec.version       = N65::VERSION
-  spec.authors       = ["Safiire"]
-  spec.email         = ["safiire@irkenkitties.com"]
-  spec.summary       = %q{An NES assembler for the 6502 microprocessor written in Ruby}
-  spec.description   = %q{An NES assembler for the 6502 microprocessor written in Ruby}
-  spec.homepage      = "http://github.com/safiire/n65"
-  spec.license       = "GPL2"
+  spec.authors       = ['Safiire']
+  spec.email         = ['safiire@irkenkitties.com']
+  spec.summary       = 'An NES assembler for the 6502 microprocessor'
+  spec.description   = 'An NES assembler for the 6502 microprocessor in pure Ruby'
+  spec.homepage      = 'http://github.com/safiire/n65'
+  spec.license       = 'GPL-2.0-or-later'
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 3.2.0'
 
-  spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rubocop'
 end

data/nes_lib/nes.sym

@@ -1,6 +1,6 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;  Let's start a little library for naming parts of memory in the NES
-;  
+;
 ;  Including this file will not emit any instructions or data into your binary
 ;  It only defines symbols in the symbol table to name memory addresses
 ;
@@ -75,7 +75,7 @@
   .space controller2 1                             ; $4017
   .scope mapper
     .org $8000
-    .space unrom 1                                 
+    .space unrom 1
     .org $8000
     .space cnrom 1
     .org $8000

data/spec/.rubocop.yml

@@ -0,0 +1,4 @@
+inherit_from: ../.rubocop.yml
+
+Metrics/BlockLength:
+  Enabled: false

data/spec/assembler_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'digest/sha2'
+require_relative '../lib/n65'
+
+RSpec.describe(N65::Assembler) do
+  describe 'assembling example files' do
+    let(:examples) do
+      File.join(__dir__, '..', 'examples')
+    end
+
+    let(:source) do
+      File.read(filename)
+    end
+
+    let(:assembler) do
+      described_class.new
+    end
+
+    let(:binary) do
+      Dir.chdir(examples) do
+        assembler.assemble_string(source).emit_binary_rom
+      end
+    end
+
+    let(:sha256) do
+      Digest::SHA256.hexdigest(binary)
+    end
+
+    context 'when assembling beep.asm' do
+      let(:filename) { 'beep.asm' }
+      let(:expected) { 'afce4dd85323d86dd6b2f8e4c9e7d704607b0480c3cf087bd8f66b37b8ddf269' }
+
+      it 'have the correct sha256 digest' do
+        expect(sha256).to eq(expected)
+      end
+    end
+
+    context 'when assembling demo.asm' do
+      let(:filename) { 'demo.asm' }
+      let(:expected) { 'ff687730a0a4022519b177c1cd92f18eaafaa2e9606f9a579371e9c62ffcb726' }
+
+      it 'have the correct sha256 digest' do
+        expect(sha256).to eq(expected)
+      end
+    end
+
+    context 'when assembling scales.asm' do
+      let(:filename) { 'scales.asm' }
+      let(:expected) { '2c6c586f3a9d35212a1a02e064a8bb71ec26ac857ed6572f217c10161f2de102' }
+
+      it 'have the correct sha256 digest' do
+        expect(sha256).to eq(expected)
+      end
+    end
+
+    context 'when assembling pulse_chord.asm' do
+      let(:filename) { 'pulse_chord.asm' }
+      let(:expected) { '77712d504edbe9b30261939a9d72f51e14ee3029da04287b879dffbb36eb9b12' }
+
+      it 'have the correct sha256 digest' do
+        expect(sha256).to eq(expected)
+      end
+    end
+
+    context 'when assembling noise.asm' do
+      let(:filename) { 'noise.asm' }
+      let(:expected) { 'ea790d892ecd2bf76f711fbcb8a2f8e9b4dbaa5dffb56b691924c81666d23673' }
+
+      it 'have the correct sha256 digest' do
+        expect(sha256).to eq(expected)
+      end
+    end
+
+    context 'when assembling mario2.asm' do
+      let(:filename) { 'mario2.asm' }
+      let(:expected) { '0974b799eac7ffb8835fcbd518a5cdeeec734d5d9476cd11cb6b75491c6ef488' }
+
+      it 'have the correct sha256 digest' do
+        expect(sha256).to eq(expected)
+      end
+    end
+  end
+end

data/spec/lib/n65/memory_space_spec.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require_relative '../../../lib/n65/memory_space'
+
+RSpec.describe(N65::MemorySpace) do
+  describe '.new' do
+    context 'when provided a size and type' do
+      let(:bank) { described_class.new(size, type) }
+      let(:size) { 0x100 }
+      let(:type) { :prog }
+
+      it 'returns a zeroed bank' do
+        expect(bank.emit_bytes.all?(&:zero?)).to eq(true)
+      end
+
+      it 'returns the requested sized bank' do
+        expect(bank.emit_bytes.size).to be(size)
+      end
+    end
+  end
+
+  describe '.create_prog_rom' do
+    context 'when creating a new prog rom' do
+      let(:bank) { described_class.create_prog_rom }
+
+      it 'returns a zeroed bank' do
+        expect(bank.emit_bytes.all?(&:zero?)).to eq(true)
+      end
+
+      it 'returns the correct sized bank' do
+        expect(bank.emit_bytes.size).to eq(0x4000)
+      end
+    end
+  end
+
+  describe '.create_char_rom' do
+    context 'when creating a new prog rom' do
+      let(:bank) { described_class.create_char_rom }
+
+      it 'returns a zeroed bank' do
+        expect(bank.emit_bytes.all?(&:zero?)).to eq(true)
+      end
+
+      it 'returns the correct sized bank' do
+        expect(bank.emit_bytes.size).to eq(0x2000)
+      end
+    end
+  end
+
+  describe '#read prog rom' do
+    let(:address) { 0xC100 }
+    let(:mirroed_address) { 0x8100 }
+    let(:bank) { described_class.create_prog_rom }
+    let(:data) { 'hi there'.bytes }
+
+    before { bank.write(address, data) }
+
+    context 'when reading from the bank' do
+      it 'can read back from the 0xC000 base address' do
+        expect(bank.read(address, data.size)).to eq(data)
+      end
+
+      it 'can read back from the 0x8000 mirrored address' do
+        expect(bank.read(mirroed_address, data.size)).to eq(data)
+      end
+    end
+
+    context 'when attempting to read out of bounds' do
+      it 'throws an error' do
+        expect { bank.read(0x0, 0x10) }.to raise_error(described_class::AccessOutsideProgRom)
+      end
+
+      it 'throws an error' do
+        expect { bank.read(0xffff, 0x10) }.to raise_error(described_class::AccessOutsideProgRom)
+      end
+    end
+  end
+
+  describe '#read char rom' do
+    let(:address) { 0x100 }
+    let(:bank) { described_class.create_char_rom }
+    let(:data) { 'hi there'.bytes }
+
+    before { bank.write(address, data) }
+
+    context 'when reading from the bank' do
+      it 'can read from the bank' do
+        expect(bank.read(address, data.size)).to eq(data)
+      end
+    end
+
+    context 'when attempting to read out of bounds' do
+      it 'throws an error' do
+        expect { bank.read(0x2000, 0x10) }.to raise_error(described_class::AccessOutsideCharRom)
+      end
+    end
+  end
+
+  describe '#write prog rom' do
+    let(:address) { 0xC100 }
+    let(:mirroed_address) { 0x8100 }
+    let(:bank) { described_class.create_prog_rom }
+    let(:data) { 'hi there'.bytes }
+
+    before { bank.write(mirroed_address, data) }
+
+    context 'when reading from the bank' do
+      it 'can read back from the 0xC000 base address' do
+        expect(bank.read(address, data.size)).to eq(data)
+      end
+
+      it 'can read back from the 0x8000 mirrored address' do
+        expect(bank.read(mirroed_address, data.size)).to eq(data)
+      end
+    end
+
+    context 'when attempting to write out of bounds' do
+      it 'throws an error' do
+        expect { bank.write(0x0, data) }.to raise_error(described_class::AccessOutsideProgRom)
+      end
+
+      it 'throws an error' do
+        expect { bank.write(0xffff, data) }.to raise_error(described_class::AccessOutsideProgRom)
+      end
+    end
+  end
+
+  describe '#write char rom' do
+    let(:address) { 0x100 }
+    let(:bank) { described_class.create_char_rom }
+    let(:data) { 'hi there'.bytes }
+
+    before { bank.write(address, data) }
+
+    context 'when reading from the bank' do
+      it 'can read from the bank' do
+        expect(bank.read(address, data.size)).to eq(data)
+      end
+    end
+
+    context 'when attempting to write out of bounds' do
+      it 'throws an error' do
+        expect { bank.write(0x2000, data) }.to raise_error(described_class::AccessOutsideCharRom)
+      end
+    end
+  end
+end