def __init__(self, raw_mem, cpu, path_mgr):
self.raw_mem = raw_mem
self.ram_size = raw_mem.ram_size
self.cpu = cpu
self.path_mgr = path_mgr
# create a label manager and error tracker
self.label_mgr = LabelManager()
self.error_tracker = ErrorTracker(cpu, self.label_mgr)
self.label_mgr.error_tracker = self.error_tracker
# set a label for first two dwords
label = LabelRange("zero_page",0,8)
self.label_mgr.add_label(label)
# create memory access
self.mem = MainMemory(self.raw_mem, self.error_tracker)
self.mem.ctx = self
# create memory allocator
self.mem_begin = 0x1000
self.alloc = MemoryAlloc(self.mem, 0, self.ram_size, self.mem_begin, self.label_mgr)
# create segment loader
self.seg_loader = SegmentLoader( self.mem, self.alloc, self.label_mgr, self.path_mgr )
# lib manager
self.lib_mgr = LibManager( self.label_mgr )
# no current process right now
self.process = None
self.proc_list = []
self.tr_list = []
def create_old_dos_guard(self):
# create a guard memory for tracking invalid old dos access
self.dos_guard_base = self.mem.reserve_special_range()
self.dos_guard_size = 0x010000
label = LabelRange("old_dos",self.dos_guard_base, self.dos_guard_size)
self.label_mgr.add_label(label)
log_mem_init.info(label)
def alloc_bstr(self, name, bstr):
size = len(bstr) + 2 # front: count, end: extra zero for safety
addr = self.alloc_mem(size)
label = LabelRange(name, addr, size)
self.label_mgr.add_label(label)
self.mem.access.w_bstr(addr, bstr)
mem = Memory(addr,size,label,self.mem.access)
log_mem_alloc.info("alloc b_str: %s",mem)
self.mem_objs[addr] = mem
return mem
def alloc_cstr(self, name, cstr):
size = len(cstr) + 1
addr = self.alloc_mem(size)
label = LabelRange(name, addr, size)
self.label_mgr.add_label(label)
self.mem.access.w_cstr(addr, cstr)
mem = Memory(addr,size,label,self.mem.access)
log_mem_alloc.info("alloc c_str: %s",mem)
self.mem_objs[addr] = mem
return mem
def alloc_memory(self, name, size, add_label=True):
addr = self.alloc_mem(size)
if add_label:
label = LabelRange(name, addr, size)
self.label_mgr.add_label(label)
else:
label = None
mem = Memory(addr,size,label,self.mem.access)
log_mem_alloc.info("alloc memory: %s",mem)
self.mem_objs[addr] = mem
return mem
def _load_seg(self, ami_bin_file, sys_bin_file):
base_name = os.path.basename(sys_bin_file)
hunk_file = HunkReader()
# does file exist?
if not os.path.isfile(sys_bin_file):
self.error = "Can't find '%s'" % sys_bin_file
return None
# read hunk file
fobj = file(sys_bin_file, "rb")
result = hunk_file.read_file_obj(sys_bin_file, fobj, None)
if result != Hunk.RESULT_OK:
self.error = "Error loading '%s'" % sys_bin_file
return None
# build segments
ok = hunk_file.build_segments()
if not ok:
self.error = "Error building segments for '%s'" % sys_bin_file
return None
# make sure its a loadseg()
if hunk_file.type != Hunk.TYPE_LOADSEG:
self.error = "File not loadSeg()able: '%s'" % sys_bin_file
return None
# create relocator
relocator = HunkRelocate(hunk_file)
# allocate segment memory
sizes = relocator.get_sizes()
names = relocator.get_type_names()
seg_list = SegList(ami_bin_file, sys_bin_file)
addrs = []
for i in xrange(len(sizes)):
size = sizes[i]
seg_size = size + 4 # add segment pointer
seg_addr = self.alloc.alloc_mem(seg_size)
# create label
label = None
name = "%s_%d:%s" % (base_name, i, names[i].replace("HUNK_",
"").lower())
if self.alloc.label_mgr != None:
label = LabelRange(name, seg_addr, seg_size)
self.alloc.label_mgr.add_label(label)
seg = Segment(name, seg_addr, seg_size, label)
seg_list.add(seg)
addrs.append(seg.addr + 4) # begin of segment data/code
# relocate to addresses and return data
datas = relocator.relocate(addrs)
# write to allocated memory
last_addr = None
for i in xrange(len(sizes)):
addr = addrs[i]
self.mem.access.w_data(addr, datas[i])
# write segment pointers
if last_addr != None:
b_addr = addr >> 2 # BCPL segment pointers
self.mem.access.w32(last_addr - 4, b_addr)
last_addr = addr
return seg_list
