def Run(self, cmd_val):
# type: (cmd_value__Argv) -> int
arg_r = args.Reader(cmd_val.argv, spids=cmd_val.arg_spids)
arg_r.Next() # skip 'exec'
_ = EXEC_SPEC.Parse(arg_r) # no flags now, but accepts --
# Apply redirects in this shell. # NOTE: Redirects were processed earlier.
if arg_r.AtEnd():
self.fd_state.MakePermanent()
return 0
environ = self.mem.GetExported()
i = arg_r.i
cmd = cmd_val.argv[i]
argv0_path = self.search_path.CachedLookup(cmd)
if argv0_path is None:
self.errfmt.Print('exec: %r not found', cmd,
span_id=cmd_val.arg_spids[1])
raise SystemExit(127) # exec builtin never returns
# shift off 'exec'
c2 = cmd_value.Argv(cmd_val.argv[i:], cmd_val.arg_spids[i:], cmd_val.block)
self.ext_prog.Exec(argv0_path, c2, environ) # NEVER RETURNS
assert False, "This line should never be reached" # makes mypy happy
def Run(self, cmd_val):
# type: (cmd_value__Argv) -> int
if len(cmd_val.argv) == 1:
return 0 # this could be an error in strict mode?
name = cmd_val.argv[1]
# Run regular builtin or special builtin
to_run = consts.LookupNormalBuiltin(name)
if to_run == consts.NO_INDEX:
to_run = consts.LookupSpecialBuiltin(name)
if to_run == consts.NO_INDEX:
span_id = cmd_val.arg_spids[1]
if consts.LookupAssignBuiltin(name) != consts.NO_INDEX:
# NOTE: There's a similar restriction for 'command'
self.errfmt.Print("Can't run assignment builtin recursively",
span_id=span_id)
else:
self.errfmt.Print("%r isn't a shell builtin", name, span_id=span_id)
return 1
cmd_val2 = cmd_value.Argv(cmd_val.argv[1:], cmd_val.arg_spids[1:],
cmd_val.block)
return self.shell_ex.RunBuiltin(to_run, cmd_val2)
def Run(self, cmd_val):
# type: (cmd_value__Argv) -> int
attrs, arg_r = flag_spec.ParseCmdVal('command', cmd_val)
arg = arg_types.command(attrs.attrs)
if arg.v:
status = 0
names = arg_r.Rest()
for kind, argument in _ResolveNames(names, self.funcs,
self.aliases,
self.search_path):
if kind is None:
status = 1 # nothing printed, but we fail
else:
# This is for -v, -V is more detailed.
print(argument)
return status
# shift by one
cmd_val = cmd_value.Argv(cmd_val.argv[1:], cmd_val.arg_spids[1:], None)
# If we respected do_fork here instead of passing True, the case
# 'command date | wc -l' would take 2 processes instead of 3. But no other
# shell does that, and this rare case isn't worth the bookkeeping.
# See test/syscall
return self.shell_ex.RunSimpleCommand(cmd_val, True, call_procs=False)
def Run(self, cmd_val):
# type: (cmd_value__Argv) -> int
# TODO: Also hard usage error here too?
attrs, arg_r = flag_spec.ParseOilCmdVal('run', cmd_val)
arg = arg_types.run(attrs.attrs)
if arg_r.Peek() is None:
# HARD ERROR, not e_usage(), because errexit is often disabled!
e_die("'run' expected a command to run", status=2)
argv, spids = arg_r.Rest2()
cmd_val2 = cmd_value.Argv(argv, spids, cmd_val.block)
# Set in the 'except' block, e.g. if 'myfunc' failed
failure_spid = runtime.NO_SPID
try:
# Temporarily turn ON errexit, and blame the 'run' spid. Note that
# 'if run myproc' disables it and then enables it!
with state.ctx_ErrExit(self.mutable_opts, True,
cmd_val.arg_spids[0]):
# Pass do_fork=True. Slight annoyance: the real value is a field of
# command.Simple(). See _NoForkLast() in CommandEvaluator We have an
# extra fork (miss out on an optimization) of code like ( status ls )
# or forkwait { status ls }, but that is NOT idiomatic code. status is
# for functions.
status = self.shell_ex.RunSimpleCommand(cmd_val2, True)
#log('st %d', status)
except error.ErrExit as e: # from functino call
#log('e %d', e.exit_status)
status = e.exit_status
failure_spid = e.span_id
# Do this before -allow-status-01
if arg.status_ok is not None:
status = _AdjustStatus(arg.status_ok, status)
if arg.allow_status_01 and status not in (0, 1):
if failure_spid != runtime.NO_SPID:
self.errfmt.Print_('(original failure)', span_id=failure_spid)
self.errfmt.StderrLine('')
raise error.ErrExit('fatal: status %d when --allow-status-01' %
status,
span_id=spids[0],
status=status)
if arg.assign_status is not None:
var_name = arg.assign_status
if var_name.startswith(':'):
var_name = var_name[1:]
state.SetRefString(self.mem, var_name, str(status))
return 0 # don't fail
return status
def _ExtProc(argv):
arg_vec = cmd_value.Argv(argv, [0] * len(argv))
argv0_path = None
for path_entry in ['/bin', '/usr/bin']:
full_path = os.path.join(path_entry, argv[0])
if os.path.exists(full_path):
argv0_path = full_path
break
if not argv0_path:
argv0_path = argv[0] # fallback that tests failure case
return Process(ExternalThunk(_EXT_PROG, argv0_path, arg_vec, {}), _JOB_STATE)
def _ExtProc(self, argv):
arg_vec = cmd_value.Argv(argv, [0] * len(argv))
argv0_path = None
for path_entry in ['/bin', '/usr/bin']:
full_path = os.path.join(path_entry, argv[0])
if os.path.exists(full_path):
argv0_path = full_path
break
if not argv0_path:
argv0_path = argv[0] # fallback that tests failure case
return Process(ExternalThunk(self.ext_prog, argv0_path, arg_vec, {}),
self.job_state, self.tracer)
def __call__(self, cmd_val, fork_external):
arg, arg_index = COMMAND_SPEC.ParseVec(cmd_val)
if arg.v:
status = 0
names = cmd_val.argv[arg_index:]
for kind, arg in _ResolveNames(names, self.funcs, self.aliases,
self.search_path):
if kind is None:
status = 1 # nothing printed, but we fail
else:
# This is for -v, -V is more detailed.
print(arg)
return status
# shift by one
cmd_val = cmd_value.Argv(cmd_val.argv[1:], cmd_val.arg_spids[1:])
# 'command ls' suppresses function lookup.
return self.ex.RunSimpleCommand(cmd_val, fork_external, funcs=False)
def MakeBuiltinArgv(argv): return cmd_value.Argv(argv, [0] * len(argv))
def _MakeBuiltinArgv(argv):
argv = [''] + argv # add dummy since arg_vec includes argv[0]
# no location info
return cmd_value.Argv(argv, [runtime.NO_SPID] * len(argv))
def MakeBuiltinArgv(argv1):
# type: (List[str]) -> cmd_value__Argv
argv = [''] # dummy for argv[0]
argv.extend(argv1)
# no location info
return cmd_value.Argv(argv, [runtime.NO_SPID] * len(argv), None)
def MakeBuiltinArgv(argv): # type: (List[str]) -> cmd_value__Argv argv = [''] + argv # add dummy for argv[0] # no location info return cmd_value.Argv(argv, [runtime.NO_SPID] * len(argv))
