--- a/libinterp/corefcn/interpreter.h	Thu Dec 01 14:23:45 2022 -0800
+++ b/libinterp/corefcn/interpreter.h	Thu Dec 01 18:02:15 2022 -0800
@@ -72,581 +72,581 @@
 
 OCTAVE_BEGIN_NAMESPACE(octave)
 
-  class profiler;
-  class child_list;
-  class push_parser;
+class profiler;
+class child_list;
+class push_parser;
 
-  // The time we last time we changed directories.
-  extern sys::time Vlast_chdir_time;
+// The time we last time we changed directories.
+extern sys::time Vlast_chdir_time;
 
-  // The application object contains a pointer to the current
-  // interpreter and the interpreter contains a pointer back to the
-  // application context so we need a forward declaration for one (or
-  // both) of them...
+// The application object contains a pointer to the current
+// interpreter and the interpreter contains a pointer back to the
+// application context so we need a forward declaration for one (or
+// both) of them...
 
-  class application;
+class application;
+
+class temporary_file_list
+{
+public:
 
-  class temporary_file_list
-  {
-  public:
+  temporary_file_list (void) : m_files () { }
+
+  // No copying!
 
-    temporary_file_list (void) : m_files () { }
+  temporary_file_list (const temporary_file_list&) = delete;
 
-    // No copying!
-
-    temporary_file_list (const temporary_file_list&) = delete;
+  temporary_file_list& operator = (const temporary_file_list&) = delete;
 
-    temporary_file_list& operator = (const temporary_file_list&) = delete;
+  ~temporary_file_list (void);
 
-    ~temporary_file_list (void);
+  void insert (const std::string& file);
 
-    void insert (const std::string& file);
+  void cleanup (void);
 
-    void cleanup (void);
+private:
 
-  private:
+  // List of temporary files to delete when we exit.
+  std::set<std::string> m_files;
 
-    // List of temporary files to delete when we exit.
-    std::set<std::string> m_files;
+};
 
-  };
+class OCTINTERP_API interpreter
+{
+public:
 
-  class OCTINTERP_API interpreter
-  {
-  public:
+  // Create an interpreter object and perform basic initialization.
 
-    // Create an interpreter object and perform basic initialization.
+  interpreter (application *app_context = nullptr);
 
-    interpreter (application *app_context = nullptr);
+  // No copying, at least not yet...
 
-    // No copying, at least not yet...
+  interpreter (const interpreter&) = delete;
 
-    interpreter (const interpreter&) = delete;
+  interpreter& operator = (const interpreter&) = delete;
 
-    interpreter& operator = (const interpreter&) = delete;
+  // Clean up the interpreter object.
 
-    // Clean up the interpreter object.
+  ~interpreter (void);
 
-    ~interpreter (void);
+  void intern_nargin (octave_idx_type nargs);
 
-    void intern_nargin (octave_idx_type nargs);
+  // If creating an embedded interpreter, you may inhibit reading
+  // the command history file by calling initialize_history with
+  // read_history_file = false prior to calling initialize.
 
-    // If creating an embedded interpreter, you may inhibit reading
-    // the command history file by calling initialize_history with
-    // read_history_file = false prior to calling initialize.
+  void initialize_history (bool read_history_file = false);
 
-    void initialize_history (bool read_history_file = false);
+  // If creating an embedded interpreter, you may inhibit setting
+  // the default compiled-in path by calling initialize_load_path
+  // with set_initial_path = false prior calling initialize.  After
+  // that, you can add directories to the load path to set up a
+  // custom path.
 
-    // If creating an embedded interpreter, you may inhibit setting
-    // the default compiled-in path by calling initialize_load_path
-    // with set_initial_path = false prior calling initialize.  After
-    // that, you can add directories to the load path to set up a
-    // custom path.
+  void initialize_load_path (bool set_initial_path = true);
 
-    void initialize_load_path (bool set_initial_path = true);
+  // Load command line history, set the load path.
 
-    // Load command line history, set the load path.
+  void initialize (void);
 
-    void initialize (void);
+  // Note: GET_LINE_AND_EVAL is only used by new experimental terminal
+  // widget.
 
-    // Note: GET_LINE_AND_EVAL is only used by new experimental terminal
-    // widget.
+  void get_line_and_eval (void);
 
-    void get_line_and_eval (void);
+  // Parse a line of input.  If input ends at a complete statement
+  // boundary, execute the resulting parse tree.  Useful to handle
+  // parsing user input when running in server mode.
 
-    // Parse a line of input.  If input ends at a complete statement
-    // boundary, execute the resulting parse tree.  Useful to handle
-    // parsing user input when running in server mode.
+  void parse_and_execute (const std::string& input, bool& incomplete_parse);
 
-    void parse_and_execute (const std::string& input, bool& incomplete_parse);
+  // Initialize the interpreter (if not already done by an explicit
+  // call to initialize), execute startup files, --eval option code,
+  // script files, and/or interactive commands.
 
-    // Initialize the interpreter (if not already done by an explicit
-    // call to initialize), execute startup files, --eval option code,
-    // script files, and/or interactive commands.
+  int execute (void);
+
+  bool server_mode (void) const { return m_evaluator.server_mode (); }
 
-    int execute (void);
-
-    bool server_mode (void) const { return m_evaluator.server_mode (); }
+  bool interactive (void) const
+  {
+    return m_interactive;
+  }
 
-    bool interactive (void) const
-    {
-      return m_interactive;
-    }
+  void interactive (bool arg)
+  {
+    m_interactive = arg;
+  }
 
-    void interactive (bool arg)
-    {
-      m_interactive = arg;
-    }
+  void read_site_files (bool flag)
+  {
+    m_read_site_files = flag;
+  }
 
-    void read_site_files (bool flag)
-    {
-      m_read_site_files = flag;
-    }
+  void read_init_files (bool flag)
+  {
+    m_read_init_files = flag;
+  }
 
-    void read_init_files (bool flag)
-    {
-      m_read_init_files = flag;
-    }
+  void verbose (bool flag)
+  {
+    m_verbose = flag;
+  }
 
-    void verbose (bool flag)
-    {
-      m_verbose = flag;
-    }
+  void traditional (bool flag)
+  {
+    m_traditional = flag;
+  }
 
-    void traditional (bool flag)
-    {
-      m_traditional = flag;
-    }
+  bool traditional (void) const
+  {
+    return m_traditional;
+  }
 
-    bool traditional (void) const
-    {
-      return m_traditional;
-    }
+  void inhibit_startup_message (bool flag)
+  {
+    m_inhibit_startup_message = flag;
+  }
 
-    void inhibit_startup_message (bool flag)
-    {
-      m_inhibit_startup_message = flag;
-    }
+  bool in_top_level_repl (void) const
+  {
+    return m_evaluator.in_top_level_repl ();
+  }
 
-    bool in_top_level_repl (void) const
-    {
-      return m_evaluator.in_top_level_repl ();
-    }
+  bool initialized (void) const
+  {
+    return m_initialized;
+  }
 
-    bool initialized (void) const
-    {
-      return m_initialized;
-    }
+  void interrupt_all_in_process_group (bool b)
+  {
+    m_interrupt_all_in_process_group = b;
+  }
 
-    void interrupt_all_in_process_group (bool b)
-    {
-      m_interrupt_all_in_process_group = b;
-    }
+  bool interrupt_all_in_process_group (void) const
+  {
+    return m_interrupt_all_in_process_group;
+  }
 
-    bool interrupt_all_in_process_group (void) const
-    {
-      return m_interrupt_all_in_process_group;
-    }
+  application * get_app_context (void)
+  {
+    return m_app_context;
+  }
 
-    application *get_app_context (void)
-    {
-      return m_app_context;
-    }
+  display_info& get_display_info (void)
+  {
+    return m_display_info;
+  }
 
-    display_info& get_display_info (void)
-    {
-      return m_display_info;
-    }
-
-    environment& get_environment (void)
-    {
-      return m_environment;
-    }
+  environment& get_environment (void)
+  {
+    return m_environment;
+  }
 
-    settings& get_settings (void)
-    {
-      return m_settings;
-    }
+  settings& get_settings (void)
+  {
+    return m_settings;
+  }
 
-    error_system& get_error_system (void)
-    {
-      return m_error_system;
-    }
+  error_system& get_error_system (void)
+  {
+    return m_error_system;
+  }
+
+  tree_evaluator& get_evaluator (void);
 
-    tree_evaluator& get_evaluator (void);
+  help_system& get_help_system (void)
+  {
+    return m_help_system;
+  }
 
-    help_system& get_help_system (void)
-    {
-      return m_help_system;
-    }
+  input_system& get_input_system (void)
+  {
+    return m_input_system;
+  }
 
-    input_system& get_input_system (void)
-    {
-      return m_input_system;
-    }
+  output_system& get_output_system (void)
+  {
+    return m_output_system;
+  }
 
-    output_system& get_output_system (void)
-    {
-      return m_output_system;
-    }
+  history_system& get_history_system (void)
+  {
+    return m_history_system;
+  }
 
-    history_system& get_history_system (void)
-    {
-      return m_history_system;
-    }
+  dynamic_loader& get_dynamic_loader (void)
+  {
+    return m_dynamic_loader;
+  }
 
-    dynamic_loader& get_dynamic_loader (void)
-    {
-      return m_dynamic_loader;
-    }
+  load_path& get_load_path (void)
+  {
+    return m_load_path;
+  }
 
-    load_path& get_load_path (void)
-    {
-      return m_load_path;
-    }
+  load_save_system& get_load_save_system (void)
+  {
+    return m_load_save_system;
+  }
 
-    load_save_system& get_load_save_system (void)
-    {
-      return m_load_save_system;
-    }
+  type_info& get_type_info (void)
+  {
+    return m_type_info;
+  }
 
-    type_info& get_type_info (void)
-    {
-      return m_type_info;
-    }
+  symbol_table& get_symbol_table (void)
+  {
+    return m_symbol_table;
+  }
+
+  symbol_scope get_top_scope (void) const;
+  symbol_scope get_current_scope (void) const;
+  symbol_scope require_current_scope (const std::string& who) const;
 
-    symbol_table& get_symbol_table (void)
-    {
-      return m_symbol_table;
-    }
+  profiler& get_profiler (void);
+
+  stream_list& get_stream_list (void);
 
-    symbol_scope get_top_scope (void) const;
-    symbol_scope get_current_scope (void) const;
-    symbol_scope require_current_scope (const std::string& who) const;
+  child_list& get_child_list (void)
+  {
+    return m_child_list;
+  }
 
-    profiler& get_profiler (void);
+  url_handle_manager& get_url_handle_manager (void);
 
-    stream_list& get_stream_list (void);
+  cdef_manager& get_cdef_manager (void)
+  {
+    return m_cdef_manager;
+  }
 
-    child_list& get_child_list (void)
-    {
-      return m_child_list;
-    }
-
-    url_handle_manager& get_url_handle_manager (void);
+  gtk_manager& get_gtk_manager (void)
+  {
+    return m_gtk_manager;
+  }
 
-    cdef_manager& get_cdef_manager (void)
-    {
-      return m_cdef_manager;
-    }
+  event_manager& get_event_manager (void)
+  {
+    return m_event_manager;
+  }
 
-    gtk_manager& get_gtk_manager (void)
-    {
-      return m_gtk_manager;
-    }
+  gh_manager& get_gh_manager (void)
+  {
+    return *m_gh_manager;
+  }
 
-    event_manager& get_event_manager (void)
-    {
-      return m_event_manager;
-    }
+  // Any Octave code that needs to change the current directory should
+  // call this function instead of calling the system chdir function
+  // directly so that the  load-path and GUI may be notified of the
+  // change.
 
-    gh_manager& get_gh_manager (void)
-    {
-      return *m_gh_manager;
-    }
+  int chdir (const std::string& dir);
 
-    // Any Octave code that needs to change the current directory should
-    // call this function instead of calling the system chdir function
-    // directly so that the  load-path and GUI may be notified of the
-    // change.
+  void mlock (bool skip_first = false) const;
+  void munlock (bool skip_first = false) const;
+  bool mislocked (bool skip_first = false) const;
 
-    int chdir (const std::string& dir);
+  // NOTE: since we have a version that accepts a bool argument, we
+  // can't rely on automatic conversion from char* to std::string.
+  void munlock (const char *nm);
+  void munlock (const std::string& nm);
 
-    void mlock (bool skip_first = false) const;
-    void munlock (bool skip_first = false) const;
-    bool mislocked (bool skip_first = false) const;
+  bool mislocked (const char *nm);
+  bool mislocked (const std::string& nm);
 
-    // NOTE: since we have a version that accepts a bool argument, we
-    // can't rely on automatic conversion from char* to std::string.
-    void munlock (const char *nm);
-    void munlock (const std::string& nm);
+  std::string mfilename (const std::string& opt = "") const;
+
+  octave_value_list eval_string (const std::string& eval_str, bool silent,
+                                 int& parse_status, int nargout);
 
-    bool mislocked (const char *nm);
-    bool mislocked (const std::string& nm);
+  octave_value eval_string (const std::string& eval_str, bool silent,
+                            int& parse_status);
 
-    std::string mfilename (const std::string& opt = "") const;
+  octave_value_list eval_string (const octave_value& arg, bool silent,
+                                 int& parse_status, int nargout);
 
-    octave_value_list eval_string (const std::string& eval_str, bool silent,
-                                   int& parse_status, int nargout);
+  octave_value_list eval (const std::string& try_code, int nargout);
 
-    octave_value eval_string (const std::string& eval_str, bool silent,
-                              int& parse_status);
+  octave_value_list eval (const std::string& try_code,
+                          const std::string& catch_code, int nargout);
 
-    octave_value_list eval_string (const octave_value& arg, bool silent,
-                                   int& parse_status, int nargout);
+  octave_value_list evalin (const std::string& context,
+                            const std::string& try_code, int nargout);
 
-    octave_value_list eval (const std::string& try_code, int nargout);
-
-    octave_value_list eval (const std::string& try_code,
+  octave_value_list evalin (const std::string& context,
+                            const std::string& try_code,
                             const std::string& catch_code, int nargout);
 
-    octave_value_list evalin (const std::string& context,
-                              const std::string& try_code, int nargout);
+  octave_value_list
+  feval (const char *name,
+         const octave_value_list& args = octave_value_list (),
+         int nargout = 0);
 
-    octave_value_list evalin (const std::string& context,
-                              const std::string& try_code,
-                              const std::string& catch_code, int nargout);
-
-    octave_value_list
-    feval (const char *name,
-           const octave_value_list& args = octave_value_list (),
-           int nargout = 0);
+  octave_value_list
+  feval (const std::string& name,
+         const octave_value_list& args = octave_value_list (),
+         int nargout = 0);
 
-    octave_value_list
-    feval (const std::string& name,
-           const octave_value_list& args = octave_value_list (),
-           int nargout = 0);
+  octave_value_list
+  feval (octave_function *fcn,
+         const octave_value_list& args = octave_value_list (),
+         int nargout = 0);
 
-    octave_value_list
-    feval (octave_function *fcn,
-           const octave_value_list& args = octave_value_list (),
-           int nargout = 0);
+  octave_value_list
+  feval (const octave_value& f_arg,
+         const octave_value_list& args = octave_value_list (),
+         int nargout = 0);
 
-    octave_value_list
-    feval (const octave_value& f_arg,
-           const octave_value_list& args = octave_value_list (),
-           int nargout = 0);
+  octave_value_list feval (const octave_value_list& args, int nargout = 0);
+
+  octave_value make_function_handle (const std::string& name);
 
-    octave_value_list feval (const octave_value_list& args, int nargout = 0);
+  void install_variable (const std::string& name, const octave_value& value,
+                         bool global);
 
-    octave_value make_function_handle (const std::string& name);
+  void set_global_value (const std::string& name, const octave_value& value);
 
-    void install_variable (const std::string& name, const octave_value& value,
-                           bool global);
+  octave_value global_varval (const std::string& name) const;
 
-    void set_global_value (const std::string& name, const octave_value& value);
+  void global_assign (const std::string& name,
+                      const octave_value& val = octave_value ());
 
-    octave_value global_varval (const std::string& name) const;
+  octave_value top_level_varval (const std::string& name) const;
 
-    void global_assign (const std::string& name,
-                        const octave_value& val = octave_value ());
+  void top_level_assign (const std::string& name,
+                         const octave_value& val = octave_value ());
 
-    octave_value top_level_varval (const std::string& name) const;
+  bool is_variable (const std::string& name) const;
 
-    void top_level_assign (const std::string& name,
-                           const octave_value& val = octave_value ());
+  bool is_local_variable (const std::string& name) const;
 
-    bool is_variable (const std::string& name) const;
-
-    bool is_local_variable (const std::string& name) const;
+  octave_value varval (const std::string& name) const;
 
-    octave_value varval (const std::string& name) const;
+  void assign (const std::string& name,
+               const octave_value& val = octave_value ());
 
-    void assign (const std::string& name,
+  void assignin (const std::string& context, const std::string& varname,
                  const octave_value& val = octave_value ());
 
-    void assignin (const std::string& context, const std::string& varname,
-                   const octave_value& val = octave_value ());
+  void source_file (const std::string& file_name,
+                    const std::string& context = "",
+                    bool verbose = false, bool require_file = true);
+
+  bool at_top_level (void) const;
 
-    void source_file (const std::string& file_name,
-                      const std::string& context = "",
-                      bool verbose = false, bool require_file = true);
+  bool isglobal (const std::string& name) const;
 
-    bool at_top_level (void) const;
+  octave_value find (const std::string& name);
 
-    bool isglobal (const std::string& name) const;
-
-    octave_value find (const std::string& name);
+  void clear_all (bool force = false);
 
-    void clear_all (bool force = false);
+  void clear_objects (void);
 
-    void clear_objects (void);
+  void clear_variable (const std::string& name);
 
-    void clear_variable (const std::string& name);
+  void clear_variable_pattern (const std::string& pattern);
 
-    void clear_variable_pattern (const std::string& pattern);
+  void clear_variable_regexp (const std::string& pattern);
 
-    void clear_variable_regexp (const std::string& pattern);
+  void clear_variables (void);
 
-    void clear_variables (void);
+  void clear_global_variable (const std::string& name);
 
-    void clear_global_variable (const std::string& name);
+  void clear_global_variable_pattern (const std::string& pattern);
 
-    void clear_global_variable_pattern (const std::string& pattern);
+  void clear_global_variable_regexp (const std::string& pattern);
 
-    void clear_global_variable_regexp (const std::string& pattern);
+  void clear_global_variables (void);
 
-    void clear_global_variables (void);
+  void clear_functions (bool force = false);
 
-    void clear_functions (bool force = false);
+  void clear_function (const std::string& name);
 
-    void clear_function (const std::string& name);
+  void clear_symbol (const std::string& name);
 
-    void clear_symbol (const std::string& name);
+  void clear_function_pattern (const std::string& pat);
 
-    void clear_function_pattern (const std::string& pat);
+  void clear_function_regexp (const std::string& pat);
 
-    void clear_function_regexp (const std::string& pat);
+  void clear_symbol_pattern (const std::string& pat);
 
-    void clear_symbol_pattern (const std::string& pat);
+  void clear_symbol_regexp (const std::string& pat);
 
-    void clear_symbol_regexp (const std::string& pat);
+  std::list<std::string> variable_names (void);
 
-    std::list<std::string> variable_names (void);
+  std::list<std::string> top_level_variable_names (void);
 
-    std::list<std::string> top_level_variable_names (void);
+  std::list<std::string> global_variable_names (void);
 
-    std::list<std::string> global_variable_names (void);
+  std::list<std::string> user_function_names (void);
 
-    std::list<std::string> user_function_names (void);
+  std::list<std::string> autoloaded_functions (void) const;
 
-    std::list<std::string> autoloaded_functions (void) const;
-
-    void interrupt (void);
+  void interrupt (void);
 
-    // Pause interpreter execution at the next available statement and
-    // enter the debugger.
-    void pause (void);
+  // Pause interpreter execution at the next available statement and
+  // enter the debugger.
+  void pause (void);
 
-    // Exit debugger or stop execution and return to the top-level REPL
-    // or server loop.
-    void stop (void);
+  // Exit debugger or stop execution and return to the top-level REPL
+  // or server loop.
+  void stop (void);
 
-    // Add EXPR to the set of expressions that may be evaluated when the
-    // debugger stops at a breakpoint.
-    void add_debug_watch_expression (const std::string& expr);
+  // Add EXPR to the set of expressions that may be evaluated when the
+  // debugger stops at a breakpoint.
+  void add_debug_watch_expression (const std::string& expr);
 
-    // Remove EXPR from the set of expressions that may be evaluated
-    // when the debugger stops at a breakpoint.
-    void remove_debug_watch_expression (const std::string& expr);
+  // Remove EXPR from the set of expressions that may be evaluated
+  // when the debugger stops at a breakpoint.
+  void remove_debug_watch_expression (const std::string& expr);
 
-    // Clear the set of expressions that may be evaluated when the
-    // debugger stops at a breakpoint.
-    void clear_debug_watch_expressions (void);
+  // Clear the set of expressions that may be evaluated when the
+  // debugger stops at a breakpoint.
+  void clear_debug_watch_expressions (void);
 
-    // Return the set of expressions that may be evaluated when the
-    // debugger stops at a breakpoint.
-    std::set<std::string> debug_watch_expressions (void) const;
+  // Return the set of expressions that may be evaluated when the
+  // debugger stops at a breakpoint.
+  std::set<std::string> debug_watch_expressions (void) const;
 
-    // Resume interpreter execution if paused.
-    void resume (void);
+  // Resume interpreter execution if paused.
+  void resume (void);
+
+  // Provided for convenience.  Will be removed once we eliminate the
+  // old terminal widget.
+  bool experimental_terminal_widget (void) const;
 
-    // Provided for convenience.  Will be removed once we eliminate the
-    // old terminal widget.
-    bool experimental_terminal_widget (void) const;
+  void handle_exception (const execution_exception& ee);
+
+  void recover_from_exception (void);
 
-    void handle_exception (const execution_exception& ee);
+  void mark_for_deletion (const std::string& file);
 
-    void recover_from_exception (void);
-
-    void mark_for_deletion (const std::string& file);
+  void cleanup_tmp_files (void);
 
-    void cleanup_tmp_files (void);
+  void quit (int exit_status, bool force = false, bool confirm = true);
 
-    void quit (int exit_status, bool force = false, bool confirm = true);
-
-    void cancel_quit (bool flag) { m_cancel_quit = flag; }
+  void cancel_quit (bool flag) { m_cancel_quit = flag; }
 
-    bool executing_finish_script (void) const
-    {
-      return m_executing_finish_script;
-    }
+  bool executing_finish_script (void) const
+  {
+    return m_executing_finish_script;
+  }
 
-    void add_atexit_fcn (const std::string& fname);
+  void add_atexit_fcn (const std::string& fname);
 
-    bool remove_atexit_fcn (const std::string& fname);
+  bool remove_atexit_fcn (const std::string& fname);
+
+  static interpreter * the_interpreter (void) { return m_instance; }
 
-    static interpreter * the_interpreter (void) { return m_instance; }
+private:
 
-  private:
+  void display_startup_message (void) const;
 
-    void display_startup_message (void) const;
+  int execute_startup_files (void);
 
-    int execute_startup_files (void);
+  int execute_eval_option_code (void);
 
-    int execute_eval_option_code (void);
+  int execute_command_line_file (void);
 
-    int execute_command_line_file (void);
+  int main_loop (void);
 
-    int main_loop (void);
+  int server_loop (void);
 
-    int server_loop (void);
+  void shutdown (void);
 
-    void shutdown (void);
+  void execute_atexit_fcns (void);
 
-    void execute_atexit_fcns (void);
-
-    void maximum_braindamage (void);
+  void maximum_braindamage (void);
 
-    void execute_pkg_add (const std::string& dir);
+  void execute_pkg_add (const std::string& dir);
 
-    //--------
+  //--------
 
-    // The interpreter instance;  Currently it is only possible to
-    // have one, so OCTAVE_THREAD_LOCAL will normally be defined to be
-    // empty.  Eventually we would like to allow multiple interpreters
-    // to be active at once, but they will still be limited to one per
-    // thread.  When that is possible, OCTAVE_THREAD_LOCAL can be
-    // replaced by the C++ thread_local keyword.  For now, use a macro
-    // to allow experimenting with thread_local storage.
+  // The interpreter instance;  Currently it is only possible to
+  // have one, so OCTAVE_THREAD_LOCAL will normally be defined to be
+  // empty.  Eventually we would like to allow multiple interpreters
+  // to be active at once, but they will still be limited to one per
+  // thread.  When that is possible, OCTAVE_THREAD_LOCAL can be
+  // replaced by the C++ thread_local keyword.  For now, use a macro
+  // to allow experimenting with thread_local storage.
 
-    OCTAVE_THREAD_LOCAL static interpreter *m_instance;
+  OCTAVE_THREAD_LOCAL static interpreter *m_instance;
 
-    application *m_app_context;
+  application *m_app_context;
 
-    temporary_file_list m_tmp_files;
+  temporary_file_list m_tmp_files;
 
-    std::list<std::string> m_atexit_fcns;
+  std::list<std::string> m_atexit_fcns;
 
-    display_info m_display_info;
+  display_info m_display_info;
 
-    environment m_environment;
+  environment m_environment;
 
-    settings m_settings;
+  settings m_settings;
 
-    error_system m_error_system;
+  error_system m_error_system;
 
-    tree_evaluator m_evaluator;
+  tree_evaluator m_evaluator;
 
-    help_system m_help_system;
+  help_system m_help_system;
 
-    input_system m_input_system;
+  input_system m_input_system;
 
-    output_system m_output_system;
+  output_system m_output_system;
 
-    history_system m_history_system;
+  history_system m_history_system;
 
-    dynamic_loader m_dynamic_loader;
+  dynamic_loader m_dynamic_loader;
 
-    load_path m_load_path;
+  load_path m_load_path;
 
-    load_save_system m_load_save_system;
+  load_save_system m_load_save_system;
 
-    type_info m_type_info;
+  type_info m_type_info;
 
-    symbol_table m_symbol_table;
+  symbol_table m_symbol_table;
 
-    stream_list m_stream_list;
+  stream_list m_stream_list;
 
-    child_list m_child_list;
+  child_list m_child_list;
 
-    url_handle_manager m_url_handle_manager;
+  url_handle_manager m_url_handle_manager;
 
-    cdef_manager m_cdef_manager;
+  cdef_manager m_cdef_manager;
 
-    gtk_manager m_gtk_manager;
+  gtk_manager m_gtk_manager;
 
-    event_manager m_event_manager;
+  event_manager m_event_manager;
 
-    gh_manager *m_gh_manager;
+  gh_manager *m_gh_manager;
 
-    // TRUE means this is an interactive interpreter (forced or not).
-    bool m_interactive;
+  // TRUE means this is an interactive interpreter (forced or not).
+  bool m_interactive;
 
-    bool m_read_site_files;
+  bool m_read_site_files;
 
-    bool m_read_init_files;
+  bool m_read_init_files;
 
-    bool m_verbose;
+  bool m_verbose;
 
-    bool m_traditional;
+  bool m_traditional;
 
-    bool m_inhibit_startup_message;
+  bool m_inhibit_startup_message;
 
-    bool m_load_path_initialized;
+  bool m_load_path_initialized;
 
-    bool m_history_initialized;
+  bool m_history_initialized;
 
-    bool m_interrupt_all_in_process_group;
+  bool m_interrupt_all_in_process_group;
 
-    bool m_cancel_quit;
+  bool m_cancel_quit;
 
-    bool m_executing_finish_script;
+  bool m_executing_finish_script;
 
-    bool m_executing_atexit;
+  bool m_executing_atexit;
 
-    bool m_initialized;
-  };
+  bool m_initialized;
+};
 
 OCTAVE_END_NAMESPACE(octave)