gdb/python/python.c

   1 /* General python/gdb code
   2
   3    Copyright (C) 2008, 2009, 2010 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 "arch-utils.h"
  22 #include "command.h"
  23 #include "ui-out.h"
  24 #include "cli/cli-script.h"
  25 #include "gdbcmd.h"
  26 #include "objfiles.h"
  27 #include "observer.h"
  28 #include "value.h"
  29 #include "language.h"
  30 #include "exceptions.h"
  31
  32 #include <ctype.h>
  33
  34 /* True if we should print the stack when catching a Python error,
  35    false otherwise.  */
  36 static int gdbpy_should_print_stack = 1;
  37
  38 /* This is true if we should auto-load python code when an objfile is
  39    opened, false otherwise.  */
  40 static int gdbpy_auto_load = 1;
  41
  42 #ifdef HAVE_PYTHON
  43
  44 #include "python.h"
  45 #include "libiberty.h"
  46 #include "cli/cli-decode.h"
  47 #include "charset.h"
  48 #include "top.h"
  49 #include "python-internal.h"
  50 #include "version.h"
  51 #include "target.h"
  52 #include "gdbthread.h"
  53
  54 static PyMethodDef GdbMethods[];
  55
  56 PyObject *gdb_module;
  57
  58 /* Some string constants we may wish to use.  */
  59 PyObject *gdbpy_to_string_cst;
  60 PyObject *gdbpy_children_cst;
  61 PyObject *gdbpy_display_hint_cst;
  62 PyObject *gdbpy_doc_cst;
  63
  64
  65 /* Architecture and language to be used in callbacks from
  66    the Python interpreter.  */
  67 struct gdbarch *python_gdbarch;
  68 const struct language_defn *python_language;
  69
  70 /* Restore global language and architecture and Python GIL state
  71    when leaving the Python interpreter.  */
  72
  73 struct python_env
  74 {
  75   PyGILState_STATE state;
  76   struct gdbarch *gdbarch;
  77   const struct language_defn *language;
  78 };
  79
  80 static void
  81 restore_python_env (void *p)
  82 {
  83   struct python_env *env = (struct python_env *)p;
  84   PyGILState_Release (env->state);
  85   python_gdbarch = env->gdbarch;
  86   python_language = env->language;
  87   xfree (env);
  88 }
  89
  90 /* Called before entering the Python interpreter to install the
  91    current language and architecture to be used for Python values.  */
  92
  93 struct cleanup *
  94 ensure_python_env (struct gdbarch *gdbarch,
  95                    const struct language_defn *language)
  96 {
  97   struct python_env *env = xmalloc (sizeof *env);
  98
  99   env->state = PyGILState_Ensure ();
 100   env->gdbarch = python_gdbarch;
 101   env->language = python_language;
 102
 103   python_gdbarch = gdbarch;
 104   python_language = language;
 105
 106   return make_cleanup (restore_python_env, env);
 107 }
 108
 109
 110 /* Given a command_line, return a command string suitable for passing
 111    to Python.  Lines in the string are separated by newlines.  The
 112    return value is allocated using xmalloc and the caller is
 113    responsible for freeing it.  */
 114
 115 static char *
 116 compute_python_string (struct command_line *l)
 117 {
 118   struct command_line *iter;
 119   char *script = NULL;
 120   int size = 0;
 121   int here;
 122
 123   for (iter = l; iter; iter = iter->next)
 124     size += strlen (iter->line) + 1;
 125
 126   script = xmalloc (size + 1);
 127   here = 0;
 128   for (iter = l; iter; iter = iter->next)
 129     {
 130       int len = strlen (iter->line);
 131       strcpy (&script[here], iter->line);
 132       here += len;
 133       script[here++] = '\n';
 134     }
 135   script[here] = '\0';
 136   return script;
 137 }
 138
 139 /* Take a command line structure representing a 'python' command, and
 140    evaluate its body using the Python interpreter.  */
 141
 142 void
 143 eval_python_from_control_command (struct command_line *cmd)
 144 {
 145   int ret;
 146   char *script;
 147   struct cleanup *cleanup;
 148
 149   if (cmd->body_count != 1)
 150     error (_("Invalid \"python\" block structure."));
 151
 152   cleanup = ensure_python_env (get_current_arch (), current_language);
 153
 154   script = compute_python_string (cmd->body_list[0]);
 155   ret = PyRun_SimpleString (script);
 156   xfree (script);
 157   if (ret)
 158     {
 159       gdbpy_print_stack ();
 160       error (_("Error while executing Python code."));
 161     }
 162
 163   do_cleanups (cleanup);
 164 }
 165
 166 /* Implementation of the gdb "python" command.  */
 167
 168 static void
 169 python_command (char *arg, int from_tty)
 170 {
 171   struct cleanup *cleanup;
 172   cleanup = ensure_python_env (get_current_arch (), current_language);
 173
 174   while (arg && *arg && isspace (*arg))
 175     ++arg;
 176   if (arg && *arg)
 177     {
 178       if (PyRun_SimpleString (arg))
 179         {
 180           gdbpy_print_stack ();
 181           error (_("Error while executing Python code."));
 182         }
 183     }
 184   else
 185     {
 186       struct command_line *l = get_command_line (python_control, "");
 187       make_cleanup_free_command_lines (&l);
 188       execute_control_command_untraced (l);
 189     }
 190
 191   do_cleanups (cleanup);
 192 }
 193
 194 \f
 195
 196 /* Transform a gdb parameters's value into a Python value.  May return
 197    NULL (and set a Python exception) on error.  Helper function for
 198    get_parameter.  */
 199
 200 static PyObject *
 201 parameter_to_python (struct cmd_list_element *cmd)
 202 {
 203   switch (cmd->var_type)
 204     {
 205     case var_string:
 206     case var_string_noescape:
 207     case var_optional_filename:
 208     case var_filename:
 209     case var_enum:
 210       {
 211         char *str = * (char **) cmd->var;
 212         if (! str)
 213           str = "";
 214         return PyString_Decode (str, strlen (str), host_charset (), NULL);
 215       }
 216
 217     case var_boolean:
 218       {
 219         if (* (int *) cmd->var)
 220           Py_RETURN_TRUE;
 221         else
 222           Py_RETURN_FALSE;
 223       }
 224
 225     case var_auto_boolean:
 226       {
 227         enum auto_boolean ab = * (enum auto_boolean *) cmd->var;
 228         if (ab == AUTO_BOOLEAN_TRUE)
 229           Py_RETURN_TRUE;
 230         else if (ab == AUTO_BOOLEAN_FALSE)
 231           Py_RETURN_FALSE;
 232         else
 233           Py_RETURN_NONE;
 234       }
 235
 236     case var_integer:
 237       if ((* (int *) cmd->var) == INT_MAX)
 238         Py_RETURN_NONE;
 239       /* Fall through.  */
 240     case var_zinteger:
 241       return PyLong_FromLong (* (int *) cmd->var);
 242
 243     case var_uinteger:
 244       {
 245         unsigned int val = * (unsigned int *) cmd->var;
 246         if (val == UINT_MAX)
 247           Py_RETURN_NONE;
 248         return PyLong_FromUnsignedLong (val);
 249       }
 250     }
 251
 252   return PyErr_Format (PyExc_RuntimeError, "programmer error: unhandled type");
 253 }
 254
 255 /* A Python function which returns a gdb parameter's value as a Python
 256    value.  */
 257
 258 static PyObject *
 259 gdbpy_parameter (PyObject *self, PyObject *args)
 260 {
 261   struct cmd_list_element *alias, *prefix, *cmd;
 262   char *arg, *newarg;
 263   int found = -1;
 264   volatile struct gdb_exception except;
 265
 266   if (! PyArg_ParseTuple (args, "s", &arg))
 267     return NULL;
 268
 269   newarg = concat ("show ", arg, (char *) NULL);
 270
 271   TRY_CATCH (except, RETURN_MASK_ALL)
 272     {
 273       found = lookup_cmd_composition (newarg, &alias, &prefix, &cmd);
 274     }
 275   xfree (newarg);
 276   GDB_PY_HANDLE_EXCEPTION (except);
 277   if (!found)
 278     return PyErr_Format (PyExc_RuntimeError,
 279                          "could not find parameter `%s'", arg);
 280
 281   if (! cmd->var)
 282     return PyErr_Format (PyExc_RuntimeError, "`%s' is not a parameter", arg);
 283   return parameter_to_python (cmd);
 284 }
 285
 286 /* Wrapper for target_charset.  */
 287
 288 static PyObject *
 289 gdbpy_target_charset (PyObject *self, PyObject *args)
 290 {
 291   const char *cset = target_charset (python_gdbarch);
 292   return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL);
 293 }
 294
 295 /* Wrapper for target_wide_charset.  */
 296
 297 static PyObject *
 298 gdbpy_target_wide_charset (PyObject *self, PyObject *args)
 299 {
 300   const char *cset = target_wide_charset (python_gdbarch);
 301   return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL);
 302 }
 303
 304 /* A Python function which evaluates a string using the gdb CLI.  */
 305
 306 static PyObject *
 307 execute_gdb_command (PyObject *self, PyObject *args)
 308 {
 309   struct cmd_list_element *alias, *prefix, *cmd;
 310   char *arg, *newarg;
 311   PyObject *from_tty_obj = NULL;
 312   int from_tty;
 313   int cmp;
 314   volatile struct gdb_exception except;
 315
 316   if (! PyArg_ParseTuple (args, "s|O!", &arg, &PyBool_Type, &from_tty_obj))
 317     return NULL;
 318
 319   from_tty = 0;
 320   if (from_tty_obj)
 321     {
 322       cmp = PyObject_IsTrue (from_tty_obj);
 323       if (cmp < 0)
 324           return NULL;
 325       from_tty = cmp;
 326     }
 327
 328   TRY_CATCH (except, RETURN_MASK_ALL)
 329     {
 330       /* Copy the argument text in case the command modifies it.  */
 331       char *copy = xstrdup (arg);
 332       struct cleanup *cleanup = make_cleanup (xfree, copy);
 333       execute_command (copy, from_tty);
 334       do_cleanups (cleanup);
 335     }
 336   GDB_PY_HANDLE_EXCEPTION (except);
 337
 338   /* Do any commands attached to breakpoint we stopped at.  */
 339   bpstat_do_actions ();
 340
 341   Py_RETURN_NONE;
 342 }
 343
 344 /* Parse a string and evaluate it as an expression.  */
 345 static PyObject *
 346 gdbpy_parse_and_eval (PyObject *self, PyObject *args)
 347 {
 348   char *expr_str;
 349   struct value *result = NULL;
 350   volatile struct gdb_exception except;
 351
 352   if (!PyArg_ParseTuple (args, "s", &expr_str))
 353     return NULL;
 354
 355   TRY_CATCH (except, RETURN_MASK_ALL)
 356     {
 357       result = parse_and_eval (expr_str);
 358     }
 359   GDB_PY_HANDLE_EXCEPTION (except);
 360
 361   return value_to_value_object (result);
 362 }
 363
 364 /* Read a file as Python code.  STREAM is the input file; FILE is the
 365    name of the file.  */
 366
 367 void
 368 source_python_script (FILE *stream, char *file)
 369 {
 370   PyGILState_STATE state;
 371
 372   state = PyGILState_Ensure ();
 373
 374   PyRun_SimpleFile (stream, file);
 375
 376   fclose (stream);
 377   PyGILState_Release (state);
 378 }
 379
 380 \f
 381
 382 /* Printing.  */
 383
 384 /* A python function to write a single string using gdb's filtered
 385    output stream.  */
 386 static PyObject *
 387 gdbpy_write (PyObject *self, PyObject *args)
 388 {
 389   char *arg;
 390   if (! PyArg_ParseTuple (args, "s", &arg))
 391     return NULL;
 392   printf_filtered ("%s", arg);
 393   Py_RETURN_NONE;
 394 }
 395
 396 /* A python function to flush gdb's filtered output stream.  */
 397 static PyObject *
 398 gdbpy_flush (PyObject *self, PyObject *args)
 399 {
 400   gdb_flush (gdb_stdout);
 401   Py_RETURN_NONE;
 402 }
 403
 404 /* Print a python exception trace, or print nothing and clear the
 405    python exception, depending on gdbpy_should_print_stack.  Only call
 406    this if a python exception is set.  */
 407 void
 408 gdbpy_print_stack (void)
 409 {
 410   if (gdbpy_should_print_stack)
 411     PyErr_Print ();
 412   else
 413     PyErr_Clear ();
 414 }
 415
 416 \f
 417
 418 /* The "current" objfile.  This is set when gdb detects that a new
 419    objfile has been loaded.  It is only set for the duration of a call
 420    to gdbpy_new_objfile; it is NULL at other times.  */
 421 static struct objfile *gdbpy_current_objfile;
 422
 423 /* The file name we attempt to read.  */
 424 #define GDBPY_AUTO_FILENAME "-gdb.py"
 425
 426 /* This is a new_objfile observer callback which loads python code
 427    based on the path to the objfile.  */
 428 static void
 429 gdbpy_new_objfile (struct objfile *objfile)
 430 {
 431   char *realname;
 432   char *filename, *debugfile;
 433   int len;
 434   FILE *input;
 435   struct cleanup *cleanups;
 436
 437   if (!gdbpy_auto_load || !objfile || !objfile->name)
 438     return;
 439
 440   cleanups = ensure_python_env (get_objfile_arch (objfile), current_language);
 441
 442   gdbpy_current_objfile = objfile;
 443
 444   realname = gdb_realpath (objfile->name);
 445   len = strlen (realname);
 446   filename = xmalloc (len + sizeof (GDBPY_AUTO_FILENAME));
 447   memcpy (filename, realname, len);
 448   strcpy (filename + len, GDBPY_AUTO_FILENAME);
 449
 450   input = fopen (filename, "r");
 451   debugfile = filename;
 452
 453   make_cleanup (xfree, filename);
 454   make_cleanup (xfree, realname);
 455
 456   if (!input && debug_file_directory)
 457     {
 458       /* Also try the same file in the separate debug info directory.  */
 459       debugfile = xmalloc (strlen (filename)
 460                            + strlen (debug_file_directory) + 1);
 461       strcpy (debugfile, debug_file_directory);
 462       /* FILENAME is absolute, so we don't need a "/" here.  */
 463       strcat (debugfile, filename);
 464
 465       make_cleanup (xfree, debugfile);
 466       input = fopen (debugfile, "r");
 467     }
 468
 469   if (!input && gdb_datadir)
 470     {
 471       /* Also try the same file in a subdirectory of gdb's data
 472          directory.  */
 473       debugfile = xmalloc (strlen (gdb_datadir) + strlen (filename)
 474                            + strlen ("/auto-load") + 1);
 475       strcpy (debugfile, gdb_datadir);
 476       strcat (debugfile, "/auto-load");
 477       /* FILENAME is absolute, so we don't need a "/" here.  */
 478       strcat (debugfile, filename);
 479
 480       make_cleanup (xfree, debugfile);
 481       input = fopen (debugfile, "r");
 482     }
 483
 484   if (input)
 485     {
 486       /* We don't want to throw an exception here -- but the user
 487          would like to know that something went wrong.  */
 488       if (PyRun_SimpleFile (input, debugfile))
 489         gdbpy_print_stack ();
 490       fclose (input);
 491     }
 492
 493   do_cleanups (cleanups);
 494   gdbpy_current_objfile = NULL;
 495 }
 496
 497 /* Return the current Objfile, or None if there isn't one.  */
 498 static PyObject *
 499 gdbpy_get_current_objfile (PyObject *unused1, PyObject *unused2)
 500 {
 501   PyObject *result;
 502
 503   if (! gdbpy_current_objfile)
 504     Py_RETURN_NONE;
 505
 506   result = objfile_to_objfile_object (gdbpy_current_objfile);
 507   if (result)
 508     Py_INCREF (result);
 509   return result;
 510 }
 511
 512 /* Return a sequence holding all the Objfiles.  */
 513 static PyObject *
 514 gdbpy_objfiles (PyObject *unused1, PyObject *unused2)
 515 {
 516   struct objfile *objf;
 517   PyObject *list;
 518
 519   list = PyList_New (0);
 520   if (!list)
 521     return NULL;
 522
 523   ALL_OBJFILES (objf)
 524   {
 525     PyObject *item = objfile_to_objfile_object (objf);
 526     if (!item || PyList_Append (list, item) == -1)
 527       {
 528         Py_DECREF (list);
 529         return NULL;
 530       }
 531   }
 532
 533   return list;
 534 }
 535
 536 #else /* HAVE_PYTHON */
 537
 538 /* Dummy implementation of the gdb "python" command.  */
 539
 540 static void
 541 python_command (char *arg, int from_tty)
 542 {
 543   while (arg && *arg && isspace (*arg))
 544     ++arg;
 545   if (arg && *arg)
 546     error (_("Python scripting is not supported in this copy of GDB."));
 547   else
 548     {
 549       struct command_line *l = get_command_line (python_control, "");
 550       struct cleanup *cleanups = make_cleanup_free_command_lines (&l);
 551       execute_control_command_untraced (l);
 552       do_cleanups (cleanups);
 553     }
 554 }
 555
 556 void
 557 eval_python_from_control_command (struct command_line *cmd)
 558 {
 559   error (_("Python scripting is not supported in this copy of GDB."));
 560 }
 561
 562 void
 563 source_python_script (FILE *stream, char *file)
 564 {
 565   fclose (stream);
 566   throw_error (UNSUPPORTED_ERROR,
 567                _("Python scripting is not supported in this copy of GDB."));
 568 }
 569
 570 #endif /* HAVE_PYTHON */
 571
 572 \f
 573
 574 /* Lists for 'maint set python' commands.  */
 575
 576 static struct cmd_list_element *set_python_list;
 577 static struct cmd_list_element *show_python_list;
 578
 579 /* Function for use by 'maint set python' prefix command.  */
 580
 581 static void
 582 set_python (char *args, int from_tty)
 583 {
 584   help_list (set_python_list, "maintenance set python ", -1, gdb_stdout);
 585 }
 586
 587 /* Function for use by 'maint show python' prefix command.  */
 588
 589 static void
 590 show_python (char *args, int from_tty)
 591 {
 592   cmd_show_list (show_python_list, from_tty, "");
 593 }
 594
 595 /* Initialize the Python code.  */
 596
 597 /* Provide a prototype to silence -Wmissing-prototypes.  */
 598 extern initialize_file_ftype _initialize_python;
 599
 600 void
 601 _initialize_python (void)
 602 {
 603   add_com ("python", class_obscure, python_command,
 604 #ifdef HAVE_PYTHON
 605            _("\
 606 Evaluate a Python command.\n\
 607 \n\
 608 The command can be given as an argument, for instance:\n\
 609 \n\
 610     python print 23\n\
 611 \n\
 612 If no argument is given, the following lines are read and used\n\
 613 as the Python commands.  Type a line containing \"end\" to indicate\n\
 614 the end of the command.")
 615 #else /* HAVE_PYTHON */
 616            _("\
 617 Evaluate a Python command.\n\
 618 \n\
 619 Python scripting is not supported in this copy of GDB.\n\
 620 This command is only a placeholder.")
 621 #endif /* HAVE_PYTHON */
 622            );
 623
 624   add_prefix_cmd ("python", no_class, show_python,
 625                   _("Prefix command for python maintenance settings."),
 626                   &show_python_list, "maintenance show python ", 0,
 627                   &maintenance_show_cmdlist);
 628   add_prefix_cmd ("python", no_class, set_python,
 629                   _("Prefix command for python maintenance settings."),
 630                   &set_python_list, "maintenance set python ", 0,
 631                   &maintenance_set_cmdlist);
 632
 633   add_setshow_boolean_cmd ("print-stack", class_maintenance,
 634                            &gdbpy_should_print_stack, _("\
 635 Enable or disable printing of Python stack dump on error."), _("\
 636 Show whether Python stack will be printed on error."), _("\
 637 Enables or disables printing of Python stack traces."),
 638                            NULL, NULL,
 639                            &set_python_list,
 640                            &show_python_list);
 641
 642   add_setshow_boolean_cmd ("auto-load", class_maintenance,
 643                            &gdbpy_auto_load, _("\
 644 Enable or disable auto-loading of Python code when an object is opened."), _("\
 645 Show whether Python code will be auto-loaded when an object is opened."), _("\
 646 Enables or disables auto-loading of Python code when an object is opened."),
 647                            NULL, NULL,
 648                            &set_python_list,
 649                            &show_python_list);
 650
 651 #ifdef HAVE_PYTHON
 652   Py_Initialize ();
 653   PyEval_InitThreads ();
 654
 655   gdb_module = Py_InitModule ("gdb", GdbMethods);
 656
 657   /* The casts to (char*) are for python 2.4.  */
 658   PyModule_AddStringConstant (gdb_module, "VERSION", (char*) version);
 659   PyModule_AddStringConstant (gdb_module, "HOST_CONFIG", (char*) host_name);
 660   PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG", (char*) target_name);
 661
 662   gdbpy_initialize_values ();
 663   gdbpy_initialize_frames ();
 664   gdbpy_initialize_commands ();
 665   gdbpy_initialize_symbols ();
 666   gdbpy_initialize_symtabs ();
 667   gdbpy_initialize_blocks ();
 668   gdbpy_initialize_functions ();
 669   gdbpy_initialize_types ();
 670   gdbpy_initialize_objfile ();
 671   gdbpy_initialize_lazy_string ();
 672
 673   PyRun_SimpleString ("import gdb");
 674   PyRun_SimpleString ("gdb.pretty_printers = []");
 675
 676   observer_attach_new_objfile (gdbpy_new_objfile);
 677
 678   gdbpy_to_string_cst = PyString_FromString ("to_string");
 679   gdbpy_children_cst = PyString_FromString ("children");
 680   gdbpy_display_hint_cst = PyString_FromString ("display_hint");
 681   gdbpy_doc_cst = PyString_FromString ("__doc__");
 682
 683   /* Create a couple objects which are used for Python's stdout and
 684      stderr.  */
 685   PyRun_SimpleString ("\
 686 import sys\n\
 687 class GdbOutputFile:\n\
 688   def close(self):\n\
 689     # Do nothing.\n\
 690     return None\n\
 691 \n\
 692   def isatty(self):\n\
 693     return False\n\
 694 \n\
 695   def write(self, s):\n\
 696     gdb.write(s)\n\
 697 \n\
 698   def writelines(self, iterable):\n\
 699     for line in iterable:\n\
 700       self.write(line)\n\
 701 \n\
 702   def flush(self):\n\
 703     gdb.flush()\n\
 704 \n\
 705 sys.stderr = GdbOutputFile()\n\
 706 sys.stdout = GdbOutputFile()\n\
 707 ");
 708
 709   /* Release the GIL while gdb runs.  */
 710   PyThreadState_Swap (NULL);
 711   PyEval_ReleaseLock ();
 712
 713 #endif /* HAVE_PYTHON */
 714 }
 715
 716 \f
 717
 718 #if HAVE_PYTHON
 719
 720 static PyMethodDef GdbMethods[] =
 721 {
 722   { "history", gdbpy_history, METH_VARARGS,
 723     "Get a value from history" },
 724   { "execute", execute_gdb_command, METH_VARARGS,
 725     "Execute a gdb command" },
 726   { "parameter", gdbpy_parameter, METH_VARARGS,
 727     "Return a gdb parameter's value" },
 728
 729   { "default_visualizer", gdbpy_default_visualizer, METH_VARARGS,
 730     "Find the default visualizer for a Value." },
 731
 732   { "current_objfile", gdbpy_get_current_objfile, METH_NOARGS,
 733     "Return the current Objfile being loaded, or None." },
 734   { "objfiles", gdbpy_objfiles, METH_NOARGS,
 735     "Return a sequence of all loaded objfiles." },
 736
 737   { "selected_frame", gdbpy_selected_frame, METH_NOARGS,
 738     "selected_frame () -> gdb.Frame.\n\
 739 Return the selected frame object." },
 740   { "frame_stop_reason_string", gdbpy_frame_stop_reason_string, METH_VARARGS,
 741     "stop_reason_string (Integer) -> String.\n\
 742 Return a string explaining unwind stop reason." },
 743
 744   { "lookup_type", (PyCFunction) gdbpy_lookup_type,
 745     METH_VARARGS | METH_KEYWORDS,
 746     "lookup_type (name [, block]) -> type\n\
 747 Return a Type corresponding to the given name." },
 748   { "lookup_symbol", (PyCFunction) gdbpy_lookup_symbol,
 749     METH_VARARGS | METH_KEYWORDS,
 750     "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
 751 Return a tuple with the symbol corresponding to the given name (or None) and\n\
 752 a boolean indicating if name is a field of the current implied argument\n\
 753 `this' (when the current language is object-oriented)." },
 754   { "block_for_pc", gdbpy_block_for_pc, METH_VARARGS,
 755     "Return the block containing the given pc value, or None." },
 756   { "parse_and_eval", gdbpy_parse_and_eval, METH_VARARGS,
 757     "parse_and_eval (String) -> Value.\n\
 758 Parse String as an expression, evaluate it, and return the result as a Value."
 759   },
 760
 761   { "target_charset", gdbpy_target_charset, METH_NOARGS,
 762     "target_charset () -> string.\n\
 763 Return the name of the current target charset." },
 764   { "target_wide_charset", gdbpy_target_wide_charset, METH_NOARGS,
 765     "target_wide_charset () -> string.\n\
 766 Return the name of the current target wide charset." },
 767
 768   { "write", gdbpy_write, METH_VARARGS,
 769     "Write a string using gdb's filtered stream." },
 770   { "flush", gdbpy_flush, METH_NOARGS,
 771     "Flush gdb's filtered stdout stream." },
 772
 773   {NULL, NULL, 0, NULL}
 774 };
 775
 776 #endif /* HAVE_PYTHON */