gdb/python/python.c

   1 /* General python/gdb code
   2
   3    Copyright (C) 2008-2012 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 "progspace.h"
  27 #include "objfiles.h"
  28 #include "value.h"
  29 #include "language.h"
  30 #include "exceptions.h"
  31 #include "event-loop.h"
  32 #include "serial.h"
  33 #include "readline/tilde.h"
  34 #include "python.h"
  35
  36 #include <ctype.h>
  37
  38 /* Declared constants and enum for python stack printing.  */
  39 static const char python_excp_none[] = "none";
  40 static const char python_excp_full[] = "full";
  41 static const char python_excp_message[] = "message";
  42
  43 /* "set python print-stack" choices.  */
  44 static const char *const python_excp_enums[] =
  45   {
  46     python_excp_none,
  47     python_excp_full,
  48     python_excp_message,
  49     NULL
  50   };
  51
  52 /* The exception printing variable.  'full' if we want to print the
  53    error message and stack, 'none' if we want to print nothing, and
  54    'message' if we only want to print the error message.  'message' is
  55    the default.  */
  56 static const char *gdbpy_should_print_stack = python_excp_message;
  57
  58 #ifdef HAVE_PYTHON
  59
  60 #include "libiberty.h"
  61 #include "cli/cli-decode.h"
  62 #include "charset.h"
  63 #include "top.h"
  64 #include "solib.h"
  65 #include "python-internal.h"
  66 #include "linespec.h"
  67 #include "source.h"
  68 #include "version.h"
  69 #include "target.h"
  70 #include "gdbthread.h"
  71 #include "observer.h"
  72 #include "interps.h"
  73
  74 static PyMethodDef GdbMethods[];
  75
  76 PyObject *gdb_module;
  77
  78 /* Some string constants we may wish to use.  */
  79 PyObject *gdbpy_to_string_cst;
  80 PyObject *gdbpy_children_cst;
  81 PyObject *gdbpy_display_hint_cst;
  82 PyObject *gdbpy_doc_cst;
  83 PyObject *gdbpy_enabled_cst;
  84 PyObject *gdbpy_value_cst;
  85
  86 /* The GdbError exception.  */
  87 PyObject *gdbpy_gdberror_exc;
  88
  89 /* The `gdb.error' base class.  */
  90 PyObject *gdbpy_gdb_error;
  91
  92 /* The `gdb.MemoryError' exception.  */
  93 PyObject *gdbpy_gdb_memory_error;
  94
  95 /* Architecture and language to be used in callbacks from
  96    the Python interpreter.  */
  97 struct gdbarch *python_gdbarch;
  98 const struct language_defn *python_language;
  99
 100 /* Restore global language and architecture and Python GIL state
 101    when leaving the Python interpreter.  */
 102
 103 struct python_env
 104 {
 105   PyGILState_STATE state;
 106   struct gdbarch *gdbarch;
 107   const struct language_defn *language;
 108   PyObject *error_type, *error_value, *error_traceback;
 109 };
 110
 111 static void
 112 restore_python_env (void *p)
 113 {
 114   struct python_env *env = (struct python_env *)p;
 115
 116   /* Leftover Python error is forbidden by Python Exception Handling.  */
 117   if (PyErr_Occurred ())
 118     {
 119       /* This order is similar to the one calling error afterwards. */
 120       gdbpy_print_stack ();
 121       warning (_("internal error: Unhandled Python exception"));
 122     }
 123
 124   PyErr_Restore (env->error_type, env->error_value, env->error_traceback);
 125
 126   PyGILState_Release (env->state);
 127   python_gdbarch = env->gdbarch;
 128   python_language = env->language;
 129   xfree (env);
 130 }
 131
 132 /* Called before entering the Python interpreter to install the
 133    current language and architecture to be used for Python values.  */
 134
 135 struct cleanup *
 136 ensure_python_env (struct gdbarch *gdbarch,
 137                    const struct language_defn *language)
 138 {
 139   struct python_env *env = xmalloc (sizeof *env);
 140
 141   env->state = PyGILState_Ensure ();
 142   env->gdbarch = python_gdbarch;
 143   env->language = python_language;
 144
 145   python_gdbarch = gdbarch;
 146   python_language = language;
 147
 148   /* Save it and ensure ! PyErr_Occurred () afterwards.  */
 149   PyErr_Fetch (&env->error_type, &env->error_value, &env->error_traceback);
 150
 151   return make_cleanup (restore_python_env, env);
 152 }
 153
 154 /* A wrapper around PyRun_SimpleFile.  FILE is the Python script to run
 155    named FILENAME.
 156
 157    On Windows hosts few users would build Python themselves (this is no
 158    trivial task on this platform), and thus use binaries built by
 159    someone else instead.  There may happen situation where the Python
 160    library and GDB are using two different versions of the C runtime
 161    library.  Python, being built with VC, would use one version of the
 162    msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
 163    A FILE * from one runtime does not necessarily operate correctly in
 164    the other runtime.
 165
 166    To work around this potential issue, we create on Windows hosts the
 167    FILE object using Python routines, thus making sure that it is
 168    compatible with the Python library.  */
 169
 170 static void
 171 python_run_simple_file (FILE *file, const char *filename)
 172 {
 173 #ifndef _WIN32
 174
 175   PyRun_SimpleFile (file, filename);
 176
 177 #else /* _WIN32 */
 178
 179   char *full_path;
 180   PyObject *python_file;
 181   struct cleanup *cleanup;
 182
 183   /* Because we have a string for a filename, and are using Python to
 184      open the file, we need to expand any tilde in the path first.  */
 185   full_path = tilde_expand (filename);
 186   cleanup = make_cleanup (xfree, full_path);
 187   python_file = PyFile_FromString (full_path, "r");
 188   if (! python_file)
 189     {
 190       do_cleanups (cleanup);
 191       gdbpy_print_stack ();
 192       error (_("Error while opening file: %s"), full_path);
 193     }
 194
 195   make_cleanup_py_decref (python_file);
 196   PyRun_SimpleFile (PyFile_AsFile (python_file), filename);
 197   do_cleanups (cleanup);
 198
 199 #endif /* _WIN32 */
 200 }
 201
 202 /* Given a command_line, return a command string suitable for passing
 203    to Python.  Lines in the string are separated by newlines.  The
 204    return value is allocated using xmalloc and the caller is
 205    responsible for freeing it.  */
 206
 207 static char *
 208 compute_python_string (struct command_line *l)
 209 {
 210   struct command_line *iter;
 211   char *script = NULL;
 212   int size = 0;
 213   int here;
 214
 215   for (iter = l; iter; iter = iter->next)
 216     size += strlen (iter->line) + 1;
 217
 218   script = xmalloc (size + 1);
 219   here = 0;
 220   for (iter = l; iter; iter = iter->next)
 221     {
 222       int len = strlen (iter->line);
 223
 224       strcpy (&script[here], iter->line);
 225       here += len;
 226       script[here++] = '\n';
 227     }
 228   script[here] = '\0';
 229   return script;
 230 }
 231
 232 /* Take a command line structure representing a 'python' command, and
 233    evaluate its body using the Python interpreter.  */
 234
 235 void
 236 eval_python_from_control_command (struct command_line *cmd)
 237 {
 238   int ret;
 239   char *script;
 240   struct cleanup *cleanup;
 241
 242   if (cmd->body_count != 1)
 243     error (_("Invalid \"python\" block structure."));
 244
 245   cleanup = ensure_python_env (get_current_arch (), current_language);
 246
 247   script = compute_python_string (cmd->body_list[0]);
 248   ret = PyRun_SimpleString (script);
 249   xfree (script);
 250   if (ret)
 251     error (_("Error while executing Python code."));
 252
 253   do_cleanups (cleanup);
 254 }
 255
 256 /* Implementation of the gdb "python" command.  */
 257
 258 static void
 259 python_command (char *arg, int from_tty)
 260 {
 261   struct cleanup *cleanup;
 262
 263   cleanup = ensure_python_env (get_current_arch (), current_language);
 264
 265   make_cleanup_restore_integer (&interpreter_async);
 266   interpreter_async = 0;
 267
 268   while (arg && *arg && isspace (*arg))
 269     ++arg;
 270   if (arg && *arg)
 271     {
 272       if (PyRun_SimpleString (arg))
 273         error (_("Error while executing Python code."));
 274     }
 275   else
 276     {
 277       struct command_line *l = get_command_line (python_control, "");
 278
 279       make_cleanup_free_command_lines (&l);
 280       execute_control_command_untraced (l);
 281     }
 282
 283   do_cleanups (cleanup);
 284 }
 285
 286 \f
 287
 288 /* Transform a gdb parameters's value into a Python value.  May return
 289    NULL (and set a Python exception) on error.  Helper function for
 290    get_parameter.  */
 291 PyObject *
 292 gdbpy_parameter_value (enum var_types type, void *var)
 293 {
 294   switch (type)
 295     {
 296     case var_string:
 297     case var_string_noescape:
 298     case var_optional_filename:
 299     case var_filename:
 300     case var_enum:
 301       {
 302         char *str = * (char **) var;
 303
 304         if (! str)
 305           str = "";
 306         return PyString_Decode (str, strlen (str), host_charset (), NULL);
 307       }
 308
 309     case var_boolean:
 310       {
 311         if (* (int *) var)
 312           Py_RETURN_TRUE;
 313         else
 314           Py_RETURN_FALSE;
 315       }
 316
 317     case var_auto_boolean:
 318       {
 319         enum auto_boolean ab = * (enum auto_boolean *) var;
 320
 321         if (ab == AUTO_BOOLEAN_TRUE)
 322           Py_RETURN_TRUE;
 323         else if (ab == AUTO_BOOLEAN_FALSE)
 324           Py_RETURN_FALSE;
 325         else
 326           Py_RETURN_NONE;
 327       }
 328
 329     case var_integer:
 330       if ((* (int *) var) == INT_MAX)
 331         Py_RETURN_NONE;
 332       /* Fall through.  */
 333     case var_zinteger:
 334       return PyLong_FromLong (* (int *) var);
 335
 336     case var_uinteger:
 337       {
 338         unsigned int val = * (unsigned int *) var;
 339
 340         if (val == UINT_MAX)
 341           Py_RETURN_NONE;
 342         return PyLong_FromUnsignedLong (val);
 343       }
 344     }
 345
 346   return PyErr_Format (PyExc_RuntimeError,
 347                        _("Programmer error: unhandled type."));
 348 }
 349
 350 /* A Python function which returns a gdb parameter's value as a Python
 351    value.  */
 352
 353 PyObject *
 354 gdbpy_parameter (PyObject *self, PyObject *args)
 355 {
 356   struct cmd_list_element *alias, *prefix, *cmd;
 357   const char *arg;
 358   char *newarg;
 359   int found = -1;
 360   volatile struct gdb_exception except;
 361
 362   if (! PyArg_ParseTuple (args, "s", &arg))
 363     return NULL;
 364
 365   newarg = concat ("show ", arg, (char *) NULL);
 366
 367   TRY_CATCH (except, RETURN_MASK_ALL)
 368     {
 369       found = lookup_cmd_composition (newarg, &alias, &prefix, &cmd);
 370     }
 371   xfree (newarg);
 372   GDB_PY_HANDLE_EXCEPTION (except);
 373   if (!found)
 374     return PyErr_Format (PyExc_RuntimeError,
 375                          _("Could not find parameter `%s'."), arg);
 376
 377   if (! cmd->var)
 378     return PyErr_Format (PyExc_RuntimeError,
 379                          _("`%s' is not a parameter."), arg);
 380   return gdbpy_parameter_value (cmd->var_type, cmd->var);
 381 }
 382
 383 /* Wrapper for target_charset.  */
 384
 385 static PyObject *
 386 gdbpy_target_charset (PyObject *self, PyObject *args)
 387 {
 388   const char *cset = target_charset (python_gdbarch);
 389
 390   return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL);
 391 }
 392
 393 /* Wrapper for target_wide_charset.  */
 394
 395 static PyObject *
 396 gdbpy_target_wide_charset (PyObject *self, PyObject *args)
 397 {
 398   const char *cset = target_wide_charset (python_gdbarch);
 399
 400   return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL);
 401 }
 402
 403 /* A Python function which evaluates a string using the gdb CLI.  */
 404
 405 static PyObject *
 406 execute_gdb_command (PyObject *self, PyObject *args, PyObject *kw)
 407 {
 408   const char *arg;
 409   PyObject *from_tty_obj = NULL, *to_string_obj = NULL;
 410   int from_tty, to_string;
 411   volatile struct gdb_exception except;
 412   static char *keywords[] = {"command", "from_tty", "to_string", NULL };
 413   char *result = NULL;
 414
 415   if (! PyArg_ParseTupleAndKeywords (args, kw, "s|O!O!", keywords, &arg,
 416                                      &PyBool_Type, &from_tty_obj,
 417                                      &PyBool_Type, &to_string_obj))
 418     return NULL;
 419
 420   from_tty = 0;
 421   if (from_tty_obj)
 422     {
 423       int cmp = PyObject_IsTrue (from_tty_obj);
 424       if (cmp < 0)
 425         return NULL;
 426       from_tty = cmp;
 427     }
 428
 429   to_string = 0;
 430   if (to_string_obj)
 431     {
 432       int cmp = PyObject_IsTrue (to_string_obj);
 433       if (cmp < 0)
 434         return NULL;
 435       to_string = cmp;
 436     }
 437
 438   TRY_CATCH (except, RETURN_MASK_ALL)
 439     {
 440       /* Copy the argument text in case the command modifies it.  */
 441       char *copy = xstrdup (arg);
 442       struct cleanup *cleanup = make_cleanup (xfree, copy);
 443
 444       make_cleanup_restore_integer (&interpreter_async);
 445       interpreter_async = 0;
 446
 447       prevent_dont_repeat ();
 448       if (to_string)
 449         result = execute_command_to_string (copy, from_tty);
 450       else
 451         {
 452           result = NULL;
 453           execute_command (copy, from_tty);
 454         }
 455
 456       do_cleanups (cleanup);
 457     }
 458   GDB_PY_HANDLE_EXCEPTION (except);
 459
 460   /* Do any commands attached to breakpoint we stopped at.  */
 461   bpstat_do_actions ();
 462
 463   if (result)
 464     {
 465       PyObject *r = PyString_FromString (result);
 466       xfree (result);
 467       return r;
 468     }
 469   Py_RETURN_NONE;
 470 }
 471
 472 /* Implementation of gdb.solib_name (Long) -> String.
 473    Returns the name of the shared library holding a given address, or None.  */
 474
 475 static PyObject *
 476 gdbpy_solib_name (PyObject *self, PyObject *args)
 477 {
 478   char *soname;
 479   PyObject *str_obj;
 480   gdb_py_longest pc;
 481
 482   if (!PyArg_ParseTuple (args, GDB_PY_LL_ARG, &pc))
 483     return NULL;
 484
 485   soname = solib_name_from_address (current_program_space, pc);
 486   if (soname)
 487     str_obj = PyString_Decode (soname, strlen (soname), host_charset (), NULL);
 488   else
 489     {
 490       str_obj = Py_None;
 491       Py_INCREF (Py_None);
 492     }
 493
 494   return str_obj;
 495 }
 496
 497 /* A Python function which is a wrapper for decode_line_1.  */
 498
 499 static PyObject *
 500 gdbpy_decode_line (PyObject *self, PyObject *args)
 501 {
 502   struct symtabs_and_lines sals = { NULL, 0 }; /* Initialize to
 503                                                   appease gcc.  */
 504   struct symtab_and_line sal;
 505   const char *arg = NULL;
 506   char *copy = NULL;
 507   struct cleanup *cleanups;
 508   PyObject *result = NULL;
 509   PyObject *return_result = NULL;
 510   PyObject *unparsed = NULL;
 511   volatile struct gdb_exception except;
 512
 513   if (! PyArg_ParseTuple (args, "|s", &arg))
 514     return NULL;
 515
 516   cleanups = make_cleanup (null_cleanup, NULL);
 517
 518   TRY_CATCH (except, RETURN_MASK_ALL)
 519     {
 520       if (arg)
 521         {
 522           copy = xstrdup (arg);
 523           make_cleanup (xfree, copy);
 524           sals = decode_line_1 (&copy, 0, 0, 0);
 525           make_cleanup (xfree, sals.sals);
 526         }
 527       else
 528         {
 529           set_default_source_symtab_and_line ();
 530           sal = get_current_source_symtab_and_line ();
 531           sals.sals = &sal;
 532           sals.nelts = 1;
 533         }
 534     }
 535   if (except.reason < 0)
 536     {
 537       do_cleanups (cleanups);
 538       /* We know this will always throw.  */
 539       GDB_PY_HANDLE_EXCEPTION (except);
 540     }
 541
 542   if (sals.nelts)
 543     {
 544       int i;
 545
 546       result = PyTuple_New (sals.nelts);
 547       if (! result)
 548         goto error;
 549       for (i = 0; i < sals.nelts; ++i)
 550         {
 551           PyObject *obj;
 552           char *str;
 553
 554           obj = symtab_and_line_to_sal_object (sals.sals[i]);
 555           if (! obj)
 556             {
 557               Py_DECREF (result);
 558               goto error;
 559             }
 560
 561           PyTuple_SetItem (result, i, obj);
 562         }
 563     }
 564   else
 565     {
 566       result = Py_None;
 567       Py_INCREF (Py_None);
 568     }
 569
 570   return_result = PyTuple_New (2);
 571   if (! return_result)
 572     {
 573       Py_DECREF (result);
 574       goto error;
 575     }
 576
 577   if (copy && strlen (copy) > 0)
 578     unparsed = PyString_FromString (copy);
 579   else
 580     {
 581       unparsed = Py_None;
 582       Py_INCREF (Py_None);
 583     }
 584
 585   PyTuple_SetItem (return_result, 0, unparsed);
 586   PyTuple_SetItem (return_result, 1, result);
 587
 588   do_cleanups (cleanups);
 589
 590   return return_result;
 591
 592  error:
 593   do_cleanups (cleanups);
 594   return NULL;
 595 }
 596
 597 /* Parse a string and evaluate it as an expression.  */
 598 static PyObject *
 599 gdbpy_parse_and_eval (PyObject *self, PyObject *args)
 600 {
 601   const char *expr_str;
 602   struct value *result = NULL;
 603   volatile struct gdb_exception except;
 604
 605   if (!PyArg_ParseTuple (args, "s", &expr_str))
 606     return NULL;
 607
 608   TRY_CATCH (except, RETURN_MASK_ALL)
 609     {
 610       char *copy = xstrdup (expr_str);
 611       struct cleanup *cleanup = make_cleanup (xfree, copy);
 612
 613       result = parse_and_eval (copy);
 614       do_cleanups (cleanup);
 615     }
 616   GDB_PY_HANDLE_EXCEPTION (except);
 617
 618   return value_to_value_object (result);
 619 }
 620
 621 /* Read a file as Python code.
 622    FILE is the file to run.  FILENAME is name of the file FILE.
 623    This does not throw any errors.  If an exception occurs python will print
 624    the traceback and clear the error indicator.  */
 625
 626 void
 627 source_python_script (FILE *file, const char *filename)
 628 {
 629   struct cleanup *cleanup;
 630
 631   cleanup = ensure_python_env (get_current_arch (), current_language);
 632   python_run_simple_file (file, filename);
 633   do_cleanups (cleanup);
 634 }
 635
 636 \f
 637
 638 /* Posting and handling events.  */
 639
 640 /* A single event.  */
 641 struct gdbpy_event
 642 {
 643   /* The Python event.  This is just a callable object.  */
 644   PyObject *event;
 645   /* The next event.  */
 646   struct gdbpy_event *next;
 647 };
 648
 649 /* All pending events.  */
 650 static struct gdbpy_event *gdbpy_event_list;
 651 /* The final link of the event list.  */
 652 static struct gdbpy_event **gdbpy_event_list_end;
 653
 654 /* We use a file handler, and not an async handler, so that we can
 655    wake up the main thread even when it is blocked in poll().  */
 656 static struct serial *gdbpy_event_fds[2];
 657
 658 /* The file handler callback.  This reads from the internal pipe, and
 659    then processes the Python event queue.  This will always be run in
 660    the main gdb thread.  */
 661
 662 static void
 663 gdbpy_run_events (struct serial *scb, void *context)
 664 {
 665   struct cleanup *cleanup;
 666   int r;
 667
 668   cleanup = ensure_python_env (get_current_arch (), current_language);
 669
 670   /* Flush the fd.  Do this before flushing the events list, so that
 671      any new event post afterwards is sure to re-awake the event
 672      loop.  */
 673   while (serial_readchar (gdbpy_event_fds[0], 0) >= 0)
 674     ;
 675
 676   while (gdbpy_event_list)
 677     {
 678       /* Dispatching the event might push a new element onto the event
 679          loop, so we update here "atomically enough".  */
 680       struct gdbpy_event *item = gdbpy_event_list;
 681       gdbpy_event_list = gdbpy_event_list->next;
 682       if (gdbpy_event_list == NULL)
 683         gdbpy_event_list_end = &gdbpy_event_list;
 684
 685       /* Ignore errors.  */
 686       if (PyObject_CallObject (item->event, NULL) == NULL)
 687         PyErr_Clear ();
 688
 689       Py_DECREF (item->event);
 690       xfree (item);
 691     }
 692
 693   do_cleanups (cleanup);
 694 }
 695
 696 /* Submit an event to the gdb thread.  */
 697 static PyObject *
 698 gdbpy_post_event (PyObject *self, PyObject *args)
 699 {
 700   struct gdbpy_event *event;
 701   PyObject *func;
 702   int wakeup;
 703
 704   if (!PyArg_ParseTuple (args, "O", &func))
 705     return NULL;
 706
 707   if (!PyCallable_Check (func))
 708     {
 709       PyErr_SetString (PyExc_RuntimeError,
 710                        _("Posted event is not callable"));
 711       return NULL;
 712     }
 713
 714   Py_INCREF (func);
 715
 716   /* From here until the end of the function, we have the GIL, so we
 717      can operate on our global data structures without worrying.  */
 718   wakeup = gdbpy_event_list == NULL;
 719
 720   event = XNEW (struct gdbpy_event);
 721   event->event = func;
 722   event->next = NULL;
 723   *gdbpy_event_list_end = event;
 724   gdbpy_event_list_end = &event->next;
 725
 726   /* Wake up gdb when needed.  */
 727   if (wakeup)
 728     {
 729       char c = 'q';             /* Anything. */
 730
 731       if (serial_write (gdbpy_event_fds[1], &c, 1))
 732         return PyErr_SetFromErrno (PyExc_IOError);
 733     }
 734
 735   Py_RETURN_NONE;
 736 }
 737
 738 /* Initialize the Python event handler.  */
 739 static void
 740 gdbpy_initialize_events (void)
 741 {
 742   if (serial_pipe (gdbpy_event_fds) == 0)
 743     {
 744       gdbpy_event_list_end = &gdbpy_event_list;
 745       serial_async (gdbpy_event_fds[0], gdbpy_run_events, NULL);
 746     }
 747 }
 748
 749 \f
 750
 751 static void
 752 before_prompt_hook (const char *current_gdb_prompt)
 753 {
 754   struct cleanup *cleanup;
 755   char *prompt = NULL;
 756
 757   cleanup = ensure_python_env (get_current_arch (), current_language);
 758
 759   if (PyObject_HasAttrString (gdb_module, "prompt_hook"))
 760     {
 761       PyObject *hook;
 762
 763       hook = PyObject_GetAttrString (gdb_module, "prompt_hook");
 764       if (hook == NULL)
 765         goto fail;
 766
 767       if (PyCallable_Check (hook))
 768         {
 769           PyObject *result;
 770           PyObject *current_prompt;
 771
 772           current_prompt = PyString_FromString (current_gdb_prompt);
 773           if (current_prompt == NULL)
 774             goto fail;
 775
 776           result = PyObject_CallFunctionObjArgs (hook, current_prompt, NULL);
 777
 778           Py_DECREF (current_prompt);
 779
 780           if (result == NULL)
 781             goto fail;
 782
 783           make_cleanup_py_decref (result);
 784
 785           /* Return type should be None, or a String.  If it is None,
 786              fall through, we will not set a prompt.  If it is a
 787              string, set  PROMPT.  Anything else, set an exception.  */
 788           if (result != Py_None && ! PyString_Check (result))
 789             {
 790               PyErr_Format (PyExc_RuntimeError,
 791                             _("Return from prompt_hook must " \
 792                               "be either a Python string, or None"));
 793               goto fail;
 794             }
 795
 796           if (result != Py_None)
 797             {
 798               prompt = python_string_to_host_string (result);
 799
 800               if (prompt == NULL)
 801                 goto fail;
 802               else
 803                 make_cleanup (xfree, prompt);
 804             }
 805         }
 806     }
 807
 808   /* If a prompt has been set, PROMPT will not be NULL.  If it is
 809      NULL, do not set the prompt.  */
 810   if (prompt != NULL)
 811     set_prompt (prompt);
 812
 813   do_cleanups (cleanup);
 814   return;
 815
 816  fail:
 817   gdbpy_print_stack ();
 818   do_cleanups (cleanup);
 819   return;
 820 }
 821
 822 \f
 823
 824 /* Printing.  */
 825
 826 /* A python function to write a single string using gdb's filtered
 827    output stream .  The optional keyword STREAM can be used to write
 828    to a particular stream.  The default stream is to gdb_stdout.  */
 829
 830 static PyObject *
 831 gdbpy_write (PyObject *self, PyObject *args, PyObject *kw)
 832 {
 833   const char *arg;
 834   static char *keywords[] = {"text", "stream", NULL };
 835   int stream_type = 0;
 836
 837   if (! PyArg_ParseTupleAndKeywords (args, kw, "s|i", keywords, &arg,
 838                                      &stream_type))
 839     return NULL;
 840
 841   switch (stream_type)
 842     {
 843     case 1:
 844       {
 845         fprintf_filtered (gdb_stderr, "%s", arg);
 846         break;
 847       }
 848     case 2:
 849       {
 850         fprintf_filtered (gdb_stdlog, "%s", arg);
 851         break;
 852       }
 853     default:
 854       fprintf_filtered (gdb_stdout, "%s", arg);
 855     }
 856
 857   Py_RETURN_NONE;
 858 }
 859
 860 /* A python function to flush a gdb stream.  The optional keyword
 861    STREAM can be used to flush a particular stream.  The default stream
 862    is gdb_stdout.  */
 863
 864 static PyObject *
 865 gdbpy_flush (PyObject *self, PyObject *args, PyObject *kw)
 866 {
 867   static char *keywords[] = {"stream", NULL };
 868   int stream_type = 0;
 869
 870   if (! PyArg_ParseTupleAndKeywords (args, kw, "|i", keywords,
 871                                      &stream_type))
 872     return NULL;
 873
 874   switch (stream_type)
 875     {
 876     case 1:
 877       {
 878         gdb_flush (gdb_stderr);
 879         break;
 880       }
 881     case 2:
 882       {
 883         gdb_flush (gdb_stdlog);
 884         break;
 885       }
 886     default:
 887       gdb_flush (gdb_stdout);
 888     }
 889
 890   Py_RETURN_NONE;
 891 }
 892
 893 /* Print a python exception trace, print just a message, or print
 894    nothing and clear the python exception, depending on
 895    gdbpy_should_print_stack.  Only call this if a python exception is
 896    set.  */
 897 void
 898 gdbpy_print_stack (void)
 899 {
 900   /* Print "none", just clear exception.  */
 901   if (gdbpy_should_print_stack == python_excp_none)
 902     {
 903       PyErr_Clear ();
 904     }
 905   /* Print "full" message and backtrace.  */
 906   else if (gdbpy_should_print_stack == python_excp_full)
 907     {
 908       PyErr_Print ();
 909       /* PyErr_Print doesn't necessarily end output with a newline.
 910          This works because Python's stdout/stderr is fed through
 911          printf_filtered.  */
 912       begin_line ();
 913     }
 914   /* Print "message", just error print message.  */
 915   else
 916     {
 917       PyObject *ptype, *pvalue, *ptraceback;
 918       char *msg = NULL, *type = NULL;
 919
 920       PyErr_Fetch (&ptype, &pvalue, &ptraceback);
 921
 922       /* Fetch the error message contained within ptype, pvalue.  */
 923       msg = gdbpy_exception_to_string (ptype, pvalue);
 924       type = gdbpy_obj_to_string (ptype);
 925       if (msg == NULL)
 926         {
 927           /* An error occurred computing the string representation of the
 928              error message.  */
 929           fprintf_filtered (gdb_stderr,
 930                             _("Error occurred computing Python error"   \
 931                               "message.\n"));
 932         }
 933       else
 934         fprintf_filtered (gdb_stderr, "Python Exception %s %s: \n",
 935                           type, msg);
 936
 937       Py_XDECREF (ptype);
 938       Py_XDECREF (pvalue);
 939       Py_XDECREF (ptraceback);
 940       xfree (msg);
 941     }
 942 }
 943
 944 \f
 945
 946 /* Return the current Progspace.
 947    There always is one.  */
 948
 949 static PyObject *
 950 gdbpy_get_current_progspace (PyObject *unused1, PyObject *unused2)
 951 {
 952   PyObject *result;
 953
 954   result = pspace_to_pspace_object (current_program_space);
 955   if (result)
 956     Py_INCREF (result);
 957   return result;
 958 }
 959
 960 /* Return a sequence holding all the Progspaces.  */
 961
 962 static PyObject *
 963 gdbpy_progspaces (PyObject *unused1, PyObject *unused2)
 964 {
 965   struct program_space *ps;
 966   PyObject *list;
 967
 968   list = PyList_New (0);
 969   if (!list)
 970     return NULL;
 971
 972   ALL_PSPACES (ps)
 973   {
 974     PyObject *item = pspace_to_pspace_object (ps);
 975
 976     if (!item || PyList_Append (list, item) == -1)
 977       {
 978         Py_DECREF (list);
 979         return NULL;
 980       }
 981   }
 982
 983   return list;
 984 }
 985
 986 \f
 987
 988 /* The "current" objfile.  This is set when gdb detects that a new
 989    objfile has been loaded.  It is only set for the duration of a call to
 990    source_python_script_for_objfile; it is NULL at other times.  */
 991 static struct objfile *gdbpy_current_objfile;
 992
 993 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
 994    as Python code.  This does not throw any errors.  If an exception
 995    occurs python will print the traceback and clear the error indicator.  */
 996
 997 void
 998 source_python_script_for_objfile (struct objfile *objfile, FILE *file,
 999                                   const char *filename)
1000 {
1001   struct cleanup *cleanups;
1002
1003   cleanups = ensure_python_env (get_objfile_arch (objfile), current_language);
1004   gdbpy_current_objfile = objfile;
1005
1006   python_run_simple_file (file, filename);
1007
1008   do_cleanups (cleanups);
1009   gdbpy_current_objfile = NULL;
1010 }
1011
1012 /* Return the current Objfile, or None if there isn't one.  */
1013
1014 static PyObject *
1015 gdbpy_get_current_objfile (PyObject *unused1, PyObject *unused2)
1016 {
1017   PyObject *result;
1018
1019   if (! gdbpy_current_objfile)
1020     Py_RETURN_NONE;
1021
1022   result = objfile_to_objfile_object (gdbpy_current_objfile);
1023   if (result)
1024     Py_INCREF (result);
1025   return result;
1026 }
1027
1028 /* Return a sequence holding all the Objfiles.  */
1029
1030 static PyObject *
1031 gdbpy_objfiles (PyObject *unused1, PyObject *unused2)
1032 {
1033   struct objfile *objf;
1034   PyObject *list;
1035
1036   list = PyList_New (0);
1037   if (!list)
1038     return NULL;
1039
1040   ALL_OBJFILES (objf)
1041   {
1042     PyObject *item = objfile_to_objfile_object (objf);
1043
1044     if (!item || PyList_Append (list, item) == -1)
1045       {
1046         Py_DECREF (list);
1047         return NULL;
1048       }
1049   }
1050
1051   return list;
1052 }
1053
1054 #else /* HAVE_PYTHON */
1055
1056 /* Dummy implementation of the gdb "python" command.  */
1057
1058 static void
1059 python_command (char *arg, int from_tty)
1060 {
1061   while (arg && *arg && isspace (*arg))
1062     ++arg;
1063   if (arg && *arg)
1064     error (_("Python scripting is not supported in this copy of GDB."));
1065   else
1066     {
1067       struct command_line *l = get_command_line (python_control, "");
1068       struct cleanup *cleanups = make_cleanup_free_command_lines (&l);
1069
1070       execute_control_command_untraced (l);
1071       do_cleanups (cleanups);
1072     }
1073 }
1074
1075 void
1076 eval_python_from_control_command (struct command_line *cmd)
1077 {
1078   error (_("Python scripting is not supported in this copy of GDB."));
1079 }
1080
1081 void
1082 source_python_script (FILE *file, const char *filename)
1083 {
1084   throw_error (UNSUPPORTED_ERROR,
1085                _("Python scripting is not supported in this copy of GDB."));
1086 }
1087
1088 int
1089 gdbpy_should_stop (struct breakpoint_object *bp_obj)
1090 {
1091   internal_error (__FILE__, __LINE__,
1092                   _("gdbpy_should_stop called when Python scripting is  " \
1093                     "not supported."));
1094 }
1095
1096 int
1097 gdbpy_breakpoint_has_py_cond (struct breakpoint_object *bp_obj)
1098 {
1099   internal_error (__FILE__, __LINE__,
1100                   _("gdbpy_breakpoint_has_py_cond called when Python " \
1101                     "scripting is not supported."));
1102 }
1103
1104 #endif /* HAVE_PYTHON */
1105
1106 \f
1107
1108 /* Lists for 'set python' commands.  */
1109
1110 static struct cmd_list_element *user_set_python_list;
1111 static struct cmd_list_element *user_show_python_list;
1112
1113 /* Function for use by 'set python' prefix command.  */
1114
1115 static void
1116 user_set_python (char *args, int from_tty)
1117 {
1118   help_list (user_set_python_list, "set python ", all_commands,
1119              gdb_stdout);
1120 }
1121
1122 /* Function for use by 'show python' prefix command.  */
1123
1124 static void
1125 user_show_python (char *args, int from_tty)
1126 {
1127   cmd_show_list (user_show_python_list, from_tty, "");
1128 }
1129
1130 /* Initialize the Python code.  */
1131
1132 /* Provide a prototype to silence -Wmissing-prototypes.  */
1133 extern initialize_file_ftype _initialize_python;
1134
1135 void
1136 _initialize_python (void)
1137 {
1138   char *cmd_name;
1139   struct cmd_list_element *cmd;
1140
1141   add_com ("python", class_obscure, python_command,
1142 #ifdef HAVE_PYTHON
1143            _("\
1144 Evaluate a Python command.\n\
1145 \n\
1146 The command can be given as an argument, for instance:\n\
1147 \n\
1148     python print 23\n\
1149 \n\
1150 If no argument is given, the following lines are read and used\n\
1151 as the Python commands.  Type a line containing \"end\" to indicate\n\
1152 the end of the command.")
1153 #else /* HAVE_PYTHON */
1154            _("\
1155 Evaluate a Python command.\n\
1156 \n\
1157 Python scripting is not supported in this copy of GDB.\n\
1158 This command is only a placeholder.")
1159 #endif /* HAVE_PYTHON */
1160            );
1161
1162   /* Add set/show python print-stack.  */
1163   add_prefix_cmd ("python", no_class, user_show_python,
1164                   _("Prefix command for python preference settings."),
1165                   &user_show_python_list, "show python ", 0,
1166                   &showlist);
1167
1168   add_prefix_cmd ("python", no_class, user_set_python,
1169                   _("Prefix command for python preference settings."),
1170                   &user_set_python_list, "set python ", 0,
1171                   &setlist);
1172
1173   add_setshow_enum_cmd ("print-stack", no_class, python_excp_enums,
1174                         &gdbpy_should_print_stack, _("\
1175 Set mode for Python stack dump on error."), _("\
1176 Show the mode of Python stack printing on error."), _("\
1177 none  == no stack or message will be printed.\n\
1178 full == a message and a stack will be printed.\n\
1179 message == an error message without a stack will be printed."),
1180                         NULL, NULL,
1181                         &user_set_python_list,
1182                         &user_show_python_list);
1183
1184 #ifdef HAVE_PYTHON
1185 #ifdef WITH_PYTHON_PATH
1186   /* Work around problem where python gets confused about where it is,
1187      and then can't find its libraries, etc.
1188      NOTE: Python assumes the following layout:
1189      /foo/bin/python
1190      /foo/lib/pythonX.Y/...
1191      This must be done before calling Py_Initialize.  */
1192   Py_SetProgramName (concat (ldirname (python_libdir), SLASH_STRING, "bin",
1193                              SLASH_STRING, "python", NULL));
1194 #endif
1195
1196   Py_Initialize ();
1197   PyEval_InitThreads ();
1198
1199   gdb_module = Py_InitModule ("gdb", GdbMethods);
1200
1201   /* The casts to (char*) are for python 2.4.  */
1202   PyModule_AddStringConstant (gdb_module, "VERSION", (char*) version);
1203   PyModule_AddStringConstant (gdb_module, "HOST_CONFIG", (char*) host_name);
1204   PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG",
1205                               (char*) target_name);
1206
1207   /* Add stream constants.  */
1208   PyModule_AddIntConstant (gdb_module, "STDOUT", 0);
1209   PyModule_AddIntConstant (gdb_module, "STDERR", 1);
1210   PyModule_AddIntConstant (gdb_module, "STDLOG", 2);
1211
1212   /* gdb.parameter ("data-directory") doesn't necessarily exist when the python
1213      script below is run (depending on order of _initialize_* functions).
1214      Define the initial value of gdb.PYTHONDIR here.  */
1215   {
1216     char *gdb_pythondir;
1217
1218     gdb_pythondir = concat (gdb_datadir, SLASH_STRING, "python", NULL);
1219     PyModule_AddStringConstant (gdb_module, "PYTHONDIR", gdb_pythondir);
1220     xfree (gdb_pythondir);
1221   }
1222
1223   gdbpy_gdb_error = PyErr_NewException ("gdb.error", PyExc_RuntimeError, NULL);
1224   PyModule_AddObject (gdb_module, "error", gdbpy_gdb_error);
1225
1226   gdbpy_gdb_memory_error = PyErr_NewException ("gdb.MemoryError",
1227                                                gdbpy_gdb_error, NULL);
1228   PyModule_AddObject (gdb_module, "MemoryError", gdbpy_gdb_memory_error);
1229
1230   gdbpy_gdberror_exc = PyErr_NewException ("gdb.GdbError", NULL, NULL);
1231   PyModule_AddObject (gdb_module, "GdbError", gdbpy_gdberror_exc);
1232
1233   gdbpy_initialize_auto_load ();
1234   gdbpy_initialize_values ();
1235   gdbpy_initialize_frames ();
1236   gdbpy_initialize_commands ();
1237   gdbpy_initialize_symbols ();
1238   gdbpy_initialize_symtabs ();
1239   gdbpy_initialize_blocks ();
1240   gdbpy_initialize_functions ();
1241   gdbpy_initialize_parameters ();
1242   gdbpy_initialize_types ();
1243   gdbpy_initialize_pspace ();
1244   gdbpy_initialize_objfile ();
1245   gdbpy_initialize_breakpoints ();
1246   gdbpy_initialize_finishbreakpoints ();
1247   gdbpy_initialize_lazy_string ();
1248   gdbpy_initialize_thread ();
1249   gdbpy_initialize_inferior ();
1250   gdbpy_initialize_events ();
1251
1252   gdbpy_initialize_eventregistry ();
1253   gdbpy_initialize_py_events ();
1254   gdbpy_initialize_event ();
1255   gdbpy_initialize_stop_event ();
1256   gdbpy_initialize_signal_event ();
1257   gdbpy_initialize_breakpoint_event ();
1258   gdbpy_initialize_continue_event ();
1259   gdbpy_initialize_exited_event ();
1260   gdbpy_initialize_thread_event ();
1261   gdbpy_initialize_new_objfile_event () ;
1262
1263   observer_attach_before_prompt (before_prompt_hook);
1264
1265   PyRun_SimpleString ("import gdb");
1266   PyRun_SimpleString ("gdb.pretty_printers = []");
1267
1268   gdbpy_to_string_cst = PyString_FromString ("to_string");
1269   gdbpy_children_cst = PyString_FromString ("children");
1270   gdbpy_display_hint_cst = PyString_FromString ("display_hint");
1271   gdbpy_doc_cst = PyString_FromString ("__doc__");
1272   gdbpy_enabled_cst = PyString_FromString ("enabled");
1273   gdbpy_value_cst = PyString_FromString ("value");
1274
1275   /* Release the GIL while gdb runs.  */
1276   PyThreadState_Swap (NULL);
1277   PyEval_ReleaseLock ();
1278
1279 #endif /* HAVE_PYTHON */
1280 }
1281
1282 #ifdef HAVE_PYTHON
1283
1284 /* Perform the remaining python initializations.
1285    These must be done after GDB is at least mostly initialized.
1286    E.g., The "info pretty-printer" command needs the "info" prefix
1287    command installed.  */
1288
1289 void
1290 finish_python_initialization (void)
1291 {
1292   struct cleanup *cleanup;
1293
1294   cleanup = ensure_python_env (get_current_arch (), current_language);
1295
1296   PyRun_SimpleString ("\
1297 import os\n\
1298 import sys\n\
1299 \n\
1300 class GdbOutputFile:\n\
1301   def close(self):\n\
1302     # Do nothing.\n\
1303     return None\n\
1304 \n\
1305   def isatty(self):\n\
1306     return False\n\
1307 \n\
1308   def write(self, s):\n\
1309     gdb.write(s, stream=gdb.STDOUT)\n   \
1310 \n\
1311   def writelines(self, iterable):\n\
1312     for line in iterable:\n\
1313       self.write(line)\n\
1314 \n\
1315   def flush(self):\n\
1316     gdb.flush()\n\
1317 \n\
1318 sys.stdout = GdbOutputFile()\n\
1319 \n\
1320 class GdbOutputErrorFile:\n\
1321   def close(self):\n\
1322     # Do nothing.\n\
1323     return None\n\
1324 \n\
1325   def isatty(self):\n\
1326     return False\n\
1327 \n\
1328   def write(self, s):\n\
1329     gdb.write(s, stream=gdb.STDERR)\n           \
1330 \n\
1331   def writelines(self, iterable):\n\
1332     for line in iterable:\n\
1333       self.write(line)\n \
1334 \n\
1335   def flush(self):\n\
1336     gdb.flush()\n\
1337 \n\
1338 sys.stderr = GdbOutputErrorFile()\n\
1339 \n\
1340 # Ideally this would live in the gdb module, but it's intentionally written\n\
1341 # in python, and we need this to bootstrap the gdb module.\n\
1342 \n\
1343 def GdbSetPythonDirectory (dir):\n\
1344   \"Set gdb.PYTHONDIR and update sys.path,etc.\"\n\
1345   old_dir = gdb.PYTHONDIR\n\
1346   gdb.PYTHONDIR = dir\n\
1347   # GDB's python scripts are stored inside gdb.PYTHONDIR.  So insert\n\
1348   # that directory name at the start of sys.path to allow the Python\n\
1349   # interpreter to find them.\n\
1350   if old_dir in sys.path:\n\
1351     sys.path.remove (old_dir)\n\
1352   sys.path.insert (0, gdb.PYTHONDIR)\n\
1353 \n\
1354   # Tell python where to find submodules of gdb.\n\
1355   gdb.__path__ = [os.path.join (gdb.PYTHONDIR, 'gdb')]\n\
1356 \n\
1357   # The gdb module is implemented in C rather than in Python.  As a result,\n\
1358   # the associated __init.py__ script is not not executed by default when\n\
1359   # the gdb module gets imported.  Execute that script manually if it\n\
1360   # exists.\n\
1361   ipy = os.path.join (gdb.PYTHONDIR, 'gdb', '__init__.py')\n\
1362   if os.path.exists (ipy):\n\
1363     execfile (ipy)\n\
1364 \n\
1365 # Install the default gdb.PYTHONDIR.\n\
1366 GdbSetPythonDirectory (gdb.PYTHONDIR)\n\
1367 # Default prompt hook does nothing.\n\
1368 prompt_hook = None\n\
1369 # Ensure that sys.argv is set to something.\n\
1370 # We do not use PySys_SetArgvEx because it did not appear until 2.6.6.\n\
1371 sys.argv = ['']\n\
1372 ");
1373
1374   do_cleanups (cleanup);
1375 }
1376
1377 #endif /* HAVE_PYTHON */
1378
1379 \f
1380
1381 #ifdef HAVE_PYTHON
1382
1383 static PyMethodDef GdbMethods[] =
1384 {
1385   { "history", gdbpy_history, METH_VARARGS,
1386     "Get a value from history" },
1387   { "execute", (PyCFunction) execute_gdb_command, METH_VARARGS | METH_KEYWORDS,
1388     "Execute a gdb command" },
1389   { "parameter", gdbpy_parameter, METH_VARARGS,
1390     "Return a gdb parameter's value" },
1391
1392   { "breakpoints", gdbpy_breakpoints, METH_NOARGS,
1393     "Return a tuple of all breakpoint objects" },
1394
1395   { "default_visualizer", gdbpy_default_visualizer, METH_VARARGS,
1396     "Find the default visualizer for a Value." },
1397
1398   { "current_progspace", gdbpy_get_current_progspace, METH_NOARGS,
1399     "Return the current Progspace." },
1400   { "progspaces", gdbpy_progspaces, METH_NOARGS,
1401     "Return a sequence of all progspaces." },
1402
1403   { "current_objfile", gdbpy_get_current_objfile, METH_NOARGS,
1404     "Return the current Objfile being loaded, or None." },
1405   { "objfiles", gdbpy_objfiles, METH_NOARGS,
1406     "Return a sequence of all loaded objfiles." },
1407
1408   { "newest_frame", gdbpy_newest_frame, METH_NOARGS,
1409     "newest_frame () -> gdb.Frame.\n\
1410 Return the newest frame object." },
1411   { "selected_frame", gdbpy_selected_frame, METH_NOARGS,
1412     "selected_frame () -> gdb.Frame.\n\
1413 Return the selected frame object." },
1414   { "frame_stop_reason_string", gdbpy_frame_stop_reason_string, METH_VARARGS,
1415     "stop_reason_string (Integer) -> String.\n\
1416 Return a string explaining unwind stop reason." },
1417
1418   { "lookup_type", (PyCFunction) gdbpy_lookup_type,
1419     METH_VARARGS | METH_KEYWORDS,
1420     "lookup_type (name [, block]) -> type\n\
1421 Return a Type corresponding to the given name." },
1422   { "lookup_symbol", (PyCFunction) gdbpy_lookup_symbol,
1423     METH_VARARGS | METH_KEYWORDS,
1424     "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
1425 Return a tuple with the symbol corresponding to the given name (or None) and\n\
1426 a boolean indicating if name is a field of the current implied argument\n\
1427 `this' (when the current language is object-oriented)." },
1428   { "lookup_global_symbol", (PyCFunction) gdbpy_lookup_global_symbol,
1429     METH_VARARGS | METH_KEYWORDS,
1430     "lookup_global_symbol (name [, domain]) -> symbol\n\
1431 Return the symbol corresponding to the given name (or None)." },
1432   { "block_for_pc", gdbpy_block_for_pc, METH_VARARGS,
1433     "Return the block containing the given pc value, or None." },
1434   { "solib_name", gdbpy_solib_name, METH_VARARGS,
1435     "solib_name (Long) -> String.\n\
1436 Return the name of the shared library holding a given address, or None." },
1437   { "decode_line", gdbpy_decode_line, METH_VARARGS,
1438     "decode_line (String) -> Tuple.  Decode a string argument the way\n\
1439 that 'break' or 'edit' does.  Return a tuple containing two elements.\n\
1440 The first element contains any unparsed portion of the String parameter\n\
1441 (or None if the string was fully parsed).  The second element contains\n\
1442 a tuple that contains all the locations that match, represented as\n\
1443 gdb.Symtab_and_line objects (or None)."},
1444   { "parse_and_eval", gdbpy_parse_and_eval, METH_VARARGS,
1445     "parse_and_eval (String) -> Value.\n\
1446 Parse String as an expression, evaluate it, and return the result as a Value."
1447   },
1448
1449   { "post_event", gdbpy_post_event, METH_VARARGS,
1450     "Post an event into gdb's event loop." },
1451
1452   { "target_charset", gdbpy_target_charset, METH_NOARGS,
1453     "target_charset () -> string.\n\
1454 Return the name of the current target charset." },
1455   { "target_wide_charset", gdbpy_target_wide_charset, METH_NOARGS,
1456     "target_wide_charset () -> string.\n\
1457 Return the name of the current target wide charset." },
1458
1459   { "string_to_argv", gdbpy_string_to_argv, METH_VARARGS,
1460     "string_to_argv (String) -> Array.\n\
1461 Parse String and return an argv-like array.\n\
1462 Arguments are separate by spaces and may be quoted."
1463   },
1464   { "write", (PyCFunction)gdbpy_write, METH_VARARGS | METH_KEYWORDS,
1465     "Write a string using gdb's filtered stream." },
1466   { "flush", (PyCFunction)gdbpy_flush, METH_VARARGS | METH_KEYWORDS,
1467     "Flush gdb's filtered stdout stream." },
1468   { "selected_thread", gdbpy_selected_thread, METH_NOARGS,
1469     "selected_thread () -> gdb.InferiorThread.\n\
1470 Return the selected thread object." },
1471   { "selected_inferior", gdbpy_selected_inferior, METH_NOARGS,
1472     "selected_inferior () -> gdb.Inferior.\n\
1473 Return the selected inferior object." },
1474   { "inferiors", gdbpy_inferiors, METH_NOARGS,
1475     "inferiors () -> (gdb.Inferior, ...).\n\
1476 Return a tuple containing all inferiors." },
1477   {NULL, NULL, 0, NULL}
1478 };
1479
1480 #endif /* HAVE_PYTHON */