1
0
mirror of https://github.com/safiire/n65.git synced 2024-12-13 06:29:16 +00:00
n65/lib/memory_space.rb
2015-03-29 10:19:19 -07:00

151 lines
3.6 KiB
Ruby

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