def __init__(self, path_mgr, doslist_mgr, base_addr, size):
self.path_mgr = path_mgr
self.doslist_mgr = doslist_mgr
self.base_addr = base_addr
self.cur_addr = base_addr
log_lock.info("init manager: base=%06x" % self.base_addr)
self.locks_by_b_addr = {}
LabelRange.__init__(self, "locks", base_addr, size)
self.lock_def = FileLockDef
self.lock_size = FileLockDef.get_size()
def __init__(self, name, addr, struct, size=0, offset=0):
str_size = struct.get_size()
if size < (str_size + offset):
size = str_size + offset
LabelRange.__init__(self, name, addr, size)
self.struct = struct
self.offset = offset
self.struct_begin = addr + offset
self.struct_end = self.struct_begin + str_size
self.struct_size = str_size
def __init__(self, path_mgr, doslist_mgr, base_addr, size):
self.path_mgr = path_mgr
self.doslist_mgr = doslist_mgr
self.base_addr = base_addr
self.cur_addr = base_addr
log_lock.info("init manager: base=%06x" % self.base_addr)
self.locks_by_b_addr = {}
LabelRange.__init__(self, "locks", base_addr, size)
self.lock_def = FileLockDef
self.lock_size = FileLockDef.get_size()
def __init__(self, name, addr, struct, size=0, offset=0):
str_size = struct.get_size()
if size < (str_size + offset):
size = str_size + offset
LabelRange.__init__(self, name, addr, size)
self.struct = struct
self.offset = offset
self.struct_begin = addr + offset
self.struct_end = self.struct_begin + str_size
self.struct_size = str_size
def __init__(self, path_mgr, base_addr, size):
self.path_mgr = path_mgr
self.base_addr = base_addr
self.cur_addr = base_addr
log_doslist.info("init manager: base=%06x" % self.base_addr)
self.entries_by_b_addr = {}
self.entries_by_name = {}
LabelRange.__init__(self, "doslist", base_addr, size)
self.entry_device_def = DosListDeviceDef
self.entry_volume_def = DosListVolumeDef
self.entry_assign_def = DosListAssignDef
self.entry_size = DosListDeviceDef.get_size()
def __init__(self, path_mgr, base_addr, size):
self.path_mgr = path_mgr
self.base_addr = base_addr
self.cur_addr = base_addr
log_doslist.info("init manager: base=%06x" % self.base_addr)
self.entries_by_b_addr = {}
self.entries_by_name = {}
LabelRange.__init__(self, "doslist", base_addr, size)
self.entry_device_def = DosListDeviceDef
self.entry_volume_def = DosListVolumeDef
self.entry_assign_def = DosListAssignDef
self.entry_size = DosListDeviceDef.get_size()
def trace_mem(self, mode, width, addr, val):
delta = addr - self.struct_begin
if delta >= 0 and delta < self.struct_size:
try:
name,off,val_type_name = self.struct.get_name_for_offset(delta, width)
type_name = self.struct.get_type_name()
addon = "%s+%d = %s(%s)+%d" % (type_name, delta, name, val_type_name, off)
self.trace_mem_int(mode, width, addr, val, text="Struct", addon=addon, level=logging.INFO)
return True
except BaseException:
return False
else:
LabelRange.trace_mem(self, mode, width, addr, val)
return True
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 __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 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_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_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 __init__(self, path_mgr, base_addr, size):
self.path_mgr = path_mgr
self.base_addr = base_addr
self.cur_addr = base_addr
log_file.info("init manager: base=%06x" % self.base_addr)
self.files_by_b_addr = {}
LabelRange.__init__(self, "files", base_addr, size)
self.fh_def = FileHandleDef
self.fh_size = FileHandleDef.get_size()
self.fh_size = (self.fh_size + 3) & ~3
# setup std input/output
self.std_input = AmiFile(sys.stdin, "<STDIN>", "", need_close=False)
self.std_output = AmiFile(sys.stdout, "<STDOUT>", "", need_close=False)
self._register_file(self.std_input)
self._register_file(self.std_output)
# get current umask
self.umask = os.umask(0)
os.umask(self.umask)
def __init__(self, path_mgr, base_addr, size):
self.path_mgr = path_mgr
self.base_addr = base_addr
self.cur_addr = base_addr
log_file.info("init manager: base=%06x" % self.base_addr)
self.files_by_b_addr = {}
LabelRange.__init__(self, "files", base_addr, size)
self.fh_def = FileHandleDef
self.fh_size = FileHandleDef.get_size()
self.fh_size = (self.fh_size + 3) & ~3
# setup std input/output
self.std_input = AmiFile(sys.stdin, '<STDIN>', '', need_close=False)
self.std_output = AmiFile(sys.stdout, '<STDOUT>', '', need_close=False)
self._register_file(self.std_input)
self._register_file(self.std_output)
# get current umask
self.umask = os.umask(0)
os.umask(self.umask)
def trace_mem(self, mode, width, addr, val):
delta = addr - self.struct_begin
if delta >= 0 and delta < self.struct_size:
try:
name, off, val_type_name = self.struct.get_name_for_offset(
delta, width)
type_name = self.struct.get_type_name()
addon = "%s+%d = %s(%s)+%d" % (type_name, delta, name,
val_type_name, off)
self.trace_mem_int(mode,
width,
addr,
val,
text="Struct",
addon=addon,
level=logging.INFO)
return True
except BaseException:
return False
else:
LabelRange.trace_mem(self, mode, width, addr, val)
return True
def __init__(self, name, addr, size, segment): LabelRange.__init__(self, name, addr, size) self.segment = segment
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
def __init__(self, name, addr, size, segment):
LabelRange.__init__(self, name, addr, size)
self.segment = segment
def __init__(self, addr, size):
LabelRange.__init__(self, "ports", addr, size)
self.ports = {}
self.base_addr = addr
self.size = size
self.cur_addr = addr
def __init__(self, addr, size):
LabelRange.__init__(self, "ports", addr, size)
self.ports = {}
self.base_addr = addr
self.size = size
self.cur_addr = addr
