n65 0.5.0

data/lib/n65/directives/ascii.rb

@@ -0,0 +1,42 @@
+require_relative '../instruction_base'
+
+module N65
+
+
+  ####
+  ##  This directive to include bytes
+  class ASCII < InstructionBase
+
+
+    ####
+    ##  Try to parse an incbin directive
+    def self.parse(line)
+      match_data = line.match(/^\.ascii\s+"([^"]+)"$/)
+      return nil if match_data.nil?
+      ASCII.new(match_data[1])
+    end
+
+
+    ####
+    ##  Initialize with filename
+    def initialize(string)
+      @string = string
+    end
+
+
+    ####
+    ##  Execute on the assembler
+    def exec(assembler)
+      assembler.write_memory(@string.bytes)
+    end
+
+
+    ####
+    ##  Display
+    def to_s
+      ".ascii \"#{@string}\""
+    end
+
+  end
+
+end

data/lib/n65/directives/bytes.rb

@@ -0,0 +1,102 @@
+require_relative '../instruction_base'
+require_relative '../regexes.rb'
+
+module N65
+
+
+  ####
+  ##  This directive to include bytes
+  class Bytes < InstructionBase
+
+    ####  Custom Exceptions
+    class InvalidByteValue < StandardError; end
+
+
+    ####
+    ##  Try to parse an incbin directive
+    def self.parse(line)
+      match_data = line.match(/^\.bytes\s+(.+)$/)
+      return nil if match_data.nil?
+
+      bytes_array = match_data[1].split(',').map do |byte_string|
+
+        ##  Does byte_string represent a numeric literal, or is it a symbol?
+        ##  In numeric captures $2 is always binary, $1 is always hex
+
+        case byte_string.strip
+        when Regexp.new("^#{Regexes::Num8}$")
+          $2.nil? ? $1.to_i(16) : $2.to_i(2)
+
+        when Regexp.new("^#{Regexes::Num16}$")
+          value = $2.nil? ? $1.to_i(16) : $2.to_i(2)
+
+          ##  Break value up into two bytes
+          high = (0xff00 & value) >> 8
+          low  = (0x00ff & value)
+          [low, high]
+        when Regexp.new("^#{Regexes::Sym}$")
+          $1
+        else
+          fail(InvalidByteValue, byte_string)
+        end
+      end.flatten
+
+      Bytes.new(bytes_array)
+    end
+
+
+    ####
+    ##  Initialize with filename
+    def initialize(bytes_array)
+      @bytes_array = bytes_array
+    end
+
+
+    ####
+    ##  Execute on the assembler
+    def exec(assembler)
+
+      promise = assembler.with_saved_state do |saved_assembler|
+        @bytes_array.map! do |byte|
+          case byte
+          when Fixnum
+            byte
+          when String
+            value = saved_assembler.symbol_table.resolve_symbol(byte)
+          else
+            fail(InvalidByteValue, byte)
+          end
+        end
+        saved_assembler.write_memory(@bytes_array)
+      end
+
+      begin
+        promise.call
+      rescue SymbolTable::UndefinedSymbol
+        ##  Write the bytes but assume a zero page address for all symbols
+        ##  And just write 0xDE for a placeholder
+        placeholder_bytes = @bytes_array.map do |byte|
+          case bytes
+          when Fixnum
+            byte
+          when String
+            0xDE
+          else
+            fail(InvalidByteValue, byte)
+          end
+        end
+        assembler.write_memory(placeholder_bytes)
+        return promise
+      end
+    end
+
+
+    ####
+    ##  Display, I don't want to write all these out
+    def to_s
+      ".bytes (#{@bytes_array.length})"
+    end
+
+  end
+
+end

data/lib/n65/directives/dw.rb

@@ -0,0 +1,86 @@
+require_relative '../instruction_base'
+
+module N65
+
+
+  ####
+  ##  This directive instruction can include a binary file
+  class DW < InstructionBase
+
+    ####
+    ##  Try to parse a dw directive
+    def self.parse(line)
+
+      ##  Maybe it is a straight up bit of hex
+      match_data = line.match(/^\.dw\s+\$([0-9A-F]{1,4})$/)
+      unless match_data.nil?
+        word = match_data[1].to_i(16)
+        return DW.new(word)
+      end
+
+      ##  Or maybe it points to a symbol
+      match_data = line.match(/^\.dw\s+([A-Za-z_][A-Za-z0-9_\.]+)/)
+      unless match_data.nil?
+        symbol = match_data[1]
+        return DW.new(symbol)
+      end
+      nil
+    end
+
+
+    ####
+    ##  Initialize with filename
+    def initialize(value)
+      @value = value
+    end
+
+
+    ####
+    ##  Execute on the assembler, now in this case value may
+    ##  be a symbol that needs to be resolved, if so we return
+    ##  a lambda which can be executed later, with the promise
+    ##  that that symbol will have then be defined
+    ##  This is a little complicated, I admit.
+    def exec(assembler)
+
+      promise = assembler.with_saved_state do |saved_assembler|
+        value = saved_assembler.symbol_table.resolve_symbol(@value)
+        bytes = [value & 0xFFFF].pack('S').bytes
+        saved_assembler.write_memory(bytes)
+      end
+
+
+      ##  Try to execute it now, or setup the promise to return
+      case @value
+      when Fixnum
+        bytes = [@value & 0xFFFF].pack('S').bytes
+        assembler.write_memory(bytes)
+      when String
+        begin
+          promise.call
+        rescue SymbolTable::UndefinedSymbol
+          ##  Must still advance PC before returning promise, so we'll write
+          ##  a place holder value of 0xDEAD
+          assembler.write_memory([0xDE, 0xAD])
+          return promise
+        end
+      else
+        fail("Uknown argument in .dw directive")
+      end
+    end
+
+
+    ####
+    ##  Display
+    def to_s
+      case @value
+      when String
+        ".dw #{@value}"
+      when Fixnum
+        ".dw $%4.X" % @value
+      end
+    end
+
+  end
+
+end

data/lib/n65/directives/enter_scope.rb

@@ -0,0 +1,55 @@
+require_relative '../instruction_base'
+
+module N65
+
+
+  ####
+  ##  This directive to include bytes
+  class EnterScope < InstructionBase
+
+    ####
+    ##  Try to parse an incbin directive
+    def self.parse(line)
+      ##  Anonymous scope
+      match_data = line.match(/^\.scope$/)
+      unless match_data.nil?
+        return EnterScope.new
+      end
+
+      ##  Named scope
+      match_data = line.match(/^\.scope\s+([a-zA-Z][a-zA-Z0-9_]+)$/)
+      return nil if match_data.nil?
+      EnterScope.new(match_data[1])
+    end
+
+
+    ####
+    ##  Initialize with filename
+    def initialize(name = nil)
+      @name = name
+    end
+
+
+    ####
+    ##  Execute on the assembler, also create a symbol referring to 
+    ##  the current pc which contains a hyphen, and is impossible for
+    ##  the user to create.  This makes a scope simultaneously act as
+    ##  a label to the current PC.  If someone tries to use a scope
+    ##  name as a label, it can return the address when the scope opened.
+    def exec(assembler)
+      assembler.symbol_table.enter_scope(@name)
+      unless @name.nil?
+        assembler.symbol_table.define_symbol("-#{@name}", assembler.program_counter)
+      end
+    end
+
+
+    ####
+    ##  Display
+    def to_s
+      ".scope #{@name}"
+    end
+
+  end
+
+end

data/lib/n65/directives/exit_scope.rb

@@ -0,0 +1,35 @@
+require_relative '../instruction_base'
+
+module N65
+
+
+  ####
+  ##  This directive to include bytes
+  class ExitScope < InstructionBase
+
+
+    ####
+    ##  Try to parse an incbin directive
+    def self.parse(line)
+      match_data = line.match(/^\.$/)
+      return nil if match_data.nil?
+      ExitScope.new
+    end
+
+
+    ####
+    ##  Execute on the assembler
+    def exec(assembler)
+      assembler.symbol_table.exit_scope
+    end
+
+
+    ####
+    ##  Display
+    def to_s
+      "."
+    end
+
+  end
+
+end

data/lib/n65/directives/inc.rb

@@ -0,0 +1,67 @@
+require_relative '../instruction_base'
+
+module N65
+
+
+  ####
+  ##  This directive instruction can include another asm file
+  class Inc < InstructionBase
+
+    ####  System include directory
+    SystemInclude = File.dirname(__FILE__) + "/../../../nes_lib"
+
+    ####  Custom Exceptions
+    class FileNotFound < StandardError; end
+
+
+    ####
+    ##  Try to parse an incbin directive
+    def self.parse(line)
+      ##  Do We have a system directory include?
+      match_data = line.match(/^\.inc <([^>]+)>$/)
+      unless match_data.nil?
+        filename = File.join(SystemInclude, match_data[1])
+        return Inc.new(filename)
+      end
+
+      ##  Do We have a project relative directory include?
+      match_data = line.match(/^\.inc "([^"]+)"$/)
+      unless match_data.nil?
+        filename = File.join(Dir.pwd, match_data[1])
+        return Inc.new(filename)
+      end
+
+      ##  Nope, not an inc directive
+      nil
+    end
+
+
+    ####
+    ##  Initialize with filename
+    def initialize(filename)
+      @filename = filename
+    end
+
+
+    ####
+    ##  Execute on the assembler
+    def exec(assembler)
+      unless File.exists?(@filename)
+        fail(FileNotFound, ".inc can't find #{@filename}")
+      end
+      File.read(@filename).split(/\n/).each do |line|
+        assembler.assemble_one_line(line)
+      end
+    end
+
+
+    ####
+    ##  Display
+    def to_s
+      ".inc \"#{@filename}\""
+    end
+
+
+  end
+
+end

data/lib/n65/directives/incbin.rb

@@ -0,0 +1,51 @@
+require_relative '../instruction_base'
+
+module N65
+
+
+  ####
+  ##  This directive instruction can include a binary file
+  class IncBin < InstructionBase
+
+    ####  Custom Exceptions
+    class FileNotFound < StandardError; end
+
+
+    ####
+    ##  Try to parse an incbin directive
+    def self.parse(line)
+      match_data = line.match(/^\.incbin "([^"]+)"$/)
+      return nil if match_data.nil?
+      filename = match_data[1]
+      IncBin.new(filename)
+    end
+
+
+    ####
+    ##  Initialize with filename
+    def initialize(filename)
+      @filename = filename
+    end
+
+
+    ####
+    ##  Execute on the assembler
+    def exec(assembler)
+      unless File.exists?(@filename)
+        fail(FileNotFound, ".incbin can't find #{@filename}")
+      end
+      data = File.read(@filename).unpack('C*')
+      assembler.write_memory(data)
+    end
+
+
+    ####
+    ##  Display
+    def to_s
+      ".incbin \"#{@filename}\""
+    end
+
+
+  end
+
+end

data/lib/n65/directives/ines_header.rb

@@ -0,0 +1,53 @@
+require 'json'
+require_relative '../instruction_base'
+
+module N65
+
+
+  ####
+  ##  This directive instruction can setup an ines header
+  class INESHeader < InstructionBase
+    attr_reader :prog, :char, :mapper, :mirror
+
+
+    ####
+    ##  Implementation of the parser for this directive
+    def self.parse(line)
+      match_data = line.match(/^\.ines (.+)$/)
+      return nil if match_data.nil?
+
+      header = JSON.parse(match_data[1])
+      INESHeader.new(header['prog'], header['char'], header['mapper'], header['mirror'])
+    end
+
+
+    ####
+    ##  Construct a header
+    def initialize(prog, char, mapper, mirror)
+      @prog, @char, @mapper, @mirror = prog, char, mapper, mirror
+    end
+
+
+    ####
+    ##  Exec function the assembler will call
+    def exec(assembler)
+      assembler.set_ines_header(self)
+    end
+
+
+    ####
+    ##  Emit the header bytes, this is not exactly right, but it works for now.
+    def emit_bytes
+      [0x4E, 0x45, 0x53, 0x1a, @prog, @char, @mapper, @mirror, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0]
+    end
+
+
+    ####
+    ##  Display
+    def to_s
+      ".ines {\"prog\": #{@prog}, \"char\": #{@char}, \"mapper\": #{@mapper}, \"mirror\": #{@mirror}}"
+    end
+
+  end
+
+end