n65 0.5.0

data/lib/n65/instruction_base.rb

@@ -0,0 +1,29 @@
+
+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")
+    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

@@ -0,0 +1,150 @@
+
+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.
+  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
+    BankSizes = {
+      :ines => 0x10,     #  16b
+      :prog => 0x4000,   #  16kb
+      :char => 0x2000,   #   8kb
+    }
+
+
+    ####
+    ##  Create a new PROG ROM
+    def self.create_prog_rom
+      self.create_bank(:prog)
+    end
+
+
+    ####
+    ##  Create a new CHAR ROM
+    def self.create_char_rom
+      self.create_bank(:char)
+    end
+
+
+    ####
+    ##  Create a new bank
+    def self.create_bank(type)
+      self.new(BankSizes[type], type)
+    end
+
+
+    ####
+    ##  Create a completely zeroed memory space
+    def initialize(size, type)
+      @type = type
+      @memory = Array.new(size, 0x0)
+    end
+
+
+    ####
+    ##  Normalized read from memory
+    def read(address, count)
+      from_normalized = normalize_address(address)
+      to_normalized = normalize_address(address + (count - 1))
+      ensure_addresses_in_bounds!([from_normalized, to_normalized])
+
+      @memory[from_normalized..to_normalized]
+    end
+
+
+    ####
+    ##  Normalized write to memory
+    def write(address, bytes)
+      from_normalized = normalize_address(address)
+      to_normalized = normalize_address(address + bytes.size - 1)
+      ensure_addresses_in_bounds!([from_normalized, to_normalized])
+
+      bytes.each_with_index do |byte, index|
+        @memory[from_normalized + index] = byte
+      end
+      bytes.size
+    end
+
+
+    ####
+    ##  Return the memory as an array of bytes to write to disk
+    def emit_bytes
+      @memory
+    end
+
+
+    private
+
+    ####
+    ##  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"))
+        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.
+    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))
+      when :char
+        unless address_inside_char_rom?(address)
+          fail(AccessOutsideCharRom, sprintf("Address $%.4X is outside CHAR ROM", address))
+        end
+        address
+      else
+        address
+      end
+    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

@@ -0,0 +1,9 @@
+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")
+
+end

data/lib/n65/parser.rb

@@ -0,0 +1,85 @@
+
+module N65
+
+  require_relative 'instruction'
+  require_relative 'directives/ines_header'
+  require_relative 'directives/org'
+  require_relative 'directives/segment'
+  require_relative 'directives/incbin'
+  require_relative 'directives/inc'
+  require_relative 'directives/dw'
+  require_relative 'directives/bytes'
+  require_relative 'directives/ascii'
+  require_relative 'directives/label'
+  require_relative 'directives/enter_scope'
+  require_relative 'directives/exit_scope'
+  require_relative 'directives/space'
+
+
+
+  ####
+  ##  This class determines what sort of line of code we
+  ##  are dealing with, parses one line, and returns an 
+  ##  object deriving from InstructionBase
+  class Parser
+
+    ####  Custom Exceptions
+    class CannotParse < StandardError; end
+
+
+    Directives = [INESHeader, Org, Segment, IncBin, Inc, DW, Bytes, ASCII, EnterScope, ExitScope, Space]
+
+    ####
+    ##  Parses a line of program source into an object
+    ##  deriving from base class InstructionBase
+    def self.parse(line)
+      sanitized = sanitize_line(line)
+      return nil if sanitized.empty?
+
+      ##  First check to see if we have a label.
+      label = Label.parse(sanitized)
+      unless label.nil?
+        return label
+      end
+
+      ##  Now check if we have a directive
+      directive = parse_directive(sanitized)
+      unless directive.nil?
+        return directive
+      end
+
+      ##  Now, surely it is an asm instruction?
+      instruction = Instruction.parse(sanitized)
+      unless instruction.nil?
+        return instruction
+      end
+
+      ##  Guess not, we have no idea
+      fail(CannotParse, sanitized)
+    end
+
+
+    private
+    ####
+    ##  Sanitize one line of program source
+    def self.sanitize_line(line)
+      code = line.split(';').first || ""
+      code.strip.chomp
+    end
+
+
+    ####
+    ##  Try to Parse a directive
+    def self.parse_directive(line)
+      if line.start_with?('.')
+        Directives.each do |directive|
+          object = directive.parse(line)
+          return object unless object.nil?
+        end
+      end
+      nil
+    end
+
+  end
+
+end

data/lib/n65/regexes.rb

@@ -0,0 +1,33 @@
+
+
+module N65
+
+  ####
+  ##  All the regexes used to parse in one module
+  module Regexes
+    ##  Mnemonics 
+    Mnemonic  = '([A-Za-z]{3})'
+    Branches  = '(BPL|BMI|BVC|BVS|BCC|BCS|BNE|BEQ|bpl|bmi|bvc|bvs|bcc|bcs|bne|beq)'
+
+    ##  Numeric Literals
+    Hex8      = '\$([A-Fa-f0-9]{1,2})'
+    Hex16     = '\$([A-Fa-f0-9]{3,4})'
+
+    Bin8      = '%([01]{1,8})'
+    Bin16     = '%([01]{9,16})'
+
+    Num8      = Regexp.union(Regexp.new(Hex8), Regexp.new(Bin8)).to_s
+    Num16     = Regexp.union(Regexp.new(Hex16),Regexp.new(Bin16)).to_s
+
+    Immediate = "\##{Num8}"
+
+    ##  Symbols, must begin with a letter, and supports dot syntax
+    Sym       = '([a-zA-Z][a-zA-Z\d_\.]*)'
+
+
+    ##  The X or Y register
+    XReg      = '[Xx]'
+    YReg      = '[Yy]'
+  end
+
+end

data/lib/n65/symbol_table.rb

@@ -0,0 +1,198 @@
+
+module N65
+
+  class SymbolTable
+    attr_accessor :scope_stack
+
+    #####  Custom Exceptions
+    class InvalidScope < StandardError; end
+    class UndefinedSymbol < StandardError; end
+    class CantExitScope < StandardError; end
+
+
+    ####
+    ##  Initialize a symbol table that begins in global scope
+    def initialize
+      @symbols = {
+        :global => {}
+      }
+      @anonymous_scope_number = 0
+      @scope_stack = [:global]
+    end
+
+
+    ####
+    ##  Define a new scope, which can be anonymous or named
+    ##  and switch into that scope
+    def enter_scope(name = nil)
+      name = generate_name if name.nil? 
+      name = name.to_sym
+      scope = current_scope
+      if scope.has_key?(name)
+        #path_string = generate_scope_path(path_ary)
+        fail(InvalidScope, "Scope: #{name} already exists")
+      end
+      scope[name] = {}
+      @scope_stack.push(name)
+    end
+
+
+    ####
+    ##  Exit the current scope
+    def exit_scope
+      if @scope_stack.size == 1
+        fail(CantExitScope, "You cannot exit global scope")
+      end
+      @scope_stack.pop
+    end
+
+
+    ####
+    ##  Define a symbol in the current scope
+    def define_symbol(symbol, value)
+      scope = current_scope
+      scope[symbol.to_sym] = value
+    end
+
+
+=begin
+    ####
+    ##  Resolve symbol to a value, for example:
+    ##  scope1.scope2.variable
+    ##  It is not nessessary to specify the root scope :global
+    ##  You can just address anything by name in the current scope
+    ##  To go backwards in scope you need to write the full path
+    ##  like global.sprite.x or whatever
+    def resolve_symbol_old(name)
+
+      value = if name.include?('.')
+        path_ary = name.split('.').map(&:to_sym)
+        symbol = path_ary.pop
+        path_ary.shift if path_ary.first == :global
+        scope = retreive_scope(path_ary)
+        ##  We also try to look up the address associated with the scope
+        root = "-#{symbol}".to_sym
+        v = scope[symbol]
+        v.kind_of?(Hash) ? v[root] : v
+      else
+        root = "-#{name}".to_sym
+        scope = current_scope
+        ##  We also try to look up the address associated with the scope
+        v = scope[name.to_sym] || scope[root]
+        v.kind_of?(Hash) ? v[root] : v
+      end
+
+      if value.nil?
+        fail(UndefinedSymbol, name)
+      end
+      value
+    end
+=end
+
+
+    ####
+    ##  
+    def resolve_symbol(name)
+      method = name.include?('.') ? :resolve_symbol_dot_syntax : :resolve_symbol_scoped
+      value = self.send(method, name)
+
+      fail(UndefinedSymbol, name) if value.nil?
+      value
+    end
+
+
+    ####
+    ##  Resolve symbol by working backwards through each
+    ##  containing scope.  Similarly named scopes shadow outer scopes
+    def resolve_symbol_scoped(name)
+      root = "-#{name}".to_sym
+      stack = @scope_stack.dup
+      loop do
+        scope = retreive_scope(stack)
+
+        ##  We see if there is a key either under this name, or root
+        v = scope[name.to_sym] || scope[root]
+        v = v.kind_of?(Hash) ? v[root] : v
+
+        return v unless v.nil?
+
+        ##  Pop the stack so we can decend to the parent scope, if any
+        stack.pop
+        return nil if stack.empty?
+      end
+    end
+
+
+    ####
+    ##  Dot syntax means to check an absolute path to the symbol
+    ##  :global is ignored if it is provided as part of the path
+    def resolve_symbol_dot_syntax(name)
+      path_ary = name.split('.').map(&:to_sym)
+      symbol = path_ary.pop
+      root = "-#{symbol}".to_sym
+      path_ary.shift if path_ary.first == :global
+
+      scope = retreive_scope(path_ary)
+
+      ##  We see if there is a key either under this name, or root
+      v = scope[symbol]
+      v.kind_of?(Hash) ? v[root] : v
+    end
+
+
+    ####
+    ##  Export the symbol table as YAML
+    def export_to_yaml
+      @symbols.to_yaml.gsub(/(\d+)$/) do |match|
+        integer = match.to_i
+        sprintf("0x%.4X", integer)
+      end
+    end
+
+
+    private
+
+    ####
+    ##  A bit more clearly states to get the current scope
+    def current_scope
+      retreive_scope
+    end
+
+
+    ####
+    ##  Retrieve a reference to a scope, current scope by default
+    def retreive_scope(path_ary = @scope_stack)
+      path_ary = path_ary.dup
+      path_ary.unshift(:global) unless path_ary.first == :global
+
+      path_ary.inject(@symbols) do |scope, path_component|
+        new_scope = scope[path_component.to_sym]
+
+        if new_scope.nil?
+          path_string = generate_scope_path(path_ary)
+          message = "Resolving scope: #{path_string} failed at #{path_component}"
+          fail(InvalidScope, message) if new_scope.nil?
+        end
+
+        new_scope
+      end
+    end
+
+
+    ####
+    ##  Generate a scope path from an array
+    def generate_scope_path(path_ary)
+      path_ary.join('.')
+    end
+
+
+    ####
+    ##  Generate an anonymous scope name
+    def generate_name
+      @anonymous_scope_number += 1
+      "anonymous_#{@anonymous_scope_number}"
+    end
+
+  end
+
+end