def lookup_ref(self, key):
try:
return self.dict[key]
except KeyError:
if self.parent:
return self.parent.lookup_ref(key)
else:
raise KeyError(revsym(key))
def reindex(self, arr, offsets, symbol_translation):
for (i, tname) in enumerate(self.static_types):
if tname:
# special case for symbols - we have to re-use
# existing symbol ids, so the translation has to
# be done manually
if tname == 'sym':
arr[i] = symbol_translation[arr[i]]
continue
# special case for intrinsics, which are a static table
if tname == 'intrinsic':
intrinsic_name = revsym(symbol_translation[arr[i]])
new_id = intrinsics.get(intrinsic_name).id
arr[i] = intrinsics.get(intrinsic_name).id
continue
arr[i] += offsets[tname]
return arr
def arg_as_str(inst_type, i, arg):
arg_type = None
try:
arg_type = inst_type.static_types[i]
if arg_type is None: return '#' + str(arg)
if arg_type == 'inst': return '@' + labels_by_addr[arg].name
if arg_type == 'const': return '+' + const_table.lookup(arg).s()
if arg_type == 'sym': return ':' + revsym(arg)
if arg_type == 'intrinsic': return '@!' + intrinsics.lookup(arg).name
except KeyError as e:
debug(0,
['no key:', inst_type.name, arg_type or '??',
str(i),
str(arg)])
except IndexError as e:
debug(
0,
['no index:', inst_type.name, arg_type or '??',
str(i),
str(arg)])
return '?%s' % str(arg)
def as_dict(self):
out = {}
for (k, v) in self.dict.iteritems():
out[revsym(k)] = v.ref_get()
return out
def intrinsic(frame, args):
try:
builtin = intrinsics.lookup(args[0])
frame.push(builtin)
except IndexError:
frame.fail(tagged('unknown-intrinsic', String(revsym(args[0]))))
def ref(frame, args):
env = frame.pop_env()
try:
frame.push(env.lookup_ref(args[0]))
except KeyError:
frame.fail(tagged('missing-key', env, String(revsym(args[0]))))
def let(frame, args):
val = frame.pop()
env = frame.pop()
sym = args[0]
debug(0, [revsym(sym), '=', val.s()])
env.let(sym, val)