def main(argv):
# type: (List[str]) -> int
arena = alloc.Arena()
dollar0 = argv[0]
debug_stack = [] # type: List[state.DebugFrame]
mem = state.Mem(dollar0, argv, arena, debug_stack)
opt_hook = state.OptHook()
parse_opts, exec_opts, mutable_opts = state.MakeOpts(mem, opt_hook)
# Dummy value; not respecting aliases!
aliases = {} # type: Dict[str, str]
# parse `` and a[x+1]=bar differently
state.SetGlobalString(mem, 'SHELLOPTS', '')
oil_grammar = None # type: Grammar
if mylib.PYTHON:
loader = pyutil.GetResourceLoader()
oil_grammar = meta.LoadOilGrammar(loader)
parse_ctx = parse_lib.ParseContext(arena, parse_opts, aliases, oil_grammar)
argv = argv[1:] # remove binary name
i, flag_a, flag_c, flag_n = Parse(argv)
argv = argv[i:] # truncate
if flag_c:
# This path is easier to run through GDB
line_reader = reader.StringLineReader(flag_c, arena)
src = source.CFlag() # type: source_t
elif len(argv) == 0:
line_reader = reader.FileLineReader(mylib.Stdin(), arena)
src = source.Stdin('')
elif len(argv) == 1:
path = argv[0]
f = mylib.open(path)
line_reader = reader.FileLineReader(f, arena)
src = source.MainFile(path)
else:
raise AssertionError(argv)
arena.PushSource(src)
c_parser = parse_ctx.MakeOshParser(line_reader)
# C++ doesn't have the abbreviations yet (though there are some differences
# like omitting spids)
#tree = node.AbbreviatedTree()
if flag_n:
try:
node = main_loop.ParseWholeFile(c_parser)
except error.Parse as e:
ui.PrettyPrintError(e, arena)
return 2
assert node is not None
if flag_a:
tree = node.PrettyTree()
ast_f = fmt.DetectConsoleOutput(mylib.Stdout())
fmt.PrintTree(tree, ast_f)
ast_f.write('\n')
return 0
# New osh_eval.py instantiations
errfmt = ui.ErrorFormatter(arena)
splitter = split.SplitContext(mem)
arith_ev = sh_expr_eval.ArithEvaluator(mem, exec_opts, parse_ctx, errfmt)
bool_ev = sh_expr_eval.BoolEvaluator(mem, exec_opts, parse_ctx, errfmt)
word_ev = word_eval.NormalWordEvaluator(mem, exec_opts, splitter, errfmt)
arith_ev.word_ev = word_ev
word_ev.arith_ev = arith_ev
procs = {} # type: Dict[str, command__ShFunction]
assign_builtins = {} # type: Dict[int, _AssignBuiltin]
new_var = builtin_assign.NewVar(mem, procs, errfmt)
assign_builtins[builtin_i.declare] = new_var
assign_builtins[builtin_i.typeset] = new_var
assign_builtins[builtin_i.local] = new_var
#assign_builtins = {
# # ShAssignment (which are pure)
# builtin_i.declare: new_var,
# builtin_i.typeset: new_var,
# builtin_i.local: new_var,
# builtin_i.export_: builtin_assign.Export(mem, errfmt),
# builtin_i.readonly: builtin_assign.Readonly(mem, errfmt),
#}
cmd_deps = cmd_eval.Deps()
cmd_deps.mutable_opts = mutable_opts
cmd_deps.traps = {}
cmd_deps.trap_nodes = [] # TODO: Clear on fork() to avoid duplicates
cmd_deps.dumper = dev.CrashDumper('')
builtins = {} # type: Dict[int, _Builtin]
builtins[builtin_i.echo] = Echo()
builtins[builtin_i.shopt] = Shopt(mutable_opts)
builtins[builtin_i.set] = Set(mutable_opts)
ex = NullExecutor(builtins)
trace_f = util.DebugFile(mylib.Stderr())
tracer = dev.Tracer(parse_ctx, exec_opts, mutable_opts, mem, word_ev, trace_f)
cmd_ev = cmd_eval.CommandEvaluator(mem, exec_opts, errfmt, procs,
assign_builtins, arena, cmd_deps)
# vm.InitCircularDeps
cmd_ev.arith_ev = arith_ev
cmd_ev.bool_ev = bool_ev
cmd_ev.word_ev = word_ev
cmd_ev.tracer = tracer
cmd_ev.shell_ex = ex
bool_ev.word_ev = word_ev
status = main_loop.Batch(cmd_ev, c_parser, arena, is_main=True)
return status
def main(argv):
# type: (List[str]) -> int
arena = alloc.Arena()
dollar0 = argv[0]
debug_stack = [] # type: List[state.DebugFrame]
argv = argv[1:] # remove binary name
i, flag_a, flag_c, flag_n = Parse(argv)
argv = argv[i:] # truncate
mem = state.Mem(dollar0, argv, arena, debug_stack)
# TODO: look at extern char** environ;
environ = {} # type: Dict[str, str]
environ['PWD'] = posix.getcwd()
state.InitMem(mem, environ, 'VERSION')
opt_hook = state.OptHook()
parse_opts, exec_opts, mutable_opts = state.MakeOpts(mem, opt_hook)
# Dummy value; not respecting aliases!
aliases = {} # type: Dict[str, str]
# parse `` and a[x+1]=bar differently
oil_grammar = None # type: Grammar
if mylib.PYTHON:
loader = pyutil.GetResourceLoader()
oil_grammar = meta.LoadOilGrammar(loader)
parse_ctx = parse_lib.ParseContext(arena, parse_opts, aliases, oil_grammar)
if flag_c:
# This path is easier to run through GDB
line_reader = reader.StringLineReader(flag_c, arena)
src = source.CFlag() # type: source_t
elif len(argv) == 0:
line_reader = reader.FileLineReader(mylib.Stdin(), arena)
src = source.Stdin('')
elif len(argv) == 1:
path = argv[0]
f = mylib.open(path)
line_reader = reader.FileLineReader(f, arena)
src = source.MainFile(path)
else:
raise AssertionError(argv)
arena.PushSource(src)
c_parser = parse_ctx.MakeOshParser(line_reader)
# C++ doesn't have the abbreviations yet (though there are some differences
# like omitting spids)
#tree = node.AbbreviatedTree()
if flag_n:
try:
node = main_loop.ParseWholeFile(c_parser)
except error.Parse as e:
ui.PrettyPrintError(e, arena)
return 2
assert node is not None
if flag_a:
tree = node.PrettyTree()
ast_f = fmt.DetectConsoleOutput(mylib.Stdout())
fmt.PrintTree(tree, ast_f)
ast_f.write('\n')
return 0
# New osh_eval.py instantiations
errfmt = ui.ErrorFormatter(arena)
splitter = split.SplitContext(mem)
arith_ev = sh_expr_eval.ArithEvaluator(mem, exec_opts, parse_ctx, errfmt)
bool_ev = sh_expr_eval.BoolEvaluator(mem, exec_opts, parse_ctx, errfmt)
word_ev = word_eval.NormalWordEvaluator(mem, exec_opts, splitter, errfmt)
prompt_ev = prompt.Evaluator('osh', parse_ctx, mem)
arith_ev.word_ev = word_ev
word_ev.arith_ev = arith_ev
word_ev.prompt_ev = prompt_ev
prompt_ev.word_ev = word_ev
procs = {} # type: Dict[str, command__ShFunction]
assign_builtins = {} # type: Dict[int, _AssignBuiltin]
new_var = builtin_assign.NewVar(mem, procs, errfmt)
assign_builtins[builtin_i.declare] = new_var
assign_builtins[builtin_i.typeset] = new_var
assign_builtins[builtin_i.local] = new_var
assign_builtins[builtin_i.export_] = builtin_assign.Export(mem, errfmt)
assign_builtins[builtin_i.readonly] = builtin_assign.Readonly(mem, errfmt)
#assign_builtins = {
# # ShAssignment (which are pure)
# builtin_i.declare: new_var,
# builtin_i.typeset: new_var,
# builtin_i.local: new_var,
# builtin_i.export_: builtin_assign.Export(mem, errfmt),
# builtin_i.readonly: builtin_assign.Readonly(mem, errfmt),
#}
cmd_deps = cmd_eval.Deps()
cmd_deps.mutable_opts = mutable_opts
cmd_deps.traps = {}
cmd_deps.trap_nodes = [] # TODO: Clear on fork() to avoid duplicates
cmd_deps.dumper = dev.CrashDumper('')
search_path = state.SearchPath(mem)
builtins = {} # type: Dict[int, vm._Builtin]
builtins[builtin_i.echo] = builtin_pure.Echo(exec_opts)
builtins[builtin_i.set] = Set(mutable_opts) # DUMMY until ParseMore()
if mylib.PYTHON:
# Use the real one
builtins[builtin_i.set] = builtin_pure.Set(mutable_opts, mem)
builtins[builtin_i.shopt] = builtin_pure.Shopt(mutable_opts)
builtins[builtin_i.alias] = builtin_pure.Alias(aliases, errfmt)
builtins[builtin_i.unalias] = builtin_pure.UnAlias(aliases, errfmt)
builtins[builtin_i.hash] = builtin_pure.Hash(search_path)
builtins[builtin_i.getopts] = builtin_pure.GetOpts(mem, errfmt)
builtins[builtin_i.shift] = builtin_assign.Shift(mem)
builtins[builtin_i.unset] = builtin_assign.Unset(
mem, exec_opts, procs, parse_ctx, arith_ev, errfmt)
true_ = builtin_pure.Boolean(0)
builtins[builtin_i.colon] = true_ # a "special" builtin
builtins[builtin_i.true_] = true_
builtins[builtin_i.false_] = builtin_pure.Boolean(1)
# builtin_meta
builtins[builtin_i.type] = builtin_meta.Type(procs, aliases, search_path, errfmt)
shell_ex = NullExecutor(exec_opts, mutable_opts, procs, builtins)
trace_f = util.DebugFile(mylib.Stderr())
tracer = dev.Tracer(parse_ctx, exec_opts, mutable_opts, mem, word_ev, trace_f)
cmd_ev = cmd_eval.CommandEvaluator(mem, exec_opts, errfmt, procs,
assign_builtins, arena, cmd_deps)
# TODO: can't instantiate this yet
#fd_state = None
# needs cmd_ev
builtins[builtin_i.eval] = builtin_meta.Eval(parse_ctx, exec_opts, cmd_ev)
#source_builtin = builtin_meta.Source(
# parse_ctx, search_path, cmd_ev, fd_state, errfmt)
#builtins[builtin_i.source] = source_builtin
#builtins[builtin_i.dot] = source_builtin
builtins[builtin_i.builtin] = builtin_meta.Builtin(shell_ex, errfmt)
builtins[builtin_i.command] = builtin_meta.Command(shell_ex, procs, aliases,
search_path)
builtins[builtin_i.printf] = builtin_printf.Printf(mem, parse_ctx, errfmt)
builtins[builtin_i.test] = builtin_bracket.Test(False, exec_opts, mem, errfmt)
builtins[builtin_i.bracket] = builtin_bracket.Test(True, exec_opts, mem, errfmt)
dir_stack = state.DirStack()
builtins[builtin_i.pushd] = builtin_misc.Pushd(mem, dir_stack, errfmt)
builtins[builtin_i.popd] = builtin_misc.Popd(mem, dir_stack, errfmt)
builtins[builtin_i.dirs] = builtin_misc.Dirs(mem, dir_stack, errfmt)
builtins[builtin_i.pwd] = builtin_misc.Pwd(mem, errfmt)
builtins[builtin_i.times] = builtin_misc.Times()
builtins[builtin_i.read] = builtin_misc.Read(splitter, mem)
builtins[builtin_i.cat] = builtin_misc.Cat() # for $(<file)
builtins[builtin_i.cd] = builtin_misc.Cd(mem, dir_stack, cmd_ev, errfmt)
# vm.InitCircularDeps
cmd_ev.arith_ev = arith_ev
cmd_ev.bool_ev = bool_ev
cmd_ev.word_ev = word_ev
cmd_ev.tracer = tracer
cmd_ev.shell_ex = shell_ex
shell_ex.cmd_ev = cmd_ev
bool_ev.word_ev = word_ev
try:
status = main_loop.Batch(cmd_ev, c_parser, arena,
cmd_flags=cmd_eval.IsMainProgram)
except util.UserExit as e:
# TODO: fix this
#status = e.status
status = 1
return status
def Main(lang, arg_r, environ, login_shell, loader, line_input):
# type: (str, args.Reader, Dict[str, str], bool, pyutil._ResourceLoader, Any) -> int
"""The full shell lifecycle. Used by bin/osh and bin/oil.
Args:
lang: 'osh' or 'oil'
argv0, arg_r: command line arguments
environ: environment
login_shell: Was - on the front?
loader: to get help, version, grammar, etc.
line_input: optional GNU readline
"""
# Differences between osh and oil:
# - --help? I guess Oil has a SUPERSET of OSH options.
# - oshrc vs oilrc
# - shopt -s oil:all
# - Change the prompt in the interactive shell?
# osh-pure:
# - no oil grammar
# - no expression evaluator
# - no interactive shell, or line_input
# - no process.*
# process.{ExternalProgram,Waiter,FdState,JobState,SignalState} -- we want
# to evaluate config files without any of these
# Modules not translated yet: completion, comp_ui, builtin_comp, process
# - word evaluator
# - shouldn't glob? set -o noglob? or hard failure?
# - ~ shouldn't read from the file system
# - I guess it can just be the HOME=HOME?
# Builtin:
# shellvm -c 'echo hi'
# shellvm <<< 'echo hi'
argv0 = arg_r.Peek()
assert argv0 is not None
arg_r.Next()
assert lang in ('osh', 'oil'), lang
try:
attrs = flag_spec.ParseMore('main', arg_r)
except error.Usage as e:
stderr_line('osh usage error: %s', e.msg)
return 2
flag = arg_types.main(attrs.attrs)
arena = alloc.Arena()
errfmt = ui.ErrorFormatter(arena)
help_builtin = builtin_misc.Help(loader, errfmt)
if flag.help:
help_builtin.Run(MakeBuiltinArgv(['%s-usage' % lang]))
return 0
if flag.version:
# OSH version is the only binary in Oil right now, so it's all one version.
pyutil.ShowAppVersion('Oil', loader)
return 0
no_str = None # type: str
debug_stack = [] # type: List[state.DebugFrame]
if arg_r.AtEnd():
dollar0 = argv0
else:
dollar0 = arg_r.Peek() # the script name, or the arg after -c
# Copy quirky bash behavior.
frame0 = state.DebugFrame(dollar0, 'main', no_str, state.LINE_ZERO, 0,
0)
debug_stack.append(frame0)
# Copy quirky bash behavior.
frame1 = state.DebugFrame(no_str, no_str, no_str, runtime.NO_SPID, 0, 0)
debug_stack.append(frame1)
script_name = arg_r.Peek() # type: Optional[str]
arg_r.Next()
mem = state.Mem(dollar0, arg_r.Rest(), arena, debug_stack)
version_str = pyutil.GetVersion(loader)
state.InitMem(mem, environ, version_str)
procs = {} # type: Dict[str, command__ShFunction]
job_state = process.JobState()
fd_state = process.FdState(errfmt, job_state, mem)
opt_hook = state.OptHook()
parse_opts, exec_opts, mutable_opts = state.MakeOpts(mem, opt_hook)
# TODO: only MutableOpts needs mem, so it's not a true circular dep.
mem.exec_opts = exec_opts # circular dep
if attrs.show_options: # special case: sh -o
mutable_opts.ShowOptions([])
return 0
# Set these BEFORE processing flags, so they can be overridden.
if lang == 'oil':
mutable_opts.SetShoptOption('oil:all', True)
builtin_pure.SetShellOpts(mutable_opts, attrs.opt_changes,
attrs.shopt_changes)
# feedback between runtime and parser
aliases = {} # type: Dict[str, str]
oil_grammar = None # type: grammar.Grammar
#oil_grammar = pyutil.LoadOilGrammar(loader)
if flag.one_pass_parse and not exec_opts.noexec():
e_usage('--one-pass-parse requires noexec (-n)')
parse_ctx = parse_lib.ParseContext(arena, parse_opts, aliases, oil_grammar)
parse_ctx.Init_OnePassParse(flag.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)
comp_ctx.Init_Trail(trail1)
comp_ctx.Init_OnePassParse(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)
hist_ctx.Init_Trail(trail2)
# Deps helps manages dependencies. These dependencies are circular:
# - cmd_ev and word_ev, arith_ev -- for command sub, arith sub
# - arith_ev and word_ev -- for $(( ${a} )) and $x$(( 1 ))
# - cmd_ev and builtins (which execute code, like eval)
# - prompt_ev needs word_ev for $PS1, which needs prompt_ev for @P
cmd_deps = cmd_eval.Deps()
cmd_deps.mutable_opts = mutable_opts
# TODO: In general, cmd_deps are shared between the mutually recursive
# evaluators. Some of the four below are only shared between a builtin and
# the CommandEvaluator, so we could put them somewhere else.
cmd_deps.traps = {}
cmd_deps.trap_nodes = [] # TODO: Clear on fork() to avoid duplicates
waiter = process.Waiter(job_state, exec_opts)
my_pid = posix.getpid()
debug_path = ''
debug_dir = environ.get('OSH_DEBUG_DIR')
if flag.debug_file is not None:
# --debug-file takes precedence over OSH_DEBUG_DIR
debug_path = flag.debug_file
elif debug_dir is not None:
debug_path = os_path.join(debug_dir, '%d-osh.log' % my_pid)
if len(debug_path):
raise NotImplementedError()
else:
debug_f = util.NullDebugFile() # type: util._DebugFile
cmd_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).
if mylib.PYTHON:
iso_stamp = time_.strftime("%Y-%m-%d %H:%M:%S")
debug_f.log('%s [%d] OSH started with argv %s', iso_stamp, my_pid,
arg_r.argv)
if len(debug_path):
debug_f.log('Writing logs to %r', debug_path)
interp = environ.get('OSH_HIJACK_SHEBANG', '')
search_path = state.SearchPath(mem)
ext_prog = process.ExternalProgram(interp, fd_state, errfmt, debug_f)
splitter = split.SplitContext(mem)
# 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 = environ.get('OSH_CRASH_DUMP_DIR', '')
cmd_deps.dumper = dev.CrashDumper(crash_dump_dir)
if flag.xtrace_to_debug_file:
trace_f = debug_f
else:
trace_f = util.DebugFile(mylib.Stderr())
#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()
#
# Initialize builtins that don't depend on evaluators
#
builtins = {} # type: Dict[int, vm._Builtin]
AddPure(builtins, mem, procs, mutable_opts, aliases, search_path, errfmt)
AddIO(builtins, mem, dir_stack, exec_opts, splitter, parse_ctx, errfmt)
builtins[builtin_i.help] = help_builtin
#
# Initialize Evaluators
#
arith_ev = sh_expr_eval.ArithEvaluator(mem, exec_opts, parse_ctx, errfmt)
bool_ev = sh_expr_eval.BoolEvaluator(mem, exec_opts, parse_ctx, errfmt)
expr_ev = None # type: expr_eval.OilEvaluator
word_ev = word_eval.NormalWordEvaluator(mem, exec_opts, splitter, errfmt)
assign_b = InitAssignmentBuiltins(mem, procs, errfmt)
cmd_ev = cmd_eval.CommandEvaluator(mem, exec_opts, errfmt, procs, assign_b,
arena, cmd_deps)
shell_ex = executor.ShellExecutor(mem, exec_opts, mutable_opts, procs,
builtins, search_path, ext_prog, waiter,
job_state, fd_state, errfmt)
#shell_ex = NullExecutor(exec_opts, mutable_opts, procs, builtins)
# PromptEvaluator rendering is needed in non-interactive shells for @P.
prompt_ev = prompt.Evaluator(lang, parse_ctx, mem)
tracer = dev.Tracer(parse_ctx, exec_opts, mutable_opts, mem, word_ev,
trace_f)
# Wire up circular dependencies.
vm.InitCircularDeps(arith_ev, bool_ev, expr_ev, word_ev, cmd_ev, shell_ex,
prompt_ev, tracer)
#
# Initialize builtins that depend on evaluators
#
# note: 'printf -v a[i]' and 'unset a[i]' require same deps
builtins[builtin_i.printf] = builtin_printf.Printf(mem, exec_opts,
parse_ctx, arith_ev,
errfmt)
builtins[builtin_i.unset] = builtin_assign.Unset(mem, exec_opts, procs,
parse_ctx, arith_ev,
errfmt)
builtins[builtin_i.eval] = builtin_meta.Eval(parse_ctx, exec_opts, cmd_ev)
#source_builtin = builtin_meta.Source(parse_ctx, search_path, cmd_ev,
#fd_state, errfmt)
#builtins[builtin_i.source] = source_builtin
#builtins[builtin_i.dot] = source_builtin
AddMeta(builtins, shell_ex, mutable_opts, mem, procs, aliases, search_path,
errfmt)
AddBlock(builtins, mem, mutable_opts, dir_stack, cmd_ev, errfmt)
#sig_state = process.SignalState()
#sig_state.InitShell()
#builtins[builtin_i.trap] = builtin_process.Trap(sig_state, cmd_deps.traps,
# cmd_deps.trap_nodes,
# parse_ctx, errfmt)
if flag.c is not None:
arena.PushSource(source.CFlag())
line_reader = reader.StringLineReader(flag.c,
arena) # type: reader._Reader
if flag.i: # -c and -i can be combined
mutable_opts.set_interactive()
elif flag.i: # force interactive
raise NotImplementedError()
else:
if script_name is None:
stdin = mylib.Stdin()
arena.PushSource(source.Stdin(''))
line_reader = reader.FileLineReader(stdin, arena)
else:
arena.PushSource(source.MainFile(script_name))
try:
f = fd_state.Open(script_name)
#f = mylib.open(script_name)
except OSError as e:
stderr_line("osh: Couldn't open %r: %s", script_name,
pyutil.strerror(e))
return 1
line_reader = reader.FileLineReader(f, arena)
# TODO: assert arena.NumSourcePaths() == 1
# TODO: .rc file needs its own arena.
c_parser = parse_ctx.MakeOshParser(line_reader)
if exec_opts.interactive():
raise NotImplementedError()
if exec_opts.noexec():
status = 0
try:
node = main_loop.ParseWholeFile(c_parser)
except error.Parse as e:
ui.PrettyPrintError(e, arena)
status = 2
if status == 0:
if flag.parser_mem_dump is not None: # only valid in -n mode
input_path = '/proc/%d/status' % posix.getpid()
pyutil.CopyFile(input_path, flag.parser_mem_dump)
ui.PrintAst(node, flag)
else:
if flag.parser_mem_dump is not None:
e_usage('--parser-mem-dump can only be used with -n')
try:
status = main_loop.Batch(cmd_ev,
c_parser,
arena,
cmd_flags=cmd_eval.IsMainProgram)
except util.UserExit as e:
status = e.status
box = [status]
cmd_ev.MaybeRunExitTrap(box)
status = box[0]
# NOTE: 'exit 1' is ControlFlow and gets here, but subshell/commandsub
# don't because they call sys.exit().
if flag.runtime_mem_dump is not None:
input_path = '/proc/%d/status' % posix.getpid()
pyutil.CopyFile(input_path, flag.runtime_mem_dump)
# NOTE: We haven't closed the file opened with fd_state.Open
return status
def main(argv):
# type: (List[str]) -> int
arena = alloc.Arena()
dollar0 = argv[0]
debug_stack = [] # type: List[state.DebugFrame]
mem = state.Mem(dollar0, argv, arena, debug_stack)
opt_hook = state.OptHook()
parse_opts, exec_opts, mutable_opts = state.MakeOpts(mem, opt_hook)
# Dummy value; not respecting aliases!
aliases = {} # type: Dict[str, str]
# parse `` and a[x+1]=bar differently
oil_grammar = None # type: Grammar
if mylib.PYTHON:
loader = pyutil.GetResourceLoader()
oil_grammar = meta.LoadOilGrammar(loader)
parse_ctx = parse_lib.ParseContext(arena, parse_opts, aliases, oil_grammar)
argv = argv[1:] # remove binary name
i, flag_a, flag_c, flag_n = Parse(argv)
argv = argv[i:] # truncate
if flag_c:
# This path is easier to run through GDB
line_reader = reader.StringLineReader(flag_c, arena)
src = source.CFlag() # type: source_t
elif len(argv) == 0:
line_reader = reader.FileLineReader(mylib.Stdin(), arena)
src = source.Stdin('')
elif len(argv) == 1:
path = argv[0]
f = mylib.open(path)
line_reader = reader.FileLineReader(f, arena)
src = source.MainFile(path)
else:
raise AssertionError(argv)
arena.PushSource(src)
c_parser = parse_ctx.MakeOshParser(line_reader)
try:
#node = main_loop.ParseWholeFile(c_parser)
node = ParseWholeFile(c_parser)
except error.Parse as e:
ui.PrettyPrintError(e, arena)
return 2
assert node is not None
# C++ doesn't have the abbreviations yet (though there are some differences
# like omitting spids)
#tree = node.AbbreviatedTree()
if flag_n:
if flag_a:
tree = node.PrettyTree()
ast_f = fmt.DetectConsoleOutput(mylib.Stdout())
fmt.PrintTree(tree, ast_f)
ast_f.write('\n')
return 0
# New osh_eval.py instantiations
errfmt = ui.ErrorFormatter(arena)
splitter = split.SplitContext(mem)
arith_ev = sh_expr_eval.ArithEvaluator(mem, exec_opts, errfmt)
word_ev = word_eval.NormalWordEvaluator(mem, exec_opts, splitter, errfmt)
arith_ev.word_ev = word_ev
word_ev.arith_ev = arith_ev
test_ev = TestEvaluator(arith_ev, word_ev)
test_ev.Eval(node)
return 0