Mercurial > octave

view libinterp/corefcn/interpreter.h @ 23087:9f406f0b36da

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
rework clean_up_and_exit (bug #50068) * quit.h, quit.cc (clean_up_and_exit): Deprecate. Simply exit. * interperter.h, interpreter.cc (safe_source_file): Return status. Simply return 1 if index or other execution exception occurs. Don't catch exit exception here. (Fquit): Throw exit exception instead of calling clean_up_and_exit. (execute_pkg_add): Don't catch exit exception here. (interpreter::cleanup): Rename from clean_up_and_exit. Perform cleanup options but don't exit. Don't call octave_link::process_events. (interpreter::~interpreter): Call cleanup. (interpreter::execute): Catch exit_exception but not execution exceptions when evaluating eval options or executing command line file. Return status instead of calling clean_up_and_exit. (interpreter::execute_eval_option_code): Catch exit exception but not interrupt exception here. (interpreter::execute_command_line_file): Return status. (interpreter::main_loop): If exit exception is caught, don't call clean_up_and_exit, but do call octave_link::exit. Return exit status if octave_link doesn't terminate the process. * octave.h, octave.cc (octave_main): Deprecate. Make application objects static so they persist after function returns. Warn if not starting an embedded application. (application::init): Warn if application is already initialized. (application::~application): Delete interpreter before setting instance to 0. * octave-link.h (octave_link::exit): New arg, process_events. If process_events is true, disable link and process pending events.
author John W. Eaton <jwe@octave.org>
date Tue, 24 Jan 2017 18:00:05 -0500
parents ef4d915df748
children 0fed4c678795
line wrap: on
line source

/*

Copyright (C) 2002-2016 John W. Eaton

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
<http://www.gnu.org/licenses/>.

*/

#if ! defined (octave_interpreter_h)
#define octave_interpreter_h 1

#include "octave-config.h"

#include <string>

#include "quit.h"
#include "str-vec.h"

#include "pt-eval.h"

extern OCTINTERP_API bool quit_allowed;

extern OCTINTERP_API bool quitting_gracefully;

extern OCTINTERP_API void recover_from_exception (void);

extern OCTINTERP_API void
octave_add_atexit_function (const std::string& fname);

extern OCTINTERP_API bool
octave_remove_atexit_function (const std::string& fname);

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

// Call a function with exceptions handled to avoid problems with
// errors while shutting down.

#define OCTAVE_IGNORE_EXCEPTION(E)                                      \
  catch (E)                                                             \
    {                                                                   \
      std::cerr << "error: ignoring " #E " while preparing to exit" << std::endl; \
      recover_from_exception ();                                        \
    }

#define OCTAVE_SAFE_CALL(F, ARGS)                                       \
  do                                                                    \
    {                                                                   \
      try                                                               \
        {                                                               \
          octave::unwind_protect frame;                                 \
                                                                        \
          frame.protect_var (Vdebug_on_error);                          \
          frame.protect_var (Vdebug_on_warning);                        \
                                                                        \
          Vdebug_on_error = false;                                      \
          Vdebug_on_warning = false;                                    \
                                                                        \
          F ARGS;                                                       \
        }                                                               \
      OCTAVE_IGNORE_EXCEPTION (const octave::interrupt_exception&)       \
        OCTAVE_IGNORE_EXCEPTION (const octave::execution_exception&)     \
        OCTAVE_IGNORE_EXCEPTION (const std::bad_alloc&)                 \
        }                                                               \
  while (0)

namespace octave
{
  extern tree_evaluator *current_evaluator;

  // 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 OCTINTERP_API interpreter
  {
  public:

    interpreter (application *app_context = 0, bool embedded = false);

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

    interpreter (const interpreter&) = delete;

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

    ~interpreter (void);

    int execute (void);

    int execute_eval_option_code (const std::string& code);

    int execute_command_line_file (const std::string& fname);

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

  private:

    int main_loop (void);

    void cleanup (void);

    application *m_app_context;

    tree_evaluator *m_evaluator;

    bool m_embedded;

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

    bool m_quitting_gracefully;
  };
}

#endif