def _InitMem():
# empty environment, no arena.
arena = test_lib.MakeArena('<state_test.py>')
line_id = arena.AddLine(1, 'foo')
span = syntax_asdl.line_span(line_id, 0, 1) # dummy
arena.AddLineSpan(span)
return state.Mem('', [], {}, arena)
def InitExecutor(parse_ctx=None, comp_lookup=None, arena=None, mem=None):
if parse_ctx:
arena = parse_ctx.arena
else:
arena or MakeArena('<InitExecutor>')
parse_ctx = parse_lib.ParseContext(arena, {})
mem = mem or state.Mem('', [], {}, arena)
fd_state = process.FdState()
funcs = {}
comp_state = completion.State()
comp_lookup = comp_lookup or completion.Lookup()
readline = None # simulate not having it
builtins = { # Lookup
builtin_e.HISTORY: builtin.History(readline),
builtin_e.COMPOPT: builtin_comp.CompOpt(comp_state),
builtin_e.COMPADJUST: builtin_comp.CompAdjust(mem),
}
# For the tests, we do not use 'readline'.
exec_opts = state.ExecOpts(mem, None)
debug_f = util.DebugFile(sys.stderr)
exec_deps = cmd_exec.Deps()
exec_deps.dumper = dev.CrashDumper('')
exec_deps.debug_f = debug_f
exec_deps.trace_f = debug_f
splitter = split.SplitContext(mem)
exec_deps.splitter = splitter
word_ev = word_eval.NormalWordEvaluator(mem, exec_opts, exec_deps, arena)
exec_deps.word_ev = word_ev
arith_ev = expr_eval.ArithEvaluator(mem, exec_opts, word_ev, arena)
exec_deps.arith_ev = arith_ev
word_ev.arith_ev = arith_ev # Circular
bool_ev = expr_eval.BoolEvaluator(mem, exec_opts, word_ev, arena)
exec_deps.bool_ev = bool_ev
tracer = cmd_exec.Tracer(parse_ctx, exec_opts, mem, word_ev, debug_f)
exec_deps.tracer = tracer
ex = cmd_exec.Executor(mem, fd_state, funcs, builtins, exec_opts,
parse_ctx, exec_deps)
spec_builder = builtin_comp.SpecBuilder(ex, parse_ctx, word_ev, splitter,
comp_lookup)
# Add some builtins that depend on the executor!
complete_builtin = builtin_comp.Complete(spec_builder,
comp_lookup) # used later
builtins[builtin_e.COMPLETE] = complete_builtin
builtins[builtin_e.COMPGEN] = builtin_comp.CompGen(spec_builder)
return ex
def InitExecutor(comp_state=None, arena=None, mem=None):
arena = arena or MakeArena('<InitExecutor>')
mem = mem or state.Mem('', [], {}, arena)
fd_state = process.FdState()
funcs = {}
comp_state = comp_state or completion.State()
readline = None # simulate not having it
builtins = { # Lookup
builtin_e.HISTORY: builtin.History(readline),
builtin_e.COMPOPT: builtin_comp.CompOpt(comp_state),
builtin_e.COMPADJUST: builtin_comp.CompAdjust(mem),
}
# For the tests, we do not use 'readline'.
exec_opts = state.ExecOpts(mem, None)
parse_ctx = parse_lib.ParseContext(arena, {})
debug_f = util.DebugFile(sys.stderr)
devtools = dev.DevTools(dev.CrashDumper(''), debug_f, debug_f)
ex = cmd_exec.Executor(mem, fd_state, funcs, builtins, exec_opts,
parse_ctx, devtools)
# Add some builtins that depend on the executor!
complete_builtin = builtin_comp.Complete(ex, comp_state) # used later
builtins[builtin_e.COMPLETE] = complete_builtin
builtins[builtin_e.COMPGEN] = builtin_comp.CompGen(ex)
return ex
def MakeTestEvaluator():
arena = alloc.SideArena('<MakeTestEvaluator>')
mem = state.Mem('', [], {}, arena)
exec_opts = state.ExecOpts(mem, None)
splitter = split.SplitContext(mem)
ev = word_eval.CompletionWordEvaluator(mem, exec_opts, splitter, arena)
return ev
def testArgv2(self):
mem = state.Mem('', ['x', 'y'], {}, None)
mem.Shift(1)
self.assertEqual(['y'], mem.GetArgv())
mem.SetArgv(['i', 'j', 'k'])
self.assertEqual(['i', 'j', 'k'], mem.GetArgv())
def MakeTestEvaluator():
arena = MakeArena('<MakeTestEvaluator>')
mem = state.Mem('', [], {}, arena)
exec_opts = state.ExecOpts(mem, None)
exec_deps = cmd_exec.Deps()
exec_deps.splitter = split.SplitContext(mem)
ev = word_eval.CompletionWordEvaluator(mem, exec_opts, exec_deps, arena)
return ev
def testEvaluator(self):
arena = test_lib.MakeArena('<ui_test.py>')
mem = state.Mem('', [], {}, arena)
ex = test_lib.InitExecutor(arena=arena)
p = prompt.Evaluator('osh', arena, ex.parse_ctx, ex, mem)
# Rgression for caching bug!
self.assertEqual('foo', p.EvalPrompt(value.Str('foo')))
self.assertEqual('foo', p.EvalPrompt(value.Str('foo')))
def MakeTestEvaluator():
arena = MakeArena('<MakeTestEvaluator>')
mem = state.Mem('', [], {}, arena)
parse_opts = parse_lib.OilParseOptions()
exec_opts = state.ExecOpts(mem, parse_opts, None)
exec_deps = cmd_exec.Deps()
exec_deps.splitter = split.SplitContext(mem)
exec_deps.trap_nodes = []
ev = word_eval.CompletionWordEvaluator(mem, exec_opts, exec_deps, arena)
return ev
def main(argv):
init_code = ' echo hi >&2 '
arena = test_lib.MakeArena('<InitCompletionTest>')
parse_ctx = parse_lib.ParseContext(arena, {})
mem = state.Mem('', [], {}, arena)
comp_lookup = completion.Lookup()
ex = test_lib.EvalCode(init_code,
parse_ctx,
comp_lookup=comp_lookup,
mem=mem)
print('hi')
def EvalCode(code_str, comp_lookup=None, arena=None, mem=None):
"""
This allows unit tests to write code strings and have functions appear in the
executor.
"""
comp_lookup = comp_lookup or completion.Lookup()
arena = arena or MakeArena('<test_lib>')
mem = mem or state.Mem('', [], {}, arena)
c_parser = InitCommandParser(code_str, arena=arena)
ex = InitExecutor(comp_lookup=comp_lookup, arena=arena, mem=mem)
# Parse and execute!
main_loop.Batch(ex, c_parser, arena)
return ex
def ParseAndEval(code_str):
arena = test_lib.MakeArena('<arith_parse_test.py>')
w_parser = test_lib.InitWordParser(code_str, arena=arena)
w_parser._Next(lex_mode_e.Arith) # Calling private method
anode = w_parser._ReadArithExpr() # need the right lex state?
print('node:', anode)
mem = state.Mem('', [], {}, arena)
exec_opts = state.ExecOpts(mem, None)
splitter = split.SplitContext(mem)
ev = word_eval.CompletionWordEvaluator(mem, exec_opts, splitter, arena)
arith_ev = expr_eval.ArithEvaluator(mem, exec_opts, ev, arena)
value = arith_ev.Eval(anode)
return value
def EvalCode(code_str, parse_ctx, comp_lookup=None, mem=None):
"""
Unit tests can evaluate code strings and then use the resulting Executor.
"""
arena = parse_ctx.arena
comp_lookup = comp_lookup or completion.Lookup()
mem = mem or state.Mem('', [], {}, arena)
line_reader, _ = InitLexer(code_str, arena)
c_parser = parse_ctx.MakeOshParser(line_reader)
ex = InitExecutor(parse_ctx=parse_ctx, comp_lookup=comp_lookup, arena=arena, mem=mem)
main_loop.Batch(ex, c_parser, arena) # Parse and execute!
return ex
def _InitMem():
# empty environment, no arena.
arena = test_lib.MakeArena('<state_test.py>')
line_id = arena.AddLine(1, 'foo')
unused = arena.AddLineSpan(line_id, 0, 1) # dummy
return state.Mem('', [], {}, arena)
def testMatchesOracle(self):
for i, case in enumerate(bash_oracle.CASES): # generated data
flags = case.get('_init_completion_flags')
if flags is None:
continue
# This was input
code_str = case['code']
assert code_str.endswith('\t')
log('')
log('--- Case %d: %r with flags %s', i, code_str, flags)
log('')
#print(case)
oracle_comp_words = case['COMP_WORDS']
oracle_comp_cword = case['COMP_CWORD']
oracle_comp_line = case['COMP_LINE']
oracle_comp_point = case['COMP_POINT']
# Init completion data
oracle_words = case['words']
oracle_cur = case['cur']
oracle_prev = case['prev']
oracle_cword = case['cword']
oracle_split = case['split']
#
# First test some invariants on the oracle's data.
#
self.assertEqual(code_str[:-1], oracle_comp_line)
# weird invariant that always holds. So isn't COMP_CWORD useless?
self.assertEqual(int(oracle_comp_cword),
len(oracle_comp_words) - 1)
# Another weird invariant. Note this is from the bash ORACLE, not from
# our mocks.
self.assertEqual(int(oracle_comp_point), len(code_str) - 1)
#
# Now run a piece of code that compares OSH's actual data against the
# oracle.
#
init_code = _INIT_TEMPLATE % {
'flags': ' '.join(flags),
'command': oracle_comp_words[0]
}
arena = test_lib.MakeArena('<InitCompletionTest>')
parse_ctx = parse_lib.ParseContext(arena, {})
mem = state.Mem('', [], {}, arena)
#
# Allow our code to access oracle data
#
state.SetGlobalArray(mem, 'ORACLE_COMP_WORDS', oracle_comp_words)
state.SetGlobalString(mem, 'ORACLE_COMP_CWORD', oracle_comp_cword)
state.SetGlobalString(mem, 'ORACLE_COMP_LINE', oracle_comp_line)
state.SetGlobalString(mem, 'ORACLE_COMP_POINT', oracle_comp_point)
state.SetGlobalArray(mem, 'ORACLE_words', oracle_words)
state.SetGlobalString(mem, 'ORACLE_cur', oracle_cur)
state.SetGlobalString(mem, 'ORACLE_prev', oracle_prev)
state.SetGlobalString(mem, 'ORACLE_cword', oracle_cword)
state.SetGlobalString(mem, 'ORACLE_split', oracle_split)
comp_lookup = completion.Lookup()
ex = test_lib.EvalCode(init_code,
parse_ctx,
comp_lookup=comp_lookup,
mem=mem)
r = _MakeRootCompleter(comp_lookup=comp_lookup)
comp = MockApi(code_str[:-1])
m = list(r.Matches(comp))
log('matches = %s', m)
# Unterminated quote in case 5. Nothing to complete.
# TODO: use a label
if i == 5:
continue
# Our test shell script records what passed in an array.
val = mem.GetVar('PASSED')
self.assertEqual(value_e.StrArray, val.tag,
"Expected array, got %s" % val)
actually_passed = val.strs
should_pass = [
'COMP_WORDS',
'COMP_CWORD',
'COMP_LINE',
'COMP_POINT', # old API
'words',
'cur',
'prev',
'cword',
'split' # new API
]
if i == 4:
should_pass.remove('COMP_WORDS')
should_pass.remove('COMP_CWORD')
should_pass.remove('cword')
should_pass.remove('words') # double quotes aren't the same
for t in should_pass:
self.assert_(t in actually_passed,
"%r was expected to pass (case %d)" % (t, i))
log('Ran %d cases', len(bash_oracle.CASES))
def testExternalCommandAction(self):
mem = state.Mem('dummy', [], {}, None)
a = completion.ExternalCommandAction(mem)
comp = self._CompApi([], 0, 'f')
print(list(a.Matches(comp)))
from core.meta import runtime_asdl, syntax_asdl
from frontend import parse_lib
from osh import state
from testdata.completion import bash_oracle
assign_op_e = syntax_asdl.assign_op_e
value_e = runtime_asdl.value_e
log = util.log
A1 = completion.TestAction(['foo.py', 'foo', 'bar.py'])
U1 = completion.UserSpec([A1], [], [], lambda candidate: True)
BASE_OPTS = {}
mem = state.Mem('', [], {}, None)
FIRST = completion.TestAction(['grep', 'sed', 'test'])
U2 = completion.UserSpec([FIRST], [], [], lambda candidate: True)
def MockApi(line):
"""Match readline's get_begidx() / get_endidx()."""
return completion.Api(line=line, begin=0, end=len(line))
def _MakeRootCompleter(parse_ctx=None, comp_lookup=None):
#comp_state = comp_state or completion.State()
compopt_state = completion.OptionState()
comp_ui_state = comp_ui.State()
comp_lookup = comp_lookup or completion.Lookup()
def ShellMain(lang, argv0, argv, login_shell):
"""Used by bin/osh and bin/oil.
Args:
lang: 'osh' or 'oil'
argv0, argv: So we can also invoke bin/osh as 'oil.ovm osh'. Like busybox.
login_shell: Was - on the front?
"""
# Differences between osh and oil:
# - --help? I guess Oil has a SUPERSET of OSH options.
# - oshrc vs oilrc
# - the parser and executor
# - Change the prompt in the interactive shell?
assert lang in ('osh', 'oil'), lang
arg_r = args.Reader(argv)
try:
opts = OSH_SPEC.Parse(arg_r)
except args.UsageError as e:
ui.usage('osh usage error: %s', e)
return 2
if opts.help:
loader = util.GetResourceLoader()
builtin.Help(['%s-usage' % lang], loader)
return 0
if opts.version:
# OSH version is the only binary in Oil right now, so it's all one version.
_ShowVersion()
return 0
# TODO: This should be in interactive mode only?
builtin.RegisterSigIntHandler()
if arg_r.AtEnd():
dollar0 = argv0
has_main = False
else:
dollar0 = arg_r.Peek() # the script name, or the arg after -c
has_main = True
pool = alloc.Pool()
arena = pool.NewArena()
# NOTE: has_main is only for ${BASH_SOURCE[@} and family. Could be a
# required arg.
mem = state.Mem(dollar0,
argv[arg_r.i + 1:],
posix.environ,
arena,
has_main=has_main)
funcs = {}
fd_state = process.FdState()
exec_opts = state.ExecOpts(mem, readline)
builtin.SetExecOpts(exec_opts, opts.opt_changes)
aliases = {} # feedback between runtime and parser
parse_ctx = parse_lib.ParseContext(arena, aliases) # For main_loop
# Three ParseContext instances SHARE aliases. TODO: Complete aliases.
comp_arena = pool.NewArena()
comp_arena.PushSource('<completion>')
trail1 = parse_lib.Trail()
comp_ctx = parse_lib.ParseContext(comp_arena, aliases, trail=trail1)
hist_arena = pool.NewArena()
hist_arena.PushSource('<history>')
trail2 = parse_lib.Trail()
hist_ctx = parse_lib.ParseContext(hist_arena, aliases, trail=trail2)
# Deps helps manages dependencies. These dependencies are circular:
# - ex and word_ev, arith_ev -- for command sub, arith sub
# - arith_ev and word_ev -- for $(( ${a} )) and $x$(( 1 ))
# - ex and builtins (which execute code, like eval)
# - prompt_ev needs word_ev for $PS1, which needs prompt_ev for @P
exec_deps = cmd_exec.Deps()
if opts.debug_file:
debug_f = util.DebugFile(fd_state.Open(opts.debug_file, mode='w'))
else:
debug_f = util.NullDebugFile()
exec_deps.debug_f = debug_f
debug_f.log('Debug file is %s', opts.debug_file)
splitter = split.SplitContext(mem)
exec_deps.splitter = splitter
# Controlled by env variable, flag, or hook?
exec_deps.dumper = dev.CrashDumper(
posix.environ.get('OSH_CRASH_DUMP_DIR', ''))
if opts.xtrace_to_debug_file:
trace_f = debug_f
else:
trace_f = util.DebugFile(sys.stderr)
exec_deps.trace_f = trace_f
# TODO: Separate comp_state and comp_lookup.
comp_state = completion.State()
comp_lookup = completion.Lookup()
builtins = { # Lookup
builtin_e.HISTORY: builtin.History(readline),
builtin_e.COMPOPT: builtin_comp.CompOpt(comp_state),
builtin_e.COMPADJUST: builtin_comp.CompAdjust(mem),
}
ex = cmd_exec.Executor(mem, fd_state, funcs, builtins, exec_opts,
parse_ctx, exec_deps)
exec_deps.ex = ex
word_ev = word_eval.NormalWordEvaluator(mem, exec_opts, exec_deps, arena)
exec_deps.word_ev = word_ev
arith_ev = expr_eval.ArithEvaluator(mem, exec_opts, word_ev, arena)
exec_deps.arith_ev = arith_ev
word_ev.arith_ev = arith_ev # Another circular dependency
bool_ev = expr_eval.BoolEvaluator(mem, exec_opts, word_ev, arena)
exec_deps.bool_ev = bool_ev
tracer = cmd_exec.Tracer(parse_ctx, exec_opts, mem, word_ev, trace_f)
exec_deps.tracer = tracer
# HACK for circular deps
ex.word_ev = word_ev
ex.arith_ev = arith_ev
ex.bool_ev = bool_ev
ex.tracer = tracer
spec_builder = builtin_comp.SpecBuilder(ex, parse_ctx, word_ev, splitter)
# Add some builtins that depend on the executor!
complete_builtin = builtin_comp.Complete(spec_builder,
comp_lookup) # used later
builtins[builtin_e.COMPLETE] = complete_builtin
builtins[builtin_e.COMPGEN] = builtin_comp.CompGen(spec_builder)
if lang == 'oil':
# The Oil executor wraps an OSH executor? It needs to be able to source
# it.
ex = oil_cmd_exec.OilExecutor(ex)
# PromptEvaluator rendering is needed in non-interactive shells for @P.
prompt_ev = ui.PromptEvaluator(lang, arena, parse_ctx, ex, mem)
exec_deps.prompt_ev = prompt_ev
word_ev.prompt_ev = prompt_ev # HACK for circular deps
# History evaluation is a no-op if readline is None.
hist_ev = reader.HistoryEvaluator(readline, hist_ctx, debug_f)
# Calculate ~/.config/oil/oshrc or oilrc
# Use ~/.config/oil to avoid cluttering the user's home directory. Some
# users may want to ln -s ~/.config/oil/oshrc ~/oshrc or ~/.oshrc.
# https://unix.stackexchange.com/questions/24347/why-do-some-applications-use-config-appname-for-their-config-data-while-other
home_dir = mem.GetVar('HOME')
assert home_dir.tag == value_e.Str, home_dir
rc_path = opts.rcfile or os_path.join(home_dir.s, '.config/oil',
lang + 'rc')
history_filename = os_path.join(home_dir.s, '.config/oil',
'history_' + lang)
if opts.c is not None:
arena.PushSource('<command string>')
line_reader = reader.StringLineReader(opts.c, arena)
if opts.i: # -c and -i can be combined
exec_opts.interactive = True
elif opts.i: # force interactive
arena.PushSource('<stdin -i>')
# interactive shell only
line_reader = reader.InteractiveLineReader(arena, prompt_ev, hist_ev)
exec_opts.interactive = True
else:
try:
script_name = arg_r.Peek()
except IndexError:
if sys.stdin.isatty():
arena.PushSource('<interactive>')
# interactive shell only
line_reader = reader.InteractiveLineReader(
arena, prompt_ev, hist_ev)
exec_opts.interactive = True
else:
arena.PushSource('<stdin>')
line_reader = reader.FileLineReader(sys.stdin, arena)
else:
arena.PushSource(script_name)
try:
f = fd_state.Open(script_name)
except OSError as e:
util.error("Couldn't open %r: %s", script_name,
posix.strerror(e.errno))
return 1
line_reader = reader.FileLineReader(f, arena)
# TODO: assert arena.NumSourcePaths() == 1
# TODO: .rc file needs its own arena.
if lang == 'osh':
c_parser = parse_ctx.MakeOshParser(line_reader)
else:
c_parser = parse_ctx.MakeOilParser(line_reader)
if exec_opts.interactive:
# NOTE: We're using a different evaluator here. The completion system can
# also run functions... it gets the Executor through Executor._Complete.
if readline:
ev = word_eval.CompletionWordEvaluator(mem, exec_opts, exec_deps,
arena)
progress_f = ui.StatusLine()
root_comp = completion.RootCompleter(ev, mem, comp_lookup,
comp_state, comp_ctx,
progress_f, debug_f)
_InitReadline(readline, history_filename, root_comp, debug_f)
_InitDefaultCompletions(ex, complete_builtin, comp_lookup)
# NOTE: Call this AFTER _InitDefaultCompletions.
SourceStartupFile(rc_path, lang, parse_ctx, ex)
return main_loop.Interactive(opts, ex, c_parser, arena)
# TODO: Remove this after removing it from benchmarks/osh-runtime. It's no
# longer relevant with main_loop.
if opts.parser_mem_dump:
# This might be superstition, but we want to let the value stabilize
# after parsing. bash -c 'cat /proc/$$/status' gives different results
# with a sleep.
time.sleep(0.001)
input_path = '/proc/%d/status' % posix.getpid()
with open(input_path) as f, open(opts.parser_mem_dump, 'w') as f2:
contents = f.read()
f2.write(contents)
log('Wrote %s to %s (--parser-mem-dump)', input_path,
opts.parser_mem_dump)
nodes_out = [] if exec_opts.noexec else None
_tlog('Execute(node)')
status = main_loop.Batch(ex, c_parser, arena, nodes_out=nodes_out)
# Only print nodes if the whole parse succeeded.
if nodes_out is not None and status == 0:
ui.PrintAst(nodes_out, opts)
# NOTE: 'exit 1' is ControlFlow and gets here, but subshell/commandsub
# don't because they call sys.exit().
if opts.runtime_mem_dump:
# This might be superstition, but we want to let the value stabilize
# after parsing. bash -c 'cat /proc/$$/status' gives different results
# with a sleep.
time.sleep(0.001)
input_path = '/proc/%d/status' % posix.getpid()
with open(input_path) as f, open(opts.runtime_mem_dump, 'w') as f2:
contents = f.read()
f2.write(contents)
log('Wrote %s to %s (--runtime-mem-dump)', input_path,
opts.runtime_mem_dump)
# NOTE: This doesn't cause any spec tests to fail, but it could.
if posix.environ.get('ASDL_TYPE_CHECK'):
log('NOTE: Performed %d ASDL_TYPE_CHECKs.', runtime.NUM_TYPE_CHECKS)
# NOTE: We haven't closed the file opened with fd_state.Open
return status
def InitExecutor(parse_ctx=None,
comp_lookup=None,
arena=None,
mem=None,
aliases=None,
ext_prog=None):
if parse_ctx:
arena = parse_ctx.arena
parse_opts = parse_ctx.parse_opts
else:
arena or MakeArena('<InitExecutor>')
parse_opts = parse_lib.OilParseOptions()
parse_ctx = parse_lib.ParseContext(arena, parse_opts, {}, None)
mem = mem or state.Mem('', [], {}, arena)
exec_opts = state.ExecOpts(mem, parse_opts, None)
errfmt = ui.ErrorFormatter(arena)
job_state = process.JobState()
fd_state = process.FdState(errfmt, job_state)
funcs = {}
aliases = {} if aliases is None else aliases
compopt_state = completion.OptionState()
comp_lookup = comp_lookup or completion.Lookup()
readline = None # simulate not having it
new_var = builtin_assign.NewVar(mem, funcs, errfmt)
builtins = { # Lookup
builtin_e.ECHO: builtin_pure.Echo(exec_opts),
builtin_e.SHIFT: builtin_assign.Shift(mem),
builtin_e.HISTORY: builtin.History(readline),
builtin_e.COMPOPT: builtin_comp.CompOpt(compopt_state, errfmt),
builtin_e.COMPADJUST: builtin_comp.CompAdjust(mem),
builtin_e.ALIAS: builtin_pure.Alias(aliases, errfmt),
builtin_e.UNALIAS: builtin_pure.UnAlias(aliases, errfmt),
builtin_e.DECLARE: new_var,
builtin_e.TYPESET: new_var,
builtin_e.LOCAL: new_var,
builtin_e.EXPORT: builtin_assign.Export(mem, errfmt),
builtin_e.READONLY: builtin_assign.Readonly(mem, errfmt),
}
# For the tests, we do not use 'readline'.
exec_opts = state.ExecOpts(mem, parse_opts, None)
debug_f = util.DebugFile(sys.stderr)
exec_deps = cmd_exec.Deps()
exec_deps.search_path = state.SearchPath(mem)
exec_deps.errfmt = errfmt
exec_deps.trap_nodes = []
exec_deps.job_state = job_state
exec_deps.waiter = process.Waiter(exec_deps.job_state, exec_opts)
exec_deps.ext_prog = \
ext_prog or process.ExternalProgram('', fd_state,
exec_deps.search_path, errfmt,
debug_f)
exec_deps.dumper = dev.CrashDumper('')
exec_deps.debug_f = debug_f
exec_deps.trace_f = debug_f
splitter = split.SplitContext(mem)
exec_deps.splitter = splitter
word_ev = word_eval.NormalWordEvaluator(mem, exec_opts, exec_deps, arena)
exec_deps.word_ev = word_ev
arith_ev = expr_eval.ArithEvaluator(mem, exec_opts, word_ev, arena)
exec_deps.arith_ev = arith_ev
word_ev.arith_ev = arith_ev # Circular
bool_ev = expr_eval.BoolEvaluator(mem, exec_opts, word_ev, arena)
exec_deps.bool_ev = bool_ev
tracer = dev.Tracer(parse_ctx, exec_opts, mem, word_ev, debug_f)
exec_deps.tracer = tracer
ex = cmd_exec.Executor(mem, fd_state, funcs, builtins, exec_opts,
parse_ctx, exec_deps)
spec_builder = builtin_comp.SpecBuilder(ex, parse_ctx, word_ev, splitter,
comp_lookup)
# Add some builtins that depend on the executor!
complete_builtin = builtin_comp.Complete(spec_builder, comp_lookup)
builtins[builtin_e.COMPLETE] = complete_builtin
builtins[builtin_e.COMPGEN] = builtin_comp.CompGen(spec_builder)
return ex
def ShellMain(lang, argv0, argv, login_shell):
"""Used by bin/osh and bin/oil.
Args:
lang: 'osh' or 'oil'
argv0, argv: So we can also invoke bin/osh as 'oil.ovm osh'. Like busybox.
login_shell: Was - on the front?
"""
# Differences between osh and oil:
# - --help? I guess Oil has a SUPERSET of OSH options.
# - oshrc vs oilrc
# - the parser and executor
# - Change the prompt in the interactive shell?
assert lang in ('osh', 'oil'), lang
arg_r = args.Reader(argv)
try:
opts = OSH_SPEC.Parse(arg_r)
except args.UsageError as e:
ui.usage('osh usage error: %s', e)
return 2
# NOTE: This has a side effect of deleting _OVM_* from the environment!
# TODO: Thread this throughout the program, and get rid of the global
# variable in core/util.py. Rename to InitResourceLaoder(). It's now only
# used for the 'help' builtin and --version.
loader = pyutil.GetResourceLoader()
if opts.help:
builtin.Help(['%s-usage' % lang], loader)
return 0
if opts.version:
# OSH version is the only binary in Oil right now, so it's all one version.
_ShowVersion()
return 0
if arg_r.AtEnd():
dollar0 = argv0
has_main = False
else:
dollar0 = arg_r.Peek() # the script name, or the arg after -c
has_main = True
arena = alloc.Arena()
# NOTE: has_main is only for ${BASH_SOURCE[@} and family. Could be a
# required arg.
mem = state.Mem(dollar0,
argv[arg_r.i + 1:],
posix.environ,
arena,
has_main=has_main)
funcs = {}
fd_state = process.FdState()
exec_opts = state.ExecOpts(mem, line_input)
builtin.SetExecOpts(exec_opts, opts.opt_changes)
aliases = {} # feedback between runtime and parser
if opts.one_pass_parse and not exec_opts.noexec:
raise args.UsageError('--one-pass-parse requires noexec (-n)')
parse_ctx = parse_lib.ParseContext(arena,
aliases,
one_pass_parse=opts.one_pass_parse)
# Three ParseContext instances SHARE aliases.
comp_arena = alloc.Arena()
comp_arena.PushSource(source.Unused('completion'))
trail1 = parse_lib.Trail()
# one_pass_parse needs to be turned on to complete inside backticks. TODO:
# fix the issue where ` gets erased because it's not part of
# set_completer_delims().
comp_ctx = parse_lib.ParseContext(comp_arena,
aliases,
trail=trail1,
one_pass_parse=True)
hist_arena = alloc.Arena()
hist_arena.PushSource(source.Unused('history'))
trail2 = parse_lib.Trail()
hist_ctx = parse_lib.ParseContext(hist_arena, aliases, trail=trail2)
# Deps helps manages dependencies. These dependencies are circular:
# - ex and word_ev, arith_ev -- for command sub, arith sub
# - arith_ev and word_ev -- for $(( ${a} )) and $x$(( 1 ))
# - ex and builtins (which execute code, like eval)
# - prompt_ev needs word_ev for $PS1, which needs prompt_ev for @P
exec_deps = cmd_exec.Deps()
my_pid = posix.getpid()
debug_path = ''
debug_dir = posix.environ.get('OSH_DEBUG_DIR')
if opts.debug_file: # --debug-file takes precedence over OSH_DEBUG_DIR
debug_path = opts.debug_file
elif debug_dir:
debug_path = os_path.join(debug_dir, '%d-osh.log' % my_pid)
if debug_path:
# This will be created as an empty file if it doesn't exist, or it could be
# a pipe.
try:
debug_f = util.DebugFile(fd_state.Open(debug_path, mode='w'))
except OSError as e:
util.error("Couldn't open %r: %s", debug_path,
posix.strerror(e.errno))
return 2
else:
debug_f = util.NullDebugFile()
exec_deps.debug_f = debug_f
# Not using datetime for dependency reasons. TODO: maybe show the date at
# the beginning of the log, and then only show time afterward? To save
# space, and make space for microseconds. (datetime supports microseconds
# but time.strftime doesn't).
iso_stamp = time.strftime("%Y-%m-%d %H:%M:%S")
debug_f.log('%s [%d] OSH started with argv %s', iso_stamp, my_pid, argv)
if debug_path:
debug_f.log('Writing logs to %r', debug_path)
interp = posix.environ.get('OSH_HIJACK_SHEBANG', '')
exec_deps.ext_prog = process.ExternalProgram(interp, fd_state, debug_f)
splitter = split.SplitContext(mem)
exec_deps.splitter = splitter
# This could just be OSH_DEBUG_STREAMS='debug crash' ? That might be
# stuffing too much into one, since a .json crash dump isn't a stream.
crash_dump_dir = posix.environ.get('OSH_CRASH_DUMP_DIR', '')
exec_deps.dumper = dev.CrashDumper(crash_dump_dir)
if opts.xtrace_to_debug_file:
trace_f = debug_f
else:
trace_f = util.DebugFile(sys.stderr)
exec_deps.trace_f = trace_f
comp_lookup = completion.Lookup()
#
# Various Global State objects to work around readline interfaces
#
compopt_state = completion.OptionState()
comp_ui_state = comp_ui.State()
prompt_state = comp_ui.PromptState()
builtins = { # Lookup
builtin_e.HISTORY: builtin.History(line_input),
builtin_e.COMPOPT: builtin_comp.CompOpt(compopt_state),
builtin_e.COMPADJUST: builtin_comp.CompAdjust(mem),
}
ex = cmd_exec.Executor(mem, fd_state, funcs, builtins, exec_opts,
parse_ctx, exec_deps)
exec_deps.ex = ex
word_ev = word_eval.NormalWordEvaluator(mem, exec_opts, exec_deps, arena)
exec_deps.word_ev = word_ev
arith_ev = expr_eval.ArithEvaluator(mem, exec_opts, word_ev, arena)
exec_deps.arith_ev = arith_ev
word_ev.arith_ev = arith_ev # Another circular dependency
bool_ev = expr_eval.BoolEvaluator(mem, exec_opts, word_ev, arena)
exec_deps.bool_ev = bool_ev
tracer = dev.Tracer(parse_ctx, exec_opts, mem, word_ev, trace_f)
exec_deps.tracer = tracer
# HACK for circular deps
ex.word_ev = word_ev
ex.arith_ev = arith_ev
ex.bool_ev = bool_ev
ex.tracer = tracer
spec_builder = builtin_comp.SpecBuilder(ex, parse_ctx, word_ev, splitter,
comp_lookup)
# Add some builtins that depend on the executor!
complete_builtin = builtin_comp.Complete(spec_builder, comp_lookup)
builtins[builtin_e.COMPLETE] = complete_builtin
builtins[builtin_e.COMPGEN] = builtin_comp.CompGen(spec_builder)
if lang == 'oil':
# The Oil executor wraps an OSH executor? It needs to be able to source
# it.
ex = oil_cmd_exec.OilExecutor(ex)
# PromptEvaluator rendering is needed in non-interactive shells for @P.
prompt_ev = prompt.Evaluator(lang, parse_ctx, ex, mem)
exec_deps.prompt_ev = prompt_ev
word_ev.prompt_ev = prompt_ev # HACK for circular deps
# History evaluation is a no-op if line_input is None.
hist_ev = history.Evaluator(line_input, hist_ctx, debug_f)
# Calculate ~/.config/oil/oshrc or oilrc
# Use ~/.config/oil to avoid cluttering the user's home directory. Some
# users may want to ln -s ~/.config/oil/oshrc ~/oshrc or ~/.oshrc.
# https://unix.stackexchange.com/questions/24347/why-do-some-applications-use-config-appname-for-their-config-data-while-other
home_dir = process.GetHomeDir()
assert home_dir is not None
rc_path = opts.rcfile or os_path.join(home_dir, '.config/oil', lang + 'rc')
history_filename = os_path.join(home_dir, '.config/oil', 'history_' + lang)
if opts.c is not None:
arena.PushSource(source.CFlag())
line_reader = reader.StringLineReader(opts.c, arena)
if opts.i: # -c and -i can be combined
exec_opts.interactive = True
elif opts.i: # force interactive
arena.PushSource(source.Stdin(' -i'))
# interactive shell only
line_reader = reader.InteractiveLineReader(arena, prompt_ev, hist_ev,
line_input, prompt_state)
exec_opts.interactive = True
else:
try:
script_name = arg_r.Peek()
except IndexError:
if sys.stdin.isatty():
arena.PushSource(source.Interactive())
# interactive shell only
line_reader = reader.InteractiveLineReader(
arena, prompt_ev, hist_ev, line_input, prompt_state)
exec_opts.interactive = True
else:
arena.PushSource(source.Stdin(''))
line_reader = reader.FileLineReader(sys.stdin, arena)
else:
arena.PushSource(source.MainFile(script_name))
try:
f = fd_state.Open(script_name)
except OSError as e:
util.error("Couldn't open %r: %s", script_name,
posix.strerror(e.errno))
return 1
line_reader = reader.FileLineReader(f, arena)
# TODO: assert arena.NumSourcePaths() == 1
# TODO: .rc file needs its own arena.
if lang == 'osh':
c_parser = parse_ctx.MakeOshParser(line_reader)
else:
c_parser = parse_ctx.MakeOilParser(line_reader)
# NOTE: SIGINT is temporarily enabled during readline() by
# frontend/reader.py.
# It's treated differently than SIGQUIT and SIGTSTP because Python handles it
# with KeyboardInterrupt. We don't want KeyboardInterrupt at arbitrary
# points in a non-interactive shell. (e.g. osh -c 'sleep 5' then Ctrl-C)
signal.signal(signal.SIGINT, signal.SIG_IGN)
if exec_opts.interactive:
if line_input:
# NOTE: We're using a different WordEvaluator here.
ev = word_eval.CompletionWordEvaluator(mem, exec_opts, exec_deps,
arena)
root_comp = completion.RootCompleter(ev, mem, comp_lookup,
compopt_state, comp_ui_state,
comp_ctx, debug_f)
term_width = 0
if opts.completion_display == 'nice':
try:
term_width = libc.get_terminal_width()
except IOError: # stdin not a terminal
pass
if term_width != 0:
display = comp_ui.NiceDisplay(term_width, comp_ui_state,
prompt_state, debug_f,
line_input)
else:
display = comp_ui.MinimalDisplay(comp_ui_state, prompt_state,
debug_f)
_InitReadline(line_input, history_filename, root_comp, display,
debug_f)
_InitDefaultCompletions(ex, complete_builtin, comp_lookup)
else: # Without readline module
display = comp_ui.MinimalDisplay(comp_ui_state, prompt_state,
debug_f)
# The shell itself should ignore Ctrl-\.
signal.signal(signal.SIGQUIT, signal.SIG_IGN)
# This prevents Ctrl-Z from suspending OSH in interactive mode. But we're
# not getting notification via wait() that the child stopped?
signal.signal(signal.SIGTSTP, signal.SIG_IGN)
# Register a callback to receive terminal width changes.
signal.signal(signal.SIGWINCH, lambda x, y: display.OnWindowChange())
# NOTE: Call this AFTER _InitDefaultCompletions.
SourceStartupFile(rc_path, lang, parse_ctx, ex)
line_reader.Reset() # After sourcing startup file, render $PS1
return main_loop.Interactive(opts, ex, c_parser, display, arena)
nodes_out = [] if exec_opts.noexec else None
if nodes_out is None and opts.parser_mem_dump:
raise args.UsageError('--parser-mem-dump can only be used with -n')
_tlog('Execute(node)')
status = main_loop.Batch(ex, c_parser, arena, nodes_out=nodes_out)
# Only print nodes if the whole parse succeeded.
if nodes_out is not None and status == 0:
if opts.parser_mem_dump: # only valid in -n mode
# This might be superstition, but we want to let the value stabilize
# after parsing. bash -c 'cat /proc/$$/status' gives different results
# with a sleep.
time.sleep(0.001)
input_path = '/proc/%d/status' % posix.getpid()
with open(input_path) as f, open(opts.parser_mem_dump, 'w') as f2:
contents = f.read()
f2.write(contents)
log('Wrote %s to %s (--parser-mem-dump)', input_path,
opts.parser_mem_dump)
ui.PrintAst(nodes_out, opts)
# NOTE: 'exit 1' is ControlFlow and gets here, but subshell/commandsub
# don't because they call sys.exit().
if opts.runtime_mem_dump:
# This might be superstition, but we want to let the value stabilize
# after parsing. bash -c 'cat /proc/$$/status' gives different results
# with a sleep.
time.sleep(0.001)
input_path = '/proc/%d/status' % posix.getpid()
with open(input_path) as f, open(opts.runtime_mem_dump, 'w') as f2:
contents = f.read()
f2.write(contents)
log('Wrote %s to %s (--runtime-mem-dump)', input_path,
opts.runtime_mem_dump)
# NOTE: We haven't closed the file opened with fd_state.Open
return status
from frontend import parse_lib
from osh import builtin
from osh import state
Process = process.Process
ExternalThunk = process.ExternalThunk
def Banner(msg):
print('-' * 60)
print(msg)
# TODO: Put these all in a function.
_ARENA = test_lib.MakeArena('process_test.py')
_MEM = state.Mem('', [], {}, _ARENA)
_PARSE_OPTS = parse_lib.OilParseOptions()
_EXEC_OPTS = state.ExecOpts(_MEM, _PARSE_OPTS, None)
_JOB_STATE = process.JobState()
_WAITER = process.Waiter(_JOB_STATE, _EXEC_OPTS)
_ERRFMT = ui.ErrorFormatter(_ARENA)
_FD_STATE = process.FdState(_ERRFMT, _JOB_STATE)
_SEARCH_PATH = state.SearchPath(_MEM)
_EXT_PROG = process.ExternalProgram(False, _FD_STATE, _SEARCH_PATH, _ERRFMT,
util.NullDebugFile())
def _CommandNode(code_str, arena):
c_parser = test_lib.InitCommandParser(code_str, arena=arena)
return c_parser.ParseLogicalLine()
def setUpClass(cls):
arena = test_lib.MakeArena('<ui_test.py>')
mem = state.Mem('', [], {}, arena)
ex = test_lib.InitExecutor(arena=arena)
cls.p = prompt.Evaluator('osh', arena, ex.parse_ctx, ex, mem)
def ShellMain(lang, argv0, argv, login_shell):
"""Used by bin/osh and bin/oil.
Args:
lang: 'osh' or 'oil'
argv0, argv: So we can also invoke bin/osh as 'oil.ovm osh'. Like busybox.
login_shell: Was - on the front?
"""
# Differences between osh and oil:
# - --help? I guess Oil has a SUPERSET of OSH options.
# - oshrc vs oilrc
# - the parser and executor
# - Change the prompt in the interactive shell?
assert lang in ('osh', 'oil'), lang
arg_r = args.Reader(argv)
try:
opts = OSH_SPEC.Parse(arg_r)
except args.UsageError as e:
ui.Stderr('osh usage error: %s', e.msg)
return 2
# NOTE: This has a side effect of deleting _OVM_* from the environment!
# TODO: Thread this throughout the program, and get rid of the global
# variable in core/util.py. Rename to InitResourceLaoder(). It's now only
# used for the 'help' builtin and --version.
loader = pyutil.GetResourceLoader()
if opts.help:
builtin.Help(['%s-usage' % lang], loader)
return 0
if opts.version:
# OSH version is the only binary in Oil right now, so it's all one version.
_ShowVersion()
return 0
if arg_r.AtEnd():
dollar0 = argv0
has_main = False
else:
dollar0 = arg_r.Peek() # the script name, or the arg after -c
has_main = True
arena = alloc.Arena()
errfmt = ui.ErrorFormatter(arena)
# NOTE: has_main is only for ${BASH_SOURCE[@} and family. Could be a
# required arg.
mem = state.Mem(dollar0,
argv[arg_r.i + 1:],
posix.environ,
arena,
has_main=has_main)
builtin_funcs.Init(mem)
procs = {}
job_state = process.JobState()
fd_state = process.FdState(errfmt, job_state)
parse_opts = parse_lib.OilParseOptions()
exec_opts = state.ExecOpts(mem, parse_opts, line_input)
if opts.show_options: # special case: sh -o
exec_opts.ShowOptions([])
return 0
builtin_pure.SetExecOpts(exec_opts, opts.opt_changes, opts.shopt_changes)
aliases = {} # feedback between runtime and parser
oil_grammar = meta.LoadOilGrammar(loader)
if opts.one_pass_parse and not exec_opts.noexec:
raise args.UsageError('--one-pass-parse requires noexec (-n)')
parse_ctx = parse_lib.ParseContext(arena,
parse_opts,
aliases,
oil_grammar,
one_pass_parse=opts.one_pass_parse)
# Three ParseContext instances SHARE aliases.
comp_arena = alloc.Arena()
comp_arena.PushSource(source.Unused('completion'))
trail1 = parse_lib.Trail()
# one_pass_parse needs to be turned on to complete inside backticks. TODO:
# fix the issue where ` gets erased because it's not part of
# set_completer_delims().
comp_ctx = parse_lib.ParseContext(comp_arena,
parse_opts,
aliases,
oil_grammar,
trail=trail1,
one_pass_parse=True)
hist_arena = alloc.Arena()
hist_arena.PushSource(source.Unused('history'))
trail2 = parse_lib.Trail()
hist_ctx = parse_lib.ParseContext(hist_arena,
parse_opts,
aliases,
oil_grammar,
trail=trail2)
# Deps helps manages dependencies. These dependencies are circular:
# - ex and word_ev, arith_ev -- for command sub, arith sub
# - arith_ev and word_ev -- for $(( ${a} )) and $x$(( 1 ))
# - ex and builtins (which execute code, like eval)
# - prompt_ev needs word_ev for $PS1, which needs prompt_ev for @P
exec_deps = cmd_exec.Deps()
# TODO: In general, exec_deps are shared between the mutually recursive
# evaluators. Some of the four below are only shared between a builtin and
# the Executor, so we could put them somewhere else.
exec_deps.traps = {}
exec_deps.trap_nodes = [] # TODO: Clear on fork() to avoid duplicates
exec_deps.job_state = job_state
# note: exec_opts.interactive set later
exec_deps.waiter = process.Waiter(job_state, exec_opts)
exec_deps.errfmt = errfmt
my_pid = posix.getpid()
debug_path = ''
debug_dir = posix.environ.get('OSH_DEBUG_DIR')
if opts.debug_file: # --debug-file takes precedence over OSH_DEBUG_DIR
debug_path = opts.debug_file
elif debug_dir:
debug_path = os_path.join(debug_dir, '%d-osh.log' % my_pid)
if debug_path:
# This will be created as an empty file if it doesn't exist, or it could be
# a pipe.
try:
debug_f = util.DebugFile(fd_state.Open(debug_path, mode='w'))
except OSError as e:
ui.Stderr("osh: Couldn't open %r: %s", debug_path,
posix.strerror(e.errno))
return 2
else:
debug_f = util.NullDebugFile()
exec_deps.debug_f = debug_f
# Not using datetime for dependency reasons. TODO: maybe show the date at
# the beginning of the log, and then only show time afterward? To save
# space, and make space for microseconds. (datetime supports microseconds
# but time.strftime doesn't).
iso_stamp = time.strftime("%Y-%m-%d %H:%M:%S")
debug_f.log('%s [%d] OSH started with argv %s', iso_stamp, my_pid, argv)
if debug_path:
debug_f.log('Writing logs to %r', debug_path)
interp = posix.environ.get('OSH_HIJACK_SHEBANG', '')
exec_deps.search_path = state.SearchPath(mem)
exec_deps.ext_prog = process.ExternalProgram(interp, fd_state,
exec_deps.search_path, errfmt,
debug_f)
splitter = split.SplitContext(mem)
exec_deps.splitter = splitter
# split() builtin
builtin_funcs.SetGlobalFunc(mem, 'split',
lambda s: splitter.SplitForWordEval(s))
# This could just be OSH_DEBUG_STREAMS='debug crash' ? That might be
# stuffing too much into one, since a .json crash dump isn't a stream.
crash_dump_dir = posix.environ.get('OSH_CRASH_DUMP_DIR', '')
exec_deps.dumper = dev.CrashDumper(crash_dump_dir)
if opts.xtrace_to_debug_file:
trace_f = debug_f
else:
trace_f = util.DebugFile(sys.stderr)
exec_deps.trace_f = trace_f
comp_lookup = completion.Lookup()
# Various Global State objects to work around readline interfaces
compopt_state = completion.OptionState()
comp_ui_state = comp_ui.State()
prompt_state = comp_ui.PromptState()
dir_stack = state.DirStack()
new_var = builtin_assign.NewVar(mem, procs, errfmt)
builtins = { # Lookup
builtin_e.ECHO: builtin_pure.Echo(exec_opts),
builtin_e.PRINTF: builtin_printf.Printf(mem, parse_ctx, errfmt),
builtin_e.PUSHD: builtin.Pushd(mem, dir_stack, errfmt),
builtin_e.POPD: builtin.Popd(mem, dir_stack, errfmt),
builtin_e.DIRS: builtin.Dirs(mem, dir_stack, errfmt),
builtin_e.PWD: builtin.Pwd(mem, errfmt),
builtin_e.READ: builtin.Read(splitter, mem),
builtin_e.HELP: builtin.Help(loader, errfmt),
builtin_e.HISTORY: builtin.History(line_input),
# Completion (more added below)
builtin_e.COMPOPT: builtin_comp.CompOpt(compopt_state, errfmt),
builtin_e.COMPADJUST: builtin_comp.CompAdjust(mem),
# test / [ differ by need_right_bracket
builtin_e.TEST: builtin_bracket.Test(False, errfmt),
builtin_e.BRACKET: builtin_bracket.Test(True, errfmt),
# Assignment (which are pure)
builtin_e.DECLARE: new_var,
builtin_e.TYPESET: new_var,
builtin_e.LOCAL: new_var,
builtin_e.EXPORT: builtin_assign.Export(mem, errfmt),
builtin_e.READONLY: builtin_assign.Readonly(mem, errfmt),
builtin_e.UNSET: builtin_assign.Unset(mem, procs, errfmt),
builtin_e.SHIFT: builtin_assign.Shift(mem),
# Pure
builtin_e.SET: builtin_pure.Set(exec_opts, mem),
builtin_e.SHOPT: builtin_pure.Shopt(exec_opts),
builtin_e.ALIAS: builtin_pure.Alias(aliases, errfmt),
builtin_e.UNALIAS: builtin_pure.UnAlias(aliases, errfmt),
builtin_e.TYPE: builtin_pure.Type(procs, aliases, exec_deps.search_path),
builtin_e.HASH: builtin_pure.Hash(exec_deps.search_path),
builtin_e.GETOPTS: builtin_pure.GetOpts(mem, errfmt),
builtin_e.COLON: lambda arg_vec: 0, # a "special" builtin
builtin_e.TRUE: lambda arg_vec: 0,
builtin_e.FALSE: lambda arg_vec: 1,
# Process
builtin_e.WAIT: builtin_process.Wait(exec_deps.waiter,
exec_deps.job_state, mem, errfmt),
builtin_e.JOBS: builtin_process.Jobs(exec_deps.job_state),
builtin_e.FG: builtin_process.Fg(exec_deps.job_state, exec_deps.waiter),
builtin_e.BG: builtin_process.Bg(exec_deps.job_state),
builtin_e.UMASK: builtin_process.Umask,
# Oil
builtin_e.REPR: builtin_oil.Repr(mem, errfmt),
builtin_e.PUSH: builtin_oil.Push(mem, errfmt),
builtin_e.USE: builtin_oil.Use(mem, errfmt),
}
ex = cmd_exec.Executor(mem, fd_state, procs, builtins, exec_opts,
parse_ctx, exec_deps)
exec_deps.ex = ex
word_ev = word_eval.NormalWordEvaluator(mem, exec_opts, exec_deps, arena)
exec_deps.word_ev = word_ev
arith_ev = osh_expr_eval.ArithEvaluator(mem, exec_opts, word_ev, errfmt)
exec_deps.arith_ev = arith_ev
word_ev.arith_ev = arith_ev # Another circular dependency
bool_ev = osh_expr_eval.BoolEvaluator(mem, exec_opts, word_ev, errfmt)
exec_deps.bool_ev = bool_ev
expr_ev = expr_eval.OilEvaluator(mem, procs, ex, word_ev, errfmt)
exec_deps.expr_ev = expr_ev
tracer = dev.Tracer(parse_ctx, exec_opts, mem, word_ev, trace_f)
exec_deps.tracer = tracer
# HACK for circular deps
ex.word_ev = word_ev
ex.arith_ev = arith_ev
ex.bool_ev = bool_ev
ex.expr_ev = expr_ev
ex.tracer = tracer
word_ev.expr_ev = expr_ev
spec_builder = builtin_comp.SpecBuilder(ex, parse_ctx, word_ev, splitter,
comp_lookup)
# Add some builtins that depend on the executor!
complete_builtin = builtin_comp.Complete(spec_builder, comp_lookup)
builtins[builtin_e.COMPLETE] = complete_builtin
builtins[builtin_e.COMPGEN] = builtin_comp.CompGen(spec_builder)
builtins[builtin_e.CD] = builtin.Cd(mem, dir_stack, ex, errfmt)
builtins[builtin_e.JSON] = builtin_oil.Json(mem, ex, errfmt)
sig_state = process.SignalState()
sig_state.InitShell()
builtins[builtin_e.TRAP] = builtin_process.Trap(sig_state, exec_deps.traps,
exec_deps.trap_nodes, ex,
errfmt)
if lang == 'oil':
# The Oil executor wraps an OSH executor? It needs to be able to source
# it.
ex = oil_cmd_exec.OilExecutor(ex)
# PromptEvaluator rendering is needed in non-interactive shells for @P.
prompt_ev = prompt.Evaluator(lang, parse_ctx, ex, mem)
exec_deps.prompt_ev = prompt_ev
word_ev.prompt_ev = prompt_ev # HACK for circular deps
# History evaluation is a no-op if line_input is None.
hist_ev = history.Evaluator(line_input, hist_ctx, debug_f)
if opts.c is not None:
arena.PushSource(source.CFlag())
line_reader = reader.StringLineReader(opts.c, arena)
if opts.i: # -c and -i can be combined
exec_opts.interactive = True
elif opts.i: # force interactive
arena.PushSource(source.Stdin(' -i'))
line_reader = reader.InteractiveLineReader(arena, prompt_ev, hist_ev,
line_input, prompt_state,
sig_state)
exec_opts.interactive = True
else:
try:
script_name = arg_r.Peek()
except IndexError:
if sys.stdin.isatty():
arena.PushSource(source.Interactive())
line_reader = reader.InteractiveLineReader(
arena, prompt_ev, hist_ev, line_input, prompt_state,
sig_state)
exec_opts.interactive = True
else:
arena.PushSource(source.Stdin(''))
line_reader = reader.FileLineReader(sys.stdin, arena)
else:
arena.PushSource(source.MainFile(script_name))
try:
f = fd_state.Open(script_name)
except OSError as e:
ui.Stderr("osh: Couldn't open %r: %s", script_name,
posix.strerror(e.errno))
return 1
line_reader = reader.FileLineReader(f, arena)
# TODO: assert arena.NumSourcePaths() == 1
# TODO: .rc file needs its own arena.
if lang == 'osh':
c_parser = parse_ctx.MakeOshParser(line_reader)
else:
c_parser = parse_ctx.MakeOilParser(line_reader)
if exec_opts.interactive:
# Calculate ~/.config/oil/oshrc or oilrc
# Use ~/.config/oil to avoid cluttering the user's home directory. Some
# users may want to ln -s ~/.config/oil/oshrc ~/oshrc or ~/.oshrc.
# https://unix.stackexchange.com/questions/24347/why-do-some-applications-use-config-appname-for-their-config-data-while-other
home_dir = process.GetHomeDir()
assert home_dir is not None
rc_path = opts.rcfile or os_path.join(home_dir, '.config/oil',
lang + 'rc')
history_filename = os_path.join(home_dir, '.config/oil',
'history_' + lang)
if line_input:
# NOTE: We're using a different WordEvaluator here.
ev = word_eval.CompletionWordEvaluator(mem, exec_opts, exec_deps,
arena)
root_comp = completion.RootCompleter(ev, mem, comp_lookup,
compopt_state, comp_ui_state,
comp_ctx, debug_f)
term_width = 0
if opts.completion_display == 'nice':
try:
term_width = libc.get_terminal_width()
except IOError: # stdin not a terminal
pass
if term_width != 0:
display = comp_ui.NiceDisplay(term_width, comp_ui_state,
prompt_state, debug_f,
line_input)
else:
display = comp_ui.MinimalDisplay(comp_ui_state, prompt_state,
debug_f)
_InitReadline(line_input, history_filename, root_comp, display,
debug_f)
_InitDefaultCompletions(ex, complete_builtin, comp_lookup)
else: # Without readline module
display = comp_ui.MinimalDisplay(comp_ui_state, prompt_state,
debug_f)
sig_state.InitInteractiveShell(display)
# NOTE: Call this AFTER _InitDefaultCompletions.
try:
SourceStartupFile(rc_path, lang, parse_ctx, ex)
except util.UserExit as e:
return e.status
line_reader.Reset() # After sourcing startup file, render $PS1
prompt_plugin = prompt.UserPlugin(mem, parse_ctx, ex)
try:
status = main_loop.Interactive(opts, ex, c_parser, display,
prompt_plugin, errfmt)
if ex.MaybeRunExitTrap():
status = ex.LastStatus()
except util.UserExit as e:
status = e.status
return status
nodes_out = [] if exec_opts.noexec else None
if nodes_out is None and opts.parser_mem_dump:
raise args.UsageError('--parser-mem-dump can only be used with -n')
_tlog('Execute(node)')
try:
status = main_loop.Batch(ex, c_parser, arena, nodes_out=nodes_out)
if ex.MaybeRunExitTrap():
status = ex.LastStatus()
except util.UserExit as e:
status = e.status
# Only print nodes if the whole parse succeeded.
if nodes_out is not None and status == 0:
if opts.parser_mem_dump: # only valid in -n mode
# This might be superstition, but we want to let the value stabilize
# after parsing. bash -c 'cat /proc/$$/status' gives different results
# with a sleep.
time.sleep(0.001)
input_path = '/proc/%d/status' % posix.getpid()
with open(input_path) as f, open(opts.parser_mem_dump, 'w') as f2:
contents = f.read()
f2.write(contents)
log('Wrote %s to %s (--parser-mem-dump)', input_path,
opts.parser_mem_dump)
ui.PrintAst(nodes_out, opts)
# NOTE: 'exit 1' is ControlFlow and gets here, but subshell/commandsub
# don't because they call sys.exit().
if opts.runtime_mem_dump:
# This might be superstition, but we want to let the value stabilize
# after parsing. bash -c 'cat /proc/$$/status' gives different results
# with a sleep.
time.sleep(0.001)
input_path = '/proc/%d/status' % posix.getpid()
with open(input_path) as f, open(opts.runtime_mem_dump, 'w') as f2:
contents = f.read()
f2.write(contents)
log('Wrote %s to %s (--runtime-mem-dump)', input_path,
opts.runtime_mem_dump)
# NOTE: We haven't closed the file opened with fd_state.Open
return status
