n65 0.5.0

data/examples/noise.asm

@@ -0,0 +1,93 @@
+;------------------------------------------------------------------------------
+;  This is a direct port of Michael Martin's tutorial project for NES101
+;  With some modifications to the tile map, and extra comments, and ported to
+;  suit my assembler. - Saf
+;  See:
+;  http://hackipedia.org/Platform/Nintendo/NES/tutorial,%20NES%20programming%20101/NES101.html
+;
+;;;;
+;  Create an iNES header
+.ines {"prog": 1, "char": 0, "mapper": 0, "mirror": 0}
+
+
+;;;;
+;  Setup the interrupt vectors
+.org $FFFA
+.dw vblank
+.dw main
+.dw irq
+
+
+.org $C000
+;;;;
+;  Here is our code entry point, which we'll call main.
+.scope main
+  ;  Disable interrupts and decimal flag
+  sei
+	cld
+
+  ;  Wait for 2 vblanks
+  wait_vb1:
+    lda $2002
+    bpl wait_vb1
+  wait_vb2:
+    lda $2002
+    bpl wait_vb2
+
+  ;  Now we want to initialize the hardware to a known state
+  lda #$00
+  ldx #$00
+  clear_segments:
+    sta $00, X
+    sta $0100, X
+    sta $0200, X
+    sta $0300, X
+    sta $0400, X
+    sta $0500, X
+    sta $0600, X
+    sta $0700, X
+    inx
+    bne clear_segments
+
+  ;  Reset the stack pointer
+  ldx #$FF
+  txs
+
+	; Disable all graphics.
+  lda #$00
+  sta $2000
+  sta $2001
+
+  ;  Init APU
+  ldx #$0F
+  stx $4015
+
+  ;  Turn on noise tone
+  ldx #$85
+  stx $400E
+
+  ;  Set volume to max
+  ldx #$3F
+  stx $400C
+
+  ; Load Length counter
+  ldx #$01
+  stx $400F
+
+  ;  Resume interrupts and loop here forever
+	cli
+  forever:
+    jmp forever
+.
+
+
+;;;;
+;  Update everything on every vblank
+vblank:
+  rti
+
+
+;;;;
+;  Don't do anything on IRQ
+irq:
+  rti

data/examples/pulse_chord.asm

@@ -0,0 +1,213 @@
+;;;;
+;  Create an iNES header
+.ines {"prog": 1, "char": 0, "mapper": 0, "mirror": 0}
+
+
+;;;;
+;  Include all the symbols in the nes library
+.inc <nes.sym>
+
+
+;;;;
+;  Open the prog section bank 0
+.segment prog 0
+
+
+;;;;
+;  Structure to keep track of input
+.org $0000
+.scope controller_state
+  .space b 1
+  .space a 1
+.
+
+
+;;;;
+;  Setup the interrupt vectors
+.org $FFFA
+.dw vblank
+.dw reset
+.dw irq
+
+
+;;;;
+;  Here is our code entry point
+.org $C000
+.scope reset
+  sei                   ; SEt Interrupt (Disables them)
+  cld                   ; CLear Decimal Mode
+
+  ldx #$ff              
+  txs                   ; Set the stack pointer
+
+  ldx #$00
+  stx nes.ppu.control
+  stx nes.ppu.mask      ; Disable Vblank & Rendering
+
+  jsr zero_apu          ; Zero all APU registers
+
+  ;  We need to wait for at least 2 Vblanks to happen
+  ;  before we know the PPU has stabilized at startup
+  ;  Here we wait for the first one.
+  wait_vblank1:
+    bit nes.ppu.status
+    bpl wait_vblank1
+
+  ;  Before we wait for the second vblank, lets
+  ;  zero all of the working RAM $0 to $800
+  ;  The $200s are sprite OAM, and should be set to $ff
+  clear_ram:
+    lda #$00
+    sta $00, x
+    sta $100, x
+    sta $300, x
+    sta $400, x
+    sta $500, x
+    sta $600, x
+    sta $700, x
+    lda #$ff
+    sta $200, x
+    inx
+    bne clear_ram
+
+  ;  Now wait for the second vblank
+  wait_vblank2:
+    bit nes.ppu.status
+    bpl wait_vblank2
+
+  jsr initialize
+
+  forever:
+    jmp forever
+  rti
+.
+
+
+;;;;
+;  Initialize everything
+.scope initialize
+  ;  Enable pulse1 and pulse2 in the APU
+  lda #%00000011
+  sta nes.apu.channel_enable
+
+  ;  Initialize the controller states
+  lda #$00
+  sta controller_state.a zp
+  sta controller_state.b zp
+
+  ;  Reenable interrupts, Turn Vblank back on
+  lda #%10000000
+  sta nes.ppu.control
+  cli
+  rts
+.
+
+
+;;;;
+;  VBlank is called 60 times per second
+.scope vblank
+  jsr read_input
+  rti
+.
+
+
+;;;;
+;  IRQ, we are not using
+.scope irq
+  rti
+.
+
+
+;;;;
+;  Zero all the APU registers
+.scope zero_apu
+  lda #$00
+  ldx #$00
+  loop:
+    sta $4000, x
+    inx
+    cpx $18
+    bne loop
+  rts
+.
+
+
+;;;;
+;  Read input from controller 1
+.scope read_input
+  lda #$01                ; strobe joypad
+  sta nes.controller1
+  lda #$00
+  sta nes.controller1
+
+  ;  Handle Button A
+  lda nes.controller1
+  and #$01
+  beq update_a_state
+
+  ;  A is pressed, but did it just change to being pressed now?
+  ldx controller_state.a zp
+  bne update_a_state
+
+  ;  do the thing A does
+  jsr play_e329
+
+  update_a_state:
+    sta controller_state.a zp
+
+  ;  Handle Button B
+  lda nes.controller1
+  and #$01
+  beq update_b_state
+
+  ;  B is pressed, but did it just change to being pressed now?
+  ldx controller_state.b zp
+  bne update_b_state
+
+  ;  Do the thing B does
+  jsr play_a220
+
+  update_b_state:
+    sta controller_state.b zp
+
+  rts
+.
+
+
+;;;;
+;;  This will play an A 220hz note
+;;  On the pulse1 generator
+.scope play_a220
+  pha
+  lda #%10011111
+  sta nes.apu.pulse1.control
+
+  lda #%11111011
+  sta nes.apu.pulse1.ft
+
+  lda #%11111001
+  sta nes.apu.pulse1.ct
+
+  pla
+  rts
+.
+
+
+;;;;
+;;  This will play an E 329.63hz note
+;;  On the pulse2 generator
+.scope play_e329
+  pha
+  lda #%10011111
+  sta nes.apu.pulse2.control
+
+  lda #%01010010
+  sta nes.apu.pulse2.ft
+
+  lda #%11111001
+  sta nes.apu.pulse2.ct
+
+  pla
+  rts
+.
+

data/lib/n65.rb

@@ -0,0 +1,243 @@
+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
+
+
+    ####
+    ##  Assemble from an asm file to a nes ROM
+    def self.from_file(infile, outfile)
+      fail(FileNotFound, infile) unless File.exists?(infile)
+
+      assembler = self.new
+      program = File.read(infile)
+
+      puts "Building #{infile}"
+      ##  Process each line in the file
+      program.split(/\n/).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}")
+          exit(1)
+        end
+        print '.'
+      end
+      puts
+
+      ##  Second pass to resolve any missing symbols.
+      print "Second pass, resolving symbols..."
+      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)
+      end
+      puts "All Done :)"
+    end
+
+
+    ####
+    ##  Initialize with a bank 1 of prog space for starters
+    def initialize
+      @ines_header = nil
+      @program_counter = 0x0
+      @current_segment = :prog
+      @current_bank = 0x0
+      @symbol_table = SymbolTable.new
+      @promises = []
+      @virtual_memory = {
+        :prog => [MemorySpace.create_prog_rom],
+        :char => []
+      }
+    end
+
+
+    ####
+    ##  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)
+    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
+    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.
+    def assemble_one_line(line)
+      parsed_object = Parser.parse(line)
+
+      unless parsed_object.nil?
+        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)
+      end
+    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
+      end
+    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
+    def with_saved_state(&block)
+      ##  Save the current state of the assembler
+      old_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)
+        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
+    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
+    def set_ines_header(ines_header)
+      fail(INESHeaderAlreadySet) unless @ines_header.nil?
+      @ines_header = ines_header
+    end
+
+
+    ####
+    ##  Set the program counter
+    def program_counter=(address)
+      fail(AddressOutOfRange) unless address_within_range?(address)
+      @program_counter = address
+    end
+
+
+    ####
+    ##  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
+      @current_segment = segment
+    end
+
+
+    ####
+    ##  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
+      @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
+
+      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]))
+      end
+
+      chars.each do |char|
+        offset += rom.write(offset, char.read(0x0, MemorySpace::BankSizes[:char]))
+      end
+      rom.emit_bytes.pack('C*')
+    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)
+    end
+
+  end
+
+end