[ysh] Implement io->evalInFrame()

It has similar use cases to Tcl's uplevel.  See doc/ref

TODO: probably needs dollar0, pos_args, vars?

Author: Andy C

builtin/method_io.py

@@ -95,10 +95,23 @@ def __init__(self, mem, cmd_ev):
 
     def Call(self, rd):
         # type: (typed_args.Reader) -> value_t
-        frag = rd.PosCommandFrag()
-        frame = rd.PosFrame()
+        unused = rd.PosValue()
+
+        #frag = rd.PosCommandFrag()
+        cmd = rd.PosCommand()
+        in_frame = rd.PosFrame()
 
-        # TODO: EvalCommandFrag()
+        #cmd.captured_frame = frame
+        frag = typed_args.GetCommandFrag(cmd)
+
+        # Note that 'cd' uses cmd_ev.EvalCommandFrag(), because a builtin does
+        # NOT push a new stack frame.  But a proc does.  So we need
+        # evalInFrame().
+
+        with state.ctx_TokenDebugFrame(self.mem, rd.LeftParenToken()):
+            # Evaluate with the given frame at the TOP of the stack
+            with state.ctx_EvalInFrame(self.mem, in_frame):
+                unused_status = self.cmd_ev.EvalCommandFrag(frag)
 
         return value.Null
 

core/shell.py

@@ -954,6 +954,14 @@ def Main(
     # Special case for testing
     mem.AddBuiltin('module-invoke', value.BuiltinProc(module_invoke))
 
+    # First, process --eval flags.  In interactive mode, this comes before --rcfile.
+    # (It could be used for the headless shell.  Although terminals have a bootstrap process.)
+    # Note that --eval
+    if flag.eval:
+        raise AssertionError()
+    if flag.eval_pure:
+        raise AssertionError('pure')
+
     #
     # Is the shell interactive?
     #
@@ -1203,7 +1211,7 @@ def Main(
         return 0
 
     #
-    # Run a shell script
+    # Batch mode: shell script or -c
     #
 
     with state.ctx_ThisDir(mem, script_name):

core/state.py

@@ -807,6 +807,23 @@ def __exit__(self, type, value, traceback):
         self.mem.var_stack[0] = self.saved_globals
 
 
+class ctx_EvalInFrame(object):
+
+    def __init__(self, mem, frame):
+        # type: (Mem, Dict[str, Cell]) -> None
+        mem.var_stack.append(frame)
+
+        self.mem = mem
+
+    def __enter__(self):
+        # type: () -> None
+        pass
+
+    def __exit__(self, type, value, traceback):
+        # type: (Any, Any, Any) -> None
+        self.mem.var_stack.pop()
+
+
 class ctx_Temp(object):
     """ POSIX shell FOO=bar mycommand """
 

doc/ref/chap-type-method.md

@@ -890,6 +890,37 @@ Example:
 
     pp (d)  # => {a: 42, b: 11}
 
+### evalInFrame()
+
+Evaluate a block in the given frame.  Example:
+
+    proc my-cd (new_dir; ; ; block) {
+      pushd $new_dir >/dev/null
+
+      # Get calling frame.  (The top-most frame, this one, has index -1)
+      var calling_frame = vm.getFrame(-2)
+
+      call io->evalInFrame(block, calling_frame)
+
+      popd >/dev/null
+    }
+
+    var i = 42
+    my-cd /tmp {
+      var my_pwd = PWD
+      var j = i + 1
+    }
+
+    # In contrast to using io->eval(), vars in the block are still visible.
+    # The block was evaluated in this frame.
+    echo "$my_pwd"  # => /tmp
+    echo "$j"       # => 43
+
+Design note: this API has similar use cases as Tcl's [uplevel][].
+
+[uplevel]: https://www.tcl-lang.org/man/tcl8.4/TclCmd/uplevel.htm
+
+
 ### captureStdout()
 
 Capture stdout of a command a string.

doc/ref/toc-ysh.md

@@ -71,7 +71,7 @@ error handling, and more.
                    Frame
                    DebugFrame  toString()
                    io          stdin            evalExpr()
-                               eval()           evalToDict()
+                               eval()           evalToDict()      evalInFrame()
                                captureStdout()
                                promptVal()
                              X time()         X strftime()      X glob()

frontend/flag_def.py

@@ -265,14 +265,22 @@ 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',
                    ['text', 'abbrev-text', 'none', '__perf', '__dumpdoc'],
                    default='abbrev-text')
 
 # Defines completion style.
-MAIN_SPEC.LongFlag('--completion-display', ['minimal', 'nice'], default='minimal')
+MAIN_SPEC.LongFlag('--completion-display', ['minimal', 'nice'],
+                   default='minimal')
 # TODO: Add option for YSH prompt style?  RHS prompt?
 
 MAIN_SPEC.LongFlag('--completion-demo')

spec/ysh-builtin-eval.test.sh

@@ -1,7 +1,7 @@
 # YSH specific features of eval
 
 ## our_shell: ysh
-## oils_failures_allowed: 4
+## oils_failures_allowed: 2
 
 #### eval builtin does not take a literal block - can restore this later
 
@@ -575,66 +575,58 @@ inner2=z
 
 #### io->evalInFrame() can express try, cd builtins
 
-var frag = ^(echo $i)
-
 proc my-cd (new_dir; ; ; block) {
-  pushd $new_dir
+  pushd $new_dir >/dev/null
 
+  # Get calling frame.  (The top-most frame, this one, has index -1)
   var calling_frame = vm.getFrame(-2)
 
-  # could call this "unbound"?  or unbind()?  What about procs and funcs and
-  # exprs?
-  var frag = getCommandFrag(block)
-
-  call io->evalInFrame(frag, calling_frame)
+  call io->evalInFrame(block, calling_frame)
 
-  popd
+  popd >/dev/null
 }
 
 var i = 42
 my-cd /tmp {
   echo $PWD
+  var my_pwd = PWD
   var j = i + 1
 }
+echo "my_pwd=$my_pwd"
 echo "j = $j"
 
 ## STDOUT:
-x: i = 0, j = 2
-x: i = 1, j = 3
-x: i = 2, j = 4
+/tmp
+my_pwd=/tmp
+j = 43
 ## END
 
 
-#### parseCommand(), io->evalInFrame(frag, frame) can behave like eval $mystr
-
-# NO LONGER WORKS, but is this a feature rather than a bug?
+#### io->evalInFrame(frag, frame) can behave like eval $mystr
 
 proc p2(code_str) {
   var mylocal = 42
+  # mylocal is visible
   eval $code_str
 }
 
-p2 'echo mylocal=$mylocal'
+p2 'echo "eval string mylocal=$mylocal"'
 
 proc p (;;; block) {
-  # To behave like eval $code_str, without variable capture:
-  #
-  # var frag = getCommandFrag(block)
-  # var this_frame = vm.getFrame(-1)
-  # call io->evalInFrame(frag, this_frame)
+  var this_frame = vm.getFrame(-1)
 
+  # mylocal is visible
   var mylocal = 99
-  call io->eval(block)
+  call io->evalInFrame(block, this_frame)
 }
 
 p {
-  echo mylocal=$mylocal
+  echo "evalInFrame mylocal=$mylocal"
 }
 
-
 ## STDOUT:
-mylocal=42
-mylocal=99
+eval string mylocal=42
+evalInFrame mylocal=99
 ## END
 
 #### eval should have a sandboxed mode