GDB 7.6.50

gdb/python/python.c

 /* General python/gdb code
 
-   Copyright (C) 2008-2012 Free Software Foundation, Inc.
+   Copyright (C) 2008-2013 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program 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.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 11 matching lines @@
 #include "gdbcmd.h"
 #include "progspace.h"
 #include "objfiles.h"
 #include "value.h"
 #include "language.h"
 #include "exceptions.h"
 #include "event-loop.h"
 #include "serial.h"
 #include "readline/tilde.h"
 #include "python.h"
+#include "cli/cli-utils.h"
 
 #include <ctype.h>
 
 /* Declared constants and enum for python stack printing.  */
 static const char python_excp_none[] = "none";
 static const char python_excp_full[] = "full";
 static const char python_excp_message[] = "message";
 
 /* "set python print-stack" choices.  */
 static const char *const python_excp_enums[] =
@@ skipping 18 matching lines @@
 #include "top.h"
 #include "solib.h"
 #include "python-internal.h"
 #include "linespec.h"
 #include "source.h"
 #include "version.h"
 #include "target.h"
 #include "gdbthread.h"
 #include "observer.h"
 #include "interps.h"
+#include "event-top.h"
+
+/* True if Python has been successfully initialized, false
+   otherwise.  */
+
+int gdb_python_initialized;
 
 static PyMethodDef GdbMethods[];
 
+#ifdef IS_PY3K
+static struct PyModuleDef GdbModuleDef;
+#endif
+
 PyObject *gdb_module;
+PyObject *gdb_python_module;
 
 /* Some string constants we may wish to use.  */
 PyObject *gdbpy_to_string_cst;
 PyObject *gdbpy_children_cst;
 PyObject *gdbpy_display_hint_cst;
 PyObject *gdbpy_doc_cst;
 PyObject *gdbpy_enabled_cst;
 PyObject *gdbpy_value_cst;
 
 /* The GdbError exception.  */
@@ skipping 44 matching lines @@
 
 /* Called before entering the Python interpreter to install the
    current language and architecture to be used for Python values.  */
 
 struct cleanup *
 ensure_python_env (struct gdbarch *gdbarch,
                    const struct language_defn *language)
 {
   struct python_env *env = xmalloc (sizeof *env);
 
+  /* We should not ever enter Python unless initialized.  */
+  if (!gdb_python_initialized)
+    error (_("Python not initialized"));
+
   env->state = PyGILState_Ensure ();
   env->gdbarch = python_gdbarch;
   env->language = python_language;
 
   python_gdbarch = gdbarch;
   python_language = language;
 
   /* Save it and ensure ! PyErr_Occurred () afterwards.  */
   PyErr_Fetch (&env->error_type, &env->error_value, &env->error_traceback);
-  
+
   return make_cleanup (restore_python_env, env);
 }
 
+/* Clear the quit flag.  */
+
+void
+clear_quit_flag (void)
+{
+  /* This clears the flag as a side effect.  */
+  PyOS_InterruptOccurred ();
+}
+
+/* Set the quit flag.  */
+
+void
+set_quit_flag (void)
+{
+  PyErr_SetInterrupt ();
+}
+
+/* Return true if the quit flag has been set, false otherwise.  */
+
+int
+check_quit_flag (void)
+{
+  return PyOS_InterruptOccurred ();
+}
+
+/* Evaluate a Python command like PyRun_SimpleString, but uses
+   Py_single_input which prints the result of expressions, and does
+   not automatically print the stack on errors.  */
+
+static int
+eval_python_command (const char *command)
+{
+  PyObject *m, *d, *v;
+
+  m = PyImport_AddModule ("__main__");
+  if (m == NULL)
+    return -1;
+
+  d = PyModule_GetDict (m);
+  if (d == NULL)
+    return -1;
+  v = PyRun_StringFlags (command, Py_single_input, d, d, NULL);
+  if (v == NULL)
+    return -1;
+
+  Py_DECREF (v);
+#ifndef IS_PY3K
+  if (Py_FlushLine ())
+    PyErr_Clear ();
+#endif
+
+  return 0;
+}
+
+/* Implementation of the gdb "python-interactive" command.  */
+
+static void
+python_interactive_command (char *arg, int from_tty)
+{
+  struct cleanup *cleanup;
+  int err;
+
+  cleanup = make_cleanup_restore_integer (&interpreter_async);
+  interpreter_async = 0;
+
+  arg = skip_spaces (arg);
+
+  ensure_python_env (get_current_arch (), current_language);
+
+  if (arg && *arg)
+    {
+      int len = strlen (arg);
+      char *script = xmalloc (len + 2);
+
+      strcpy (script, arg);
+      script[len] = '\n';
+      script[len + 1] = '\0';
+      err = eval_python_command (script);
+      xfree (script);
+    }
+  else
+    {
+      err = PyRun_InteractiveLoop (instream, "<stdin>");
+      dont_repeat ();
+    }
+
+  if (err)
+    {
+      gdbpy_print_stack ();
+      error (_("Error while executing Python code."));
+    }
+
+  do_cleanups (cleanup);
+}
+
 /* A wrapper around PyRun_SimpleFile.  FILE is the Python script to run
    named FILENAME.
 
    On Windows hosts few users would build Python themselves (this is no
    trivial task on this platform), and thus use binaries built by
    someone else instead.  There may happen situation where the Python
    library and GDB are using two different versions of the C runtime
    library.  Python, being built with VC, would use one version of the
    msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
    A FILE * from one runtime does not necessarily operate correctly in
@@ skipping 20 matching lines @@
      open the file, we need to expand any tilde in the path first.  */
   full_path = tilde_expand (filename);
   cleanup = make_cleanup (xfree, full_path);
   python_file = PyFile_FromString (full_path, "r");
   if (! python_file)
     {
       do_cleanups (cleanup);
       gdbpy_print_stack ();
       error (_("Error while opening file: %s"), full_path);
     }
- 
+
   make_cleanup_py_decref (python_file);
   PyRun_SimpleFile (PyFile_AsFile (python_file), filename);
   do_cleanups (cleanup);
 
 #endif /* _WIN32 */
 }
 
 /* Given a command_line, return a command string suitable for passing
    to Python.  Lines in the string are separated by newlines.  The
    return value is allocated using xmalloc and the caller is
@@ skipping 53 matching lines @@
 static void
 python_command (char *arg, int from_tty)
 {
   struct cleanup *cleanup;
 
   cleanup = ensure_python_env (get_current_arch (), current_language);
 
   make_cleanup_restore_integer (&interpreter_async);
   interpreter_async = 0;
 
-  while (arg && *arg && isspace (*arg))
-    ++arg;
+  arg = skip_spaces (arg);
   if (arg && *arg)
     {
       if (PyRun_SimpleString (arg))
         error (_("Error while executing Python code."));
     }
   else
     {
       struct command_line *l = get_command_line (python_control, "");
 
       make_cleanup_free_command_lines (&l);
@@ skipping 53 matching lines @@
       /* Fall through.  */
     case var_zinteger:
       return PyLong_FromLong (* (int *) var);
 
     case var_uinteger:
       {
         unsigned int val = * (unsigned int *) var;
 
         if (val == UINT_MAX)
           Py_RETURN_NONE;