def _parse_arg(arg, argtype):
if not argtype:
return
result = None
if argtype == 'str':
return arg
if fw.is_valid_range(argtype):
return fw.restrict(arg, argtype)
err.fatal('Internal error, unrecognized argtype', argtype)
def _do_disassemble_file(fp, env):
pathinfo = env['pathinfo']
if not fp in pathinfo:
err.fatal('Internal error, unable to fetch path data for file', fp)
fdata = pathinfo[fp]
source = None
try:
with open(fp, 'r+b') as f:
source = f.read()
except FileNotFoundError:
err.fatal('Unable to find file:', target)
except IOError as e:
err.fatal('Unable to open file:', target)
output = dsm.disassemble(source)
print('Disassembly for file:', fp)
print(output)
if not env['logdsm']:
return
# Do this
dest = env['dest']
filename = fdata['name']
if dest:
# This is not portable (for now)...
out = dest + '/' + filename + '.dis'
try:
with open(out, 'w') as f:
f.write(output)
except IOError as e:
err.fatal('Unable to write file:', out)
def _do_assemble_file(fp, env):
pi = env['pathinfo']
if not fp in pi:
err.fatal('Internal error, unable to fetch path data for file', fp)
fdata = pi[fp]
source = None
try:
with open(fp, 'r') as f:
source = f.read()
except FileNotFoundError:
err.fatal('Unable to find file:', target)
except IOError as e:
err.fatal('Unable to open file:', target)
segments, ast = _do_build_segments(source)
dest = env['dest']
filename = fdata['name']
if dest:
# This is not portable (for now)...
out = dest + '/' + filename + '.csm'
else:
out = filename + '.csm'
try:
with open(out, 'w+b') as f:
for s in segments:
f.write(s)
except IOError as e:
err.fatal('Unable to write file:', out)
if env['dsegments']:
print('Displaying generated byte segments for file:', fp)
for s in segments:
print(' ', str(s)[1:])
elif env['dast']:
print('Displaying generated AST for file:', fp)
tv_display.visit(ast)
def main():
# Make sure to skip the first sys/argv value!
argv = sys.argv[1:]
files = []
flags = []
for arg in argv:
if len(arg) == 1 and arg[0] == '-':
err.fatal('Bad string while parsing flag:', arg)
if arg[0] == '-':
flags.append(arg)
continue
files.append(arg)
env = cmd.env_init(files, flags, argv)
entrypoint = env['entrypoint']
entrypoint(env)
def visit(node, env=None):
result = None
width = 0
if not tt.has_immediate(node.opcode.toktype):
if node.arg:
err.fatal('Opcode:', node, 'cannot have arg:', node.arg)
result = _validate_noi(node, env)
else:
for predicate, validator, bts in _immediate_lookup_table:
if predicate(node.opcode.toktype):
assert (node.arg)
result = validator(node, env)
width = bts
break
m = env['active-method-map']
result.ins = m['ins']
m['ins'] += width + 1
m['inc'] += 1
return result
def env_init(files, flags, argv):
result = _default_environment
if not files and not flags:
print(_usage_str)
result['entrypoint'] = _entrypoint_soft_quit
return result
result = copy.deepcopy(_default_environment)
result['files'] = files
result['flags'] = flags
result['argv'] = argv
result['nofiles'] = len(files) == 0
for fp in files:
_env_attach_file_pathinfo(fp, result)
for string in flags:
if len(string) == 1 or string[0] != '-':
err.fatal('Internal error, unable to parse flag', string)
rawflag = string[1:]
_parse_flag(rawflag, result)
if (result['nofiles']) and result['gracefail']:
result['entrypoint'] = _entrypoint_soft_quit
return result
def _handle_method_pragmas(node, env):
k = node.id.value
if not k in _method_pmap:
err.fatal('Unrecognized method pragma:', node.id)
m = env['active-method-map']
ptype, pwidth, preq, pdefault = _method_pmap[k]
# NOTE: Check to see if we don't take an arg.
if node.arg and preq == _arg_n:
err.fatal('Pragma', node.id, 'does not take value', node.arg)
return
if not node.arg and preq == _arg_y:
err.fatal('Pragma', node.id, 'requires value')
return
if not node.arg and preq == _arg_n:
v = True
_insert_pragma_value(k, v, m)
return
if not node.arg and preq == _arg_o:
v = pdefault
_insert_pragma_value(k, v, m)
return
if node.arg:
v = _parse_pragma_arg(node.arg, ptype, pwidth, env)
_insert_pragma_value(k, v, m)
return
assert ('Should never reach here.' == None)
return
def _stop(self, msg):
last = self._last()
out = 'Parser expected ' + msg + ' but found ' + str(last)
err.fatal(out)
def _handle_object_pragmas(node, env):
err.fatal('No object level pragmas yet.')
return
def _handle_module_pragmas(node, env):
err.fatal('No module level pragmas yet.')
return
def visit(node, env=None):
err.fatal('Unresolved jump while emitting segments:', node)
def visit(node, env=None):
err.fatal('Unclassified instruction while emitting segments:', node)
def _parse_flag(rawflag, env):
flag, arg = _split_flag_string(rawflag)
if not flag in _flag_table:
err.fatal('Unrecognized flag:', flag)
if flag in env['switched']:
return
handler, no_files_reaction, takes_arg, argtype = _flag_table[flag]
nfr = no_files_reaction
nofiles = env['nofiles']
if nfr < _n_skip or nfr > _n_ok:
err.fatal('Internal error, bad no_files_reaction value:', nfr)
elif nfr == _n_skip and nofiles:
return
# We will need to program a more robust error system soon.
elif nfr == _n_err and nofiles:
err.fatal('Flag', flag, 'requires input files!')
elif nfr == _n_die and nofiles:
err.fatal('Flag', flag, 'requires input files!')
elif nfr == _n_ok:
env['gracefail'] = True
if arg and not takes_arg:
err.fatal('Flag', flag, 'does not accept arg, found:', arg)
if takes_arg and not arg:
err.fatal('Flag', flag, 'expects arg of type:', argtype)
parsed_arg = _parse_arg(arg, argtype)
env['switched'][flag] = parsed_arg
handler(parsed_arg, env)
def _loop_through_files(action, env):
files = env['files']
if len(files) == 0:
err.fatal('No input files provided!')
for fp in files:
action(fp, env)