OILS / osh / cmd_eval.py View on Github | oilshell.org

2145 lines, 1328 significant
1#!/usr/bin/env python2
2# Copyright 2016 Andy Chu. All rights reserved.
3# Licensed under the Apache License, Version 2.0 (the "License");
4# you may not use this file except in compliance with the License.
5# You may obtain a copy of the License at
6#
7# http://www.apache.org/licenses/LICENSE-2.0
8"""
9cmd_eval.py -- Interpreter for the command language.
10
11Problems:
12$ < Makefile cat | < NOTES.txt head
13
14This just does head? Last one wins.
15"""
16from __future__ import print_function
17
18import sys
19
20from _devbuild.gen.id_kind_asdl import Id
21from _devbuild.gen.option_asdl import option_i
22from _devbuild.gen.syntax_asdl import (
23 IntParamBox,
24 loc,
25 loc_t,
26 loc_e,
27 Token,
28 CompoundWord,
29 command,
30 command_e,
31 command_t,
32 command_str,
33 condition,
34 condition_e,
35 condition_t,
36 case_arg,
37 case_arg_e,
38 case_arg_t,
39 BraceGroup,
40 Proc,
41 Func,
42 assign_op_e,
43 expr_t,
44 proc_sig,
45 proc_sig_e,
46 redir_param,
47 redir_param_e,
48 for_iter,
49 for_iter_e,
50 pat,
51 pat_e,
52 word,
53 Eggex,
54)
55from _devbuild.gen.runtime_asdl import (
56 cmd_value,
57 cmd_value_e,
58 RedirValue,
59 redirect_arg,
60 flow_e,
61 scope_e,
62 CommandStatus,
63 StatusArray,
64)
65from _devbuild.gen.types_asdl import redir_arg_type_e
66from _devbuild.gen.value_asdl import (value, value_e, value_t, y_lvalue,
67 y_lvalue_e, y_lvalue_t, LeftName)
68
69from core import dev
70from core import error
71from core import executor
72from core.error import e_die, e_die_status
73from core import num
74from core import pyos # Time(). TODO: rename
75from core import pyutil
76from core import state
77from core import ui
78from core import util
79from core import vm
80from frontend import consts
81from frontend import lexer
82from frontend import location
83from osh import braces
84from osh import sh_expr_eval
85from osh import word_eval
86from mycpp import mops
87from mycpp import mylib
88from mycpp.mylib import log, probe, switch, tagswitch
89from ysh import expr_eval
90from ysh import func_proc
91from ysh import val_ops
92
93import posix_ as posix
94import libc # for fnmatch
95# Import this name directly because the C++ translation uses macros literally.
96from libc import FNM_CASEFOLD
97
98from typing import List, Dict, Tuple, Optional, Any, cast, TYPE_CHECKING
99
100if TYPE_CHECKING:
101 from _devbuild.gen.option_asdl import builtin_t
102 from _devbuild.gen.runtime_asdl import cmd_value_t
103 from _devbuild.gen.syntax_asdl import Redir, EnvPair
104 from core.alloc import Arena
105 from core import optview
106 from core.vm import _Executor, _AssignBuiltin
107 from builtin import trap_osh
108
109# flags for main_loop.Batch, ExecuteAndCatch. TODO: Should probably in
110# ExecuteAndCatch, along with SetValue() flags.
111IsMainProgram = 1 << 0 # the main shell program, not eval/source/subshell
112RaiseControlFlow = 1 << 1 # eval/source builtins
113Optimize = 1 << 2
114NoDebugTrap = 1 << 3
115NoErrTrap = 1 << 4
116
117
118def MakeBuiltinArgv(argv1):
119 # type: (List[str]) -> cmd_value.Argv
120 argv = [''] # dummy for argv[0]
121 argv.extend(argv1)
122 missing = None # type: CompoundWord
123 return cmd_value.Argv(argv, [missing] * len(argv), None, None, None, None)
124
125
126class Deps(object):
127
128 def __init__(self):
129 # type: () -> None
130 self.mutable_opts = None # type: state.MutableOpts
131 self.dumper = None # type: dev.CrashDumper
132 self.debug_f = None # type: util._DebugFile
133
134
135def _HasManyStatuses(node):
136 # type: (command_t) -> bool
137 """Code patterns that are bad for POSIX errexit. For YSH strict_errexit.
138
139 Note: strict_errexit also uses
140 shopt --unset _allow_command_sub _allow_process_sub
141 """
142 UP_node = node
143 with tagswitch(node) as case:
144 # Atoms.
145 # TODO: Do we need YSH atoms here?
146 if case(command_e.Simple, command_e.DBracket, command_e.DParen):
147 return False
148
149 elif case(command_e.Redirect):
150 node = cast(command.Redirect, UP_node)
151 return _HasManyStatuses(node.child)
152
153 elif case(command_e.Sentence):
154 # Sentence check is for if false; versus if false
155 node = cast(command.Sentence, UP_node)
156 return _HasManyStatuses(node.child)
157
158 elif case(command_e.Pipeline):
159 node = cast(command.Pipeline, UP_node)
160 if len(node.children) == 1:
161 # '! false' is a pipeline that we want to ALLOW
162 # '! ( echo subshell )' is DISALLWOED
163 return _HasManyStatuses(node.children[0])
164 else:
165 # Multiple parts like 'ls | wc' is disallowed
166 return True
167
168 # - ShAssignment could be allowed, though its exit code will always be
169 # 0 without command subs
170 # - Naively, (non-singleton) pipelines could be allowed because pipefail.
171 # BUT could be a proc executed inside a child process, which causes a
172 # problem: the strict_errexit check has to occur at runtime and there's
173 # no way to signal it ot the parent.
174
175 return True
176
177
178def PlusEquals(old_val, val):
179 # type: (value_t, value_t) -> value_t
180 """Implement s+=val, typeset s+=val, etc."""
181
182 UP_old_val = old_val
183 UP_val = val
184
185 tag = val.tag()
186
187 with tagswitch(old_val) as case:
188 if case(value_e.Undef):
189 pass # val is RHS
190
191 elif case(value_e.Str):
192 if tag == value_e.Str:
193 old_val = cast(value.Str, UP_old_val)
194 str_to_append = cast(value.Str, UP_val)
195 val = value.Str(old_val.s + str_to_append.s)
196
197 elif tag == value_e.BashArray:
198 e_die("Can't append array to string")
199
200 else:
201 raise AssertionError() # parsing should prevent this
202
203 elif case(value_e.BashArray):
204 if tag == value_e.Str:
205 e_die("Can't append string to array")
206
207 elif tag == value_e.BashArray:
208 old_val = cast(value.BashArray, UP_old_val)
209 to_append = cast(value.BashArray, UP_val)
210
211 # TODO: MUTATE the existing value for efficiency?
212 strs = [] # type: List[str]
213 strs.extend(old_val.strs)
214 strs.extend(to_append.strs)
215 val = value.BashArray(strs)
216
217 else:
218 raise AssertionError() # parsing should prevent this
219
220 elif case(value_e.BashAssoc):
221 # TODO: Could try to match bash, it will append to ${A[0]}
222 pass
223
224 else:
225 e_die("Can't append to value of type %s" % ui.ValType(old_val))
226
227 return val
228
229
230class ctx_LoopLevel(object):
231 """For checking for invalid control flow."""
232
233 def __init__(self, cmd_ev):
234 # type: (CommandEvaluator) -> None
235 cmd_ev.loop_level += 1
236 self.cmd_ev = cmd_ev
237
238 def __enter__(self):
239 # type: () -> None
240 pass
241
242 def __exit__(self, type, value, traceback):
243 # type: (Any, Any, Any) -> None
244 self.cmd_ev.loop_level -= 1
245
246
247class CommandEvaluator(object):
248 """Executes the program by tree-walking.
249
250 It also does some double-dispatch by passing itself into Eval() for
251 Compound/WordPart.
252 """
253
254 def __init__(
255 self,
256 mem, # type: state.Mem
257 exec_opts, # type: optview.Exec
258 errfmt, # type: ui.ErrorFormatter
259 procs, # type: Dict[str, value.Proc]
260 assign_builtins, # type: Dict[builtin_t, _AssignBuiltin]
261 arena, # type: Arena
262 cmd_deps, # type: Deps
263 trap_state, # type: trap_osh.TrapState
264 signal_safe, # type: pyos.SignalSafe
265 ):
266 # type: (...) -> None
267 """
268 Args:
269 mem: Mem instance for storing variables
270 procs: dict of SHELL functions or 'procs'
271 builtins: dict of builtin callables
272 TODO: This should only be for assignment builtins?
273 cmd_deps: A bundle of stateless code
274 """
275 self.shell_ex = None # type: _Executor
276 self.arith_ev = None # type: sh_expr_eval.ArithEvaluator
277 self.bool_ev = None # type: sh_expr_eval.BoolEvaluator
278 self.expr_ev = None # type: expr_eval.ExprEvaluator
279 self.word_ev = None # type: word_eval.AbstractWordEvaluator
280 self.tracer = None # type: dev.Tracer
281
282 self.mem = mem
283 # This is for shopt and set -o. They are initialized by flags.
284 self.exec_opts = exec_opts
285 self.errfmt = errfmt
286 self.procs = procs
287 self.assign_builtins = assign_builtins
288 self.arena = arena
289
290 self.mutable_opts = cmd_deps.mutable_opts
291 self.dumper = cmd_deps.dumper
292 self.debug_f = cmd_deps.debug_f # Used by ShellFuncAction too
293
294 self.trap_state = trap_state
295 self.signal_safe = signal_safe
296
297 self.loop_level = 0 # for detecting bad top-level break/continue
298 self.check_command_sub_status = False # a hack. Modified by ShellExecutor
299
300 self.status_array_pool = [] # type: List[StatusArray]
301
302 def CheckCircularDeps(self):
303 # type: () -> None
304 assert self.arith_ev is not None
305 assert self.bool_ev is not None
306 # Disabled for push OSH
307 #assert self.expr_ev is not None
308 assert self.word_ev is not None
309
310 def _RunAssignBuiltin(self, cmd_val):
311 # type: (cmd_value.Assign) -> int
312 """Run an assignment builtin.
313
314 Except blocks copied from RunBuiltin.
315 """
316 builtin_func = self.assign_builtins.get(cmd_val.builtin_id)
317 if builtin_func is None:
318 # This only happens with alternative Oils interpreters.
319 e_die("Assignment builtin %r not configured" % cmd_val.argv[0],
320 cmd_val.arg_locs[0])
321
322 io_errors = [] # type: List[error.IOError_OSError]
323 with vm.ctx_FlushStdout(io_errors):
324 with ui.ctx_Location(self.errfmt, cmd_val.arg_locs[0]):
325 try:
326 status = builtin_func.Run(cmd_val)
327 except (IOError, OSError) as e:
328 # e.g. declare -p > /dev/full
329 self.errfmt.PrintMessage(
330 '%s builtin I/O error: %s' %
331 (cmd_val.argv[0], pyutil.strerror(e)),
332 cmd_val.arg_locs[0])
333 return 1
334 except error.Usage as e: # Copied from RunBuiltin
335 arg0 = cmd_val.argv[0]
336 self.errfmt.PrefixPrint(e.msg, '%r ' % arg0, e.location)
337 return 2 # consistent error code for usage error
338
339 if len(io_errors): # e.g. declare -p > /dev/full
340 self.errfmt.PrintMessage(
341 '%s builtin I/O: %s' %
342 (cmd_val.argv[0], pyutil.strerror(io_errors[0])),
343 cmd_val.arg_locs[0])
344 return 1
345
346 return status
347
348 def _CheckStatus(self, status, cmd_st, node, default_loc):
349 # type: (int, CommandStatus, command_t, loc_t) -> None
350 """Raises error.ErrExit, maybe with location info attached."""
351
352 assert status >= 0, status
353
354 if status == 0:
355 return # Nothing to do
356
357 self._MaybeRunErrTrap()
358
359 if self.exec_opts.errexit():
360 # NOTE: Sometimes we print 2 errors
361 # - 'type -z' has a UsageError with location, then errexit
362 # - '> /nonexistent' has an I/O error, then errexit
363 # - Pipelines and subshells are compound. Commands within them fail.
364 # - however ( exit 33 ) only prints one message.
365 #
366 # But we will want something like 'false' to have location info.
367
368 UP_node = node
369 with tagswitch(node) as case:
370 if case(command_e.ShAssignment):
371 node = cast(command.ShAssignment, UP_node)
372 cmd_st.show_code = True # leaf
373 # Note: we show errors from assignments a=$(false) rarely: when
374 # errexit, inherit_errexit, verbose_errexit are on, but
375 # command_sub_errexit is off!
376
377 # Note: a subshell often doesn't fail on its own.
378 elif case(command_e.Subshell):
379 node = cast(command.Subshell, UP_node)
380 cmd_st.show_code = True # not sure about this, e.g. ( exit 42 )
381
382 elif case(command_e.Pipeline):
383 node = cast(command.Pipeline, UP_node)
384 cmd_st.show_code = True # not sure about this
385 # TODO: We should show which element of the pipeline failed!
386
387 desc = command_str(node.tag())
388
389 # Override location if explicitly passed.
390 # Note: this produces better results for process sub
391 # echo <(sort x)
392 # and different results for some pipelines:
393 # { ls; false; } | wc -l; echo hi # Point to | or first { ?
394 if default_loc.tag() != loc_e.Missing:
395 blame_loc = default_loc # type: loc_t
396 else:
397 blame_loc = location.TokenForCommand(node)
398
399 msg = '%s failed with status %d' % (desc, status)
400 raise error.ErrExit(status,
401 msg,
402 blame_loc,
403 show_code=cmd_st.show_code)
404
405 def _EvalRedirect(self, r):
406 # type: (Redir) -> RedirValue
407
408 result = RedirValue(r.op.id, r.op, r.loc, None)
409
410 arg = r.arg
411 UP_arg = arg
412 with tagswitch(arg) as case:
413 if case(redir_param_e.Word):
414 arg_word = cast(CompoundWord, UP_arg)
415
416 # Note: needed for redirect like 'echo foo > x$LINENO'
417 self.mem.SetTokenForLine(r.op)
418
419 # Could be computed at parse time?
420 redir_type = consts.RedirArgType(r.op.id)
421
422 if redir_type == redir_arg_type_e.Path:
423 # Redirects with path arguments are evaluated in a special
424 # way. bash and zsh allow globbing a path, but
425 # dash/ash/mksh don't.
426 #
427 # If there are multiple files, zsh opens BOTH, but bash
428 # makes the command fail with status 1. We mostly follow
429 # bash behavior.
430
431 # These don't match bash/zsh behavior
432 # val = self.word_ev.EvalWordToString(arg_word)
433 # val, has_extglob = self.word_ev.EvalWordToPattern(arg_word)
434 # Short-circuit with word_.StaticEval() also doesn't work
435 # with globs
436
437 # mycpp needs this explicit declaration
438 b = braces.BraceDetect(
439 arg_word) # type: Optional[word.BracedTree]
440 if b is not None:
441 raise error.RedirectEval(
442 'Brace expansion not allowed (try adding quotes)',
443 arg_word)
444
445 # Needed for globbing behavior
446 files = self.word_ev.EvalWordSequence([arg_word])
447
448 n = len(files)
449 if n == 0:
450 # happens in OSH on empty elision
451 # in YSH because simple_word_eval globs to zero
452 raise error.RedirectEval(
453 "Can't redirect to zero files", arg_word)
454 if n > 1:
455 raise error.RedirectEval(
456 "Can't redirect to more than one file", arg_word)
457
458 result.arg = redirect_arg.Path(files[0])
459 return result
460
461 elif redir_type == redir_arg_type_e.Desc: # e.g. 1>&2, 1>&-, 1>&2-
462 val = self.word_ev.EvalWordToString(arg_word)
463 t = val.s
464 if len(t) == 0:
465 raise error.RedirectEval(
466 "Redirect descriptor can't be empty", arg_word)
467 return None
468
469 try:
470 if t == '-':
471 result.arg = redirect_arg.CloseFd
472 elif t[-1] == '-':
473 target_fd = int(t[:-1])
474 result.arg = redirect_arg.MoveFd(target_fd)
475 else:
476 result.arg = redirect_arg.CopyFd(int(t))
477 except ValueError:
478 raise error.RedirectEval(
479 'Invalid descriptor %r. Expected D, -, or D- where D is an '
480 'integer' % t, arg_word)
481 return None
482
483 return result
484
485 elif redir_type == redir_arg_type_e.Here: # here word
486 val = self.word_ev.EvalWordToString(arg_word)
487 assert val.tag() == value_e.Str, val
488 # NOTE: bash and mksh both add \n
489 result.arg = redirect_arg.HereDoc(val.s + '\n')
490 return result
491
492 else:
493 raise AssertionError('Unknown redirect op')
494
495 elif case(redir_param_e.HereDoc):
496 arg = cast(redir_param.HereDoc, UP_arg)
497 w = CompoundWord(
498 arg.stdin_parts) # HACK: Wrap it in a word to eval
499 val = self.word_ev.EvalWordToString(w)
500 assert val.tag() == value_e.Str, val
501 result.arg = redirect_arg.HereDoc(val.s)
502 return result
503
504 else:
505 raise AssertionError('Unknown redirect type')
506
507 raise AssertionError('for -Wreturn-type in C++')
508
509 def _RunSimpleCommand(self, cmd_val, cmd_st, run_flags):
510 # type: (cmd_value_t, CommandStatus, int) -> int
511 """Private interface to run a simple command (including assignment)."""
512 UP_cmd_val = cmd_val
513 with tagswitch(UP_cmd_val) as case:
514 if case(cmd_value_e.Argv):
515 cmd_val = cast(cmd_value.Argv, UP_cmd_val)
516 self.tracer.OnSimpleCommand(cmd_val.argv)
517 return self.shell_ex.RunSimpleCommand(cmd_val, cmd_st,
518 run_flags)
519
520 elif case(cmd_value_e.Assign):
521 cmd_val = cast(cmd_value.Assign, UP_cmd_val)
522 self.tracer.OnAssignBuiltin(cmd_val)
523 return self._RunAssignBuiltin(cmd_val)
524
525 else:
526 raise AssertionError()
527
528 def _EvalTempEnv(self, more_env, flags):
529 # type: (List[EnvPair], int) -> None
530 """For FOO=1 cmd."""
531 for e_pair in more_env:
532 val = self.word_ev.EvalRhsWord(e_pair.val)
533 # Set each var so the next one can reference it. Example:
534 # FOO=1 BAR=$FOO ls /
535 self.mem.SetNamed(location.LName(e_pair.name),
536 val,
537 scope_e.LocalOnly,
538 flags=flags)
539
540 def _StrictErrExit(self, node):
541 # type: (command_t) -> None
542 if not (self.exec_opts.errexit() and self.exec_opts.strict_errexit()):
543 return
544
545 if _HasManyStatuses(node):
546 node_str = ui.CommandType(node)
547 e_die(
548 "strict_errexit only allows simple commands in conditionals (got %s). "
549 % node_str, loc.Command(node))
550
551 def _StrictErrExitList(self, node_list):
552 # type: (List[command_t]) -> None
553 """Not allowed, too confusing:
554
555 if grep foo eggs.txt; grep bar eggs.txt; then echo hi fi
556 """
557 if not (self.exec_opts.errexit() and self.exec_opts.strict_errexit()):
558 return
559
560 if len(node_list) > 1:
561 e_die(
562 "strict_errexit only allows a single command. Hint: use 'try'.",
563 loc.Command(node_list[0]))
564
565 assert len(node_list) > 0
566 node = node_list[0]
567 if _HasManyStatuses(node):
568 # TODO: consolidate error message with above
569 node_str = ui.CommandType(node)
570 e_die(
571 "strict_errexit only allows simple commands in conditionals (got %s). "
572 % node_str, loc.Command(node))
573
574 def _EvalCondition(self, cond, blame_tok):
575 # type: (condition_t, Token) -> bool
576 """
577 Args:
578 spid: for OSH conditions, where errexit was disabled -- e.g. if
579 for YSH conditions, it would be nice to blame the ( instead
580 """
581 b = False
582 UP_cond = cond
583 with tagswitch(cond) as case:
584 if case(condition_e.Shell):
585 cond = cast(condition.Shell, UP_cond)
586 self._StrictErrExitList(cond.commands)
587 with state.ctx_ErrExit(self.mutable_opts, False, blame_tok):
588 cond_status = self._ExecuteList(cond.commands)
589
590 b = cond_status == 0
591
592 elif case(condition_e.YshExpr):
593 cond = cast(condition.YshExpr, UP_cond)
594 obj = self.expr_ev.EvalExpr(cond.e, blame_tok)
595 b = val_ops.ToBool(obj)
596
597 return b
598
599 def _EvalCaseArg(self, arg, blame):
600 # type: (case_arg_t, loc_t) -> value_t
601 """Evaluate a `case_arg` into a `value_t` which can be matched on in a case
602 command.
603 """
604 UP_arg = arg
605 with tagswitch(arg) as case:
606 if case(case_arg_e.Word):
607 arg = cast(case_arg.Word, UP_arg)
608 return self.word_ev.EvalWordToString(arg.w)
609
610 elif case(case_arg_e.YshExpr):
611 arg = cast(case_arg.YshExpr, UP_arg)
612 return self.expr_ev.EvalExpr(arg.e, blame)
613
614 else:
615 raise NotImplementedError()
616
617 def _DoVarDecl(self, node):
618 # type: (command.VarDecl) -> int
619 # x = 'foo' in Hay blocks
620 if node.keyword is None:
621 # Note: there's only one LHS
622 lhs0 = node.lhs[0]
623 lval = LeftName(lhs0.name, lhs0.left)
624 assert node.rhs is not None, node
625 val = self.expr_ev.EvalExpr(node.rhs, loc.Missing)
626
627 self.mem.SetNamed(lval,
628 val,
629 scope_e.LocalOnly,
630 flags=state.SetReadOnly)
631
632 else: # var or const
633 flags = (state.SetReadOnly
634 if node.keyword.id == Id.KW_Const else 0)
635
636 # var x, y does null initialization
637 if node.rhs is None:
638 for i, lhs_val in enumerate(node.lhs):
639 lval = LeftName(lhs_val.name, lhs_val.left)
640 self.mem.SetNamed(lval,
641 value.Null,
642 scope_e.LocalOnly,
643 flags=flags)
644 return 0
645
646 right_val = self.expr_ev.EvalExpr(node.rhs, loc.Missing)
647 lvals = None # type: List[LeftName]
648 rhs_vals = None # type: List[value_t]
649
650 num_lhs = len(node.lhs)
651 if num_lhs == 1:
652 lhs0 = node.lhs[0]
653 lvals = [LeftName(lhs0.name, lhs0.left)]
654 rhs_vals = [right_val]
655 else:
656 items = val_ops.ToList(
657 right_val, 'Destructuring assignment expected List',
658 node.keyword)
659
660 num_rhs = len(items)
661 if num_lhs != num_rhs:
662 raise error.Expr(
663 'Got %d places on the left, but %d values on right' %
664 (num_lhs, num_rhs), node.keyword)
665
666 lvals = []
667 rhs_vals = []
668 for i, lhs_val in enumerate(node.lhs):
669 lval = LeftName(lhs_val.name, lhs_val.left)
670 lvals.append(lval)
671 rhs_vals.append(items[i])
672
673 for i, lval in enumerate(lvals):
674 rval = rhs_vals[i]
675 self.mem.SetNamed(lval, rval, scope_e.LocalOnly, flags=flags)
676
677 return 0
678
679 def _DoMutation(self, node):
680 # type: (command.Mutation) -> None
681
682 with switch(node.keyword.id) as case2:
683 if case2(Id.KW_SetVar):
684 which_scopes = scope_e.LocalOnly
685 elif case2(Id.KW_SetGlobal):
686 which_scopes = scope_e.GlobalOnly
687 else:
688 raise AssertionError(node.keyword.id)
689
690 if node.op.id == Id.Arith_Equal:
691 right_val = self.expr_ev.EvalExpr(node.rhs, loc.Missing)
692
693 lvals = None # type: List[y_lvalue_t]
694 rhs_vals = None # type: List[value_t]
695
696 num_lhs = len(node.lhs)
697 if num_lhs == 1:
698 lvals = [self.expr_ev.EvalLhsExpr(node.lhs[0], which_scopes)]
699 rhs_vals = [right_val]
700 else:
701 items = val_ops.ToList(
702 right_val, 'Destructuring assignment expected List',
703 node.keyword)
704
705 num_rhs = len(items)
706 if num_lhs != num_rhs:
707 raise error.Expr(
708 'Got %d places on the left, but %d values on the right'
709 % (num_lhs, num_rhs), node.keyword)
710
711 lvals = []
712 rhs_vals = []
713 for i, lhs_val in enumerate(node.lhs):
714 lvals.append(
715 self.expr_ev.EvalLhsExpr(lhs_val, which_scopes))
716 rhs_vals.append(items[i])
717
718 for i, lval in enumerate(lvals):
719 rval = rhs_vals[i]
720
721 # setvar mylist[0] = 42
722 # setvar mydict['key'] = 42
723 UP_lval = lval
724
725 if lval.tag() == y_lvalue_e.Local:
726 lval = cast(LeftName, UP_lval)
727
728 self.mem.SetNamed(lval, rval, which_scopes)
729
730 elif lval.tag() == y_lvalue_e.Container:
731 lval = cast(y_lvalue.Container, UP_lval)
732
733 obj = lval.obj
734 UP_obj = obj
735 with tagswitch(obj) as case:
736 if case(value_e.List):
737 obj = cast(value.List, UP_obj)
738 index = val_ops.ToInt(lval.index,
739 'List index should be Int',
740 loc.Missing)
741 obj.items[index] = rval
742
743 elif case(value_e.Dict):
744 obj = cast(value.Dict, UP_obj)
745 key = val_ops.ToStr(lval.index,
746 'Dict index should be Str',
747 loc.Missing)
748 obj.d[key] = rval
749
750 else:
751 raise error.TypeErr(
752 obj, "obj[index] expected List or Dict",
753 loc.Missing)
754
755 else:
756 raise AssertionError()
757
758 else:
759 # Checked in the parser
760 assert len(node.lhs) == 1
761
762 aug_lval = self.expr_ev.EvalLhsExpr(node.lhs[0], which_scopes)
763 val = self.expr_ev.EvalExpr(node.rhs, loc.Missing)
764
765 self.expr_ev.EvalAugmented(aug_lval, val, node.op, which_scopes)
766
767 def _DoSimple(self, node, cmd_st):
768 # type: (command.Simple, CommandStatus) -> int
769 probe('cmd_eval', '_DoSimple_enter')
770
771 # PROBLEM: We want to log argv in 'xtrace' mode, but we may have already
772 # redirected here, which screws up logging. For example, 'echo hi
773 # >/dev/null 2>&1'. We want to evaluate argv and log it BEFORE applying
774 # redirects.
775
776 # Another problem:
777 # - tracing can be called concurrently from multiple processes, leading
778 # to overlap. Maybe have a mode that creates a file per process.
779 # xtrace-proc
780 # - line numbers for every command would be very nice. But then you have
781 # to print the filename too.
782
783 words = braces.BraceExpandWords(node.words)
784
785 # Note: Individual WORDS can fail
786 # - $() and <() can have failures. This can happen in DBracket,
787 # DParen, etc. too
788 # - Tracing: this can start processes for proc sub and here docs!
789 cmd_val = self.word_ev.EvalWordSequence2(words, allow_assign=True)
790
791 UP_cmd_val = cmd_val
792 if UP_cmd_val.tag() == cmd_value_e.Argv:
793 cmd_val = cast(cmd_value.Argv, UP_cmd_val)
794
795 if len(cmd_val.argv): # it can be empty in rare cases
796 self.mem.SetLastArgument(cmd_val.argv[-1])
797 else:
798 self.mem.SetLastArgument('')
799
800 if node.typed_args or node.block: # guard to avoid allocs
801 func_proc.EvalTypedArgsToProc(self.expr_ev, self.mutable_opts,
802 node, cmd_val)
803 else:
804 if node.block:
805 e_die("ShAssignment builtins don't accept blocks",
806 node.block.brace_group.left)
807 cmd_val = cast(cmd_value.Assign, UP_cmd_val)
808
809 # Could reset $_ after assignment, but then we'd have to do it for
810 # all YSH constructs too. It's easier to let it persist. Other
811 # shells aren't consistent.
812 # self.mem.SetLastArgument('')
813
814 run_flags = executor.DO_FORK if node.do_fork else 0
815 # NOTE: RunSimpleCommand never returns when do_fork=False!
816 if len(node.more_env): # I think this guard is necessary?
817 is_other_special = False # TODO: There are other special builtins too!
818 if cmd_val.tag() == cmd_value_e.Assign or is_other_special:
819 # Special builtins have their temp env persisted.
820 self._EvalTempEnv(node.more_env, 0)
821 status = self._RunSimpleCommand(cmd_val, cmd_st, run_flags)
822 else:
823 with state.ctx_Temp(self.mem):
824 self._EvalTempEnv(node.more_env, state.SetExport)
825 status = self._RunSimpleCommand(cmd_val, cmd_st, run_flags)
826 else:
827 status = self._RunSimpleCommand(cmd_val, cmd_st, run_flags)
828
829 probe('cmd_eval', '_DoSimple_exit', status)
830 return status
831
832 def _DoExpandedAlias(self, node):
833 # type: (command.ExpandedAlias) -> int
834 # Expanded aliases need redirects and env bindings from the calling
835 # context, as well as redirects in the expansion!
836
837 # TODO: SetTokenForLine to OUTSIDE? Don't bother with stuff inside
838 # expansion, since aliases are discouraged.
839
840 if len(node.more_env):
841 with state.ctx_Temp(self.mem):
842 self._EvalTempEnv(node.more_env, state.SetExport)
843 return self._Execute(node.child)
844 else:
845 return self._Execute(node.child)
846
847 def _DoPipeline(self, node, cmd_st):
848 # type: (command.Pipeline, CommandStatus) -> int
849 cmd_st.check_errexit = True
850 for op in node.ops:
851 if op.id != Id.Op_Pipe:
852 e_die("|& isn't supported", op)
853
854 # Remove $_ before pipeline. This matches bash, and is important in
855 # pipelines than assignments because pipelines are non-deterministic.
856 self.mem.SetLastArgument('')
857
858 # Set status to INVALID value, because we MIGHT set cmd_st.pipe_status,
859 # which _Execute() boils down into a status for us.
860 status = -1
861
862 if node.negated is not None:
863 self._StrictErrExit(node)
864 with state.ctx_ErrExit(self.mutable_opts, False, node.negated):
865 # '! grep' is parsed as a pipeline, according to the grammar, but
866 # there's no pipe() call.
867 if len(node.children) == 1:
868 tmp_status = self._Execute(node.children[0])
869 status = 1 if tmp_status == 0 else 0
870 else:
871 self.shell_ex.RunPipeline(node, cmd_st)
872 cmd_st.pipe_negated = True
873
874 # errexit is disabled for !.
875 cmd_st.check_errexit = False
876 else:
877 self.shell_ex.RunPipeline(node, cmd_st)
878
879 return status
880
881 def _DoShAssignment(self, node, cmd_st):
882 # type: (command.ShAssignment, CommandStatus) -> int
883 assert len(node.pairs) >= 1, node
884
885 # x=y is 'neutered' inside 'proc'
886 which_scopes = self.mem.ScopesForWriting()
887
888 for pair in node.pairs:
889 if pair.op == assign_op_e.PlusEqual:
890 assert pair.rhs, pair.rhs # I don't think a+= is valid?
891 rhs = self.word_ev.EvalRhsWord(pair.rhs)
892
893 lval = self.arith_ev.EvalShellLhs(pair.lhs, which_scopes)
894 # do not respect set -u
895 old_val = sh_expr_eval.OldValue(lval, self.mem, None)
896
897 val = PlusEquals(old_val, rhs)
898
899 else: # plain assignment
900 lval = self.arith_ev.EvalShellLhs(pair.lhs, which_scopes)
901
902 # RHS can be a string or array.
903 if pair.rhs:
904 val = self.word_ev.EvalRhsWord(pair.rhs)
905 assert isinstance(val, value_t), val
906
907 else: # e.g. 'readonly x' or 'local x'
908 val = None
909
910 # NOTE: In bash and mksh, declare -a myarray makes an empty cell
911 # with Undef value, but the 'array' attribute.
912
913 flags = 0 # for tracing
914 self.mem.SetValue(lval, val, which_scopes, flags=flags)
915 self.tracer.OnShAssignment(lval, pair.op, val, flags, which_scopes)
916
917 # PATCH to be compatible with existing shells: If the assignment had a
918 # command sub like:
919 #
920 # s=$(echo one; false)
921 #
922 # then its status will be in mem.last_status, and we can check it here.
923 # If there was NOT a command sub in the assignment, then we don't want to
924 # check it.
925
926 # Only do this if there was a command sub? How? Look at node?
927 # Set a flag in mem? self.mem.last_status or
928 if self.check_command_sub_status:
929 last_status = self.mem.LastStatus()
930 self._CheckStatus(last_status, cmd_st, node, loc.Missing)
931 return last_status # A global assignment shouldn't clear $?.
932 else:
933 return 0
934
935 def _DoExpr(self, node):
936 # type: (command.Expr) -> int
937
938 # call f(x) or = f(x)
939 val = self.expr_ev.EvalExpr(node.e, loc.Missing)
940
941 if node.keyword.id == Id.Lit_Equals: # = f(x)
942 io_errors = [] # type: List[error.IOError_OSError]
943 with vm.ctx_FlushStdout(io_errors):
944 try:
945 ui.PrettyPrintValue(val, mylib.Stdout())
946 except (IOError, OSError) as e:
947 self.errfmt.PrintMessage(
948 'I/O error during = keyword: %s' % pyutil.strerror(e),
949 node.keyword)
950 return 1
951
952 if len(io_errors): # e.g. disk full, ulimit
953 self.errfmt.PrintMessage(
954 'I/O error during = keyword: %s' %
955 pyutil.strerror(io_errors[0]), node.keyword)
956 return 1
957
958 return 0
959
960 def _DoControlFlow(self, node):
961 # type: (command.ControlFlow) -> int
962 keyword = node.keyword
963
964 if node.arg_word: # Evaluate the argument
965 str_val = self.word_ev.EvalWordToString(node.arg_word)
966
967 # Quirk: We need 'return $empty' to be valid for libtool. This is
968 # another meaning of strict_control_flow, which also has to do with
969 # break/continue at top level. It has the side effect of making
970 # 'return ""' valid, which shells other than zsh fail on.
971 if (len(str_val.s) == 0 and
972 not self.exec_opts.strict_control_flow()):
973 arg = 0
974 else:
975 try:
976 arg = int(str_val.s) # all control flow takes an integer
977 except ValueError:
978 # Either a bad argument, or integer overflow
979 e_die(
980 '%r expected a small integer, got %r' %
981 (lexer.TokenVal(keyword), str_val.s),
982 loc.Word(node.arg_word))
983
984 # C++ int() does range checking, but Python doesn't. So let's
985 # simulate it here for spec tests.
986 # TODO: could be mylib.ToMachineInt()? Problem: 'int' in C/C++
987 # could be more than 4 bytes. We are testing INT_MAX and
988 # INT_MIN in gc_builtins.cc - those could be hard-coded.
989 if mylib.PYTHON:
990 max_int = (1 << 31) - 1
991 min_int = -(1 << 31)
992 if not (min_int <= arg <= max_int):
993 e_die(
994 '%r expected a small integer, got %r' %
995 (lexer.TokenVal(keyword), str_val.s),
996 loc.Word(node.arg_word))
997 else:
998 if keyword.id in (Id.ControlFlow_Exit, Id.ControlFlow_Return):
999 arg = self.mem.LastStatus()
1000 else:
1001 arg = 1 # break or continue 1 level by default
1002
1003 self.tracer.OnControlFlow(consts.ControlFlowName(keyword.id), arg)
1004
1005 # NOTE: A top-level 'return' is OK, unlike in bash. If you can return
1006 # from a sourced script, it makes sense to return from a main script.
1007 if (keyword.id in (Id.ControlFlow_Break, Id.ControlFlow_Continue) and
1008 self.loop_level == 0):
1009 msg = 'Invalid control flow at top level'
1010 if self.exec_opts.strict_control_flow():
1011 e_die(msg, keyword)
1012 else:
1013 # Only print warnings, never fatal.
1014 # Bash oddly only exits 1 for 'return', but no other shell does.
1015 self.errfmt.PrefixPrint(msg, 'warning: ', keyword)
1016 return 0
1017
1018 if keyword.id == Id.ControlFlow_Exit:
1019 # handled differently than other control flow
1020 raise util.UserExit(arg)
1021 else:
1022 raise vm.IntControlFlow(keyword, arg)
1023
1024 def _DoAndOr(self, node, cmd_st):
1025 # type: (command.AndOr, CommandStatus) -> int
1026 # NOTE: && and || have EQUAL precedence in command mode. See case #13
1027 # in dbracket.test.sh.
1028
1029 left = node.children[0]
1030
1031 # Suppress failure for every child except the last one.
1032 self._StrictErrExit(left)
1033 with state.ctx_ErrExit(self.mutable_opts, False, node.ops[0]):
1034 status = self._Execute(left)
1035
1036 i = 1
1037 n = len(node.children)
1038 while i < n:
1039 #log('i %d status %d', i, status)
1040 child = node.children[i]
1041 op = node.ops[i - 1]
1042 op_id = op.id
1043
1044 #log('child %s op_id %s', child, op_id)
1045
1046 if op_id == Id.Op_DPipe and status == 0:
1047 i += 1
1048 continue # short circuit
1049
1050 elif op_id == Id.Op_DAmp and status != 0:
1051 i += 1
1052 continue # short circuit
1053
1054 if i == n - 1: # errexit handled differently for last child
1055 status = self._Execute(child)
1056 else:
1057 # blame the right && or ||
1058 self._StrictErrExit(child)
1059 with state.ctx_ErrExit(self.mutable_opts, False, op):
1060 status = self._Execute(child)
1061
1062 i += 1
1063
1064 return status
1065
1066 def _DoWhileUntil(self, node):
1067 # type: (command.WhileUntil) -> int
1068 status = 0
1069 with ctx_LoopLevel(self):
1070 while True:
1071 try:
1072 # blame while/until spid
1073 b = self._EvalCondition(node.cond, node.keyword)
1074 if node.keyword.id == Id.KW_Until:
1075 b = not b
1076 if not b:
1077 break
1078 status = self._Execute(node.body) # last one wins
1079
1080 except vm.IntControlFlow as e:
1081 status = 0
1082 action = e.HandleLoop()
1083 if action == flow_e.Break:
1084 break
1085 elif action == flow_e.Raise:
1086 raise
1087
1088 return status
1089
1090 def _DoForEach(self, node):
1091 # type: (command.ForEach) -> int
1092
1093 # for the 2 kinds of shell loop
1094 iter_list = None # type: List[str]
1095
1096 # for YSH loop
1097 iter_expr = None # type: expr_t
1098 expr_blame = None # type: loc_t
1099
1100 iterable = node.iterable
1101 UP_iterable = iterable
1102
1103 with tagswitch(node.iterable) as case:
1104 if case(for_iter_e.Args):
1105 iter_list = self.mem.GetArgv()
1106
1107 elif case(for_iter_e.Words):
1108 iterable = cast(for_iter.Words, UP_iterable)
1109 words = braces.BraceExpandWords(iterable.words)
1110 iter_list = self.word_ev.EvalWordSequence(words)
1111
1112 elif case(for_iter_e.YshExpr):
1113 iterable = cast(for_iter.YshExpr, UP_iterable)
1114 iter_expr = iterable.e
1115 expr_blame = iterable.blame
1116
1117 n = len(node.iter_names)
1118 assert n > 0
1119
1120 i_name = None # type: Optional[LeftName]
1121 # required
1122 name1 = None # type: LeftName
1123 name2 = None # type: Optional[LeftName]
1124
1125 it2 = None # type: val_ops._ContainerIter
1126 if iter_list is None: # for_expr.YshExpr
1127 val = self.expr_ev.EvalExpr(iter_expr, expr_blame)
1128
1129 UP_val = val
1130 with tagswitch(val) as case:
1131 if case(value_e.List):
1132 val = cast(value.List, UP_val)
1133 it2 = val_ops.ListIterator(val)
1134
1135 if n == 1:
1136 name1 = location.LName(node.iter_names[0])
1137 elif n == 2:
1138 i_name = location.LName(node.iter_names[0])
1139 name1 = location.LName(node.iter_names[1])
1140 else:
1141 # This is similar to a parse error
1142 e_die_status(
1143 2,
1144 'List iteration expects at most 2 loop variables',
1145 node.keyword)
1146
1147 elif case(value_e.Dict):
1148 val = cast(value.Dict, UP_val)
1149 it2 = val_ops.DictIterator(val)
1150
1151 if n == 1:
1152 name1 = location.LName(node.iter_names[0])
1153 elif n == 2:
1154 name1 = location.LName(node.iter_names[0])
1155 name2 = location.LName(node.iter_names[1])
1156 elif n == 3:
1157 i_name = location.LName(node.iter_names[0])
1158 name1 = location.LName(node.iter_names[1])
1159 name2 = location.LName(node.iter_names[2])
1160 else:
1161 raise AssertionError()
1162
1163 elif case(value_e.Range):
1164 val = cast(value.Range, UP_val)
1165 it2 = val_ops.RangeIterator(val)
1166
1167 if n == 1:
1168 name1 = location.LName(node.iter_names[0])
1169 elif n == 2:
1170 i_name = location.LName(node.iter_names[0])
1171 name1 = location.LName(node.iter_names[1])
1172 else:
1173 e_die_status(
1174 2,
1175 'Range iteration expects at most 2 loop variables',
1176 node.keyword)
1177
1178 else:
1179 raise error.TypeErr(val, 'for loop expected List or Dict',
1180 node.keyword)
1181 else:
1182 #log('iter list %s', iter_list)
1183 it2 = val_ops.ArrayIter(iter_list)
1184
1185 if n == 1:
1186 name1 = location.LName(node.iter_names[0])
1187 elif n == 2:
1188 i_name = location.LName(node.iter_names[0])
1189 name1 = location.LName(node.iter_names[1])
1190 else:
1191 # This is similar to a parse error
1192 e_die_status(
1193 2, 'Argv iteration expects at most 2 loop variables',
1194 node.keyword)
1195
1196 status = 0 # in case we loop zero times
1197 with ctx_LoopLevel(self):
1198 while not it2.Done():
1199 self.mem.SetLocalName(name1, it2.FirstValue())
1200 if name2:
1201 self.mem.SetLocalName(name2, it2.SecondValue())
1202 if i_name:
1203 self.mem.SetLocalName(i_name, num.ToBig(it2.Index()))
1204
1205 # increment index before handling continue, etc.
1206 it2.Next()
1207
1208 try:
1209 status = self._Execute(node.body) # last one wins
1210 except vm.IntControlFlow as e:
1211 status = 0
1212 action = e.HandleLoop()
1213 if action == flow_e.Break:
1214 break
1215 elif action == flow_e.Raise:
1216 raise
1217
1218 return status
1219
1220 def _DoForExpr(self, node):
1221 # type: (command.ForExpr) -> int
1222
1223 status = 0
1224
1225 init = node.init
1226 for_cond = node.cond
1227 body = node.body
1228 update = node.update
1229
1230 self.arith_ev.Eval(init)
1231 with ctx_LoopLevel(self):
1232 while True:
1233 # We only accept integers as conditions
1234 cond_int = self.arith_ev.EvalToBigInt(for_cond)
1235 if mops.Equal(cond_int, mops.ZERO): # false
1236 break
1237
1238 try:
1239 status = self._Execute(body)
1240 except vm.IntControlFlow as e:
1241 status = 0
1242 action = e.HandleLoop()
1243 if action == flow_e.Break:
1244 break
1245 elif action == flow_e.Raise:
1246 raise
1247
1248 self.arith_ev.Eval(update)
1249
1250 return status
1251
1252 def _DoShFunction(self, node):
1253 # type: (command.ShFunction) -> None
1254 if node.name in self.procs and not self.exec_opts.redefine_proc_func():
1255 e_die(
1256 "Function %s was already defined (redefine_proc_func)" %
1257 node.name, node.name_tok)
1258 self.procs[node.name] = value.Proc(node.name, node.name_tok,
1259 proc_sig.Open, node.body, None,
1260 True)
1261
1262 def _DoProc(self, node):
1263 # type: (Proc) -> None
1264 proc_name = lexer.TokenVal(node.name)
1265 if proc_name in self.procs and not self.exec_opts.redefine_proc_func():
1266 e_die(
1267 "Proc %s was already defined (redefine_proc_func)" % proc_name,
1268 node.name)
1269
1270 if node.sig.tag() == proc_sig_e.Closed:
1271 sig = cast(proc_sig.Closed, node.sig)
1272 proc_defaults = func_proc.EvalProcDefaults(self.expr_ev, sig)
1273 else:
1274 proc_defaults = None
1275
1276 # no dynamic scope
1277 self.procs[proc_name] = value.Proc(proc_name, node.name, node.sig,
1278 node.body, proc_defaults, False)
1279
1280 def _DoFunc(self, node):
1281 # type: (Func) -> None
1282 name = lexer.TokenVal(node.name)
1283 lval = location.LName(name)
1284
1285 # Check that we haven't already defined a function
1286 cell = self.mem.GetCell(name, scope_e.LocalOnly)
1287 if cell and cell.val.tag() == value_e.Func:
1288 if self.exec_opts.redefine_proc_func():
1289 cell.readonly = False # Ensure we can unset the value
1290 did_unset = self.mem.Unset(lval, scope_e.LocalOnly)
1291 assert did_unset, name
1292 else:
1293 e_die(
1294 "Func %s was already defined (redefine_proc_func)" % name,
1295 node.name)
1296
1297 pos_defaults, named_defaults = func_proc.EvalFuncDefaults(
1298 self.expr_ev, node)
1299 func_val = value.Func(name, node, pos_defaults, named_defaults, None)
1300
1301 self.mem.SetNamed(lval,
1302 func_val,
1303 scope_e.LocalOnly,
1304 flags=state.SetReadOnly)
1305
1306 def _DoIf(self, node):
1307 # type: (command.If) -> int
1308 status = -1
1309
1310 done = False
1311 for if_arm in node.arms:
1312 b = self._EvalCondition(if_arm.cond, if_arm.keyword)
1313 if b:
1314 status = self._ExecuteList(if_arm.action)
1315 done = True
1316 break
1317
1318 if not done and node.else_action is not None:
1319 status = self._ExecuteList(node.else_action)
1320
1321 assert status != -1, 'Should have been initialized'
1322 return status
1323
1324 def _DoCase(self, node):
1325 # type: (command.Case) -> int
1326
1327 to_match = self._EvalCaseArg(node.to_match, node.case_kw)
1328 fnmatch_flags = FNM_CASEFOLD if self.exec_opts.nocasematch() else 0
1329
1330 status = 0 # If there are no arms, it should be zero?
1331
1332 done = False # Should we try the next arm?
1333
1334 # For &; terminator - not just case fallthrough, but IGNORE the condition!
1335 ignore_next_cond = False
1336
1337 for case_arm in node.arms:
1338 with tagswitch(case_arm.pattern) as case:
1339 if case(pat_e.Words):
1340 if to_match.tag() != value_e.Str:
1341 continue # A non-string `to_match` will never match a pat.Words
1342 to_match_str = cast(value.Str, to_match)
1343
1344 pat_words = cast(pat.Words, case_arm.pattern)
1345
1346 this_arm_matches = False
1347 if ignore_next_cond: # Special handling for ;&
1348 this_arm_matches = True
1349 ignore_next_cond = False
1350 else:
1351 for pat_word in pat_words.words:
1352 word_val = self.word_ev.EvalWordToString(
1353 pat_word, word_eval.QUOTE_FNMATCH)
1354
1355 if libc.fnmatch(word_val.s, to_match_str.s,
1356 fnmatch_flags):
1357 this_arm_matches = True
1358 break # Stop at first pattern
1359
1360 if this_arm_matches:
1361 status = self._ExecuteList(case_arm.action)
1362 done = True
1363
1364 # ;& and ;;& only apply to shell-style case
1365 if case_arm.right:
1366 id_ = case_arm.right.id
1367 if id_ == Id.Op_SemiAmp:
1368 # very weird semantic
1369 ignore_next_cond = True
1370 done = False
1371 elif id_ == Id.Op_DSemiAmp:
1372 # Keep going until next pattern
1373 done = False
1374
1375 elif case(pat_e.YshExprs):
1376 pat_exprs = cast(pat.YshExprs, case_arm.pattern)
1377
1378 for pat_expr in pat_exprs.exprs:
1379 expr_val = self.expr_ev.EvalExpr(
1380 pat_expr, case_arm.left)
1381
1382 if val_ops.ExactlyEqual(expr_val, to_match,
1383 case_arm.left):
1384 status = self._ExecuteList(case_arm.action)
1385 done = True
1386 break
1387
1388 elif case(pat_e.Eggex):
1389 eggex = cast(Eggex, case_arm.pattern)
1390 eggex_val = self.expr_ev.EvalEggex(eggex)
1391
1392 if val_ops.MatchRegex(to_match, eggex_val, self.mem):
1393 status = self._ExecuteList(case_arm.action)
1394 done = True
1395 break
1396
1397 elif case(pat_e.Else):
1398 status = self._ExecuteList(case_arm.action)
1399 done = True
1400 break
1401
1402 else:
1403 raise AssertionError()
1404
1405 if done: # first match wins
1406 break
1407
1408 return status
1409
1410 def _DoTimeBlock(self, node):
1411 # type: (command.TimeBlock) -> int
1412 # TODO:
1413 # - When do we need RUSAGE_CHILDREN?
1414 # - Respect TIMEFORMAT environment variable.
1415 # "If this variable is not set, Bash acts as if it had the value"
1416 # $'\nreal\t%3lR\nuser\t%3lU\nsys\t%3lS'
1417 # "A trailing newline is added when the format string is displayed."
1418
1419 s_real, s_user, s_sys = pyos.Time()
1420 status = self._Execute(node.pipeline)
1421 e_real, e_user, e_sys = pyos.Time()
1422 # note: mycpp doesn't support %.3f
1423 libc.print_time(e_real - s_real, e_user - s_user, e_sys - s_sys)
1424
1425 return status
1426
1427 def _DoRedirect(self, node, cmd_st):
1428 # type: (command.Redirect, CommandStatus) -> int
1429
1430 status = 0
1431 redirects = [] # type: List[RedirValue]
1432
1433 try:
1434 for redir in node.redirects:
1435 redirects.append(self._EvalRedirect(redir))
1436 except error.RedirectEval as e:
1437 self.errfmt.PrettyPrintError(e)
1438 redirects = None
1439 except error.FailGlob as e: # e.g. echo hi > foo-*
1440 if not e.HasLocation():
1441 e.location = self.mem.GetFallbackLocation()
1442 self.errfmt.PrettyPrintError(e, prefix='failglob: ')
1443 redirects = None
1444
1445 if redirects is None:
1446 # Error evaluating redirect words
1447 status = 1
1448
1449 # Translation fix: redirect I/O errors may happen in a C++
1450 # destructor ~vm::ctx_Redirect, which means they must be signaled
1451 # by out params, not exceptions.
1452 io_errors = [] # type: List[error.IOError_OSError]
1453
1454 # If we evaluated redirects, apply/push them
1455 if status == 0:
1456 self.shell_ex.PushRedirects(redirects, io_errors)
1457 if len(io_errors):
1458 # if errno is 0, error has already printed
1459 if io_errors[0].errno:
1460 # core/process.py prints cryptic errors, so we repeat them
1461 # here. e.g. Bad File Descriptor
1462 self.errfmt.PrintMessage(
1463 'I/O redirect error: %s' %
1464 pyutil.strerror(io_errors[0]),
1465 self.mem.GetFallbackLocation())
1466 status = 1
1467
1468 # If we applied redirects successfully, run the command_t, and pop
1469 # them.
1470 if status == 0:
1471 with vm.ctx_Redirect(self.shell_ex, len(redirects), io_errors):
1472 status = self._Execute(node.child)
1473 if len(io_errors):
1474 # It would be better to point to the right redirect
1475 # operator, but we don't track it specifically
1476 e_die("Fatal error popping redirect: %s" %
1477 pyutil.strerror(io_errors[0]))
1478
1479 return status
1480
1481 def _Dispatch(self, node, cmd_st):
1482 # type: (command_t, CommandStatus) -> int
1483 """Switch on the command_t variants and execute them."""
1484
1485 # If we call RunCommandSub in a recursive call to the executor, this will
1486 # be set true (if strict_errexit is false). But it only lasts for one
1487 # command.
1488 probe('cmd_eval', '_Dispatch', node.tag())
1489 self.check_command_sub_status = False
1490
1491 UP_node = node
1492 with tagswitch(node) as case:
1493 if case(command_e.Simple): # LEAF command
1494 node = cast(command.Simple, UP_node)
1495
1496 # for $LINENO, e.g. PS4='+$SOURCE_NAME:$LINENO:'
1497 # Note that for '> $LINENO' the location token is set in _EvalRedirect.
1498 # TODO: blame_tok should always be set.
1499 if node.blame_tok is not None:
1500 self.mem.SetTokenForLine(node.blame_tok)
1501
1502 self._MaybeRunDebugTrap()
1503 cmd_st.check_errexit = True
1504 status = self._DoSimple(node, cmd_st)
1505
1506 elif case(command_e.ExpandedAlias):
1507 node = cast(command.ExpandedAlias, UP_node)
1508 status = self._DoExpandedAlias(node)
1509
1510 elif case(command_e.Sentence):
1511 node = cast(command.Sentence, UP_node)
1512
1513 # Don't check_errexit since this isn't a leaf command
1514 if node.terminator.id == Id.Op_Semi:
1515 status = self._Execute(node.child)
1516 else:
1517 status = self.shell_ex.RunBackgroundJob(node.child)
1518
1519 elif case(command_e.Redirect):
1520 node = cast(command.Redirect, UP_node)
1521
1522 # set -e affects redirect error, like mksh and bash 5.2, but unlike
1523 # dash/ash
1524 cmd_st.check_errexit = True
1525 status = self._DoRedirect(node, cmd_st)
1526
1527 elif case(command_e.Pipeline):
1528 node = cast(command.Pipeline, UP_node)
1529 status = self._DoPipeline(node, cmd_st)
1530
1531 elif case(command_e.Subshell):
1532 node = cast(command.Subshell, UP_node)
1533
1534 # This is a leaf from the parent process POV
1535 cmd_st.check_errexit = True
1536 status = self.shell_ex.RunSubshell(node.child)
1537
1538 elif case(command_e.DBracket): # LEAF command
1539 node = cast(command.DBracket, UP_node)
1540
1541 self.mem.SetTokenForLine(node.left)
1542 self._MaybeRunDebugTrap()
1543
1544 self.tracer.PrintSourceCode(node.left, node.right, self.arena)
1545
1546 cmd_st.check_errexit = True
1547 cmd_st.show_code = True # this is a "leaf" for errors
1548 result = self.bool_ev.EvalB(node.expr)
1549 status = 0 if result else 1
1550
1551 elif case(command_e.DParen): # LEAF command
1552 node = cast(command.DParen, UP_node)
1553
1554 self.mem.SetTokenForLine(node.left)
1555 self._MaybeRunDebugTrap()
1556
1557 self.tracer.PrintSourceCode(node.left, node.right, self.arena)
1558
1559 cmd_st.check_errexit = True
1560 cmd_st.show_code = True # this is a "leaf" for errors
1561 i = self.arith_ev.EvalToBigInt(node.child)
1562 status = 1 if mops.Equal(i, mops.ZERO) else 0
1563
1564 elif case(command_e.ControlFlow): # LEAF command
1565 node = cast(command.ControlFlow, UP_node)
1566
1567 self.mem.SetTokenForLine(node.keyword)
1568 self._MaybeRunDebugTrap()
1569
1570 status = self._DoControlFlow(node)
1571
1572 elif case(command_e.VarDecl): # LEAF command
1573 node = cast(command.VarDecl, UP_node)
1574
1575 # Point to var name (bare assignment has no keyword)
1576 self.mem.SetTokenForLine(node.lhs[0].left)
1577 status = self._DoVarDecl(node)
1578
1579 elif case(command_e.Mutation): # LEAF command
1580 node = cast(command.Mutation, UP_node)
1581
1582 self.mem.SetTokenForLine(node.keyword) # point to setvar/set
1583 self._DoMutation(node)
1584 status = 0 # if no exception is thrown, it succeeds
1585
1586 elif case(command_e.ShAssignment): # LEAF command
1587 node = cast(command.ShAssignment, UP_node)
1588
1589 self.mem.SetTokenForLine(node.pairs[0].left)
1590 self._MaybeRunDebugTrap()
1591
1592 # Only unqualified assignment a=b
1593 status = self._DoShAssignment(node, cmd_st)
1594
1595 elif case(command_e.Expr): # YSH LEAF command
1596 node = cast(command.Expr, UP_node)
1597
1598 self.mem.SetTokenForLine(node.keyword)
1599 # YSH debug trap?
1600
1601 status = self._DoExpr(node)
1602
1603 elif case(command_e.Retval): # YSH LEAF command
1604 node = cast(command.Retval, UP_node)
1605
1606 self.mem.SetTokenForLine(node.keyword)
1607 # YSH debug trap? I think we don't want the debug trap in func
1608 # dialect, for speed?
1609
1610 val = self.expr_ev.EvalExpr(node.val, node.keyword)
1611 raise vm.ValueControlFlow(node.keyword, val)
1612
1613 # Note CommandList and DoGroup have no redirects, but BraceGroup does.
1614 # DoGroup has 'do' and 'done' spids for translation.
1615 elif case(command_e.CommandList):
1616 node = cast(command.CommandList, UP_node)
1617 status = self._ExecuteList(node.children)
1618
1619 elif case(command_e.DoGroup):
1620 node = cast(command.DoGroup, UP_node)
1621 status = self._ExecuteList(node.children)
1622
1623 elif case(command_e.BraceGroup):
1624 node = cast(BraceGroup, UP_node)
1625 status = self._ExecuteList(node.children)
1626
1627 elif case(command_e.AndOr):
1628 node = cast(command.AndOr, UP_node)
1629 status = self._DoAndOr(node, cmd_st)
1630
1631 elif case(command_e.WhileUntil):
1632 node = cast(command.WhileUntil, UP_node)
1633
1634 self.mem.SetTokenForLine(node.keyword)
1635 status = self._DoWhileUntil(node)
1636
1637 elif case(command_e.ForEach):
1638 node = cast(command.ForEach, UP_node)
1639
1640 self.mem.SetTokenForLine(node.keyword)
1641 status = self._DoForEach(node)
1642
1643 elif case(command_e.ForExpr):
1644 node = cast(command.ForExpr, UP_node)
1645
1646 self.mem.SetTokenForLine(node.keyword) # for x in $LINENO
1647 status = self._DoForExpr(node)
1648
1649 elif case(command_e.ShFunction):
1650 node = cast(command.ShFunction, UP_node)
1651 self._DoShFunction(node)
1652 status = 0
1653
1654 elif case(command_e.Proc):
1655 node = cast(Proc, UP_node)
1656 self._DoProc(node)
1657 status = 0
1658
1659 elif case(command_e.Func):
1660 node = cast(Func, UP_node)
1661
1662 # Needed for error, when the func is an existing variable name
1663 self.mem.SetTokenForLine(node.name)
1664
1665 self._DoFunc(node)
1666 status = 0
1667
1668 elif case(command_e.If):
1669 node = cast(command.If, UP_node)
1670
1671 # No SetTokenForLine() because
1672 # - $LINENO can't appear directly in 'if'
1673 # - 'if' doesn't directly cause errors
1674 # It will be taken care of by command.Simple, condition, etc.
1675 status = self._DoIf(node)
1676
1677 elif case(command_e.NoOp):
1678 status = 0 # make it true
1679
1680 elif case(command_e.Case):
1681 node = cast(command.Case, UP_node)
1682
1683 # Must set location for 'case $LINENO'
1684 self.mem.SetTokenForLine(node.case_kw)
1685 self._MaybeRunDebugTrap()
1686 status = self._DoCase(node)
1687
1688 elif case(command_e.TimeBlock):
1689 node = cast(command.TimeBlock, UP_node)
1690 status = self._DoTimeBlock(node)
1691
1692 else:
1693 raise NotImplementedError(node.tag())
1694
1695 # Return to caller. Note the only case that didn't set it was Pipeline,
1696 # which set cmd_st.pipe_status.
1697 return status
1698
1699 def RunPendingTraps(self):
1700 # type: () -> None
1701
1702 trap_nodes = self.trap_state.GetPendingTraps()
1703 if trap_nodes is not None:
1704 with state.ctx_Option(self.mutable_opts, [option_i._running_trap],
1705 True):
1706 for trap_node in trap_nodes:
1707 # Isolate the exit status.
1708 with state.ctx_Registers(self.mem):
1709 # Trace it. TODO: Show the trap kind too
1710 with dev.ctx_Tracer(self.tracer, 'trap', None):
1711 self._Execute(trap_node)
1712
1713 def _Execute(self, node):
1714 # type: (command_t) -> int
1715 """Call _Dispatch(), and performs the errexit check.
1716
1717 Also runs trap handlers.
1718 """
1719 # TODO: Do this in "leaf" nodes? SimpleCommand, DBracket, DParen should
1720 # call self.DoTick()? That will RunPendingTraps and check the Ctrl-C flag,
1721 # and maybe throw an exception.
1722 self.RunPendingTraps()
1723
1724 # We only need this somewhat hacky check in osh-cpp since python's runtime
1725 # handles SIGINT for us in osh.
1726 if mylib.CPP:
1727 if self.signal_safe.PollSigInt():
1728 raise KeyboardInterrupt()
1729
1730 # Manual GC point before every statement
1731 mylib.MaybeCollect()
1732
1733 # Optimization: These 2 records have rarely-used lists, so we don't pass
1734 # alloc_lists=True. We create them on demand.
1735 cmd_st = CommandStatus.CreateNull()
1736 if len(self.status_array_pool):
1737 # Optimized to avoid allocs
1738 process_sub_st = self.status_array_pool.pop()
1739 else:
1740 process_sub_st = StatusArray.CreateNull()
1741
1742 with vm.ctx_ProcessSub(self.shell_ex, process_sub_st): # for wait()
1743 try:
1744 status = self._Dispatch(node, cmd_st)
1745 except error.FailGlob as e:
1746 if not e.HasLocation(): # Last resort!
1747 e.location = self.mem.GetFallbackLocation()
1748 self.errfmt.PrettyPrintError(e, prefix='failglob: ')
1749 status = 1 # another redirect word eval error
1750 cmd_st.check_errexit = True # failglob + errexit
1751
1752 # Now we've waited for process subs
1753
1754 # If it was a real pipeline, compute status from ${PIPESTATUS[@]} aka
1755 # @_pipeline_status
1756 pipe_status = cmd_st.pipe_status
1757 # Note: bash/mksh set PIPESTATUS set even on non-pipelines. This
1758 # makes it annoying to check both _process_sub_status and
1759 # _pipeline_status
1760
1761 errexit_loc = loc.Missing # type: loc_t
1762 if pipe_status is not None:
1763 # Tricky: _DoPipeline sets cmt_st.pipe_status and returns -1
1764 # for a REAL pipeline (but not singleton pipelines)
1765 assert status == -1, (
1766 "Shouldn't have redir errors when PIPESTATUS (status = %d)" %
1767 status)
1768
1769 self.mem.SetPipeStatus(pipe_status)
1770
1771 if self.exec_opts.pipefail():
1772 # The status is that of the last command that is non-zero.
1773 status = 0
1774 for i, st in enumerate(pipe_status):
1775 if st != 0:
1776 status = st
1777 errexit_loc = cmd_st.pipe_locs[i]
1778 else:
1779 # The status is that of last command, period.
1780 status = pipe_status[-1]
1781
1782 if cmd_st.pipe_negated:
1783 status = 1 if status == 0 else 0
1784
1785 # Compute status from _process_sub_status
1786 if process_sub_st.codes is None:
1787 # Optimized to avoid allocs
1788 self.status_array_pool.append(process_sub_st)
1789 else:
1790 codes = process_sub_st.codes
1791 self.mem.SetProcessSubStatus(codes)
1792 if status == 0 and self.exec_opts.process_sub_fail():
1793 # Choose the LAST non-zero status, consistent with pipefail above.
1794 for i, st in enumerate(codes):
1795 if st != 0:
1796 status = st
1797 errexit_loc = process_sub_st.locs[i]
1798
1799 self.mem.SetLastStatus(status)
1800
1801 # NOTE: Bash says that 'set -e' checking is done after each 'pipeline'.
1802 # However, any bash construct can appear in a pipeline. So it's easier
1803 # just to put it at the end, instead of after every node.
1804 #
1805 # Possible exceptions:
1806 # - function def (however this always exits 0 anyway)
1807 # - assignment - its result should be the result of the RHS?
1808 # - e.g. arith sub, command sub? I don't want arith sub.
1809 # - ControlFlow: always raises, it has no status.
1810 if cmd_st.check_errexit:
1811 #log('cmd_st %s', cmd_st)
1812 self._CheckStatus(status, cmd_st, node, errexit_loc)
1813
1814 return status
1815
1816 def _ExecuteList(self, children):
1817 # type: (List[command_t]) -> int
1818 status = 0 # for empty list
1819 for child in children:
1820 # last status wins
1821 status = self._Execute(child)
1822 return status
1823
1824 def LastStatus(self):
1825 # type: () -> int
1826 """For main_loop.py to determine the exit code of the shell itself."""
1827 return self.mem.LastStatus()
1828
1829 def _NoForkLast(self, node):
1830 # type: (command_t) -> None
1831
1832 if 0:
1833 log('optimizing')
1834 node.PrettyPrint(sys.stderr)
1835 log('')
1836
1837 UP_node = node
1838 with tagswitch(node) as case:
1839 if case(command_e.Simple):
1840 node = cast(command.Simple, UP_node)
1841 node.do_fork = False
1842 if 0:
1843 log('Simple optimized')
1844
1845 elif case(command_e.Pipeline):
1846 node = cast(command.Pipeline, UP_node)
1847 if node.negated is None:
1848 #log ('pipe')
1849 self._NoForkLast(node.children[-1])
1850
1851 elif case(command_e.Sentence):
1852 node = cast(command.Sentence, UP_node)
1853 self._NoForkLast(node.child)
1854
1855 elif case(command_e.CommandList):
1856 # Subshells start with CommandList, even if there's only one.
1857 node = cast(command.CommandList, UP_node)
1858 self._NoForkLast(node.children[-1])
1859
1860 elif case(command_e.BraceGroup):
1861 # TODO: What about redirects?
1862 node = cast(BraceGroup, UP_node)
1863 self._NoForkLast(node.children[-1])
1864
1865 def _RemoveSubshells(self, node):
1866 # type: (command_t) -> command_t
1867 """Eliminate redundant subshells like ( echo hi ) | wc -l etc.
1868
1869 This is ONLY called at the top level of ExecuteAndCatch() - it wouldn't
1870 be correct otherwise.
1871 """
1872 UP_node = node
1873 with tagswitch(node) as case:
1874 if case(command_e.Subshell):
1875 node = cast(command.Subshell, UP_node)
1876 # Optimize ( ( date ) ) etc.
1877 return self._RemoveSubshells(node.child)
1878 return node
1879
1880 def ExecuteAndCatch(self, node, cmd_flags=0):
1881 # type: (command_t, int) -> Tuple[bool, bool]
1882 """Execute a subprogram, handling vm.IntControlFlow and fatal exceptions.
1883
1884 Args:
1885 node: LST subtree
1886 optimize: Whether to exec the last process rather than fork/exec
1887
1888 Returns:
1889 TODO: use enum 'why' instead of the 2 booleans
1890
1891 Used by
1892 - main_loop.py.
1893 - SubProgramThunk for pipelines, subshell, command sub, process sub
1894 - TODO: Signals besides EXIT trap
1895
1896 Note: To do what optimize does, dash has EV_EXIT flag and yash has a
1897 finally_exit boolean. We use a different algorithm.
1898 """
1899 if cmd_flags & Optimize:
1900 node = self._RemoveSubshells(node)
1901 self._NoForkLast(node) # turn the last ones into exec
1902
1903 if 0:
1904 log('after opt:')
1905 node.PrettyPrint()
1906 log('')
1907
1908 is_return = False
1909 is_fatal = False
1910 is_errexit = False
1911
1912 err = None # type: error.FatalRuntime
1913 status = -1 # uninitialized
1914
1915 try:
1916 options = [] # type: List[int]
1917 if cmd_flags & NoDebugTrap:
1918 options.append(option_i._no_debug_trap)
1919 if cmd_flags & NoErrTrap:
1920 options.append(option_i._no_err_trap)
1921 with state.ctx_Option(self.mutable_opts, options, True):
1922 status = self._Execute(node)
1923 except vm.IntControlFlow as e:
1924 if cmd_flags & RaiseControlFlow:
1925 raise # 'eval break' and 'source return.sh', etc.
1926 else:
1927 # Return at top level is OK, unlike in bash.
1928 if e.IsReturn():
1929 is_return = True
1930 status = e.StatusCode()
1931 else:
1932 # TODO: This error message is invalid. Can also happen in eval.
1933 # We need a flag.
1934
1935 # Invalid control flow
1936 self.errfmt.Print_(
1937 "Loop and control flow can't be in different processes",
1938 blame_loc=e.token)
1939 is_fatal = True
1940 # All shells exit 0 here. It could be hidden behind
1941 # strict_control_flow if the incompatibility causes problems.
1942 status = 1
1943 except error.Parse as e:
1944 self.dumper.MaybeRecord(self, e) # Do this before unwinding stack
1945 raise
1946 except error.ErrExit as e:
1947 err = e
1948 is_errexit = True
1949 except error.FatalRuntime as e:
1950 err = e
1951
1952 if err:
1953 status = err.ExitStatus()
1954
1955 is_fatal = True
1956 # Do this before unwinding stack
1957 self.dumper.MaybeRecord(self, err)
1958
1959 if not err.HasLocation(): # Last resort!
1960 #log('Missing location')
1961 err.location = self.mem.GetFallbackLocation()
1962 #log('%s', err.location)
1963
1964 if is_errexit:
1965 if self.exec_opts.verbose_errexit():
1966 self.errfmt.PrintErrExit(cast(error.ErrExit, err),
1967 posix.getpid())
1968 else:
1969 self.errfmt.PrettyPrintError(err, prefix='fatal: ')
1970
1971 assert status >= 0, 'Should have been initialized'
1972
1973 # Problem: We have no idea here if a SUBSHELL (or pipeline comment) already
1974 # created a crash dump. So we get 2 or more of them.
1975 self.dumper.MaybeDump(status)
1976
1977 self.mem.SetLastStatus(status)
1978 return is_return, is_fatal
1979
1980 def EvalCommand(self, block):
1981 # type: (command_t) -> int
1982 """For builtins to evaluate command args.
1983
1984 e.g. cd /tmp (x)
1985 """
1986 status = 0
1987 try:
1988 status = self._Execute(block) # can raise FatalRuntimeError, etc.
1989 except vm.IntControlFlow as e: # A block is more like a function.
1990 # return in a block
1991 if e.IsReturn():
1992 status = e.StatusCode()
1993 else:
1994 e_die('Unexpected control flow in block', e.token)
1995
1996 return status
1997
1998 def MaybeRunExitTrap(self, mut_status):
1999 # type: (IntParamBox) -> None
2000 """If an EXIT trap handler exists, run it.
2001
2002 Only mutates the status if 'return' or 'exit'. This is odd behavior, but
2003 all bash/dash/mksh seem to agree on it. See cases in
2004 builtin-trap.test.sh.
2005
2006 Note: if we could easily modulo -1 % 256 == 255 here, then we could get rid
2007 of this awkward interface. But that's true in Python and not C!
2008
2009 Could use i & (n-1) == i & 255 because we have a power of 2.
2010 https://stackoverflow.com/questions/14997165/fastest-way-to-get-a-positive-modulo-in-c-c
2011 """
2012 node = self.trap_state.GetHook('EXIT') # type: command_t
2013 if node:
2014 # NOTE: Don't set option_i._running_trap, because that's for
2015 # RunPendingTraps() in the MAIN LOOP
2016 with dev.ctx_Tracer(self.tracer, 'trap EXIT', None):
2017 try:
2018 is_return, is_fatal = self.ExecuteAndCatch(node)
2019 except util.UserExit as e: # explicit exit
2020 mut_status.i = e.status
2021 return
2022 if is_return: # explicit 'return' in the trap handler!
2023 mut_status.i = self.LastStatus()
2024
2025 def _MaybeRunDebugTrap(self):
2026 # type: () -> None
2027 """Run user-specified DEBUG code before certain commands."""
2028 node = self.trap_state.GetHook('DEBUG') # type: command_t
2029 if node is None:
2030 return
2031
2032 # Fix lastpipe / job control / DEBUG trap interaction
2033 if self.exec_opts._no_debug_trap():
2034 return
2035
2036 # Don't run recursively run traps, etc.
2037 if not self.mem.ShouldRunDebugTrap():
2038 return
2039
2040 # NOTE: Don't set option_i._running_trap, because that's for
2041 # RunPendingTraps() in the MAIN LOOP
2042
2043 with dev.ctx_Tracer(self.tracer, 'trap DEBUG', None):
2044 with state.ctx_Registers(self.mem): # prevent setting $? etc.
2045 # for SetTokenForLine $LINENO
2046 with state.ctx_DebugTrap(self.mem):
2047 # Don't catch util.UserExit, etc.
2048 self._Execute(node)
2049
2050 def _MaybeRunErrTrap(self):
2051 # type: () -> None
2052 """
2053 Run user-specified ERR code after checking the status of certain
2054 commands (pipelines)
2055 """
2056 node = self.trap_state.GetHook('ERR') # type: command_t
2057 if node is None:
2058 return
2059
2060 # ERR trap is only run for a whole pipeline, not its parts
2061 if self.exec_opts._no_err_trap():
2062 return
2063
2064 # Prevent infinite recursion
2065 if self.mem.running_err_trap:
2066 return
2067
2068 # "disabled errexit" rule
2069 if self.mutable_opts.ErrExitIsDisabled():
2070 return
2071
2072 # bash rule - affected by set -o errtrace
2073 if self.mem.InsideFunction():
2074 return
2075
2076 # NOTE: Don't set option_i._running_trap, because that's for
2077 # RunPendingTraps() in the MAIN LOOP
2078
2079 with dev.ctx_Tracer(self.tracer, 'trap ERR', None):
2080 #with state.ctx_Registers(self.mem): # prevent setting $? etc.
2081 with state.ctx_ErrTrap(self.mem):
2082 self._Execute(node)
2083
2084 def RunProc(self, proc, cmd_val):
2085 # type: (value.Proc, cmd_value.Argv) -> int
2086 """Run procs aka "shell functions".
2087
2088 For SimpleCommand and registered completion hooks.
2089 """
2090 sig = proc.sig
2091 if sig.tag() == proc_sig_e.Closed:
2092 # We're binding named params. User should use @rest. No 'shift'.
2093 proc_argv = [] # type: List[str]
2094 else:
2095 proc_argv = cmd_val.argv[1:]
2096
2097 # Hm this sets "$@". TODO: Set ARGV only
2098 with state.ctx_ProcCall(self.mem, self.mutable_opts, proc, proc_argv):
2099 func_proc.BindProcArgs(proc, cmd_val, self.mem)
2100
2101 # Redirects still valid for functions.
2102 # Here doc causes a pipe and Process(SubProgramThunk).
2103 try:
2104 status = self._Execute(proc.body)
2105 except vm.IntControlFlow as e:
2106 if e.IsReturn():
2107 status = e.StatusCode()
2108 else:
2109 # break/continue used in the wrong place.
2110 e_die(
2111 'Unexpected %r (in proc call)' %
2112 lexer.TokenVal(e.token), e.token)
2113 except error.FatalRuntime as e:
2114 # Dump the stack before unwinding it
2115 self.dumper.MaybeRecord(self, e)
2116 raise
2117
2118 return status
2119
2120 def RunFuncForCompletion(self, proc, argv):
2121 # type: (value.Proc, List[str]) -> int
2122 """
2123 Args:
2124 argv: $1 $2 $3 ... not including $0
2125 """
2126 cmd_val = MakeBuiltinArgv(argv)
2127
2128 # TODO: Change this to run YSH procs and funcs too
2129 try:
2130 status = self.RunProc(proc, cmd_val)
2131 except error.FatalRuntime as e:
2132 self.errfmt.PrettyPrintError(e)
2133 status = e.ExitStatus()
2134 except vm.IntControlFlow as e:
2135 # shouldn't be able to exit the shell from a completion hook!
2136 # TODO: Avoid overwriting the prompt!
2137 self.errfmt.Print_('Attempted to exit from completion hook.',
2138 blame_loc=e.token)
2139
2140 status = 1
2141 # NOTE: (IOError, OSError) are caught in completion.py:ReadlineCallback
2142 return status
2143
2144
2145# vim: sw=4