1
0
mirror of https://github.com/safiire/n65.git synced 2024-12-13 06:29:16 +00:00
n65/lib/assembler.rb

183 lines
5.6 KiB
Ruby
Raw Normal View History

require_relative 'module_functions'
require_relative 'opcodes'
require_relative 'memory'
require_relative 'directive'
require_relative 'instruction'
require_relative 'label'
2015-02-18 03:05:37 +00:00
module Assembler6502
####
## The Main Assembler
class Assembler
2015-02-18 03:05:37 +00:00
## Custom exceptions
class INESHeaderNotFound < StandardError; end
class MapperNotSupported < StandardError; end
2015-02-18 03:05:37 +00:00
####
## Assemble from an asm file to a nes ROM
def self.from_file(infile, outfile)
assembler = self.new(File.read(infile))
byte_array = assembler.assemble
File.open(outfile, 'w') do |fp|
fp.write(byte_array.pack('C*'))
end
end
####
## Instantiate a new Assembler with a full asm
## file as given in a string.
def initialize(assembly_code)
@ines_header = nil
@assembly_code = assembly_code
2015-02-18 03:05:37 +00:00
end
####
## New ROM assembly, this is so simplified, and needs to take banks into account
## This will happen once I fully understand mappers and banks.
def assemble
## Assemble into a virtual memory space
virtual_memory = assemble_in_virtual_memory
## First we need to be sure we have an iNES header
fail(MapperNotSupported, "Mapper #{@ines_header.mapper} not supported") if @ines_header.mapper != 0
## First we need to be sure we have an iNES header
fail(INESHeaderNotFound) if @ines_header.nil?
## Now we want to create a ROM layout for PROG
## This is simplified and only holds max two PROG entries
prog_rom = MemorySpace.new(@ines_header.prog * MemorySpace::ProgROMSize)
case @ines_header.prog
when 0
fail("You must have at least one PROG section")
exit(1)
when 1
prog_rom.write(0x0, virtual_memory.read(0xc000, MemorySpace::ProgROMSize))
when 2
prog_rom.write(0x0, virtual_memory.read(0x8000, MemorySpace::ProgROMSize))
prog_rom.write(MemorySpace::ProgROMSize, virtual_memory.read(0xC000, MemorySpace::ProgROMSize))
else
fail("I can't support more than 2 PROG sections")
exit(1)
end
## Now we want to create a ROM layout for CHAR
## This is simplified and only holds max two CHAR entries
char_rom = MemorySpace.new(@ines_header.char * MemorySpace::CharROMSize)
case @ines_header.char
when 0
when 1
char_rom.write(0x0, virtual_memory.read(0x0000, MemorySpace::CharROMSize))
when 2
char_rom.write(0x0, virtual_memory.read(0x0000, MemorySpace::CharROMSize))
char_rom.write(MemorySpace::CharROMSize, virtual_memory.read(0x2000, MemorySpace::CharROMSize))
else
fail("I can't support more than 2 CHAR sections")
exit(1)
end
if @ines_header.char.zero?
@ines_header.emit_bytes + prog_rom.emit_bytes
else
@ines_header.emit_bytes + prog_rom.emit_bytes + char_rom.emit_bytes
end
end
private
2015-02-18 03:05:37 +00:00
####
## Run the assembly process into a virtual memory object
def assemble_in_virtual_memory
address = 0x0
labels = {}
memory = MemorySpace.new
unresolved_instructions = []
puts "Assembling, first pass..."
@assembly_code.split(/\n/).each do |raw_line|
sanitized = Assembler6502.sanitize_line(raw_line)
next if sanitized.empty?
parsed_line = Assembler6502::Instruction.parse(sanitized, address)
2015-02-18 03:05:37 +00:00
case parsed_line
when INESHeader
fail(SyntaxError, "Already got ines header") unless @ines_header.nil?
@ines_header = parsed_line
puts "\tGot iNES Header"
when Org
address = parsed_line.address
puts "\tMoving to address: $%X" % address
2015-02-18 03:05:37 +00:00
when Label
puts "\tLabel #{parsed_line.label} = $%X" % parsed_line.address
2015-02-18 03:05:37 +00:00
labels[parsed_line.label.to_sym] = parsed_line
2015-02-18 03:05:37 +00:00
when Instruction
if parsed_line.unresolved_symbols?
puts "\tSaving instruction with unresolved symbols #{parsed_line}, for second pass"
unresolved_instructions << parsed_line
else
2015-02-22 13:59:03 +00:00
puts "\tWriting instruction #{parsed_line}"
memory.write(parsed_line.address, parsed_line.emit_bytes)
end
2015-02-18 03:05:37 +00:00
address += parsed_line.length
when IncBin
2015-02-22 13:59:03 +00:00
puts "\t Including binary file #{parsed_line.filepath}"
memory.write(parsed_line.address, parsed_line.emit_bytes)
address += parsed_line.size
when DW
if parsed_line.unresolved_symbols?
2015-02-22 13:59:03 +00:00
puts "\tSaving #{parsed_line} directive with unresolved symbols, for second pass"
unresolved_instructions << parsed_line
else
2015-02-22 13:59:03 +00:00
puts "\tWriting #{parsed_line} to memory"
memory.write(address, parsed_line.emit_bytes)
end
address += 2
when Bytes
bytes = parsed_line.emit_bytes
puts "\tWriting raw #{bytes.size} bytes to #{sprintf("$%X", address)}"
memory.write(address, bytes)
address += bytes.size
when ASCII
bytes = parsed_line.emit_bytes
puts "\tWriting ascii string to memory \"#{bytes.pack('C*')}\""
memory.write(address, bytes)
address += bytes.size
2015-02-18 03:05:37 +00:00
else
fail(SyntaxError, sprintf("%.4X: Failed to parse: #{parsed_line}", address))
2015-02-18 03:05:37 +00:00
end
end
2015-02-22 13:59:03 +00:00
puts "Second pass: Resolving Symbols..."
unresolved_instructions.each do |instruction|
2015-02-18 03:05:37 +00:00
if instruction.unresolved_symbols?
instruction.resolve_symbols(labels)
end
2015-02-22 13:59:03 +00:00
puts "\tResolved #{instruction}"
memory.write(instruction.address, instruction.emit_bytes)
2015-02-18 03:05:37 +00:00
end
puts 'Done'
memory
end
2015-02-18 03:05:37 +00:00
end
end