Replace all usages of util.Enum with simple ADSL sum types.

oilshell · Feb 7, 2018 · f444dd76a7526a2eb468a372111542d5320befae · f444dd7
1 parent f7b22d7
commit f444dd76a7526a2eb468a372111542d5320befae
diff --git a/asdl/py_meta.py b/asdl/py_meta.py
@@ -121,6 +121,7 @@ def __init__(self, enum_id, name):
  # bool_arg_type_e.Undefined = bool_arg_type_e(1, 'Undefined')

  def __hash__(self):
+    # Could it be the integer self.enum_id?
    return hash(self.__class__.__name__ + self.name)

  def __repr__(self):
diff --git a/core/builtin.py b/core/builtin.py
@@ -31,11 +31,11 @@

 from core import args
 from core import lexer
-from osh.meta import runtime
 from core import util
 from core import state
 from core import word_compile

+from osh.meta import runtime
 from osh import lex

 from _devbuild.gen import osh_help  # generated file
@@ -44,89 +44,72 @@
 scope_e = runtime.scope_e
 span_e = runtime.span_e
 var_flags_e = runtime.var_flags_e
+builtin_e = runtime.builtin_e
 log = util.log
 e_die = util.e_die

-
-# NOTE: NONE is a special value.
-
-EBuiltin = util.Enum('EBuiltin', """
-NONE READ ECHO SHIFT
-CD PUSHD POPD DIRS
-EXPORT UNSET SET SHOPT
-TRAP UMASK
-SOURCE DOT EVAL EXEC WAIT JOBS
-COMPLETE COMPGEN DEBUG_LINE
-TRUE FALSE
-COLON
-TEST BRACKET GETOPTS
-COMMAND TYPE HELP
-DECLARE TYPESET
-""".split())
-
-
 # Special builtins can't be redefined by functions.  On the other hand, 'cd'
 # CAN be redefined.
 #
 # http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_14

 _SPECIAL_BUILTINS = {
-    ":": EBuiltin.COLON,
-    ".": EBuiltin.DOT,
-    "eval": EBuiltin.EVAL,
-    "exec": EBuiltin.EXEC,
-    "export": EBuiltin.EXPORT,
-
-    "set": EBuiltin.SET,
-    "shift": EBuiltin.SHIFT,
-    #"times": EBuiltin.TIMES,  # no implemented
-    "trap": EBuiltin.TRAP,
-    "unset": EBuiltin.UNSET,
+    ":": builtin_e.COLON,
+    ".": builtin_e.DOT,
+    "eval": builtin_e.EVAL,
+    "exec": builtin_e.EXEC,
+    "export": builtin_e.EXPORT,
+
+    "set": builtin_e.SET,
+    "shift": builtin_e.SHIFT,
+    #"times": builtin_e.TIMES,  # no implemented
+    "trap": builtin_e.TRAP,
+    "unset": builtin_e.UNSET,

    # May be a builtin or an assignment
-    #"readonly": EBuiltin.READONLY,
-    #"local": EBuiltin.LOCAL,
-    "declare": EBuiltin.DECLARE,
-    "typeset": EBuiltin.TYPESET,
+    #"readonly": builtin_e.READONLY,
+    #"local": builtin_e.LOCAL,
+    "declare": builtin_e.DECLARE,
+    "typeset": builtin_e.TYPESET,

    # Not treated as builtins by OSH.  TODO: Need to auto-complete these
    # break continue return
 }

 _NORMAL_BUILTINS = {
-    "read": EBuiltin.READ,
-    "echo": EBuiltin.ECHO,
-    "cd": EBuiltin.CD,
-    "pushd": EBuiltin.PUSHD,
-    "popd": EBuiltin.POPD,
-    "dirs": EBuiltin.DIRS,
+    "read": builtin_e.READ,
+    "echo": builtin_e.ECHO,
+    "cd": builtin_e.CD,
+    "pushd": builtin_e.PUSHD,
+    "popd": builtin_e.POPD,
+    "dirs": builtin_e.DIRS,

-    "source": EBuiltin.SOURCE,  # note that . alias is special
+    "source": builtin_e.SOURCE,  # note that . alias is special

-    "umask": EBuiltin.UMASK,
-    "wait": EBuiltin.WAIT,
-    "jobs": EBuiltin.JOBS,
+    "umask": builtin_e.UMASK,
+    "wait": builtin_e.WAIT,
+    "jobs": builtin_e.JOBS,

-    "shopt": EBuiltin.SHOPT,
-    "complete": EBuiltin.COMPLETE,
-    "compgen": EBuiltin.COMPGEN,
+    "shopt": builtin_e.SHOPT,
+    "complete": builtin_e.COMPLETE,
+    "compgen": builtin_e.COMPGEN,

-    "true": EBuiltin.TRUE,
-    "false": EBuiltin.FALSE,
+    "true": builtin_e.TRUE,
+    "false": builtin_e.FALSE,

-    "test": EBuiltin.TEST,
-    "[": EBuiltin.BRACKET,
+    "test": builtin_e.TEST,
+    "[": builtin_e.BRACKET,

-    "getopts": EBuiltin.GETOPTS,
+    "getopts": builtin_e.GETOPTS,

-    "command": EBuiltin.COMMAND,
-    "type": EBuiltin.TYPE,
+    "command": builtin_e.COMMAND,
+    "type": builtin_e.TYPE,

-    "declare": EBuiltin.DECLARE,
-    "typeset": EBuiltin.TYPESET,
+    "declare": builtin_e.DECLARE,
+    "typeset": builtin_e.TYPESET,

-    "help": EBuiltin.HELP,
-    "debug-line": EBuiltin.DEBUG_LINE,
+    "help": builtin_e.HELP,
+    "debug-line": builtin_e.DEBUG_LINE,
 }


@@ -165,11 +148,11 @@ def _Register(name, help_topic=None):


 def ResolveSpecial(argv0):
-  return _SPECIAL_BUILTINS.get(argv0, EBuiltin.NONE)
+  return _SPECIAL_BUILTINS.get(argv0, builtin_e.NONE)


 def Resolve(argv0):
-  return _NORMAL_BUILTINS.get(argv0, EBuiltin.NONE)
+  return _NORMAL_BUILTINS.get(argv0, builtin_e.NONE)


 #
@@ -825,9 +808,9 @@ def _ResolveNames(names, funcs, path_val):
  for name in names:
    if name in funcs:
      kind = ('function', name)
-    elif Resolve(name) != EBuiltin.NONE:
+    elif Resolve(name) != builtin_e.NONE:
      kind = ('builtin', name)
-    elif ResolveSpecial(name) != EBuiltin.NONE:
+    elif ResolveSpecial(name) != builtin_e.NONE:
      kind = ('builtin', name)
    elif lex.IsOtherBuiltin(name):  # declare, continue, etc.
      kind = ('builtin', name)
diff --git a/core/cmd_exec.py b/core/cmd_exec.py
@@ -38,15 +38,15 @@
 from core import state
 from core import word_compile

-from osh.meta import ast, Id, REDIR_TYPE, REDIR_DEFAULT_FD, runtime, types
+from osh.meta import ast, Id, REDIR_ARG_TYPES, REDIR_DEFAULT_FD, runtime, types
 from osh import parse_lib

 try:
  import libc  # for fnmatch
 except ImportError:
  from benchmarks import fake_libc as libc

-EBuiltin = builtin.EBuiltin
+builtin_e = builtin.builtin_e

 lex_mode_e = types.lex_mode_e
 redir_arg_type_e = types.redir_arg_type_e
@@ -272,104 +272,104 @@ def _RunBuiltin(self, builtin_id, argv):

    # TODO: figure out a quicker dispatch mechanism.  Just make a table of
    # builtins I guess.
-    if builtin_id == EBuiltin.EXEC:
+    if builtin_id == builtin_e.EXEC:
      status = self._Exec(argv)  # may never return
      # But if it returns, then we want to permanently apply the redirects
      # associated with it.
      self.fd_state.MakePermanent()

-    elif builtin_id == EBuiltin.READ:
+    elif builtin_id == builtin_e.READ:
      status = builtin.Read(argv, self.splitter, self.mem)

-    elif builtin_id == EBuiltin.ECHO:
+    elif builtin_id == builtin_e.ECHO:
      status = builtin.Echo(argv)

-    elif builtin_id == EBuiltin.SHIFT:
+    elif builtin_id == builtin_e.SHIFT:
      status = builtin.Shift(argv, self.mem)

-    elif builtin_id == EBuiltin.CD:
+    elif builtin_id == builtin_e.CD:
      status = builtin.Cd(argv, self.mem, self.dir_stack)

-    elif builtin_id == EBuiltin.SET:
+    elif builtin_id == builtin_e.SET:
      status = builtin.Set(argv, self.exec_opts, self.mem)

-    elif builtin_id == EBuiltin.SHOPT:
+    elif builtin_id == builtin_e.SHOPT:
      status = builtin.Shopt(argv, self.exec_opts)

-    elif builtin_id == EBuiltin.UNSET:
+    elif builtin_id == builtin_e.UNSET:
      status = builtin.Unset(argv, self.mem, self.funcs)

-    elif builtin_id == EBuiltin.EXPORT:
+    elif builtin_id == builtin_e.EXPORT:
      status = builtin.Export(argv, self.mem)

-    elif builtin_id == EBuiltin.WAIT:
+    elif builtin_id == builtin_e.WAIT:
      status = builtin.Wait(argv, self.waiter, self.job_state, self.mem)

-    elif builtin_id == EBuiltin.JOBS:
+    elif builtin_id == builtin_e.JOBS:
      status = builtin.Jobs(argv, self.job_state)

-    elif builtin_id == EBuiltin.PUSHD:
+    elif builtin_id == builtin_e.PUSHD:
      status = builtin.Pushd(argv, self.mem.GetVar('HOME'), self.dir_stack)

-    elif builtin_id == EBuiltin.POPD:
+    elif builtin_id == builtin_e.POPD:
      status = builtin.Popd(argv, self.mem.GetVar('HOME'), self.dir_stack)

-    elif builtin_id == EBuiltin.DIRS:
+    elif builtin_id == builtin_e.DIRS:
      status = builtin.Dirs(argv, self.mem.GetVar('HOME'), self.dir_stack)

-    elif builtin_id in (EBuiltin.SOURCE, EBuiltin.DOT):
+    elif builtin_id in (builtin_e.SOURCE, builtin_e.DOT):
      status = self._Source(argv)

-    elif builtin_id == EBuiltin.TRAP:
+    elif builtin_id == builtin_e.TRAP:
      status = builtin.Trap(argv, self.traps, self.nodes_to_run, self)

-    elif builtin_id == EBuiltin.UMASK:
+    elif builtin_id == builtin_e.UMASK:
      status = builtin.Umask(argv)

-    elif builtin_id == EBuiltin.EVAL:
+    elif builtin_id == builtin_e.EVAL:
      status = self._Eval(argv)

-    elif builtin_id == EBuiltin.COMPLETE:
+    elif builtin_id == builtin_e.COMPLETE:
      status = self._Complete(argv)

-    elif builtin_id == EBuiltin.COMPGEN:
+    elif builtin_id == builtin_e.COMPGEN:
      status = self._CompGen(argv)

-    elif builtin_id == EBuiltin.COLON:  # special builtin like 'true'
+    elif builtin_id == builtin_e.COLON:  # special builtin like 'true'
      status = 0

-    elif builtin_id == EBuiltin.TRUE:
+    elif builtin_id == builtin_e.TRUE:
      status = 0

-    elif builtin_id == EBuiltin.FALSE:
+    elif builtin_id == builtin_e.FALSE:
      status = 1

-    elif builtin_id == EBuiltin.TEST:
+    elif builtin_id == builtin_e.TEST:
      status = test_builtin.Test(argv, False)

-    elif builtin_id == EBuiltin.BRACKET:
+    elif builtin_id == builtin_e.BRACKET:
      status = test_builtin.Test(argv, True)  # need_right_bracket

-    elif builtin_id == EBuiltin.GETOPTS:
+    elif builtin_id == builtin_e.GETOPTS:
      status = builtin.GetOpts(argv, self.mem)

-    elif builtin_id == EBuiltin.COMMAND:
+    elif builtin_id == builtin_e.COMMAND:
      path = self.mem.GetVar('PATH')
      status = builtin.Command(argv, self.funcs, path)

-    elif builtin_id == EBuiltin.TYPE:
+    elif builtin_id == builtin_e.TYPE:
      path = self.mem.GetVar('PATH')
      status = builtin.Type(argv, self.funcs, path)

-    elif builtin_id in (EBuiltin.DECLARE, EBuiltin.TYPESET):
+    elif builtin_id in (builtin_e.DECLARE, builtin_e.TYPESET):
      # These are synonyms
      status = builtin.DeclareTypeset(argv, self.mem, self.funcs)

-    elif builtin_id == EBuiltin.HELP:
+    elif builtin_id == builtin_e.HELP:
      loader = util.GetResourceLoader()
      status = builtin.Help(argv, loader)

-    elif builtin_id == EBuiltin.DEBUG_LINE:
+    elif builtin_id == builtin_e.DEBUG_LINE:
      status = builtin.DebugLine(argv, self.status_lines)

    else:
@@ -422,7 +422,7 @@ def _EvalLhs(self, node, spid):
  def _EvalRedirect(self, n):
    fd = REDIR_DEFAULT_FD[n.op_id] if n.fd == const.NO_INTEGER else n.fd
    if n.tag == redir_e.Redir:
-      redir_type = REDIR_TYPE[n.op_id]  # could be static in the LST?
+      redir_type = REDIR_ARG_TYPES[n.op_id]  # could be static in the LST?

      if redir_type == redir_arg_type_e.Path:
        # NOTE: no globbing.  You can write to a file called '*.py'.
@@ -532,7 +532,7 @@ def _RunSimpleCommand(self, argv, fork_external):
    arg0 = argv[0]

    builtin_id = builtin.ResolveSpecial(arg0)
-    if builtin_id != EBuiltin.NONE:
+    if builtin_id != builtin_e.NONE:
      try:
        status = self._RunBuiltin(builtin_id, argv)
      except args.UsageError as e:
@@ -549,7 +549,7 @@ def _RunSimpleCommand(self, argv, fork_external):
      return status

    builtin_id = builtin.Resolve(arg0)
-    if builtin_id != EBuiltin.NONE:
+    if builtin_id != builtin_e.NONE:
      try:
        status = self._RunBuiltin(builtin_id, argv)
      except args.UsageError as e: