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

2173 lines, 1348 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: state.Procs
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 else:
1118 raise AssertionError()
1119
1120 n = len(node.iter_names)
1121 assert n > 0
1122
1123 i_name = None # type: Optional[LeftName]
1124 # required
1125 name1 = None # type: LeftName
1126 name2 = None # type: Optional[LeftName]
1127
1128 it2 = None # type: val_ops.Iterator
1129 if iter_expr: # for_expr.YshExpr
1130 val = self.expr_ev.EvalExpr(iter_expr, expr_blame)
1131
1132 UP_val = val
1133 with tagswitch(val) as case:
1134 if case(value_e.List):
1135 val = cast(value.List, UP_val)
1136 it2 = val_ops.ListIterator(val)
1137
1138 if n == 1:
1139 name1 = location.LName(node.iter_names[0])
1140 elif n == 2:
1141 i_name = location.LName(node.iter_names[0])
1142 name1 = location.LName(node.iter_names[1])
1143 else:
1144 # This is similar to a parse error
1145 e_die_status(
1146 2,
1147 'List iteration expects at most 2 loop variables',
1148 node.keyword)
1149
1150 elif case(value_e.Dict):
1151 val = cast(value.Dict, UP_val)
1152 it2 = val_ops.DictIterator(val)
1153
1154 if n == 1:
1155 name1 = location.LName(node.iter_names[0])
1156 elif n == 2:
1157 name1 = location.LName(node.iter_names[0])
1158 name2 = location.LName(node.iter_names[1])
1159 elif n == 3:
1160 i_name = location.LName(node.iter_names[0])
1161 name1 = location.LName(node.iter_names[1])
1162 name2 = location.LName(node.iter_names[2])
1163 else:
1164 raise AssertionError()
1165
1166 elif case(value_e.Range):
1167 val = cast(value.Range, UP_val)
1168 it2 = val_ops.RangeIterator(val)
1169
1170 if n == 1:
1171 name1 = location.LName(node.iter_names[0])
1172 elif n == 2:
1173 i_name = location.LName(node.iter_names[0])
1174 name1 = location.LName(node.iter_names[1])
1175 else:
1176 e_die_status(
1177 2,
1178 'Range iteration expects at most 2 loop variables',
1179 node.keyword)
1180
1181 elif case(value_e.Stdin):
1182 # TODO: This could changed to magic iterator?
1183 it2 = val_ops.StdinIterator(expr_blame)
1184 if n == 1:
1185 name1 = location.LName(node.iter_names[0])
1186 elif n == 2:
1187 i_name = location.LName(node.iter_names[0])
1188 name1 = location.LName(node.iter_names[1])
1189 else:
1190 e_die_status(
1191 2,
1192 'Stdin iteration expects at most 2 loop variables',
1193 node.keyword)
1194 else:
1195 raise error.TypeErr(
1196 val, 'for loop expected List, Dict, Range, or Stdin',
1197 node.keyword)
1198
1199 else:
1200 assert iter_list is not None, iter_list
1201
1202 #log('iter list %s', iter_list)
1203 it2 = val_ops.ArrayIter(iter_list)
1204
1205 if n == 1:
1206 name1 = location.LName(node.iter_names[0])
1207 elif n == 2:
1208 i_name = location.LName(node.iter_names[0])
1209 name1 = location.LName(node.iter_names[1])
1210 else:
1211 # This is similar to a parse error
1212 e_die_status(
1213 2, 'Argv iteration expects at most 2 loop variables',
1214 node.keyword)
1215
1216 status = 0 # in case we loop zero times
1217 with ctx_LoopLevel(self):
1218 while True:
1219 first = it2.FirstValue()
1220 #log('first %s', first)
1221 if first is None: # for StdinIterator
1222 #log('first is None')
1223 break
1224
1225 if first.tag() == value_e.Interrupted:
1226 self.RunPendingTraps()
1227 #log('Done running traps')
1228 continue
1229
1230 self.mem.SetLocalName(name1, first)
1231 if name2:
1232 self.mem.SetLocalName(name2, it2.SecondValue())
1233 if i_name:
1234 self.mem.SetLocalName(i_name, num.ToBig(it2.Index()))
1235
1236 # increment index before handling continue, etc.
1237 it2.Next()
1238
1239 try:
1240 status = self._Execute(node.body) # last one wins
1241 except vm.IntControlFlow as e:
1242 status = 0
1243 action = e.HandleLoop()
1244 if action == flow_e.Break:
1245 break
1246 elif action == flow_e.Raise:
1247 raise
1248
1249 return status
1250
1251 def _DoForExpr(self, node):
1252 # type: (command.ForExpr) -> int
1253
1254 status = 0
1255
1256 init = node.init
1257 for_cond = node.cond
1258 body = node.body
1259 update = node.update
1260
1261 self.arith_ev.Eval(init)
1262 with ctx_LoopLevel(self):
1263 while True:
1264 # We only accept integers as conditions
1265 cond_int = self.arith_ev.EvalToBigInt(for_cond)
1266 if mops.Equal(cond_int, mops.ZERO): # false
1267 break
1268
1269 try:
1270 status = self._Execute(body)
1271 except vm.IntControlFlow as e:
1272 status = 0
1273 action = e.HandleLoop()
1274 if action == flow_e.Break:
1275 break
1276 elif action == flow_e.Raise:
1277 raise
1278
1279 self.arith_ev.Eval(update)
1280
1281 return status
1282
1283 def _DoShFunction(self, node):
1284 # type: (command.ShFunction) -> None
1285 if self.procs.Get(node.name) and not self.exec_opts.redefine_proc_func():
1286 e_die(
1287 "Function %s was already defined (redefine_proc_func)" %
1288 node.name, node.name_tok)
1289 sh_func = value.Proc(node.name, node.name_tok, proc_sig.Open, node.body, None, True)
1290 self.procs.SetShFunc(node.name, sh_func)
1291
1292 def _DoProc(self, node):
1293 # type: (Proc) -> None
1294 proc_name = lexer.TokenVal(node.name)
1295 if self.procs.Get(proc_name) and not self.exec_opts.redefine_proc_func():
1296 e_die(
1297 "Proc %s was already defined (redefine_proc_func)" % proc_name,
1298 node.name)
1299
1300 if node.sig.tag() == proc_sig_e.Closed:
1301 sig = cast(proc_sig.Closed, node.sig)
1302 proc_defaults = func_proc.EvalProcDefaults(self.expr_ev, sig)
1303 else:
1304 proc_defaults = None
1305
1306 # no dynamic scope
1307 proc = value.Proc(proc_name, node.name, node.sig, node.body, proc_defaults, False)
1308 self.procs.SetProc(proc_name, proc)
1309
1310 def _DoFunc(self, node):
1311 # type: (Func) -> None
1312 name = lexer.TokenVal(node.name)
1313 lval = location.LName(name)
1314
1315 # Check that we haven't already defined a function
1316 cell = self.mem.GetCell(name, scope_e.LocalOnly)
1317 if cell and cell.val.tag() == value_e.Func:
1318 if self.exec_opts.redefine_proc_func():
1319 cell.readonly = False # Ensure we can unset the value
1320 did_unset = self.mem.Unset(lval, scope_e.LocalOnly)
1321 assert did_unset, name
1322 else:
1323 e_die(
1324 "Func %s was already defined (redefine_proc_func)" % name,
1325 node.name)
1326
1327 pos_defaults, named_defaults = func_proc.EvalFuncDefaults(
1328 self.expr_ev, node)
1329 func_val = value.Func(name, node, pos_defaults, named_defaults, None)
1330
1331 self.mem.SetNamed(lval,
1332 func_val,
1333 scope_e.LocalOnly,
1334 flags=state.SetReadOnly)
1335
1336 def _DoIf(self, node):
1337 # type: (command.If) -> int
1338 status = -1
1339
1340 done = False
1341 for if_arm in node.arms:
1342 b = self._EvalCondition(if_arm.cond, if_arm.keyword)
1343 if b:
1344 status = self._ExecuteList(if_arm.action)
1345 done = True
1346 break
1347
1348 if not done and node.else_action is not None:
1349 status = self._ExecuteList(node.else_action)
1350
1351 assert status != -1, 'Should have been initialized'
1352 return status
1353
1354 def _DoCase(self, node):
1355 # type: (command.Case) -> int
1356
1357 to_match = self._EvalCaseArg(node.to_match, node.case_kw)
1358 fnmatch_flags = FNM_CASEFOLD if self.exec_opts.nocasematch() else 0
1359
1360 status = 0 # If there are no arms, it should be zero?
1361
1362 done = False # Should we try the next arm?
1363
1364 # For &; terminator - not just case fallthrough, but IGNORE the condition!
1365 ignore_next_cond = False
1366
1367 for case_arm in node.arms:
1368 with tagswitch(case_arm.pattern) as case:
1369 if case(pat_e.Words):
1370 if to_match.tag() != value_e.Str:
1371 continue # A non-string `to_match` will never match a pat.Words
1372 to_match_str = cast(value.Str, to_match)
1373
1374 pat_words = cast(pat.Words, case_arm.pattern)
1375
1376 this_arm_matches = False
1377 if ignore_next_cond: # Special handling for ;&
1378 this_arm_matches = True
1379 ignore_next_cond = False
1380 else:
1381 for pat_word in pat_words.words:
1382 word_val = self.word_ev.EvalWordToString(
1383 pat_word, word_eval.QUOTE_FNMATCH)
1384
1385 if libc.fnmatch(word_val.s, to_match_str.s,
1386 fnmatch_flags):
1387 this_arm_matches = True
1388 break # Stop at first pattern
1389
1390 if this_arm_matches:
1391 status = self._ExecuteList(case_arm.action)
1392 done = True
1393
1394 # ;& and ;;& only apply to shell-style case
1395 if case_arm.right:
1396 id_ = case_arm.right.id
1397 if id_ == Id.Op_SemiAmp:
1398 # very weird semantic
1399 ignore_next_cond = True
1400 done = False
1401 elif id_ == Id.Op_DSemiAmp:
1402 # Keep going until next pattern
1403 done = False
1404
1405 elif case(pat_e.YshExprs):
1406 pat_exprs = cast(pat.YshExprs, case_arm.pattern)
1407
1408 for pat_expr in pat_exprs.exprs:
1409 expr_val = self.expr_ev.EvalExpr(
1410 pat_expr, case_arm.left)
1411
1412 if val_ops.ExactlyEqual(expr_val, to_match,
1413 case_arm.left):
1414 status = self._ExecuteList(case_arm.action)
1415 done = True
1416 break
1417
1418 elif case(pat_e.Eggex):
1419 eggex = cast(Eggex, case_arm.pattern)
1420 eggex_val = self.expr_ev.EvalEggex(eggex)
1421
1422 if val_ops.MatchRegex(to_match, eggex_val, self.mem):
1423 status = self._ExecuteList(case_arm.action)
1424 done = True
1425 break
1426
1427 elif case(pat_e.Else):
1428 status = self._ExecuteList(case_arm.action)
1429 done = True
1430 break
1431
1432 else:
1433 raise AssertionError()
1434
1435 if done: # first match wins
1436 break
1437
1438 return status
1439
1440 def _DoTimeBlock(self, node):
1441 # type: (command.TimeBlock) -> int
1442 # TODO:
1443 # - When do we need RUSAGE_CHILDREN?
1444 # - Respect TIMEFORMAT environment variable.
1445 # "If this variable is not set, Bash acts as if it had the value"
1446 # $'\nreal\t%3lR\nuser\t%3lU\nsys\t%3lS'
1447 # "A trailing newline is added when the format string is displayed."
1448
1449 s_real, s_user, s_sys = pyos.Time()
1450 status = self._Execute(node.pipeline)
1451 e_real, e_user, e_sys = pyos.Time()
1452 # note: mycpp doesn't support %.3f
1453 libc.print_time(e_real - s_real, e_user - s_user, e_sys - s_sys)
1454
1455 return status
1456
1457 def _DoRedirect(self, node, cmd_st):
1458 # type: (command.Redirect, CommandStatus) -> int
1459
1460 status = 0
1461 redirects = [] # type: List[RedirValue]
1462
1463 try:
1464 for redir in node.redirects:
1465 redirects.append(self._EvalRedirect(redir))
1466 except error.RedirectEval as e:
1467 self.errfmt.PrettyPrintError(e)
1468 redirects = None
1469 except error.FailGlob as e: # e.g. echo hi > foo-*
1470 if not e.HasLocation():
1471 e.location = self.mem.GetFallbackLocation()
1472 self.errfmt.PrettyPrintError(e, prefix='failglob: ')
1473 redirects = None
1474
1475 if redirects is None:
1476 # Error evaluating redirect words
1477 status = 1
1478
1479 # Translation fix: redirect I/O errors may happen in a C++
1480 # destructor ~vm::ctx_Redirect, which means they must be signaled
1481 # by out params, not exceptions.
1482 io_errors = [] # type: List[error.IOError_OSError]
1483
1484 # If we evaluated redirects, apply/push them
1485 if status == 0:
1486 self.shell_ex.PushRedirects(redirects, io_errors)
1487 if len(io_errors):
1488 # core/process.py prints cryptic errors, so we repeat them
1489 # here. e.g. Bad File Descriptor
1490 self.errfmt.PrintMessage(
1491 'I/O error applying redirect: %s' %
1492 pyutil.strerror(io_errors[0]),
1493 self.mem.GetFallbackLocation())
1494 status = 1
1495
1496 # If we applied redirects successfully, run the command_t, and pop
1497 # them.
1498 if status == 0:
1499 with vm.ctx_Redirect(self.shell_ex, len(redirects), io_errors):
1500 status = self._Execute(node.child)
1501 if len(io_errors):
1502 # It would be better to point to the right redirect
1503 # operator, but we don't track it specifically
1504 e_die("Fatal error popping redirect: %s" %
1505 pyutil.strerror(io_errors[0]))
1506
1507 return status
1508
1509 def _Dispatch(self, node, cmd_st):
1510 # type: (command_t, CommandStatus) -> int
1511 """Switch on the command_t variants and execute them."""
1512
1513 # If we call RunCommandSub in a recursive call to the executor, this will
1514 # be set true (if strict_errexit is false). But it only lasts for one
1515 # command.
1516 probe('cmd_eval', '_Dispatch', node.tag())
1517 self.check_command_sub_status = False
1518
1519 UP_node = node
1520 with tagswitch(node) as case:
1521 if case(command_e.Simple): # LEAF command
1522 node = cast(command.Simple, UP_node)
1523
1524 # for $LINENO, e.g. PS4='+$SOURCE_NAME:$LINENO:'
1525 # Note that for '> $LINENO' the location token is set in _EvalRedirect.
1526 # TODO: blame_tok should always be set.
1527 if node.blame_tok is not None:
1528 self.mem.SetTokenForLine(node.blame_tok)
1529
1530 self._MaybeRunDebugTrap()
1531 cmd_st.check_errexit = True
1532 status = self._DoSimple(node, cmd_st)
1533
1534 elif case(command_e.ExpandedAlias):
1535 node = cast(command.ExpandedAlias, UP_node)
1536 status = self._DoExpandedAlias(node)
1537
1538 elif case(command_e.Sentence):
1539 node = cast(command.Sentence, UP_node)
1540
1541 # Don't check_errexit since this isn't a leaf command
1542 if node.terminator.id == Id.Op_Semi:
1543 status = self._Execute(node.child)
1544 else:
1545 status = self.shell_ex.RunBackgroundJob(node.child)
1546
1547 elif case(command_e.Redirect):
1548 node = cast(command.Redirect, UP_node)
1549
1550 # set -e affects redirect error, like mksh and bash 5.2, but unlike
1551 # dash/ash
1552 cmd_st.check_errexit = True
1553 status = self._DoRedirect(node, cmd_st)
1554
1555 elif case(command_e.Pipeline):
1556 node = cast(command.Pipeline, UP_node)
1557 status = self._DoPipeline(node, cmd_st)
1558
1559 elif case(command_e.Subshell):
1560 node = cast(command.Subshell, UP_node)
1561
1562 # This is a leaf from the parent process POV
1563 cmd_st.check_errexit = True
1564 status = self.shell_ex.RunSubshell(node.child)
1565
1566 elif case(command_e.DBracket): # LEAF command
1567 node = cast(command.DBracket, UP_node)
1568
1569 self.mem.SetTokenForLine(node.left)
1570 self._MaybeRunDebugTrap()
1571
1572 self.tracer.PrintSourceCode(node.left, node.right, self.arena)
1573
1574 cmd_st.check_errexit = True
1575 cmd_st.show_code = True # this is a "leaf" for errors
1576 result = self.bool_ev.EvalB(node.expr)
1577 status = 0 if result else 1
1578
1579 elif case(command_e.DParen): # LEAF command
1580 node = cast(command.DParen, UP_node)
1581
1582 self.mem.SetTokenForLine(node.left)
1583 self._MaybeRunDebugTrap()
1584
1585 self.tracer.PrintSourceCode(node.left, node.right, self.arena)
1586
1587 cmd_st.check_errexit = True
1588 cmd_st.show_code = True # this is a "leaf" for errors
1589 i = self.arith_ev.EvalToBigInt(node.child)
1590 status = 1 if mops.Equal(i, mops.ZERO) else 0
1591
1592 elif case(command_e.ControlFlow): # LEAF command
1593 node = cast(command.ControlFlow, UP_node)
1594
1595 self.mem.SetTokenForLine(node.keyword)
1596 self._MaybeRunDebugTrap()
1597
1598 status = self._DoControlFlow(node)
1599
1600 elif case(command_e.VarDecl): # LEAF command
1601 node = cast(command.VarDecl, UP_node)
1602
1603 # Point to var name (bare assignment has no keyword)
1604 self.mem.SetTokenForLine(node.lhs[0].left)
1605 status = self._DoVarDecl(node)
1606
1607 elif case(command_e.Mutation): # LEAF command
1608 node = cast(command.Mutation, UP_node)
1609
1610 self.mem.SetTokenForLine(node.keyword) # point to setvar/set
1611 self._DoMutation(node)
1612 status = 0 # if no exception is thrown, it succeeds
1613
1614 elif case(command_e.ShAssignment): # LEAF command
1615 node = cast(command.ShAssignment, UP_node)
1616
1617 self.mem.SetTokenForLine(node.pairs[0].left)
1618 self._MaybeRunDebugTrap()
1619
1620 # Only unqualified assignment a=b
1621 status = self._DoShAssignment(node, cmd_st)
1622
1623 elif case(command_e.Expr): # YSH LEAF command
1624 node = cast(command.Expr, UP_node)
1625
1626 self.mem.SetTokenForLine(node.keyword)
1627 # YSH debug trap?
1628
1629 status = self._DoExpr(node)
1630
1631 elif case(command_e.Retval): # YSH LEAF command
1632 node = cast(command.Retval, UP_node)
1633
1634 self.mem.SetTokenForLine(node.keyword)
1635 # YSH debug trap? I think we don't want the debug trap in func
1636 # dialect, for speed?
1637
1638 val = self.expr_ev.EvalExpr(node.val, node.keyword)
1639 raise vm.ValueControlFlow(node.keyword, val)
1640
1641 # Note CommandList and DoGroup have no redirects, but BraceGroup does.
1642 # DoGroup has 'do' and 'done' spids for translation.
1643 elif case(command_e.CommandList):
1644 node = cast(command.CommandList, UP_node)
1645 status = self._ExecuteList(node.children)
1646
1647 elif case(command_e.DoGroup):
1648 node = cast(command.DoGroup, UP_node)
1649 status = self._ExecuteList(node.children)
1650
1651 elif case(command_e.BraceGroup):
1652 node = cast(BraceGroup, UP_node)
1653 status = self._ExecuteList(node.children)
1654
1655 elif case(command_e.AndOr):
1656 node = cast(command.AndOr, UP_node)
1657 status = self._DoAndOr(node, cmd_st)
1658
1659 elif case(command_e.WhileUntil):
1660 node = cast(command.WhileUntil, UP_node)
1661
1662 self.mem.SetTokenForLine(node.keyword)
1663 status = self._DoWhileUntil(node)
1664
1665 elif case(command_e.ForEach):
1666 node = cast(command.ForEach, UP_node)
1667
1668 self.mem.SetTokenForLine(node.keyword)
1669 status = self._DoForEach(node)
1670
1671 elif case(command_e.ForExpr):
1672 node = cast(command.ForExpr, UP_node)
1673
1674 self.mem.SetTokenForLine(node.keyword) # for x in $LINENO
1675 status = self._DoForExpr(node)
1676
1677 elif case(command_e.ShFunction):
1678 node = cast(command.ShFunction, UP_node)
1679 self._DoShFunction(node)
1680 status = 0
1681
1682 elif case(command_e.Proc):
1683 node = cast(Proc, UP_node)
1684 self._DoProc(node)
1685 status = 0
1686
1687 elif case(command_e.Func):
1688 node = cast(Func, UP_node)
1689
1690 # Needed for error, when the func is an existing variable name
1691 self.mem.SetTokenForLine(node.name)
1692
1693 self._DoFunc(node)
1694 status = 0
1695
1696 elif case(command_e.If):
1697 node = cast(command.If, UP_node)
1698
1699 # No SetTokenForLine() because
1700 # - $LINENO can't appear directly in 'if'
1701 # - 'if' doesn't directly cause errors
1702 # It will be taken care of by command.Simple, condition, etc.
1703 status = self._DoIf(node)
1704
1705 elif case(command_e.NoOp):
1706 status = 0 # make it true
1707
1708 elif case(command_e.Case):
1709 node = cast(command.Case, UP_node)
1710
1711 # Must set location for 'case $LINENO'
1712 self.mem.SetTokenForLine(node.case_kw)
1713 self._MaybeRunDebugTrap()
1714 status = self._DoCase(node)
1715
1716 elif case(command_e.TimeBlock):
1717 node = cast(command.TimeBlock, UP_node)
1718 status = self._DoTimeBlock(node)
1719
1720 else:
1721 raise NotImplementedError(node.tag())
1722
1723 # Return to caller. Note the only case that didn't set it was Pipeline,
1724 # which set cmd_st.pipe_status.
1725 return status
1726
1727 def RunPendingTraps(self):
1728 # type: () -> None
1729
1730 trap_nodes = self.trap_state.GetPendingTraps()
1731 if trap_nodes is not None:
1732 with state.ctx_Option(self.mutable_opts, [option_i._running_trap],
1733 True):
1734 for trap_node in trap_nodes:
1735 # Isolate the exit status.
1736 with state.ctx_Registers(self.mem):
1737 # Trace it. TODO: Show the trap kind too
1738 with dev.ctx_Tracer(self.tracer, 'trap', None):
1739 self._Execute(trap_node)
1740
1741 def _Execute(self, node):
1742 # type: (command_t) -> int
1743 """Call _Dispatch(), and performs the errexit check.
1744
1745 Also runs trap handlers.
1746 """
1747 # TODO: Do this in "leaf" nodes? SimpleCommand, DBracket, DParen should
1748 # call self.DoTick()? That will RunPendingTraps and check the Ctrl-C flag,
1749 # and maybe throw an exception.
1750 self.RunPendingTraps()
1751
1752 # We only need this somewhat hacky check in osh-cpp since python's runtime
1753 # handles SIGINT for us in osh.
1754 if mylib.CPP:
1755 if self.signal_safe.PollSigInt():
1756 raise KeyboardInterrupt()
1757
1758 # Manual GC point before every statement
1759 mylib.MaybeCollect()
1760
1761 # Optimization: These 2 records have rarely-used lists, so we don't pass
1762 # alloc_lists=True. We create them on demand.
1763 cmd_st = CommandStatus.CreateNull()
1764 if len(self.status_array_pool):
1765 # Optimized to avoid allocs
1766 process_sub_st = self.status_array_pool.pop()
1767 else:
1768 process_sub_st = StatusArray.CreateNull()
1769
1770 with vm.ctx_ProcessSub(self.shell_ex, process_sub_st): # for wait()
1771 try:
1772 status = self._Dispatch(node, cmd_st)
1773 except error.FailGlob as e:
1774 if not e.HasLocation(): # Last resort!
1775 e.location = self.mem.GetFallbackLocation()
1776 self.errfmt.PrettyPrintError(e, prefix='failglob: ')
1777 status = 1 # another redirect word eval error
1778 cmd_st.check_errexit = True # failglob + errexit
1779
1780 # Now we've waited for process subs
1781
1782 # If it was a real pipeline, compute status from ${PIPESTATUS[@]} aka
1783 # @_pipeline_status
1784 pipe_status = cmd_st.pipe_status
1785 # Note: bash/mksh set PIPESTATUS set even on non-pipelines. This
1786 # makes it annoying to check both _process_sub_status and
1787 # _pipeline_status
1788
1789 errexit_loc = loc.Missing # type: loc_t
1790 if pipe_status is not None:
1791 # Tricky: _DoPipeline sets cmt_st.pipe_status and returns -1
1792 # for a REAL pipeline (but not singleton pipelines)
1793 assert status == -1, (
1794 "Shouldn't have redir errors when PIPESTATUS (status = %d)" %
1795 status)
1796
1797 self.mem.SetPipeStatus(pipe_status)
1798
1799 if self.exec_opts.pipefail():
1800 # The status is that of the last command that is non-zero.
1801 status = 0
1802 for i, st in enumerate(pipe_status):
1803 if st != 0:
1804 status = st
1805 errexit_loc = cmd_st.pipe_locs[i]
1806 else:
1807 # The status is that of last command, period.
1808 status = pipe_status[-1]
1809
1810 if cmd_st.pipe_negated:
1811 status = 1 if status == 0 else 0
1812
1813 # Compute status from _process_sub_status
1814 if process_sub_st.codes is None:
1815 # Optimized to avoid allocs
1816 self.status_array_pool.append(process_sub_st)
1817 else:
1818 codes = process_sub_st.codes
1819 self.mem.SetProcessSubStatus(codes)
1820 if status == 0 and self.exec_opts.process_sub_fail():
1821 # Choose the LAST non-zero status, consistent with pipefail above.
1822 for i, st in enumerate(codes):
1823 if st != 0:
1824 status = st
1825 errexit_loc = process_sub_st.locs[i]
1826
1827 self.mem.SetLastStatus(status)
1828
1829 # NOTE: Bash says that 'set -e' checking is done after each 'pipeline'.
1830 # However, any bash construct can appear in a pipeline. So it's easier
1831 # just to put it at the end, instead of after every node.
1832 #
1833 # Possible exceptions:
1834 # - function def (however this always exits 0 anyway)
1835 # - assignment - its result should be the result of the RHS?
1836 # - e.g. arith sub, command sub? I don't want arith sub.
1837 # - ControlFlow: always raises, it has no status.
1838 if cmd_st.check_errexit:
1839 #log('cmd_st %s', cmd_st)
1840 self._CheckStatus(status, cmd_st, node, errexit_loc)
1841
1842 return status
1843
1844 def _ExecuteList(self, children):
1845 # type: (List[command_t]) -> int
1846 status = 0 # for empty list
1847 for child in children:
1848 # last status wins
1849 status = self._Execute(child)
1850 return status
1851
1852 def LastStatus(self):
1853 # type: () -> int
1854 """For main_loop.py to determine the exit code of the shell itself."""
1855 return self.mem.LastStatus()
1856
1857 def _NoForkLast(self, node):
1858 # type: (command_t) -> None
1859
1860 if 0:
1861 log('optimizing')
1862 node.PrettyPrint(sys.stderr)
1863 log('')
1864
1865 UP_node = node
1866 with tagswitch(node) as case:
1867 if case(command_e.Simple):
1868 node = cast(command.Simple, UP_node)
1869 node.do_fork = False
1870 if 0:
1871 log('Simple optimized')
1872
1873 elif case(command_e.Pipeline):
1874 node = cast(command.Pipeline, UP_node)
1875 if node.negated is None:
1876 #log ('pipe')
1877 self._NoForkLast(node.children[-1])
1878
1879 elif case(command_e.Sentence):
1880 node = cast(command.Sentence, UP_node)
1881 self._NoForkLast(node.child)
1882
1883 elif case(command_e.CommandList):
1884 # Subshells start with CommandList, even if there's only one.
1885 node = cast(command.CommandList, UP_node)
1886 self._NoForkLast(node.children[-1])
1887
1888 elif case(command_e.BraceGroup):
1889 # TODO: What about redirects?
1890 node = cast(BraceGroup, UP_node)
1891 self._NoForkLast(node.children[-1])
1892
1893 def _RemoveSubshells(self, node):
1894 # type: (command_t) -> command_t
1895 """Eliminate redundant subshells like ( echo hi ) | wc -l etc.
1896
1897 This is ONLY called at the top level of ExecuteAndCatch() - it wouldn't
1898 be correct otherwise.
1899 """
1900 UP_node = node
1901 with tagswitch(node) as case:
1902 if case(command_e.Subshell):
1903 node = cast(command.Subshell, UP_node)
1904 # Optimize ( ( date ) ) etc.
1905 return self._RemoveSubshells(node.child)
1906 return node
1907
1908 def ExecuteAndCatch(self, node, cmd_flags=0):
1909 # type: (command_t, int) -> Tuple[bool, bool]
1910 """Execute a subprogram, handling vm.IntControlFlow and fatal exceptions.
1911
1912 Args:
1913 node: LST subtree
1914 optimize: Whether to exec the last process rather than fork/exec
1915
1916 Returns:
1917 TODO: use enum 'why' instead of the 2 booleans
1918
1919 Used by
1920 - main_loop.py.
1921 - SubProgramThunk for pipelines, subshell, command sub, process sub
1922 - TODO: Signals besides EXIT trap
1923
1924 Note: To do what optimize does, dash has EV_EXIT flag and yash has a
1925 finally_exit boolean. We use a different algorithm.
1926 """
1927 if cmd_flags & Optimize:
1928 node = self._RemoveSubshells(node)
1929 self._NoForkLast(node) # turn the last ones into exec
1930
1931 if 0:
1932 log('after opt:')
1933 node.PrettyPrint()
1934 log('')
1935
1936 is_return = False
1937 is_fatal = False
1938 is_errexit = False
1939
1940 err = None # type: error.FatalRuntime
1941 status = -1 # uninitialized
1942
1943 try:
1944 options = [] # type: List[int]
1945 if cmd_flags & NoDebugTrap:
1946 options.append(option_i._no_debug_trap)
1947 if cmd_flags & NoErrTrap:
1948 options.append(option_i._no_err_trap)
1949 with state.ctx_Option(self.mutable_opts, options, True):
1950 status = self._Execute(node)
1951 except vm.IntControlFlow as e:
1952 if cmd_flags & RaiseControlFlow:
1953 raise # 'eval break' and 'source return.sh', etc.
1954 else:
1955 # Return at top level is OK, unlike in bash.
1956 if e.IsReturn():
1957 is_return = True
1958 status = e.StatusCode()
1959 else:
1960 # TODO: This error message is invalid. Can also happen in eval.
1961 # We need a flag.
1962
1963 # Invalid control flow
1964 self.errfmt.Print_(
1965 "Loop and control flow can't be in different processes",
1966 blame_loc=e.token)
1967 is_fatal = True
1968 # All shells exit 0 here. It could be hidden behind
1969 # strict_control_flow if the incompatibility causes problems.
1970 status = 1
1971 except error.Parse as e:
1972 self.dumper.MaybeRecord(self, e) # Do this before unwinding stack
1973 raise
1974 except error.ErrExit as e:
1975 err = e
1976 is_errexit = True
1977 except error.FatalRuntime as e:
1978 err = e
1979
1980 if err:
1981 status = err.ExitStatus()
1982
1983 is_fatal = True
1984 # Do this before unwinding stack
1985 self.dumper.MaybeRecord(self, err)
1986
1987 if not err.HasLocation(): # Last resort!
1988 #log('Missing location')
1989 err.location = self.mem.GetFallbackLocation()
1990 #log('%s', err.location)
1991
1992 if is_errexit:
1993 if self.exec_opts.verbose_errexit():
1994 self.errfmt.PrintErrExit(cast(error.ErrExit, err),
1995 posix.getpid())
1996 else:
1997 self.errfmt.PrettyPrintError(err, prefix='fatal: ')
1998
1999 assert status >= 0, 'Should have been initialized'
2000
2001 # Problem: We have no idea here if a SUBSHELL (or pipeline comment) already
2002 # created a crash dump. So we get 2 or more of them.
2003 self.dumper.MaybeDump(status)
2004
2005 self.mem.SetLastStatus(status)
2006 return is_return, is_fatal
2007
2008 def EvalCommand(self, block):
2009 # type: (command_t) -> int
2010 """For builtins to evaluate command args.
2011
2012 e.g. cd /tmp (x)
2013 """
2014 status = 0
2015 try:
2016 status = self._Execute(block) # can raise FatalRuntimeError, etc.
2017 except vm.IntControlFlow as e: # A block is more like a function.
2018 # return in a block
2019 if e.IsReturn():
2020 status = e.StatusCode()
2021 else:
2022 e_die('Unexpected control flow in block', e.token)
2023
2024 return status
2025
2026 def MaybeRunExitTrap(self, mut_status):
2027 # type: (IntParamBox) -> None
2028 """If an EXIT trap handler exists, run it.
2029
2030 Only mutates the status if 'return' or 'exit'. This is odd behavior, but
2031 all bash/dash/mksh seem to agree on it. See cases in
2032 builtin-trap.test.sh.
2033
2034 Note: if we could easily modulo -1 % 256 == 255 here, then we could get rid
2035 of this awkward interface. But that's true in Python and not C!
2036
2037 Could use i & (n-1) == i & 255 because we have a power of 2.
2038 https://stackoverflow.com/questions/14997165/fastest-way-to-get-a-positive-modulo-in-c-c
2039 """
2040 node = self.trap_state.GetHook('EXIT') # type: command_t
2041 if node:
2042 # NOTE: Don't set option_i._running_trap, because that's for
2043 # RunPendingTraps() in the MAIN LOOP
2044 with dev.ctx_Tracer(self.tracer, 'trap EXIT', None):
2045 try:
2046 is_return, is_fatal = self.ExecuteAndCatch(node)
2047 except util.UserExit as e: # explicit exit
2048 mut_status.i = e.status
2049 return
2050 if is_return: # explicit 'return' in the trap handler!
2051 mut_status.i = self.LastStatus()
2052
2053 def _MaybeRunDebugTrap(self):
2054 # type: () -> None
2055 """Run user-specified DEBUG code before certain commands."""
2056 node = self.trap_state.GetHook('DEBUG') # type: command_t
2057 if node is None:
2058 return
2059
2060 # Fix lastpipe / job control / DEBUG trap interaction
2061 if self.exec_opts._no_debug_trap():
2062 return
2063
2064 # Don't run recursively run traps, etc.
2065 if not self.mem.ShouldRunDebugTrap():
2066 return
2067
2068 # NOTE: Don't set option_i._running_trap, because that's for
2069 # RunPendingTraps() in the MAIN LOOP
2070
2071 with dev.ctx_Tracer(self.tracer, 'trap DEBUG', None):
2072 with state.ctx_Registers(self.mem): # prevent setting $? etc.
2073 # for SetTokenForLine $LINENO
2074 with state.ctx_DebugTrap(self.mem):
2075 # Don't catch util.UserExit, etc.
2076 self._Execute(node)
2077
2078 def _MaybeRunErrTrap(self):
2079 # type: () -> None
2080 """
2081 Run user-specified ERR code after checking the status of certain
2082 commands (pipelines)
2083 """
2084 node = self.trap_state.GetHook('ERR') # type: command_t
2085 if node is None:
2086 return
2087
2088 # ERR trap is only run for a whole pipeline, not its parts
2089 if self.exec_opts._no_err_trap():
2090 return
2091
2092 # Prevent infinite recursion
2093 if self.mem.running_err_trap:
2094 return
2095
2096 # "disabled errexit" rule
2097 if self.mutable_opts.ErrExitIsDisabled():
2098 return
2099
2100 # bash rule - affected by set -o errtrace
2101 if self.mem.InsideFunction():
2102 return
2103
2104 # NOTE: Don't set option_i._running_trap, because that's for
2105 # RunPendingTraps() in the MAIN LOOP
2106
2107 with dev.ctx_Tracer(self.tracer, 'trap ERR', None):
2108 #with state.ctx_Registers(self.mem): # prevent setting $? etc.
2109 with state.ctx_ErrTrap(self.mem):
2110 self._Execute(node)
2111
2112 def RunProc(self, proc, cmd_val):
2113 # type: (value.Proc, cmd_value.Argv) -> int
2114 """Run procs aka "shell functions".
2115
2116 For SimpleCommand and registered completion hooks.
2117 """
2118 sig = proc.sig
2119 if sig.tag() == proc_sig_e.Closed:
2120 # We're binding named params. User should use @rest. No 'shift'.
2121 proc_argv = [] # type: List[str]
2122 else:
2123 proc_argv = cmd_val.argv[1:]
2124
2125 # Hm this sets "$@". TODO: Set ARGV only
2126 with state.ctx_ProcCall(self.mem, self.mutable_opts, proc, proc_argv):
2127 func_proc.BindProcArgs(proc, cmd_val, self.mem)
2128
2129 # Redirects still valid for functions.
2130 # Here doc causes a pipe and Process(SubProgramThunk).
2131 try:
2132 status = self._Execute(proc.body)
2133 except vm.IntControlFlow as e:
2134 if e.IsReturn():
2135 status = e.StatusCode()
2136 else:
2137 # break/continue used in the wrong place.
2138 e_die(
2139 'Unexpected %r (in proc call)' %
2140 lexer.TokenVal(e.token), e.token)
2141 except error.FatalRuntime as e:
2142 # Dump the stack before unwinding it
2143 self.dumper.MaybeRecord(self, e)
2144 raise
2145
2146 return status
2147
2148 def RunFuncForCompletion(self, proc, argv):
2149 # type: (value.Proc, List[str]) -> int
2150 """
2151 Args:
2152 argv: $1 $2 $3 ... not including $0
2153 """
2154 cmd_val = MakeBuiltinArgv(argv)
2155
2156 # TODO: Change this to run YSH procs and funcs too
2157 try:
2158 status = self.RunProc(proc, cmd_val)
2159 except error.FatalRuntime as e:
2160 self.errfmt.PrettyPrintError(e)
2161 status = e.ExitStatus()
2162 except vm.IntControlFlow as e:
2163 # shouldn't be able to exit the shell from a completion hook!
2164 # TODO: Avoid overwriting the prompt!
2165 self.errfmt.Print_('Attempted to exit from completion hook.',
2166 blame_loc=e.token)
2167
2168 status = 1
2169 # NOTE: (IOError, OSError) are caught in completion.py:ReadlineCallback
2170 return status
2171
2172
2173# vim: sw=4