n65 0.5.0

data/lib/n65/version.rb

@@ -0,0 +1,3 @@
+module N65
+  VERSION = "0.5.0"
+end

data/n65.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'n65/version'
+
+Gem::Specification.new do |spec|
+  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.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.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/nes_lib/nes.sym

@@ -0,0 +1,105 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;  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
+;
+;  Author: Saf Allen 2015
+;  I picked up some extra register names for mappers etc here:
+;  http://wiki.nesdev.com/w/index.php/Registers
+;  Some different common names from here:
+;  http://wiki.nesdev.com/w/index.php/PPU_registers
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+.org $0000
+.scope nes
+  .scope ppu
+    .org $2000
+    .space control 1                             ; $2000
+    .space mask 1                                ; $2001
+    .space status 1                              ; $2002
+    .org $2005
+    .space scroll 1                               ; $2005
+  .
+  .org $2003
+  .scope oam
+    .space address 1                              ; $2003
+    .space io 1                                   ; $2004
+    .org $4014
+    .space dma 1                                  ; $4014
+  .
+  .org $2006
+  .scope vram
+    .space address 1                              ; $2006
+    .space io 1                                   ; $2007
+  .
+
+  ;  Now let's do the APU registers
+  .org $4000
+  .scope apu
+    .scope pulse1
+      .space control 1                             ; $4000
+      .space ramp_control 1                        ; $4001
+      .space ft 1                                  ; $4002
+      .space ct 1                                  ; $4003
+    .
+    .scope pulse2
+      .space control 1                             ; $4004
+      .space ramp_control 1                        ; $4005
+      .space ft 1                                  ; $4006
+      .space ct 1                                  ; $4007
+    .
+    .scope triangle
+      .space control1 1                            ; $4008
+      .space control2 1                            ; $4009
+      .space freq1 1                               ; $400A
+      .space freq2 1                               ; $400B
+    .
+    .scope noise
+      .space control1 1                            ; $400C
+      .space control2 1                            ; $400D
+      .space freq1 1                               ; $400E
+      .space freq2 1                               ; $400F
+    .
+    .scope dmc
+      .space control 1                             ; $4010
+      .space da 1                                  ; $4011
+      .space address 1                             ; $4012
+      .space dl 1                                  ; $4013
+    .
+    .org $4015
+    .space channel_enable 1                        ; $4015
+  .
+  .org $4016
+  .space controller1 1                             ; $4016
+  .space controller2 1                             ; $4017
+  .scope mapper
+    .org $8000
+    .space unrom 1                                 
+    .org $8000
+    .space cnrom 1
+    .org $8000
+    .space mmc1_control 1
+    .org $A000
+    .space mmc1_vrom_low 1
+    .org $C000
+    .space mmc1_vrom_high 1
+    .org $E000
+    .space mmc1_prog 1
+    .org $8000
+    .space mmc3_command 1
+    .space mmc3_page 1
+    .org $A000
+    .space mmc3_mirror 1
+    .space mmc3_sram 1
+    .org $C000
+    .space mmc3_clock 1
+    .space mmc3_latch 1
+    .org $E000
+    .space mmc3_clock_off 1
+    .space mmc3_clock_on 1
+  .
+.
+
+; Let's put PC back somewhere sane
+.org $0000

data/test/test_memory_space.rb

@@ -0,0 +1,82 @@
+gem 'minitest'
+require 'minitest/autorun'
+require 'minitest/unit'
+
+require_relative '../lib/n65/memory_space.rb'
+
+
+class TestMemorySpace < MiniTest::Test
+  include N65
+
+  def _test_create_prog_rom
+    ##  First just try to read alll of it
+    space = MemorySpace.create_prog_rom
+    contents = space.read(0x8000, 0x4000)
+    assert_equal(contents.size, 0x4000)
+    assert(contents.all?{|byte| byte.zero?})
+
+    ##  It is mirrored so this should also work
+    space = MemorySpace.create_prog_rom
+    contents = space.read(0xC000, 0x4000)
+    assert_equal(contents.size, 0x4000)
+    assert(contents.all?{|byte| byte.zero?})
+  end
+
+
+  def _test_writing
+    ##  Write some bytes into prog 2 area
+    space = MemorySpace.create_prog_rom
+    space.write(0xC000, "hi there".bytes)
+
+    ##  Read them back..
+    contents = space.read(0xC000, 8)
+    assert_equal('hi there', contents.pack('C*'))
+
+    ##  Should be mirrored in prog 1
+    contents = space.read(0x8000, 8)
+    assert_equal('hi there', contents.pack('C*'))
+  end
+
+
+  def _test_reading_out_of_bounds
+    space = MemorySpace.create_prog_rom
+    assert_raises(MemorySpace::AccessOutsideProgRom) do 
+      space.read(0x200, 10)
+    end
+
+    ##  But that is valid char rom area, so no explody
+    space = MemorySpace.create_char_rom
+    space.read(0x200, 10)
+
+    ##  But something like this should explode
+    space = MemorySpace.create_char_rom
+    assert_raises(MemorySpace::AccessOutsideCharRom) do 
+      space.read(0x8001, 10)
+    end
+  end
+
+
+  ####
+  ##  There seem to be problems writing bytes right to
+  ##  the end of the memory map, specifically where the
+  ##  vector table is in prog rom, so let's test that.
+  def test_writing_to_end
+    space = MemorySpace.create_prog_rom
+    bytes = [0xDE, 0xAD]
+
+    ##  Write the NMI address to FFFA
+    space.write(0xFFFA, bytes)
+   
+    ##  Write the entry point to FFFC
+    space.write(0xFFFC, bytes)
+
+    ##  Write the irq to FFFE, and this fails, saying
+    ##  I'm trying to write to $10000 for some reason.
+    space.write(0xFFFE, bytes)
+
+    ##  Write to the very first
+    space.write(0x8000, bytes)
+  end
+
+end
+

data/test/test_symbol_table.rb

@@ -0,0 +1,238 @@
+gem 'minitest'
+require 'minitest/autorun'
+require 'minitest/unit'
+
+require_relative '../lib/n65/symbol_table.rb'
+require_relative '../lib/n65.rb'
+
+
+class TestSymbolTable < MiniTest::Test
+  include N65
+
+  ####
+  ##  Test that we can make simple global symbols
+  def test_define_global_symbols
+    st = SymbolTable.new
+    st.define_symbol('dog', 'woof')
+    assert_equal('woof', st.resolve_symbol('dog'))
+  end
+
+
+  ####
+  ##  Test entering into a sub scope, and setting and retrieving values
+  def test_enter_scope
+    st = SymbolTable.new
+    st.enter_scope('animals')
+    st.define_symbol('dog', 'woof')
+    assert_equal('woof', st.resolve_symbol('dog'))
+  end
+
+
+  ####
+  ##  Access something from an outer scope without dot syntax
+  def test_outer_scope
+    st = SymbolTable.new
+    st.enter_scope('outer')
+    st.define_symbol('dog', 'woof')
+    st.enter_scope('inner')
+    st.define_symbol('pig', 'oink')
+    assert_equal('woof', st.resolve_symbol('dog'))
+  end
+
+
+  ####
+  ##  Access something from an outer scope without dot syntax
+  def test_shadow
+    st = SymbolTable.new
+    st.enter_scope('outer')
+    st.define_symbol('dog', 'woof')
+    st.enter_scope('inner')
+    st.define_symbol('dog', 'bark')
+    assert_equal('bark', st.resolve_symbol('dog'))
+    assert_equal('woof', st.resolve_symbol('outer.dog'))
+    st.exit_scope
+    st.exit_scope
+    assert_equal('bark', st.resolve_symbol('outer.inner.dog'))
+  end
+
+
+  ####
+  ##  Test exiting a sub scope, and seeing that the variable is unavailable by simple name
+  def test_exit_scope
+    st = SymbolTable.new
+    st.enter_scope('animals')
+    st.define_symbol('dog', 'woof')
+    assert_equal('woof', st.resolve_symbol('dog'))
+
+    st.exit_scope
+
+    assert_raises(SymbolTable::UndefinedSymbol) do 
+      assert_equal('woof', st.resolve_symbol('dog'))
+    end
+  end
+
+
+  ####
+  ##  Test exiting a sub scope, and being able to access a symbol through a full path
+  def test_exit_scope
+    st = SymbolTable.new
+    st.enter_scope('animals')
+    st.define_symbol('dog', 'woof')
+    assert_equal('woof', st.resolve_symbol('dog'))
+
+    st.exit_scope
+
+    assert_equal('woof', st.resolve_symbol('animals.dog'))
+  end
+
+
+  ####
+  ##  Have two symbols that are the same but are in different scopes
+  def test_two_scopes_same_symbol
+    st = SymbolTable.new
+    st.define_symbol('dog', 'woof')
+    assert_equal('woof', st.resolve_symbol('dog'))
+
+    st.enter_scope('animals')
+
+    st.define_symbol('dog', 'woofwoof')
+    assert_equal('woofwoof', st.resolve_symbol('dog'))
+
+    st.exit_scope
+
+    assert_equal('woof', st.resolve_symbol('dog'))
+    assert_equal('woofwoof', st.resolve_symbol('animals.dog'))
+  end
+
+
+  ####
+  ##  How do you get stuff out of the global scope when you are in 
+  ##  a sub scope?
+  def test_access_global_scope
+    st = SymbolTable.new
+    st.define_symbol('dog', 'woof')
+    assert_equal('woof', st.resolve_symbol('dog'))
+
+    st.enter_scope('animals')
+    st.define_symbol('pig', 'oink')
+    assert_equal('oink', st.resolve_symbol('pig'))
+
+    ##  Ok, now I want to access global.dog basically from the previous scope
+    assert_equal('woof', st.resolve_symbol('global.dog'))
+  end
+
+
+  ####
+  ##  Now I want to just test making an anonymous scope
+  def test_anonymous_scope
+    st = SymbolTable.new
+    st.define_symbol('dog', 'woof')
+    assert_equal('woof', st.resolve_symbol('dog'))
+
+    st.enter_scope
+    st.define_symbol('pig', 'oink')
+    assert_equal('oink', st.resolve_symbol('pig'))
+
+    ##  Ok, now I want to access global.dog basically from the previous scope
+    assert_equal('woof', st.resolve_symbol('global.dog'))
+
+    ##  Now exit the anonymous scope and get dog
+    st.exit_scope
+    assert_equal('woof', st.resolve_symbol('global.dog'))
+    assert_equal('woof', st.resolve_symbol('dog'))
+  end
+
+
+  ####
+  ##  Now I want to test that I cannot exist the outer-most 
+  ##  global scope by mistake
+  def test_cant_exit_global
+    st = SymbolTable.new
+    assert_raises(SymbolTable::CantExitScope) do 
+      st.exit_scope
+    end
+  end
+
+
+  ####
+  ##  I would like the name of the scope to take on the 
+  ##  value of the program counter at that location.
+  def test_scope_as_symbol
+    program = <<-ASM
+      .ines {"prog": 1, "char": 0, "mapper": 0, "mirror": 0}
+      .org $8000
+      .segment prog 0
+      .scope main
+        sei
+        cld
+        lda \#$00
+        jmp main
+      .
+      jmp main
+      jmp global.main
+    ASM
+
+    ####  There really should be an evaluate string method
+    assembler = Assembler.new
+    program.split(/\n/).each do |line|
+      assembler.assemble_one_line(line)
+    end
+    assembler.fulfill_promises
+    assert_equal(0x8000, assembler.symbol_table.resolve_symbol('global.main'))
+  end
+
+
+  ####
+  ##  Fix a bug where we can't see a forward declared symbol in a scope
+  def test_foward_declaration_in_scope
+    program = <<-ASM
+    ;;;;
+    ;  Create an iNES header
+    .ines {"prog": 1, "char": 0, "mapper": 0, "mirror": 0}
+
+    ;;;;
+    ;  Try to expose a problem we have with scopes
+    ;  We don't seem to be able to branch to a forward
+    ;  declared symbol within a scope
+    .org $8000
+    .scope main
+      sei
+      cld
+      lda #\$00
+      bne forward_symbol
+      nop
+      nop
+      nop
+      forward_symbol:
+      rts
+    .
+    ASM
+
+    ####  There really should be an evaluate string method
+    assembler = Assembler.new
+    program.split(/\n/).each do |line|
+      assembler.assemble_one_line(line)
+    end
+    puts YAML.dump(assembler.symbol_table)
+    assembler.fulfill_promises
+
+    ####  The forward symbol should have been resolved to +3, and the ROM should look like this:
+    correct_rom = [0x4e, 0x45, 0x53, 0x1a, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+                   0x78,        # SEI
+                   0xd8,        # CLD
+                   0xa9, 0x0,   # LDA immediate 0
+                   0xd0, 0x3,   # BNE +3
+                   0xea,        # NOP
+                   0xea,        # NOP
+                   0xea,        # NOP
+                   0x60         # RTS forward_symbol
+    ]
+
+    ####  Grab the first 26 bytes of the rom and make sure they assemble to the above
+    emitted_rom = assembler.emit_binary_rom.bytes[0...26]
+    assert_equal(correct_rom, emitted_rom)
+    ####  Yup it is fixed now.
+  end
+
+end
+