octave: libinterp/corefcn/interpreter.cc comparison

comparison libinterp/corefcn/interpreter.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	d9970470108a

comparison

equal deleted inserted replaced

-:e88a07dec498
+:aac27ad79be6
 print_usage ();
 std::string arg = args(0).xstring_value ("atexit: FCN argument must be a string");
 bool add_mode = (nargin == 2)
 ? args(1).xbool_value ("atexit: FLAG argument must be a logical value")
 : true;
 octave_value_list retval;
 if (add_mode)
 interp.add_atexit_fcn (arg);
 @end deftypefn */)
 {
 return ovl (interp.traditional ());
 }
 temporary_file_list::~temporary_file_list (void)
+{
+cleanup ();
+}
+void temporary_file_list::insert (const std::string& file)
+{
+m_files.insert (file);
+}
+void temporary_file_list::cleanup (void)
+{
+while (! m_files.empty ())
+{
+auto it = m_files.begin ();
+octave_unlink_wrapper (it->c_str ());
+m_files.erase (it);
+}
+}
+// The time we last time we changed directories.
+sys::time Vlast_chdir_time = 0.0;
+// Execute commands from a file and catch potential exceptions in a consistent
+// way.  This function should be called anywhere we might parse and execute
+// commands from a file before we have entered the main loop in
+// toplev.cc.
+static int safe_source_file (const std::string& file_name,
+const std::string& context = "",
+bool verbose = false,
+bool require_file = true)
+{
+interpreter& interp = __get_interpreter__ ();
+try
+{
+source_file (file_name, context, verbose, require_file);
+}
+catch (const interrupt_exception&)
+{
+interp.recover_from_exception ();
+return 1;
+}
+catch (const execution_exception& ee)
+{
+interp.handle_exception (ee);
+return 1;
+}
+return 0;
+}
+static void initialize_version_info (void)
+{
+octave_value_list args;
+args(3) = OCTAVE_RELEASE_DATE;
+args(2) = config::release ();
+args(1) = OCTAVE_VERSION;
+args(0) = "GNU Octave";
+F__version_info__ (args, 0);
+}
+static void xerbla_abort (void)
+{
+error ("Fortran procedure terminated by call to XERBLA");
+}
+static void initialize_xerbla_error_handler (void)
+{
+// The idea here is to force xerbla to be referenced so that we will
+// link to our own version instead of the one provided by the BLAS
+// library.  But numeric_limits<double>::NaN () should never be -1, so
+// we should never actually call xerbla.  FIXME (again!): If this
+// becomes a constant expression the test might be optimized away and
+// then the reference to the function might also disappear.
+if (numeric_limits<double>::NaN () == -1)
+F77_FUNC (xerbla, XERBLA) ("octave", 13 F77_CHAR_ARG_LEN (6));
+typedef void (*xerbla_handler_ptr) (void);
+typedef void (*octave_set_xerbla_handler_ptr) (xerbla_handler_ptr);
+dynamic_library libs ("");
+if (libs)
+{
+octave_set_xerbla_handler_ptr octave_set_xerbla_handler
+= reinterpret_cast<octave_set_xerbla_handler_ptr>
+(libs.search ("octave_set_xerbla_handler"));
+if (octave_set_xerbla_handler)
+octave_set_xerbla_handler (xerbla_abort);
+}
+}
+OCTAVE_NORETURN static void
+lo_error_handler (const char *fmt, ...)
+{
+va_list args;
+va_start (args, fmt);
+verror_with_cfn (fmt, args);
+va_end (args);
+throw execution_exception ();
+}
+OCTAVE_NORETURN static void
+lo_error_with_id_handler (const char *id, const char *fmt, ...)
+{
+va_list args;
+va_start (args, fmt);
+verror_with_id_cfn (id, fmt, args);
+va_end (args);
+throw execution_exception ();
+}
+static void initialize_error_handlers (void)
+{
+set_liboctave_error_handler (lo_error_handler);
+set_liboctave_error_with_id_handler (lo_error_with_id_handler);
+set_liboctave_warning_handler (warning);
+set_liboctave_warning_with_id_handler (warning_with_id);
+}
+// Create an interpreter object and perform initialization up to the
+// point of setting reading command history and setting the load
+// path.
+interpreter::interpreter (application *app_context)
+: m_app_context (app_context),
+m_tmp_files (),
+m_atexit_fcns (),
+m_display_info (),
+m_environment (),
+m_settings (),
+m_error_system (*this),
+m_evaluator (*this),
+m_help_system (*this),
+m_input_system (*this),
+m_output_system (*this),
+m_history_system (*this),
+m_dynamic_loader (*this),
+m_load_path (*this),
+m_load_save_system (*this),
+m_type_info (),
+m_symbol_table (*this),
+m_stream_list (*this),
+m_child_list (),
+m_url_handle_manager (),
+m_cdef_manager (*this),
+m_gtk_manager (),
+m_event_manager (*this),
+m_gh_manager (nullptr),
+m_interactive (false),
+m_read_site_files (true),
+m_read_init_files (m_app_context != nullptr),
+m_verbose (false),
+m_traditional (false),
+m_inhibit_startup_message (false),
+m_load_path_initialized (false),
+m_history_initialized (false),
+m_interrupt_all_in_process_group (true),
+m_cancel_quit (false),
+m_executing_finish_script (false),
+m_executing_atexit (false),
+m_initialized (false)
+{
+// FIXME: When thread_local storage is used by default, this message
+// should change to say something like
+//
+//   only one Octave interpreter may be active in any given thread
+if (m_instance)
+throw std::runtime_error
+("only one Octave interpreter may be active");
+m_instance = this;
+#if defined (OCTAVE_HAVE_WINDOWS_UTF8_LOCALE)
+// Force a UTF-8 locale on Windows if possible
+std::setlocale (LC_ALL, ".UTF8");
+#else
+std::setlocale (LC_ALL, "");
+#endif
+// Matlab uses "C" locale for LC_NUMERIC class regardless of local setting
+std::setlocale (LC_NUMERIC, "C");
+std::setlocale (LC_TIME, "C");
+sys::env::putenv ("LC_NUMERIC", "C");
+sys::env::putenv ("LC_TIME", "C");
+// Initialize the default floating point unit control state.
+octave_set_default_fpucw ();
+thread::init ();
+octave_ieee_init ();
+initialize_xerbla_error_handler ();
+initialize_error_handlers ();
+if (m_app_context)
+{
+install_signal_handlers ();
+octave_unblock_signal_by_name ("SIGTSTP");
+}
+else
+quit_allowed = false;
+if (! m_app_context)
+m_display_info.initialize ();
+bool line_editing = false;
+if (m_app_context)
+{
+// Embedded interpreters don't execute command line options.
+const cmdline_options& options = m_app_context->options ();
+// Make all command-line arguments available to startup files,
+// including PKG_ADD files.
+string_vector args = options.all_args ();
+m_app_context->intern_argv (args);
+intern_nargin (args.numel () - 1);
+bool is_octave_program = m_app_context->is_octave_program ();
+std::list<std::string> command_line_path = options.command_line_path ();
+for (const auto& pth : command_line_path)
+m_load_path.set_command_line_path (pth);
+std::string exec_path = options.exec_path ();
+if (! exec_path.empty ())
+m_environment.exec_path (exec_path);
+std::string image_path = options.image_path ();
+if (! image_path.empty ())
+m_environment.image_path (image_path);
+if (! options.no_window_system ())
+m_display_info.initialize ();
+// Is input coming from a terminal?  If so, we are probably
+// interactive.
+// If stdin is not a tty, then we are reading commands from a
+// pipe or a redirected file.
+bool stdin_is_tty = octave_isatty_wrapper (fileno (stdin));
+m_interactive = (! is_octave_program && stdin_is_tty
+&& octave_isatty_wrapper (fileno (stdout)));
+// Don't force interactive if we're already interactive (bug #60696).
+bool forced_interactive = options.forced_interactive ();
+if (m_interactive)
+{
+m_app_context->forced_interactive (false);
+forced_interactive = false;
+}
+// Check if the user forced an interactive session.
+if (forced_interactive)
+m_interactive = true;
+line_editing = options.line_editing ();
+if ((! m_interactive || forced_interactive)
+&& ! options.forced_line_editing ())
+line_editing = false;
+m_traditional = options.traditional ();
+// FIXME: if possible, perform the following actions directly
+// instead of using the interpreter-level functions.
+if (options.echo_commands ())
+m_evaluator.echo
+(tree_evaluator::ECHO_SCRIPTS | tree_evaluator::ECHO_FUNCTIONS
+| tree_evaluator::ECHO_ALL);
+std::string docstrings_file = options.docstrings_file ();
+if (! docstrings_file.empty ())
+Fbuilt_in_docstrings_file (*this, octave_value (docstrings_file));
+std::string doc_cache_file = options.doc_cache_file ();
+if (! doc_cache_file.empty ())
+Fdoc_cache_file (*this, octave_value (doc_cache_file));
+std::string info_file = options.info_file ();
+if (! info_file.empty ())
+Finfo_file (*this, octave_value (info_file));
+std::string info_program = options.info_program ();
+if (! info_program.empty ())
+Finfo_program (*this, octave_value (info_program));
+std::string texi_macros_file = options.texi_macros_file ();
+if (! texi_macros_file.empty ())
+Ftexi_macros_file (*this, octave_value (texi_macros_file));
+}
+// FIXME: we defer creation of the gh_manager object because it
+// creates a root_figure object that requires the display_info
+// object, but that is currently only accessible through the global
+// interpreter object and that is not available until after the
+// interpreter::instance pointer is set (above).  It would be better
+// if m_gh_manager could be an object value instead of a pointer and
+// created as part of the interpreter initialization.  To do that,
+// we should either make the display_info object independent of the
+// interpreter object (does it really need to cache any
+// information?) or defer creation of the root_figure object until
+// it is actually needed.
+m_gh_manager = new gh_manager (*this);
+m_input_system.initialize (line_editing);
+// These can come after command line args since none of them set any
+// defaults that might be changed by command line options.
+initialize_version_info ();
+// This should be done before initializing the load path because
+// some PKG_ADD files might need --traditional behavior.
+if (m_traditional)
+maximum_braindamage ();
+octave_interpreter_ready = true;
+}
+OCTAVE_THREAD_LOCAL interpreter *interpreter::m_instance = nullptr;
+interpreter::~interpreter (void)
+{
+if (! m_app_context)
+shutdown ();
+delete m_gh_manager;
+}
+void interpreter::intern_nargin (octave_idx_type nargs)
+{
+m_evaluator.set_auto_fcn_var (stack_frame::NARGIN, nargs);
+}
+// Read the history file unless a command-line option inhibits that.
+void interpreter::initialize_history (bool read_history_file)
+{
+if (! m_history_initialized)
+{
+// Allow command-line option to override.
+if (m_app_context)
+{
+const cmdline_options& options = m_app_context->options ();
+read_history_file = options.read_history_file ();
+if (! read_history_file)
+command_history::ignore_entries ();
+}
+m_history_system.initialize (read_history_file);
+if (! m_app_context)
+command_history::ignore_entries ();
+m_history_initialized = true;
+}
+}
+// Set the initial path to the system default unless command-line
+// option says to leave it empty.
+void interpreter::initialize_load_path (bool set_initial_path)
+{
+if (! m_load_path_initialized)
+{
+// Allow command-line option to override.
+if (m_app_context)
+{
+const cmdline_options& options = m_app_context->options ();
+set_initial_path = options.set_initial_path ();
+}
+// Temporarily set the execute_pkg_add function to one that
+// catches exceptions.  This is better than wrapping
+// load_path::initialize in a try-catch block because it will
+// not stop executing PKG_ADD files at the first exception.
+// It's also better than changing the default execute_pkg_add
+// function to use safe_source file because that will normally
+// be evaluated from the normal interpreter loop where exceptions
+// are already handled.
+unwind_action restore_add_hook (&load_path::set_add_hook, &m_load_path,
+m_load_path.get_add_hook ());
+m_load_path.set_add_hook ([=] (const std::string& dir)
+{ this->execute_pkg_add (dir); });
+m_load_path.initialize (set_initial_path);
+m_load_path_initialized = true;
+}
+}
+// This may be called separately from execute
+void interpreter::initialize (void)
+{
+if (m_initialized)
+return;
+if (m_app_context)
+{
+const cmdline_options& options = m_app_context->options ();
+if (options.experimental_terminal_widget ())
+{
+if (! options.gui ())
+display_startup_message ();
+}
+else
+display_startup_message ();
+}
+else
+display_startup_message ();
+// Wait to read the history file until the interpreter reads input
+// files and begins evaluating commands.
+initialize_history ();
+// Initializing the load path may execute PKG_ADD files, so can't be
+// done until the interpreter is ready to execute commands.
+// Deferring it to the execute step also allows the path to be
+// initialized between creating and execute the interpreter, for
+// example, to set a custom path for an embedded interpreter.
+initialize_load_path ();
+octave_save_signal_mask ();
+can_interrupt = true;
+octave_signal_hook = respond_to_pending_signals;
+octave_interrupt_hook = nullptr;
+catch_interrupts ();
+// FIXME: could we eliminate this variable or make it not be global?
+// Global used to communicate with signal handler.
+octave_initialized = true;
+m_initialized = true;
+}
+// Note: this function is currently only used with the new
+// experimental terminal widget.
+void interpreter::get_line_and_eval (void)
+{
+m_evaluator.get_line_and_eval ();
+}
+// Note: the following class is currently only used with the new
+// experimental terminal widget.
+class cli_input_reader
+{
+public:
+cli_input_reader (interpreter& interp)
+: m_interpreter (interp), m_thread () { }
+cli_input_reader (const cli_input_reader&) = delete;
+cli_input_reader& operator = (const cli_input_reader&) = delete;
+~cli_input_reader (void)
 {
-cleanup ();
+// FIXME: Would it be better to ensure that
+// interpreter::get_line_and_eval exits and then call
+// m_thread.join () here?
+m_thread.detach ();
 }
-void temporary_file_list::insert (const std::string& file)
+void start (void)
 {
-m_files.insert (file);
+m_thread = std::thread (&interpreter::get_line_and_eval, &m_interpreter);
 }
-void temporary_file_list::cleanup (void)
+private:
-{
-while (! m_files.empty ())
+interpreter& m_interpreter;
-{
-auto it = m_files.begin ();
+std::thread m_thread;
+};
-octave_unlink_wrapper (it->c_str ());
+void interpreter::parse_and_execute (const std::string& input,
-m_files.erase (it);
+bool& incomplete_parse)
-}
+{
-}
+m_evaluator.parse_and_execute (input, incomplete_parse);
+}
-// The time we last time we changed directories.
-sys::time Vlast_chdir_time = 0.0;
+// FIXME: this function is intended to be executed only once.  Should
+// we enforce that restriction?
-// Execute commands from a file and catch potential exceptions in a consistent
-// way.  This function should be called anywhere we might parse and execute
+int interpreter::execute (void)
-// commands from a file before we have entered the main loop in
+{
-// toplev.cc.
+int exit_status = 0;
-static int safe_source_file (const std::string& file_name,
+try
-const std::string& context = "",
+{
-bool verbose = false,
+initialize ();
-bool require_file = true)
-{
+execute_startup_files ();
-interpreter& interp = __get_interpreter__ ();
+if (m_app_context)
-try
+{
-{
+const cmdline_options& options = m_app_context->options ();
-source_file (file_name, context, verbose, require_file);
-}
+if (m_app_context->have_eval_option_code ())
-catch (const interrupt_exception&)
+{
-{
+int status = execute_eval_option_code ();
-interp.recover_from_exception ();
+if (status )
-return 1;
+exit_status = status;
-}
-catch (const execution_exception& ee)
+if (! options.persist ())
 {
-interp.handle_exception (ee);
+shutdown ();
-return 1;
+return exit_status;
 }
+}
-return 0;
-}
+// If there is an extra argument, see if it names a file to
+// read.  Additional arguments are taken as command line options
-static void initialize_version_info (void)
+// for the script.
-{
-octave_value_list args;
+if (m_app_context->have_script_file ())
+{
-args(3) = OCTAVE_RELEASE_DATE;
+int status = execute_command_line_file ();
-args(2) = config::release ();
-args(1) = OCTAVE_VERSION;
+if (status)
-args(0) = "GNU Octave";
+exit_status = status;
-F__version_info__ (args, 0);
+if (! options.persist ())
-}
+{
+shutdown ();
-static void xerbla_abort (void)
-{
+return exit_status;
-error ("Fortran procedure terminated by call to XERBLA");
+}
 }
-static void initialize_xerbla_error_handler (void)
+if (options.forced_interactive ())
-{
+command_editor::blink_matching_paren (false);
-// The idea here is to force xerbla to be referenced so that we will
-// link to our own version instead of the one provided by the BLAS
+if (options.server ())
-// library.  But numeric_limits<double>::NaN () should never be -1, so
+exit_status = server_loop ();
-// we should never actually call xerbla.  FIXME (again!): If this
+else if (options.experimental_terminal_widget ())
-// becomes a constant expression the test might be optimized away and
+{
-// then the reference to the function might also disappear.
+if (options.gui ())
+{
-if (numeric_limits<double>::NaN () == -1)
+m_event_manager.start_gui (true);
-F77_FUNC (xerbla, XERBLA) ("octave", 13 F77_CHAR_ARG_LEN (6));
+exit_status = server_loop ();
-typedef void (*xerbla_handler_ptr) (void);
+}
+else
-typedef void (*octave_set_xerbla_handler_ptr) (xerbla_handler_ptr);
+{
+// Use an object so that the thread started for the
-dynamic_library libs ("");
+// reader will be cleaned up no matter how we exit
+// this function.
-if (libs)
-{
+cli_input_reader reader (*this);
-octave_set_xerbla_handler_ptr octave_set_xerbla_handler
-= reinterpret_cast<octave_set_xerbla_handler_ptr>
+reader.start ();
-(libs.search ("octave_set_xerbla_handler"));
+exit_status = server_loop ();
-if (octave_set_xerbla_handler)
+}
-octave_set_xerbla_handler (xerbla_abort);
+}
-}
+else
-}
+exit_status = main_loop ();
-OCTAVE_NORETURN static void
+shutdown ();
-lo_error_handler (const char *fmt, ...)
+}
-{
+}
-va_list args;
+catch (const exit_exception& xe)
-va_start (args, fmt);
+{
-verror_with_cfn (fmt, args);
+exit_status = xe.exit_status ();
-va_end (args);
-throw execution_exception ();
-}
-OCTAVE_NORETURN static void
-lo_error_with_id_handler (const char *id, const char *fmt, ...)
-{
-va_list args;
-va_start (args, fmt);
-verror_with_id_cfn (id, fmt, args);
-va_end (args);
-throw execution_exception ();
-}
-static void initialize_error_handlers (void)
-{
-set_liboctave_error_handler (lo_error_handler);
-set_liboctave_error_with_id_handler (lo_error_with_id_handler);
-set_liboctave_warning_handler (warning);
-set_liboctave_warning_with_id_handler (warning_with_id);
-}
-// Create an interpreter object and perform initialization up to the
-// point of setting reading command history and setting the load
-// path.
-interpreter::interpreter (application *app_context)
-: m_app_context (app_context),
-m_tmp_files (),
-m_atexit_fcns (),
-m_display_info (),
-m_environment (),
-m_settings (),
-m_error_system (*this),
-m_evaluator (*this),
-m_help_system (*this),
-m_input_system (*this),
-m_output_system (*this),
-m_history_system (*this),
-m_dynamic_loader (*this),
-m_load_path (*this),
-m_load_save_system (*this),
-m_type_info (),
-m_symbol_table (*this),
-m_stream_list (*this),
-m_child_list (),
-m_url_handle_manager (),
-m_cdef_manager (*this),
-m_gtk_manager (),
-m_event_manager (*this),
-m_gh_manager (nullptr),
-m_interactive (false),
-m_read_site_files (true),
-m_read_init_files (m_app_context != nullptr),
-m_verbose (false),
-m_traditional (false),
-m_inhibit_startup_message (false),
-m_load_path_initialized (false),
-m_history_initialized (false),
-m_interrupt_all_in_process_group (true),
-m_cancel_quit (false),
-m_executing_finish_script (false),
-m_executing_atexit (false),
-m_initialized (false)
-{
-// FIXME: When thread_local storage is used by default, this message
-// should change to say something like
-//
-//   only one Octave interpreter may be active in any given thread
-if (m_instance)
-throw std::runtime_error
-("only one Octave interpreter may be active");
-m_instance = this;
-#if defined (OCTAVE_HAVE_WINDOWS_UTF8_LOCALE)
-// Force a UTF-8 locale on Windows if possible
-std::setlocale (LC_ALL, ".UTF8");
-#else
-std::setlocale (LC_ALL, "");
-#endif
-// Matlab uses "C" locale for LC_NUMERIC class regardless of local setting
-std::setlocale (LC_NUMERIC, "C");
-std::setlocale (LC_TIME, "C");
-sys::env::putenv ("LC_NUMERIC", "C");
-sys::env::putenv ("LC_TIME", "C");
-// Initialize the default floating point unit control state.
-octave_set_default_fpucw ();
-thread::init ();
-octave_ieee_init ();
-initialize_xerbla_error_handler ();
-initialize_error_handlers ();
-if (m_app_context)
-{
-install_signal_handlers ();
-octave_unblock_signal_by_name ("SIGTSTP");
-}
-else
-quit_allowed = false;
-if (! m_app_context)
-m_display_info.initialize ();
-bool line_editing = false;
-if (m_app_context)
-{
-// Embedded interpreters don't execute command line options.
-const cmdline_options& options = m_app_context->options ();
-// Make all command-line arguments available to startup files,
-// including PKG_ADD files.
-string_vector args = options.all_args ();
-m_app_context->intern_argv (args);
-intern_nargin (args.numel () - 1);
-bool is_octave_program = m_app_context->is_octave_program ();
-std::list<std::string> command_line_path = options.command_line_path ();
-for (const auto& pth : command_line_path)
-m_load_path.set_command_line_path (pth);
-std::string exec_path = options.exec_path ();
-if (! exec_path.empty ())
-m_environment.exec_path (exec_path);
-std::string image_path = options.image_path ();
-if (! image_path.empty ())
-m_environment.image_path (image_path);
-if (! options.no_window_system ())
-m_display_info.initialize ();
-// Is input coming from a terminal?  If so, we are probably
-// interactive.
-// If stdin is not a tty, then we are reading commands from a
-// pipe or a redirected file.
-bool stdin_is_tty = octave_isatty_wrapper (fileno (stdin));
-m_interactive = (! is_octave_program && stdin_is_tty
-&& octave_isatty_wrapper (fileno (stdout)));
-// Don't force interactive if we're already interactive (bug #60696).
-bool forced_interactive = options.forced_interactive ();
-if (m_interactive)
-{
-m_app_context->forced_interactive (false);
-forced_interactive = false;
-}
-// Check if the user forced an interactive session.
-if (forced_interactive)
-m_interactive = true;
-line_editing = options.line_editing ();
-if ((! m_interactive || forced_interactive)
-&& ! options.forced_line_editing ())
-line_editing = false;
-m_traditional = options.traditional ();
-// FIXME: if possible, perform the following actions directly
-// instead of using the interpreter-level functions.
-if (options.echo_commands ())
-m_evaluator.echo
-(tree_evaluator::ECHO_SCRIPTS | tree_evaluator::ECHO_FUNCTIONS
-| tree_evaluator::ECHO_ALL);
-std::string docstrings_file = options.docstrings_file ();
-if (! docstrings_file.empty ())
-Fbuilt_in_docstrings_file (*this, octave_value (docstrings_file));
-std::string doc_cache_file = options.doc_cache_file ();
-if (! doc_cache_file.empty ())
-Fdoc_cache_file (*this, octave_value (doc_cache_file));
-std::string info_file = options.info_file ();
-if (! info_file.empty ())
-Finfo_file (*this, octave_value (info_file));
-std::string info_program = options.info_program ();
-if (! info_program.empty ())
-Finfo_program (*this, octave_value (info_program));
-std::string texi_macros_file = options.texi_macros_file ();
-if (! texi_macros_file.empty ())
-Ftexi_macros_file (*this, octave_value (texi_macros_file));
-}
-// FIXME: we defer creation of the gh_manager object because it
-// creates a root_figure object that requires the display_info
-// object, but that is currently only accessible through the global
-// interpreter object and that is not available until after the
-// interpreter::instance pointer is set (above).  It would be better
-// if m_gh_manager could be an object value instead of a pointer and
-// created as part of the interpreter initialization.  To do that,
-// we should either make the display_info object independent of the
-// interpreter object (does it really need to cache any
-// information?) or defer creation of the root_figure object until
-// it is actually needed.
-m_gh_manager = new gh_manager (*this);
-m_input_system.initialize (line_editing);
-// These can come after command line args since none of them set any
-// defaults that might be changed by command line options.
-initialize_version_info ();
-// This should be done before initializing the load path because
-// some PKG_ADD files might need --traditional behavior.
-if (m_traditional)
-maximum_braindamage ();
-octave_interpreter_ready = true;
-}
-OCTAVE_THREAD_LOCAL interpreter *interpreter::m_instance = nullptr;
-interpreter::~interpreter (void)
-{
-if (! m_app_context)
 shutdown ();
+}
-delete m_gh_manager;
-}
+return exit_status;
+}
-void interpreter::intern_nargin (octave_idx_type nargs)
-{
+// Call a function with exceptions handled to avoid problems with
-m_evaluator.set_auto_fcn_var (stack_frame::NARGIN, nargs);
+// errors while shutting down.
-}
-// Read the history file unless a command-line option inhibits that.
-void interpreter::initialize_history (bool read_history_file)
-{
-if (! m_history_initialized)
-{
-// Allow command-line option to override.
-if (m_app_context)
-{
-const cmdline_options& options = m_app_context->options ();
-read_history_file = options.read_history_file ();
-if (! read_history_file)
-command_history::ignore_entries ();
-}
-m_history_system.initialize (read_history_file);
-if (! m_app_context)
-command_history::ignore_entries ();
-m_history_initialized = true;
-}
-}
-// Set the initial path to the system default unless command-line
-// option says to leave it empty.
-void interpreter::initialize_load_path (bool set_initial_path)
-{
-if (! m_load_path_initialized)
-{
-// Allow command-line option to override.
-if (m_app_context)
-{
-const cmdline_options& options = m_app_context->options ();
-set_initial_path = options.set_initial_path ();
-}
-// Temporarily set the execute_pkg_add function to one that
-// catches exceptions.  This is better than wrapping
-// load_path::initialize in a try-catch block because it will
-// not stop executing PKG_ADD files at the first exception.
-// It's also better than changing the default execute_pkg_add
-// function to use safe_source file because that will normally
-// be evaluated from the normal interpreter loop where exceptions
-// are already handled.
-unwind_action restore_add_hook (&load_path::set_add_hook, &m_load_path,
-m_load_path.get_add_hook ());
-m_load_path.set_add_hook ([=] (const std::string& dir)
-{ this->execute_pkg_add (dir); });
-m_load_path.initialize (set_initial_path);
-m_load_path_initialized = true;
-}
-}
-// This may be called separately from execute
-void interpreter::initialize (void)
-{
-if (m_initialized)
-return;
-if (m_app_context)
-{
-const cmdline_options& options = m_app_context->options ();
-if (options.experimental_terminal_widget ())
-{
-if (! options.gui ())
-display_startup_message ();
-}
-else
-display_startup_message ();
-}
-else
-display_startup_message ();
-// Wait to read the history file until the interpreter reads input
-// files and begins evaluating commands.
-initialize_history ();
-// Initializing the load path may execute PKG_ADD files, so can't be
-// done until the interpreter is ready to execute commands.
-// Deferring it to the execute step also allows the path to be
-// initialized between creating and execute the interpreter, for
-// example, to set a custom path for an embedded interpreter.
-initialize_load_path ();
-octave_save_signal_mask ();
-can_interrupt = true;
-octave_signal_hook = respond_to_pending_signals;
-octave_interrupt_hook = nullptr;
-catch_interrupts ();
-// FIXME: could we eliminate this variable or make it not be global?
-// Global used to communicate with signal handler.
-octave_initialized = true;
-m_initialized = true;
-}
-// Note: this function is currently only used with the new
-// experimental terminal widget.
-void interpreter::get_line_and_eval (void)
-{
-m_evaluator.get_line_and_eval ();
-}
-// Note: the following class is currently only used with the new
-// experimental terminal widget.
-class cli_input_reader
-{
-public:
-cli_input_reader (interpreter& interp)
-: m_interpreter (interp), m_thread () { }
-cli_input_reader (const cli_input_reader&) = delete;
-cli_input_reader& operator = (const cli_input_reader&) = delete;
-~cli_input_reader (void)
-{
-// FIXME: Would it be better to ensure that
-// interpreter::get_line_and_eval exits and then call
-// m_thread.join () here?
-m_thread.detach ();
-}
-void start (void)
-{
-m_thread = std::thread (&interpreter::get_line_and_eval, &m_interpreter);
-}
-private:
-interpreter& m_interpreter;
-std::thread m_thread;
-};
-void interpreter::parse_and_execute (const std::string& input,
-bool& incomplete_parse)
-{
-m_evaluator.parse_and_execute (input, incomplete_parse);
-}
-// FIXME: this function is intended to be executed only once.  Should
-// we enforce that restriction?
-int interpreter::execute (void)
-{
-int exit_status = 0;
-try
-{
-initialize ();
-execute_startup_files ();
-if (m_app_context)
-{
-const cmdline_options& options = m_app_context->options ();
-if (m_app_context->have_eval_option_code ())
-{
-int status = execute_eval_option_code ();
-if (status )
-exit_status = status;
-if (! options.persist ())
-{
-shutdown ();
-return exit_status;
-}
-}
-// If there is an extra argument, see if it names a file to
-// read.  Additional arguments are taken as command line options
-// for the script.
-if (m_app_context->have_script_file ())
-{
-int status = execute_command_line_file ();
-if (status)
-exit_status = status;
-if (! options.persist ())
-{
-shutdown ();
-return exit_status;
-}
-}
-if (options.forced_interactive ())
-command_editor::blink_matching_paren (false);
-if (options.server ())
-exit_status = server_loop ();
-else if (options.experimental_terminal_widget ())
-{
-if (options.gui ())
-{
-m_event_manager.start_gui (true);
-exit_status = server_loop ();
-}
-else
-{
-// Use an object so that the thread started for the
-// reader will be cleaned up no matter how we exit
-// this function.
-cli_input_reader reader (*this);
-reader.start ();
-exit_status = server_loop ();
-}
-}
-else
-exit_status = main_loop ();
-shutdown ();
-}
-}
-catch (const exit_exception& xe)
-{
-exit_status = xe.exit_status ();
-shutdown ();
-}
-return exit_status;
-}
-// Call a function with exceptions handled to avoid problems with
-// errors while shutting down.
 #define OCTAVE_IGNORE_EXCEPTION(E)                                      \
 catch (E)                                                             \
 {                                                                   \
 recover_from_exception ();                                        \
 OCTAVE_IGNORE_EXCEPTION (const execution_exception&)              \
 OCTAVE_IGNORE_EXCEPTION (const std::bad_alloc&)                   \
 }                                                                   \
 while (0)
 void interpreter::shutdown (void)
 {
 // Attempt to prevent more than one call to shutdown.
 if (! m_initialized)
 return;
 m_initialized = false;
 OCTAVE_SAFE_CALL (feval, ("close", ovl ("all"), 0));
 // Any atexit functions added after this function call won't be
 // executed.  Each atexit function is executed with
 // OCTAVE_SAFE_CALL, so we don't need that here.
 execute_atexit_fcns ();
 // Clear all functions and variables while the event manager is
 // still processing events and notify the event manager.  This way,
 // the workspace model will be cleared before the GUI exits.
 // FIXME: This approach seems a bit fragile since there could be
 // other places in the GUI that have references to interpreter
 // objects.  How can we reliably ensure that they are all removed
 // before the interpreter exits?  Maybe the best solution is to
 // always start the GUI from the interpreter and close it when the
 // interpreter exits?  However, the workspace model is owned by the
 // base_qobject object not the workspace viewer or the main window,
 // so simply closing the GUI window(s) is not sufficient.  See also
 // bug #61994.
 // Note that we don't force symbols to be cleared, so we will
 // respect mlock at this point.  Later, we'll force all variables
 // and functions to be cleared.
 OCTAVE_SAFE_CALL (clear_all, ());
 OCTAVE_SAFE_CALL (m_event_manager.clear_workspace, ());
 // If we are attached to a GUI, queue and event to close it (only
 // works with the new terminal widget), process pending events and
 // disable the link.
 OCTAVE_SAFE_CALL (m_event_manager.close_gui, ());
 OCTAVE_SAFE_CALL (m_event_manager.process_events, (true));
 OCTAVE_SAFE_CALL (m_event_manager.disable, ());
 OCTAVE_SAFE_CALL (m_input_system.clear_input_event_hooks, ());
 // We may still have some figures.  Close them.
 OCTAVE_SAFE_CALL (feval, ("close", ovl ("all"), 0));
 // What is supposed to happen if a figure has a closerequestfcn or
 // deletefcn callback registered that creates other figures or
 // variables?  What if those variables are classdef objects with
 // destructors that can create figures?  The possibilities are
 // endless.  At some point, we have to give up and force execution
 // to end.
 // Note that we again don't force symbols to be cleared, so we
 // continue to respect mlock here.  Later, we'll force all variables
 // and functions to be cleared.
 OCTAVE_SAFE_CALL (clear_all, ());
 // Do this explicitly so that destructors for mex file objects
 // are called, so that functions registered with mexAtExit are
 // called.
 OCTAVE_SAFE_CALL (m_symbol_table.clear_mex_functions, ());
 OCTAVE_SAFE_CALL (command_editor::restore_terminal_state, ());
 OCTAVE_SAFE_CALL (m_history_system.write_timestamp, ());
 if (! command_history::ignoring_entries ())
 OCTAVE_SAFE_CALL (command_history::clean_up_and_save, ());
 OCTAVE_SAFE_CALL (m_gtk_manager.unload_all_toolkits, ());
 // Now that the graphics toolkits have been unloaded, force all
 // symbols to be cleared.
 OCTAVE_SAFE_CALL (clear_all, (true));
 // FIXME:  May still need something like this to ensure that
 // destructors for class objects will run properly.  Should that be
 // done earlier?  Before or after atexit functions are executed?
 // What will happen if the destructor for an obect attempts to
 // display a figure?
 OCTAVE_SAFE_CALL (m_symbol_table.cleanup, ());
 OCTAVE_SAFE_CALL (sysdep_cleanup, ());
 OCTAVE_SAFE_CALL (flush_stdout, ());
 // Don't call singleton_cleanup_list::cleanup until we have the
 // problems with registering/unregistering types worked out.  For
 // example, uncomment the following line, then use the make_int
 // function from the examples directory to create an integer
 // object and then exit Octave.  Octave should crash with a
 // segfault when cleaning up the typinfo singleton.  We need some
 // way to force new octave_value_X types that are created in
 // .oct files to be unregistered when the .oct file shared library
 // is unloaded.
 //
 // OCTAVE_SAFE_CALL (singleton_cleanup_list::cleanup, ());
 }
 void interpreter::execute_atexit_fcns (void)
 {
 // Prevent atexit functions from adding new functions to the list.
 m_executing_atexit = true;
 while (! m_atexit_fcns.empty ())
 {
 std::string fcn = m_atexit_fcns.front ();
 m_atexit_fcns.pop_front ();
 OCTAVE_SAFE_CALL (feval, (fcn, octave_value_list (), 0));
 OCTAVE_SAFE_CALL (flush_stdout, ());
 }
 }
 void interpreter::display_startup_message (void) const
 {
 bool inhibit_startup_message = false;
 if (m_app_context)
 {
 const cmdline_options& options = m_app_context->options ();
 inhibit_startup_message = options.inhibit_startup_message ();
 }
 if (m_interactive && ! inhibit_startup_message)
 std::cout << octave_startup_message () << "\n" << std::endl;
 }
 // Initialize by reading startup files.  Return non-zero if an exception
 // occurs when reading any of them, but don't exit early because of an
 // exception.
 int interpreter::execute_startup_files (void)
 {
 bool read_site_files = m_read_site_files;
 bool read_init_files = m_read_init_files;
 bool verbose = m_verbose;
 bool inhibit_startup_message = m_inhibit_startup_message;
 if (m_app_context)
 {
 const cmdline_options& options = m_app_context->options ();
 read_site_files = options.read_site_files ();
 read_init_files = options.read_init_files ();
 verbose = options.verbose_flag ();
 inhibit_startup_message = options.inhibit_startup_message ();
 }
 verbose = (verbose && ! inhibit_startup_message);
 bool require_file = false;
 std::string context;
 int exit_status = 0;
 if (read_site_files)
 {
 // Execute commands from the site-wide configuration file.
 // First from the file $(prefix)/lib/octave/site/m/octaverc
 // (if it exists), then from the file
 // $(prefix)/share/octave/$(version)/m/octaverc (if it exists).
 int status = safe_source_file (config::local_site_defaults_file (),
 context, verbose, require_file);
 if (status)
 exit_status = status;
 status = safe_source_file (config::site_defaults_file (),
 context, verbose, require_file);
 if (status)
 exit_status = status;
 }
 if (read_init_files)
 {
 // Try to execute commands from the Matlab compatible startup.m file
 // if it exists anywhere in the load path when starting Octave.
 std::string ff_startup_m = file_in_path ("startup.m", "");
 if (! ff_startup_m.empty ())
 {
 int parse_status = 0;
 try
 {
 eval_string (std::string ("startup"), false, parse_status, 0);
 }
 catch (const interrupt_exception&)
 {
 recover_from_exception ();
 }
 catch (const execution_exception& ee)
 {
 handle_exception (ee);
 }
 }
 // Try to execute commands from $CONFIG/octave/octaverc, where
 // $CONFIG is the platform-dependent location for user local
 // configuration files.
 std::string user_config_dir = sys::env::get_user_config_directory ();
 std::string cfg_dir = user_config_dir + sys::file_ops::dir_sep_str ()
 + "octave";
 std::string cfg_rc = sys::env::make_absolute ("octaverc", cfg_dir);
 if (! cfg_rc.empty ())
 {
 int status = safe_source_file (cfg_rc, context, verbose,
 require_file);
 if (status)
 exit_status = status;
 }
 // Try to execute commands from $HOME/$OCTAVE_INITFILE and
 // $OCTAVE_INITFILE.  If $OCTAVE_INITFILE is not set,
 // .octaverc is assumed.
 bool home_rc_already_executed = false;
 std::string initfile = sys::env::getenv ("OCTAVE_INITFILE");
 if (initfile.empty ())
 initfile = ".octaverc";
 std::string home_dir = sys::env::get_home_directory ();
 std::string home_rc = sys::env::make_absolute (initfile, home_dir);
 std::string local_rc;
 if (! home_rc.empty ())
 {
 int status = safe_source_file (home_rc, context, verbose,
 require_file);
 if (status)
 exit_status = status;
 // Names alone are not enough.
 sys::file_stat fs_home_rc (home_rc);
 if (fs_home_rc)
 {
 // We want to check for curr_dir after executing home_rc
 // because doing that may change the working directory.
-local_rc = sys::env::make_absolute (initfile);
-home_rc_already_executed = same_file (home_rc, local_rc);
-}
-}
-if (! home_rc_already_executed)
-{
-if (local_rc.empty ())
 local_rc = sys::env::make_absolute (initfile);
-int status = safe_source_file (local_rc, context, verbose,
+home_rc_already_executed = same_file (home_rc, local_rc);
-require_file);
+}
+}
-if (status)
-exit_status = status;
+if (! home_rc_already_executed)
-}
+{
-}
+if (local_rc.empty ())
+local_rc = sys::env::make_absolute (initfile);
-if (m_interactive && verbose)
-std::cout << std::endl;
+int status = safe_source_file (local_rc, context, verbose,
+require_file);
-return exit_status;
-}
+if (status)
+exit_status = status;
-// Execute any code specified with --eval 'CODE'
+}
+}
-int interpreter::execute_eval_option_code (void)
-{
+if (m_interactive && verbose)
-if (! m_app_context)
+std::cout << std::endl;
-return 0;
+return exit_status;
-const cmdline_options& options = m_app_context->options ();
+}
-std::string code_to_eval = options.code_to_eval ();
+// Execute any code specified with --eval 'CODE'
-unwind_protect_var<bool> upv (m_interactive, false);
+int interpreter::execute_eval_option_code (void)
+{
-int parse_status = 0;
+if (! m_app_context)
+return 0;
-try
-{
+const cmdline_options& options = m_app_context->options ();
-eval_string (code_to_eval, false, parse_status, 0);
-}
+std::string code_to_eval = options.code_to_eval ();
-catch (const interrupt_exception&)
-{
+unwind_protect_var<bool> upv (m_interactive, false);
-recover_from_exception ();
+int parse_status = 0;
-return 1;
-}
+try
-catch (const execution_exception& ee)
+{
-{
+eval_string (code_to_eval, false, parse_status, 0);
-handle_exception (ee);
+}
+catch (const interrupt_exception&)
-return 1;
+{
-}
+recover_from_exception ();
-return parse_status;
+return 1;
 }
+catch (const execution_exception& ee)
-int interpreter::execute_command_line_file (void)
+{
-{
+handle_exception (ee);
-if (! m_app_context)
-return 0;
+return 1;
+}
-const cmdline_options& options = m_app_context->options ();
+return parse_status;
-string_vector args = options.all_args ();
+}
-void (interpreter::*interactive_fptr) (bool) = &interpreter::interactive;
+int interpreter::execute_command_line_file (void)
-unwind_action restore_interactive (interactive_fptr, this, m_interactive);
+{
+if (! m_app_context)
-unwind_action restore_argv (&application::intern_argv, m_app_context, args);
+return 0;
-unwind_action restore_nargin (&interpreter::intern_nargin, this,
+const cmdline_options& options = m_app_context->options ();
-args.numel () - 1);
+string_vector args = options.all_args ();
-void (application::*program_invocation_name_fptr) (const std::string&)
-= &application::program_invocation_name;
+void (interpreter::*interactive_fptr) (bool) = &interpreter::interactive;
-unwind_action restore_program_invocation_name
+unwind_action restore_interactive (interactive_fptr, this, m_interactive);
-(program_invocation_name_fptr, m_app_context,
-application::program_invocation_name ());
+unwind_action restore_argv (&application::intern_argv, m_app_context, args);
-void (application::*program_name_fptr) (const std::string&)
+unwind_action restore_nargin (&interpreter::intern_nargin, this,
-= &application::program_name;
+args.numel () - 1);
-unwind_action restore_program_name
-(program_name_fptr, m_app_context, application::program_name ());
+void (application::*program_invocation_name_fptr) (const std::string&)
+= &application::program_invocation_name;
-m_interactive = false;
+unwind_action restore_program_invocation_name
+(program_invocation_name_fptr, m_app_context,
-// If we are running an executable script (#! /bin/octave) then
+application::program_invocation_name ());
-// we should only see the args passed to the script.
+void (application::*program_name_fptr) (const std::string&)
-string_vector script_args = options.remaining_args ();
+= &application::program_name;
+unwind_action restore_program_name
-m_app_context->intern_argv (script_args);
+(program_name_fptr, m_app_context, application::program_name ());
-intern_nargin (script_args.numel () - 1);
+m_interactive = false;
-std::string fname = script_args[0];
+// If we are running an executable script (#! /bin/octave) then
-m_app_context->set_program_names (fname);
+// we should only see the args passed to the script.
-std::string context;
+string_vector script_args = options.remaining_args ();
-bool verbose = false;
-bool require_file = true;
+m_app_context->intern_argv (script_args);
+intern_nargin (script_args.numel () - 1);
-return safe_source_file (fname, context, verbose, require_file);
-}
+std::string fname = script_args[0];
-int interpreter::main_loop (void)
+m_app_context->set_program_names (fname);
-{
-command_editor::add_event_hook (release_unreferenced_dynamic_libraries);
+std::string context;
+bool verbose = false;
-return m_evaluator.repl ();
+bool require_file = true;
-}
+return safe_source_file (fname, context, verbose, require_file);
-int interpreter::server_loop (void)
+}
-{
-return m_evaluator.server_loop ();
+int interpreter::main_loop (void)
-}
+{
+command_editor::add_event_hook (release_unreferenced_dynamic_libraries);
-tree_evaluator& interpreter::get_evaluator (void)
-{
+return m_evaluator.repl ();
-return m_evaluator;
+}
-}
+int interpreter::server_loop (void)
-stream_list& interpreter::get_stream_list (void)
+{
-{
+return m_evaluator.server_loop ();
-return m_stream_list;
+}
-}
+tree_evaluator& interpreter::get_evaluator (void)
-url_handle_manager& interpreter::get_url_handle_manager (void)
+{
-{
+return m_evaluator;
-return m_url_handle_manager;
+}
-}
+stream_list& interpreter::get_stream_list (void)
-symbol_scope
+{
-interpreter::get_top_scope (void) const
+return m_stream_list;
-{
+}
-return m_evaluator.get_top_scope ();
-}
+url_handle_manager& interpreter::get_url_handle_manager (void)
+{
-symbol_scope
+return m_url_handle_manager;
-interpreter::get_current_scope (void) const
+}
-{
-return m_evaluator.get_current_scope ();
+symbol_scope
-}
+interpreter::get_top_scope (void) const
+{
-symbol_scope
+return m_evaluator.get_top_scope ();
-interpreter::require_current_scope (const std::string& who) const
+}
-{
-symbol_scope scope = get_current_scope ();
+symbol_scope
+interpreter::get_current_scope (void) const
-if (! scope)
+{
-error ("%s: symbol table scope missing", who.c_str ());
+return m_evaluator.get_current_scope ();
+}
-return scope;
-}
+symbol_scope
+interpreter::require_current_scope (const std::string& who) const
-profiler& interpreter::get_profiler (void)
+{
-{
+symbol_scope scope = get_current_scope ();
-return m_evaluator.get_profiler ();
-}
+if (! scope)
+error ("%s: symbol table scope missing", who.c_str ());
-int interpreter::chdir (const std::string& dir)
-{
+return scope;
-std::string xdir = sys::file_ops::tilde_expand (dir);
+}
-int cd_ok = sys::env::chdir (xdir);
+profiler& interpreter::get_profiler (void)
+{
-if (! cd_ok)
+return m_evaluator.get_profiler ();
-error ("%s: %s", dir.c_str (), std::strerror (errno));
+}
-Vlast_chdir_time.stamp ();
+int interpreter::chdir (const std::string& dir)
+{
-// FIXME: should these actions be handled as a list of functions
+std::string xdir = sys::file_ops::tilde_expand (dir);
-// to call so users can add their own chdir handlers?
+int cd_ok = sys::env::chdir (xdir);
-m_load_path.read_dir_config (".");
-m_load_path.update ();
+if (! cd_ok)
+error ("%s: %s", dir.c_str (), std::strerror (errno));
-m_event_manager.directory_changed (sys::env::get_current_directory ());
+Vlast_chdir_time.stamp ();
-return cd_ok;
-}
+// FIXME: should these actions be handled as a list of functions
+// to call so users can add their own chdir handlers?
-void interpreter::mlock (bool skip_first) const
-{
+m_load_path.read_dir_config (".");
-m_evaluator.mlock (skip_first);
+m_load_path.update ();
-}
+m_event_manager.directory_changed (sys::env::get_current_directory ());
-void interpreter::munlock (bool skip_first) const
-{
+return cd_ok;
-m_evaluator.munlock (skip_first);
+}
-}
+void interpreter::mlock (bool skip_first) const
-bool interpreter::mislocked (bool skip_first) const
+{
-{
+m_evaluator.mlock (skip_first);
-return m_evaluator.mislocked (skip_first);
+}
-}
+void interpreter::munlock (bool skip_first) const
-void interpreter::munlock (const char *nm)
+{
-{
+m_evaluator.munlock (skip_first);
-if (! nm)
+}
-error ("munlock: invalid value for NAME");
+bool interpreter::mislocked (bool skip_first) const
-munlock (std::string (nm));
+{
-}
+return m_evaluator.mislocked (skip_first);
+}
-void interpreter::munlock (const std::string& nm)
-{
+void interpreter::munlock (const char *nm)
-octave_value val = m_symbol_table.find_function (nm);
+{
+if (! nm)
-if (val.is_defined ())
+error ("munlock: invalid value for NAME");
-{
-octave_function *fcn = val.function_value ();
+munlock (std::string (nm));
+}
-if (fcn)
-fcn->unlock ();
+void interpreter::munlock (const std::string& nm)
-}
+{
-}
+octave_value val = m_symbol_table.find_function (nm);
-bool interpreter::mislocked (const char *nm)
+if (val.is_defined ())
 {
-if (! nm)
+octave_function *fcn = val.function_value ();
-error ("mislocked: invalid value for NAME");
+if (fcn)
-return mislocked (std::string (nm));
+fcn->unlock ();
 }
+}
-bool interpreter::mislocked (const std::string& nm)
-{
+bool interpreter::mislocked (const char *nm)
-bool retval = false;
+{
+if (! nm)
-octave_value val = m_symbol_table.find_function (nm);
+error ("mislocked: invalid value for NAME");
-if (val.is_defined ())
+return mislocked (std::string (nm));
-{
+}
-octave_function *fcn = val.function_value ();
+bool interpreter::mislocked (const std::string& nm)
-if (fcn)
+{
-retval = fcn->islocked ();
+bool retval = false;
-}
+octave_value val = m_symbol_table.find_function (nm);
-return retval;
-}
+if (val.is_defined ())
+{
-std::string interpreter::mfilename (const std::string& opt) const
+octave_function *fcn = val.function_value ();
-{
-return m_evaluator.mfilename (opt);
+if (fcn)
-}
+retval = fcn->islocked ();
+}
-octave_value_list interpreter::eval_string (const std::string& eval_str,
-bool silent, int& parse_status,
+return retval;
-int nargout)
+}
-{
-return m_evaluator.eval_string (eval_str, silent, parse_status, nargout);
+std::string interpreter::mfilename (const std::string& opt) const
-}
+{
+return m_evaluator.mfilename (opt);
-octave_value interpreter::eval_string (const std::string& eval_str,
+}
-bool silent, int& parse_status)
-{
+octave_value_list interpreter::eval_string (const std::string& eval_str,
-return m_evaluator.eval_string (eval_str, silent, parse_status);
+bool silent, int& parse_status,
-}
+int nargout)
+{
-octave_value_list interpreter::eval_string (const octave_value& arg,
+return m_evaluator.eval_string (eval_str, silent, parse_status, nargout);
-bool silent, int& parse_status,
+}
-int nargout)
-{
+octave_value interpreter::eval_string (const std::string& eval_str,
-return m_evaluator.eval_string (arg, silent, parse_status, nargout);
+bool silent, int& parse_status)
-}
+{
+return m_evaluator.eval_string (eval_str, silent, parse_status);
-octave_value_list interpreter::eval (const std::string& try_code,
+}
+octave_value_list interpreter::eval_string (const octave_value& arg,
+bool silent, int& parse_status,
+int nargout)
+{
+return m_evaluator.eval_string (arg, silent, parse_status, nargout);
+}
+octave_value_list interpreter::eval (const std::string& try_code,
+int nargout)
+{
+return m_evaluator.eval (try_code, nargout);
+}
+octave_value_list interpreter::eval (const std::string& try_code,
+const std::string& catch_code,
+int nargout)
+{
+return m_evaluator.eval (try_code, catch_code, nargout);
+}
+octave_value_list interpreter::evalin (const std::string& context,
+const std::string& try_code,
 int nargout)
 {
-return m_evaluator.eval (try_code, nargout);
+return m_evaluator.evalin (context, try_code, nargout);
 }
-octave_value_list interpreter::eval (const std::string& try_code,
+octave_value_list interpreter::evalin (const std::string& context,
+const std::string& try_code,
 const std::string& catch_code,
 int nargout)
 {
-return m_evaluator.eval (try_code, catch_code, nargout);
+return m_evaluator.evalin (context, try_code, catch_code, nargout);
 }
-octave_value_list interpreter::evalin (const std::string& context,
+//! Evaluate an Octave function (built-in or interpreted) and return
-const std::string& try_code,
+//! the list of result values.
-int nargout)
+//!
-{
+//! @param name The name of the function to call.
-return m_evaluator.evalin (context, try_code, nargout);
+//! @param args The arguments to the function.
-}
+//! @param nargout The number of output arguments expected.
+//! @return A list of output values.  The length of the list is not
-octave_value_list interpreter::evalin (const std::string& context,
+//!         necessarily the same as @c nargout.
-const std::string& try_code,
-const std::string& catch_code,
+octave_value_list interpreter::feval (const char *name,
-int nargout)
+const octave_value_list& args,
-{
+int nargout)
-return m_evaluator.evalin (context, try_code, catch_code, nargout);
+{
-}
+return feval (std::string (name), args, nargout);
+}
-//! Evaluate an Octave function (built-in or interpreted) and return
-//! the list of result values.
+octave_value_list interpreter::feval (const std::string& name,
-//!
+const octave_value_list& args,
-//! @param name The name of the function to call.
+int nargout)
-//! @param args The arguments to the function.
+{
-//! @param nargout The number of output arguments expected.
+octave_value fcn = m_symbol_table.find_function (name, args);
-//! @return A list of output values.  The length of the list is not
-//!         necessarily the same as @c nargout.
+if (fcn.is_undefined ())
+error ("feval: function '%s' not found", name.c_str ());
-octave_value_list interpreter::feval (const char *name,
-const octave_value_list& args,
+octave_function *of = fcn.function_value ();
-int nargout)
-{
+return of->call (m_evaluator, nargout, args);
-return feval (std::string (name), args, nargout);
+}
-}
+octave_value_list interpreter::feval (octave_function *fcn,
-octave_value_list interpreter::feval (const std::string& name,
+const octave_value_list& args,
-const octave_value_list& args,
+int nargout)
-int nargout)
+{
-{
+if (fcn)
-octave_value fcn = m_symbol_table.find_function (name, args);
+return fcn->call (m_evaluator, nargout, args);
-if (fcn.is_undefined ())
+return octave_value_list ();
-error ("feval: function '%s' not found", name.c_str ());
+}
-octave_function *of = fcn.function_value ();
+octave_value_list interpreter::feval (const octave_value& val,
+const octave_value_list& args,
-return of->call (m_evaluator, nargout, args);
+int nargout)
-}
+{
+// FIXME: do we really want to silently return an empty ovl if
-octave_value_list interpreter::feval (octave_function *fcn,
+// the function object is undefined?  It's essentially what the
-const octave_value_list& args,
+// version above that accepts a pointer to an octave_function
-int nargout)
+// object does and some code was apparently written to rely on it
-{
+// (for example, __ode15__).
-if (fcn)
-return fcn->call (m_evaluator, nargout, args);
+if (val.is_undefined ())
-return octave_value_list ();
-}
-octave_value_list interpreter::feval (const octave_value& val,
-const octave_value_list& args,
-int nargout)
-{
-// FIXME: do we really want to silently return an empty ovl if
-// the function object is undefined?  It's essentially what the
-// version above that accepts a pointer to an octave_function
-// object does and some code was apparently written to rely on it
-// (for example, __ode15__).
-if (val.is_undefined ())
-return ovl ();
-if (val.is_function ())
-{
-return feval (val.function_value (), args, nargout);
-}
-else if (val.is_function_handle () || val.is_inline_function ())
-{
-// This covers function handles, inline functions, and anonymous
-//  functions.
-std::list<octave_value_list> arg_list;
-arg_list.push_back (args);
-// FIXME: could we make octave_value::subsref a const method?
-// It would be difficult because there are instances of
-// incrementing the reference count inside subsref methods,
-// which means they can't be const with the current way of
-// handling reference counting.
-octave_value xval = val;
-return xval.subsref ("(", arg_list, nargout);
-}
-else if (val.is_string ())
-{
-return feval (val.string_value (), args, nargout);
-}
-else
-error ("feval: first argument must be a string, inline function, or a function handle");
 return ovl ();
-}
+if (val.is_function ())
-//! Evaluate an Octave function (built-in or interpreted) and return
+{
-//! the list of result values.
+return feval (val.function_value (), args, nargout);
-//!
+}
-//! @param args The first element of @c args is the function to call.
+else if (val.is_function_handle () || val.is_inline_function ())
-//!             It may be the name of the function as a string, a function
+{
-//!             handle, or an inline function.  The remaining arguments are
+// This covers function handles, inline functions, and anonymous
-//!             passed to the function.
+//  functions.
-//! @param nargout The number of output arguments expected.
-//! @return A list of output values.  The length of the list is not
+std::list<octave_value_list> arg_list;
-//!         necessarily the same as @c nargout.
+arg_list.push_back (args);
-octave_value_list interpreter::feval (const octave_value_list& args,
+// FIXME: could we make octave_value::subsref a const method?
-int nargout)
+// It would be difficult because there are instances of
-{
+// incrementing the reference count inside subsref methods,
-if (args.length () == 0)
+// which means they can't be const with the current way of
-error ("feval: first argument must be a string, inline function, or a function handle");
+// handling reference counting.
-octave_value f_arg = args(0);
+octave_value xval = val;
+return xval.subsref ("(", arg_list, nargout);
-octave_value_list tmp_args = args.slice (1, args.length () - 1, true);
+}
+else if (val.is_string ())
-return feval (f_arg, tmp_args, nargout);
+{
-}
+return feval (val.string_value (), args, nargout);
+}
-octave_value interpreter::make_function_handle (const std::string& name)
+else
-{
+error ("feval: first argument must be a string, inline function, or a function handle");
-return m_evaluator.make_fcn_handle (name);
-}
+return ovl ();
+}
-void interpreter::install_variable (const std::string& name,
-const octave_value& value, bool global)
+//! Evaluate an Octave function (built-in or interpreted) and return
-{
+//! the list of result values.
-m_evaluator.install_variable (name, value, global);
+//!
-}
+//! @param args The first element of @c args is the function to call.
+//!             It may be the name of the function as a string, a function
-octave_value interpreter::global_varval (const std::string& name) const
+//!             handle, or an inline function.  The remaining arguments are
-{
+//!             passed to the function.
-return m_evaluator.global_varval (name);
+//! @param nargout The number of output arguments expected.
-}
+//! @return A list of output values.  The length of the list is not
+//!         necessarily the same as @c nargout.
-void interpreter::global_assign (const std::string& name,
-const octave_value& val)
+octave_value_list interpreter::feval (const octave_value_list& args,
-{
+int nargout)
-m_evaluator.global_assign (name, val);
+{
-}
+if (args.length () == 0)
+error ("feval: first argument must be a string, inline function, or a function handle");
-octave_value interpreter::top_level_varval (const std::string& name) const
-{
+octave_value f_arg = args(0);
-return m_evaluator.top_level_varval (name);
-}
+octave_value_list tmp_args = args.slice (1, args.length () - 1, true);
-void interpreter::top_level_assign (const std::string& name,
+return feval (f_arg, tmp_args, nargout);
-const octave_value& val)
+}
-{
-m_evaluator.top_level_assign (name, val);
+octave_value interpreter::make_function_handle (const std::string& name)
-}
+{
+return m_evaluator.make_fcn_handle (name);
-bool interpreter::is_variable (const std::string& name) const
+}
-{
-return m_evaluator.is_variable (name);
+void interpreter::install_variable (const std::string& name,
-}
+const octave_value& value, bool global)
+{
-bool interpreter::is_local_variable (const std::string& name) const
+m_evaluator.install_variable (name, value, global);
-{
+}
-return m_evaluator.is_local_variable (name);
-}
+octave_value interpreter::global_varval (const std::string& name) const
+{
-octave_value interpreter::varval (const std::string& name) const
+return m_evaluator.global_varval (name);
-{
+}
-return m_evaluator.varval (name);
-}
+void interpreter::global_assign (const std::string& name,
+const octave_value& val)
-void interpreter::assign (const std::string& name,
+{
+m_evaluator.global_assign (name, val);
+}
+octave_value interpreter::top_level_varval (const std::string& name) const
+{
+return m_evaluator.top_level_varval (name);
+}
+void interpreter::top_level_assign (const std::string& name,
+const octave_value& val)
+{
+m_evaluator.top_level_assign (name, val);
+}
+bool interpreter::is_variable (const std::string& name) const
+{
+return m_evaluator.is_variable (name);
+}
+bool interpreter::is_local_variable (const std::string& name) const
+{
+return m_evaluator.is_local_variable (name);
+}
+octave_value interpreter::varval (const std::string& name) const
+{
+return m_evaluator.varval (name);
+}
+void interpreter::assign (const std::string& name,
+const octave_value& val)
+{
+m_evaluator.assign (name, val);
+}
+void interpreter::assignin (const std::string& context,
+const std::string& name,
 const octave_value& val)
 {
-m_evaluator.assign (name, val);
+m_evaluator.assignin (context, name, val);
 }
-void interpreter::assignin (const std::string& context,
+void interpreter::source_file (const std::string& file_name,
-const std::string& name,
+const std::string& context, bool verbose,
-const octave_value& val)
+bool require_file)
 {
-m_evaluator.assignin (context, name, val);
+m_evaluator.source_file (file_name, context, verbose, require_file);
 }
-void interpreter::source_file (const std::string& file_name,
+bool interpreter::at_top_level (void) const
-const std::string& context, bool verbose,
+{
-bool require_file)
+return m_evaluator.at_top_level ();
-{
+}
-m_evaluator.source_file (file_name, context, verbose, require_file);
-}
+bool interpreter::isglobal (const std::string& name) const
+{
-bool interpreter::at_top_level (void) const
+return m_evaluator.is_global (name);
-{
+}
-return m_evaluator.at_top_level ();
-}
+octave_value interpreter::find (const std::string& name)
+{
-bool interpreter::isglobal (const std::string& name) const
+return m_evaluator.find (name);
-{
+}
-return m_evaluator.is_global (name);
-}
+void interpreter::clear_all (bool force)
+{
-octave_value interpreter::find (const std::string& name)
+m_evaluator.clear_all (force);
-{
+}
-return m_evaluator.find (name);
-}
+void interpreter::clear_objects (void)
+{
-void interpreter::clear_all (bool force)
+m_evaluator.clear_objects ();
-{
+}
-m_evaluator.clear_all (force);
-}
+void interpreter::clear_variable (const std::string& name)
+{
-void interpreter::clear_objects (void)
+m_evaluator.clear_variable (name);
-{
+}
-m_evaluator.clear_objects ();
-}
+void interpreter::clear_variable_pattern (const std::string& pattern)
+{
-void interpreter::clear_variable (const std::string& name)
+m_evaluator.clear_variable_pattern (pattern);
-{
+}
-m_evaluator.clear_variable (name);
-}
+void interpreter::clear_variable_regexp (const std::string& pattern)
+{
-void interpreter::clear_variable_pattern (const std::string& pattern)
+m_evaluator.clear_variable_regexp (pattern);
-{
+}
-m_evaluator.clear_variable_pattern (pattern);
-}
+void interpreter::clear_variables (void)
+{
-void interpreter::clear_variable_regexp (const std::string& pattern)
+m_evaluator.clear_variables ();
-{
+}
-m_evaluator.clear_variable_regexp (pattern);
-}
+void interpreter::clear_global_variable (const std::string& name)
+{
-void interpreter::clear_variables (void)
+m_evaluator.clear_global_variable (name);
-{
+}
-m_evaluator.clear_variables ();
-}
+void interpreter::clear_global_variable_pattern (const std::string& pattern)
+{
-void interpreter::clear_global_variable (const std::string& name)
+m_evaluator.clear_global_variable_pattern (pattern);
-{
+}
-m_evaluator.clear_global_variable (name);
-}
+void interpreter::clear_global_variable_regexp (const std::string& pattern)
+{
-void interpreter::clear_global_variable_pattern (const std::string& pattern)
+m_evaluator.clear_global_variable_regexp (pattern);
-{
+}
-m_evaluator.clear_global_variable_pattern (pattern);
-}
+void interpreter::clear_global_variables (void)
+{
-void interpreter::clear_global_variable_regexp (const std::string& pattern)
+m_evaluator.clear_global_variables ();
-{
+}
-m_evaluator.clear_global_variable_regexp (pattern);
-}
+void interpreter::clear_functions (bool force)
+{
-void interpreter::clear_global_variables (void)
+m_symbol_table.clear_functions (force);
-{
+}
-m_evaluator.clear_global_variables ();
-}
+void interpreter::clear_function (const std::string& name)
+{
-void interpreter::clear_functions (bool force)
+m_symbol_table.clear_function (name);
-{
+}
-m_symbol_table.clear_functions (force);
-}
+void interpreter::clear_symbol (const std::string& name)
+{
-void interpreter::clear_function (const std::string& name)
+m_evaluator.clear_symbol (name);
-{
+}
-m_symbol_table.clear_function (name);
-}
+void interpreter::clear_function_pattern (const std::string& pat)
+{
-void interpreter::clear_symbol (const std::string& name)
+m_symbol_table.clear_function_pattern (pat);
-{
+}
-m_evaluator.clear_symbol (name);
-}
+void interpreter::clear_function_regexp (const std::string& pat)
+{
-void interpreter::clear_function_pattern (const std::string& pat)
+m_symbol_table.clear_function_regexp (pat);
-{
+}
-m_symbol_table.clear_function_pattern (pat);
-}
+void interpreter::clear_symbol_pattern (const std::string& pat)
+{
-void interpreter::clear_function_regexp (const std::string& pat)
+return m_evaluator.clear_symbol_pattern (pat);
-{
+}
-m_symbol_table.clear_function_regexp (pat);
-}
+void interpreter::clear_symbol_regexp (const std::string& pat)
+{
-void interpreter::clear_symbol_pattern (const std::string& pat)
+return m_evaluator.clear_symbol_regexp (pat);
-{
+}
-return m_evaluator.clear_symbol_pattern (pat);
-}
+std::list<std::string> interpreter::global_variable_names (void)
+{
-void interpreter::clear_symbol_regexp (const std::string& pat)
+return m_evaluator.global_variable_names ();
-{
+}
-return m_evaluator.clear_symbol_regexp (pat);
-}
+std::list<std::string> interpreter::top_level_variable_names (void)
+{
-std::list<std::string> interpreter::global_variable_names (void)
+return m_evaluator.top_level_variable_names ();
-{
+}
-return m_evaluator.global_variable_names ();
-}
+std::list<std::string> interpreter::variable_names (void)
+{
-std::list<std::string> interpreter::top_level_variable_names (void)
+return m_evaluator.variable_names ();
-{
+}
-return m_evaluator.top_level_variable_names ();
-}
+std::list<std::string> interpreter::user_function_names (void)
+{
-std::list<std::string> interpreter::variable_names (void)
+return m_symbol_table.user_function_names ();
-{
+}
-return m_evaluator.variable_names ();
-}
+std::list<std::string> interpreter::autoloaded_functions (void) const
+{
-std::list<std::string> interpreter::user_function_names (void)
+return m_evaluator.autoloaded_functions ();
-{
+}
-return m_symbol_table.user_function_names ();
-}
+// May be used to send an interrupt signal to the the interpreter from
+// another thread (for example, the GUI).
-std::list<std::string> interpreter::autoloaded_functions (void) const
-{
+void interpreter::interrupt (void)
-return m_evaluator.autoloaded_functions ();
+{
-}
+static int sigint = 0;
+static bool first = true;
-// May be used to send an interrupt signal to the the interpreter from
-// another thread (for example, the GUI).
+if (first)
+{
-void interpreter::interrupt (void)
+octave_get_sig_number ("SIGINT", &sigint);
-{
+first = false;
-static int sigint = 0;
+}
-static bool first = true;
+// Send SIGINT to Octave and (optionally) all other processes in its
-if (first)
+// process group.  The signal handler for SIGINT will set a global
-{
+// variable indicating an interrupt has happened.  That variable is
-octave_get_sig_number ("SIGINT", &sigint);
+// checked in many places in the Octave interpreter and eventually
-first = false;
+// results in an interrupt_exception being thrown.  Finally, that
-}
+// exception is caught and returns control to one of the
+// read-eval-print loops or to the server loop.  We use a signal
-// Send SIGINT to Octave and (optionally) all other processes in its
+// instead of just setting the global variables here so that we will
-// process group.  The signal handler for SIGINT will set a global
+// probably send interrupt signals to any subprocesses as well as
-// variable indicating an interrupt has happened.  That variable is
+// interrupt execution of the interpreter.
-// checked in many places in the Octave interpreter and eventually
-// results in an interrupt_exception being thrown.  Finally, that
+pid_t pid
-// exception is caught and returns control to one of the
+= m_interrupt_all_in_process_group ? 0 : octave_getpid_wrapper ();
-// read-eval-print loops or to the server loop.  We use a signal
-// instead of just setting the global variables here so that we will
+octave_kill_wrapper (pid, sigint);
-// probably send interrupt signals to any subprocesses as well as
+}
-// interrupt execution of the interpreter.
+void interpreter::pause (void)
-pid_t pid
+{
-= m_interrupt_all_in_process_group ? 0 : octave_getpid_wrapper ();
+// FIXME: To be reliable, these tree_evaluator functions must be
+// made thread safe.
-octave_kill_wrapper (pid, sigint);
-}
+m_evaluator.break_on_next_statement (true);
+m_evaluator.reset_debug_state ();
-void interpreter::pause (void)
+}
-{
-// FIXME: To be reliable, these tree_evaluator functions must be
+void interpreter::stop (void)
-// made thread safe.
+{
+// FIXME: To be reliable, these tree_evaluator functions must be
-m_evaluator.break_on_next_statement (true);
+// made thread safe.
-m_evaluator.reset_debug_state ();
-}
+if (m_evaluator.in_debug_repl ())
+m_evaluator.dbquit (true);
-void interpreter::stop (void)
+else
-{
+interrupt ();
-// FIXME: To be reliable, these tree_evaluator functions must be
+}
-// made thread safe.
+void interpreter::resume (void)
-if (m_evaluator.in_debug_repl ())
+{
-m_evaluator.dbquit (true);
+// FIXME: To be reliable, these tree_evaluator functions must be
-else
+// made thread safe.
-interrupt ();
-}
+// FIXME: Should there be any feeback about not doing anything if
+// not in debug mode?
-void interpreter::resume (void)
-{
+if (m_evaluator.in_debug_repl ())
-// FIXME: To be reliable, these tree_evaluator functions must be
+m_evaluator.dbcont ();
-// made thread safe.
+}
-// FIXME: Should there be any feeback about not doing anything if
+// Provided for convenience.  Will be removed once we eliminate the
-// not in debug mode?
+// old terminal widget.
+bool interpreter::experimental_terminal_widget (void) const
-if (m_evaluator.in_debug_repl ())
+{
-m_evaluator.dbcont ();
+if (! m_app_context)
-}
+return false;
-// Provided for convenience.  Will be removed once we eliminate the
+// Embedded interpreters don't execute command line options.
-// old terminal widget.
+const cmdline_options& options = m_app_context->options ();
-bool interpreter::experimental_terminal_widget (void) const
-{
+return options.experimental_terminal_widget ();
-if (! m_app_context)
+}
-return false;
+void interpreter::add_debug_watch_expression (const std::string& expr)
-// Embedded interpreters don't execute command line options.
+{
-const cmdline_options& options = m_app_context->options ();
+m_evaluator.add_debug_watch_expression (expr);
+}
-return options.experimental_terminal_widget ();
-}
+void interpreter::remove_debug_watch_expression (const std::string& expr)
+{
-void interpreter::add_debug_watch_expression (const std::string& expr)
+m_evaluator.remove_debug_watch_expression (expr);
-{
+}
-m_evaluator.add_debug_watch_expression (expr);
-}
+void interpreter::clear_debug_watch_expressions (void)
+{
-void interpreter::remove_debug_watch_expression (const std::string& expr)
+m_evaluator.clear_debug_watch_expressions ();
-{
+}
-m_evaluator.remove_debug_watch_expression (expr);
-}
+std::set<std::string> interpreter::debug_watch_expressions (void) const
+{
-void interpreter::clear_debug_watch_expressions (void)
+return m_evaluator.debug_watch_expressions ();
-{
+}
-m_evaluator.clear_debug_watch_expressions ();
-}
+void interpreter::handle_exception (const execution_exception& ee)
+{
-std::set<std::string> interpreter::debug_watch_expressions (void) const
+m_error_system.save_exception (ee);
-{
-return m_evaluator.debug_watch_expressions ();
+// FIXME: use a separate stream instead of std::cerr directly so that
-}
+// error messages can be redirected more easily?  Pass the message
+// to an event manager function?
-void interpreter::handle_exception (const execution_exception& ee)
+m_error_system.display_exception (ee);
-{
-m_error_system.save_exception (ee);
+recover_from_exception ();
+}
-// FIXME: use a separate stream instead of std::cerr directly so that
-// error messages can be redirected more easily?  Pass the message
+void interpreter::recover_from_exception (void)
-// to an event manager function?
+{
-m_error_system.display_exception (ee);
+if (octave_interrupt_state)
+m_event_manager.interpreter_interrupted ();
-recover_from_exception ();
-}
+can_interrupt = true;
+octave_interrupt_state = 0;
-void interpreter::recover_from_exception (void)
+octave_signal_caught = 0;
-{
+octave_restore_signal_mask ();
-if (octave_interrupt_state)
+catch_interrupts ();
-m_event_manager.interpreter_interrupted ();
+}
-can_interrupt = true;
+void interpreter::mark_for_deletion (const std::string& file)
-octave_interrupt_state = 0;
+{
-octave_signal_caught = 0;
+m_tmp_files.insert (file);
-octave_restore_signal_mask ();
+}
-catch_interrupts ();
-}
+void interpreter::cleanup_tmp_files (void)
+{
-void interpreter::mark_for_deletion (const std::string& file)
+m_tmp_files.cleanup ();
-{
+}
-m_tmp_files.insert (file);
-}
+void interpreter::quit (int exit_status, bool force, bool confirm)
+{
-void interpreter::cleanup_tmp_files (void)
+if (! force)
 {
-m_tmp_files.cleanup ();
+try
-}
+{
+bool cancel = false;
-void interpreter::quit (int exit_status, bool force, bool confirm)
-{
+if (symbol_exist ("finish.m", "file"))
-if (! force)
+{
-{
+unwind_protect_var<bool> upv1 (m_executing_finish_script, true);
-try
+unwind_protect_var<bool> upv2 (m_cancel_quit);
-{
-bool cancel = false;
+evalin ("base", "finish", 0);
-if (symbol_exist ("finish.m", "file"))
+cancel = m_cancel_quit;
-{
+}
-unwind_protect_var<bool> upv1 (m_executing_finish_script, true);
-unwind_protect_var<bool> upv2 (m_cancel_quit);
+if (cancel)
+return;
-evalin ("base", "finish", 0);
+// Check for confirmation.
-cancel = m_cancel_quit;
-}
+if (confirm && ! m_event_manager.confirm_shutdown ())
+return;
-if (cancel)
+}
-return;
+catch (const execution_exception&)
+{
-// Check for confirmation.
+// Catch execution_exceptions so we don't throw an
+// exit_exception if there is an in finish.m.  But throw it
-if (confirm && ! m_event_manager.confirm_shutdown ())
+// again so that will be handled as any other
-return;
+// execution_exception by the evaluator.  This way, errors
-}
+// will be ignored properly and we won't exit if quit is
-catch (const execution_exception&)
+// called recursively from finish.m.
-{
-// Catch execution_exceptions so we don't throw an
+throw;
-// exit_exception if there is an in finish.m.  But throw it
+}
-// again so that will be handled as any other
+}
-// execution_exception by the evaluator.  This way, errors
-// will be ignored properly and we won't exit if quit is
+throw exit_exception (exit_status);
-// called recursively from finish.m.
+}
-throw;
+void interpreter::add_atexit_fcn (const std::string& fname)
-}
+{
-}
+if (m_executing_atexit)
+return;
-throw exit_exception (exit_status);
-}
+m_atexit_fcns.push_front (fname);
+}
-void interpreter::add_atexit_fcn (const std::string& fname)
-{
+bool interpreter::remove_atexit_fcn (const std::string& fname)
-if (m_executing_atexit)
+{
-return;
+bool found = false;
-m_atexit_fcns.push_front (fname);
+for (auto it = m_atexit_fcns.begin ();
-}
+it != m_atexit_fcns.end (); it++)
+{
-bool interpreter::remove_atexit_fcn (const std::string& fname)
+if (*it == fname)
 {
-bool found = false;
+m_atexit_fcns.erase (it);
+found = true;
-for (auto it = m_atexit_fcns.begin ();
+break;
-it != m_atexit_fcns.end (); it++)
+}
-{
+}
-if (*it == fname)
-{
+return found;
-m_atexit_fcns.erase (it);
+}
-found = true;
-break;
+// What internal options get configured by --traditional.
-}
-}
+void interpreter::maximum_braindamage (void)
+{
-return found;
+m_input_system.PS1 (">> ");
-}
+m_input_system.PS2 ("");
-// What internal options get configured by --traditional.
+m_evaluator.PS4 ("");
-void interpreter::maximum_braindamage (void)
+m_load_save_system.crash_dumps_octave_core (false);
-{
+m_load_save_system.save_default_options ("-mat-binary");
-m_input_system.PS1 (">> ");
-m_input_system.PS2 ("");
+m_history_system.timestamp_format_string ("%%-- %D %I:%M %p --%%");
-m_evaluator.PS4 ("");
+m_error_system.beep_on_error (true);
-m_load_save_system.crash_dumps_octave_core (false);
+Fconfirm_recursive_rmdir (octave_value (false));
-m_load_save_system.save_default_options ("-mat-binary");
+Foptimize_diagonal_matrix (octave_value (false));
+Foptimize_permutation_matrix (octave_value (false));
-m_history_system.timestamp_format_string ("%%-- %D %I:%M %p --%%");
+Foptimize_range (octave_value (false));
+Ffixed_point_format (octave_value (true));
-m_error_system.beep_on_error (true);
+Fprint_empty_dimensions (octave_value (false));
+Fprint_struct_array_contents (octave_value (true));
-Fconfirm_recursive_rmdir (octave_value (false));
+Fstruct_levels_to_print (octave_value (0));
-Foptimize_diagonal_matrix (octave_value (false));
-Foptimize_permutation_matrix (octave_value (false));
+m_error_system.disable_warning ("Octave:abbreviated-property-match");
-Foptimize_range (octave_value (false));
+m_error_system.disable_warning ("Octave:colon-nonscalar-argument");
-Ffixed_point_format (octave_value (true));
+m_error_system.disable_warning ("Octave:data-file-in-path");
-Fprint_empty_dimensions (octave_value (false));
+m_error_system.disable_warning ("Octave:empty-index");
-Fprint_struct_array_contents (octave_value (true));
+m_error_system.disable_warning ("Octave:function-name-clash");
-Fstruct_levels_to_print (octave_value (0));
+m_error_system.disable_warning ("Octave:possible-matlab-short-circuit-operator");
+}
-m_error_system.disable_warning ("Octave:abbreviated-property-match");
-m_error_system.disable_warning ("Octave:colon-nonscalar-argument");
+void interpreter::execute_pkg_add (const std::string& dir)
-m_error_system.disable_warning ("Octave:data-file-in-path");
+{
-m_error_system.disable_warning ("Octave:empty-index");
+try
-m_error_system.disable_warning ("Octave:function-name-clash");
+{
-m_error_system.disable_warning ("Octave:possible-matlab-short-circuit-operator");
+m_load_path.execute_pkg_add (dir);
 }
+catch (const interrupt_exception&)
-void interpreter::execute_pkg_add (const std::string& dir)
+{
-{
+recover_from_exception ();
-try
+}
-{
+catch (const execution_exception& ee)
-m_load_path.execute_pkg_add (dir);
+{
-}
+handle_exception (ee);
-catch (const interrupt_exception&)
+}
-{
+}
-recover_from_exception ();
-}
-catch (const execution_exception& ee)
-{
-handle_exception (ee);
-}
-}
 OCTAVE_END_NAMESPACE(octave)

Mercurial > octave

comparison libinterp/corefcn/interpreter.cc @ 31607:aac27ad79be6 stable