[main] Support mutiple --eval flags

Author: Andy C

core/shell.py

@@ -959,11 +959,10 @@ def Main(
     # (It could be used for the headless shell.  Although terminals have a bootstrap process.)
     # Note that --eval
 
-    # TODO: process these in a loop, in order
-    if flag.eval is not None:
+    for path, is_pure in attrs.eval_flags:
+        # TODO: respect is_pure
         try:
-            ok = main_loop.EvalFile(flag.eval, fd_state, parse_ctx, cmd_ev,
-                                    lang)
+            ok = main_loop.EvalFile(path, fd_state, parse_ctx, cmd_ev, lang)
         except util.UserExit as e:
             # Doesn't seem like we need this, and verbose_errexit isn't the right option
             #if exec_opts.verbose_errexit():
@@ -972,10 +971,6 @@ def Main(
         if not ok:  # parse error or I/O error was already printed
             return 1
 
-    if flag.eval_pure is not None:
-        # TODO: Same as above, except we restrict
-        raise AssertionError('pure')
-
     #
     # Is the shell interactive?
     #

cpp/frontend_flag_spec.cc

@@ -123,7 +123,10 @@ void _CreateActions(Action_c* in, Dict<BigStr*, args::_Action*>* out) {
       }
       action = a;
     } break;
-    }
+    case ActionType_c::AppendEvalFlag:
+      action = Alloc<args::AppendEvalFlag>(StrFromC(p->name));
+      break;
+    }  // switch
 
     if (action) {
       out->set(StrFromC(p->key), action);

cpp/frontend_flag_spec.h

@@ -47,6 +47,8 @@ enum class ActionType_c {
   SetNamedOption_shopt,  // no args, valid
   SetAction,             // name
   SetNamedAction,        // no args, valid
+
+  AppendEvalFlag,  // no args, valid
 };
 
 // TODO: Figure out the difference between name and key

frontend/args.py

@@ -54,16 +54,15 @@
 from __future__ import print_function
 
 from _devbuild.gen.syntax_asdl import loc, loc_t, CompoundWord
-from _devbuild.gen.value_asdl import (value, value_e, value_t)
+from _devbuild.gen.value_asdl import (value, value_t)
 
 from core.error import e_usage
-#from frontend import match
 from mycpp import mops
-from mycpp.mylib import log, tagswitch, iteritems
+from mycpp.mylib import log, iteritems
 
 _ = log
 
-from typing import (cast, Tuple, Optional, Dict, List, Any, TYPE_CHECKING)
+from typing import (Tuple, Optional, Dict, List, TYPE_CHECKING)
 if TYPE_CHECKING:
     from frontend import flag_spec
     OptChange = Tuple[str, bool]
@@ -87,9 +86,18 @@ def __init__(self, defaults):
         # New style
         self.attrs = {}  # type: Dict[str, value_t]
 
-        self.opt_changes = []  # type: List[OptChange]  # -o errexit +o nounset
-        self.shopt_changes = [
-        ]  # type: List[OptChange]  # -O nullglob +O nullglob
+        # -o errexit +o nounset
+        self.opt_changes = []  # type: List[OptChange]
+
+        # -O nullglob +O nullglob
+        self.shopt_changes = []  # type: List[OptChange]
+
+        # Special case for --eval and --eval-pure?  For bin/osh.  It seems OK
+        # to have one now.  The pool tells us if it was pure or not.
+        # Note: MAIN_SPEC is different than SET_SPEC, so set --eval does
+        # nothing.
+        self.eval_flags = []  # type: List[Tuple[str, bool]]
+
         self.show_options = False  # 'set -o' without an argument
         self.actions = []  # type: List[str]  # for compgen -A
         self.saw_double_dash = False  # for set --
@@ -112,24 +120,6 @@ def Set(self, name, val):
 
         self.attrs[name] = val
 
-        if 0:
-            # Backward compatibility!
-            with tagswitch(val) as case:
-                if case(value_e.Undef):
-                    py_val = None  # type: Any
-                elif case(value_e.Bool):
-                    py_val = cast(value.Bool, val).b
-                elif case(value_e.Int):
-                    py_val = cast(value.Int, val).i
-                elif case(value_e.Float):
-                    py_val = cast(value.Float, val).f
-                elif case(value_e.Str):
-                    py_val = cast(value.Str, val).s
-                else:
-                    raise AssertionError(val)
-
-            setattr(self, name, py_val)
-
     def __repr__(self):
         # type: () -> str
         return '<_Attributes %s>' % self.__dict__
@@ -266,6 +256,31 @@ def OnMatch(self, attached_arg, arg_r, out):
         raise NotImplementedError()
 
 
+class AppendEvalFlag(_Action):
+
+    def __init__(self, name):
+        # type: (str) -> None
+        _Action.__init__(self)
+        self.name = name
+        self.is_pure = (name == 'eval-pure')
+
+    def OnMatch(self, attached_arg, arg_r, out):
+        # type: (Optional[str], Reader, _Attributes) -> bool
+        """Called when the flag matches."""
+
+        assert attached_arg is None, attached_arg
+
+        arg_r.Next()
+        arg = arg_r.Peek()
+        if arg is None:
+            e_usage('expected argument to %r' % ('--' + self.name),
+                    arg_r.Location())
+
+        # is_pure is True for --eval-pure
+        out.eval_flags.append((arg, self.is_pure))
+        return False
+
+
 class _ArgAction(_Action):
 
     def __init__(self, name, quit_parsing_flags, valid=None):

frontend/flag_def.py

@@ -243,6 +243,9 @@ def _AddShellOptions(spec):
 
 MAIN_SPEC = FlagSpecAndMore('main')
 
+# Special case: Define --eval and --eval-pure
+MAIN_SPEC.EvalFlags()
+
 MAIN_SPEC.ShortFlag('-c', args.String,
                     quit_parsing_flags=True)  # command string
 MAIN_SPEC.LongFlag('--help')
@@ -265,13 +268,6 @@ def _AddShellOptions(spec):
 MAIN_SPEC.LongFlag('--login')  # login - currently no-op
 MAIN_SPEC.LongFlag('--headless')  # accepts ECMD, etc.
 
-# --eval is not processed in interactive mode
-# TODO: This should be a list
-MAIN_SPEC.LongFlag('--eval', args.String)
-
-# TODO: relative order of --eval and --eval-pure should be preserved
-MAIN_SPEC.LongFlag('--eval-pure', args.String)
-
 # TODO: -h too
 # the output format when passing -n
 MAIN_SPEC.LongFlag('--ast-format',

frontend/flag_gen.py

@@ -128,6 +128,10 @@ def _WriteActions(f, var_name, actions, counter):
         elif isinstance(action, args.SetNamedAction):
             action_type = 'SetNamedAction'
 
+        elif isinstance(action, args.AppendEvalFlag):
+            action_type = 'AppendEvalFlag'
+            name = action.name
+
         else:
             raise AssertionError(action)
 

frontend/flag_spec.py

@@ -266,6 +266,11 @@ def InitShopt(self):
         self.actions_short['O'] = args.SetNamedOption(shopt=True)  # -O and +O
         self.plus_flags.append('O')
 
+    def EvalFlags(self):
+        # type: () -> None
+        self.actions_long['eval'] = args.AppendEvalFlag('eval')
+        self.actions_long['eval-pure'] = args.AppendEvalFlag('eval-pure')
+
     def ShortFlag(self,
                   short_name,
                   arg_type=None,

prebuilt/asdl/runtime.mycpp.cc

@@ -37,14 +37,12 @@ GLOBAL_STR(S_rpo, "\u001b[37m");
 GLOBAL_STR(S_sCc, "\u001b[4m");
 GLOBAL_STR(S_woy, "\u001b[7m");
 GLOBAL_STR(S_yfw, " ");
-GLOBAL_STR(S_ctw, "%s%s%s");
 GLOBAL_STR(S_Clt, "&");
 GLOBAL_STR(S_usD, "&");
 GLOBAL_STR(S_dyr, ">");
 GLOBAL_STR(S_Dcl, "<");
 GLOBAL_STR(S_ijB, "(");
 GLOBAL_STR(S_hxb, ")");
-GLOBAL_STR(S_Cpi, "...0x%s");
 GLOBAL_STR(S_fyj, ":");
 GLOBAL_STR(S_eox, "<");
 GLOBAL_STR(S_jye, ">");
@@ -54,9 +52,7 @@ GLOBAL_STR(S_Eax, "[");
 GLOBAL_STR(S_xmu, "[]");
 GLOBAL_STR(S_pcD, "]");
 GLOBAL_STR(S_tci, "_");
-GLOBAL_STR(S_bme, "___ DOC COUNT %d");
 GLOBAL_STR(S_gfw, "___ GC: after printing");
-GLOBAL_STR(S_ray, "___ HNODE COUNT %d");
 
 namespace ansi {  // declare
 

prebuilt/core/error.mycpp.cc

@@ -12,14 +12,13 @@ namespace runtime {  // forward declare
 namespace num {  // forward declare
 }
 
-GLOBAL_STR(S_BEl, " (line %d, offset %d-%d: %r)");
-GLOBAL_STR(S_xFg, "%s, got %s");
 GLOBAL_STR(S_ijB, "(");
 GLOBAL_STR(S_hxb, ")");
 GLOBAL_STR(S_gFh, "F");
 GLOBAL_STR(S_cor, "T");
 GLOBAL_STR(S_tci, "_");
 GLOBAL_STR(S_gFE, "code");
+GLOBAL_STR(S_xho, "failglob: ");
 GLOBAL_STR(S_pBg, "message");
 
 namespace runtime {  // declare
@@ -124,7 +123,13 @@ Usage::Usage(BigStr* msg, syntax_asdl::loc_t* location) : ::error::_ErrorWithLoc
 Parse::Parse(BigStr* msg, syntax_asdl::loc_t* location) : ::error::_ErrorWithLocation(msg, location) {
 }
 
-FailGlob::FailGlob(BigStr* msg, syntax_asdl::loc_t* location) : ::error::_ErrorWithLocation(msg, location) {
+WordFailure::WordFailure(BigStr* msg, syntax_asdl::loc_t* location) : ::error::_ErrorWithLocation(msg, location) {
+}
+
+FailGlob::FailGlob(BigStr* msg, syntax_asdl::loc_t* location) : ::error::WordFailure(str_concat(S_xho, msg), location) {
+}
+
+VarSubFailure::VarSubFailure(BigStr* msg, syntax_asdl::loc_t* location) : ::error::WordFailure(msg, location) {
 }
 
 RedirectEval::RedirectEval(BigStr* msg, syntax_asdl::loc_t* location) : ::error::_ErrorWithLocation(msg, location) {

prebuilt/core/error.mycpp.h

@@ -18,7 +18,9 @@ namespace error {  // forward declare
   class _ErrorWithLocation;
   class Usage;
   class Parse;
+  class WordFailure;
   class FailGlob;
+  class VarSubFailure;
   class RedirectEval;
   class FatalRuntime;
   class Strict;
@@ -86,21 +88,51 @@ class Parse : public ::error::_ErrorWithLocation {
   DISALLOW_COPY_AND_ASSIGN(Parse)
 };
 
-class FailGlob : public ::error::_ErrorWithLocation {
+class WordFailure : public ::error::_ErrorWithLocation {
  public:
-  FailGlob(BigStr* msg, syntax_asdl::loc_t* location);
+  WordFailure(BigStr* msg, syntax_asdl::loc_t* location);
 
   static constexpr uint32_t field_mask() {
     return ::error::_ErrorWithLocation::field_mask();
   }
 
+  static constexpr ObjHeader obj_header() {
+    return ObjHeader::ClassFixed(field_mask(), sizeof(WordFailure));
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(WordFailure)
+};
+
+class FailGlob : public ::error::WordFailure {
+ public:
+  FailGlob(BigStr* msg, syntax_asdl::loc_t* location);
+  
+  static constexpr uint32_t field_mask() {
+    return ::error::WordFailure::field_mask();
+  }
+
   static constexpr ObjHeader obj_header() {
     return ObjHeader::ClassFixed(field_mask(), sizeof(FailGlob));
   }
 
   DISALLOW_COPY_AND_ASSIGN(FailGlob)
 };
 
+class VarSubFailure : public ::error::WordFailure {
+ public:
+  VarSubFailure(BigStr* msg, syntax_asdl::loc_t* location);
+  
+  static constexpr uint32_t field_mask() {
+    return ::error::WordFailure::field_mask();
+  }
+
+  static constexpr ObjHeader obj_header() {
+    return ObjHeader::ClassFixed(field_mask(), sizeof(VarSubFailure));
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(VarSubFailure)
+};
+
 class RedirectEval : public ::error::_ErrorWithLocation {
  public:
   RedirectEval(BigStr* msg, syntax_asdl::loc_t* location);