octave: libinterp/parse-tree/pt-eval.cc comparison

comparison libinterp/parse-tree/pt-eval.cc @ 31607:aac27ad79be6 stable

maint: Re-indent code after switch to using namespace macros. * build-env.h, build-env.in.cc, Cell.h, __betainc__.cc, __eigs__.cc, __ftp__.cc, __ichol__.cc, __ilu__.cc, __isprimelarge__.cc, __magick_read__.cc, __pchip_deriv__.cc, amd.cc, base-text-renderer.cc, base-text-renderer.h, besselj.cc, bitfcns.cc, bsxfun.cc, c-file-ptr-stream.h, call-stack.cc, call-stack.h, ccolamd.cc, cellfun.cc, chol.cc, colamd.cc, dasrt.cc, data.cc, debug.cc, defaults.cc, defaults.h, det.cc, display.cc, display.h, dlmread.cc, dynamic-ld.cc, dynamic-ld.h, ellipj.cc, environment.cc, environment.h, error.cc, error.h, errwarn.h, event-manager.cc, event-manager.h, event-queue.cc, event-queue.h, fcn-info.cc, fcn-info.h, fft.cc, fft2.cc, file-io.cc, filter.cc, find.cc, ft-text-renderer.cc, ft-text-renderer.h, gcd.cc, gl-render.cc, gl-render.h, gl2ps-print.cc, gl2ps-print.h, graphics-toolkit.cc, graphics-toolkit.h, graphics.cc, gsvd.cc, gtk-manager.cc, gtk-manager.h, help.cc, help.h, hook-fcn.cc, hook-fcn.h, input.cc, input.h, interpreter-private.cc, interpreter-private.h, interpreter.cc, interpreter.h, inv.cc, jsondecode.cc, jsonencode.cc, latex-text-renderer.cc, latex-text-renderer.h, load-path.cc, load-path.h, load-save.cc, load-save.h, lookup.cc, ls-hdf5.cc, ls-mat4.cc, ls-mat5.cc, lsode.cc, lu.cc, mappers.cc, matrix_type.cc, max.cc, mex.cc, mexproto.h, mxarray.h, mxtypes.in.h, oct-errno.in.cc, oct-hdf5-types.cc, oct-hist.cc, oct-hist.h, oct-map.cc, oct-map.h, oct-opengl.h, oct-prcstrm.h, oct-process.cc, oct-process.h, oct-stdstrm.h, oct-stream.cc, oct-stream.h, oct-strstrm.h, octave-default-image.h, ordqz.cc, ordschur.cc, pager.cc, pager.h, pinv.cc, pow2.cc, pr-output.cc, psi.cc, qr.cc, quadcc.cc, rand.cc, regexp.cc, settings.cc, settings.h, sighandlers.cc, sighandlers.h, sparse-xpow.cc, sqrtm.cc, stack-frame.cc, stack-frame.h, stream-euler.cc, strfns.cc, svd.cc, syminfo.cc, syminfo.h, symrcm.cc, symrec.cc, symrec.h, symscope.cc, symscope.h, symtab.cc, symtab.h, sysdep.cc, sysdep.h, text-engine.cc, text-engine.h, text-renderer.cc, text-renderer.h, time.cc, toplev.cc, typecast.cc, url-handle-manager.cc, url-handle-manager.h, urlwrite.cc, utils.cc, utils.h, variables.cc, variables.h, xdiv.cc, __delaunayn__.cc, __init_fltk__.cc, __init_gnuplot__.cc, __ode15__.cc, __voronoi__.cc, audioread.cc, convhulln.cc, gzip.cc, cdef-class.cc, cdef-class.h, cdef-fwd.h, cdef-manager.cc, cdef-manager.h, cdef-method.cc, cdef-method.h, cdef-object.cc, cdef-object.h, cdef-package.cc, cdef-package.h, cdef-property.cc, cdef-property.h, cdef-utils.cc, cdef-utils.h, ov-base-diag.cc, ov-base-int.cc, ov-base-mat.cc, ov-base-mat.h, ov-base-scalar.cc, ov-base.cc, ov-base.h, ov-bool-mat.cc, ov-bool-mat.h, ov-bool-sparse.cc, ov-bool.cc, ov-builtin.h, ov-cell.cc, ov-ch-mat.cc, ov-class.cc, ov-class.h, ov-classdef.cc, ov-classdef.h, ov-complex.cc, ov-cx-diag.cc, ov-cx-mat.cc, ov-cx-sparse.cc, ov-dld-fcn.cc, ov-dld-fcn.h, ov-fcn-handle.cc, ov-fcn-handle.h, ov-fcn.h, ov-float.cc, ov-flt-complex.cc, ov-flt-cx-diag.cc, ov-flt-cx-mat.cc, ov-flt-re-diag.cc, ov-flt-re-mat.cc, ov-flt-re-mat.h, ov-intx.h, ov-java.cc, ov-lazy-idx.cc, ov-legacy-range.cc, ov-magic-int.cc, ov-mex-fcn.cc, ov-mex-fcn.h, ov-null-mat.cc, ov-perm.cc, ov-range.cc, ov-re-diag.cc, ov-re-mat.cc, ov-re-mat.h, ov-re-sparse.cc, ov-scalar.cc, ov-str-mat.cc, ov-struct.cc, ov-typeinfo.cc, ov-typeinfo.h, ov-usr-fcn.cc, ov-usr-fcn.h, ov.cc, ov.h, ovl.h, octave.cc, octave.h, op-b-sbm.cc, op-bm-sbm.cc, op-cs-scm.cc, op-fm-fcm.cc, op-fs-fcm.cc, op-s-scm.cc, op-scm-cs.cc, op-scm-s.cc, op-sm-cs.cc, ops.h, anon-fcn-validator.cc, anon-fcn-validator.h, bp-table.cc, bp-table.h, comment-list.cc, comment-list.h, filepos.h, lex.h, oct-lvalue.cc, oct-lvalue.h, parse.h, profiler.cc, profiler.h, pt-anon-scopes.cc, pt-anon-scopes.h, pt-arg-list.cc, pt-arg-list.h, pt-args-block.cc, pt-args-block.h, pt-array-list.cc, pt-array-list.h, pt-assign.cc, pt-assign.h, pt-binop.cc, pt-binop.h, pt-bp.cc, pt-bp.h, pt-cbinop.cc, pt-cbinop.h, pt-cell.cc, pt-cell.h, pt-check.cc, pt-check.h, pt-classdef.cc, pt-classdef.h, pt-cmd.h, pt-colon.cc, pt-colon.h, pt-const.cc, pt-const.h, pt-decl.cc, pt-decl.h, pt-eval.cc, pt-eval.h, pt-except.cc, pt-except.h, pt-exp.cc, pt-exp.h, pt-fcn-handle.cc, pt-fcn-handle.h, pt-id.cc, pt-id.h, pt-idx.cc, pt-idx.h, pt-jump.h, pt-loop.cc, pt-loop.h, pt-mat.cc, pt-mat.h, pt-misc.cc, pt-misc.h, pt-pr-code.cc, pt-pr-code.h, pt-select.cc, pt-select.h, pt-spmd.cc, pt-spmd.h, pt-stmt.cc, pt-stmt.h, pt-tm-const.cc, pt-tm-const.h, pt-unop.cc, pt-unop.h, pt-walk.cc, pt-walk.h, pt.cc, pt.h, token.cc, token.h, Range.cc, Range.h, idx-vector.cc, idx-vector.h, range-fwd.h, CollocWt.cc, CollocWt.h, aepbalance.cc, aepbalance.h, chol.cc, chol.h, gepbalance.cc, gepbalance.h, gsvd.cc, gsvd.h, hess.cc, hess.h, lo-mappers.cc, lo-mappers.h, lo-specfun.cc, lo-specfun.h, lu.cc, lu.h, oct-convn.cc, oct-convn.h, oct-fftw.cc, oct-fftw.h, oct-norm.cc, oct-norm.h, oct-rand.cc, oct-rand.h, oct-spparms.cc, oct-spparms.h, qr.cc, qr.h, qrp.cc, qrp.h, randgamma.cc, randgamma.h, randmtzig.cc, randmtzig.h, randpoisson.cc, randpoisson.h, schur.cc, schur.h, sparse-chol.cc, sparse-chol.h, sparse-lu.cc, sparse-lu.h, sparse-qr.cc, sparse-qr.h, svd.cc, svd.h, child-list.cc, child-list.h, dir-ops.cc, dir-ops.h, file-ops.cc, file-ops.h, file-stat.cc, file-stat.h, lo-sysdep.cc, lo-sysdep.h, lo-sysinfo.cc, lo-sysinfo.h, mach-info.cc, mach-info.h, oct-env.cc, oct-env.h, oct-group.cc, oct-group.h, oct-password.cc, oct-password.h, oct-syscalls.cc, oct-syscalls.h, oct-time.cc, oct-time.h, oct-uname.cc, oct-uname.h, action-container.cc, action-container.h, base-list.h, cmd-edit.cc, cmd-edit.h, cmd-hist.cc, cmd-hist.h, f77-fcn.h, file-info.cc, file-info.h, lo-array-errwarn.cc, lo-array-errwarn.h, lo-hash.cc, lo-hash.h, lo-ieee.h, lo-regexp.cc, lo-regexp.h, lo-utils.cc, lo-utils.h, oct-base64.cc, oct-base64.h, oct-glob.cc, oct-glob.h, oct-inttypes.h, oct-mutex.cc, oct-mutex.h, oct-refcount.h, oct-shlib.cc, oct-shlib.h, oct-sparse.cc, oct-sparse.h, oct-string.h, octave-preserve-stream-state.h, pathsearch.cc, pathsearch.h, quit.cc, quit.h, unwind-prot.cc, unwind-prot.h, url-transfer.cc, url-transfer.h: Re-indent code after switch to using namespace macros.

author	Rik <rik@octave.org>
date	Thu, 01 Dec 2022 18:02:15 -0800
parents	e88a07dec498
children	23664317f0d3 597f3ee61a48

comparison

equal deleted inserted replaced

-:e88a07dec498
+:aac27ad79be6
 #include "utils.h"
 #include "variables.h"
 OCTAVE_BEGIN_NAMESPACE(octave)
 // Normal evaluator.
 class quit_debug_exception
+{
+public:
+quit_debug_exception (bool all = false) : m_all (all) { }
+quit_debug_exception (const quit_debug_exception&) = default;
+quit_debug_exception& operator = (const quit_debug_exception&) = default;
+~quit_debug_exception (void) = default;
+bool all (void) const { return m_all; }
+private:
+bool m_all;
+};
+class debugger
+{
+public:
+enum execution_mode
 {
-public:
+EX_NORMAL = 0,
+EX_CONTINUE = 1,
-quit_debug_exception (bool all = false) : m_all (all) { }
+EX_QUIT = 2,
+EX_QUIT_ALL = 3
-quit_debug_exception (const quit_debug_exception&) = default;
-quit_debug_exception& operator = (const quit_debug_exception&) = default;
-~quit_debug_exception (void) = default;
-bool all (void) const { return m_all; }
-private:
-bool m_all;
 };
-class debugger
+debugger (interpreter& interp, std::size_t level)
+: m_interpreter (interp), m_level (level),
+m_execution_mode (EX_NORMAL), m_in_debug_repl (false)
+{ }
+int server_loop (void);
+void repl (const std::string& prompt = "debug> ");
+bool in_debug_repl (void) const { return m_in_debug_repl; }
+void dbcont (void) { m_execution_mode = EX_CONTINUE; }
+void dbquit (bool all = false)
 {
-public:
+if (all)
+m_execution_mode = EX_QUIT_ALL;
-enum execution_mode
+else
+m_execution_mode = EX_QUIT;
+}
+bool quitting_debugger (void) const;
+private:
+interpreter& m_interpreter;
+std::size_t m_level;
+execution_mode m_execution_mode;
+bool m_in_debug_repl;
+};
+// FIXME: Could the debugger server_loop and repl functions be merged
+// with the corresponding tree_evaluator functions or do they need to
+// remain separate?  They perform nearly the same functions.
+int debugger::server_loop (void)
+{
+// Process events from the event queue.
+tree_evaluator& tw = m_interpreter.get_evaluator ();
+void (tree_evaluator::*server_mode_fptr) (bool)
+= &tree_evaluator::server_mode;
+unwind_action act (server_mode_fptr, &tw, true);
+int exit_status = 0;
+do
+{
+if (m_execution_mode == EX_CONTINUE || tw.dbstep_flag ())
+break;
+if (quitting_debugger ())
+break;
+try
+{
+// FIXME: Should we call octave_quit in the octave::sleep
+// and/or command_editor::run_event_hooks functions?
+octave_quit ();
+// FIXME: Running the event queue should be decoupled from
+// the command_editor.
+// FIXME: Is it OK to use command_editor::run_event_hooks
+// here?  It may run more than one queued function per call,
+// and it seems that the checks at the top of the loop
+// probably need to be done after each individual event
+// function is executed.  For now, maybe the simplest thing
+// would be to pass a predicate function (lambda expression)
+// to the command_editor::run_event_hooks and have it check
+// that and break out of the eval loop(s) if the condition
+// is met?
+// FIXME: We should also use a condition variable to manage
+// the execution of entries in the queue and eliminate the
+// need for the busy-wait loop.
+command_editor::run_event_hooks ();
+release_unreferenced_dynamic_libraries ();
+sleep (0.1);
+}
+catch (const interrupt_exception&)
+{
+octave_interrupt_state = 1;
+m_interpreter.recover_from_exception ();
+// Required newline when the user does Ctrl+C at the prompt.
+if (m_interpreter.interactive ())
+octave_stdout << "\n";
+}
+catch (const index_exception& e)
+{
+m_interpreter.recover_from_exception ();
+std::cerr << "error: unhandled index exception: "
+<< e.message () << " -- trying to return to prompt"
+<< std::endl;
+}
+catch (const execution_exception& ee)
+{
+error_system& es = m_interpreter.get_error_system ();
+es.save_exception (ee);
+es.display_exception (ee);
+if (m_interpreter.interactive ())
+{
+m_interpreter.recover_from_exception ();
+}
+else
+{
+// We should exit with a nonzero status.
+exit_status = 1;
+break;
+}
+}
+catch (const quit_debug_exception& qde)
+{
+if (qde.all ())
+throw;
+// Continue in this debug level.
+}
+catch (const std::bad_alloc&)
+{
+m_interpreter.recover_from_exception ();
+std::cerr << "error: out of memory -- trying to return to prompt"
+<< std::endl;
+}
+}
+while (exit_status == 0);
+if (exit_status == EOF)
+{
+if (m_interpreter.interactive ())
+octave_stdout << "\n";
+exit_status = 0;
+}
+return exit_status;
+}
+void debugger::repl (const std::string& prompt_arg)
+{
+unwind_protect frame;
+frame.protect_var (m_in_debug_repl);
+frame.protect_var (m_execution_mode);
+m_in_debug_repl = true;
+tree_evaluator& tw = m_interpreter.get_evaluator ();
+bool silent = tw.quiet_breakpoint_flag (false);
+frame.add (&tree_evaluator::restore_frame, &tw,
+tw.current_call_stack_frame_number ());
+tw.goto_frame (tw.debug_frame ());
+octave_user_code *caller = tw.current_user_code ();
+std::string fcn_file_nm, fcn_nm;
+if (caller)
+{
+fcn_file_nm = caller->fcn_file_name ();
+fcn_nm = fcn_file_nm.empty () ? caller->name () : fcn_file_nm;
+}
+int curr_debug_line = tw.current_line ();
+std::ostringstream buf;
+input_system& input_sys = m_interpreter.get_input_system ();
+event_manager& evmgr = m_interpreter.get_event_manager ();
+if (! fcn_nm.empty ())
+{
+if (input_sys.gud_mode ())
+{
+static char ctrl_z = 'Z' & 0x1f;
+buf << ctrl_z << ctrl_z << fcn_nm << ':' << curr_debug_line;
+}
+else
+{
+// FIXME: we should come up with a clean way to detect
+// that we are stopped on the no-op command that marks the
+// end of a function or script.
+if (! silent)
+{
+std::shared_ptr<stack_frame> frm = tw.current_user_frame ();
+frm->display_stopped_in_message (buf);
+}
+evmgr.enter_debugger_event (fcn_nm, fcn_file_nm, curr_debug_line);
+evmgr.set_workspace ();
+frame.add (&event_manager::execute_in_debugger_event, &evmgr,
+fcn_nm, curr_debug_line);
+if (! silent)
+{
+std::string line_buf;
+if (caller)
+line_buf = caller->get_code_line (curr_debug_line);
+if (! line_buf.empty ())
+buf << curr_debug_line << ": " << line_buf;
+}
+}
+}
+if (silent)
+command_editor::erase_empty_line (true);
+std::string stopped_in_msg = buf.str ();
+if (m_interpreter.server_mode ())
+{
+if (! stopped_in_msg.empty ())
+octave_stdout << stopped_in_msg << std::endl;
+evmgr.push_event_queue ();
+frame.add (&event_manager::pop_event_queue, &evmgr);
+frame.add (&tree_evaluator::set_parser, &tw, tw.get_parser ());
+std::shared_ptr<push_parser>
+debug_parser (new push_parser (m_interpreter));
+tw.set_parser (debug_parser);
+server_loop ();
+}
+else
+{
+if (! stopped_in_msg.empty ())
+std::cerr << stopped_in_msg << std::endl;
+std::string tmp_prompt = prompt_arg;
+if (m_level > 0)
+tmp_prompt = "[" + std::to_string (m_level) + "]" + prompt_arg;
+frame.add (&input_system::set_PS1, &input_sys, input_sys.PS1 ());
+input_sys.PS1 (tmp_prompt);
+if (! m_interpreter.interactive ())
+{
+void (interpreter::*interactive_fptr) (bool)
+= &interpreter::interactive;
+frame.add (interactive_fptr, &m_interpreter,
+m_interpreter.interactive ());
+m_interpreter.interactive (true);
+// FIXME: should debugging be possible in an embedded
+// interpreter?
+application *app = application::app ();
+if (app)
+{
+void (application::*forced_interactive_fptr) (bool)
+= &application::forced_interactive;
+frame.add (forced_interactive_fptr, app,
+app->forced_interactive ());
+app->forced_interactive (true);
+}
+}
+#if defined (OCTAVE_ENABLE_COMMAND_LINE_PUSH_PARSER)
+input_reader reader (m_interpreter);
+push_parser debug_parser (m_interpreter);
+#else
+parser debug_parser (m_interpreter);
+#endif
+error_system& es = m_interpreter.get_error_system ();
+while (m_in_debug_repl)
+{
+if (m_execution_mode == EX_CONTINUE || tw.dbstep_flag ())
+break;
+if (quitting_debugger ())
+break;
+try
+{
+debug_parser.reset ();
+#if defined (OCTAVE_ENABLE_COMMAND_LINE_PUSH_PARSER)
+int retval = 0;
+std::string prompt
+= command_editor::decode_prompt_string (tmp_prompt);
+do
+{
+bool eof = false;
+std::string input_line = reader.get_input (prompt, eof);
+if (eof)
+{
+retval = EOF;
+break;
+}
+retval = debug_parser.run (input_line, false);
+prompt = command_editor::decode_prompt_string (input_sys.PS2 ());
+}
+while (retval < 0);
+#else
+int retval = debug_parser.run ();
+#endif
+if (command_editor::interrupt (false))
+{
+// Break regardless of m_execution_mode value.
+quitting_debugger ();
+break;
+}
+else
+{
+if (retval == 0)
+{
+std::shared_ptr<tree_statement_list> stmt_list
+= debug_parser.statement_list ();
+if (stmt_list)
+stmt_list->accept (tw);
+if (octave_completion_matches_called)
+octave_completion_matches_called = false;
+// FIXME: the following statement is here because
+// the last command may have been a dbup, dbdown, or
+// dbstep command that changed the current debug
+// frame.  If so, we need to reset the current frame
+// for the call stack.  But is this right way to do
+// this job?  What if the statement list was
+// something like "dbup; dbstack"?  Will the call to
+// dbstack use the right frame?  If not, how can we
+// fix this problem?
+tw.goto_frame (tw.debug_frame ());
+}
+octave_quit ();
+}
+}
+catch (const execution_exception& ee)
+{
+es.save_exception (ee);
+es.display_exception (ee);
+// Ignore errors when in debugging mode;
+m_interpreter.recover_from_exception ();
+}
+catch (const quit_debug_exception& qde)
+{
+if (qde.all ())
+throw;
+// Continue in this debug level.
+}
+}
+}
+}
+bool debugger::quitting_debugger (void) const
+{
+if (m_execution_mode == EX_QUIT)
+{
+// If there is no enclosing debug level or the top-level
+// repl is not active, handle dbquit the same as dbcont.
+if (m_level > 0 || m_interpreter.server_mode ()
+|| m_interpreter.in_top_level_repl ())
+throw quit_debug_exception ();
+else
+return true;
+}
+if (m_execution_mode == EX_QUIT_ALL)
+{
+// If the top-level repl is not active, handle "dbquit all"
+// the same as dbcont.
+if (m_interpreter.server_mode () || m_interpreter.in_top_level_repl ())
+throw quit_debug_exception (true);
+else
+return true;
+}
+return false;
+}
+bool tree_evaluator::at_top_level (void) const
+{
+return m_call_stack.at_top_level ();
+}
+std::string
+tree_evaluator::mfilename (const std::string& opt) const
+{
+std::string fname;
+octave_user_code *fcn = m_call_stack.current_user_code ();
+if (fcn)
+{
+fname = fcn->fcn_file_name ();
+if (fname.empty ())
+fname = fcn->name ();
+}
+if (opt == "fullpathext")
+return fname;
+std::size_t dpos = fname.rfind (sys::file_ops::dir_sep_char ());
+std::size_t epos = fname.rfind ('.');
+if (epos <= dpos+1)
+epos = std::string::npos;
+if (epos != std::string::npos)
+fname = fname.substr (0, epos);
+if (opt == "fullpath")
+return fname;
+if (dpos != std::string::npos)
+fname = fname.substr (dpos+1);
+return fname;
+}
+void tree_evaluator::parse_and_execute (const std::string& input,
+bool& incomplete_parse)
+{
+incomplete_parse = false;
+unwind_protect_var<bool> upv (m_in_top_level_repl, true);
+if (at_top_level ())
+{
+dbstep_flag (0);
+reset_debug_state ();
+}
+// FIXME: OK to do this job here, or should it be in the functions
+// that do the actual prompting?
+// Update the time stamp for the "prompt" so that automatically
+// finding modified files based on file modification times will
+// work.  In the future, we may do something completely different to
+// check for changes to files but for now, we rely on the prompt
+// time stamp to limit the checks for file modification times.
+Vlast_prompt_time.stamp ();
+bool eof = false;
+event_manager& evmgr = m_interpreter.get_event_manager ();
+if (command_history::add (input))
+evmgr.append_history (input);
+m_exit_status = m_parser->run (input, eof);
+if (m_exit_status == 0)
+{
+std::shared_ptr<tree_statement_list>
+stmt_list = m_parser->statement_list ();
+if (stmt_list)
+{
+command_editor::increment_current_command_number ();
+eval (stmt_list, m_interpreter.interactive ());
+evmgr.set_workspace ();
+}
+else if (m_parser->at_end_of_input ())
+m_exit_status = EOF;
+}
+else
+incomplete_parse = true;
+// FIXME: Should we be checking m_exit_status or incomplete_parse or
+// both here?  Could EOF have a value other than -1, and is there
+// possible confusion between that state and the parser returning -1?
+if (m_exit_status == -1)
+m_exit_status = 0;
+else
+m_parser->reset ();
+evmgr.pre_input_event ();
+}
+void tree_evaluator::get_line_and_eval (void)
+{
+std::mutex mtx;
+std::unique_lock<std::mutex> lock (mtx);
+std::condition_variable cv;
+bool incomplete_parse = false;
+bool evaluation_pending = false;
+bool exiting = false;
+input_system& input_sys = m_interpreter.get_input_system ();
+event_manager& evmgr = m_interpreter.get_event_manager ();
+while (true)
+{
+// FIXME: Detect EOF?  Use readline?  If
+// so, then we need to disable idle event loop hook function
+// execution.
+std::string ps = incomplete_parse ? input_sys.PS2 () : input_sys.PS1 ();
+std::cout << command_editor::decode_prompt_string (ps);
+std::string input;
+std::getline (std::cin, input);
+if (input.empty ())
+continue;
+incomplete_parse = false;
+evaluation_pending = true;
+exiting = false;
+evmgr.post_event
+([&] (interpreter& interp)
 {
-EX_NORMAL = 0,
+// INTERPRETER THREAD
-EX_CONTINUE = 1,
-EX_QUIT = 2,
+std::lock_guard<std::mutex> local_lock (mtx);
-EX_QUIT_ALL = 3
-};
-debugger (interpreter& interp, std::size_t level)
-: m_interpreter (interp), m_level (level),
-m_execution_mode (EX_NORMAL), m_in_debug_repl (false)
-{ }
-int server_loop (void);
-void repl (const std::string& prompt = "debug> ");
-bool in_debug_repl (void) const { return m_in_debug_repl; }
-void dbcont (void) { m_execution_mode = EX_CONTINUE; }
-void dbquit (bool all = false)
-{
-if (all)
-m_execution_mode = EX_QUIT_ALL;
-else
-m_execution_mode = EX_QUIT;
-}
-bool quitting_debugger (void) const;
-private:
-interpreter& m_interpreter;
-std::size_t m_level;
-execution_mode m_execution_mode;
-bool m_in_debug_repl;
-};
-// FIXME: Could the debugger server_loop and repl functions be merged
-// with the corresponding tree_evaluator functions or do they need to
-// remain separate?  They perform nearly the same functions.
-int debugger::server_loop (void)
-{
-// Process events from the event queue.
-tree_evaluator& tw = m_interpreter.get_evaluator ();
-void (tree_evaluator::*server_mode_fptr) (bool)
-= &tree_evaluator::server_mode;
-unwind_action act (server_mode_fptr, &tw, true);
-int exit_status = 0;
-do
-{
-if (m_execution_mode == EX_CONTINUE || tw.dbstep_flag ())
-break;
-if (quitting_debugger ())
-break;
 try
 {
-// FIXME: Should we call octave_quit in the octave::sleep
+interp.parse_and_execute (input, incomplete_parse);
-// and/or command_editor::run_event_hooks functions?
-octave_quit ();
-// FIXME: Running the event queue should be decoupled from
-// the command_editor.
-// FIXME: Is it OK to use command_editor::run_event_hooks
-// here?  It may run more than one queued function per call,
-// and it seems that the checks at the top of the loop
-// probably need to be done after each individual event
-// function is executed.  For now, maybe the simplest thing
-// would be to pass a predicate function (lambda expression)
-// to the command_editor::run_event_hooks and have it check
-// that and break out of the eval loop(s) if the condition
-// is met?
-// FIXME: We should also use a condition variable to manage
-// the execution of entries in the queue and eliminate the
-// need for the busy-wait loop.
-command_editor::run_event_hooks ();
-release_unreferenced_dynamic_libraries ();
-sleep (0.1);
 }
-catch (const interrupt_exception&)
+catch (const exit_exception&)
 {
-octave_interrupt_state = 1;
+evaluation_pending = false;
-m_interpreter.recover_from_exception ();
+exiting = true;
+cv.notify_all ();
-// Required newline when the user does Ctrl+C at the prompt.
+throw;
-if (m_interpreter.interactive ())
-octave_stdout << "\n";
-}
-catch (const index_exception& e)
-{
-m_interpreter.recover_from_exception ();
-std::cerr << "error: unhandled index exception: "
-<< e.message () << " -- trying to return to prompt"
-<< std::endl;
 }
 catch (const execution_exception& ee)
 {
 error_system& es = m_interpreter.get_error_system ();
 es.display_exception (ee);
 if (m_interpreter.interactive ())
 {
 m_interpreter.recover_from_exception ();
+m_parser->reset ();
+evaluation_pending = false;
+cv.notify_all ();
 }
 else
 {
-// We should exit with a nonzero status.
+evaluation_pending = false;
-exit_status = 1;
+cv.notify_all ();
-break;
+throw exit_exception (1);
 }
 }
-catch (const quit_debug_exception& qde)
+catch (...)
 {
-if (qde.all ())
+evaluation_pending = false;
-throw;
+cv.notify_all ();
+throw;
-// Continue in this debug level.
 }
-catch (const std::bad_alloc&)
-{
+evaluation_pending = false;
+cv.notify_all ();
+});
+// Wait until evaluation is finished before prompting for input
+// again.
+cv.wait (lock, [&] { return ! evaluation_pending; });
+if (exiting)
+break;
+}
+}
+int tree_evaluator::repl (void)
+{
+// The big loop.  Read, Eval, Print, Loop.  Normally user
+// interaction at the command line in a terminal session, but we may
+// also end up here when reading from a pipe or when stdin is
+// connected to a file by the magic of input redirection.
+int exit_status = 0;
+// FIXME: should this choice be a command-line option?  Note that we
+// intend that the push parser interface only be used for
+// interactive sessions.
+#if defined (OCTAVE_ENABLE_COMMAND_LINE_PUSH_PARSER)
+static bool use_command_line_push_parser = true;
+#else
+static bool use_command_line_push_parser = false;
+#endif
+// The following logic is written as it is to allow easy transition
+// to setting USE_COMMAND_LINE_PUSH_PARSER at run time and to
+// simplify the logic of the main loop below by using the same
+// base_parser::run interface for both push and pull parsers.
+std::shared_ptr<base_parser> repl_parser;
+if (m_interpreter.interactive ())
+{
+if (use_command_line_push_parser)
+{
+push_parser *pp
+= new push_parser (m_interpreter,
+new input_reader (m_interpreter));
+repl_parser = std::shared_ptr<base_parser> (pp);
+}
+else
+{
+parser *pp = new parser (new lexer (m_interpreter));
+repl_parser = std::shared_ptr<base_parser> (pp);
+}
+}
+else
+{
+parser *pp = new parser (new lexer (stdin, m_interpreter));
+repl_parser = std::shared_ptr<base_parser> (pp);
+}
+do
+{
+try
+{
+unwind_protect_var<bool> upv (m_in_top_level_repl, true);
+repl_parser->reset ();
+if (at_top_level ())
+{
+dbstep_flag (0);
+reset_debug_state ();
+}
+exit_status = repl_parser->run ();
+if (exit_status == 0)
+{
+std::shared_ptr<tree_statement_list>
+stmt_list = repl_parser->statement_list ();
+if (stmt_list)
+{
+command_editor::increment_current_command_number ();
+eval (stmt_list, m_interpreter.interactive ());
+}
+else if (repl_parser->at_end_of_input ())
+{
+exit_status = EOF;
+break;
+}
+}
+}
+catch (const interrupt_exception&)
+{
+m_interpreter.recover_from_exception ();
+// Required newline when the user does Ctrl+C at the prompt.
+if (m_interpreter.interactive ())
+octave_stdout << "\n";
+}
+catch (const index_exception& ie)
+{
+m_interpreter.recover_from_exception ();
+std::cerr << "error: unhandled index exception: "
+<< ie.message () << " -- trying to return to prompt"
+<< std::endl;
+}
+catch (const execution_exception& ee)
+{
+error_system& es = m_interpreter.get_error_system ();
+es.save_exception (ee);
+es.display_exception (ee);
+if (m_interpreter.interactive ())
 m_interpreter.recover_from_exception ();
+else
-std::cerr << "error: out of memory -- trying to return to prompt"
+{
-<< std::endl;
+// We should exit with a nonzero status.
-}
+exit_status = 1;
-}
+break;
-while (exit_status == 0);
+}
+}
-if (exit_status == EOF)
+catch (const quit_debug_exception&)
 {
-if (m_interpreter.interactive ())
+m_interpreter.recover_from_exception ();
-octave_stdout << "\n";
+// FIXME: Does anything else need to happen here?
-exit_status = 0;
+}
-}
+catch (const std::bad_alloc&)
+{
-return exit_status;
+m_interpreter.recover_from_exception ();
-}
+std::cerr << "error: out of memory -- trying to return to prompt"
-void debugger::repl (const std::string& prompt_arg)
+<< std::endl;
+}
+}
+while (exit_status == 0);
+if (exit_status == EOF)
+{
+if (m_interpreter.interactive ())
+octave_stdout << "\n";
+exit_status = 0;
+}
+return exit_status;
+}
+int tree_evaluator::server_loop (void)
+{
+// Process events from the event queue.
+unwind_protect_var<bool> upv1 (m_server_mode, true);
+m_exit_status = 0;
+std::shared_ptr<push_parser> parser (new push_parser (m_interpreter));
+unwind_protect_var<std::shared_ptr<push_parser>> upv2 (m_parser, parser);
+// FIXME: We are currently resetting the parser after every call to
+// recover_from_exception.  This action should probably be handled
+// in a more consistent way, but resetting the parser in every call
+// to interpreter::recover_from_exception appears to cause
+// segfaults in the test suite.
+do
+{
+try
+{
+// FIXME: Should we call octave_quit in the octave::sleep
+// and/or command_editor::run_event_hooks functions?
+octave_quit ();
+// FIXME: Running the event queue should be decoupled from
+// the command_editor.  We should also use a condition
+// variable to manage the execution of entries in the queue
+// and eliminate the need for the busy-wait loop.
+command_editor::run_event_hooks ();
+release_unreferenced_dynamic_libraries ();
+sleep (0.1);
+}
+catch (const interrupt_exception&)
+{
+octave_interrupt_state = 1;
+m_interpreter.recover_from_exception ();
+m_parser->reset ();
+// Required newline when the user does Ctrl+C at the prompt.
+if (m_interpreter.interactive ())
+octave_stdout << "\n";
+}
+catch (const index_exception& e)
+{
+m_interpreter.recover_from_exception ();
+m_parser->reset ();
+std::cerr << "error: unhandled index exception: "
+<< e.message () << " -- trying to return to prompt"
+<< std::endl;
+}
+catch (const execution_exception& ee)
+{
+error_system& es = m_interpreter.get_error_system ();
+es.save_exception (ee);
+es.display_exception (ee);
+if (m_interpreter.interactive ())
+{
+m_interpreter.recover_from_exception ();
+m_parser->reset ();
+}
+else
+{
+// We should exit with a nonzero status.
+m_exit_status = 1;
+break;
+}
+}
+catch (const quit_debug_exception&)
+{
+octave_interrupt_state = 1;
+m_interpreter.recover_from_exception ();
+m_parser->reset ();
+}
+catch (const exit_exception& xe)
+{
+m_exit_status = xe.exit_status ();
+break;
+}
+catch (const std::bad_alloc&)
+{
+m_interpreter.recover_from_exception ();
+m_parser->reset ();
+std::cerr << "error: out of memory -- trying to return to prompt"
+<< std::endl;
+}
+}
+while (m_exit_status == 0);
+if (m_exit_status == EOF)
+{
+if (m_interpreter.interactive ())
+octave_stdout << "\n";
+m_exit_status = 0;
+}
+return m_exit_status;
+}
+void tree_evaluator::eval (std::shared_ptr<tree_statement_list>& stmt_list,
+bool interactive)
+{
+try
+{
+stmt_list->accept (*this);
+octave_quit ();
+if (! interactive)
+{
+bool quit = (m_returning || m_breaking);
+if (m_returning)
+m_returning = 0;
+if (m_breaking)
+m_breaking--;
+if (quit)
+return;
+}
+if (octave_completion_matches_called)
+octave_completion_matches_called = false;
+}
+catch (const quit_debug_exception&)
+{
+m_interpreter.recover_from_exception ();
+}
+}
+octave_value_list
+tree_evaluator::eval_string (const std::string& eval_str, bool silent,
+int& parse_status, int nargout)
+{
+octave_value_list retval;
+parser eval_parser (eval_str, m_interpreter);
+do
+{
+eval_parser.reset ();
+// If we are looking at
+//
+//   val = eval ("code");
+//
+// then don't allow code to be parsed as a command.
+if (nargout > 0)
+eval_parser.disallow_command_syntax ();
+parse_status = eval_parser.run ();
+if (parse_status == 0)
+{
+std::shared_ptr<tree_statement_list> stmt_list
+= eval_parser.statement_list ();
+if (stmt_list)
+{
+tree_statement *stmt = nullptr;
+if (stmt_list->length () == 1
+&& (stmt = stmt_list->front ())
+&& stmt->is_expression ())
+{
+tree_expression *expr = stmt->expression ();
+if (silent)
+expr->set_print_flag (false);
+retval = expr->evaluate_n (*this, nargout);
+bool do_bind_ans = false;
+if (expr->is_identifier ())
+do_bind_ans = ! is_variable (expr);
+else
+do_bind_ans = ! expr->is_assignment_expression ();
+if (do_bind_ans && ! retval.empty ())
+bind_ans (retval(0), expr->print_result ());
+if (nargout == 0)
+retval = octave_value_list ();
+}
+else if (nargout == 0)
+stmt_list->accept (*this);
+else
+error ("eval: invalid use of statement list");
+if (returning () || breaking () || continuing ())
+break;
+}
+else if (eval_parser.at_end_of_input ())
+break;
+}
+}
+while (parse_status == 0);
+return retval;
+}
+octave_value tree_evaluator::eval_string (const std::string& eval_str,
+bool silent, int& parse_status)
+{
+octave_value retval;
+octave_value_list tmp = eval_string (eval_str, silent, parse_status, 1);
+if (! tmp.empty ())
+retval = tmp(0);
+return retval;
+}
+octave_value_list tree_evaluator::eval_string (const octave_value& arg,
+bool silent, int& parse_status,
+int nargout)
+{
+std::string s = arg.xstring_value ("eval: expecting string argument");
+return eval_string (s, silent, parse_status, nargout);
+}
+octave_value_list tree_evaluator::eval (const std::string& try_code,
+int nargout)
+{
+int parse_status = 0;
+return eval_string (try_code, nargout > 0, parse_status, nargout);
+}
+octave_value_list tree_evaluator::eval (const std::string& try_code,
+const std::string& catch_code,
+int nargout)
+{
+octave_value_list retval;
+error_system& es = m_interpreter.get_error_system ();
+int parse_status = 0;
+bool execution_error = false;
+octave_value_list tmp;
+try
+{
+tmp = eval_string (try_code, nargout > 0, parse_status, nargout);
+}
+catch (const execution_exception& ee)
+{
+es.save_exception (ee);
+m_interpreter.recover_from_exception ();
+execution_error = true;
+}
+if (parse_status != 0 || execution_error)
+{
+tmp = eval_string (catch_code, nargout > 0, parse_status, nargout);
+retval = (nargout > 0) ? tmp : octave_value_list ();
+}
+else
+{
+if (nargout > 0)
+retval = tmp;
+// FIXME: we should really be rethrowing whatever
+// exception occurred, not just throwing an
+// execution exception.
+if (execution_error)
+throw execution_exception ();
+}
+return retval;
+}
+octave_value_list tree_evaluator::evalin (const std::string& context,
+const std::string& try_code,
+int nargout)
+{
+unwind_action act ([=] (std::size_t frm)
 {
-unwind_protect frame;
+m_call_stack.restore_frame (frm);
+}, m_call_stack.current_frame ());
-frame.protect_var (m_in_debug_repl);
-frame.protect_var (m_execution_mode);
+if (context == "caller")
+m_call_stack.goto_caller_frame ();
-m_in_debug_repl = true;
+else if (context == "base")
+m_call_stack.goto_base_frame ();
-tree_evaluator& tw = m_interpreter.get_evaluator ();
+else
+error (R"(evalin: CONTEXT must be "caller" or "base")");
-bool silent = tw.quiet_breakpoint_flag (false);
+int parse_status = 0;
-frame.add (&tree_evaluator::restore_frame, &tw,
-tw.current_call_stack_frame_number ());
+return eval_string (try_code, nargout > 0, parse_status, nargout);
+}
-tw.goto_frame (tw.debug_frame ());
+octave_value_list tree_evaluator::evalin (const std::string& context,
-octave_user_code *caller = tw.current_user_code ();
+const std::string& try_code,
-std::string fcn_file_nm, fcn_nm;
+const std::string& catch_code,
+int nargout)
-if (caller)
+{
-{
+octave_value_list retval;
-fcn_file_nm = caller->fcn_file_name ();
-fcn_nm = fcn_file_nm.empty () ? caller->name () : fcn_file_nm;
+unwind_action act1 ([=] (std::size_t frm)
-}
+{
+m_call_stack.restore_frame (frm);
-int curr_debug_line = tw.current_line ();
+}, m_call_stack.current_frame ());
-std::ostringstream buf;
+if (context == "caller")
+m_call_stack.goto_caller_frame ();
-input_system& input_sys = m_interpreter.get_input_system ();
+else if (context == "base")
+m_call_stack.goto_base_frame ();
-event_manager& evmgr = m_interpreter.get_event_manager ();
+else
+error (R"(evalin: CONTEXT must be "caller" or "base")");
-if (! fcn_nm.empty ())
-{
+error_system& es = m_interpreter.get_error_system ();
-if (input_sys.gud_mode ())
-{
+int parse_status = 0;
-static char ctrl_z = 'Z' & 0x1f;
+bool execution_error = false;
-buf << ctrl_z << ctrl_z << fcn_nm << ':' << curr_debug_line;
-}
+octave_value_list tmp;
-else
-{
+try
-// FIXME: we should come up with a clean way to detect
+{
-// that we are stopped on the no-op command that marks the
+tmp = eval_string (try_code, nargout > 0, parse_status, nargout);
-// end of a function or script.
+}
+catch (const execution_exception& ee)
-if (! silent)
+{
-{
+es.save_exception (ee);
-std::shared_ptr<stack_frame> frm = tw.current_user_frame ();
+m_interpreter.recover_from_exception ();
-frm->display_stopped_in_message (buf);
+execution_error = true;
 }
-evmgr.enter_debugger_event (fcn_nm, fcn_file_nm, curr_debug_line);
+if (parse_status != 0 || execution_error)
+{
-evmgr.set_workspace ();
+tmp = eval_string (catch_code, nargout > 0, parse_status, nargout);
-frame.add (&event_manager::execute_in_debugger_event, &evmgr,
+retval = (nargout > 0) ? tmp : octave_value_list ();
-fcn_nm, curr_debug_line);
+}
+else
-if (! silent)
+{
-{
+if (nargout > 0)
-std::string line_buf;
+retval = tmp;
-if (caller)
+// FIXME: we should really be rethrowing whatever
-line_buf = caller->get_code_line (curr_debug_line);
+// exception occurred, not just throwing an
+// execution exception.
-if (! line_buf.empty ())
+if (execution_error)
-buf << curr_debug_line << ": " << line_buf;
+throw execution_exception ();
 }
-}
-}
+return retval;
+}
-if (silent)
-command_editor::erase_empty_line (true);
+void
+tree_evaluator::visit_anon_fcn_handle (tree_anon_fcn_handle&)
-std::string stopped_in_msg = buf.str ();
+{
+panic_impossible ();
-if (m_interpreter.server_mode ())
+}
-{
-if (! stopped_in_msg.empty ())
+void
-octave_stdout << stopped_in_msg << std::endl;
+tree_evaluator::visit_argument_list (tree_argument_list&)
+{
-evmgr.push_event_queue ();
+panic_impossible ();
+}
-frame.add (&event_manager::pop_event_queue, &evmgr);
+void
-frame.add (&tree_evaluator::set_parser, &tw, tw.get_parser ());
+tree_evaluator::visit_arguments_block (tree_arguments_block&)
+{
-std::shared_ptr<push_parser>
+warning ("function arguments validation blocks are not supported; INCORRECT RESULTS ARE POSSIBLE");
-debug_parser (new push_parser (m_interpreter));
+}
-tw.set_parser (debug_parser);
+void
+tree_evaluator::visit_args_block_attribute_list (tree_args_block_attribute_list&)
-server_loop ();
+{
-}
+panic_impossible ();
-else
+}
-{
-if (! stopped_in_msg.empty ())
+void
-std::cerr << stopped_in_msg << std::endl;
+tree_evaluator::visit_args_block_validation_list (tree_args_block_validation_list&)
+{
-std::string tmp_prompt = prompt_arg;
+panic_impossible ();
-if (m_level > 0)
+}
-tmp_prompt = "[" + std::to_string (m_level) + "]" + prompt_arg;
+void
-frame.add (&input_system::set_PS1, &input_sys, input_sys.PS1 ());
+tree_evaluator::visit_arg_validation (tree_arg_validation&)
-input_sys.PS1 (tmp_prompt);
+{
+panic_impossible ();
-if (! m_interpreter.interactive ())
+}
-{
-void (interpreter::*interactive_fptr) (bool)
+void
-= &interpreter::interactive;
+tree_evaluator::visit_arg_size_spec (tree_arg_size_spec&)
-frame.add (interactive_fptr, &m_interpreter,
+{
-m_interpreter.interactive ());
+panic_impossible ();
+}
-m_interpreter.interactive (true);
+void
-// FIXME: should debugging be possible in an embedded
+tree_evaluator::visit_arg_validation_fcns (tree_arg_validation_fcns&)
-// interpreter?
+{
+panic_impossible ();
-application *app = application::app ();
+}
-if (app)
+void
-{
+tree_evaluator::visit_binary_expression (tree_binary_expression&)
-void (application::*forced_interactive_fptr) (bool)
+{
-= &application::forced_interactive;
+panic_impossible ();
-frame.add (forced_interactive_fptr, app,
+}
-app->forced_interactive ());
+void
-app->forced_interactive (true);
+tree_evaluator::visit_boolean_expression (tree_boolean_expression&)
-}
+{
-}
+panic_impossible ();
+}
-#if defined (OCTAVE_ENABLE_COMMAND_LINE_PUSH_PARSER)
+void
-input_reader reader (m_interpreter);
+tree_evaluator::visit_compound_binary_expression (tree_compound_binary_expression&)
+{
-push_parser debug_parser (m_interpreter);
+panic_impossible ();
+}
-#else
+void
-parser debug_parser (m_interpreter);
+tree_evaluator::visit_break_command (tree_break_command& cmd)
+{
-#endif
+if (m_echo_state)
+{
-error_system& es = m_interpreter.get_error_system ();
+int line = cmd.line ();
+if (line < 0)
-while (m_in_debug_repl)
+line = 1;
-{
+echo_code (line);
-if (m_execution_mode == EX_CONTINUE || tw.dbstep_flag ())
+m_echo_file_pos = line + 1;
+}
+if (m_debug_mode)
+do_breakpoint (cmd.is_active_breakpoint (*this));
+if (m_in_loop_command)
+m_breaking = 1;
+else
+error ("break must appear in a loop in the same file as loop command");
+}
+void
+tree_evaluator::visit_colon_expression (tree_colon_expression&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_continue_command (tree_continue_command& cmd)
+{
+if (m_echo_state)
+{
+int line = cmd.line ();
+if (line < 0)
+line = 1;
+echo_code (line);
+m_echo_file_pos = line + 1;
+}
+if (m_debug_mode)
+do_breakpoint (cmd.is_active_breakpoint (*this));
+if (m_in_loop_command)
+m_continuing = 1;
+}
+bool
+tree_evaluator::statement_printing_enabled (void)
+{
+return ! (m_silent_functions && (m_statement_context == SC_FUNCTION
+|| m_statement_context == SC_SCRIPT));
+}
+void
+tree_evaluator::reset_debug_state (void)
+{
+m_debug_mode = (m_bp_table.have_breakpoints ()
+|| m_dbstep_flag != 0
+|| m_break_on_next_stmt
+|| in_debug_repl ());
+}
+void
+tree_evaluator::reset_debug_state (bool mode)
+{
+m_debug_mode = mode;
+}
+void
+tree_evaluator::enter_debugger (const std::string& prompt)
+{
+unwind_protect frame;
+frame.add (command_history::ignore_entries,
+command_history::ignoring_entries ());
+command_history::ignore_entries (false);
+frame.add (&call_stack::restore_frame, &m_call_stack,
+m_call_stack.current_frame ());
+// Don't allow errors or warnings at the debug prompt to push us
+// into deeper levels of debugging.
+error_system& es = m_interpreter.get_error_system ();
+frame.add (&error_system::set_debug_on_error, &es, es.debug_on_error ());
+frame.add (&error_system::set_debug_on_warning, &es,
+es.debug_on_warning ());
+es.debug_on_error (false);
+es.debug_on_warning (false);
+// Go up to the nearest user code frame.
+m_debug_frame = m_call_stack.dbupdown (0);
+// FIXME: probably we just want to print one line, not the
+// entire statement, which might span many lines...
+//
+// tree_print_code tpc (octave_stdout);
+// stmt.accept (tpc);
+debugger *dbgr = new debugger (m_interpreter, m_debugger_stack.size ());
+m_debugger_stack.push (dbgr);
+frame.add ([=] (void)
+{
+delete m_debugger_stack.top ();
+m_debugger_stack.pop ();
+reset_debug_state ();
+});
+dbgr->repl (prompt);
+}
+void
+tree_evaluator::keyboard (const std::string& prompt)
+{
+enter_debugger (prompt);
+}
+void
+tree_evaluator::dbupdown (int n, bool verbose)
+{
+m_debug_frame = m_call_stack.dbupdown (n, verbose);
+}
+Matrix
+tree_evaluator::ignored_fcn_outputs (void) const
+{
+Matrix retval;
+const std::list<octave_lvalue> *lvalues = m_lvalue_list;
+if (! lvalues)
+return retval;
+octave_idx_type nbh = 0;
+for (const auto& lval : *lvalues)
+nbh += lval.is_black_hole ();
+if (nbh > 0)
+{
+retval.resize (1, nbh);
+octave_idx_type k = 0;
+octave_idx_type l = 0;
+for (const auto& lval : *lvalues)
+{
+if (lval.is_black_hole ())
+retval(l++) = k+1;
+k += lval.numel ();
+}
+}
+return retval;
+}
+// If NAME is an operator (like "+", "-", ...), convert it to the
+// corresponding function name ("plus", "minus", ...).
+static std::string
+get_operator_function_name (const std::string& name)
+{
+// Bow to the god of compatibility.
+// FIXME: it seems ugly to put this here, but there is no single
+// function in the parser that converts from the operator name to
+// the corresponding function name.  At least try to do it without N
+// string compares.
+// FIXME: .+, .-, **, and .** are deprecated but still need to be
+// handled here until they are removed.
+std::size_t len = name.length ();
+if (len == 3 && name == ".**")
+// deprecated
+return "power";
+else if (len == 2)
+{
+if (name[0] == '.')
+{
+switch (name[1])
+{
+case '\'':
+return "transpose";
+case '+':
+// deprecated
+return "plus";
+case '-':
+// deprecated
+return "minus";
+case '*':
+return "times";
+case '/':
+return "rdivide";
+case '^':
+return "power";
+case '\\':
+return "ldivide";
+default:
 break;
+}
-if (quitting_debugger ())
+}
+else if (name[1] == '=')
+{
+switch (name[0])
+{
+case '<':
+return "le";
+case '=':
+return "eq";
+case '>':
+return "ge";
+case '~':
+case '!':
+return "ne";
+default:
 break;
+}
-try
+}
-{
+else if (name == "**")
-debug_parser.reset ();
+// deprecated
+return "mpower";
-#if defined (OCTAVE_ENABLE_COMMAND_LINE_PUSH_PARSER)
+}
+else if (len == 1)
-int retval = 0;
+{
+switch (name[0])
-std::string prompt
+{
-= command_editor::decode_prompt_string (tmp_prompt);
+case '~':
+case '!':
-do
+return "not";
-{
-bool eof = false;
+case '\'':
-std::string input_line = reader.get_input (prompt, eof);
+return "ctranspose";
-if (eof)
+case '+':
-{
+return "plus";
-retval = EOF;
-break;
+case '-':
-}
+return "minus";
-retval = debug_parser.run (input_line, false);
+case '*':
+return "mtimes";
-prompt = command_editor::decode_prompt_string (input_sys.PS2 ());
-}
+case '/':
-while (retval < 0);
+return "mrdivide";
-#else
+case '^':
+return "mpower";
-int retval = debug_parser.run ();
+case '\\':
-#endif
+return "mldivide";
-if (command_editor::interrupt (false))
-{
+case '<':
-// Break regardless of m_execution_mode value.
+return "lt";
-quitting_debugger ();
+case '>':
+return "gt";
-break;
-}
+case '&':
-else
+return "and";
-{
-if (retval == 0)
+case '|':
-{
+return "or";
-std::shared_ptr<tree_statement_list> stmt_list
-= debug_parser.statement_list ();
+default:
-if (stmt_list)
-stmt_list->accept (tw);
-if (octave_completion_matches_called)
-octave_completion_matches_called = false;
-// FIXME: the following statement is here because
-// the last command may have been a dbup, dbdown, or
-// dbstep command that changed the current debug
-// frame.  If so, we need to reset the current frame
-// for the call stack.  But is this right way to do
-// this job?  What if the statement list was
-// something like "dbup; dbstack"?  Will the call to
-// dbstack use the right frame?  If not, how can we
-// fix this problem?
-tw.goto_frame (tw.debug_frame ());
-}
-octave_quit ();
-}
-}
-catch (const execution_exception& ee)
-{
-es.save_exception (ee);
-es.display_exception (ee);
-// Ignore errors when in debugging mode;
-m_interpreter.recover_from_exception ();
-}
-catch (const quit_debug_exception& qde)
-{
-if (qde.all ())
-throw;
-// Continue in this debug level.
-}
-}
-}
-}
-bool debugger::quitting_debugger (void) const
-{
-if (m_execution_mode == EX_QUIT)
-{
-// If there is no enclosing debug level or the top-level
-// repl is not active, handle dbquit the same as dbcont.
-if (m_level > 0 || m_interpreter.server_mode ()
-|| m_interpreter.in_top_level_repl ())
-throw quit_debug_exception ();
-else
-return true;
-}
-if (m_execution_mode == EX_QUIT_ALL)
-{
-// If the top-level repl is not active, handle "dbquit all"
-// the same as dbcont.
-if (m_interpreter.server_mode () || m_interpreter.in_top_level_repl ())
-throw quit_debug_exception (true);
-else
-return true;
-}
-return false;
-}
-bool tree_evaluator::at_top_level (void) const
-{
-return m_call_stack.at_top_level ();
-}
-std::string
-tree_evaluator::mfilename (const std::string& opt) const
-{
-std::string fname;
-octave_user_code *fcn = m_call_stack.current_user_code ();
-if (fcn)
-{
-fname = fcn->fcn_file_name ();
-if (fname.empty ())
-fname = fcn->name ();
-}
-if (opt == "fullpathext")
-return fname;
-std::size_t dpos = fname.rfind (sys::file_ops::dir_sep_char ());
-std::size_t epos = fname.rfind ('.');
-if (epos <= dpos+1)
-epos = std::string::npos;
-if (epos != std::string::npos)
-fname = fname.substr (0, epos);
-if (opt == "fullpath")
-return fname;
-if (dpos != std::string::npos)
-fname = fname.substr (dpos+1);
-return fname;
-}
-void tree_evaluator::parse_and_execute (const std::string& input,
-bool& incomplete_parse)
-{
-incomplete_parse = false;
-unwind_protect_var<bool> upv (m_in_top_level_repl, true);
-if (at_top_level ())
-{
-dbstep_flag (0);
-reset_debug_state ();
-}
-// FIXME: OK to do this job here, or should it be in the functions
-// that do the actual prompting?
-// Update the time stamp for the "prompt" so that automatically
-// finding modified files based on file modification times will
-// work.  In the future, we may do something completely different to
-// check for changes to files but for now, we rely on the prompt
-// time stamp to limit the checks for file modification times.
-Vlast_prompt_time.stamp ();
-bool eof = false;
-event_manager& evmgr = m_interpreter.get_event_manager ();
-if (command_history::add (input))
-evmgr.append_history (input);
-m_exit_status = m_parser->run (input, eof);
-if (m_exit_status == 0)
-{
-std::shared_ptr<tree_statement_list>
-stmt_list = m_parser->statement_list ();
-if (stmt_list)
-{
-command_editor::increment_current_command_number ();
-eval (stmt_list, m_interpreter.interactive ());
-evmgr.set_workspace ();
-}
-else if (m_parser->at_end_of_input ())
-m_exit_status = EOF;
-}
-else
-incomplete_parse = true;
-// FIXME: Should we be checking m_exit_status or incomplete_parse or
-// both here?  Could EOF have a value other than -1, and is there
-// possible confusion between that state and the parser returning -1?
-if (m_exit_status == -1)
-m_exit_status = 0;
-else
-m_parser->reset ();
-evmgr.pre_input_event ();
-}
-void tree_evaluator::get_line_and_eval (void)
-{
-std::mutex mtx;
-std::unique_lock<std::mutex> lock (mtx);
-std::condition_variable cv;
-bool incomplete_parse = false;
-bool evaluation_pending = false;
-bool exiting = false;
-input_system& input_sys = m_interpreter.get_input_system ();
-event_manager& evmgr = m_interpreter.get_event_manager ();
-while (true)
-{
-// FIXME: Detect EOF?  Use readline?  If
-// so, then we need to disable idle event loop hook function
-// execution.
-std::string ps = incomplete_parse ? input_sys.PS2 () : input_sys.PS1 ();
-std::cout << command_editor::decode_prompt_string (ps);
-std::string input;
-std::getline (std::cin, input);
-if (input.empty ())
-continue;
-incomplete_parse = false;
-evaluation_pending = true;
-exiting = false;
-evmgr.post_event
-([&] (interpreter& interp)
-{
-// INTERPRETER THREAD
-std::lock_guard<std::mutex> local_lock (mtx);
-try
-{
-interp.parse_and_execute (input, incomplete_parse);
-}
-catch (const exit_exception&)
-{
-evaluation_pending = false;
-exiting = true;
-cv.notify_all ();
-throw;
-}
-catch (const execution_exception& ee)
-{
-error_system& es = m_interpreter.get_error_system ();
-es.save_exception (ee);
-es.display_exception (ee);
-if (m_interpreter.interactive ())
-{
-m_interpreter.recover_from_exception ();
-m_parser->reset ();
-evaluation_pending = false;
-cv.notify_all ();
-}
-else
-{
-evaluation_pending = false;
-cv.notify_all ();
-throw exit_exception (1);
-}
-}
-catch (...)
-{
-evaluation_pending = false;
-cv.notify_all ();
-throw;
-}
-evaluation_pending = false;
-cv.notify_all ();
-});
-// Wait until evaluation is finished before prompting for input
-// again.
-cv.wait (lock, [&] { return ! evaluation_pending; });
-if (exiting)
 break;
 }
 }
-int tree_evaluator::repl (void)
+return name;
-{
+}
-// The big loop.  Read, Eval, Print, Loop.  Normally user
-// interaction at the command line in a terminal session, but we may
+// Creates a function handle that takes into account the context,
-// also end up here when reading from a pipe or when stdin is
+// finding local, nested, private, or sub functions.
-// connected to a file by the magic of input redirection.
+octave_value
-int exit_status = 0;
+tree_evaluator::make_fcn_handle (const std::string& name)
+{
-// FIXME: should this choice be a command-line option?  Note that we
+octave_value retval;
-// intend that the push parser interface only be used for
-// interactive sessions.
+// The str2func function can create a function handle with the name
+// of an operator (for example, "+").  If so, it is converted to the
-#if defined (OCTAVE_ENABLE_COMMAND_LINE_PUSH_PARSER)
+// name of the corresponding function ("+" -> "plus") and we create
-static bool use_command_line_push_parser = true;
+// a simple function handle using that name.
-#else
-static bool use_command_line_push_parser = false;
+std::string fcn_name = get_operator_function_name (name);
-#endif
+// If FCN_NAME is different from NAME, then NAME is an operator.  As
-// The following logic is written as it is to allow easy transition
+// of version 2020a, Matlab apparently uses the function name
-// to setting USE_COMMAND_LINE_PUSH_PARSER at run time and to
+// corresponding to the operator to search for private and local
-// simplify the logic of the main loop below by using the same
+// functions in the current scope but not(!) nested functions.
-// base_parser::run interface for both push and pull parsers.
+bool name_is_operator = fcn_name != name;
-std::shared_ptr<base_parser> repl_parser;
+std::size_t pos = fcn_name.find ('.');
-if (m_interpreter.interactive ())
-{
+if (pos != std::string::npos)
-if (use_command_line_push_parser)
+{
-{
+// Recognize (some of?  which ones?) the following cases
-push_parser *pp
+// and create something other than a simple function handle?
-= new push_parser (m_interpreter,
+// Should we just be checking for the last two when the first
-new input_reader (m_interpreter));
+// element of the dot-separated list is an object?  If so, then
+// should this syntax be limited to a dot-separated list with
-repl_parser = std::shared_ptr<base_parser> (pp);
+// exactly two elements?
-}
+//
-else
+//   object . method
-{
+//   object . static-method
-parser *pp = new parser (new lexer (m_interpreter));
+//
-repl_parser = std::shared_ptr<base_parser> (pp);
+// Code to do that duplicates some of simple_fcn_handle::call.
-}
-}
+// Only accept expressions that contain one '.' separator.
-else
-{
+// FIXME: The logic here is a bit complicated.  Is there a good
-parser *pp = new parser (new lexer (stdin, m_interpreter));
+// way to simplify it?
-repl_parser = std::shared_ptr<base_parser> (pp);
-}
+std::string meth_nm = fcn_name.substr (pos+1);
-do
+if (meth_nm.find ('.') == std::string::npos)
 {
-try
+std::string obj_nm = fcn_name.substr (0, pos);
-{
-unwind_protect_var<bool> upv (m_in_top_level_repl, true);
+// If obj_nm is an object in the current scope with a
+// method named meth_nm, create a classsimple handle.
-repl_parser->reset ();
+octave_value object = varval (obj_nm);
-if (at_top_level ())
-{
+if (object.is_defined () && object.is_classdef_object ())
-dbstep_flag (0);
+{
-reset_debug_state ();
+octave_classdef *cdef = object.classdef_object_value ();
-}
+if (cdef)
-exit_status = repl_parser->run ();
+{
+std::string class_nm = cdef->class_name ();
-if (exit_status == 0)
-{
+cdef_object cdef_obj = cdef->get_object ();
-std::shared_ptr<tree_statement_list>
-stmt_list = repl_parser->statement_list ();
+cdef_class cls = cdef_obj.get_class ();
-if (stmt_list)
+cdef_method meth = cls.find_method (meth_nm);
-{
-command_editor::increment_current_command_number ();
+if (meth.ok ())
+{
-eval (stmt_list, m_interpreter.interactive ());
+// If the method we found is static, create a
-}
+// new function name from the class name and
-else if (repl_parser->at_end_of_input ())
+// method name and create a simple function
-{
+// handle below.  Otherwise, create a class
-exit_status = EOF;
+// simple function handle.
-break;
-}
+if (meth.is_static ())
-}
+fcn_name = class_nm + '.' + meth_nm;
-}
+else
-catch (const interrupt_exception&)
-{
-m_interpreter.recover_from_exception ();
-// Required newline when the user does Ctrl+C at the prompt.
-if (m_interpreter.interactive ())
-octave_stdout << "\n";
-}
-catch (const index_exception& ie)
-{
-m_interpreter.recover_from_exception ();
-std::cerr << "error: unhandled index exception: "
-<< ie.message () << " -- trying to return to prompt"
-<< std::endl;
-}
-catch (const execution_exception& ee)
-{
-error_system& es = m_interpreter.get_error_system ();
-es.save_exception (ee);
-es.display_exception (ee);
-if (m_interpreter.interactive ())
-m_interpreter.recover_from_exception ();
-else
-{
-// We should exit with a nonzero status.
-exit_status = 1;
-break;
-}
-}
-catch (const quit_debug_exception&)
-{
-m_interpreter.recover_from_exception ();
-// FIXME: Does anything else need to happen here?
-}
-catch (const std::bad_alloc&)
-{
-m_interpreter.recover_from_exception ();
-std::cerr << "error: out of memory -- trying to return to prompt"
-<< std::endl;
-}
-}
-while (exit_status == 0);
-if (exit_status == EOF)
-{
-if (m_interpreter.interactive ())
-octave_stdout << "\n";
-exit_status = 0;
-}
-return exit_status;
-}
-int tree_evaluator::server_loop (void)
-{
-// Process events from the event queue.
-unwind_protect_var<bool> upv1 (m_server_mode, true);
-m_exit_status = 0;
-std::shared_ptr<push_parser> parser (new push_parser (m_interpreter));
-unwind_protect_var<std::shared_ptr<push_parser>> upv2 (m_parser, parser);
-// FIXME: We are currently resetting the parser after every call to
-// recover_from_exception.  This action should probably be handled
-// in a more consistent way, but resetting the parser in every call
-// to interpreter::recover_from_exception appears to cause
-// segfaults in the test suite.
-do
-{
-try
-{
-// FIXME: Should we call octave_quit in the octave::sleep
-// and/or command_editor::run_event_hooks functions?
-octave_quit ();
-// FIXME: Running the event queue should be decoupled from
-// the command_editor.  We should also use a condition
-// variable to manage the execution of entries in the queue
-// and eliminate the need for the busy-wait loop.
-command_editor::run_event_hooks ();
-release_unreferenced_dynamic_libraries ();
-sleep (0.1);
-}
-catch (const interrupt_exception&)
-{
-octave_interrupt_state = 1;
-m_interpreter.recover_from_exception ();
-m_parser->reset ();
-// Required newline when the user does Ctrl+C at the prompt.
-if (m_interpreter.interactive ())
-octave_stdout << "\n";
-}
-catch (const index_exception& e)
-{
-m_interpreter.recover_from_exception ();
-m_parser->reset ();
-std::cerr << "error: unhandled index exception: "
-<< e.message () << " -- trying to return to prompt"
-<< std::endl;
-}
-catch (const execution_exception& ee)
-{
-error_system& es = m_interpreter.get_error_system ();
-es.save_exception (ee);
-es.display_exception (ee);
-if (m_interpreter.interactive ())
-{
-m_interpreter.recover_from_exception ();
-m_parser->reset ();
-}
-else
-{
-// We should exit with a nonzero status.
-m_exit_status = 1;
-break;
-}
-}
-catch (const quit_debug_exception&)
-{
-octave_interrupt_state = 1;
-m_interpreter.recover_from_exception ();
-m_parser->reset ();
-}
-catch (const exit_exception& xe)
-{
-m_exit_status = xe.exit_status ();
-break;
-}
-catch (const std::bad_alloc&)
-{
-m_interpreter.recover_from_exception ();
-m_parser->reset ();
-std::cerr << "error: out of memory -- trying to return to prompt"
-<< std::endl;
-}
-}
-while (m_exit_status == 0);
-if (m_exit_status == EOF)
-{
-if (m_interpreter.interactive ())
-octave_stdout << "\n";
-m_exit_status = 0;
-}
-return m_exit_status;
-}
-void tree_evaluator::eval (std::shared_ptr<tree_statement_list>& stmt_list,
-bool interactive)
-{
-try
-{
-stmt_list->accept (*this);
-octave_quit ();
-if (! interactive)
-{
-bool quit = (m_returning || m_breaking);
-if (m_returning)
-m_returning = 0;
-if (m_breaking)
-m_breaking--;
-if (quit)
-return;
-}
-if (octave_completion_matches_called)
-octave_completion_matches_called = false;
-}
-catch (const quit_debug_exception&)
-{
-m_interpreter.recover_from_exception ();
-}
-}
-octave_value_list
-tree_evaluator::eval_string (const std::string& eval_str, bool silent,
-int& parse_status, int nargout)
-{
-octave_value_list retval;
-parser eval_parser (eval_str, m_interpreter);
-do
-{
-eval_parser.reset ();
-// If we are looking at
-//
-//   val = eval ("code");
-//
-// then don't allow code to be parsed as a command.
-if (nargout > 0)
-eval_parser.disallow_command_syntax ();
-parse_status = eval_parser.run ();
-if (parse_status == 0)
-{
-std::shared_ptr<tree_statement_list> stmt_list
-= eval_parser.statement_list ();
-if (stmt_list)
-{
-tree_statement *stmt = nullptr;
-if (stmt_list->length () == 1
-&& (stmt = stmt_list->front ())
-&& stmt->is_expression ())
-{
-tree_expression *expr = stmt->expression ();
-if (silent)
-expr->set_print_flag (false);
-retval = expr->evaluate_n (*this, nargout);
-bool do_bind_ans = false;
-if (expr->is_identifier ())
-do_bind_ans = ! is_variable (expr);
-else
-do_bind_ans = ! expr->is_assignment_expression ();
-if (do_bind_ans && ! retval.empty ())
-bind_ans (retval(0), expr->print_result ());
-if (nargout == 0)
-retval = octave_value_list ();
-}
-else if (nargout == 0)
-stmt_list->accept (*this);
-else
-error ("eval: invalid use of statement list");
-if (returning () || breaking () || continuing ())
-break;
-}
-else if (eval_parser.at_end_of_input ())
-break;
-}
-}
-while (parse_status == 0);
-return retval;
-}
-octave_value tree_evaluator::eval_string (const std::string& eval_str,
-bool silent, int& parse_status)
-{
-octave_value retval;
-octave_value_list tmp = eval_string (eval_str, silent, parse_status, 1);
-if (! tmp.empty ())
-retval = tmp(0);
-return retval;
-}
-octave_value_list tree_evaluator::eval_string (const octave_value& arg,
-bool silent, int& parse_status,
-int nargout)
-{
-std::string s = arg.xstring_value ("eval: expecting string argument");
-return eval_string (s, silent, parse_status, nargout);
-}
-octave_value_list tree_evaluator::eval (const std::string& try_code,
-int nargout)
-{
-int parse_status = 0;
-return eval_string (try_code, nargout > 0, parse_status, nargout);
-}
-octave_value_list tree_evaluator::eval (const std::string& try_code,
-const std::string& catch_code,
-int nargout)
-{
-octave_value_list retval;
-error_system& es = m_interpreter.get_error_system ();
-int parse_status = 0;
-bool execution_error = false;
-octave_value_list tmp;
-try
-{
-tmp = eval_string (try_code, nargout > 0, parse_status, nargout);
-}
-catch (const execution_exception& ee)
-{
-es.save_exception (ee);
-m_interpreter.recover_from_exception ();
-execution_error = true;
-}
-if (parse_status != 0 || execution_error)
-{
-tmp = eval_string (catch_code, nargout > 0, parse_status, nargout);
-retval = (nargout > 0) ? tmp : octave_value_list ();
-}
-else
-{
-if (nargout > 0)
-retval = tmp;
-// FIXME: we should really be rethrowing whatever
-// exception occurred, not just throwing an
-// execution exception.
-if (execution_error)
-throw execution_exception ();
-}
-return retval;
-}
-octave_value_list tree_evaluator::evalin (const std::string& context,
-const std::string& try_code,
-int nargout)
-{
-unwind_action act ([=] (std::size_t frm)
-{
-m_call_stack.restore_frame (frm);
-}, m_call_stack.current_frame ());
-if (context == "caller")
-m_call_stack.goto_caller_frame ();
-else if (context == "base")
-m_call_stack.goto_base_frame ();
-else
-error (R"(evalin: CONTEXT must be "caller" or "base")");
-int parse_status = 0;
-return eval_string (try_code, nargout > 0, parse_status, nargout);
-}
-octave_value_list tree_evaluator::evalin (const std::string& context,
-const std::string& try_code,
-const std::string& catch_code,
-int nargout)
-{
-octave_value_list retval;
-unwind_action act1 ([=] (std::size_t frm)
 {
-m_call_stack.restore_frame (frm);
+octave_value meth_fcn = meth.get_function ();
-}, m_call_stack.current_frame ());
+octave_fcn_handle *fh
-if (context == "caller")
+= new octave_fcn_handle (object, meth_fcn,
-m_call_stack.goto_caller_frame ();
+class_nm, meth_nm);
-else if (context == "base")
-m_call_stack.goto_base_frame ();
+return octave_value (fh);
-else
+}
-error (R"(evalin: CONTEXT must be "caller" or "base")");
+}
+}
-error_system& es = m_interpreter.get_error_system ();
+}
+}
-int parse_status = 0;
+// We didn't match anything above, so create handle to SIMPLE
-bool execution_error = false;
+// package function or static class method.  Function resolution
+// is performed when the handle is used.
-octave_value_list tmp;
+return octave_value (new octave_fcn_handle (fcn_name));
-try
+}
-{
-tmp = eval_string (try_code, nargout > 0, parse_status, nargout);
+// If the function name refers to a sub/local/private function or a
-}
+// class method/constructor, create scoped function handle that is
-catch (const execution_exception& ee)
+// bound to that function.  Use the same precedence list as
-{
+// fcn_info::find but limit search to the following types of
-es.save_exception (ee);
+// functions:
-m_interpreter.recover_from_exception ();
+//
+//   nested functions (and subfunctions)
-execution_error = true;
+//   local functions in the current file
-}
+//   private function
+//   class method
-if (parse_status != 0 || execution_error)
+//
-{
+// For anything else we create a simple function handle that will be
-tmp = eval_string (catch_code, nargout > 0, parse_status, nargout);
+// resolved dynamically in the scope where it is evaluated.
-retval = (nargout > 0) ? tmp : octave_value_list ();
+symbol_scope curr_scope = get_current_scope ();
-}
-else
+symbol_table& symtab = m_interpreter.get_symbol_table ();
-{
-if (nargout > 0)
+if (curr_scope)
-retval = tmp;
+{
+octave_value ov_fcn
-// FIXME: we should really be rethrowing whatever
+= symtab.find_scoped_function (fcn_name, curr_scope);
-// exception occurred, not just throwing an
-// execution exception.
+// If name is operator, we are in Fstr2func, so skip the stack
-if (execution_error)
+// frame for that function.
-throw execution_exception ();
-}
+bool skip_first = name_is_operator;
+octave_function *curr_fcn = current_function (skip_first);
-return retval;
-}
+if (ov_fcn.is_defined ())
+{
-void
+octave_function *fcn = ov_fcn.function_value ();
-tree_evaluator::visit_anon_fcn_handle (tree_anon_fcn_handle&)
-{
+if (fcn->is_nested_function ())
-panic_impossible ();
+{
-}
+if (! name_is_operator)
+{
-void
+// Get current stack frame and return handle to nested
-tree_evaluator::visit_argument_list (tree_argument_list&)
+// function.
-{
-panic_impossible ();
+std::shared_ptr<stack_frame> frame
-}
+= m_call_stack.get_current_stack_frame ();
-void
+// If we are creating a handle to the current
-tree_evaluator::visit_arguments_block (tree_arguments_block&)
+// function or a handle to a sibling function (i.e.,
-{
+// not a child of the current function), then use
-warning ("function arguments validation blocks are not supported; INCORRECT RESULTS ARE POSSIBLE");
+// the calling stack frame as the context instead of
-}
+// the current stack frame.
-void
+// FIXME:  Do we need both checks here or is it
-tree_evaluator::visit_args_block_attribute_list (tree_args_block_attribute_list&)
+// sufficient to check that the parent of curr_fcn
-{
+// is the same as the parent of fcn?  Is there any
-panic_impossible ();
+// case where curr_fcn could be nullptr, or does
-}
+// that indicate an internal error of some kind?
-void
+if (curr_fcn
-tree_evaluator::visit_args_block_validation_list (tree_args_block_validation_list&)
+&& (fcn_name == curr_fcn->name ()
-{
+|| fcn->parent_fcn_name () == curr_fcn->parent_fcn_name ()))
-panic_impossible ();
+frame = frame->access_link ();
-}
+octave_fcn_handle *fh
-void
+= new octave_fcn_handle (ov_fcn, fcn_name, frame);
-tree_evaluator::visit_arg_validation (tree_arg_validation&)
-{
+return octave_value (fh);
-panic_impossible ();
+}
 }
+else if (fcn->is_subfunction ()
-void
+/* || fcn->is_localfunction () */
-tree_evaluator::visit_arg_size_spec (tree_arg_size_spec&)
+|| fcn->is_private_function ())
 {
-panic_impossible ();
+// Create handle to SCOPED function (sub/local function
-}
+// or private function).
-void
+std::list<std::string> parentage = fcn->parent_fcn_names ();
-tree_evaluator::visit_arg_validation_fcns (tree_arg_validation_fcns&)
-{
+octave_fcn_handle *fh
-panic_impossible ();
+= new octave_fcn_handle (ov_fcn, fcn_name, parentage);
-}
+return octave_value (fh);
-void
+}
-tree_evaluator::visit_binary_expression (tree_binary_expression&)
+}
-{
-panic_impossible ();
+if (curr_fcn && (curr_fcn->is_class_method ()
-}
+|| curr_fcn->is_class_constructor ()))
+{
-void
+std::string dispatch_class = curr_fcn->dispatch_class ();
-tree_evaluator::visit_boolean_expression (tree_boolean_expression&)
-{
+octave_value ov_meth
-panic_impossible ();
+= symtab.find_method (fcn_name, dispatch_class);
-}
+if (ov_meth.is_defined ())
-void
+{
-tree_evaluator::visit_compound_binary_expression (tree_compound_binary_expression&)
+octave_function *fcn = ov_meth.function_value ();
-{
-panic_impossible ();
+// FIXME: do we need to check that it is a method of
-}
+// dispatch_class, or is it sufficient to just check
+// that it is a method?
-void
-tree_evaluator::visit_break_command (tree_break_command& cmd)
+if (fcn->is_class_method ())
 {
-if (m_echo_state)
+// Create CLASSSIMPLE handle to method but don't
-{
+// bind to the method.  Lookup will be done later.
-int line = cmd.line ();
-if (line < 0)
+octave_fcn_handle *fh
-line = 1;
+= new octave_fcn_handle (dispatch_class, fcn_name);
-echo_code (line);
-m_echo_file_pos = line + 1;
+return octave_value (fh);
 }
+}
-if (m_debug_mode)
+}
-do_breakpoint (cmd.is_active_breakpoint (*this));
+}
-if (m_in_loop_command)
+octave_value ov_fcn = symtab.find_user_function (fcn_name);
-m_breaking = 1;
-else
+// Create handle to SIMPLE function.  If the function is not found
-error ("break must appear in a loop in the same file as loop command");
+// now, then we will look for it again when the handle is used.
-}
+return octave_value (new octave_fcn_handle (ov_fcn, fcn_name));
-void
+}
-tree_evaluator::visit_colon_expression (tree_colon_expression&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_continue_command (tree_continue_command& cmd)
-{
-if (m_echo_state)
-{
-int line = cmd.line ();
-if (line < 0)
-line = 1;
-echo_code (line);
-m_echo_file_pos = line + 1;
-}
-if (m_debug_mode)
-do_breakpoint (cmd.is_active_breakpoint (*this));
-if (m_in_loop_command)
-m_continuing = 1;
-}
-bool
-tree_evaluator::statement_printing_enabled (void)
-{
-return ! (m_silent_functions && (m_statement_context == SC_FUNCTION
-|| m_statement_context == SC_SCRIPT));
-}
-void
-tree_evaluator::reset_debug_state (void)
-{
-m_debug_mode = (m_bp_table.have_breakpoints ()
-|| m_dbstep_flag != 0
-|| m_break_on_next_stmt
-|| in_debug_repl ());
-}
-void
-tree_evaluator::reset_debug_state (bool mode)
-{
-m_debug_mode = mode;
-}
-void
-tree_evaluator::enter_debugger (const std::string& prompt)
-{
-unwind_protect frame;
-frame.add (command_history::ignore_entries,
-command_history::ignoring_entries ());
-command_history::ignore_entries (false);
-frame.add (&call_stack::restore_frame, &m_call_stack,
-m_call_stack.current_frame ());
-// Don't allow errors or warnings at the debug prompt to push us
-// into deeper levels of debugging.
-error_system& es = m_interpreter.get_error_system ();
-frame.add (&error_system::set_debug_on_error, &es, es.debug_on_error ());
-frame.add (&error_system::set_debug_on_warning, &es,
-es.debug_on_warning ());
-es.debug_on_error (false);
-es.debug_on_warning (false);
-// Go up to the nearest user code frame.
-m_debug_frame = m_call_stack.dbupdown (0);
-// FIXME: probably we just want to print one line, not the
-// entire statement, which might span many lines...
-//
-// tree_print_code tpc (octave_stdout);
-// stmt.accept (tpc);
-debugger *dbgr = new debugger (m_interpreter, m_debugger_stack.size ());
-m_debugger_stack.push (dbgr);
-frame.add ([=] (void)
-{
-delete m_debugger_stack.top ();
-m_debugger_stack.pop ();
-reset_debug_state ();
-});
-dbgr->repl (prompt);
-}
-void
-tree_evaluator::keyboard (const std::string& prompt)
-{
-enter_debugger (prompt);
-}
-void
-tree_evaluator::dbupdown (int n, bool verbose)
-{
-m_debug_frame = m_call_stack.dbupdown (n, verbose);
-}
-Matrix
-tree_evaluator::ignored_fcn_outputs (void) const
-{
-Matrix retval;
-const std::list<octave_lvalue> *lvalues = m_lvalue_list;
-if (! lvalues)
-return retval;
-octave_idx_type nbh = 0;
-for (const auto& lval : *lvalues)
-nbh += lval.is_black_hole ();
-if (nbh > 0)
-{
-retval.resize (1, nbh);
-octave_idx_type k = 0;
-octave_idx_type l = 0;
-for (const auto& lval : *lvalues)
-{
-if (lval.is_black_hole ())
-retval(l++) = k+1;
-k += lval.numel ();
-}
-}
-return retval;
-}
-// If NAME is an operator (like "+", "-", ...), convert it to the
-// corresponding function name ("plus", "minus", ...).
-static std::string
-get_operator_function_name (const std::string& name)
-{
-// Bow to the god of compatibility.
-// FIXME: it seems ugly to put this here, but there is no single
-// function in the parser that converts from the operator name to
-// the corresponding function name.  At least try to do it without N
-// string compares.
-// FIXME: .+, .-, **, and .** are deprecated but still need to be
-// handled here until they are removed.
-std::size_t len = name.length ();
-if (len == 3 && name == ".**")
-// deprecated
-return "power";
-else if (len == 2)
-{
-if (name[0] == '.')
-{
-switch (name[1])
-{
-case '\'':
-return "transpose";
-case '+':
-// deprecated
-return "plus";
-case '-':
-// deprecated
-return "minus";
-case '*':
-return "times";
-case '/':
-return "rdivide";
-case '^':
-return "power";
-case '\\':
-return "ldivide";
-default:
-break;
-}
-}
-else if (name[1] == '=')
-{
-switch (name[0])
-{
-case '<':
-return "le";
-case '=':
-return "eq";
-case '>':
-return "ge";
-case '~':
-case '!':
-return "ne";
-default:
-break;
-}
-}
-else if (name == "**")
-// deprecated
-return "mpower";
-}
-else if (len == 1)
-{
-switch (name[0])
-{
-case '~':
-case '!':
-return "not";
-case '\'':
-return "ctranspose";
-case '+':
-return "plus";
-case '-':
-return "minus";
-case '*':
-return "mtimes";
-case '/':
-return "mrdivide";
-case '^':
-return "mpower";
-case '\\':
-return "mldivide";
-case '<':
-return "lt";
-case '>':
-return "gt";
-case '&':
-return "and";
-case '|':
-return "or";
-default:
-break;
-}
-}
-return name;
-}
-// Creates a function handle that takes into account the context,
-// finding local, nested, private, or sub functions.
-octave_value
-tree_evaluator::make_fcn_handle (const std::string& name)
-{
-octave_value retval;
-// The str2func function can create a function handle with the name
-// of an operator (for example, "+").  If so, it is converted to the
-// name of the corresponding function ("+" -> "plus") and we create
-// a simple function handle using that name.
-std::string fcn_name = get_operator_function_name (name);
-// If FCN_NAME is different from NAME, then NAME is an operator.  As
-// of version 2020a, Matlab apparently uses the function name
-// corresponding to the operator to search for private and local
-// functions in the current scope but not(!) nested functions.
-bool name_is_operator = fcn_name != name;
-std::size_t pos = fcn_name.find ('.');
-if (pos != std::string::npos)
-{
-// Recognize (some of?  which ones?) the following cases
-// and create something other than a simple function handle?
-// Should we just be checking for the last two when the first
-// element of the dot-separated list is an object?  If so, then
-// should this syntax be limited to a dot-separated list with
-// exactly two elements?
-//
-//   object . method
-//   object . static-method
-//
-// Code to do that duplicates some of simple_fcn_handle::call.
-// Only accept expressions that contain one '.' separator.
-// FIXME: The logic here is a bit complicated.  Is there a good
-// way to simplify it?
-std::string meth_nm = fcn_name.substr (pos+1);
-if (meth_nm.find ('.') == std::string::npos)
-{
-std::string obj_nm = fcn_name.substr (0, pos);
-// If obj_nm is an object in the current scope with a
-// method named meth_nm, create a classsimple handle.
-octave_value object = varval (obj_nm);
-if (object.is_defined () && object.is_classdef_object ())
-{
-octave_classdef *cdef = object.classdef_object_value ();
-if (cdef)
-{
-std::string class_nm = cdef->class_name ();
-cdef_object cdef_obj = cdef->get_object ();
-cdef_class cls = cdef_obj.get_class ();
-cdef_method meth = cls.find_method (meth_nm);
-if (meth.ok ())
-{
-// If the method we found is static, create a
-// new function name from the class name and
-// method name and create a simple function
-// handle below.  Otherwise, create a class
-// simple function handle.
-if (meth.is_static ())
-fcn_name = class_nm + '.' + meth_nm;
-else
-{
-octave_value meth_fcn = meth.get_function ();
-octave_fcn_handle *fh
-= new octave_fcn_handle (object, meth_fcn,
-class_nm, meth_nm);
-return octave_value (fh);
-}
-}
-}
-}
-}
-// We didn't match anything above, so create handle to SIMPLE
-// package function or static class method.  Function resolution
-// is performed when the handle is used.
-return octave_value (new octave_fcn_handle (fcn_name));
-}
-// If the function name refers to a sub/local/private function or a
-// class method/constructor, create scoped function handle that is
-// bound to that function.  Use the same precedence list as
-// fcn_info::find but limit search to the following types of
-// functions:
-//
-//   nested functions (and subfunctions)
-//   local functions in the current file
-//   private function
-//   class method
-//
-// For anything else we create a simple function handle that will be
-// resolved dynamically in the scope where it is evaluated.
-symbol_scope curr_scope = get_current_scope ();
-symbol_table& symtab = m_interpreter.get_symbol_table ();
-if (curr_scope)
-{
-octave_value ov_fcn
-= symtab.find_scoped_function (fcn_name, curr_scope);
-// If name is operator, we are in Fstr2func, so skip the stack
-// frame for that function.
-bool skip_first = name_is_operator;
-octave_function *curr_fcn = current_function (skip_first);
-if (ov_fcn.is_defined ())
-{
-octave_function *fcn = ov_fcn.function_value ();
-if (fcn->is_nested_function ())
-{
-if (! name_is_operator)
-{
-// Get current stack frame and return handle to nested
-// function.
-std::shared_ptr<stack_frame> frame
-= m_call_stack.get_current_stack_frame ();
-// If we are creating a handle to the current
-// function or a handle to a sibling function (i.e.,
-// not a child of the current function), then use
-// the calling stack frame as the context instead of
-// the current stack frame.
-// FIXME:  Do we need both checks here or is it
-// sufficient to check that the parent of curr_fcn
-// is the same as the parent of fcn?  Is there any
-// case where curr_fcn could be nullptr, or does
-// that indicate an internal error of some kind?
-if (curr_fcn
-&& (fcn_name == curr_fcn->name ()
-|| fcn->parent_fcn_name () == curr_fcn->parent_fcn_name ()))
-frame = frame->access_link ();
-octave_fcn_handle *fh
-= new octave_fcn_handle (ov_fcn, fcn_name, frame);
-return octave_value (fh);
-}
-}
-else if (fcn->is_subfunction ()
-/* || fcn->is_localfunction () */
-|| fcn->is_private_function ())
-{
-// Create handle to SCOPED function (sub/local function
-// or private function).
-std::list<std::string> parentage = fcn->parent_fcn_names ();
-octave_fcn_handle *fh
-= new octave_fcn_handle (ov_fcn, fcn_name, parentage);
-return octave_value (fh);
-}
-}
-if (curr_fcn && (curr_fcn->is_class_method ()
-|| curr_fcn->is_class_constructor ()))
-{
-std::string dispatch_class = curr_fcn->dispatch_class ();
-octave_value ov_meth
-= symtab.find_method (fcn_name, dispatch_class);
-if (ov_meth.is_defined ())
-{
-octave_function *fcn = ov_meth.function_value ();
-// FIXME: do we need to check that it is a method of
-// dispatch_class, or is it sufficient to just check
-// that it is a method?
-if (fcn->is_class_method ())
-{
-// Create CLASSSIMPLE handle to method but don't
-// bind to the method.  Lookup will be done later.
-octave_fcn_handle *fh
-= new octave_fcn_handle (dispatch_class, fcn_name);
-return octave_value (fh);
-}
-}
-}
-}
-octave_value ov_fcn = symtab.find_user_function (fcn_name);
-// Create handle to SIMPLE function.  If the function is not found
-// now, then we will look for it again when the handle is used.
-return octave_value (new octave_fcn_handle (ov_fcn, fcn_name));
-}
 /*
 %!test
 %! x = {".**", "power";
 %!      ".'", "transpose";
 %! for i = 1:rows (x)
 %!   assert (functions (str2func (x{i,1})).function, x{i,2});
 %! endfor
 */
 octave_value
 tree_evaluator::evaluate (tree_decl_elt *elt)
+{
+// Do not allow functions to return null values.
+tree_identifier *id = elt->ident ();
+return id ? id->evaluate (*this).storable_value () : octave_value ();
+}
+bool
+tree_evaluator::is_variable (const std::string& name) const
+{
+std::shared_ptr<stack_frame> frame
+= m_call_stack.get_current_stack_frame ();
+return frame->is_variable (name);
+}
+bool
+tree_evaluator::is_local_variable (const std::string& name) const
+{
+std::shared_ptr<stack_frame> frame
+= m_call_stack.get_current_stack_frame ();
+return frame->is_local_variable (name);
+}
+bool
+tree_evaluator::is_variable (const tree_expression *expr) const
+{
+if (expr->is_identifier ())
+{
+const tree_identifier *id
+= dynamic_cast<const tree_identifier *> (expr);
+if (id->is_black_hole ())
+return false;
+return is_variable (id->symbol ());
+}
+return false;
+}
+bool
+tree_evaluator::is_defined (const tree_expression *expr) const
+{
+if (expr->is_identifier ())
+{
+const tree_identifier *id
+= dynamic_cast<const tree_identifier *> (expr);
+return is_defined (id->symbol ());
+}
+return false;
+}
+bool
+tree_evaluator::is_variable (const symbol_record& sym) const
+{
+std::shared_ptr<stack_frame> frame
+= m_call_stack.get_current_stack_frame ();
+return frame->is_variable (sym);
+}
+bool
+tree_evaluator::is_defined (const symbol_record& sym) const
+{
+std::shared_ptr<stack_frame> frame
+= m_call_stack.get_current_stack_frame ();
+return frame->is_defined (sym);
+}
+bool tree_evaluator::is_global (const std::string& name) const
+{
+std::shared_ptr<stack_frame> frame
+= m_call_stack.get_current_stack_frame ();
+return frame->is_global (name);
+}
+octave_value
+tree_evaluator::varval (const symbol_record& sym) const
+{
+std::shared_ptr<stack_frame> frame
+= m_call_stack.get_current_stack_frame ();
+return frame->varval (sym);
+}
+octave_value
+tree_evaluator::varval (const std::string& name) const
+{
+std::shared_ptr<stack_frame> frame
+= m_call_stack.get_current_stack_frame ();
+return frame->varval (name);
+}
+void tree_evaluator::install_variable (const std::string& name,
+const octave_value& value,
+bool global)
+{
+std::shared_ptr<stack_frame> frame
+= m_call_stack.get_current_stack_frame ();
+return frame->install_variable (name, value, global);
+}
+octave_value
+tree_evaluator::global_varval (const std::string& name) const
+{
+return m_call_stack.global_varval (name);
+}
+octave_value&
+tree_evaluator::global_varref (const std::string& name)
+{
+return m_call_stack.global_varref (name);
+}
+void
+tree_evaluator::global_assign (const std::string& name,
+const octave_value& val)
+{
+m_call_stack.global_varref (name) = val;
+}
+octave_value
+tree_evaluator::top_level_varval (const std::string& name) const
+{
+return m_call_stack.get_top_level_value (name);
+}
+void
+tree_evaluator::top_level_assign (const std::string& name,
+const octave_value& val)
+{
+m_call_stack.set_top_level_value (name, val);
+}
+void
+tree_evaluator::assign (const std::string& name, const octave_value& val)
+{
+std::shared_ptr<stack_frame> frame
+= m_call_stack.get_current_stack_frame ();
+frame->assign (name, val);
+}
+void
+tree_evaluator::assignin (const std::string& context,
+const std::string& name, const octave_value& val)
+{
+// FIXME: Can this be done without an unwind-protect frame, simply
+// by getting a reference to the caller or base stack frame and
+// calling assign on that?
+unwind_action act ([=] (std::size_t frm)
 {
-// Do not allow functions to return null values.
+m_call_stack.restore_frame (frm);
+}, m_call_stack.current_frame ());
-tree_identifier *id = elt->ident ();
+if (context == "caller")
-return id ? id->evaluate (*this).storable_value () : octave_value ();
+m_call_stack.goto_caller_frame ();
-}
+else if (context == "base")
+m_call_stack.goto_base_frame ();
-bool
+else
-tree_evaluator::is_variable (const std::string& name) const
+error (R"(assignin: CONTEXT must be "caller" or "base")");
-{
-std::shared_ptr<stack_frame> frame
+if (valid_identifier (name))
-= m_call_stack.get_current_stack_frame ();
+{
+// Put the check here so that we don't slow down assignments
-return frame->is_variable (name);
+// generally.  Any that go through Octave's parser should have
-}
+// already been checked.
-bool
+if (iskeyword (name))
-tree_evaluator::is_local_variable (const std::string& name) const
+error ("assignin: invalid assignment to keyword '%s'",
-{
+name.c_str ());
-std::shared_ptr<stack_frame> frame
-= m_call_stack.get_current_stack_frame ();
+assign (name, val);
+}
-return frame->is_local_variable (name);
+else
-}
+error ("assignin: invalid variable name '%s'", name.c_str ());
+}
-bool
-tree_evaluator::is_variable (const tree_expression *expr) const
+void
-{
+tree_evaluator::source_file (const std::string& file_name,
-if (expr->is_identifier ())
+const std::string& context,
-{
+bool verbose, bool require_file)
-const tree_identifier *id
+{
-= dynamic_cast<const tree_identifier *> (expr);
+// Map from absolute name of script file to recursion level.  We
+// use a map instead of simply placing a limit on recursion in the
-if (id->is_black_hole ())
+// source_file function so that two mutually recursive scripts
-return false;
+// written as
+//
-return is_variable (id->symbol ());
+//   foo1.m:
-}
+//   ------
+//   foo2
-return false;
+//
-}
+//   foo2.m:
+//   ------
-bool
+//   foo1
-tree_evaluator::is_defined (const tree_expression *expr) const
+//
-{
+// and called with
-if (expr->is_identifier ())
+//
-{
+//   foo1
-const tree_identifier *id
+//
-= dynamic_cast<const tree_identifier *> (expr);
+// (for example) will behave the same if they are written as
+//
-return is_defined (id->symbol ());
+//   foo1.m:
-}
+//   ------
+//   source ("foo2.m")
-return false;
+//
-}
+//   foo2.m:
+//   ------
-bool
+//   source ("foo1.m")
-tree_evaluator::is_variable (const symbol_record& sym) const
+//
-{
+// and called with
-std::shared_ptr<stack_frame> frame
+//
-= m_call_stack.get_current_stack_frame ();
+//   source ("foo1.m")
+//
-return frame->is_variable (sym);
+// (for example).
-}
+static std::map<std::string, int> source_call_depth;
-bool
-tree_evaluator::is_defined (const symbol_record& sym) const
+std::string file_full_name
-{
+= sys::file_ops::tilde_expand (file_name);
-std::shared_ptr<stack_frame> frame
-= m_call_stack.get_current_stack_frame ();
+std::size_t pos
+= file_full_name.find_last_of (sys::file_ops::dir_sep_str ());
-return frame->is_defined (sym);
-}
+std::string dir_name = file_full_name.substr (0, pos);
-bool tree_evaluator::is_global (const std::string& name) const
+file_full_name = sys::env::make_absolute (file_full_name);
-{
-std::shared_ptr<stack_frame> frame
+unwind_protect frame;
-= m_call_stack.get_current_stack_frame ();
+if (source_call_depth.find (file_full_name) == source_call_depth.end ())
-return frame->is_global (name);
+source_call_depth[file_full_name] = -1;
-}
+frame.protect_var (source_call_depth[file_full_name]);
-octave_value
-tree_evaluator::varval (const symbol_record& sym) const
+source_call_depth[file_full_name]++;
-{
-std::shared_ptr<stack_frame> frame
+if (source_call_depth[file_full_name] >= max_recursion_depth ())
-= m_call_stack.get_current_stack_frame ();
+error ("max_recursion_depth exceeded");
-return frame->varval (sym);
+if (! context.empty ())
-}
+{
+frame.add (&call_stack::restore_frame, &m_call_stack,
-octave_value
+m_call_stack.current_frame ());
-tree_evaluator::varval (const std::string& name) const
-{
+if (context == "caller")
-std::shared_ptr<stack_frame> frame
+m_call_stack.goto_caller_frame ();
-= m_call_stack.get_current_stack_frame ();
+else if (context == "base")
+m_call_stack.goto_base_frame ();
-return frame->varval (name);
+else
-}
+error (R"(source: CONTEXT must be "caller" or "base")");
+}
-void tree_evaluator::install_variable (const std::string& name,
-const octave_value& value,
+// Find symbol name that would be in symbol_table, if it were loaded.
-bool global)
+std::size_t dir_end
-{
+= file_name.find_last_of (sys::file_ops::dir_sep_chars ());
-std::shared_ptr<stack_frame> frame
+dir_end = (dir_end == std::string::npos) ? 0 : dir_end + 1;
-= m_call_stack.get_current_stack_frame ();
+std::size_t extension = file_name.find_last_of ('.');
-return frame->install_variable (name, value, global);
+if (extension == std::string::npos)
-}
+extension = file_name.length ();
-octave_value
+std::string symbol = file_name.substr (dir_end, extension - dir_end);
-tree_evaluator::global_varval (const std::string& name) const
+std::string full_name = sys::canonicalize_file_name (file_name);
-{
-return m_call_stack.global_varval (name);
+// Check if this file is already loaded (or in the path)
-}
+symbol_table& symtab = m_interpreter.get_symbol_table ();
+octave_value ov_code = symtab.fcn_table_find (symbol);
-octave_value&
-tree_evaluator::global_varref (const std::string& name)
+// For compatibility with Matlab, accept both scripts and
-{
+// functions.
-return m_call_stack.global_varref (name);
-}
+if (ov_code.is_user_code ())
+{
-void
+octave_user_code *code = ov_code.user_code_value ();
-tree_evaluator::global_assign (const std::string& name,
-const octave_value& val)
+if (! code
-{
+|| (sys::canonicalize_file_name (code->fcn_file_name ())
-m_call_stack.global_varref (name) = val;
+!= full_name))
-}
+{
+// Wrong file, so load it below.
-octave_value
+ov_code = octave_value ();
-tree_evaluator::top_level_varval (const std::string& name) const
+}
-{
+}
-return m_call_stack.get_top_level_value (name);
+else
-}
+{
+// Not a script, so load it below.
-void
+ov_code = octave_value ();
-tree_evaluator::top_level_assign (const std::string& name,
+}
-const octave_value& val)
-{
+// If no symbol of this name, or the symbol is for a different
-m_call_stack.set_top_level_value (name, val);
+// file, load.
-}
+if (ov_code.is_undefined ())
-void
+{
-tree_evaluator::assign (const std::string& name, const octave_value& val)
+try
 {
-std::shared_ptr<stack_frame> frame
+ov_code = parse_fcn_file (m_interpreter, file_full_name,
-= m_call_stack.get_current_stack_frame ();
+file_name, dir_name, "", "",
+require_file, true, false, false);
-frame->assign (name, val);
+}
-}
+catch (execution_exception& ee)
+{
-void
+error (ee, "source: error sourcing file '%s'",
-tree_evaluator::assignin (const std::string& context,
+file_full_name.c_str ());
-const std::string& name, const octave_value& val)
+}
-{
+}
-// FIXME: Can this be done without an unwind-protect frame, simply
-// by getting a reference to the caller or base stack frame and
+// Return or error if we don't have a valid script or function.
-// calling assign on that?
+if (ov_code.is_undefined ())
-unwind_action act ([=] (std::size_t frm)
+return;
-{
-m_call_stack.restore_frame (frm);
+if (! ov_code.is_user_code ())
-}, m_call_stack.current_frame ());
+error ("source: %s is not a script", full_name.c_str ());
-if (context == "caller")
+if (verbose)
-m_call_stack.goto_caller_frame ();
+{
-else if (context == "base")
+octave_stdout << "executing commands from " << full_name << " ... ";
-m_call_stack.goto_base_frame ();
+octave_stdout.flush ();
-else
+}
-error (R"(assignin: CONTEXT must be "caller" or "base")");
+octave_user_code *code = ov_code.user_code_value ();
-if (valid_identifier (name))
-{
+code->call (*this, 0, octave_value_list ());
-// Put the check here so that we don't slow down assignments
-// generally.  Any that go through Octave's parser should have
+if (verbose)
-// already been checked.
+octave_stdout << "done." << std::endl;
+}
-if (iskeyword (name))
-error ("assignin: invalid assignment to keyword '%s'",
+void
-name.c_str ());
+tree_evaluator::set_auto_fcn_var (stack_frame::auto_var_type avt,
+const octave_value& val)
-assign (name, val);
+{
-}
+m_call_stack.set_auto_fcn_var (avt, val);
-else
+}
-error ("assignin: invalid variable name '%s'", name.c_str ());
-}
+octave_value
+tree_evaluator::get_auto_fcn_var (stack_frame::auto_var_type avt) const
-void
+{
-tree_evaluator::source_file (const std::string& file_name,
+return m_call_stack.get_auto_fcn_var (avt);
-const std::string& context,
+}
-bool verbose, bool require_file)
-{
+void
-// Map from absolute name of script file to recursion level.  We
+tree_evaluator::define_parameter_list_from_arg_vector
-// use a map instead of simply placing a limit on recursion in the
+(tree_parameter_list *param_list, const octave_value_list& args)
-// source_file function so that two mutually recursive scripts
+{
-// written as
+if (! param_list || param_list->varargs_only ())
-//
+return;
-//   foo1.m:
-//   ------
+int i = -1;
-//   foo2
-//
+for (tree_decl_elt *elt : *param_list)
-//   foo2.m:
+{
-//   ------
+i++;
-//   foo1
-//
+octave_lvalue ref = elt->lvalue (*this);
-// and called with
-//
+if (i < args.length ())
-//   foo1
+{
-//
+if (args(i).is_defined () && args(i).is_magic_colon ())
-// (for example) will behave the same if they are written as
+{
-//
+if (! eval_decl_elt (elt))
-//   foo1.m:
+error ("no default value for argument %d", i+1);
-//   ------
+}
-//   source ("foo2.m")
+else
-//
+ref.define (args(i));
-//   foo2.m:
+}
-//   ------
+else
-//   source ("foo1.m")
+eval_decl_elt (elt);
-//
+}
-// and called with
+}
-//
-//   source ("foo1.m")
+void
-//
+tree_evaluator::undefine_parameter_list (tree_parameter_list *param_list)
-// (for example).
+{
+for (tree_decl_elt *elt : *param_list)
-static std::map<std::string, int> source_call_depth;
+{
+octave_lvalue ref = elt->lvalue (*this);
-std::string file_full_name
-= sys::file_ops::tilde_expand (file_name);
+ref.assign (octave_value::op_asn_eq, octave_value ());
+}
-std::size_t pos
+}
-= file_full_name.find_last_of (sys::file_ops::dir_sep_str ());
-std::string dir_name = file_full_name.substr (0, pos);
-file_full_name = sys::env::make_absolute (file_full_name);
-unwind_protect frame;
-if (source_call_depth.find (file_full_name) == source_call_depth.end ())
-source_call_depth[file_full_name] = -1;
-frame.protect_var (source_call_depth[file_full_name]);
-source_call_depth[file_full_name]++;
-if (source_call_depth[file_full_name] >= max_recursion_depth ())
-error ("max_recursion_depth exceeded");
-if (! context.empty ())
-{
-frame.add (&call_stack::restore_frame, &m_call_stack,
-m_call_stack.current_frame ());
-if (context == "caller")
-m_call_stack.goto_caller_frame ();
-else if (context == "base")
-m_call_stack.goto_base_frame ();
-else
-error (R"(source: CONTEXT must be "caller" or "base")");
-}
-// Find symbol name that would be in symbol_table, if it were loaded.
-std::size_t dir_end
-= file_name.find_last_of (sys::file_ops::dir_sep_chars ());
-dir_end = (dir_end == std::string::npos) ? 0 : dir_end + 1;
-std::size_t extension = file_name.find_last_of ('.');
-if (extension == std::string::npos)
-extension = file_name.length ();
-std::string symbol = file_name.substr (dir_end, extension - dir_end);
-std::string full_name = sys::canonicalize_file_name (file_name);
-// Check if this file is already loaded (or in the path)
-symbol_table& symtab = m_interpreter.get_symbol_table ();
-octave_value ov_code = symtab.fcn_table_find (symbol);
-// For compatibility with Matlab, accept both scripts and
-// functions.
-if (ov_code.is_user_code ())
-{
-octave_user_code *code = ov_code.user_code_value ();
-if (! code
-|| (sys::canonicalize_file_name (code->fcn_file_name ())
-!= full_name))
-{
-// Wrong file, so load it below.
-ov_code = octave_value ();
-}
-}
-else
-{
-// Not a script, so load it below.
-ov_code = octave_value ();
-}
-// If no symbol of this name, or the symbol is for a different
-// file, load.
-if (ov_code.is_undefined ())
-{
-try
-{
-ov_code = parse_fcn_file (m_interpreter, file_full_name,
-file_name, dir_name, "", "",
-require_file, true, false, false);
-}
-catch (execution_exception& ee)
-{
-error (ee, "source: error sourcing file '%s'",
-file_full_name.c_str ());
-}
-}
-// Return or error if we don't have a valid script or function.
-if (ov_code.is_undefined ())
-return;
-if (! ov_code.is_user_code ())
-error ("source: %s is not a script", full_name.c_str ());
-if (verbose)
-{
-octave_stdout << "executing commands from " << full_name << " ... ";
-octave_stdout.flush ();
-}
-octave_user_code *code = ov_code.user_code_value ();
-code->call (*this, 0, octave_value_list ());
-if (verbose)
-octave_stdout << "done." << std::endl;
-}
-void
-tree_evaluator::set_auto_fcn_var (stack_frame::auto_var_type avt,
-const octave_value& val)
-{
-m_call_stack.set_auto_fcn_var (avt, val);
-}
-octave_value
-tree_evaluator::get_auto_fcn_var (stack_frame::auto_var_type avt) const
-{
-return m_call_stack.get_auto_fcn_var (avt);
-}
-void
-tree_evaluator::define_parameter_list_from_arg_vector
-(tree_parameter_list *param_list, const octave_value_list& args)
-{
-if (! param_list || param_list->varargs_only ())
-return;
-int i = -1;
-for (tree_decl_elt *elt : *param_list)
-{
-i++;
-octave_lvalue ref = elt->lvalue (*this);
-if (i < args.length ())
-{
-if (args(i).is_defined () && args(i).is_magic_colon ())
-{
-if (! eval_decl_elt (elt))
-error ("no default value for argument %d", i+1);
-}
-else
-ref.define (args(i));
-}
-else
-eval_decl_elt (elt);
-}
-}
-void
-tree_evaluator::undefine_parameter_list (tree_parameter_list *param_list)
-{
-for (tree_decl_elt *elt : *param_list)
-{
-octave_lvalue ref = elt->lvalue (*this);
-ref.assign (octave_value::op_asn_eq, octave_value ());
-}
-}
 // END is documented in op-kw-docs.
 DEFMETHOD (end, interp, args, ,
 doc: /* -*- texinfo -*-
 @deftypefn {} {} end
 %! assert (x(end), 10);
 %! assert (x(minus (end, 1)), 9);
 %! assert (x(minus (minus (end, 1), 1)), 8);
 */
 octave_value_list
 tree_evaluator::convert_to_const_vector (tree_argument_list *args)
+{
+std::list<octave_value> arg_vals;
+for (auto elt : *args)
+{
+// FIXME: is it possible for elt to be invalid?
+if (! elt)
+break;
+octave_value tmp = elt->evaluate (*this);
+if (tmp.is_cs_list ())
+{
+octave_value_list tmp_ovl = tmp.list_value ();
+for (octave_idx_type i = 0; i < tmp_ovl.length (); i++)
+arg_vals.push_back (tmp_ovl(i));
+}
+else if (tmp.is_defined ())
+arg_vals.push_back (tmp);
+}
+return octave_value_list (arg_vals);
+}
+octave_value_list
+tree_evaluator::convert_return_list_to_const_vector
+(tree_parameter_list *ret_list, int nargout, const Matrix& ignored_outputs,
+const Cell& varargout)
+{
+octave_idx_type vlen = varargout.numel ();
+int len = ret_list->length ();
+// Special case.  Will do a shallow copy.
+if (len == 0)
+return varargout;
+else
+{
+int i = 0;
+int k = 0;
+int num_ignored = ignored_outputs.numel ();
+int ignored = num_ignored > 0 ? ignored_outputs(k) - 1 : -1;
+if (nargout <= len)
+{
+int nout = nargout > 0 ? nargout : 1;
+octave_value_list retval (nout);
+for (tree_decl_elt *elt : *ret_list)
+{
+if (nargout == 0 && ! is_defined (elt->ident ()))
+break;
+if (ignored >= 0 && i == ignored)
+{
+i++;
+k++;
+ignored = k < num_ignored ? ignored_outputs(k) - 1 : -1;
+}
+else
+retval(i++) = evaluate (elt);
+if (i == nout)
+break;
+}
+return retval;
+}
+else
+{
+octave_value_list retval (len + vlen);
+for (tree_decl_elt *elt : *ret_list)
+{
+if (ignored >= 0 && i == ignored)
+{
+i++;
+k++;
+ignored = k < num_ignored ? ignored_outputs(k) - 1 : -1;
+}
+else
+retval(i++) = evaluate (elt);
+}
+for (octave_idx_type j = 0; j < vlen; j++)
+retval(i++) = varargout(j);
+return retval;
+}
+}
+}
+bool
+tree_evaluator::eval_decl_elt (tree_decl_elt *elt)
+{
+bool retval = false;
+tree_identifier *id = elt->ident ();
+tree_expression *expr = elt->expression ();
+if (id && expr)
+{
+octave_lvalue ult = id->lvalue (*this);
+octave_value init_val = expr->evaluate (*this);
+ult.assign (octave_value::op_asn_eq, init_val);
+retval = true;
+}
+return retval;
+}
+bool
+tree_evaluator::switch_case_label_matches (tree_switch_case *expr,
+const octave_value& val)
+{
+tree_expression *label = expr->case_label ();
+octave_value label_value = label->evaluate (*this);
+if (label_value.is_defined ())
+{
+if (label_value.iscell ())
+{
+Cell cell (label_value.cell_value ());
+for (octave_idx_type i = 0; i < cell.rows (); i++)
+{
+for (octave_idx_type j = 0; j < cell.columns (); j++)
+{
+bool match = val.is_equal (cell(i, j));
+if (match)
+return true;
+}
+}
+}
+else
+return val.is_equal (label_value);
+}
+return false;
+}
+void tree_evaluator::push_stack_frame (const symbol_scope& scope)
+{
+m_call_stack.push (scope);
+}
+void tree_evaluator::push_stack_frame (octave_user_function *fcn,
+const std::shared_ptr<stack_frame>& closure_frames)
+{
+m_call_stack.push (fcn, closure_frames);
+}
+void tree_evaluator::push_stack_frame (octave_user_function *fcn,
+const stack_frame::local_vars_map& local_vars,
+const std::shared_ptr<stack_frame>& closure_frames)
+{
+m_call_stack.push (fcn, local_vars, closure_frames);
+}
+void tree_evaluator::push_stack_frame (octave_user_script *script)
+{
+m_call_stack.push (script);
+}
+void tree_evaluator::push_stack_frame (octave_function *fcn)
+{
+m_call_stack.push (fcn);
+}
+void tree_evaluator::pop_stack_frame (void)
+{
+m_call_stack.pop ();
+}
+int tree_evaluator::current_line (void) const
+{
+return m_call_stack.current_line ();
+}
+int tree_evaluator::current_column (void) const
+{
+return m_call_stack.current_column ();
+}
+int tree_evaluator::debug_user_code_line (void) const
+{
+return m_call_stack.debug_user_code_line ();
+}
+int tree_evaluator::debug_user_code_column (void) const
+{
+return m_call_stack.debug_user_code_column ();
+}
+void tree_evaluator::debug_where (std::ostream& os) const
+{
+std::shared_ptr<stack_frame> frm = m_call_stack.current_user_frame ();
+frm->display_stopped_in_message (os);
+}
+octave_user_code *tree_evaluator::current_user_code (void) const
+{
+return m_call_stack.current_user_code ();
+}
+unwind_protect *tree_evaluator::curr_fcn_unwind_protect_frame (void)
+{
+return m_call_stack.curr_fcn_unwind_protect_frame ();
+}
+octave_user_code *tree_evaluator::debug_user_code (void) const
+{
+return m_call_stack.debug_user_code ();
+}
+octave_function *tree_evaluator::current_function (bool skip_first) const
+{
+return m_call_stack.current_function (skip_first);
+}
+octave_function *tree_evaluator::caller_function (void) const
+{
+return m_call_stack.current_function (true);
+}
+bool tree_evaluator::goto_frame (std::size_t n, bool verbose)
+{
+return m_call_stack.goto_frame (n, verbose);
+}
+void tree_evaluator::goto_caller_frame (void)
+{
+m_call_stack.goto_caller_frame ();
+}
+void tree_evaluator::goto_base_frame (void)
+{
+m_call_stack.goto_base_frame ();
+}
+void tree_evaluator::restore_frame (std::size_t n)
+{
+return m_call_stack.restore_frame (n);
+}
+std::string tree_evaluator::get_dispatch_class (void) const
+{
+return m_call_stack.get_dispatch_class ();
+}
+void tree_evaluator::set_dispatch_class (const std::string& class_name)
+{
+m_call_stack.set_dispatch_class (class_name);
+}
+bool
+tree_evaluator::is_class_method_executing (std::string& dclass) const
+{
+return m_call_stack.is_class_method_executing (dclass);
+}
+bool
+tree_evaluator::is_class_constructor_executing (std::string& dclass) const
+{
+return m_call_stack.is_class_constructor_executing (dclass);
+}
+std::list<std::shared_ptr<stack_frame>>
+tree_evaluator::backtrace_frames (octave_idx_type& curr_user_frame) const
+{
+return m_call_stack.backtrace_frames (curr_user_frame);
+}
+std::list<std::shared_ptr<stack_frame>>
+tree_evaluator::backtrace_frames (void) const
+{
+return m_call_stack.backtrace_frames ();
+}
+std::list<frame_info>
+tree_evaluator::backtrace_info (octave_idx_type& curr_user_frame,
+bool print_subfn) const
+{
+return m_call_stack.backtrace_info (curr_user_frame, print_subfn);
+}
+std::list<frame_info> tree_evaluator::backtrace_info (void) const
+{
+return m_call_stack.backtrace_info ();
+}
+octave_map
+tree_evaluator::backtrace (octave_idx_type& curr_user_frame,
+bool print_subfn) const
+{
+return m_call_stack.backtrace (curr_user_frame, print_subfn);
+}
+octave_map tree_evaluator::backtrace (void) const
+{
+return m_call_stack.backtrace ();
+}
+octave_map tree_evaluator::empty_backtrace (void) const
+{
+return m_call_stack.empty_backtrace ();
+}
+std::string tree_evaluator::backtrace_message (void) const
+{
+std::list<frame_info> frames = backtrace_info ();
+std::ostringstream buf;
+for (const auto& frm : frames)
+{
+buf << "    " << frm.fcn_name ();
+int line = frm.line ();
+if (line > 0)
+{
+buf << " at line " << line;
+int column = frm.column ();
+if (column > 0)
+buf << " column " << column;
+buf << "\n";
+}
+}
+return buf.str ();
+}
+void tree_evaluator::push_dummy_scope (const std::string& name)
+{
+symbol_scope dummy_scope (name + "$dummy");
+m_call_stack.push (dummy_scope);
+}
+void tree_evaluator::pop_scope (void)
+{
+m_call_stack.pop ();
+}
+symbol_scope tree_evaluator::get_top_scope (void) const
+{
+return m_call_stack.top_scope ();
+}
+symbol_scope tree_evaluator::get_current_scope (void) const
+{
+return m_call_stack.current_scope ();
+}
+void tree_evaluator::mlock (bool skip_first) const
+{
+octave_function *fcn = m_call_stack.current_function (skip_first);
+if (! fcn)
+error ("mlock: invalid use outside a function");
+if (fcn->is_builtin_function ())
+{
+warning ("mlock: locking built-in function has no effect");
+return;
+}
+fcn->lock ();
+}
+void tree_evaluator::munlock (bool skip_first) const
+{
+octave_function *fcn = m_call_stack.current_function (skip_first);
+if (! fcn)
+error ("munlock: invalid use outside a function");
+if (fcn->is_builtin_function ())
+{
+warning ("munlock: unlocking built-in function has no effect");
+return;
+}
+fcn->unlock ();
+}
+bool tree_evaluator::mislocked (bool skip_first) const
+{
+octave_function *fcn = m_call_stack.current_function (skip_first);
+if (! fcn)
+error ("mislocked: invalid use outside a function");
+return fcn->islocked ();
+}
+octave_value
+tree_evaluator::max_stack_depth (const octave_value_list& args, int nargout)
+{
+return m_call_stack.max_stack_depth (args, nargout);
+}
+void tree_evaluator::display_call_stack (void) const
+{
+m_call_stack.display ();
+}
+octave_value tree_evaluator::find (const std::string& name)
+{
+std::shared_ptr<stack_frame> frame
+= m_call_stack.get_current_stack_frame ();
+octave_value val = frame->varval (name);
+if (val.is_defined ())
+return val;
+// Subfunction.  I think it only makes sense to check for
+// subfunctions if we are currently executing a function defined
+// from a .m file.
+octave_value fcn = frame->find_subfunction (name);
+if (fcn.is_defined ())
+return fcn;
+symbol_table& symtab = m_interpreter.get_symbol_table ();
+return symtab.fcn_table_find (name, ovl ());
+}
+void tree_evaluator::clear_objects (void)
+{
+std::shared_ptr<stack_frame> frame
+= m_call_stack.get_current_stack_frame ();
+frame->clear_objects ();
+}
+void tree_evaluator::clear_variable (const std::string& name)
+{
+std::shared_ptr<stack_frame> frame
+= m_call_stack.get_current_stack_frame ();
+frame->clear_variable (name);
+}
+void tree_evaluator::clear_variable_pattern (const std::string& pattern)
+{
+std::shared_ptr<stack_frame> frame
+= m_call_stack.get_current_stack_frame ();
+frame->clear_variable_pattern (pattern);
+}
+void tree_evaluator::clear_variable_regexp (const std::string& pattern)
+{
+std::shared_ptr<stack_frame> frame
+= m_call_stack.get_current_stack_frame ();
+frame->clear_variable_regexp (pattern);
+}
+void tree_evaluator::clear_variables (void)
+{
+std::shared_ptr<stack_frame> frame
+= m_call_stack.get_current_stack_frame ();
+frame->clear_variables ();
+}
+void tree_evaluator::clear_global_variable (const std::string& name)
+{
+m_call_stack.clear_global_variable (name);
+}
+void
+tree_evaluator::clear_global_variable_pattern (const std::string& pattern)
+{
+m_call_stack.clear_global_variable_pattern (pattern);
+}
+void tree_evaluator::clear_global_variable_regexp(const std::string& pattern)
+{
+m_call_stack.clear_global_variable_regexp (pattern);
+}
+void tree_evaluator::clear_global_variables (void)
+{
+m_call_stack.clear_global_variables ();
+}
+void tree_evaluator::clear_all (bool force)
+{
+// FIXME: should this also clear objects?
+clear_variables ();
+clear_global_variables ();
+symbol_table& symtab = m_interpreter.get_symbol_table ();
+symtab.clear_functions (force);
+}
+void tree_evaluator::clear_symbol (const std::string& name)
+{
+// FIXME: are we supposed to do both here?
+clear_variable (name);
+symbol_table& symtab = m_interpreter.get_symbol_table ();
+symtab.clear_function (name);
+}
+void tree_evaluator::clear_symbol_pattern (const std::string& pattern)
+{
+// FIXME: are we supposed to do both here?
+clear_variable_pattern (pattern);
+symbol_table& symtab = m_interpreter.get_symbol_table ();
+symtab.clear_function_pattern (pattern);
+}
+void tree_evaluator::clear_symbol_regexp (const std::string& pattern)
+{
+// FIXME: are we supposed to do both here?
+clear_variable_regexp (pattern);
+symbol_table& symtab = m_interpreter.get_symbol_table ();
+symtab.clear_function_regexp (pattern);
+}
+std::list<std::string> tree_evaluator::global_variable_names (void) const
+{
+return m_call_stack.global_variable_names ();
+}
+std::list<std::string> tree_evaluator::top_level_variable_names (void) const
+{
+return m_call_stack.top_level_variable_names ();
+}
+std::list<std::string> tree_evaluator::variable_names (void) const
+{
+return m_call_stack.variable_names ();
+}
+// Return a pointer to the user-defined function FNAME.  If FNAME is empty,
+// search backward for the first user-defined function in the
+// current call stack.
+octave_user_code *
+tree_evaluator::get_user_code (const std::string& fname,
+const std::string& class_name)
+{
+octave_user_code *user_code = nullptr;
+if (fname.empty ())
+user_code = m_call_stack.debug_user_code ();
+else
+{
+std::string name = fname;
+if (sys::file_ops::dir_sep_char () != '/' && name[0] == '@')
+{
+auto beg = name.begin () + 2;  // never have @/method
+auto end = name.end () - 1;    // never have trailing '/'
+std::replace (beg, end, '/', sys::file_ops::dir_sep_char ());
+}
+std::size_t name_len = name.length ();
+if (name_len > 2 && name.substr (name_len-2) == ".m")
+name = name.substr (0, name_len-2);
+if (name.empty ())
+return nullptr;
+symbol_table& symtab = m_interpreter.get_symbol_table ();
+octave_value fcn;
+std::size_t p2 = std::string::npos;
+if (name[0] == '@')
+{
+std::size_t p1 = name.find (sys::file_ops::dir_sep_char (), 1);
+if (p1 == std::string::npos)
+return nullptr;
+std::string dispatch_type = name.substr (1, p1-1);
+p2 = name.find ('>', p1);
+std::string method = name.substr (p1+1, p2-1);
+fcn = symtab.find_method (method, dispatch_type);
+}
+else if (! class_name.empty ())
+{
+cdef_manager& cdm = m_interpreter.get_cdef_manager ();
+fcn = cdm.find_method (class_name, name);
+// If there is no classdef method, then try legacy classes.
+if (fcn.is_undefined ())
+fcn = symtab.find_method (name, class_name);
+}
+else
+{
+p2 = name.find ('>');
+std::string main_fcn = name.substr (0, p2);
+fcn = symtab.find_function (main_fcn);
+}
+// List of function names sub1>sub2>...
+std::string subfuns;
+if (p2 != std::string::npos)
+subfuns = name.substr (p2+1);
+if (fcn.is_defined () && fcn.is_user_code ())
+user_code = fcn.user_code_value ();
+if (! user_code || subfuns.empty ())
+return user_code;
+fcn = user_code->find_subfunction (subfuns);
+if (fcn.is_undefined ())
+return nullptr;
+user_code = fcn.user_code_value ();
+}
+return user_code;
+}
+std::string
+tree_evaluator::current_function_name (bool skip_first) const
+{
+octave_function *curfcn = m_call_stack.current_function (skip_first);
+if (curfcn)
+return curfcn->name ();
+return "";
+}
+bool
+tree_evaluator::in_user_code (void) const
+{
+return m_call_stack.current_user_code () != nullptr;
+}
+void
+tree_evaluator::visit_decl_command (tree_decl_command& cmd)
+{
+if (m_echo_state)
+{
+int line = cmd.line ();
+if (line < 0)
+line = 1;
+echo_code (line);
+m_echo_file_pos = line + 1;
+}
+if (m_debug_mode)
+do_breakpoint (cmd.is_active_breakpoint (*this));
+// FIXME: tree_decl_init_list is not derived from tree, so should it
+// really have an accept method?
+tree_decl_init_list *init_list = cmd.initializer_list ();
+if (init_list)
+init_list->accept (*this);
+}
+void
+tree_evaluator::visit_decl_elt (tree_decl_elt& elt)
+{
+tree_identifier *id = elt.ident ();
+if (id)
+{
+if (elt.is_global ())
+m_call_stack.make_global (id->symbol ());
+else if (elt.is_persistent ())
+m_call_stack.make_persistent (id->symbol ());
+else
+error ("declaration list element not global or persistent");
+octave_lvalue ult = id->lvalue (*this);
+if (ult.is_undefined ())
+{
+tree_expression *expr = elt.expression ();
+octave_value init_val;
+if (expr)
+init_val = expr->evaluate (*this);
+else
+init_val = Matrix ();
+ult.assign (octave_value::op_asn_eq, init_val);
+}
+}
+}
+template <typename T>
+void
+tree_evaluator::execute_range_loop (const range<T>& rng, int line,
+octave_lvalue& ult,
+tree_statement_list *loop_body)
+{
+octave_idx_type steps = rng.numel ();
+if (math::isinf (rng.limit ()))
+warning_with_id ("Octave:infinite-loop",
+"FOR loop limit is infinite, will stop after %"
+OCTAVE_IDX_TYPE_FORMAT " steps", steps);
+for (octave_idx_type i = 0; i < steps; i++)
+{
+if (m_echo_state)
+m_echo_file_pos = line;
+octave_value val (rng.elem (i));
+ult.assign (octave_value::op_asn_eq, val);
+if (loop_body)
+loop_body->accept (*this);
+if (quit_loop_now ())
+break;
+}
+}
+void
+tree_evaluator::visit_simple_for_command (tree_simple_for_command& cmd)
+{
+int line = cmd.line ();
+if (line < 0)
+line = 1;
+if (m_echo_state)
+{
+echo_code (line);
+line++;
+}
+if (m_debug_mode)
+do_breakpoint (cmd.is_active_breakpoint (*this));
+// FIXME: need to handle PARFOR loops here using cmd.in_parallel ()
+// and cmd.maxproc_expr ();
+unwind_protect_var<bool> upv (m_in_loop_command, true);
+tree_expression *expr = cmd.control_expr ();
+octave_value rhs = expr->evaluate (*this);
+if (rhs.is_undefined ())
+return;
+tree_expression *lhs = cmd.left_hand_side ();
+octave_lvalue ult = lhs->lvalue (*this);
+tree_statement_list *loop_body = cmd.body ();
+if (rhs.is_range ())
+{
+// FIXME: is there a better way to dispatch here?
+if (rhs.is_double_type ())
+{
+execute_range_loop (rhs.range_value (), line, ult, loop_body);
+return;
+}
+// For now, disable all but range<double>.
+#if 0
+if (rhs.is_int64_type ())
+{
+execute_range_loop (rhs.int64_range_value (), line, ult, loop_body);
+return;
+}
+if (rhs.is_uint64_type ())
+{
+execute_range_loop (rhs.uint64_range_value (), line, ult, loop_body);
+return;
+}
+if (rhs.is_int32_type ())
+{
+execute_range_loop (rhs.int32_range_value (), line, ult, loop_body);
+return;
+}
+if (rhs.is_uint32_type ())
+{
+execute_range_loop (rhs.uint32_range_value (), line, ult, loop_body);
+return;
+}
+if (rhs.is_int16_type ())
+{
+execute_range_loop (rhs.int16_range_value (), line, ult, loop_body);
+return;
+}
+if (rhs.is_uint16_type ())
+{
+execute_range_loop (rhs.uint16_range_value (), line, ult, loop_body);
+return;
+}
+if (rhs.is_int8_type ())
+{
+execute_range_loop (rhs.int8_range_value (), line, ult, loop_body);
+return;
+}
+if (rhs.is_uint8_type ())
+{
+execute_range_loop (rhs.uint8_range_value (), line, ult, loop_body);
+return;
+}
+if (rhs.is_single_type ())
+{
+execute_range_loop (rhs.float_range_value (), line, ult, loop_body);
+return;
+}
+#endif
+}
+if (rhs.is_scalar_type ())
+{
+if (m_echo_state)
+m_echo_file_pos = line;
+ult.assign (octave_value::op_asn_eq, rhs);
+if (loop_body)
+loop_body->accept (*this);
+// Maybe decrement break and continue states.
+quit_loop_now ();
+return;
+}
+// Also handle any range types not explicitly handled above, though
+// not as efficiently as the specialized code above.
+if (rhs.is_range () || rhs.is_matrix_type () || rhs.iscell ()
+|| rhs.is_string () || rhs.isstruct ())
+{
+// A matrix or cell is reshaped to 2 dimensions and iterated by
+// columns.
+dim_vector dv = rhs.dims ().redim (2);
+octave_idx_type nrows = dv(0);
+octave_idx_type steps = dv(1);
+octave_value arg = rhs;
+if (rhs.ndims () > 2)
+arg = arg.reshape (dv);
+if (nrows > 0 && steps > 0)
+{
+octave_value_list idx;
+octave_idx_type iidx;
+// for row vectors, use single index to speed things up.
+if (nrows == 1)
+{
+idx.resize (1);
+iidx = 0;
+}
+else
+{
+idx.resize (2);
+idx(0) = octave_value::magic_colon_t;
+iidx = 1;
+}
+for (octave_idx_type i = 1; i <= steps; i++)
+{
+if (m_echo_state)
+m_echo_file_pos = line;
+// index_op expects one-based indices.
+idx(iidx) = i;
+octave_value val = arg.index_op (idx);
+ult.assign (octave_value::op_asn_eq, val);
+if (loop_body)
+loop_body->accept (*this);
+if (quit_loop_now ())
+break;
+}
+}
+else
+{
+// Handle empty cases, while still assigning to loop var.
+ult.assign (octave_value::op_asn_eq, arg);
+}
+return;
+}
+error ("invalid type in for loop expression near line %d, column %d",
+cmd.line (), cmd.column ());
+}
+void
+tree_evaluator::visit_complex_for_command (tree_complex_for_command& cmd)
+{
+int line = cmd.line ();
+if (line < 0)
+line = 1;
+if (m_echo_state)
+{
+echo_code (line);
+line++;
+}
+if (m_debug_mode)
+do_breakpoint (cmd.is_active_breakpoint (*this));
+unwind_protect_var<bool> upv (m_in_loop_command, true);
+tree_expression *expr = cmd.control_expr ();
+octave_value rhs = expr->evaluate (*this);
+if (rhs.is_undefined ())
+return;
+if (! rhs.isstruct ())
+error ("in statement 'for [X, Y] = VAL', VAL must be a structure");
+// Cycle through structure elements.  First element of id_list
+// is set to value and the second is set to the name of the
+// structure element.
+tree_argument_list *lhs = cmd.left_hand_side ();
+auto p = lhs->begin ();
+tree_expression *elt = *p++;
+octave_lvalue val_ref = elt->lvalue (*this);
+elt = *p;
+octave_lvalue key_ref = elt->lvalue (*this);
+const octave_map tmp_val = rhs.map_value ();
+tree_statement_list *loop_body = cmd.body ();
+string_vector keys = tmp_val.keys ();
+octave_idx_type nel = keys.numel ();
+for (octave_idx_type i = 0; i < nel; i++)
+{
+if (m_echo_state)
+m_echo_file_pos = line;
+std::string key = keys[i];
+const Cell val_lst = tmp_val.contents (key);
+octave_idx_type n = val_lst.numel ();
+octave_value val = (n == 1) ? val_lst(0) : octave_value (val_lst);
+val_ref.assign (octave_value::op_asn_eq, val);
+key_ref.assign (octave_value::op_asn_eq, key);
+if (loop_body)
+loop_body->accept (*this);
+if (quit_loop_now ())
+break;
+}
+}
+void tree_evaluator::visit_spmd_command (tree_spmd_command& cmd)
+{
+// For now, we just execute the commands serially.
+tree_statement_list *body = cmd.body ();
+if (body)
+body->accept (*this);
+}
+octave_value
+tree_evaluator::evaluate_anon_fcn_handle (tree_anon_fcn_handle& afh)
+{
+// FIXME: should CMD_LIST be limited to a single expression?
+// I think that is what Matlab does.
+symbol_scope new_scope;
+symbol_scope scope = afh.scope ();
+if (scope)
+new_scope = scope.dup ();
+tree_parameter_list *param_list = afh.parameter_list ();
+tree_parameter_list *param_list_dup
+= param_list ? param_list->dup (new_scope) : nullptr;
+tree_parameter_list *ret_list = nullptr;
+tree_statement_list *stmt_list = nullptr;
+symbol_scope parent_scope = get_current_scope ();
+new_scope.set_parent (parent_scope);
+new_scope.set_primary_parent (parent_scope);
+tree_expression *expr = afh.expression ();
+if (expr)
+{
+tree_expression *expr_dup = expr->dup (new_scope);
+tree_statement *stmt = new tree_statement (expr_dup, nullptr);
+stmt_list = new tree_statement_list (stmt);
+}
+tree_anon_scopes anon_fcn_ctx (afh);
+std::set<std::string> free_vars = anon_fcn_ctx.free_variables ();
+stack_frame::local_vars_map local_vars;
+std::shared_ptr<stack_frame> frame
+= m_call_stack.get_current_stack_frame ();
+for (auto& name : free_vars)
+{
+octave_value val = frame->varval (name);
+if (val.is_defined ())
+local_vars[name] = val;
+}
+octave_user_function *af
+= new octave_user_function (new_scope, param_list_dup, ret_list,
+stmt_list);
+octave_function *curr_fcn = m_call_stack.current_function ();
+bool is_nested = false;
+if (curr_fcn)
+{
+// FIXME: maybe it would be better to just stash curr_fcn
+// instead of individual bits of info about it?
+// An anonymous function defined inside another nested function
+// or parent of a nested function also behaves like a nested
+// function.
+if (curr_fcn->is_parent_function () || curr_fcn->is_nested_function ())
+{
+is_nested = true;
+af->mark_as_nested_function ();
+new_scope.set_nesting_depth (parent_scope.nesting_depth () + 1);
+}
+af->stash_dir_name (curr_fcn->dir_name ());
+new_scope.cache_fcn_file_name (curr_fcn->fcn_file_name ());
+new_scope.cache_dir_name (curr_fcn->dir_name ());
+// The following is needed so that class method dispatch works
+// properly for anonymous functions that wrap class methods.
+if (curr_fcn->is_class_method () || curr_fcn->is_class_constructor ())
+af->stash_dispatch_class (curr_fcn->dispatch_class ());
+af->stash_fcn_file_name (curr_fcn->fcn_file_name ());
+}
+af->mark_as_anonymous_function ();
+octave_value ov_fcn (af);
+return (is_nested
+? octave_value (new octave_fcn_handle (ov_fcn, local_vars, frame))
+: octave_value (new octave_fcn_handle (ov_fcn, local_vars)));
+}
+octave_value_list
+tree_evaluator::execute_builtin_function (octave_builtin& builtin_function,
+int nargout,
+const octave_value_list& args)
+{
+octave_value_list retval;
+if (args.has_magic_colon ())
+error ("invalid use of colon in function argument list");
+profiler::enter<octave_builtin> block (m_profiler, builtin_function);
+octave_builtin::fcn fcn = builtin_function.function ();
+if (fcn)
+retval = (*fcn) (args, nargout);
+else
+{
+octave_builtin::meth meth = builtin_function.method ();
+retval = (*meth) (m_interpreter, args, nargout);
+}
+// Do not allow null values to be returned from functions.
+// FIXME: perhaps true builtins should be allowed?
+retval.make_storable_values ();
+// Fix the case of a single undefined value.
+// This happens when a compiled function uses
+//
+//   octave_value retval;
+//
+// instead of
+//
+//   octave_value_list retval;
+//
+// the idiom is very common, so we solve that here.
+if (retval.length () == 1 && retval.xelem (0).is_undefined ())
+retval.clear ();
+return retval;
+}
+octave_value_list
+tree_evaluator::execute_mex_function (octave_mex_function& mex_function,
+int nargout,
+const octave_value_list& args)
+{
+octave_value_list retval;
+if (args.has_magic_colon ())
+error ("invalid use of colon in function argument list");
+profiler::enter<octave_mex_function> block (m_profiler, mex_function);
+retval = call_mex (mex_function, args, nargout);
+return retval;
+}
+octave_value_list
+tree_evaluator::execute_user_script (octave_user_script& user_script,
+int nargout,
+const octave_value_list& args)
+{
+octave_value_list retval;
+std::string file_name = user_script.fcn_file_name ();
+if (args.length () != 0 || nargout != 0)
+error ("invalid call to script %s", file_name.c_str ());
+tree_statement_list *cmd_list = user_script.body ();
+if (! cmd_list)
+return retval;
+// FIXME: Maybe this check belongs in the places where we push a new
+// stack frame?  Or in the call_stack push method itself?
+if (m_call_stack.size () >= static_cast<std::size_t> (m_max_recursion_depth))
+error ("max_recursion_depth exceeded");
+unwind_protect_var<stmt_list_type> upv (m_statement_context, SC_SCRIPT);
+profiler::enter<octave_user_script> block (m_profiler, user_script);
+if (echo ())
+push_echo_state (tree_evaluator::ECHO_SCRIPTS, file_name);
+// FIXME: Should we be using tree_evaluator::eval here?
+cmd_list->accept (*this);
+if (m_returning)
+m_returning = 0;
+if (m_breaking)
+m_breaking--;
+return retval;
+}
+void
+tree_evaluator::visit_octave_user_script (octave_user_script&)
+{
+// ??
+panic_impossible ();
+}
+octave_value_list
+tree_evaluator::execute_user_function (octave_user_function& user_function,
+int nargout,
+const octave_value_list& xargs)
+{
+octave_value_list retval;
+// If this function is a classdef constructor, extract the first input
+// argument, which must be the partially constructed object instance.
+octave_value_list args (xargs);
+octave_value_list ret_args;
+int nargin = args.length ();
+if (user_function.is_classdef_constructor ())
+{
+if (nargin > 0)
+{
+ret_args = args.slice (0, 1, true);
+--nargin;
+args = args.slice (1, nargin, true);
+}
+else
+panic_impossible ();
+}
+// FIXME: this probably shouldn't be a double-precision matrix.
+Matrix ignored_outputs = ignored_fcn_outputs ();
+tree_parameter_list *param_list = user_function.parameter_list ();
+bool takes_varargs = false;
+int max_inputs = 0;
+if (param_list)
+{
+takes_varargs = param_list->takes_varargs ();
+max_inputs = param_list->length ();
+}
+if (! takes_varargs && nargin > max_inputs)
+{
+std::string name = user_function.name ();
+if (name.empty ())
+name = "@<anonymous>";
+error_with_id ("Octave:invalid-fun-call",
+"%s: function called with too many inputs",
+name.c_str ());
+}
+define_parameter_list_from_arg_vector (param_list, args);
+tree_parameter_list *ret_list = user_function.return_list ();
+if (ret_list && ! ret_list->takes_varargs ())
+{
+int max_outputs = ret_list->length ();
+if (nargout > max_outputs)
+{
+std::string name = user_function.name ();
+error_with_id ("Octave:invalid-fun-call",
+"%s: function called with too many outputs",
+name.c_str ());
+}
+}
+bind_auto_fcn_vars (xargs.name_tags (), ignored_outputs, nargin,
+nargout, user_function.takes_varargs (),
+user_function.all_va_args (args));
+// For classdef constructor, pre-populate the output arguments
+// with the pre-initialized object instance, extracted above.
+if (user_function.is_classdef_constructor ())
+{
+if (! ret_list)
+error ("%s: invalid classdef constructor, no output argument defined",
+user_function.dispatch_class ().c_str ());
+define_parameter_list_from_arg_vector (ret_list, ret_args);
+}
+// FIXME: Maybe this check belongs in the places where we push a
+// new stack frame?  Or in the call_stack push method itself?
+if (m_call_stack.size () >= static_cast<std::size_t> (m_max_recursion_depth))
+error ("max_recursion_depth exceeded");
+unwind_action act2 ([&user_function] ()
 {
-std::list<octave_value> arg_vals;
+user_function.restore_warning_states ();
+});
-for (auto elt : *args)
+// Evaluate the commands that make up the function.
+unwind_protect_var<stmt_list_type> upv (m_statement_context, SC_FUNCTION);
+tree_statement_list *cmd_list = user_function.body ();
+if (cmd_list)
+{
+profiler::enter<octave_user_function>
+block (m_profiler, user_function);
+if (echo ())
+push_echo_state (tree_evaluator::ECHO_FUNCTIONS,
+user_function.fcn_file_name ());
+if (user_function.is_special_expr ())
+{
+panic_if (cmd_list->length () != 1);
+tree_statement *stmt = cmd_list->front ();
+tree_expression *expr = stmt->expression ();
+if (expr)
+{
+m_call_stack.set_location (stmt->line (), stmt->column ());
+retval = expr->evaluate_n (*this, nargout);
+}
+}
+else
+cmd_list->accept (*this);
+if (m_returning)
+m_returning = 0;
+if (m_breaking)
+m_breaking--;
+}
+// Copy return values out.
+if (ret_list && ! user_function.is_special_expr ())
+{
+Cell varargout;
+if (ret_list->takes_varargs ())
+{
+octave_value varargout_varval = varval ("varargout");
+if (varargout_varval.is_defined ())
+varargout = varargout_varval.xcell_value ("varargout must be a cell array object");
+}
+retval = convert_return_list_to_const_vector (ret_list, nargout,
+ignored_outputs,
+varargout);
+}
+return retval;
+}
+void
+tree_evaluator::visit_octave_user_function (octave_user_function&)
+{
+// ??
+panic_impossible ();
+}
+void
+tree_evaluator::visit_octave_user_function_header (octave_user_function&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_octave_user_function_trailer (octave_user_function&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_function_def (tree_function_def& cmd)
+{
+octave_value fcn = cmd.function ();
+octave_function *f = fcn.function_value ();
+if (f)
+{
+std::string nm = f->name ();
+symbol_table& symtab = m_interpreter.get_symbol_table ();
+symtab.install_cmdline_function (nm, fcn);
+// Make sure that any variable with the same name as the new
+// function is cleared.
+assign (nm);
+}
+}
+void
+tree_evaluator::visit_identifier (tree_identifier&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_if_clause (tree_if_clause&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_if_command (tree_if_command& cmd)
+{
+if (m_echo_state)
+{
+int line = cmd.line ();
+if (line < 0)
+line = 1;
+echo_code (line);
+m_echo_file_pos = line + 1;
+}
+// FIXME: tree_if_command_list is not derived from tree, so should it
+// really have an accept method?
+tree_if_command_list *lst = cmd.cmd_list ();
+if (lst)
+lst->accept (*this);
+}
+void
+tree_evaluator::visit_if_command_list (tree_if_command_list& lst)
+{
+for (tree_if_clause *tic : lst)
+{
+tree_expression *expr = tic->condition ();
+if (! (in_debug_repl ()
+&& m_call_stack.current_frame () == m_debug_frame))
+m_call_stack.set_location (tic->line (), tic->column ());
+if (m_debug_mode && ! tic->is_else_clause ())
+do_breakpoint (tic->is_active_breakpoint (*this));
+if (tic->is_else_clause () || is_logically_true (expr, "if"))
+{
+tree_statement_list *stmt_lst = tic->commands ();
+if (stmt_lst)
+stmt_lst->accept (*this);
+break;
+}
+}
+}
+void
+tree_evaluator::visit_index_expression (tree_index_expression&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_matrix (tree_matrix&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_cell (tree_cell&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_multi_assignment (tree_multi_assignment&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_no_op_command (tree_no_op_command& cmd)
+{
+if (m_echo_state)
+{
+int line = cmd.line ();
+if (line < 0)
+line = 1;
+echo_code (line);
+m_echo_file_pos = line + 1;
+}
+if (m_debug_mode && cmd.is_end_of_fcn_or_script ())
+do_breakpoint (cmd.is_active_breakpoint (*this), true);
+}
+void
+tree_evaluator::visit_constant (tree_constant&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_fcn_handle (tree_fcn_handle&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_parameter_list (tree_parameter_list&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_postfix_expression (tree_postfix_expression&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_prefix_expression (tree_prefix_expression&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_return_command (tree_return_command& cmd)
+{
+if (m_echo_state)
+{
+int line = cmd.line ();
+if (line < 0)
+line = 1;
+echo_code (line);
+m_echo_file_pos = line + 1;
+}
+if (m_debug_mode)
+do_breakpoint (cmd.is_active_breakpoint (*this));
+// Act like dbcont.
+if (in_debug_repl () && m_call_stack.current_frame () == m_debug_frame)
+dbcont ();
+else if (m_statement_context == SC_FUNCTION
+|| m_statement_context == SC_SCRIPT
+|| m_in_loop_command)
+m_returning = 1;
+}
+void
+tree_evaluator::visit_simple_assignment (tree_simple_assignment&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_statement (tree_statement& stmt)
+{
+tree_command *cmd = stmt.command ();
+tree_expression *expr = stmt.expression ();
+if (cmd || expr)
+{
+if (! (in_debug_repl ()
+&& m_call_stack.current_frame () == m_debug_frame))
+m_call_stack.set_location (stmt.line (), stmt.column ());
+try
+{
+if (cmd)
+{
+unwind_protect_var<const std::list<octave_lvalue> *>
+upv (m_lvalue_list, nullptr);
+cmd->accept (*this);
+}
+else
+{
+if (m_echo_state)
+{
+int line = stmt.line ();
+if (line < 0)
+line = 1;
+echo_code (line);
+m_echo_file_pos = line + 1;
+}
+if (m_debug_mode)
+do_breakpoint (expr->is_active_breakpoint (*this));
+// FIXME: maybe all of this should be packaged in
+// one virtual function that returns a flag saying whether
+// or not the expression will take care of binding ans and
+// printing the result.
+// FIXME: it seems that we should just have to
+// evaluate the expression and that should take care of
+// everything, binding ans as necessary?
+octave_value tmp_result = expr->evaluate (*this, 0);
+if (tmp_result.is_defined ())
+{
+bool do_bind_ans = false;
+if (expr->is_identifier ())
+do_bind_ans = ! is_variable (expr);
+else
+do_bind_ans = ! expr->is_assignment_expression ();
+if (do_bind_ans)
+bind_ans (tmp_result, expr->print_result ()
+&& statement_printing_enabled ());
+}
+}
+}
+catch (const std::bad_alloc&)
+{
+// FIXME: We want to use error_with_id here so that give users
+// control over this error message but error_with_id will
+// require some memory allocations.  Is there anything we can
+// do to make those more likely to succeed?
+error_with_id ("Octave:bad-alloc",
+"out of memory or dimension too large for Octave's index type");
+}
+catch (const interrupt_exception&)
+{
+// If we are debugging, then continue with next statement.
+// Otherwise, jump out of here.
+if (m_debug_mode)
+m_interpreter.recover_from_exception ();
+else
+throw;
+}
+catch (const execution_exception& ee)
+{
+error_system& es = m_interpreter.get_error_system ();
+if ((m_interpreter.interactive ()
+|| application::forced_interactive ())
+&& ((es.debug_on_error ()
+&& m_bp_table.debug_on_err (es.last_error_id ()))
+|| (es.debug_on_caught ()
+&& m_bp_table.debug_on_caught (es.last_error_id ())))
+&& in_user_code ())
+{
+es.save_exception (ee);
+es.display_exception (ee);
+enter_debugger ();
+// It doesn't make sense to continue execution after an
+// error occurs so force the debugger to quit all debug
+// levels and return the the top prompt.
+throw quit_debug_exception (true);
+}
+else
+throw;
+}
+}
+}
+void
+tree_evaluator::visit_statement_list (tree_statement_list& lst)
+{
+// FIXME: commented out along with else clause below.
+// static octave_value_list empty_list;
+auto p = lst.begin ();
+if (p != lst.end ())
+{
+while (true)
+{
+tree_statement *elt = *p++;
+if (! elt)
+error ("invalid statement found in statement list!");
+octave_quit ();
+elt->accept (*this);
+if (m_breaking || m_continuing)
+break;
+if (m_returning)
+break;
+if (p == lst.end ())
+break;
+else
+{
+// Clear previous values before next statement is
+// evaluated so that we aren't holding an extra
+// reference to a value that may be used next.  For
+// example, in code like this:
+//
+//   X = rand (N);  # refcount for X should be 1
+//                  # after this statement
+//
+//   X(idx) = val;  # no extra copy of X should be
+//                  # needed, but we will be faked
+//                  # out if retval is not cleared
+//                  # between statements here
+//              result_values = empty_list;
+}
+}
+}
+}
+void
+tree_evaluator::visit_switch_case (tree_switch_case&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_switch_case_list (tree_switch_case_list&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_switch_command (tree_switch_command& cmd)
+{
+if (m_echo_state)
+{
+int line = cmd.line ();
+if (line < 0)
+line = 1;
+echo_code (line);
+m_echo_file_pos = line + 1;
+}
+if (m_debug_mode)
+do_breakpoint (cmd.is_active_breakpoint (*this));
+tree_expression *expr = cmd.switch_value ();
+if (! expr)
+error ("missing value in switch command near line %d, column %d",
+cmd.line (), cmd.column ());
+octave_value val = expr->evaluate (*this);
+tree_switch_case_list *lst = cmd.case_list ();
+if (lst)
+{
+for (tree_switch_case *t : *lst)
+{
+if (t->is_default_case () || switch_case_label_matches (t, val))
+{
+tree_statement_list *stmt_lst = t->commands ();
+if (stmt_lst)
+stmt_lst->accept (*this);
+break;
+}
+}
+}
+}
+void
+tree_evaluator::visit_try_catch_command (tree_try_catch_command& cmd)
+{
+if (m_echo_state)
+{
+int line = cmd.line ();
+if (line < 0)
+line = 1;
+echo_code (line);
+m_echo_file_pos = line + 1;
+}
+bool execution_error = false;
+octave_scalar_map err_map;
+tree_statement_list *try_code = cmd.body ();
+if (try_code)
+{
+// unwind frame before catch block
+unwind_protect frame;
+interpreter_try (frame);
+// The catch code is *not* added to unwind_protect stack; it
+// doesn't need to be run on interrupts.
+try
+{
+try_code->accept (*this);
+}
+catch (const execution_exception& ee)
+{
+execution_error = true;
+error_system& es = m_interpreter.get_error_system ();
+es.save_exception (ee);
+err_map.assign ("message", es.last_error_message ());
+err_map.assign ("identifier", es.last_error_id ());
+err_map.assign ("stack", es.last_error_stack ());
+m_interpreter.recover_from_exception ();
+}
+// Actions attached to unwind_protect frame will run here, prior
+// to executing the catch block.
+}
+if (execution_error)
+{
+tree_statement_list *catch_code = cmd.cleanup ();
+if (catch_code)
+{
+tree_identifier *expr_id = cmd.identifier ();
+if (expr_id)
+{
+octave_lvalue ult = expr_id->lvalue (*this);
+ult.assign (octave_value::op_asn_eq, err_map);
+}
+// perform actual "catch" block
+catch_code->accept (*this);
+}
+}
+}
+void
+tree_evaluator::do_unwind_protect_cleanup_code (tree_statement_list *list)
+{
+unwind_protect frame;
+frame.protect_var (octave_interrupt_state);
+octave_interrupt_state = 0;
+// We want to preserve the last location info for possible
+// backtracking.
+frame.add (&call_stack::set_line, &m_call_stack,
+m_call_stack.current_line ());
+frame.add (&call_stack::set_column, &m_call_stack,
+m_call_stack.current_column ());
+// Similarly, if we have seen a return or break statement, allow all
+// the cleanup code to run before returning or handling the break.
+// We don't have to worry about continue statements because they can
+// only occur in loops.
+frame.protect_var (m_returning);
+m_returning = 0;
+frame.protect_var (m_breaking);
+m_breaking = 0;
+try
+{
+if (list)
+list->accept (*this);
+}
+catch (const execution_exception& ee)
+{
+error_system& es = m_interpreter.get_error_system ();
+es.save_exception (ee);
+m_interpreter.recover_from_exception ();
+if (m_breaking || m_returning)
+frame.discard (2);
+else
+frame.run (2);
+frame.discard (2);
+throw;
+}
+// The unwind_protects are popped off the stack in the reverse of
+// the order they are pushed on.
+// FIXME: these statements say that if we see a break or
+// return statement in the cleanup block, that we want to use the
+// new value of the breaking or returning flag instead of restoring
+// the previous value.  Is that the right thing to do?  I think so.
+// Consider the case of
+//
+//   function foo ()
+//     unwind_protect
+//       fprintf (stderr, "1: this should always be executed\n");
+//       break;
+//       fprintf (stderr, "1: this should never be executed\n");
+//     unwind_protect_cleanup
+//       fprintf (stderr, "2: this should always be executed\n");
+//       return;
+//       fprintf (stderr, "2: this should never be executed\n");
+//     end_unwind_protect
+//   endfunction
+//
+// If we reset the value of the breaking flag, both the returning
+// flag and the breaking flag will be set, and we shouldn't have
+// both.  So, use the most recent one.  If there is no return or
+// break in the cleanup block, the values should be reset to
+// whatever they were when the cleanup block was entered.
+if (m_breaking || m_returning)
+frame.discard (2);
+else
+frame.run (2);
+}
+void
+tree_evaluator::visit_unwind_protect_command (tree_unwind_protect_command& cmd)
+{
+if (m_echo_state)
+{
+int line = cmd.line ();
+if (line < 0)
+line = 1;
+echo_code (line);
+m_echo_file_pos = line + 1;
+}
+tree_statement_list *cleanup_code = cmd.cleanup ();
+tree_statement_list *unwind_protect_code = cmd.body ();
+if (unwind_protect_code)
+{
+try
+{
+unwind_protect_code->accept (*this);
+}
+catch (const execution_exception& ee)
+{
+error_system& es = m_interpreter.get_error_system ();
+// FIXME: Maybe we should be able to temporarily set the
+// interpreter's exception handling state to something "safe"
+// while the cleanup block runs instead of just resetting it
+// here?
+es.save_exception (ee);
+m_interpreter.recover_from_exception ();
+// Run the cleanup code on exceptions, so that it is run even
+// in case of interrupt or out-of-memory.
+do_unwind_protect_cleanup_code (cleanup_code);
+// If an error occurs inside the cleanup code, a new
+// exception will be thrown instead of the original.
+throw;
+}
+catch (const interrupt_exception&)
+{
+// The comments above apply here as well.
+m_interpreter.recover_from_exception ();
+do_unwind_protect_cleanup_code (cleanup_code);
+throw;
+}
+// Also execute the unwind_protect_cleanump code if the
+// unwind_protect block runs without error.
+do_unwind_protect_cleanup_code (cleanup_code);
+}
+}
+void
+tree_evaluator::visit_while_command (tree_while_command& cmd)
+{
+int line = cmd.line ();
+if (line < 0)
+line = 1;
+if (m_echo_state)
+{
+echo_code (line);
+line++;
+}
+unwind_protect_var<bool> upv (m_in_loop_command, true);
+tree_expression *expr = cmd.condition ();
+if (! expr)
+panic_impossible ();
+for (;;)
+{
+if (m_echo_state)
+m_echo_file_pos = line;
+if (m_debug_mode)
+do_breakpoint (cmd.is_active_breakpoint (*this));
+if (is_logically_true (expr, "while"))
+{
+tree_statement_list *loop_body = cmd.body ();
+if (loop_body)
+loop_body->accept (*this);
+if (quit_loop_now ())
+break;
+}
+else
+break;
+}
+}
+void
+tree_evaluator::visit_do_until_command (tree_do_until_command& cmd)
+{
+int line = cmd.line ();
+if (line < 0)
+line = 1;
+if (m_echo_state)
+{
+echo_code (line);
+line++;
+}
+unwind_protect_var<bool> upv (m_in_loop_command, true);
+tree_expression *expr = cmd.condition ();
+if (! expr)
+panic_impossible ();
+for (;;)
+{
+if (m_echo_state)
+m_echo_file_pos = line;
+tree_statement_list *loop_body = cmd.body ();
+if (loop_body)
+loop_body->accept (*this);
+if (quit_loop_now ())
+break;
+if (m_debug_mode)
+do_breakpoint (cmd.is_active_breakpoint (*this));
+if (is_logically_true (expr, "do-until"))
+break;
+}
+}
+void
+tree_evaluator::visit_superclass_ref (tree_superclass_ref&)
+{
+panic_impossible ();
+}
+void
+tree_evaluator::visit_metaclass_query (tree_metaclass_query&)
+{
+panic_impossible ();
+}
+void tree_evaluator::bind_ans (const octave_value& val, bool print)
+{
+static std::string ans = "ans";
+if (val.is_defined ())
+{
+if (val.is_cs_list ())
+{
+octave_value_list lst = val.list_value ();
+for (octave_idx_type i = 0; i < lst.length (); i++)
+bind_ans (lst(i), print);
+}
+else
+{
+// FIXME: Maybe assign could also return the assigned value,
+// just for convenience?
+assign (ans, val);
+if (print)
+{
+// Use varval instead of displaying VAL directly so that
+// we get the right type and value for things like
+// magic_int values that may mutate when stored.
+octave_value_list args = ovl (varval (ans));
+args.stash_name_tags (string_vector (ans));
+feval ("display", args);
+}
+}
+}
+}
+void
+tree_evaluator::do_breakpoint (tree_statement& stmt)
+{
+do_breakpoint (stmt.is_active_breakpoint (*this),
+stmt.is_end_of_fcn_or_script ());
+}
+void
+tree_evaluator::do_breakpoint (bool is_breakpoint,
+bool is_end_of_fcn_or_script)
+{
+bool break_on_this_statement = false;
+if (is_breakpoint)
+break_on_this_statement = true;
+else if (m_dbstep_flag > 0)
+{
+if (m_call_stack.current_frame () == m_debug_frame)
+{
+if (m_dbstep_flag == 1 || is_end_of_fcn_or_script)
+{
+// We get here if we are doing a "dbstep" or a "dbstep N" and
+// the count has reached 1 so that we must stop and return to
+// debug prompt.  Alternatively, "dbstep N" has been used but
+// the end of the frame has been reached so we stop at the last
+// line and return to prompt.
+break_on_this_statement = true;
+}
+else
+{
+// Executing "dbstep N".  Decrease N by one and continue.
+m_dbstep_flag--;
+}
+}
+else if (m_dbstep_flag == 1
+&& m_call_stack.current_frame () < m_debug_frame)
+{
+// We stepped out from the end of a function.
+m_debug_frame = m_call_stack.current_frame ();
+break_on_this_statement = true;
+}
+}
+else if (m_dbstep_flag == -1)
+{
+// We get here if we are doing a "dbstep in".
+break_on_this_statement = true;
+m_debug_frame = m_call_stack.current_frame ();
+}
+else if (m_dbstep_flag == -2)
+{
+// We get here if we are doing a "dbstep out".  Check for end of
+// function and whether the current frame is the same as the
+// cached value because we want to step out from the frame where
+// "dbstep out" was evaluated, not from any functions called from
+// that frame.
+if (is_end_of_fcn_or_script
+&& m_call_stack.current_frame () == m_debug_frame)
+m_dbstep_flag = -1;
+}
+if (! break_on_this_statement)
+break_on_this_statement = m_break_on_next_stmt;
+m_break_on_next_stmt = false;
+if (break_on_this_statement)
+{
+m_dbstep_flag = 0;
+enter_debugger ();
+}
+}
+bool
+tree_evaluator::is_logically_true (tree_expression *expr,
+const char *warn_for)
+{
+bool expr_value = false;
+m_call_stack.set_location (expr->line (), expr->column ());
+octave_value t1 = expr->evaluate (*this);
+if (t1.is_defined ())
+return t1.is_true ();
+else
+error ("%s: undefined value used in conditional expression", warn_for);
+return expr_value;
+}
+octave_value
+tree_evaluator::max_recursion_depth (const octave_value_list& args,
+int nargout)
+{
+return set_internal_variable (m_max_recursion_depth, args, nargout,
+"max_recursion_depth", 0);
+}
+symbol_info_list
+tree_evaluator::glob_symbol_info (const std::string& pattern) const
+{
+return m_call_stack.glob_symbol_info (pattern);
+}
+symbol_info_list
+tree_evaluator::regexp_symbol_info (const std::string& pattern) const
+{
+return m_call_stack.regexp_symbol_info (pattern);
+}
+symbol_info_list
+tree_evaluator::get_symbol_info (void)
+{
+return m_call_stack.get_symbol_info ();
+}
+symbol_info_list
+tree_evaluator::top_scope_symbol_info (void) const
+{
+return m_call_stack.top_scope_symbol_info ();
+}
+octave_map tree_evaluator::get_autoload_map (void) const
+{
+Cell fcn_names (dim_vector (m_autoload_map.size (), 1));
+Cell file_names (dim_vector (m_autoload_map.size (), 1));
+octave_idx_type i = 0;
+for (const auto& fcn_fname : m_autoload_map)
+{
+fcn_names(i) = fcn_fname.first;
+file_names(i) = fcn_fname.second;
+i++;
+}
+octave_map m;
+m.assign ("function", fcn_names);
+m.assign ("file", file_names);
+return m;
+}
+std::string tree_evaluator::lookup_autoload (const std::string& nm) const
+{
+std::string retval;
+auto p = m_autoload_map.find (nm);
+if (p != m_autoload_map.end ())
+{
+load_path& lp = m_interpreter.get_load_path ();
+retval = lp.find_file (p->second);
+}
+return retval;
+}
+std::list<std::string> tree_evaluator::autoloaded_functions (void) const
+{
+std::list<std::string> names;
+for (const auto& fcn_fname : m_autoload_map)
+names.push_back (fcn_fname.first);
+return names;
+}
+std::list<std::string>
+tree_evaluator::reverse_lookup_autoload (const std::string& nm) const
+{
+std::list<std::string> names;
+for (const auto& fcn_fname : m_autoload_map)
+if (nm == fcn_fname.second)
+names.push_back (fcn_fname.first);
+return names;
+}
+void tree_evaluator::add_autoload (const std::string& fcn,
+const std::string& nm)
+{
+std::string file_name = check_autoload_file (nm);
+m_autoload_map[fcn] = file_name;
+}
+void tree_evaluator::remove_autoload (const std::string& fcn,
+const std::string& nm)
+{
+check_autoload_file (nm);
+// Remove function from symbol table and autoload map.
+symbol_table& symtab = m_interpreter.get_symbol_table ();
+symtab.clear_dld_function (fcn);
+m_autoload_map.erase (fcn);
+}
+octave_value
+tree_evaluator::whos_line_format (const octave_value_list& args, int nargout)
+{
+return set_internal_variable (m_whos_line_format, args, nargout,
+"whos_line_format");
+}
+octave_value
+tree_evaluator::silent_functions (const octave_value_list& args, int nargout)
+{
+return set_internal_variable (m_silent_functions, args, nargout,
+"silent_functions");
+}
+octave_value
+tree_evaluator::string_fill_char (const octave_value_list& args, int nargout)
+{
+return set_internal_variable (m_string_fill_char, args, nargout,
+"string_fill_char");
+}
+// Final step of processing an indexing error.  Add the name of the
+// variable being indexed, if any, then issue an error.  (Will this also
+// be needed by pt-lvalue, which calls subsref?)
+void tree_evaluator::final_index_error (index_exception& ie,
+const tree_expression *expr)
+{
+std::string extra_message;
+if (is_variable (expr))
+{
+std::string var = expr->name ();
+ie.set_var (var);
+symbol_table& symtab = m_interpreter.get_symbol_table ();
+octave_value fcn = symtab.find_function (var);
+if (fcn.is_function ())
+{
+octave_function *fp = fcn.function_value ();
+if (fp && fp->name () == var)
+extra_message
+= " (note: variable '" + var + "' shadows function)";
+}
+}
+std::string msg = ie.message () + extra_message;
+error_with_id (ie.err_id (), "%s", msg.c_str ());
+}
+octave_value
+tree_evaluator::do_who (int argc, const string_vector& argv,
+bool return_list, bool verbose)
+{
+return m_call_stack.do_who (argc, argv, return_list, verbose);
+}
+octave_value_list
+tree_evaluator::make_value_list (tree_argument_list *args,
+const string_vector& arg_nm)
+{
+octave_value_list retval;
+if (args)
+{
+unwind_protect_var<const std::list<octave_lvalue> *>
+upv (m_lvalue_list, nullptr);
+int len = args->length ();
+unwind_protect_var<int> upv2 (m_index_position);
+unwind_protect_var<int> upv3 (m_num_indices);
+m_num_indices = len;
+std::list<octave_value> arg_vals;
+int k = 0;
+for (auto elt : *args)
+{
+// FIXME: is it possible for elt to be invalid?
+if (! elt)
+break;
+m_index_position = k++;
+octave_value tmp = elt->evaluate (*this);
+if (tmp.is_cs_list ())
+{
+octave_value_list tmp_ovl = tmp.list_value ();
+for (octave_idx_type i = 0; i < tmp_ovl.length (); i++)
+arg_vals.push_back (tmp_ovl(i));
+}
+else if (tmp.is_defined ())
+arg_vals.push_back (tmp);
+}
+retval = octave_value_list (arg_vals);
+}
+octave_idx_type n = retval.length ();
+if (n > 0)
+retval.stash_name_tags (arg_nm);
+return retval;
+}
+std::list<octave_lvalue>
+tree_evaluator::make_lvalue_list (tree_argument_list *lhs)
+{
+std::list<octave_lvalue> retval;
+for (tree_expression *elt : *lhs)
+retval.push_back (elt->lvalue (*this));
+return retval;
+}
+void
+tree_evaluator::push_echo_state (int type, const std::string& file_name,
+int pos)
+{
+unwind_protect *frame = m_call_stack.curr_fcn_unwind_protect_frame ();
+if (frame)
+{
+push_echo_state_cleanup (*frame);
+set_echo_state (type, file_name, pos);
+}
+}
+void
+tree_evaluator::set_echo_state (int type, const std::string& file_name,
+int pos)
+{
+m_echo_state = echo_this_file (file_name, type);
+m_echo_file_name = file_name;
+m_echo_file_pos = pos;
+}
+void
+tree_evaluator::uwp_set_echo_state (bool state, const std::string& file_name,
+int pos)
+{
+m_echo_state = state;
+m_echo_file_name = file_name;
+m_echo_file_pos = pos;
+}
+void
+tree_evaluator::maybe_set_echo_state (void)
+{
+octave_function *caller = caller_function ();
+if (caller && caller->is_user_code ())
+{
+octave_user_code *fcn = dynamic_cast<octave_user_code *> (caller);
+int type = fcn->is_user_function () ? ECHO_FUNCTIONS : ECHO_SCRIPTS;
+std::string file_name = fcn->fcn_file_name ();
+// We want the line where "echo" was called, not the line number
+// stored in the stack frame that was created for the echo
+// function (that will always be -1).
+int pos = m_call_stack.current_user_code_line ();
+if (pos < 0)
+pos = 1;
+set_echo_state (type, file_name, pos);
+}
+}
+void
+tree_evaluator::push_echo_state_cleanup (unwind_protect& frame)
+{
+frame.add (&tree_evaluator::uwp_set_echo_state, this,
+m_echo_state, m_echo_file_name, m_echo_file_pos);
+}
+bool tree_evaluator::maybe_push_echo_state_cleanup (void)
+{
+// This function is expected to be called from ECHO, which would be
+// the top of the call stack.  If the caller of ECHO is a
+// user-defined function or script, then set up unwind-protect
+// elements to restore echo state.
+unwind_protect *frame = m_call_stack.curr_fcn_unwind_protect_frame ();
+if (frame)
+{
+push_echo_state_cleanup (*frame);
+return true;
+}
+return false;
+}
+octave_value
+tree_evaluator::echo (const octave_value_list& args, int)
+{
+bool cleanup_pushed = maybe_push_echo_state_cleanup ();
+string_vector argv = args.make_argv ();
+switch (args.length ())
+{
+case 0:
+if ((m_echo & ECHO_SCRIPTS) || (m_echo & ECHO_FUNCTIONS))
+{
+m_echo = ECHO_OFF;
+m_echo_files.clear ();
+}
+else
+m_echo = ECHO_SCRIPTS;
+break;
+case 1:
 {
-// FIXME: is it possible for elt to be invalid?
+std::string arg0 = argv[0];
-if (! elt)
+if (arg0 == "on")
-break;
+m_echo = ECHO_SCRIPTS;
+else if (arg0 == "off")
-octave_value tmp = elt->evaluate (*this);
+m_echo = ECHO_OFF;
+else
-if (tmp.is_cs_list ())
 {
-octave_value_list tmp_ovl = tmp.list_value ();
+std::string file = fcn_file_in_path (arg0);
+file = sys::env::make_absolute (file);
-for (octave_idx_type i = 0; i < tmp_ovl.length (); i++)
-arg_vals.push_back (tmp_ovl(i));
+if (file.empty ())
-}
+error ("echo: no such file %s", arg0.c_str ());
-else if (tmp.is_defined ())
-arg_vals.push_back (tmp);
+if (m_echo & ECHO_ALL)
-}
-return octave_value_list (arg_vals);
-}
-octave_value_list
-tree_evaluator::convert_return_list_to_const_vector
-(tree_parameter_list *ret_list, int nargout, const Matrix& ignored_outputs,
-const Cell& varargout)
-{
-octave_idx_type vlen = varargout.numel ();
-int len = ret_list->length ();
-// Special case.  Will do a shallow copy.
-if (len == 0)
-return varargout;
-else
-{
-int i = 0;
-int k = 0;
-int num_ignored = ignored_outputs.numel ();
-int ignored = num_ignored > 0 ? ignored_outputs(k) - 1 : -1;
-if (nargout <= len)
-{
-int nout = nargout > 0 ? nargout : 1;
-octave_value_list retval (nout);
-for (tree_decl_elt *elt : *ret_list)
 {
-if (nargout == 0 && ! is_defined (elt->ident ()))
+// Echo is enabled for all functions, so turn it off
-break;
+// for this one.
-if (ignored >= 0 && i == ignored)
+m_echo_files[file] = false;
+}
+else
+{
+// Echo may be enabled for specific functions.
+auto p = m_echo_files.find (file);
+if (p == m_echo_files.end ())
 {
-i++;
+// Not this one, so enable it.
-k++;
-ignored = k < num_ignored ? ignored_outputs(k) - 1 : -1;
+m_echo |= ECHO_FUNCTIONS;
+m_echo_files[file] = true;
 }
 else
-retval(i++) = evaluate (elt);
-if (i == nout)
-break;
-}
-return retval;
-}
-else
-{
-octave_value_list retval (len + vlen);
-for (tree_decl_elt *elt : *ret_list)
-{
-if (ignored >= 0 && i == ignored)
 {
-i++;
+// This one is already in the list.  Flip the
-k++;
+// status for it.
-ignored = k < num_ignored ? ignored_outputs(k) - 1 : -1;
-}
+p->second = ! p->second;
-else
-retval(i++) = evaluate (elt);
-}
-for (octave_idx_type j = 0; j < vlen; j++)
-retval(i++) = varargout(j);
-return retval;
-}
-}
-}
-bool
-tree_evaluator::eval_decl_elt (tree_decl_elt *elt)
-{
-bool retval = false;
-tree_identifier *id = elt->ident ();
-tree_expression *expr = elt->expression ();
-if (id && expr)
-{
-octave_lvalue ult = id->lvalue (*this);
-octave_value init_val = expr->evaluate (*this);
-ult.assign (octave_value::op_asn_eq, init_val);
-retval = true;
-}
-return retval;
-}
-bool
-tree_evaluator::switch_case_label_matches (tree_switch_case *expr,
-const octave_value& val)
-{
-tree_expression *label = expr->case_label ();
-octave_value label_value = label->evaluate (*this);
-if (label_value.is_defined ())
-{
-if (label_value.iscell ())
-{
-Cell cell (label_value.cell_value ());
-for (octave_idx_type i = 0; i < cell.rows (); i++)
-{
-for (octave_idx_type j = 0; j < cell.columns (); j++)
-{
-bool match = val.is_equal (cell(i,j));
-if (match)
-return true;
 }
 }
 }
-else
-return val.is_equal (label_value);
 }
+break;
-return false;
-}
+case 2:
-void tree_evaluator::push_stack_frame (const symbol_scope& scope)
-{
-m_call_stack.push (scope);
-}
-void tree_evaluator::push_stack_frame (octave_user_function *fcn,
-const std::shared_ptr<stack_frame>& closure_frames)
-{
-m_call_stack.push (fcn, closure_frames);
-}
-void tree_evaluator::push_stack_frame (octave_user_function *fcn,
-const stack_frame::local_vars_map& local_vars,
-const std::shared_ptr<stack_frame>& closure_frames)
-{
-m_call_stack.push (fcn, local_vars, closure_frames);
-}
-void tree_evaluator::push_stack_frame (octave_user_script *script)
-{
-m_call_stack.push (script);
-}
-void tree_evaluator::push_stack_frame (octave_function *fcn)
-{
-m_call_stack.push (fcn);
-}
-void tree_evaluator::pop_stack_frame (void)
-{
-m_call_stack.pop ();
-}
-int tree_evaluator::current_line (void) const
-{
-return m_call_stack.current_line ();
-}
-int tree_evaluator::current_column (void) const
-{
-return m_call_stack.current_column ();
-}
-int tree_evaluator::debug_user_code_line (void) const
-{
-return m_call_stack.debug_user_code_line ();
-}
-int tree_evaluator::debug_user_code_column (void) const
-{
-return m_call_stack.debug_user_code_column ();
-}
-void tree_evaluator::debug_where (std::ostream& os) const
-{
-std::shared_ptr<stack_frame> frm = m_call_stack.current_user_frame ();
-frm->display_stopped_in_message (os);
-}
-octave_user_code * tree_evaluator::current_user_code (void) const
-{
-return m_call_stack.current_user_code ();
-}
-unwind_protect * tree_evaluator::curr_fcn_unwind_protect_frame (void)
-{
-return m_call_stack.curr_fcn_unwind_protect_frame ();
-}
-octave_user_code * tree_evaluator::debug_user_code (void) const
-{
-return m_call_stack.debug_user_code ();
-}
-octave_function * tree_evaluator::current_function (bool skip_first) const
-{
-return m_call_stack.current_function (skip_first);
-}
-octave_function * tree_evaluator::caller_function (void) const
-{
-return m_call_stack.current_function (true);
-}
-bool tree_evaluator::goto_frame (std::size_t n, bool verbose)
-{
-return m_call_stack.goto_frame (n, verbose);
-}
-void tree_evaluator::goto_caller_frame (void)
-{
-m_call_stack.goto_caller_frame ();
-}
-void tree_evaluator::goto_base_frame (void)
-{
-m_call_stack.goto_base_frame ();
-}
-void tree_evaluator::restore_frame (std::size_t n)
-{
-return m_call_stack.restore_frame (n);
-}
-std::string tree_evaluator::get_dispatch_class (void) const
-{
-return m_call_stack.get_dispatch_class ();
-}
-void tree_evaluator::set_dispatch_class (const std::string& class_name)
-{
-m_call_stack.set_dispatch_class (class_name);
-}
-bool
-tree_evaluator::is_class_method_executing (std::string& dclass) const
-{
-return m_call_stack.is_class_method_executing (dclass);
-}
-bool
-tree_evaluator::is_class_constructor_executing (std::string& dclass) const
-{
-return m_call_stack.is_class_constructor_executing (dclass);
-}
-std::list<std::shared_ptr<stack_frame>>
-tree_evaluator::backtrace_frames (octave_idx_type& curr_user_frame) const
-{
-return m_call_stack.backtrace_frames (curr_user_frame);
-}
-std::list<std::shared_ptr<stack_frame>>
-tree_evaluator::backtrace_frames (void) const
-{
-return m_call_stack.backtrace_frames ();
-}
-std::list<frame_info>
-tree_evaluator::backtrace_info (octave_idx_type& curr_user_frame,
-bool print_subfn) const
-{
-return m_call_stack.backtrace_info (curr_user_frame, print_subfn);
-}
-std::list<frame_info> tree_evaluator::backtrace_info (void) const
-{
-return m_call_stack.backtrace_info ();
-}
-octave_map
-tree_evaluator::backtrace (octave_idx_type& curr_user_frame,
-bool print_subfn) const
-{
-return m_call_stack.backtrace (curr_user_frame, print_subfn);
-}
-octave_map tree_evaluator::backtrace (void) const
-{
-return m_call_stack.backtrace ();
-}
-octave_map tree_evaluator::empty_backtrace (void) const
-{
-return m_call_stack.empty_backtrace ();
-}
-std::string tree_evaluator::backtrace_message (void) const
-{
-std::list<frame_info> frames = backtrace_info ();
-std::ostringstream buf;
-for (const auto& frm : frames)
 {
-buf << "    " << frm.fcn_name ();
+std::string arg0 = argv[0];
+std::string arg1 = argv[1];
-int line = frm.line ();
+if (arg1 == "on" || arg1 == "off")
-if (line > 0)
+std::swap (arg0, arg1);
+if (arg0 == "on")
 {
-buf << " at line " << line;
+if (arg1 == "all")
-int column = frm.column ();
-if (column > 0)
-buf << " column " << column;
-buf << "\n";
-}
-}
-return buf.str ();
-}
-void tree_evaluator::push_dummy_scope (const std::string& name)
-{
-symbol_scope dummy_scope (name + "$dummy");
-m_call_stack.push (dummy_scope);
-}
-void tree_evaluator::pop_scope (void)
-{
-m_call_stack.pop ();
-}
-symbol_scope tree_evaluator::get_top_scope (void) const
-{
-return m_call_stack.top_scope ();
-}
-symbol_scope tree_evaluator::get_current_scope (void) const
-{
-return m_call_stack.current_scope ();
-}
-void tree_evaluator::mlock (bool skip_first) const
-{
-octave_function *fcn = m_call_stack.current_function (skip_first);
-if (! fcn)
-error ("mlock: invalid use outside a function");
-if (fcn->is_builtin_function ())
-{
-warning ("mlock: locking built-in function has no effect");
-return;
-}
-fcn->lock ();
-}
-void tree_evaluator::munlock (bool skip_first) const
-{
-octave_function *fcn = m_call_stack.current_function (skip_first);
-if (! fcn)
-error ("munlock: invalid use outside a function");
-if (fcn->is_builtin_function ())
-{
-warning ("munlock: unlocking built-in function has no effect");
-return;
-}
-fcn->unlock ();
-}
-bool tree_evaluator::mislocked (bool skip_first) const
-{
-octave_function *fcn = m_call_stack.current_function (skip_first);
-if (! fcn)
-error ("mislocked: invalid use outside a function");
-return fcn->islocked ();
-}
-octave_value
-tree_evaluator::max_stack_depth (const octave_value_list& args, int nargout)
-{
-return m_call_stack.max_stack_depth (args, nargout);
-}
-void tree_evaluator::display_call_stack (void) const
-{
-m_call_stack.display ();
-}
-octave_value tree_evaluator::find (const std::string& name)
-{
-std::shared_ptr<stack_frame> frame
-= m_call_stack.get_current_stack_frame ();
-octave_value val = frame->varval (name);
-if (val.is_defined ())
-return val;
-// Subfunction.  I think it only makes sense to check for
-// subfunctions if we are currently executing a function defined
-// from a .m file.
-octave_value fcn = frame->find_subfunction (name);
-if (fcn.is_defined ())
-return fcn;
-symbol_table& symtab = m_interpreter.get_symbol_table ();
-return symtab.fcn_table_find (name, ovl ());
-}
-void tree_evaluator::clear_objects (void)
-{
-std::shared_ptr<stack_frame> frame
-= m_call_stack.get_current_stack_frame ();
-frame->clear_objects ();
-}
-void tree_evaluator::clear_variable (const std::string& name)
-{
-std::shared_ptr<stack_frame> frame
-= m_call_stack.get_current_stack_frame ();
-frame->clear_variable (name);
-}
-void tree_evaluator::clear_variable_pattern (const std::string& pattern)
-{
-std::shared_ptr<stack_frame> frame
-= m_call_stack.get_current_stack_frame ();
-frame->clear_variable_pattern (pattern);
-}
-void tree_evaluator::clear_variable_regexp (const std::string& pattern)
-{
-std::shared_ptr<stack_frame> frame
-= m_call_stack.get_current_stack_frame ();
-frame->clear_variable_regexp (pattern);
-}
-void tree_evaluator::clear_variables (void)
-{
-std::shared_ptr<stack_frame> frame
-= m_call_stack.get_current_stack_frame ();
-frame->clear_variables ();
-}
-void tree_evaluator::clear_global_variable (const std::string& name)
-{
-m_call_stack.clear_global_variable (name);
-}
-void
-tree_evaluator::clear_global_variable_pattern (const std::string& pattern)
-{
-m_call_stack.clear_global_variable_pattern (pattern);
-}
-void tree_evaluator::clear_global_variable_regexp(const std::string& pattern)
-{
-m_call_stack.clear_global_variable_regexp (pattern);
-}
-void tree_evaluator::clear_global_variables (void)
-{
-m_call_stack.clear_global_variables ();
-}
-void tree_evaluator::clear_all (bool force)
-{
-// FIXME: should this also clear objects?
-clear_variables ();
-clear_global_variables ();
-symbol_table& symtab = m_interpreter.get_symbol_table ();
-symtab.clear_functions (force);
-}
-void tree_evaluator::clear_symbol (const std::string& name)
-{
-// FIXME: are we supposed to do both here?
-clear_variable (name);
-symbol_table& symtab = m_interpreter.get_symbol_table ();
-symtab.clear_function (name);
-}
-void tree_evaluator::clear_symbol_pattern (const std::string& pattern)
-{
-// FIXME: are we supposed to do both here?
-clear_variable_pattern (pattern);
-symbol_table& symtab = m_interpreter.get_symbol_table ();
-symtab.clear_function_pattern (pattern);
-}
-void tree_evaluator::clear_symbol_regexp (const std::string& pattern)
-{
-// FIXME: are we supposed to do both here?
-clear_variable_regexp (pattern);
-symbol_table& symtab = m_interpreter.get_symbol_table ();
-symtab.clear_function_regexp (pattern);
-}
-std::list<std::string> tree_evaluator::global_variable_names (void) const
-{
-return m_call_stack.global_variable_names ();
-}
-std::list<std::string> tree_evaluator::top_level_variable_names (void) const
-{
-return m_call_stack.top_level_variable_names ();
-}
-std::list<std::string> tree_evaluator::variable_names (void) const
-{
-return m_call_stack.variable_names ();
-}
-// Return a pointer to the user-defined function FNAME.  If FNAME is empty,
-// search backward for the first user-defined function in the
-// current call stack.
-octave_user_code *
-tree_evaluator::get_user_code (const std::string& fname,
-const std::string& class_name)
-{
-octave_user_code *user_code = nullptr;
-if (fname.empty ())
-user_code = m_call_stack.debug_user_code ();
-else
-{
-std::string name = fname;
-if (sys::file_ops::dir_sep_char () != '/' && name[0] == '@')
-{
-auto beg = name.begin () + 2;  // never have @/method
-auto end = name.end () - 1;    // never have trailing '/'
-std::replace (beg, end, '/', sys::file_ops::dir_sep_char ());
-}
-std::size_t name_len = name.length ();
-if (name_len > 2 && name.substr (name_len-2) == ".m")
-name = name.substr (0, name_len-2);
-if (name.empty ())
-return nullptr;
-symbol_table& symtab = m_interpreter.get_symbol_table ();
-octave_value fcn;
-std::size_t p2 = std::string::npos;
-if (name[0] == '@')
-{
-std::size_t p1 = name.find (sys::file_ops::dir_sep_char (), 1);
-if (p1 == std::string::npos)
-return nullptr;
-std::string dispatch_type = name.substr (1, p1-1);
-p2 = name.find ('>', p1);
-std::string method = name.substr (p1+1, p2-1);
-fcn = symtab.find_method (method, dispatch_type);
-}
-else if (! class_name.empty ())
-{
-cdef_manager& cdm = m_interpreter.get_cdef_manager ();
-fcn = cdm.find_method (class_name, name);
-// If there is no classdef method, then try legacy classes.
-if (fcn.is_undefined ())
-fcn = symtab.find_method (name, class_name);
-}
-else
-{
-p2 = name.find ('>');
-std::string main_fcn = name.substr (0, p2);
-fcn = symtab.find_function (main_fcn);
-}
-// List of function names sub1>sub2>...
-std::string subfuns;
-if (p2 != std::string::npos)
-subfuns = name.substr (p2+1);
-if (fcn.is_defined () && fcn.is_user_code ())
-user_code = fcn.user_code_value ();
-if (! user_code || subfuns.empty ())
-return user_code;
-fcn = user_code->find_subfunction (subfuns);
-if (fcn.is_undefined ())
-return nullptr;
-user_code = fcn.user_code_value ();
-}
-return user_code;
-}
-std::string
-tree_evaluator::current_function_name (bool skip_first) const
-{
-octave_function *curfcn = m_call_stack.current_function (skip_first);
-if (curfcn)
-return curfcn->name ();
-return "";
-}
-bool
-tree_evaluator::in_user_code (void) const
-{
-return m_call_stack.current_user_code () != nullptr;
-}
-void
-tree_evaluator::visit_decl_command (tree_decl_command& cmd)
-{
-if (m_echo_state)
-{
-int line = cmd.line ();
-if (line < 0)
-line = 1;
-echo_code (line);
-m_echo_file_pos = line + 1;
-}
-if (m_debug_mode)
-do_breakpoint (cmd.is_active_breakpoint (*this));
-// FIXME: tree_decl_init_list is not derived from tree, so should it
-// really have an accept method?
-tree_decl_init_list *init_list = cmd.initializer_list ();
-if (init_list)
-init_list->accept (*this);
-}
-void
-tree_evaluator::visit_decl_elt (tree_decl_elt& elt)
-{
-tree_identifier *id = elt.ident ();
-if (id)
-{
-if (elt.is_global ())
-m_call_stack.make_global (id->symbol ());
-else if (elt.is_persistent ())
-m_call_stack.make_persistent (id->symbol ());
-else
-error ("declaration list element not global or persistent");
-octave_lvalue ult = id->lvalue (*this);
-if (ult.is_undefined ())
-{
-tree_expression *expr = elt.expression ();
-octave_value init_val;
-if (expr)
-init_val = expr->evaluate (*this);
-else
-init_val = Matrix ();
-ult.assign (octave_value::op_asn_eq, init_val);
-}
-}
-}
-template <typename T>
-void
-tree_evaluator::execute_range_loop (const range<T>& rng, int line,
-octave_lvalue& ult,
-tree_statement_list *loop_body)
-{
-octave_idx_type steps = rng.numel ();
-if (math::isinf (rng.limit ()))
-warning_with_id ("Octave:infinite-loop",
-"FOR loop limit is infinite, will stop after %"
-OCTAVE_IDX_TYPE_FORMAT " steps", steps);
-for (octave_idx_type i = 0; i < steps; i++)
-{
-if (m_echo_state)
-m_echo_file_pos = line;
-octave_value val (rng.elem (i));
-ult.assign (octave_value::op_asn_eq, val);
-if (loop_body)
-loop_body->accept (*this);
-if (quit_loop_now ())
-break;
-}
-}
-void
-tree_evaluator::visit_simple_for_command (tree_simple_for_command& cmd)
-{
-int line = cmd.line ();
-if (line < 0)
-line = 1;
-if (m_echo_state)
-{
-echo_code (line);
-line++;
-}
-if (m_debug_mode)
-do_breakpoint (cmd.is_active_breakpoint (*this));
-// FIXME: need to handle PARFOR loops here using cmd.in_parallel ()
-// and cmd.maxproc_expr ();
-unwind_protect_var<bool> upv (m_in_loop_command, true);
-tree_expression *expr = cmd.control_expr ();
-octave_value rhs = expr->evaluate (*this);
-if (rhs.is_undefined ())
-return;
-tree_expression *lhs = cmd.left_hand_side ();
-octave_lvalue ult = lhs->lvalue (*this);
-tree_statement_list *loop_body = cmd.body ();
-if (rhs.is_range ())
-{
-// FIXME: is there a better way to dispatch here?
-if (rhs.is_double_type ())
-{
-execute_range_loop (rhs.range_value (), line, ult, loop_body);
-return;
-}
-// For now, disable all but range<double>.
-#if 0
-if (rhs.is_int64_type ())
-{
-execute_range_loop (rhs.int64_range_value (), line, ult, loop_body);
-return;
-}
-if (rhs.is_uint64_type ())
-{
-execute_range_loop (rhs.uint64_range_value (), line, ult, loop_body);
-return;
-}
-if (rhs.is_int32_type ())
-{
-execute_range_loop (rhs.int32_range_value (), line, ult, loop_body);
-return;
-}
-if (rhs.is_uint32_type ())
-{
-execute_range_loop (rhs.uint32_range_value (), line, ult, loop_body);
-return;
-}
-if (rhs.is_int16_type ())
-{
-execute_range_loop (rhs.int16_range_value (), line, ult, loop_body);
-return;
-}
-if (rhs.is_uint16_type ())
-{
-execute_range_loop (rhs.uint16_range_value (), line, ult, loop_body);
-return;
-}
-if (rhs.is_int8_type ())
-{
-execute_range_loop (rhs.int8_range_value (), line, ult, loop_body);
-return;
-}
-if (rhs.is_uint8_type ())
-{
-execute_range_loop (rhs.uint8_range_value (), line, ult, loop_body);
-return;
-}
-if (rhs.is_single_type ())
-{
-execute_range_loop (rhs.float_range_value (), line, ult, loop_body);
-return;
-}
-#endif
-}
-if (rhs.is_scalar_type ())
-{
-if (m_echo_state)
-m_echo_file_pos = line;
-ult.assign (octave_value::op_asn_eq, rhs);
-if (loop_body)
-loop_body->accept (*this);
-// Maybe decrement break and continue states.
-quit_loop_now ();
-return;
-}
-// Also handle any range types not explicitly handled above, though
-// not as efficiently as the specialized code above.
-if (rhs.is_range () || rhs.is_matrix_type () || rhs.iscell ()
-|| rhs.is_string () || rhs.isstruct ())
-{
-// A matrix or cell is reshaped to 2 dimensions and iterated by
-// columns.
-dim_vector dv = rhs.dims ().redim (2);
-octave_idx_type nrows = dv(0);
-octave_idx_type steps = dv(1);
-octave_value arg = rhs;
-if (rhs.ndims () > 2)
-arg = arg.reshape (dv);
-if (nrows > 0 && steps > 0)
-{
-octave_value_list idx;
-octave_idx_type iidx;
-// for row vectors, use single index to speed things up.
-if (nrows == 1)
 {
-idx.resize (1);
+m_echo = (ECHO_SCRIPTS | ECHO_FUNCTIONS | ECHO_ALL);
-iidx = 0;
+m_echo_files.clear ();
 }
 else
 {
-idx.resize (2);
+std::string file = fcn_file_in_path (arg1);
-idx(0) = octave_value::magic_colon_t;
+file = sys::env::make_absolute (file);
-iidx = 1;
+if (file.empty ())
+error ("echo: no such file %s", arg1.c_str ());
+m_echo |= ECHO_FUNCTIONS;
+m_echo_files[file] = true;
 }
+}
-for (octave_idx_type i = 1; i <= steps; i++)
+else if (arg0 == "off")
+{
+if (arg1 == "all")
 {
-if (m_echo_state)
+m_echo = ECHO_OFF;
-m_echo_file_pos = line;
+m_echo_files.clear ();
+}
-// index_op expects one-based indices.
+else
-idx(iidx) = i;
+{
-octave_value val = arg.index_op (idx);
+std::string file = fcn_file_in_path (arg1);
+file = sys::env::make_absolute (file);
-ult.assign (octave_value::op_asn_eq, val);
+if (file.empty ())
-if (loop_body)
+error ("echo: no such file %s", arg1.c_str ());
-loop_body->accept (*this);
+m_echo_files[file] = false;
-if (quit_loop_now ())
-break;
 }
 }
 else
+print_usage ();
+}
+break;
+default:
+print_usage ();
+break;
+}
+if (cleanup_pushed)
+maybe_set_echo_state ();
+return octave_value ();
+}
+bool tree_evaluator::in_debug_repl (void) const
+{
+return (m_debugger_stack.empty ()
+? false : m_debugger_stack.top()->in_debug_repl ());
+}
+void tree_evaluator::dbcont (void)
+{
+if (! m_debugger_stack.empty ())
+m_debugger_stack.top()->dbcont ();
+}
+void tree_evaluator::dbquit (bool all)
+{
+if (! m_debugger_stack.empty ())
+m_debugger_stack.top()->dbquit (all);
+}
+static octave_value end_value (const octave_value& value,
+octave_idx_type index_position,
+octave_idx_type num_indices)
+{
+dim_vector dv = value.dims ();
+int ndims = dv.ndims ();
+if (num_indices < ndims)
+{
+for (int i = num_indices; i < ndims; i++)
+dv(num_indices-1) *= dv(i);
+if (num_indices == 1)
+{
+ndims = 2;
+dv.resize (ndims);
+dv(1) = 1;
+}
+else
+{
+ndims = num_indices;
+dv.resize (ndims);
+}
+}
+return (index_position < ndims
+? octave_value (dv(index_position)) : octave_value (1.0));
+}
+octave_value_list
+tree_evaluator::evaluate_end_expression (const octave_value_list& args)
+{
+int nargin = args.length ();
+if (nargin != 0 && nargin != 3)
+print_usage ();
+if (nargin == 3)
+{
+octave_idx_type index_position
+= args(1).xidx_type_value ("end: K must be integer value");
+if (index_position < 1)
+error ("end: K must be greater than zero");
+octave_idx_type num_indices
+= args(2).xidx_type_value ("end: N must be integer value");
+if (num_indices < 1)
+error ("end: N must be greater than zero");
+return end_value (args(0), index_position-1, num_indices);
+}
+// If m_indexed_object is undefined, then this use of 'end' is
+// either appearing in a function call argument list or in an
+// attempt to index an undefined symbol.  There seems to be no
+// reasonable way to provide a better error message.  So just fail
+// with an invalid use message.  See bug #58830.
+if (m_indexed_object.is_undefined ())
+error ("invalid use of 'end': may only be used to index existing value");
+octave_value expr_result;
+if (m_index_list.empty ())
+expr_result = m_indexed_object;
+else
+{
+try
+{
+// When evaluating "end" with no arguments, we should have
+// been called from the built-in Fend function that appears
+// in the context of an argument list.  Fend will be
+// evaluated in its own stack frame.  But we need to
+// evaluate the partial expression that the special "end"
+// token applies to in the calling stack frame.
+unwind_action act ([=] (std::size_t frm)
 {
-// Handle empty cases, while still assigning to loop var.
+m_call_stack.restore_frame (frm);
-ult.assign (octave_value::op_asn_eq, arg);
+}, m_call_stack.current_frame ());
-}
+std::size_t n = m_call_stack.find_current_user_frame ();
-return;
+m_call_stack.goto_frame (n);
-}
+// End is only valid inside argument lists used for
-error ("invalid type in for loop expression near line %d, column %d",
+// indexing.  The dispatch class is set by the function that
-cmd.line (), cmd.column ());
+// evaluates the argument list.
-}
+// Silently ignore extra output values.
-void
-tree_evaluator::visit_complex_for_command (tree_complex_for_command& cmd)
+octave_value_list tmp
-{
+= m_indexed_object.subsref (m_index_type, m_index_list, 1);
-int line = cmd.line ();
-if (line < 0)
+expr_result = tmp.length () ? tmp(0) : octave_value ();
-line = 1;
+if (expr_result.is_cs_list ())
-if (m_echo_state)
+err_indexed_cs_list ();
-{
+}
-echo_code (line);
+catch (const index_exception&)
-line++;
+{
-}
+error ("error evaluating partial expression for END");
+}
-if (m_debug_mode)
+}
-do_breakpoint (cmd.is_active_breakpoint (*this));
+if (expr_result.isobject ())
-unwind_protect_var<bool> upv (m_in_loop_command, true);
+{
+// FIXME: is there a better way to lookup and execute a method
-tree_expression *expr = cmd.control_expr ();
+// that handles all the details like setting the dispatch class
+// appropriately?
-octave_value rhs = expr->evaluate (*this);
+std::string dispatch_class = expr_result.class_name ();
-if (rhs.is_undefined ())
-return;
+symbol_table& symtab = m_interpreter.get_symbol_table ();
-if (! rhs.isstruct ())
+octave_value meth = symtab.find_method ("end", dispatch_class);
-error ("in statement 'for [X, Y] = VAL', VAL must be a structure");
+if (meth.is_defined ())
-// Cycle through structure elements.  First element of id_list
+return m_interpreter.feval
-// is set to value and the second is set to the name of the
+(meth, ovl (expr_result, m_index_position+1, m_num_indices), 1);
-// structure element.
+}
-tree_argument_list *lhs = cmd.left_hand_side ();
+return end_value (expr_result, m_index_position, m_num_indices);
+}
-auto p = lhs->begin ();
+octave_value
-tree_expression *elt = *p++;
+tree_evaluator::PS4 (const octave_value_list& args, int nargout)
+{
-octave_lvalue val_ref = elt->lvalue (*this);
+return set_internal_variable (m_PS4, args, nargout, "PS4");
+}
-elt = *p;
+bool tree_evaluator::echo_this_file (const std::string& file, int type) const
-octave_lvalue key_ref = elt->lvalue (*this);
+{
+if ((type & m_echo) == ECHO_SCRIPTS)
-const octave_map tmp_val = rhs.map_value ();
+{
+// Asking about scripts and echo is enabled for them.
-tree_statement_list *loop_body = cmd.body ();
+return true;
+}
-string_vector keys = tmp_val.keys ();
+if ((type & m_echo) == ECHO_FUNCTIONS)
-octave_idx_type nel = keys.numel ();
+{
+// Asking about functions and echo is enabled for functions.
-for (octave_idx_type i = 0; i < nel; i++)
+// Now, which ones?
-{
-if (m_echo_state)
+auto p = m_echo_files.find (file);
-m_echo_file_pos = line;
+if (m_echo & ECHO_ALL)
-std::string key = keys[i];
+{
+// Return true ulness echo was turned off for a specific
-const Cell val_lst = tmp_val.contents (key);
+// file.
-octave_idx_type n = val_lst.numel ();
+return (p == m_echo_files.end () || p->second);
+}
-octave_value val = (n == 1) ? val_lst(0) : octave_value (val_lst);
+else
+{
-val_ref.assign (octave_value::op_asn_eq, val);
+// Return true if echo is specifically enabled for this file.
-key_ref.assign (octave_value::op_asn_eq, key);
+return p != m_echo_files.end () && p->second;
-if (loop_body)
+}
-loop_body->accept (*this);
+}
-if (quit_loop_now ())
+return false;
-break;
+}
-}
-}
+void tree_evaluator::echo_code (int line)
+{
-void tree_evaluator::visit_spmd_command (tree_spmd_command& cmd)
+std::string prefix = command_editor::decode_prompt_string (m_PS4);
-{
-// For now, we just execute the commands serially.
+octave_function *curr_fcn = m_call_stack.current_function ();
-tree_statement_list *body = cmd.body ();
+if (curr_fcn && curr_fcn->is_user_code ())
+{
-if (body)
+octave_user_code *code = dynamic_cast<octave_user_code *> (curr_fcn);
-body->accept (*this);
-}
+int num_lines = line - m_echo_file_pos + 1;
-octave_value
+std::deque<std::string> lines
-tree_evaluator::evaluate_anon_fcn_handle (tree_anon_fcn_handle& afh)
+= code->get_code_lines (m_echo_file_pos, num_lines);
-{
-// FIXME: should CMD_LIST be limited to a single expression?
+for (auto& elt : lines)
-// I think that is what Matlab does.
+octave_stdout << prefix << elt << std::endl;
+}
-symbol_scope new_scope;
+}
-symbol_scope scope = afh.scope ();
-if (scope)
+// Decide if it's time to quit a for or while loop.
-new_scope = scope.dup ();
+bool tree_evaluator::quit_loop_now (void)
+{
-tree_parameter_list *param_list = afh.parameter_list ();
+octave_quit ();
-tree_parameter_list *param_list_dup
-= param_list ? param_list->dup (new_scope) : nullptr;
+// Maybe handle 'continue N' someday...
-tree_parameter_list *ret_list = nullptr;
+if (m_continuing)
+m_continuing--;
-tree_statement_list *stmt_list = nullptr;
+bool quit = (m_returning || m_breaking || m_continuing);
-symbol_scope parent_scope = get_current_scope ();
+if (m_breaking)
-new_scope.set_parent (parent_scope);
+m_breaking--;
-new_scope.set_primary_parent (parent_scope);
+return quit;
-tree_expression *expr = afh.expression ();
+}
-if (expr)
-{
+void tree_evaluator::bind_auto_fcn_vars (const string_vector& arg_names,
-tree_expression *expr_dup = expr->dup (new_scope);
+const Matrix& ignored_outputs,
-tree_statement *stmt = new tree_statement (expr_dup, nullptr);
+int nargin, int nargout,
-stmt_list = new tree_statement_list (stmt);
+bool takes_varargs,
-}
+const octave_value_list& va_args)
+{
-tree_anon_scopes anon_fcn_ctx (afh);
+set_auto_fcn_var (stack_frame::ARG_NAMES, Cell (arg_names));
+set_auto_fcn_var (stack_frame::IGNORED, ignored_outputs);
-std::set<std::string> free_vars = anon_fcn_ctx.free_variables ();
+set_auto_fcn_var (stack_frame::NARGIN, nargin);
+set_auto_fcn_var (stack_frame::NARGOUT, nargout);
-stack_frame::local_vars_map local_vars;
+set_auto_fcn_var (stack_frame::SAVED_WARNING_STATES, octave_value ());
-std::shared_ptr<stack_frame> frame
+if (takes_varargs)
-= m_call_stack.get_current_stack_frame ();
+assign ("varargin", va_args.cell_value ());
+}
-for (auto& name : free_vars)
-{
+std::string
-octave_value val = frame->varval (name);
+tree_evaluator::check_autoload_file (const std::string& nm) const
+{
-if (val.is_defined ())
+if (sys::env::absolute_pathname (nm))
-local_vars[name] = val;
+return nm;
-}
+std::string full_name = nm;
-octave_user_function *af
-= new octave_user_function (new_scope, param_list_dup, ret_list,
+octave_user_code *fcn = m_call_stack.current_user_code ();
-stmt_list);
+bool found = false;
-octave_function *curr_fcn = m_call_stack.current_function ();
+if (fcn)
-bool is_nested = false;
+{
+std::string fname = fcn->fcn_file_name ();
-if (curr_fcn)
-{
+if (! fname.empty ())
-// FIXME: maybe it would be better to just stash curr_fcn
+{
-// instead of individual bits of info about it?
+fname = sys::env::make_absolute (fname);
+fname = fname.substr (0, fname.find_last_of (sys::file_ops::dir_sep_str ()) + 1);
-// An anonymous function defined inside another nested function
-// or parent of a nested function also behaves like a nested
+sys::file_stat fs (fname + nm);
-// function.
+if (fs.exists ())
-if (curr_fcn->is_parent_function () || curr_fcn->is_nested_function ())
-{
-is_nested = true;
-af->mark_as_nested_function ();
-new_scope.set_nesting_depth (parent_scope.nesting_depth () + 1);
-}
-af->stash_dir_name (curr_fcn->dir_name ());
-new_scope.cache_fcn_file_name (curr_fcn->fcn_file_name ());
-new_scope.cache_dir_name (curr_fcn->dir_name ());
-// The following is needed so that class method dispatch works
-// properly for anonymous functions that wrap class methods.
-if (curr_fcn->is_class_method () || curr_fcn->is_class_constructor ())
-af->stash_dispatch_class (curr_fcn->dispatch_class ());
-af->stash_fcn_file_name (curr_fcn->fcn_file_name ());
-}
-af->mark_as_anonymous_function ();
-octave_value ov_fcn (af);
-return (is_nested
-? octave_value (new octave_fcn_handle (ov_fcn, local_vars, frame))
-: octave_value (new octave_fcn_handle (ov_fcn, local_vars)));
-}
-octave_value_list
-tree_evaluator::execute_builtin_function (octave_builtin& builtin_function,
-int nargout,
-const octave_value_list& args)
-{
-octave_value_list retval;
-if (args.has_magic_colon ())
-error ("invalid use of colon in function argument list");
-profiler::enter<octave_builtin> block (m_profiler, builtin_function);
-octave_builtin::fcn fcn = builtin_function.function ();
-if (fcn)
-retval = (*fcn) (args, nargout);
-else
-{
-octave_builtin::meth meth = builtin_function.method ();
-retval = (*meth) (m_interpreter, args, nargout);
-}
-// Do not allow null values to be returned from functions.
-// FIXME: perhaps true builtins should be allowed?
-retval.make_storable_values ();
-// Fix the case of a single undefined value.
-// This happens when a compiled function uses
-//
-//   octave_value retval;
-//
-// instead of
-//
-//   octave_value_list retval;
-//
-// the idiom is very common, so we solve that here.
-if (retval.length () == 1 && retval.xelem (0).is_undefined ())
-retval.clear ();
-return retval;
-}
-octave_value_list
-tree_evaluator::execute_mex_function (octave_mex_function& mex_function,
-int nargout,
-const octave_value_list& args)
-{
-octave_value_list retval;
-if (args.has_magic_colon ())
-error ("invalid use of colon in function argument list");
-profiler::enter<octave_mex_function> block (m_profiler, mex_function);
-retval = call_mex (mex_function, args, nargout);
-return retval;
-}
-octave_value_list
-tree_evaluator::execute_user_script (octave_user_script& user_script,
-int nargout,
-const octave_value_list& args)
-{
-octave_value_list retval;
-std::string file_name = user_script.fcn_file_name ();
-if (args.length () != 0 || nargout != 0)
-error ("invalid call to script %s", file_name.c_str ());
-tree_statement_list *cmd_list = user_script.body ();
-if (! cmd_list)
-return retval;
-// FIXME: Maybe this check belongs in the places where we push a new
-// stack frame?  Or in the call_stack push method itself?
-if (m_call_stack.size () >= static_cast<std::size_t> (m_max_recursion_depth))
-error ("max_recursion_depth exceeded");
-unwind_protect_var<stmt_list_type> upv (m_statement_context, SC_SCRIPT);
-profiler::enter<octave_user_script> block (m_profiler, user_script);
-if (echo ())
-push_echo_state (tree_evaluator::ECHO_SCRIPTS, file_name);
-// FIXME: Should we be using tree_evaluator::eval here?
-cmd_list->accept (*this);
-if (m_returning)
-m_returning = 0;
-if (m_breaking)
-m_breaking--;
-return retval;
-}
-void
-tree_evaluator::visit_octave_user_script (octave_user_script&)
-{
-// ??
-panic_impossible ();
-}
-octave_value_list
-tree_evaluator::execute_user_function (octave_user_function& user_function,
-int nargout,
-const octave_value_list& xargs)
-{
-octave_value_list retval;
-// If this function is a classdef constructor, extract the first input
-// argument, which must be the partially constructed object instance.
-octave_value_list args (xargs);
-octave_value_list ret_args;
-int nargin = args.length ();
-if (user_function.is_classdef_constructor ())
-{
-if (nargin > 0)
-{
-ret_args = args.slice (0, 1, true);
---nargin;
-args = args.slice (1, nargin, true);
-}
-else
-panic_impossible ();
-}
-// FIXME: this probably shouldn't be a double-precision matrix.
-Matrix ignored_outputs = ignored_fcn_outputs ();
-tree_parameter_list *param_list = user_function.parameter_list ();
-bool takes_varargs = false;
-int max_inputs = 0;
-if (param_list)
-{
-takes_varargs = param_list->takes_varargs ();
-max_inputs = param_list->length ();
-}
-if (! takes_varargs && nargin > max_inputs)
-{
-std::string name = user_function.name ();
-if (name.empty ())
-name = "@<anonymous>";
-error_with_id ("Octave:invalid-fun-call",
-"%s: function called with too many inputs",
-name.c_str ());
-}
-define_parameter_list_from_arg_vector (param_list, args);
-tree_parameter_list *ret_list = user_function.return_list ();
-if (ret_list && ! ret_list->takes_varargs ())
-{
-int max_outputs = ret_list->length ();
-if (nargout > max_outputs)
-{
-std::string name = user_function.name ();
-error_with_id ("Octave:invalid-fun-call",
-"%s: function called with too many outputs",
-name.c_str ());
-}
-}
-bind_auto_fcn_vars (xargs.name_tags (), ignored_outputs, nargin,
-nargout, user_function.takes_varargs (),
-user_function.all_va_args (args));
-// For classdef constructor, pre-populate the output arguments
-// with the pre-initialized object instance, extracted above.
-if (user_function.is_classdef_constructor ())
-{
-if (! ret_list)
-error ("%s: invalid classdef constructor, no output argument defined",
-user_function.dispatch_class ().c_str ());
-define_parameter_list_from_arg_vector (ret_list, ret_args);
-}
-// FIXME: Maybe this check belongs in the places where we push a
-// new stack frame?  Or in the call_stack push method itself?
-if (m_call_stack.size () >= static_cast<std::size_t> (m_max_recursion_depth))
-error ("max_recursion_depth exceeded");
-unwind_action act2 ([&user_function] () {
-user_function.restore_warning_states ();
-});
-// Evaluate the commands that make up the function.
-unwind_protect_var<stmt_list_type> upv (m_statement_context, SC_FUNCTION);
-tree_statement_list *cmd_list = user_function.body ();
-if (cmd_list)
-{
-profiler::enter<octave_user_function>
-block (m_profiler, user_function);
-if (echo ())
-push_echo_state (tree_evaluator::ECHO_FUNCTIONS,
-user_function.fcn_file_name ());
-if (user_function.is_special_expr ())
-{
-panic_if (cmd_list->length () != 1);
-tree_statement *stmt = cmd_list->front ();
-tree_expression *expr = stmt->expression ();
-if (expr)
-{
-m_call_stack.set_location (stmt->line (), stmt->column ());
-retval = expr->evaluate_n (*this, nargout);
-}
-}
-else
-cmd_list->accept (*this);
-if (m_returning)
-m_returning = 0;
-if (m_breaking)
-m_breaking--;
-}
-// Copy return values out.
-if (ret_list && ! user_function.is_special_expr ())
-{
-Cell varargout;
-if (ret_list->takes_varargs ())
-{
-octave_value varargout_varval = varval ("varargout");
-if (varargout_varval.is_defined ())
-varargout = varargout_varval.xcell_value ("varargout must be a cell array object");
-}
-retval = convert_return_list_to_const_vector (ret_list, nargout,
-ignored_outputs,
-varargout);
-}
-return retval;
-}
-void
-tree_evaluator::visit_octave_user_function (octave_user_function&)
-{
-// ??
-panic_impossible ();
-}
-void
-tree_evaluator::visit_octave_user_function_header (octave_user_function&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_octave_user_function_trailer (octave_user_function&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_function_def (tree_function_def& cmd)
-{
-octave_value fcn = cmd.function ();
-octave_function *f = fcn.function_value ();
-if (f)
-{
-std::string nm = f->name ();
-symbol_table& symtab = m_interpreter.get_symbol_table ();
-symtab.install_cmdline_function (nm, fcn);
-// Make sure that any variable with the same name as the new
-// function is cleared.
-assign (nm);
-}
-}
-void
-tree_evaluator::visit_identifier (tree_identifier&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_if_clause (tree_if_clause&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_if_command (tree_if_command& cmd)
-{
-if (m_echo_state)
-{
-int line = cmd.line ();
-if (line < 0)
-line = 1;
-echo_code (line);
-m_echo_file_pos = line + 1;
-}
-// FIXME: tree_if_command_list is not derived from tree, so should it
-// really have an accept method?
-tree_if_command_list *lst = cmd.cmd_list ();
-if (lst)
-lst->accept (*this);
-}
-void
-tree_evaluator::visit_if_command_list (tree_if_command_list& lst)
-{
-for (tree_if_clause *tic : lst)
-{
-tree_expression *expr = tic->condition ();
-if (! (in_debug_repl ()
-&& m_call_stack.current_frame () == m_debug_frame))
-m_call_stack.set_location (tic->line (), tic->column ());
-if (m_debug_mode && ! tic->is_else_clause ())
-do_breakpoint (tic->is_active_breakpoint (*this));
-if (tic->is_else_clause () || is_logically_true (expr, "if"))
-{
-tree_statement_list *stmt_lst = tic->commands ();
-if (stmt_lst)
-stmt_lst->accept (*this);
-break;
-}
-}
-}
-void
-tree_evaluator::visit_index_expression (tree_index_expression&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_matrix (tree_matrix&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_cell (tree_cell&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_multi_assignment (tree_multi_assignment&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_no_op_command (tree_no_op_command& cmd)
-{
-if (m_echo_state)
-{
-int line = cmd.line ();
-if (line < 0)
-line = 1;
-echo_code (line);
-m_echo_file_pos = line + 1;
-}
-if (m_debug_mode && cmd.is_end_of_fcn_or_script ())
-do_breakpoint (cmd.is_active_breakpoint (*this), true);
-}
-void
-tree_evaluator::visit_constant (tree_constant&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_fcn_handle (tree_fcn_handle&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_parameter_list (tree_parameter_list&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_postfix_expression (tree_postfix_expression&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_prefix_expression (tree_prefix_expression&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_return_command (tree_return_command& cmd)
-{
-if (m_echo_state)
-{
-int line = cmd.line ();
-if (line < 0)
-line = 1;
-echo_code (line);
-m_echo_file_pos = line + 1;
-}
-if (m_debug_mode)
-do_breakpoint (cmd.is_active_breakpoint (*this));
-// Act like dbcont.
-if (in_debug_repl () && m_call_stack.current_frame () == m_debug_frame)
-dbcont ();
-else if (m_statement_context == SC_FUNCTION
-|| m_statement_context == SC_SCRIPT
-|| m_in_loop_command)
-m_returning = 1;
-}
-void
-tree_evaluator::visit_simple_assignment (tree_simple_assignment&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_statement (tree_statement& stmt)
-{
-tree_command *cmd = stmt.command ();
-tree_expression *expr = stmt.expression ();
-if (cmd || expr)
-{
-if (! (in_debug_repl ()
-&& m_call_stack.current_frame () == m_debug_frame))
-m_call_stack.set_location (stmt.line (), stmt.column ());
-try
-{
-if (cmd)
-{
-unwind_protect_var<const std::list<octave_lvalue> *>
-upv (m_lvalue_list, nullptr);
-cmd->accept (*this);
-}
-else
-{
-if (m_echo_state)
-{
-int line = stmt.line ();
-if (line < 0)
-line = 1;
-echo_code (line);
-m_echo_file_pos = line + 1;
-}
-if (m_debug_mode)
-do_breakpoint (expr->is_active_breakpoint (*this));
-// FIXME: maybe all of this should be packaged in
-// one virtual function that returns a flag saying whether
-// or not the expression will take care of binding ans and
-// printing the result.
-// FIXME: it seems that we should just have to
-// evaluate the expression and that should take care of
-// everything, binding ans as necessary?
-octave_value tmp_result = expr->evaluate (*this, 0);
-if (tmp_result.is_defined ())
-{
-bool do_bind_ans = false;
-if (expr->is_identifier ())
-do_bind_ans = ! is_variable (expr);
-else
-do_bind_ans = ! expr->is_assignment_expression ();
-if (do_bind_ans)
-bind_ans (tmp_result, expr->print_result ()
-&& statement_printing_enabled ());
-}
-}
-}
-catch (const std::bad_alloc&)
-{
-// FIXME: We want to use error_with_id here so that give users
-// control over this error message but error_with_id will
-// require some memory allocations.  Is there anything we can
-// do to make those more likely to succeed?
-error_with_id ("Octave:bad-alloc",
-"out of memory or dimension too large for Octave's index type");
-}
-catch (const interrupt_exception&)
-{
-// If we are debugging, then continue with next statement.
-// Otherwise, jump out of here.
-if (m_debug_mode)
-m_interpreter.recover_from_exception ();
-else
-throw;
-}
-catch (const execution_exception& ee)
-{
-error_system& es = m_interpreter.get_error_system ();
-if ((m_interpreter.interactive ()
-|| application::forced_interactive ())
-&& ((es.debug_on_error ()
-&& m_bp_table.debug_on_err (es.last_error_id ()))
-|| (es.debug_on_caught ()
-&& m_bp_table.debug_on_caught (es.last_error_id ())))
-&& in_user_code ())
-{
-es.save_exception (ee);
-es.display_exception (ee);
-enter_debugger ();
-// It doesn't make sense to continue execution after an
-// error occurs so force the debugger to quit all debug
-// levels and return the the top prompt.
-throw quit_debug_exception (true);
-}
-else
-throw;
-}
-}
-}
-void
-tree_evaluator::visit_statement_list (tree_statement_list& lst)
-{
-// FIXME: commented out along with else clause below.
-// static octave_value_list empty_list;
-auto p = lst.begin ();
-if (p != lst.end ())
-{
-while (true)
-{
-tree_statement *elt = *p++;
-if (! elt)
-error ("invalid statement found in statement list!");
-octave_quit ();
-elt->accept (*this);
-if (m_breaking || m_continuing)
-break;
-if (m_returning)
-break;
-if (p == lst.end ())
-break;
-else
-{
-// Clear previous values before next statement is
-// evaluated so that we aren't holding an extra
-// reference to a value that may be used next.  For
-// example, in code like this:
-//
-//   X = rand (N);  # refcount for X should be 1
-//                  # after this statement
-//
-//   X(idx) = val;  # no extra copy of X should be
-//                  # needed, but we will be faked
-//                  # out if retval is not cleared
-//                  # between statements here
-//              result_values = empty_list;
-}
-}
-}
-}
-void
-tree_evaluator::visit_switch_case (tree_switch_case&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_switch_case_list (tree_switch_case_list&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_switch_command (tree_switch_command& cmd)
-{
-if (m_echo_state)
-{
-int line = cmd.line ();
-if (line < 0)
-line = 1;
-echo_code (line);
-m_echo_file_pos = line + 1;
-}
-if (m_debug_mode)
-do_breakpoint (cmd.is_active_breakpoint (*this));
-tree_expression *expr = cmd.switch_value ();
-if (! expr)
-error ("missing value in switch command near line %d, column %d",
-cmd.line (), cmd.column ());
-octave_value val = expr->evaluate (*this);
-tree_switch_case_list *lst = cmd.case_list ();
-if (lst)
-{
-for (tree_switch_case *t : *lst)
-{
-if (t->is_default_case () || switch_case_label_matches (t, val))
-{
-tree_statement_list *stmt_lst = t->commands ();
-if (stmt_lst)
-stmt_lst->accept (*this);
-break;
-}
-}
-}
-}
-void
-tree_evaluator::visit_try_catch_command (tree_try_catch_command& cmd)
-{
-if (m_echo_state)
-{
-int line = cmd.line ();
-if (line < 0)
-line = 1;
-echo_code (line);
-m_echo_file_pos = line + 1;
-}
-bool execution_error = false;
-octave_scalar_map err_map;
-tree_statement_list *try_code = cmd.body ();
-if (try_code)
-{
-// unwind frame before catch block
-unwind_protect frame;
-interpreter_try (frame);
-// The catch code is *not* added to unwind_protect stack; it
-// doesn't need to be run on interrupts.
-try
-{
-try_code->accept (*this);
-}
-catch (const execution_exception& ee)
-{
-execution_error = true;
-error_system& es = m_interpreter.get_error_system ();
-es.save_exception (ee);
-err_map.assign ("message", es.last_error_message ());
-err_map.assign ("identifier", es.last_error_id ());
-err_map.assign ("stack", es.last_error_stack ());
-m_interpreter.recover_from_exception ();
-}
-// Actions attached to unwind_protect frame will run here, prior
-// to executing the catch block.
-}
-if (execution_error)
-{
-tree_statement_list *catch_code = cmd.cleanup ();
-if (catch_code)
-{
-tree_identifier *expr_id = cmd.identifier ();
-if (expr_id)
-{
-octave_lvalue ult = expr_id->lvalue (*this);
-ult.assign (octave_value::op_asn_eq, err_map);
-}
-// perform actual "catch" block
-catch_code->accept (*this);
-}
-}
-}
-void
-tree_evaluator::do_unwind_protect_cleanup_code (tree_statement_list *list)
-{
-unwind_protect frame;
-frame.protect_var (octave_interrupt_state);
-octave_interrupt_state = 0;
-// We want to preserve the last location info for possible
-// backtracking.
-frame.add (&call_stack::set_line, &m_call_stack,
-m_call_stack.current_line ());
-frame.add (&call_stack::set_column, &m_call_stack,
-m_call_stack.current_column ());
-// Similarly, if we have seen a return or break statement, allow all
-// the cleanup code to run before returning or handling the break.
-// We don't have to worry about continue statements because they can
-// only occur in loops.
-frame.protect_var (m_returning);
-m_returning = 0;
-frame.protect_var (m_breaking);
-m_breaking = 0;
-try
-{
-if (list)
-list->accept (*this);
-}
-catch (const execution_exception& ee)
-{
-error_system& es = m_interpreter.get_error_system ();
-es.save_exception (ee);
-m_interpreter.recover_from_exception ();
-if (m_breaking || m_returning)
-frame.discard (2);
-else
-frame.run (2);
-frame.discard (2);
-throw;
-}
-// The unwind_protects are popped off the stack in the reverse of
-// the order they are pushed on.
-// FIXME: these statements say that if we see a break or
-// return statement in the cleanup block, that we want to use the
-// new value of the breaking or returning flag instead of restoring
-// the previous value.  Is that the right thing to do?  I think so.
-// Consider the case of
-//
-//   function foo ()
-//     unwind_protect
-//       fprintf (stderr, "1: this should always be executed\n");
-//       break;
-//       fprintf (stderr, "1: this should never be executed\n");
-//     unwind_protect_cleanup
-//       fprintf (stderr, "2: this should always be executed\n");
-//       return;
-//       fprintf (stderr, "2: this should never be executed\n");
-//     end_unwind_protect
-//   endfunction
-//
-// If we reset the value of the breaking flag, both the returning
-// flag and the breaking flag will be set, and we shouldn't have
-// both.  So, use the most recent one.  If there is no return or
-// break in the cleanup block, the values should be reset to
-// whatever they were when the cleanup block was entered.
-if (m_breaking || m_returning)
-frame.discard (2);
-else
-frame.run (2);
-}
-void
-tree_evaluator::visit_unwind_protect_command (tree_unwind_protect_command& cmd)
-{
-if (m_echo_state)
-{
-int line = cmd.line ();
-if (line < 0)
-line = 1;
-echo_code (line);
-m_echo_file_pos = line + 1;
-}
-tree_statement_list *cleanup_code = cmd.cleanup ();
-tree_statement_list *unwind_protect_code = cmd.body ();
-if (unwind_protect_code)
-{
-try
-{
-unwind_protect_code->accept (*this);
-}
-catch (const execution_exception& ee)
-{
-error_system& es = m_interpreter.get_error_system ();
-// FIXME: Maybe we should be able to temporarily set the
-// interpreter's exception handling state to something "safe"
-// while the cleanup block runs instead of just resetting it
-// here?
-es.save_exception (ee);
-m_interpreter.recover_from_exception ();
-// Run the cleanup code on exceptions, so that it is run even
-// in case of interrupt or out-of-memory.
-do_unwind_protect_cleanup_code (cleanup_code);
-// If an error occurs inside the cleanup code, a new
-// exception will be thrown instead of the original.
-throw;
-}
-catch (const interrupt_exception&)
-{
-// The comments above apply here as well.
-m_interpreter.recover_from_exception ();
-do_unwind_protect_cleanup_code (cleanup_code);
-throw;
-}
-// Also execute the unwind_protect_cleanump code if the
-// unwind_protect block runs without error.
-do_unwind_protect_cleanup_code (cleanup_code);
-}
-}
-void
-tree_evaluator::visit_while_command (tree_while_command& cmd)
-{
-int line = cmd.line ();
-if (line < 0)
-line = 1;
-if (m_echo_state)
-{
-echo_code (line);
-line++;
-}
-unwind_protect_var<bool> upv (m_in_loop_command, true);
-tree_expression *expr = cmd.condition ();
-if (! expr)
-panic_impossible ();
-for (;;)
-{
-if (m_echo_state)
-m_echo_file_pos = line;
-if (m_debug_mode)
-do_breakpoint (cmd.is_active_breakpoint (*this));
-if (is_logically_true (expr, "while"))
-{
-tree_statement_list *loop_body = cmd.body ();
-if (loop_body)
-loop_body->accept (*this);
-if (quit_loop_now ())
-break;
-}
-else
-break;
-}
-}
-void
-tree_evaluator::visit_do_until_command (tree_do_until_command& cmd)
-{
-int line = cmd.line ();
-if (line < 0)
-line = 1;
-if (m_echo_state)
-{
-echo_code (line);
-line++;
-}
-unwind_protect_var<bool> upv (m_in_loop_command, true);
-tree_expression *expr = cmd.condition ();
-if (! expr)
-panic_impossible ();
-for (;;)
-{
-if (m_echo_state)
-m_echo_file_pos = line;
-tree_statement_list *loop_body = cmd.body ();
-if (loop_body)
-loop_body->accept (*this);
-if (quit_loop_now ())
-break;
-if (m_debug_mode)
-do_breakpoint (cmd.is_active_breakpoint (*this));
-if (is_logically_true (expr, "do-until"))
-break;
-}
-}
-void
-tree_evaluator::visit_superclass_ref (tree_superclass_ref&)
-{
-panic_impossible ();
-}
-void
-tree_evaluator::visit_metaclass_query (tree_metaclass_query&)
-{
-panic_impossible ();
-}
-void tree_evaluator::bind_ans (const octave_value& val, bool print)
-{
-static std::string ans = "ans";
-if (val.is_defined ())
-{
-if (val.is_cs_list ())
-{
-octave_value_list lst = val.list_value ();
-for (octave_idx_type i = 0; i < lst.length (); i++)
-bind_ans (lst(i), print);
-}
-else
-{
-// FIXME: Maybe assign could also return the assigned value,
-// just for convenience?
-assign (ans, val);
-if (print)
-{
-// Use varval instead of displaying VAL directly so that
-// we get the right type and value for things like
-// magic_int values that may mutate when stored.
-octave_value_list args = ovl (varval (ans));
-args.stash_name_tags (string_vector (ans));
-feval ("display", args);
-}
-}
-}
-}
-void
-tree_evaluator::do_breakpoint (tree_statement& stmt)
-{
-do_breakpoint (stmt.is_active_breakpoint (*this),
-stmt.is_end_of_fcn_or_script ());
-}
-void
-tree_evaluator::do_breakpoint (bool is_breakpoint,
-bool is_end_of_fcn_or_script)
-{
-bool break_on_this_statement = false;
-if (is_breakpoint)
-break_on_this_statement = true;
-else if (m_dbstep_flag > 0)
-{
-if (m_call_stack.current_frame () == m_debug_frame)
-{
-if (m_dbstep_flag == 1 || is_end_of_fcn_or_script)
-{
-// We get here if we are doing a "dbstep" or a "dbstep N" and
-// the count has reached 1 so that we must stop and return to
-// debug prompt.  Alternatively, "dbstep N" has been used but
-// the end of the frame has been reached so we stop at the last
-// line and return to prompt.
-break_on_this_statement = true;
-}
-else
-{
-// Executing "dbstep N".  Decrease N by one and continue.
-m_dbstep_flag--;
-}
-}
-else if (m_dbstep_flag == 1
-&& m_call_stack.current_frame () < m_debug_frame)
-{
-// We stepped out from the end of a function.
-m_debug_frame = m_call_stack.current_frame ();
-break_on_this_statement = true;
-}
-}
-else if (m_dbstep_flag == -1)
-{
-// We get here if we are doing a "dbstep in".
-break_on_this_statement = true;
-m_debug_frame = m_call_stack.current_frame ();
-}
-else if (m_dbstep_flag == -2)
-{
-// We get here if we are doing a "dbstep out".  Check for end of
-// function and whether the current frame is the same as the
-// cached value because we want to step out from the frame where
-// "dbstep out" was evaluated, not from any functions called from
-// that frame.
-if (is_end_of_fcn_or_script
-&& m_call_stack.current_frame () == m_debug_frame)
-m_dbstep_flag = -1;
-}
-if (! break_on_this_statement)
-break_on_this_statement = m_break_on_next_stmt;
-m_break_on_next_stmt = false;
-if (break_on_this_statement)
-{
-m_dbstep_flag = 0;
-enter_debugger ();
-}
-}
-bool
-tree_evaluator::is_logically_true (tree_expression *expr,
-const char *warn_for)
-{
-bool expr_value = false;
-m_call_stack.set_location (expr->line (), expr->column ());
-octave_value t1 = expr->evaluate (*this);
-if (t1.is_defined ())
-return t1.is_true ();
-else
-error ("%s: undefined value used in conditional expression", warn_for);
-return expr_value;
-}
-octave_value
-tree_evaluator::max_recursion_depth (const octave_value_list& args,
-int nargout)
-{
-return set_internal_variable (m_max_recursion_depth, args, nargout,
-"max_recursion_depth", 0);
-}
-symbol_info_list
-tree_evaluator::glob_symbol_info (const std::string& pattern) const
-{
-return m_call_stack.glob_symbol_info (pattern);
-}
-symbol_info_list
-tree_evaluator::regexp_symbol_info (const std::string& pattern) const
-{
-return m_call_stack.regexp_symbol_info (pattern);
-}
-symbol_info_list
-tree_evaluator::get_symbol_info (void)
-{
-return m_call_stack.get_symbol_info ();
-}
-symbol_info_list
-tree_evaluator::top_scope_symbol_info (void) const
-{
-return m_call_stack.top_scope_symbol_info ();
-}
-octave_map tree_evaluator::get_autoload_map (void) const
-{
-Cell fcn_names (dim_vector (m_autoload_map.size (), 1));
-Cell file_names (dim_vector (m_autoload_map.size (), 1));
-octave_idx_type i = 0;
-for (const auto& fcn_fname : m_autoload_map)
-{
-fcn_names(i) = fcn_fname.first;
-file_names(i) = fcn_fname.second;
-i++;
-}
-octave_map m;
-m.assign ("function", fcn_names);
-m.assign ("file", file_names);
-return m;
-}
-std::string tree_evaluator::lookup_autoload (const std::string& nm) const
-{
-std::string retval;
-auto p = m_autoload_map.find (nm);
-if (p != m_autoload_map.end ())
-{
-load_path& lp = m_interpreter.get_load_path ();
-retval = lp.find_file (p->second);
-}
-return retval;
-}
-std::list<std::string> tree_evaluator::autoloaded_functions (void) const
-{
-std::list<std::string> names;
-for (const auto& fcn_fname : m_autoload_map)
-names.push_back (fcn_fname.first);
-return names;
-}
-std::list<std::string>
-tree_evaluator::reverse_lookup_autoload (const std::string& nm) const
-{
-std::list<std::string> names;
-for (const auto& fcn_fname : m_autoload_map)
-if (nm == fcn_fname.second)
-names.push_back (fcn_fname.first);
-return names;
-}
-void tree_evaluator::add_autoload (const std::string& fcn,
-const std::string& nm)
-{
-std::string file_name = check_autoload_file (nm);
-m_autoload_map[fcn] = file_name;
-}
-void tree_evaluator::remove_autoload (const std::string& fcn,
-const std::string& nm)
-{
-check_autoload_file (nm);
-// Remove function from symbol table and autoload map.
-symbol_table& symtab = m_interpreter.get_symbol_table ();
-symtab.clear_dld_function (fcn);
-m_autoload_map.erase (fcn);
-}
-octave_value
-tree_evaluator::whos_line_format (const octave_value_list& args, int nargout)
-{
-return set_internal_variable (m_whos_line_format, args, nargout,
-"whos_line_format");
-}
-octave_value
-tree_evaluator::silent_functions (const octave_value_list& args, int nargout)
-{
-return set_internal_variable (m_silent_functions, args, nargout,
-"silent_functions");
-}
-octave_value
-tree_evaluator::string_fill_char (const octave_value_list& args, int nargout)
-{
-return set_internal_variable (m_string_fill_char, args, nargout,
-"string_fill_char");
-}
-// Final step of processing an indexing error.  Add the name of the
-// variable being indexed, if any, then issue an error.  (Will this also
-// be needed by pt-lvalue, which calls subsref?)
-void tree_evaluator::final_index_error (index_exception& ie,
-const tree_expression *expr)
-{
-std::string extra_message;
-if (is_variable (expr))
-{
-std::string var = expr->name ();
-ie.set_var (var);
-symbol_table& symtab = m_interpreter.get_symbol_table ();
-octave_value fcn = symtab.find_function (var);
-if (fcn.is_function ())
-{
-octave_function *fp = fcn.function_value ();
-if (fp && fp->name () == var)
-extra_message
-= " (note: variable '" + var + "' shadows function)";
-}
-}
-std::string msg = ie.message () + extra_message;
-error_with_id (ie.err_id (), "%s", msg.c_str ());
-}
-octave_value
-tree_evaluator::do_who (int argc, const string_vector& argv,
-bool return_list, bool verbose)
-{
-return m_call_stack.do_who (argc, argv, return_list, verbose);
-}
-octave_value_list
-tree_evaluator::make_value_list (tree_argument_list *args,
-const string_vector& arg_nm)
-{
-octave_value_list retval;
-if (args)
-{
-unwind_protect_var<const std::list<octave_lvalue> *>
-upv (m_lvalue_list, nullptr);
-int len = args->length ();
-unwind_protect_var<int> upv2 (m_index_position);
-unwind_protect_var<int> upv3 (m_num_indices);
-m_num_indices = len;
-std::list<octave_value> arg_vals;
-int k = 0;
-for (auto elt : *args)
-{
-// FIXME: is it possible for elt to be invalid?
-if (! elt)
-break;
-m_index_position = k++;
-octave_value tmp = elt->evaluate (*this);
-if (tmp.is_cs_list ())
-{
-octave_value_list tmp_ovl = tmp.list_value ();
-for (octave_idx_type i = 0; i < tmp_ovl.length (); i++)
-arg_vals.push_back (tmp_ovl(i));
-}
-else if (tmp.is_defined ())
-arg_vals.push_back (tmp);
-}
-retval = octave_value_list (arg_vals);
-}
-octave_idx_type n = retval.length ();
-if (n > 0)
-retval.stash_name_tags (arg_nm);
-return retval;
-}
-std::list<octave_lvalue>
-tree_evaluator::make_lvalue_list (tree_argument_list *lhs)
-{
-std::list<octave_lvalue> retval;
-for (tree_expression *elt : *lhs)
-retval.push_back (elt->lvalue (*this));
-return retval;
-}
-void
-tree_evaluator::push_echo_state (int type, const std::string& file_name,
-int pos)
-{
-unwind_protect *frame = m_call_stack.curr_fcn_unwind_protect_frame ();
-if (frame)
-{
-push_echo_state_cleanup (*frame);
-set_echo_state (type, file_name, pos);
-}
-}
-void
-tree_evaluator::set_echo_state (int type, const std::string& file_name,
-int pos)
-{
-m_echo_state = echo_this_file (file_name, type);
-m_echo_file_name = file_name;
-m_echo_file_pos = pos;
-}
-void
-tree_evaluator::uwp_set_echo_state (bool state, const std::string& file_name,
-int pos)
-{
-m_echo_state = state;
-m_echo_file_name = file_name;
-m_echo_file_pos = pos;
-}
-void
-tree_evaluator::maybe_set_echo_state (void)
-{
-octave_function *caller = caller_function ();
-if (caller && caller->is_user_code ())
-{
-octave_user_code *fcn = dynamic_cast<octave_user_code *> (caller);
-int type = fcn->is_user_function () ? ECHO_FUNCTIONS : ECHO_SCRIPTS;
-std::string file_name = fcn->fcn_file_name ();
-// We want the line where "echo" was called, not the line number
-// stored in the stack frame that was created for the echo
-// function (that will always be -1).
-int pos = m_call_stack.current_user_code_line ();
-if (pos < 0)
-pos = 1;
-set_echo_state (type, file_name, pos);
-}
-}
-void
-tree_evaluator::push_echo_state_cleanup (unwind_protect& frame)
-{
-frame.add (&tree_evaluator::uwp_set_echo_state, this,
-m_echo_state, m_echo_file_name, m_echo_file_pos);
-}
-bool tree_evaluator::maybe_push_echo_state_cleanup (void)
-{
-// This function is expected to be called from ECHO, which would be
-// the top of the call stack.  If the caller of ECHO is a
-// user-defined function or script, then set up unwind-protect
-// elements to restore echo state.
-unwind_protect *frame = m_call_stack.curr_fcn_unwind_protect_frame ();
-if (frame)
-{
-push_echo_state_cleanup (*frame);
-return true;
-}
-return false;
-}
-octave_value
-tree_evaluator::echo (const octave_value_list& args, int)
-{
-bool cleanup_pushed = maybe_push_echo_state_cleanup ();
-string_vector argv = args.make_argv ();
-switch (args.length ())
-{
-case 0:
-if ((m_echo & ECHO_SCRIPTS) || (m_echo & ECHO_FUNCTIONS))
-{
-m_echo = ECHO_OFF;
-m_echo_files.clear ();
-}
-else
-m_echo = ECHO_SCRIPTS;
-break;
-case 1:
-{
-std::string arg0 = argv[0];
-if (arg0 == "on")
-m_echo = ECHO_SCRIPTS;
-else if (arg0 == "off")
-m_echo = ECHO_OFF;
-else
 {
-std::string file = fcn_file_in_path (arg0);
+full_name = fname + nm;
-file = sys::env::make_absolute (file);
+found = true;
-if (file.empty ())
-error ("echo: no such file %s", arg0.c_str ());
-if (m_echo & ECHO_ALL)
-{
-// Echo is enabled for all functions, so turn it off
-// for this one.
-m_echo_files[file] = false;
-}
-else
-{
-// Echo may be enabled for specific functions.
-auto p = m_echo_files.find (file);
-if (p == m_echo_files.end ())
-{
-// Not this one, so enable it.
-m_echo |= ECHO_FUNCTIONS;
-m_echo_files[file] = true;
-}
-else
-{
-// This one is already in the list.  Flip the
-// status for it.
-p->second = ! p->second;
-}
-}
 }
 }
-break;
+}
-case 2:
+if (! found)
-{
+warning_with_id ("Octave:autoload-relative-file-name",
-std::string arg0 = argv[0];
+"autoload: '%s' is not an absolute filename",
-std::string arg1 = argv[1];
+nm.c_str ());
-if (arg1 == "on" || arg1 == "off")
+return full_name;
-std::swap (arg0, arg1);
+}
-if (arg0 == "on")
-{
-if (arg1 == "all")
-{
-m_echo = (ECHO_SCRIPTS | ECHO_FUNCTIONS | ECHO_ALL);
-m_echo_files.clear ();
-}
-else
-{
-std::string file = fcn_file_in_path (arg1);
-file = sys::env::make_absolute (file);
-if (file.empty ())
-error ("echo: no such file %s", arg1.c_str ());
-m_echo |= ECHO_FUNCTIONS;
-m_echo_files[file] = true;
-}
-}
-else if (arg0 == "off")
-{
-if (arg1 == "all")
-{
-m_echo = ECHO_OFF;
-m_echo_files.clear ();
-}
-else
-{
-std::string file = fcn_file_in_path (arg1);
-file = sys::env::make_absolute (file);
-if (file.empty ())
-error ("echo: no such file %s", arg1.c_str ());
-m_echo_files[file] = false;
-}
-}
-else
-print_usage ();
-}
-break;
-default:
-print_usage ();
-break;
-}
-if (cleanup_pushed)
-maybe_set_echo_state ();
-return octave_value ();
-}
-bool tree_evaluator::in_debug_repl (void) const
-{
-return (m_debugger_stack.empty ()
-? false : m_debugger_stack.top()->in_debug_repl ());
-}
-void tree_evaluator::dbcont (void)
-{
-if (! m_debugger_stack.empty ())
-m_debugger_stack.top()->dbcont ();
-}
-void tree_evaluator::dbquit (bool all)
-{
-if (! m_debugger_stack.empty ())
-m_debugger_stack.top()->dbquit (all);
-}
-static octave_value end_value (const octave_value& value,
-octave_idx_type index_position,
-octave_idx_type num_indices)
-{
-dim_vector dv = value.dims ();
-int ndims = dv.ndims ();
-if (num_indices < ndims)
-{
-for (int i = num_indices; i < ndims; i++)
-dv(num_indices-1) *= dv(i);
-if (num_indices == 1)
-{
-ndims = 2;
-dv.resize (ndims);
-dv(1) = 1;
-}
-else
-{
-ndims = num_indices;
-dv.resize (ndims);
-}
-}
-return (index_position < ndims
-? octave_value (dv(index_position)) : octave_value (1.0));
-}
-octave_value_list
-tree_evaluator::evaluate_end_expression (const octave_value_list& args)
-{
-int nargin = args.length ();
-if (nargin != 0 && nargin != 3)
-print_usage ();
-if (nargin == 3)
-{
-octave_idx_type index_position
-= args(1).xidx_type_value ("end: K must be integer value");
-if (index_position < 1)
-error ("end: K must be greater than zero");
-octave_idx_type num_indices
-= args(2).xidx_type_value ("end: N must be integer value");
-if (num_indices < 1)
-error ("end: N must be greater than zero");
-return end_value (args(0), index_position-1, num_indices);
-}
-// If m_indexed_object is undefined, then this use of 'end' is
-// either appearing in a function call argument list or in an
-// attempt to index an undefined symbol.  There seems to be no
-// reasonable way to provide a better error message.  So just fail
-// with an invalid use message.  See bug #58830.
-if (m_indexed_object.is_undefined ())
-error ("invalid use of 'end': may only be used to index existing value");
-octave_value expr_result;
-if (m_index_list.empty ())
-expr_result = m_indexed_object;
-else
-{
-try
-{
-// When evaluating "end" with no arguments, we should have
-// been called from the built-in Fend function that appears
-// in the context of an argument list.  Fend will be
-// evaluated in its own stack frame.  But we need to
-// evaluate the partial expression that the special "end"
-// token applies to in the calling stack frame.
-unwind_action act ([=] (std::size_t frm)
-{
-m_call_stack.restore_frame (frm);
-}, m_call_stack.current_frame ());
-std::size_t n = m_call_stack.find_current_user_frame ();
-m_call_stack.goto_frame (n);
-// End is only valid inside argument lists used for
-// indexing.  The dispatch class is set by the function that
-// evaluates the argument list.
-// Silently ignore extra output values.
-octave_value_list tmp
-= m_indexed_object.subsref (m_index_type, m_index_list, 1);
-expr_result = tmp.length () ? tmp(0) : octave_value ();
-if (expr_result.is_cs_list ())
-err_indexed_cs_list ();
-}
-catch (const index_exception&)
-{
-error ("error evaluating partial expression for END");
-}
-}
-if (expr_result.isobject ())
-{
-// FIXME: is there a better way to lookup and execute a method
-// that handles all the details like setting the dispatch class
-// appropriately?
-std::string dispatch_class = expr_result.class_name ();
-symbol_table& symtab = m_interpreter.get_symbol_table ();
-octave_value meth = symtab.find_method ("end", dispatch_class);
-if (meth.is_defined ())
-return m_interpreter.feval
-(meth, ovl (expr_result, m_index_position+1, m_num_indices), 1);
-}
-return end_value (expr_result, m_index_position, m_num_indices);
-}
-octave_value
-tree_evaluator::PS4 (const octave_value_list& args, int nargout)
-{
-return set_internal_variable (m_PS4, args, nargout, "PS4");
-}
-bool tree_evaluator::echo_this_file (const std::string& file, int type) const
-{
-if ((type & m_echo) == ECHO_SCRIPTS)
-{
-// Asking about scripts and echo is enabled for them.
-return true;
-}
-if ((type & m_echo) == ECHO_FUNCTIONS)
-{
-// Asking about functions and echo is enabled for functions.
-// Now, which ones?
-auto p = m_echo_files.find (file);
-if (m_echo & ECHO_ALL)
-{
-// Return true ulness echo was turned off for a specific
-// file.
-return (p == m_echo_files.end () || p->second);
-}
-else
-{
-// Return true if echo is specifically enabled for this file.
-return p != m_echo_files.end () && p->second;
-}
-}
-return false;
-}
-void tree_evaluator::echo_code (int line)
-{
-std::string prefix = command_editor::decode_prompt_string (m_PS4);
-octave_function *curr_fcn = m_call_stack.current_function ();
-if (curr_fcn && curr_fcn->is_user_code ())
-{
-octave_user_code *code = dynamic_cast<octave_user_code *> (curr_fcn);
-int num_lines = line - m_echo_file_pos + 1;
-std::deque<std::string> lines
-= code->get_code_lines (m_echo_file_pos, num_lines);
-for (auto& elt : lines)
-octave_stdout << prefix << elt << std::endl;
-}
-}
-// Decide if it's time to quit a for or while loop.
-bool tree_evaluator::quit_loop_now (void)
-{
-octave_quit ();
-// Maybe handle 'continue N' someday...
-if (m_continuing)
-m_continuing--;
-bool quit = (m_returning || m_breaking || m_continuing);
-if (m_breaking)
-m_breaking--;
-return quit;
-}
-void tree_evaluator::bind_auto_fcn_vars (const string_vector& arg_names,
-const Matrix& ignored_outputs,
-int nargin, int nargout,
-bool takes_varargs,
-const octave_value_list& va_args)
-{
-set_auto_fcn_var (stack_frame::ARG_NAMES, Cell (arg_names));
-set_auto_fcn_var (stack_frame::IGNORED, ignored_outputs);
-set_auto_fcn_var (stack_frame::NARGIN, nargin);
-set_auto_fcn_var (stack_frame::NARGOUT, nargout);
-set_auto_fcn_var (stack_frame::SAVED_WARNING_STATES, octave_value ());
-if (takes_varargs)
-assign ("varargin", va_args.cell_value ());
-}
-std::string
-tree_evaluator::check_autoload_file (const std::string& nm) const
-{
-if (sys::env::absolute_pathname (nm))
-return nm;
-std::string full_name = nm;
-octave_user_code *fcn = m_call_stack.current_user_code ();
-bool found = false;
-if (fcn)
-{
-std::string fname = fcn->fcn_file_name ();
-if (! fname.empty ())
-{
-fname = sys::env::make_absolute (fname);
-fname = fname.substr (0, fname.find_last_of (sys::file_ops::dir_sep_str ()) + 1);
-sys::file_stat fs (fname + nm);
-if (fs.exists ())
-{
-full_name = fname + nm;
-found = true;
-}
-}
-}
-if (! found)
-warning_with_id ("Octave:autoload-relative-file-name",
-"autoload: '%s' is not an absolute filename",
-nm.c_str ());
-return full_name;
-}
 DEFMETHOD (max_recursion_depth, interp, args, nargout,
 doc: /* -*- texinfo -*-
 @deftypefn  {} {@var{val} =} max_recursion_depth ()
 @deftypefnx {} {@var{old_val} =} max_recursion_depth (@var{new_val})

Mercurial > octave

comparison libinterp/parse-tree/pt-eval.cc @ 31607:aac27ad79be6 stable