gdb/python/python.c

   1 /* General python/gdb code
   2
   3    Copyright (C) 2008, 2009 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "command.h"
  22 #include "ui-out.h"
  23 #include "cli/cli-script.h"
  24 #include "gdbcmd.h"
  25
  26 #include <ctype.h>
  27
  28 /* True if we should print the stack when catching a Python error,
  29    false otherwise.  */
  30 static int gdbpy_should_print_stack = 1;
  31
  32 #ifdef HAVE_PYTHON
  33
  34 #include "python.h"
  35 #include "libiberty.h"
  36 #include "cli/cli-decode.h"
  37 #include "charset.h"
  38 #include "top.h"
  39 #include "exceptions.h"
  40 #include "python-internal.h"
  41 #include "version.h"
  42 #include "target.h"
  43 #include "gdbthread.h"
  44
  45 static PyMethodDef GdbMethods[];
  46
  47 PyObject *gdb_module;
  48
  49 PyObject *gdbpy_doc_cst;
  50
  51 /* Given a command_line, return a command string suitable for passing
  52    to Python.  Lines in the string are separated by newlines.  The
  53    return value is allocated using xmalloc and the caller is
  54    responsible for freeing it.  */
  55
  56 static char *
  57 compute_python_string (struct command_line *l)
  58 {
  59   struct command_line *iter;
  60   char *script = NULL;
  61   int size = 0;
  62   int here;
  63
  64   for (iter = l; iter; iter = iter->next)
  65     size += strlen (iter->line) + 1;
  66
  67   script = xmalloc (size + 1);
  68   here = 0;
  69   for (iter = l; iter; iter = iter->next)
  70     {
  71       int len = strlen (iter->line);
  72       strcpy (&script[here], iter->line);
  73       here += len;
  74       script[here++] = '\n';
  75     }
  76   script[here] = '\0';
  77   return script;
  78 }
  79
  80 /* Take a command line structure representing a 'python' command, and
  81    evaluate its body using the Python interpreter.  */
  82
  83 void
  84 eval_python_from_control_command (struct command_line *cmd)
  85 {
  86   int ret;
  87   char *script;
  88   struct cleanup *cleanup;
  89   PyGILState_STATE state;
  90
  91   if (cmd->body_count != 1)
  92     error (_("Invalid \"python\" block structure."));
  93
  94   state = PyGILState_Ensure ();
  95   cleanup = make_cleanup_py_restore_gil (&state);
  96
  97   script = compute_python_string (cmd->body_list[0]);
  98   ret = PyRun_SimpleString (script);
  99   xfree (script);
 100   if (ret)
 101     {
 102       gdbpy_print_stack ();
 103       error (_("Error while executing Python code."));
 104     }
 105
 106   do_cleanups (cleanup);
 107 }
 108
 109 /* Implementation of the gdb "python" command.  */
 110
 111 static void
 112 python_command (char *arg, int from_tty)
 113 {
 114   struct cleanup *cleanup;
 115   PyGILState_STATE state;
 116
 117   state = PyGILState_Ensure ();
 118   cleanup = make_cleanup_py_restore_gil (&state);
 119
 120   while (arg && *arg && isspace (*arg))
 121     ++arg;
 122   if (arg && *arg)
 123     {
 124       if (PyRun_SimpleString (arg))
 125         {
 126           gdbpy_print_stack ();
 127           error (_("Error while executing Python code."));
 128         }
 129     }
 130   else
 131     {
 132       struct command_line *l = get_command_line (python_control, "");
 133       make_cleanup_free_command_lines (&l);
 134       execute_control_command_untraced (l);
 135     }
 136
 137   do_cleanups (cleanup);
 138 }
 139
 140 \f
 141
 142 /* Transform a gdb parameters's value into a Python value.  May return
 143    NULL (and set a Python exception) on error.  Helper function for
 144    get_parameter.  */
 145
 146 static PyObject *
 147 parameter_to_python (struct cmd_list_element *cmd)
 148 {
 149   switch (cmd->var_type)
 150     {
 151     case var_string:
 152     case var_string_noescape:
 153     case var_optional_filename:
 154     case var_filename:
 155     case var_enum:
 156       {
 157         char *str = * (char **) cmd->var;
 158         if (! str)
 159           str = "";
 160         return PyString_Decode (str, strlen (str), host_charset (), NULL);
 161       }
 162
 163     case var_boolean:
 164       {
 165         if (* (int *) cmd->var)
 166           Py_RETURN_TRUE;
 167         else
 168           Py_RETURN_FALSE;
 169       }
 170
 171     case var_auto_boolean:
 172       {
 173         enum auto_boolean ab = * (enum auto_boolean *) cmd->var;
 174         if (ab == AUTO_BOOLEAN_TRUE)
 175           Py_RETURN_TRUE;
 176         else if (ab == AUTO_BOOLEAN_FALSE)
 177           Py_RETURN_FALSE;
 178         else
 179           Py_RETURN_NONE;
 180       }
 181
 182     case var_integer:
 183       if ((* (int *) cmd->var) == INT_MAX)
 184         Py_RETURN_NONE;
 185       /* Fall through.  */
 186     case var_zinteger:
 187       return PyLong_FromLong (* (int *) cmd->var);
 188
 189     case var_uinteger:
 190       {
 191         unsigned int val = * (unsigned int *) cmd->var;
 192         if (val == UINT_MAX)
 193           Py_RETURN_NONE;
 194         return PyLong_FromUnsignedLong (val);
 195       }
 196     }
 197
 198   return PyErr_Format (PyExc_RuntimeError, "programmer error: unhandled type");
 199 }
 200
 201 /* A Python function which returns a gdb parameter's value as a Python
 202    value.  */
 203
 204 static PyObject *
 205 get_parameter (PyObject *self, PyObject *args)
 206 {
 207   struct cmd_list_element *alias, *prefix, *cmd;
 208   char *arg, *newarg;
 209   volatile struct gdb_exception except;
 210
 211   if (! PyArg_ParseTuple (args, "s", &arg))
 212     return NULL;
 213
 214   newarg = concat ("show ", arg, (char *) NULL);
 215
 216   TRY_CATCH (except, RETURN_MASK_ALL)
 217     {
 218       if (! lookup_cmd_composition (newarg, &alias, &prefix, &cmd))
 219         {
 220           xfree (newarg);
 221           return PyErr_Format (PyExc_RuntimeError,
 222                                "could not find variable `%s'", arg);
 223         }
 224     }
 225   xfree (newarg);
 226   GDB_PY_HANDLE_EXCEPTION (except);
 227
 228   if (! cmd->var)
 229     return PyErr_Format (PyExc_RuntimeError, "`%s' is not a variable", arg);
 230   return parameter_to_python (cmd);
 231 }
 232
 233 /* A Python function which evaluates a string using the gdb CLI.  */
 234
 235 static PyObject *
 236 execute_gdb_command (PyObject *self, PyObject *args)
 237 {
 238   struct cmd_list_element *alias, *prefix, *cmd;
 239   char *arg, *newarg;
 240   PyObject *from_tty_obj = NULL;
 241   int from_tty;
 242   int cmp;
 243   volatile struct gdb_exception except;
 244
 245   if (! PyArg_ParseTuple (args, "s|O!", &arg, &PyBool_Type, &from_tty_obj))
 246     return NULL;
 247
 248   from_tty = 0;
 249   if (from_tty_obj)
 250     {
 251       cmp = PyObject_IsTrue (from_tty_obj);
 252       if (cmp < 0)
 253           return NULL;
 254       from_tty = cmp;
 255     }
 256
 257   TRY_CATCH (except, RETURN_MASK_ALL)
 258     {
 259       execute_command (arg, from_tty);
 260     }
 261   GDB_PY_HANDLE_EXCEPTION (except);
 262
 263   /* Do any commands attached to breakpoint we stopped at.  */
 264   bpstat_do_actions ();
 265
 266   Py_RETURN_NONE;
 267 }
 268
 269 \f
 270
 271 /* Printing.  */
 272
 273 /* A python function to write a single string using gdb's filtered
 274    output stream.  */
 275 static PyObject *
 276 gdbpy_write (PyObject *self, PyObject *args)
 277 {
 278   char *arg;
 279   if (! PyArg_ParseTuple (args, "s", &arg))
 280     return NULL;
 281   printf_filtered ("%s", arg);
 282   Py_RETURN_NONE;
 283 }
 284
 285 /* A python function to flush gdb's filtered output stream.  */
 286 static PyObject *
 287 gdbpy_flush (PyObject *self, PyObject *args)
 288 {
 289   gdb_flush (gdb_stdout);
 290   Py_RETURN_NONE;
 291 }
 292
 293 /* Print a python exception trace, or print nothing and clear the
 294    python exception, depending on gdbpy_should_print_stack.  Only call
 295    this if a python exception is set.  */
 296 void
 297 gdbpy_print_stack (void)
 298 {
 299   if (gdbpy_should_print_stack)
 300     PyErr_Print ();
 301   else
 302     PyErr_Clear ();
 303 }
 304
 305 #else /* HAVE_PYTHON */
 306
 307 /* Dummy implementation of the gdb "python" command.  */
 308
 309 static void
 310 python_command (char *arg, int from_tty)
 311 {
 312   while (arg && *arg && isspace (*arg))
 313     ++arg;
 314   if (arg && *arg)
 315     error (_("Python scripting is not supported in this copy of GDB."));
 316   else
 317     {
 318       struct command_line *l = get_command_line (python_control, "");
 319       struct cleanup *cleanups = make_cleanup_free_command_lines (&l);
 320       execute_control_command_untraced (l);
 321       do_cleanups (cleanups);
 322     }
 323 }
 324
 325 void
 326 eval_python_from_control_command (struct command_line *cmd)
 327 {
 328   error (_("Python scripting is not supported in this copy of GDB."));
 329 }
 330
 331 #endif /* HAVE_PYTHON */
 332
 333 \f
 334
 335 /* Lists for 'maint set python' commands.  */
 336
 337 static struct cmd_list_element *set_python_list;
 338 static struct cmd_list_element *show_python_list;
 339
 340 /* Function for use by 'maint set python' prefix command.  */
 341
 342 static void
 343 set_python (char *args, int from_tty)
 344 {
 345   help_list (set_python_list, "maintenance set python ", -1, gdb_stdout);
 346 }
 347
 348 /* Function for use by 'maint show python' prefix command.  */
 349
 350 static void
 351 show_python (char *args, int from_tty)
 352 {
 353   cmd_show_list (show_python_list, from_tty, "");
 354 }
 355
 356 /* Initialize the Python code.  */
 357
 358 void
 359 _initialize_python (void)
 360 {
 361   add_com ("python", class_obscure, python_command,
 362 #ifdef HAVE_PYTHON
 363            _("\
 364 Evaluate a Python command.\n\
 365 \n\
 366 The command can be given as an argument, for instance:\n\
 367 \n\
 368     python print 23\n\
 369 \n\
 370 If no argument is given, the following lines are read and used\n\
 371 as the Python commands.  Type a line containing \"end\" to indicate\n\
 372 the end of the command.")
 373 #else /* HAVE_PYTHON */
 374            _("\
 375 Evaluate a Python command.\n\
 376 \n\
 377 Python scripting is not supported in this copy of GDB.\n\
 378 This command is only a placeholder.")
 379 #endif /* HAVE_PYTHON */
 380            );
 381
 382   add_prefix_cmd ("python", no_class, show_python,
 383                   _("Prefix command for python maintenance settings."),
 384                   &show_python_list, "maintenance show python ", 0,
 385                   &maintenance_show_cmdlist);
 386   add_prefix_cmd ("python", no_class, set_python,
 387                   _("Prefix command for python maintenance settings."),
 388                   &set_python_list, "maintenance set python ", 0,
 389                   &maintenance_set_cmdlist);
 390
 391   add_setshow_boolean_cmd ("print-stack", class_maintenance,
 392                            &gdbpy_should_print_stack, _("\
 393 Enable or disable printing of Python stack dump on error."), _("\
 394 Show whether Python stack will be printed on error."), _("\
 395 Enables or disables printing of Python stack traces."),
 396                            NULL, NULL,
 397                            &set_python_list,
 398                            &show_python_list);
 399
 400 #ifdef HAVE_PYTHON
 401   Py_Initialize ();
 402   PyEval_InitThreads ();
 403
 404   gdb_module = Py_InitModule ("gdb", GdbMethods);
 405
 406   /* The casts to (char*) are for python 2.4.  */
 407   PyModule_AddStringConstant (gdb_module, "VERSION", (char*) version);
 408   PyModule_AddStringConstant (gdb_module, "HOST_CONFIG", (char*) host_name);
 409   PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG", (char*) target_name);
 410
 411   gdbpy_initialize_values ();
 412   gdbpy_initialize_commands ();
 413
 414   PyRun_SimpleString ("import gdb");
 415
 416   gdbpy_doc_cst = PyString_FromString ("__doc__");
 417
 418   /* Create a couple objects which are used for Python's stdout and
 419      stderr.  */
 420   PyRun_SimpleString ("\
 421 import sys\n\
 422 class GdbOutputFile:\n\
 423   def close(self):\n\
 424     # Do nothing.\n\
 425     return None\n\
 426 \n\
 427   def isatty(self):\n\
 428     return False\n\
 429 \n\
 430   def write(self, s):\n\
 431     gdb.write(s)\n\
 432 \n\
 433   def writelines(self, iterable):\n\
 434     for line in iterable:\n\
 435       self.write(line)\n\
 436 \n\
 437   def flush(self):\n\
 438     gdb.flush()\n\
 439 \n\
 440 sys.stderr = GdbOutputFile()\n\
 441 sys.stdout = GdbOutputFile()\n\
 442 ");
 443
 444   /* Release the GIL while gdb runs.  */
 445   PyThreadState_Swap (NULL);
 446   PyEval_ReleaseLock ();
 447
 448 #endif /* HAVE_PYTHON */
 449 }
 450
 451 \f
 452
 453 #if HAVE_PYTHON
 454
 455 static PyMethodDef GdbMethods[] =
 456 {
 457   { "history", gdbpy_history, METH_VARARGS,
 458     "Get a value from history" },
 459   { "execute", execute_gdb_command, METH_VARARGS,
 460     "Execute a gdb command" },
 461   { "get_parameter", get_parameter, METH_VARARGS,
 462     "Return a gdb parameter's value" },
 463
 464   { "write", gdbpy_write, METH_VARARGS,
 465     "Write a string using gdb's filtered stream." },
 466   { "flush", gdbpy_flush, METH_NOARGS,
 467     "Flush gdb's filtered stdout stream." },
 468
 469   {NULL, NULL, 0, NULL}
 470 };
 471
 472 #endif /* HAVE_PYTHON */