////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002-2022 The Octave Project Developers
//
// See the file COPYRIGHT.md in the top-level directory of this
// distribution or <https://octave.org/copyright/>.
//
// This file is part of Octave.
//
// Octave is free software: you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Octave is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Octave; see the file COPYING.  If not, see
// <https://www.gnu.org/licenses/>.
//
////////////////////////////////////////////////////////////////////////

#if ! defined (octave_interpreter_h)
#define octave_interpreter_h 1

#include "octave-config.h"

#include <map>
#include <set>
#include <stack>
#include <string>

#include "child-list.h"
#include "oct-time.h"
#include "quit.h"
#include "str-vec.h"

#include "cdef-manager.h"
#include "display.h"
#include "dynamic-ld.h"
#include "environment.h"
#include "error.h"
#include "event-manager.h"
#include "graphics.h"
#include "gtk-manager.h"
#include "help.h"
#include "input.h"
#include "load-path.h"
#include "load-save.h"
#include "oct-hist.h"
#include "oct-stream.h"
#include "ov-typeinfo.h"
#include "pager.h"
#include "pt-eval.h"
#include "settings.h"
#include "symtab.h"
#include "url-handle-manager.h"

extern OCTINTERP_API bool quit_allowed;

// TRUE means we are ready to interpret commands, but not everything
// is ready for interactive use.
extern OCTINTERP_API bool octave_interpreter_ready;

// TRUE means we've processed all the init code and we are good to go.
extern OCTINTERP_API bool octave_initialized;

#include "oct-time.h"

OCTAVE_BEGIN_NAMESPACE(octave)

  class profiler;
  class child_list;
  class push_parser;

  // 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...

  class application;

  class temporary_file_list
  {
  public:

    temporary_file_list (void) : m_files () { }

    // No copying!

    temporary_file_list (const temporary_file_list&) = delete;

    temporary_file_list& operator = (const temporary_file_list&) = delete;

    ~temporary_file_list (void);

    void insert (const std::string& file);

    void cleanup (void);

  private:

    // List of temporary files to delete when we exit.
    std::set<std::string> m_files;

  };

  class OCTINTERP_API interpreter
  {
  public:

    // Create an interpreter object and perform basic initialization.

    interpreter (application *app_context = nullptr);

    // No copying, at least not yet...

    interpreter (const interpreter&) = delete;

    interpreter& operator = (const interpreter&) = delete;

    // Clean up the interpreter object.

    ~interpreter (void);

    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.

    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.

    void initialize_load_path (bool set_initial_path = true);

    // Load command line history, set the load path.

    void initialize (void);

    // Note: GET_LINE_AND_EVAL is only used by new experimental terminal
    // widget.

    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.

    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.

    int execute (void);

    bool server_mode (void) const { return m_evaluator.server_mode (); }

    bool interactive (void) const
    {
      return m_interactive;
    }

    void interactive (bool arg)
    {
      m_interactive = arg;
    }

    void read_site_files (bool flag)
    {
      m_read_site_files = flag;
    }

    void read_init_files (bool flag)
    {
      m_read_init_files = flag;
    }

    void verbose (bool flag)
    {
      m_verbose = flag;
    }

    void traditional (bool flag)
    {
      m_traditional = flag;
    }

    bool traditional (void) const
    {
      return m_traditional;
    }

    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 initialized (void) const
    {
      return m_initialized;
    }

    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;
    }

    application *get_app_context (void)
    {
      return m_app_context;
    }

    display_info& get_display_info (void)
    {
      return m_display_info;
    }

    environment& get_environment (void)
    {
      return m_environment;
    }

    settings& get_settings (void)
    {
      return m_settings;
    }

    error_system& get_error_system (void)
    {
      return m_error_system;
    }

    tree_evaluator& get_evaluator (void);

    help_system& get_help_system (void)
    {
      return m_help_system;
    }

    input_system& get_input_system (void)
    {
      return m_input_system;
    }

    output_system& get_output_system (void)
    {
      return m_output_system;
    }

    history_system& get_history_system (void)
    {
      return m_history_system;
    }

    dynamic_loader& get_dynamic_loader (void)
    {
      return m_dynamic_loader;
    }

    load_path& get_load_path (void)
    {
      return m_load_path;
    }

    load_save_system& get_load_save_system (void)
    {
      return m_load_save_system;
    }

    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;

    profiler& get_profiler (void);

    stream_list& get_stream_list (void);

    child_list& get_child_list (void)
    {
      return m_child_list;
    }

    url_handle_manager& get_url_handle_manager (void);

    cdef_manager& get_cdef_manager (void)
    {
      return m_cdef_manager;
    }

    gtk_manager& get_gtk_manager (void)
    {
      return m_gtk_manager;
    }

    event_manager& get_event_manager (void)
    {
      return m_event_manager;
    }

    gh_manager& get_gh_manager (void)
    {
      return *m_gh_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.

    int chdir (const std::string& dir);

    void mlock (bool skip_first = false) const;
    void munlock (bool skip_first = false) const;
    bool mislocked (bool skip_first = false) const;

    // 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);

    bool mislocked (const char *nm);
    bool mislocked (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);

    octave_value eval_string (const std::string& eval_str, bool silent,
                              int& parse_status);

    octave_value_list eval_string (const octave_value& arg, bool silent,
                                   int& parse_status, int nargout);

    octave_value_list eval (const std::string& try_code, int nargout);

    octave_value_list eval (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 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 (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_list& args, int nargout = 0);

    octave_value make_function_handle (const std::string& name);

    void install_variable (const std::string& name, const octave_value& value,
                           bool global);

    void set_global_value (const std::string& name, const octave_value& value);

    octave_value global_varval (const std::string& name) const;

    void global_assign (const std::string& name,
                        const octave_value& val = octave_value ());

    octave_value top_level_varval (const std::string& name) const;

    void top_level_assign (const std::string& name,
                           const octave_value& val = octave_value ());

    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;

    void assign (const std::string& name,
                 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;

    bool isglobal (const std::string& name) const;

    octave_value find (const std::string& name);

    void clear_all (bool force = false);

    void clear_objects (void);

    void clear_variable (const std::string& name);

    void clear_variable_pattern (const std::string& pattern);

    void clear_variable_regexp (const std::string& pattern);

    void clear_variables (void);

    void clear_global_variable (const std::string& name);

    void clear_global_variable_pattern (const std::string& pattern);

    void clear_global_variable_regexp (const std::string& pattern);

    void clear_global_variables (void);

    void clear_functions (bool force = false);

    void clear_function (const std::string& name);

    void clear_symbol (const std::string& name);

    void clear_function_pattern (const std::string& pat);

    void clear_function_regexp (const std::string& pat);

    void clear_symbol_pattern (const std::string& pat);

    void clear_symbol_regexp (const std::string& pat);

    std::list<std::string> variable_names (void);

    std::list<std::string> top_level_variable_names (void);

    std::list<std::string> global_variable_names (void);

    std::list<std::string> user_function_names (void);

    std::list<std::string> autoloaded_functions (void) const;

    void interrupt (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);

    // 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);

    // 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;

    // 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;

    void handle_exception (const execution_exception& ee);

    void recover_from_exception (void);

    void mark_for_deletion (const std::string& file);

    void cleanup_tmp_files (void);

    void quit (int exit_status, bool force = false, bool confirm = true);

    void cancel_quit (bool flag) { m_cancel_quit = flag; }

    bool executing_finish_script (void) const
    {
      return m_executing_finish_script;
    }

    void add_atexit_fcn (const std::string& fname);

    bool remove_atexit_fcn (const std::string& fname);

    static interpreter * the_interpreter (void) { return m_instance; }

  private:

    void display_startup_message (void) const;

    int execute_startup_files (void);

    int execute_eval_option_code (void);

    int execute_command_line_file (void);

    int main_loop (void);

    int server_loop (void);

    void shutdown (void);

    void execute_atexit_fcns (void);

    void maximum_braindamage (void);

    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.

    OCTAVE_THREAD_LOCAL static interpreter *m_instance;

    application *m_app_context;

    temporary_file_list m_tmp_files;

    std::list<std::string> m_atexit_fcns;

    display_info m_display_info;

    environment m_environment;

    settings m_settings;

    error_system m_error_system;

    tree_evaluator m_evaluator;

    help_system m_help_system;

    input_system m_input_system;

    output_system m_output_system;

    history_system m_history_system;

    dynamic_loader m_dynamic_loader;

    load_path m_load_path;

    load_save_system m_load_save_system;

    type_info m_type_info;

    symbol_table m_symbol_table;

    stream_list m_stream_list;

    child_list m_child_list;

    url_handle_manager m_url_handle_manager;

    cdef_manager m_cdef_manager;

    gtk_manager m_gtk_manager;

    event_manager m_event_manager;

    gh_manager *m_gh_manager;

    // TRUE means this is an interactive interpreter (forced or not).
    bool m_interactive;

    bool m_read_site_files;

    bool m_read_init_files;

    bool m_verbose;

    bool m_traditional;

    bool m_inhibit_startup_message;

    bool m_load_path_initialized;

    bool m_history_initialized;

    bool m_interrupt_all_in_process_group;

    bool m_cancel_quit;

    bool m_executing_finish_script;

    bool m_executing_atexit;

    bool m_initialized;
  };

OCTAVE_END_NAMESPACE(octave)

#endif