n65 0.5.0

data/lib/n65/directives/label.rb

@@ -0,0 +1,46 @@
+
+module N65
+
+  ####
+  ##  This class represents a label, and will create 
+  ##  an entry in the symbol table associated with 
+  ##  the address it appears at.
+  class Label
+
+    ####
+    ##  Try to parse as a label
+    def self.parse(line)
+      match_data = line.match(/^([a-zA-Z][a-zA-Z0-9_]+):$/)
+      unless match_data.nil?
+        label = match_data[1].to_sym
+        return self.new(label)
+      end
+      nil
+    end
+
+
+    ####
+    ##  Create a new label object
+    def initialize(symbol)
+      @symbol = symbol
+    end
+
+
+    ####
+    ##  Create an entry in the symbol table for this label
+    def exec(assembler)
+      program_counter = assembler.program_counter
+      assembler.symbol_table.define_symbol(@symbol, program_counter)
+    end
+
+
+    ####
+    ##  Display
+    def to_s
+      "#{@symbol}:"
+    end
+
+
+  end
+
+end

data/lib/n65/directives/org.rb

@@ -0,0 +1,47 @@
+require_relative '../instruction_base'
+
+module N65
+
+  ####
+  ##  This is an .org directive
+  class Org < InstructionBase
+    attr_reader :address
+
+    ####
+    ##  Try to parse an .org statement
+    def self.parse(line)
+      match_data = line.match(/^\.org\s+\$([0-9A-Fa-f]{4})$/)
+      return nil if match_data.nil?
+      address = match_data[1].to_i(16)
+      Org.new(address)
+    end
+
+    
+    ####
+    ##  Initialized with address to switch to
+    def initialize(address)
+      @address = address
+    end
+
+
+    ####
+    ##  Exec this directive on the assembler
+    def exec(assembler)
+      assembler.program_counter = address
+    end
+
+
+    ####
+    ##  Display
+    def to_s
+      if @address <= 0xff
+        ".org $%2.X" % @address
+      else
+        ".org $%4.X" % @address
+      end
+    end
+
+  end
+
+end
+

data/lib/n65/directives/segment.rb

@@ -0,0 +1,45 @@
+require_relative '../instruction_base' 
+module N65
+
+
+  ####
+  ##  This directive instruction can include a binary file
+  class Segment < InstructionBase
+
+    ####
+    ##  Try to parse a dw directive
+    def self.parse(line)
+      match_data = line.match(/^.segment (prog|char) (\d+)$/i)
+      unless match_data.nil?
+        _, segment, bank = match_data.to_a
+        return Segment.new(segment, bank.to_i)
+      end
+      nil
+    end
+
+
+    ####
+    ##  Initialize with filename
+    def initialize(segment, bank)
+      @bank = bank
+      @segment = segment
+    end
+
+
+    ####
+    ##  Execute the segment and bank change on the assembler
+    def exec(assembler)
+      assembler.current_segment = @segment
+      assembler.current_bank = @bank
+    end
+
+
+    ####
+    ##  Display
+    def to_s
+      ".segment #{@segment} #{@bank}"
+    end
+
+  end
+
+end

data/lib/n65/directives/space.rb

@@ -0,0 +1,46 @@
+require_relative '../instruction_base'
+
+module N65
+
+
+  ####
+  ##  This directive gives a symbolic name for memory and creates space for a variable in RAM
+  class Space < InstructionBase
+
+    ####
+    ##  Try to parse a .space directive
+    def self.parse(line)
+      match_data = line.match(/^.space\s+([a-zA-Z]?[a-zA-Z0-9_]+?)\s+([0-9]+)$/)
+      return nil if match_data.nil?
+      _, name, size = match_data.to_a
+
+      Space.new(name, size.to_i)
+    end
+
+
+    ####
+    ##  Initialize some memory space with a name
+    def initialize(name, size)
+      @name = name
+      @size = size
+    end
+
+
+    ####
+    ##  .space creates a symbol at the current PC, and then advances PC by size
+    def exec(assembler)
+      program_counter = assembler.program_counter
+      assembler.symbol_table.define_symbol(@name, program_counter)
+      assembler.program_counter += @size
+    end
+
+
+    ####
+    ##  Display
+    def to_s
+      ".space #{@name} #{@size}"
+    end
+
+  end
+
+end

data/lib/n65/front_end.rb

@@ -0,0 +1,90 @@
+require 'optparse'
+require_relative '../n65'
+
+module N65
+
+  ####
+  ##  This class handles the front end aspects, 
+  ##  parsing the commandline options and running the assembler
+  class FrontEnd
+
+    ####
+    ##  Initialize with ARGV commandline
+    def initialize(argv)
+      @options = {:output_file => nil}
+      @argv = argv.dup
+    end
+
+
+    ####
+    ##  Run the assembler
+    def run
+      ##  First use the option parser
+      parser = create_option_parser
+      parser.parse!(@argv)
+
+      ##  Whatever is leftover in argv the input files
+      if @argv.size.zero?
+        STDERR.puts("No input files")
+        exit(1)
+      end
+
+      ##  Only can assemble one file at once for now
+      if @argv.size != 1
+        STDERR.puts "Can only assemble one input file at once :("
+        exit(1)
+      end
+
+      input_file = @argv.shift
+
+      ##  Make sure the input file exists
+      unless File.exists?(input_file)
+        STDERR.puts "Input file #{input_file} does not exist"
+        exit(1)
+      end
+      
+      ##  Maybe they didn't provide an output file name, so we'll guess
+      if @options[:output_file].nil?
+        ext = File.extname(input_file)
+        @options[:output_file] = input_file.gsub(ext, '') + '.nes'
+      end
+
+      if @options.values.any?(&:nil?)
+        STDERR.puts "Missing options try --help"
+        exit(1)
+      end
+
+      #begin
+        N65::Assembler.from_file(input_file, @options[:output_file])
+      #rescue StandardError => error
+        #STDERR.puts("Assemble Failed!")
+        #STDERR.puts(error.class)
+        #if error.message
+          #STDERR.puts(error.message)
+        #end
+        #exit(1)
+      #end
+    end
+
+    private
+
+    ####
+    ##  Create a commandline option parser
+    def create_option_parser
+      OptionParser.new do |opts|
+        opts.banner = "Usage: #{$0} [options] <input_file.asm>"
+
+        opts.on('-o', '--outfile filename', 'outfile') do |output_file|
+          @options[:output_file] = output_file;
+        end
+
+        opts.on('-h', '--help', 'Displays Help') do
+          puts opts
+          exit
+        end
+      end
+    end
+
+  end
+
+end

data/lib/n65/instruction.rb

@@ -0,0 +1,308 @@
+require_relative 'opcodes'
+require_relative 'regexes'
+
+module N65
+
+  ####
+  ##  Represents a single 6502 Instruction
+  class Instruction
+    attr_reader :op, :arg, :mode, :hex, :description, :length, :cycle, :boundry_add, :flags, :address
+
+    ##  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
+
+    AddressingModes = {
+      :relative => {
+        :example     => 'B** my_label',
+        :display     => '%s $%.4X',
+        :regex       => /$^/i,  #  Will never match this one
+        :regex_label => /^#{Branches}\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}$/
+      },
+
+      :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_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$/
+      },
+
+      :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_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_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}$/
+      }
+    }
+
+    ####
+    ##  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
+        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
+          _, 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
+            return Instruction.new(op, arg_hex.to_i(16), mode)
+          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?
+          unless parse_info[:regex_label].nil?
+
+            ##  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
+              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 match_array.size == 4
+                _, op, byte_selector, arg = match_array
+                return Instruction.new(op, arg, mode, byte_selector.to_sym)
+              else
+                _, op, arg = match_array
+                return Instruction.new(op, arg, mode)
+              end
+            end
+          end
+        end
+      end
+
+      ##  We just don't recognize this line of asm, it must be a Syntax Error
+      fail(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
+    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)
+
+      @op = op.downcase.to_sym
+      definition = OpCodes[@op]
+      fail(InvalidInstruction, op) if definition.nil?
+
+      @arg = arg
+
+      ##  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
+
+      @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
+    def zero_page_instruction?
+      [: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.
+    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.
+        @arg = apply_byte_selector(@byte_selector, @arg)
+
+        ##  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
+        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.
+          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.
+          assembler.write_memory(placeholder)
+          return promise
+        end
+      end
+    end
+
+
+    ####
+    ##  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)
+      when :<
+        low_byte(value)
+      end
+    end
+
+
+    ####
+    ##  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")
+        end
+        [@hex, @arg]
+      when 3
+        [@hex] + break_16(@arg)
+      else
+        fail("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
+    def break_16(integer)
+      [integer & 0x00FF, (integer & 0xFF00) >> 8]
+    end
+
+
+    ####
+    ##  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
+    def low_byte(word)
+      word & 0xFF
+    end
+
+  end
+
+end