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 /* Provide a prototype to silence -Wmissing-prototypes.  */
 359 extern initialize_file_ftype _initialize_python;
 360
 361 void
 362 _initialize_python (void)
 363 {
 364   add_com ("python", class_obscure, python_command,
 365 #ifdef HAVE_PYTHON
 366            _("\
 367 Evaluate a Python command.\n\
 368 \n\
 369 The command can be given as an argument, for instance:\n\
 370 \n\
 371     python print 23\n\
 372 \n\
 373 If no argument is given, the following lines are read and used\n\
 374 as the Python commands.  Type a line containing \"end\" to indicate\n\
 375 the end of the command.")
 376 #else /* HAVE_PYTHON */
 377            _("\
 378 Evaluate a Python command.\n\
 379 \n\
 380 Python scripting is not supported in this copy of GDB.\n\
 381 This command is only a placeholder.")
 382 #endif /* HAVE_PYTHON */
 383            );
 384
 385   add_prefix_cmd ("python", no_class, show_python,
 386                   _("Prefix command for python maintenance settings."),
 387                   &show_python_list, "maintenance show python ", 0,
 388                   &maintenance_show_cmdlist);
 389   add_prefix_cmd ("python", no_class, set_python,
 390                   _("Prefix command for python maintenance settings."),
 391                   &set_python_list, "maintenance set python ", 0,
 392                   &maintenance_set_cmdlist);
 393
 394   add_setshow_boolean_cmd ("print-stack", class_maintenance,
 395                            &gdbpy_should_print_stack, _("\
 396 Enable or disable printing of Python stack dump on error."), _("\
 397 Show whether Python stack will be printed on error."), _("\
 398 Enables or disables printing of Python stack traces."),
 399                            NULL, NULL,
 400                            &set_python_list,
 401                            &show_python_list);
 402
 403 #ifdef HAVE_PYTHON
 404   Py_Initialize ();
 405   PyEval_InitThreads ();
 406
 407   gdb_module = Py_InitModule ("gdb", GdbMethods);
 408
 409   /* The casts to (char*) are for python 2.4.  */
 410   PyModule_AddStringConstant (gdb_module, "VERSION", (char*) version);
 411   PyModule_AddStringConstant (gdb_module, "HOST_CONFIG", (char*) host_name);
 412   PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG", (char*) target_name);
 413
 414   gdbpy_initialize_values ();
 415   gdbpy_initialize_commands ();
 416   gdbpy_initialize_functions ();
 417
 418   PyRun_SimpleString ("import gdb");
 419
 420   gdbpy_doc_cst = PyString_FromString ("__doc__");
 421
 422   /* Create a couple objects which are used for Python's stdout and
 423      stderr.  */
 424   PyRun_SimpleString ("\
 425 import sys\n\
 426 class GdbOutputFile:\n\
 427   def close(self):\n\
 428     # Do nothing.\n\
 429     return None\n\
 430 \n\
 431   def isatty(self):\n\
 432     return False\n\
 433 \n\
 434   def write(self, s):\n\
 435     gdb.write(s)\n\
 436 \n\
 437   def writelines(self, iterable):\n\
 438     for line in iterable:\n\
 439       self.write(line)\n\
 440 \n\
 441   def flush(self):\n\
 442     gdb.flush()\n\
 443 \n\
 444 sys.stderr = GdbOutputFile()\n\
 445 sys.stdout = GdbOutputFile()\n\
 446 ");
 447
 448   /* Release the GIL while gdb runs.  */
 449   PyThreadState_Swap (NULL);
 450   PyEval_ReleaseLock ();
 451
 452 #endif /* HAVE_PYTHON */
 453 }
 454
 455 \f
 456
 457 #if HAVE_PYTHON
 458
 459 static PyMethodDef GdbMethods[] =
 460 {
 461   { "history", gdbpy_history, METH_VARARGS,
 462     "Get a value from history" },
 463   { "execute", execute_gdb_command, METH_VARARGS,
 464     "Execute a gdb command" },
 465   { "get_parameter", get_parameter, METH_VARARGS,
 466     "Return a gdb parameter's value" },
 467
 468   { "write", gdbpy_write, METH_VARARGS,
 469     "Write a string using gdb's filtered stream." },
 470   { "flush", gdbpy_flush, METH_NOARGS,
 471     "Flush gdb's filtered stdout stream." },
 472
 473   {NULL, NULL, 0, NULL}
 474 };
 475
 476 #endif /* HAVE_PYTHON */