Subversion Repositories openrisc

/* General python/gdb code

/* General python/gdb code

   Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.

   Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.

   This file is part of GDB.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify

   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

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   You should have received a copy of the GNU General Public License

   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"

#include "defs.h"

#include "arch-utils.h"

#include "arch-utils.h"

#include "command.h"

#include "command.h"

#include "ui-out.h"

#include "ui-out.h"

#include "cli/cli-script.h"

#include "cli/cli-script.h"

#include "gdbcmd.h"

#include "gdbcmd.h"

#include "objfiles.h"

#include "objfiles.h"

#include "observer.h"

#include "observer.h"

#include "value.h"

#include "value.h"

#include "language.h"

#include "language.h"

#include "exceptions.h"

#include "exceptions.h"

#include <ctype.h>

#include <ctype.h>

/* True if we should print the stack when catching a Python error,

/* True if we should print the stack when catching a Python error,

   false otherwise.  */

   false otherwise.  */

static int gdbpy_should_print_stack = 1;

static int gdbpy_should_print_stack = 1;

/* This is true if we should auto-load python code when an objfile is

/* This is true if we should auto-load python code when an objfile is

   opened, false otherwise.  */

   opened, false otherwise.  */

static int gdbpy_auto_load = 1;

static int gdbpy_auto_load = 1;

#ifdef HAVE_PYTHON

#ifdef HAVE_PYTHON

#include "python.h"

#include "python.h"

#include "libiberty.h"

#include "libiberty.h"

#include "cli/cli-decode.h"

#include "cli/cli-decode.h"

#include "charset.h"

#include "charset.h"

#include "top.h"

#include "top.h"

#include "python-internal.h"

#include "python-internal.h"

#include "version.h"

#include "version.h"

#include "target.h"

#include "target.h"

#include "gdbthread.h"

#include "gdbthread.h"

static PyMethodDef GdbMethods[];

static PyMethodDef GdbMethods[];

PyObject *gdb_module;

PyObject *gdb_module;

/* Some string constants we may wish to use.  */

/* Some string constants we may wish to use.  */

PyObject *gdbpy_to_string_cst;

PyObject *gdbpy_to_string_cst;

PyObject *gdbpy_children_cst;

PyObject *gdbpy_children_cst;

PyObject *gdbpy_display_hint_cst;

PyObject *gdbpy_display_hint_cst;

PyObject *gdbpy_doc_cst;

PyObject *gdbpy_doc_cst;

/* Architecture and language to be used in callbacks from

/* Architecture and language to be used in callbacks from

   the Python interpreter.  */

   the Python interpreter.  */

struct gdbarch *python_gdbarch;

struct gdbarch *python_gdbarch;

const struct language_defn *python_language;

const struct language_defn *python_language;

/* Restore global language and architecture and Python GIL state

/* Restore global language and architecture and Python GIL state

   when leaving the Python interpreter.  */

   when leaving the Python interpreter.  */

struct python_env

struct python_env

{

{

  PyGILState_STATE state;

  PyGILState_STATE state;

  struct gdbarch *gdbarch;

  struct gdbarch *gdbarch;

  const struct language_defn *language;

  const struct language_defn *language;

};

};

static void

static void

restore_python_env (void *p)

restore_python_env (void *p)

{

{

  struct python_env *env = (struct python_env *)p;

  struct python_env *env = (struct python_env *)p;

  PyGILState_Release (env->state);

  PyGILState_Release (env->state);

  python_gdbarch = env->gdbarch;

  python_gdbarch = env->gdbarch;

  python_language = env->language;

  python_language = env->language;

  xfree (env);

  xfree (env);

}

}

/* Called before entering the Python interpreter to install the

/* Called before entering the Python interpreter to install the

   current language and architecture to be used for Python values.  */

   current language and architecture to be used for Python values.  */

struct cleanup *

struct cleanup *

ensure_python_env (struct gdbarch *gdbarch,

ensure_python_env (struct gdbarch *gdbarch,

                   const struct language_defn *language)

                   const struct language_defn *language)

{

{

  struct python_env *env = xmalloc (sizeof *env);

  struct python_env *env = xmalloc (sizeof *env);

  env->state = PyGILState_Ensure ();

  env->state = PyGILState_Ensure ();

  env->gdbarch = python_gdbarch;

  env->gdbarch = python_gdbarch;

  env->language = python_language;

  env->language = python_language;

  python_gdbarch = gdbarch;

  python_gdbarch = gdbarch;

  python_language = language;

  python_language = language;

  return make_cleanup (restore_python_env, env);

  return make_cleanup (restore_python_env, env);

}

}

/* Given a command_line, return a command string suitable for passing

/* Given a command_line, return a command string suitable for passing

   to Python.  Lines in the string are separated by newlines.  The

   to Python.  Lines in the string are separated by newlines.  The

   return value is allocated using xmalloc and the caller is

   return value is allocated using xmalloc and the caller is

   responsible for freeing it.  */

   responsible for freeing it.  */

static char *

static char *

compute_python_string (struct command_line *l)

compute_python_string (struct command_line *l)

{

{

  struct command_line *iter;

  struct command_line *iter;

  char *script = NULL;

  char *script = NULL;

  int size = 0;

  int size = 0;

  int here;

  int here;

  for (iter = l; iter; iter = iter->next)

  for (iter = l; iter; iter = iter->next)

    size += strlen (iter->line) + 1;

    size += strlen (iter->line) + 1;

  script = xmalloc (size + 1);

  script = xmalloc (size + 1);

  here = 0;

  here = 0;

  for (iter = l; iter; iter = iter->next)

  for (iter = l; iter; iter = iter->next)

    {

    {

      int len = strlen (iter->line);

      int len = strlen (iter->line);

      strcpy (&script[here], iter->line);

      strcpy (&script[here], iter->line);

      here += len;

      here += len;

      script[here++] = '\n';

      script[here++] = '\n';

    }

    }

  script[here] = '\0';

  script[here] = '\0';

  return script;

  return script;

}

}

/* Take a command line structure representing a 'python' command, and

/* Take a command line structure representing a 'python' command, and

   evaluate its body using the Python interpreter.  */

   evaluate its body using the Python interpreter.  */

void

void

eval_python_from_control_command (struct command_line *cmd)

eval_python_from_control_command (struct command_line *cmd)

{

{

  int ret;

  int ret;

  char *script;

  char *script;

  struct cleanup *cleanup;

  struct cleanup *cleanup;

  if (cmd->body_count != 1)

  if (cmd->body_count != 1)

    error (_("Invalid \"python\" block structure."));

    error (_("Invalid \"python\" block structure."));

  cleanup = ensure_python_env (get_current_arch (), current_language);

  cleanup = ensure_python_env (get_current_arch (), current_language);

  script = compute_python_string (cmd->body_list[0]);

  script = compute_python_string (cmd->body_list[0]);

  ret = PyRun_SimpleString (script);

  ret = PyRun_SimpleString (script);

  xfree (script);

  xfree (script);

  if (ret)

  if (ret)

    {

    {

      gdbpy_print_stack ();

      gdbpy_print_stack ();

      error (_("Error while executing Python code."));

      error (_("Error while executing Python code."));

    }

    }

  do_cleanups (cleanup);

  do_cleanups (cleanup);

}

}

/* Implementation of the gdb "python" command.  */

/* Implementation of the gdb "python" command.  */

static void

static void

python_command (char *arg, int from_tty)

python_command (char *arg, int from_tty)

{

{

  struct cleanup *cleanup;

  struct cleanup *cleanup;

  cleanup = ensure_python_env (get_current_arch (), current_language);

  cleanup = ensure_python_env (get_current_arch (), current_language);

  while (arg && *arg && isspace (*arg))

  while (arg && *arg && isspace (*arg))

    ++arg;

    ++arg;

  if (arg && *arg)

  if (arg && *arg)

    {

    {

      if (PyRun_SimpleString (arg))

      if (PyRun_SimpleString (arg))

        {

        {

          gdbpy_print_stack ();

          gdbpy_print_stack ();

          error (_("Error while executing Python code."));

          error (_("Error while executing Python code."));

        }

        }

    }

    }

  else

  else

    {

    {

      struct command_line *l = get_command_line (python_control, "");

      struct command_line *l = get_command_line (python_control, "");

      make_cleanup_free_command_lines (&l);

      make_cleanup_free_command_lines (&l);

      execute_control_command_untraced (l);

      execute_control_command_untraced (l);

    }

    }

  do_cleanups (cleanup);

  do_cleanups (cleanup);

}

}

/* Transform a gdb parameters's value into a Python value.  May return

/* Transform a gdb parameters's value into a Python value.  May return

   NULL (and set a Python exception) on error.  Helper function for

   NULL (and set a Python exception) on error.  Helper function for

   get_parameter.  */

   get_parameter.  */

static PyObject *

static PyObject *

parameter_to_python (struct cmd_list_element *cmd)

parameter_to_python (struct cmd_list_element *cmd)

{

{

  switch (cmd->var_type)

  switch (cmd->var_type)

    {

    {

    case var_string:

    case var_string:

    case var_string_noescape:

    case var_string_noescape:

    case var_optional_filename:

    case var_optional_filename:

    case var_filename:

    case var_filename:

    case var_enum:

    case var_enum:

      {

      {

        char *str = * (char **) cmd->var;

        char *str = * (char **) cmd->var;

        if (! str)

        if (! str)

          str = "";

          str = "";

        return PyString_Decode (str, strlen (str), host_charset (), NULL);

        return PyString_Decode (str, strlen (str), host_charset (), NULL);

      }

      }

    case var_boolean:

    case var_boolean:

      {

      {

        if (* (int *) cmd->var)

        if (* (int *) cmd->var)

          Py_RETURN_TRUE;

          Py_RETURN_TRUE;

        else

        else

          Py_RETURN_FALSE;

          Py_RETURN_FALSE;

      }

      }

    case var_auto_boolean:

    case var_auto_boolean:

      {

      {

        enum auto_boolean ab = * (enum auto_boolean *) cmd->var;

        enum auto_boolean ab = * (enum auto_boolean *) cmd->var;

        if (ab == AUTO_BOOLEAN_TRUE)

        if (ab == AUTO_BOOLEAN_TRUE)

          Py_RETURN_TRUE;

          Py_RETURN_TRUE;

        else if (ab == AUTO_BOOLEAN_FALSE)

        else if (ab == AUTO_BOOLEAN_FALSE)

          Py_RETURN_FALSE;

          Py_RETURN_FALSE;

        else

        else

          Py_RETURN_NONE;

          Py_RETURN_NONE;

      }

      }

    case var_integer:

    case var_integer:

      if ((* (int *) cmd->var) == INT_MAX)

      if ((* (int *) cmd->var) == INT_MAX)

        Py_RETURN_NONE;

        Py_RETURN_NONE;

      /* Fall through.  */

      /* Fall through.  */

    case var_zinteger:

    case var_zinteger:

      return PyLong_FromLong (* (int *) cmd->var);

      return PyLong_FromLong (* (int *) cmd->var);

    case var_uinteger:

    case var_uinteger:

      {

      {

        unsigned int val = * (unsigned int *) cmd->var;

        unsigned int val = * (unsigned int *) cmd->var;

        if (val == UINT_MAX)

        if (val == UINT_MAX)

          Py_RETURN_NONE;

          Py_RETURN_NONE;

        return PyLong_FromUnsignedLong (val);

        return PyLong_FromUnsignedLong (val);

      }

      }

    }

    }

  return PyErr_Format (PyExc_RuntimeError, "programmer error: unhandled type");

  return PyErr_Format (PyExc_RuntimeError, "programmer error: unhandled type");

}

}

/* A Python function which returns a gdb parameter's value as a Python

/* A Python function which returns a gdb parameter's value as a Python

   value.  */

   value.  */

static PyObject *

static PyObject *

gdbpy_parameter (PyObject *self, PyObject *args)

gdbpy_parameter (PyObject *self, PyObject *args)

{

{

  struct cmd_list_element *alias, *prefix, *cmd;

  struct cmd_list_element *alias, *prefix, *cmd;

  char *arg, *newarg;

  char *arg, *newarg;

  int found = -1;

  int found = -1;

  volatile struct gdb_exception except;

  volatile struct gdb_exception except;

  if (! PyArg_ParseTuple (args, "s", &arg))

  if (! PyArg_ParseTuple (args, "s", &arg))

    return NULL;

    return NULL;

  newarg = concat ("show ", arg, (char *) NULL);

  newarg = concat ("show ", arg, (char *) NULL);

  TRY_CATCH (except, RETURN_MASK_ALL)

  TRY_CATCH (except, RETURN_MASK_ALL)

    {

    {

      found = lookup_cmd_composition (newarg, &alias, &prefix, &cmd);

      found = lookup_cmd_composition (newarg, &alias, &prefix, &cmd);

    }

    }

  xfree (newarg);

  xfree (newarg);

  GDB_PY_HANDLE_EXCEPTION (except);

  GDB_PY_HANDLE_EXCEPTION (except);

  if (!found)

  if (!found)

    return PyErr_Format (PyExc_RuntimeError,

    return PyErr_Format (PyExc_RuntimeError,

                         "could not find parameter `%s'", arg);

                         "could not find parameter `%s'", arg);

  if (! cmd->var)

  if (! cmd->var)

    return PyErr_Format (PyExc_RuntimeError, "`%s' is not a parameter", arg);

    return PyErr_Format (PyExc_RuntimeError, "`%s' is not a parameter", arg);

  return parameter_to_python (cmd);

  return parameter_to_python (cmd);

}

}

/* A Python function which evaluates a string using the gdb CLI.  */

/* A Python function which evaluates a string using the gdb CLI.  */

static PyObject *

static PyObject *

execute_gdb_command (PyObject *self, PyObject *args)

execute_gdb_command (PyObject *self, PyObject *args)

{

{

  struct cmd_list_element *alias, *prefix, *cmd;

  struct cmd_list_element *alias, *prefix, *cmd;

  char *arg, *newarg;

  char *arg, *newarg;

  PyObject *from_tty_obj = NULL;

  PyObject *from_tty_obj = NULL;

  int from_tty;

  int from_tty;

  int cmp;

  int cmp;

  volatile struct gdb_exception except;

  volatile struct gdb_exception except;

  if (! PyArg_ParseTuple (args, "s|O!", &arg, &PyBool_Type, &from_tty_obj))

  if (! PyArg_ParseTuple (args, "s|O!", &arg, &PyBool_Type, &from_tty_obj))

    return NULL;

    return NULL;

  from_tty = 0;

  from_tty = 0;

  if (from_tty_obj)

  if (from_tty_obj)

    {

    {

      cmp = PyObject_IsTrue (from_tty_obj);

      cmp = PyObject_IsTrue (from_tty_obj);

      if (cmp < 0)

      if (cmp < 0)

          return NULL;

          return NULL;

      from_tty = cmp;

      from_tty = cmp;

    }

    }

  TRY_CATCH (except, RETURN_MASK_ALL)

  TRY_CATCH (except, RETURN_MASK_ALL)

    {

    {

      /* Copy the argument text in case the command modifies it.  */

      /* Copy the argument text in case the command modifies it.  */

      char *copy = xstrdup (arg);

      char *copy = xstrdup (arg);

      struct cleanup *cleanup = make_cleanup (xfree, copy);

      struct cleanup *cleanup = make_cleanup (xfree, copy);

      execute_command (copy, from_tty);

      execute_command (copy, from_tty);

      do_cleanups (cleanup);

      do_cleanups (cleanup);

    }

    }

  GDB_PY_HANDLE_EXCEPTION (except);

  GDB_PY_HANDLE_EXCEPTION (except);

  /* Do any commands attached to breakpoint we stopped at.  */

  /* Do any commands attached to breakpoint we stopped at.  */

  bpstat_do_actions ();

  bpstat_do_actions ();

  Py_RETURN_NONE;

  Py_RETURN_NONE;

}

}

/* Parse a string and evaluate it as an expression.  */

/* Parse a string and evaluate it as an expression.  */

static PyObject *

static PyObject *

gdbpy_parse_and_eval (PyObject *self, PyObject *args)

gdbpy_parse_and_eval (PyObject *self, PyObject *args)

{

{

  char *expr_str;

  char *expr_str;

  struct value *result = NULL;

  struct value *result = NULL;

  volatile struct gdb_exception except;

  volatile struct gdb_exception except;

  if (!PyArg_ParseTuple (args, "s", &expr_str))

  if (!PyArg_ParseTuple (args, "s", &expr_str))

    return NULL;

    return NULL;

  TRY_CATCH (except, RETURN_MASK_ALL)

  TRY_CATCH (except, RETURN_MASK_ALL)

    {

    {

      result = parse_and_eval (expr_str);

      result = parse_and_eval (expr_str);

    }

    }

  GDB_PY_HANDLE_EXCEPTION (except);

  GDB_PY_HANDLE_EXCEPTION (except);

  return value_to_value_object (result);

  return value_to_value_object (result);

}

}

/* Read a file as Python code.  STREAM is the input file; FILE is the

/* Read a file as Python code.  STREAM is the input file; FILE is the

   name of the file.  */

   name of the file.  */

void

void

source_python_script (FILE *stream, char *file)

source_python_script (FILE *stream, char *file)

{

{

  PyGILState_STATE state;

  PyGILState_STATE state;

  state = PyGILState_Ensure ();

  state = PyGILState_Ensure ();

  PyRun_SimpleFile (stream, file);

  PyRun_SimpleFile (stream, file);

  fclose (stream);

  fclose (stream);

  PyGILState_Release (state);

  PyGILState_Release (state);

}

}

/* Printing.  */

/* Printing.  */

/* A python function to write a single string using gdb's filtered

/* A python function to write a single string using gdb's filtered

   output stream.  */

   output stream.  */

static PyObject *

static PyObject *

gdbpy_write (PyObject *self, PyObject *args)

gdbpy_write (PyObject *self, PyObject *args)

{

{

  char *arg;

  char *arg;

  if (! PyArg_ParseTuple (args, "s", &arg))

  if (! PyArg_ParseTuple (args, "s", &arg))

    return NULL;

    return NULL;

  printf_filtered ("%s", arg);

  printf_filtered ("%s", arg);

  Py_RETURN_NONE;

  Py_RETURN_NONE;

}

}

/* A python function to flush gdb's filtered output stream.  */

/* A python function to flush gdb's filtered output stream.  */

static PyObject *

static PyObject *

gdbpy_flush (PyObject *self, PyObject *args)

gdbpy_flush (PyObject *self, PyObject *args)

{

{

  gdb_flush (gdb_stdout);

  gdb_flush (gdb_stdout);

  Py_RETURN_NONE;

  Py_RETURN_NONE;

}

}

/* Print a python exception trace, or print nothing and clear the

/* Print a python exception trace, or print nothing and clear the

   python exception, depending on gdbpy_should_print_stack.  Only call

   python exception, depending on gdbpy_should_print_stack.  Only call

   this if a python exception is set.  */

   this if a python exception is set.  */

void

void

gdbpy_print_stack (void)

gdbpy_print_stack (void)

{

{

  if (gdbpy_should_print_stack)

  if (gdbpy_should_print_stack)

    PyErr_Print ();

    PyErr_Print ();

  else

  else

    PyErr_Clear ();

    PyErr_Clear ();

}

}

/* The "current" objfile.  This is set when gdb detects that a new

/* The "current" objfile.  This is set when gdb detects that a new

   objfile has been loaded.  It is only set for the duration of a call

   objfile has been loaded.  It is only set for the duration of a call

   to gdbpy_new_objfile; it is NULL at other times.  */

   to gdbpy_new_objfile; it is NULL at other times.  */

static struct objfile *gdbpy_current_objfile;

static struct objfile *gdbpy_current_objfile;

/* The file name we attempt to read.  */

/* The file name we attempt to read.  */

#define GDBPY_AUTO_FILENAME "-gdb.py"

#define GDBPY_AUTO_FILENAME "-gdb.py"

/* This is a new_objfile observer callback which loads python code

/* This is a new_objfile observer callback which loads python code

   based on the path to the objfile.  */

   based on the path to the objfile.  */

static void

static void

gdbpy_new_objfile (struct objfile *objfile)

gdbpy_new_objfile (struct objfile *objfile)

{

{

  char *realname;

  char *realname;

  char *filename, *debugfile;

  char *filename, *debugfile;

  int len;

  int len;

  FILE *input;

  FILE *input;

  struct cleanup *cleanups;

  struct cleanup *cleanups;

  if (!gdbpy_auto_load || !objfile || !objfile->name)

  if (!gdbpy_auto_load || !objfile || !objfile->name)

    return;

    return;

  cleanups = ensure_python_env (get_objfile_arch (objfile), current_language);

  cleanups = ensure_python_env (get_objfile_arch (objfile), current_language);

  gdbpy_current_objfile = objfile;

  gdbpy_current_objfile = objfile;

  realname = gdb_realpath (objfile->name);

  realname = gdb_realpath (objfile->name);

  len = strlen (realname);

  len = strlen (realname);

  filename = xmalloc (len + sizeof (GDBPY_AUTO_FILENAME));

  filename = xmalloc (len + sizeof (GDBPY_AUTO_FILENAME));

  memcpy (filename, realname, len);

  memcpy (filename, realname, len);

  strcpy (filename + len, GDBPY_AUTO_FILENAME);

  strcpy (filename + len, GDBPY_AUTO_FILENAME);

  input = fopen (filename, "r");

  input = fopen (filename, "r");

  debugfile = filename;

  debugfile = filename;

  make_cleanup (xfree, filename);

  make_cleanup (xfree, filename);

  make_cleanup (xfree, realname);

  make_cleanup (xfree, realname);

  if (!input && debug_file_directory)

  if (!input && debug_file_directory)

    {

    {

      /* Also try the same file in the separate debug info directory.  */

      /* Also try the same file in the separate debug info directory.  */

      debugfile = xmalloc (strlen (filename)

      debugfile = xmalloc (strlen (filename)

                           + strlen (debug_file_directory) + 1);

                           + strlen (debug_file_directory) + 1);

      strcpy (debugfile, debug_file_directory);

      strcpy (debugfile, debug_file_directory);

      /* FILENAME is absolute, so we don't need a "/" here.  */

      /* FILENAME is absolute, so we don't need a "/" here.  */

      strcat (debugfile, filename);

      strcat (debugfile, filename);

      make_cleanup (xfree, debugfile);

      make_cleanup (xfree, debugfile);

      input = fopen (debugfile, "r");

      input = fopen (debugfile, "r");

    }

    }

  if (!input && gdb_datadir)

  if (!input && gdb_datadir)

    {

    {

      /* Also try the same file in a subdirectory of gdb's data

      /* Also try the same file in a subdirectory of gdb's data

         directory.  */

         directory.  */

      debugfile = xmalloc (strlen (gdb_datadir) + strlen (filename)

      debugfile = xmalloc (strlen (gdb_datadir) + strlen (filename)

                           + strlen ("/auto-load") + 1);

                           + strlen ("/auto-load") + 1);

      strcpy (debugfile, gdb_datadir);

      strcpy (debugfile, gdb_datadir);

      strcat (debugfile, "/auto-load");

      strcat (debugfile, "/auto-load");

      /* FILENAME is absolute, so we don't need a "/" here.  */

      /* FILENAME is absolute, so we don't need a "/" here.  */

      strcat (debugfile, filename);

      strcat (debugfile, filename);

      make_cleanup (xfree, debugfile);

      make_cleanup (xfree, debugfile);

      input = fopen (debugfile, "r");

      input = fopen (debugfile, "r");

    }

    }

  if (input)

  if (input)

    {

    {

      /* We don't want to throw an exception here -- but the user

      /* We don't want to throw an exception here -- but the user

         would like to know that something went wrong.  */

         would like to know that something went wrong.  */

      if (PyRun_SimpleFile (input, debugfile))

      if (PyRun_SimpleFile (input, debugfile))

        gdbpy_print_stack ();

        gdbpy_print_stack ();

      fclose (input);

      fclose (input);

    }

    }

  do_cleanups (cleanups);

  do_cleanups (cleanups);

  gdbpy_current_objfile = NULL;

  gdbpy_current_objfile = NULL;

}

}

/* Return the current Objfile, or None if there isn't one.  */

/* Return the current Objfile, or None if there isn't one.  */

static PyObject *

static PyObject *

gdbpy_get_current_objfile (PyObject *unused1, PyObject *unused2)

gdbpy_get_current_objfile (PyObject *unused1, PyObject *unused2)

{

{

  PyObject *result;

  PyObject *result;

  if (! gdbpy_current_objfile)

  if (! gdbpy_current_objfile)

    Py_RETURN_NONE;

    Py_RETURN_NONE;

  result = objfile_to_objfile_object (gdbpy_current_objfile);

  result = objfile_to_objfile_object (gdbpy_current_objfile);

  if (result)

  if (result)

    Py_INCREF (result);

    Py_INCREF (result);

  return result;

  return result;

}

}

/* Return a sequence holding all the Objfiles.  */

/* Return a sequence holding all the Objfiles.  */

static PyObject *

static PyObject *

gdbpy_objfiles (PyObject *unused1, PyObject *unused2)

gdbpy_objfiles (PyObject *unused1, PyObject *unused2)

{

{

  struct objfile *objf;

  struct objfile *objf;

  PyObject *list;

  PyObject *list;

  list = PyList_New (0);

  list = PyList_New (0);

  if (!list)

  if (!list)

    return NULL;

    return NULL;

  ALL_OBJFILES (objf)

  ALL_OBJFILES (objf)

  {

  {

    PyObject *item = objfile_to_objfile_object (objf);

    PyObject *item = objfile_to_objfile_object (objf);

    if (!item || PyList_Append (list, item) == -1)

    if (!item || PyList_Append (list, item) == -1)

      {

      {

        Py_DECREF (list);

        Py_DECREF (list);

        return NULL;

        return NULL;

      }

      }

  }

  }

  return list;

  return list;

}

}

#else /* HAVE_PYTHON */

#else /* HAVE_PYTHON */

/* Dummy implementation of the gdb "python" command.  */

/* Dummy implementation of the gdb "python" command.  */

static void

static void

python_command (char *arg, int from_tty)

python_command (char *arg, int from_tty)

{

{

  while (arg && *arg && isspace (*arg))

  while (arg && *arg && isspace (*arg))

    ++arg;

    ++arg;

  if (arg && *arg)

  if (arg && *arg)

    error (_("Python scripting is not supported in this copy of GDB."));

    error (_("Python scripting is not supported in this copy of GDB."));

  else

  else

    {

    {

      struct command_line *l = get_command_line (python_control, "");

      struct command_line *l = get_command_line (python_control, "");

      struct cleanup *cleanups = make_cleanup_free_command_lines (&l);

      struct cleanup *cleanups = make_cleanup_free_command_lines (&l);

      execute_control_command_untraced (l);

      execute_control_command_untraced (l);

      do_cleanups (cleanups);

      do_cleanups (cleanups);

    }

    }

}

}

void

void

eval_python_from_control_command (struct command_line *cmd)

eval_python_from_control_command (struct command_line *cmd)

{

{

  error (_("Python scripting is not supported in this copy of GDB."));

  error (_("Python scripting is not supported in this copy of GDB."));

}

}

void

void

source_python_script (FILE *stream, char *file)

source_python_script (FILE *stream, char *file)

{

{

  fclose (stream);

  fclose (stream);

  throw_error (UNSUPPORTED_ERROR,

  throw_error (UNSUPPORTED_ERROR,

               _("Python scripting is not supported in this copy of GDB."));

               _("Python scripting is not supported in this copy of GDB."));

}

}

#endif /* HAVE_PYTHON */

#endif /* HAVE_PYTHON */

/* Lists for 'maint set python' commands.  */

/* Lists for 'maint set python' commands.  */

static struct cmd_list_element *set_python_list;

static struct cmd_list_element *set_python_list;

static struct cmd_list_element *show_python_list;

static struct cmd_list_element *show_python_list;

/* Function for use by 'maint set python' prefix command.  */

/* Function for use by 'maint set python' prefix command.  */

static void

static void

set_python (char *args, int from_tty)

set_python (char *args, int from_tty)

{

{

  help_list (set_python_list, "maintenance set python ", -1, gdb_stdout);

  help_list (set_python_list, "maintenance set python ", -1, gdb_stdout);

}

}

/* Function for use by 'maint show python' prefix command.  */

/* Function for use by 'maint show python' prefix command.  */

static void

static void