gdb/python/python.c

   1 /* General python/gdb code
   2
   3    Copyright (C) 2008, 2009, 2010, 2011 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
  34 #include <ctype.h>
  35
  36 /* True if we should print the stack when catching a Python error,
  37    false otherwise.  */
  38 static int gdbpy_should_print_stack = 1;
  39
  40 #ifdef HAVE_PYTHON
  41
  42 #include "python.h"
  43 #include "libiberty.h"
  44 #include "cli/cli-decode.h"
  45 #include "charset.h"
  46 #include "top.h"
  47 #include "solib.h"
  48 #include "python-internal.h"
  49 #include "linespec.h"
  50 #include "source.h"
  51 #include "version.h"
  52 #include "target.h"
  53 #include "gdbthread.h"
  54
  55 static PyMethodDef GdbMethods[];
  56
  57 PyObject *gdb_module;
  58
  59 /* Some string constants we may wish to use.  */
  60 PyObject *gdbpy_to_string_cst;
  61 PyObject *gdbpy_children_cst;
  62 PyObject *gdbpy_display_hint_cst;
  63 PyObject *gdbpy_doc_cst;
  64 PyObject *gdbpy_enabled_cst;
  65
  66 /* The GdbError exception.  */
  67 PyObject *gdbpy_gdberror_exc;
  68
  69 /* The `gdb.error' base class.  */
  70 PyObject *gdbpy_gdb_error;
  71
  72 /* The `gdb.MemoryError' exception.  */
  73 PyObject *gdbpy_gdb_memory_error;
  74
  75 /* Architecture and language to be used in callbacks from
  76    the Python interpreter.  */
  77 struct gdbarch *python_gdbarch;
  78 const struct language_defn *python_language;
  79
  80 /* Restore global language and architecture and Python GIL state
  81    when leaving the Python interpreter.  */
  82
  83 struct python_env
  84 {
  85   PyGILState_STATE state;
  86   struct gdbarch *gdbarch;
  87   const struct language_defn *language;
  88   PyObject *error_type, *error_value, *error_traceback;
  89 };
  90
  91 static void
  92 restore_python_env (void *p)
  93 {
  94   struct python_env *env = (struct python_env *)p;
  95
  96   /* Leftover Python error is forbidden by Python Exception Handling.  */
  97   if (PyErr_Occurred ())
  98     {
  99       /* This order is similar to the one calling error afterwards. */
 100       gdbpy_print_stack ();
 101       warning (_("internal error: Unhandled Python exception"));
 102     }
 103
 104   PyErr_Restore (env->error_type, env->error_value, env->error_traceback);
 105
 106   PyGILState_Release (env->state);
 107   python_gdbarch = env->gdbarch;
 108   python_language = env->language;
 109   xfree (env);
 110 }
 111
 112 /* Called before entering the Python interpreter to install the
 113    current language and architecture to be used for Python values.  */
 114
 115 struct cleanup *
 116 ensure_python_env (struct gdbarch *gdbarch,
 117                    const struct language_defn *language)
 118 {
 119   struct python_env *env = xmalloc (sizeof *env);
 120
 121   env->state = PyGILState_Ensure ();
 122   env->gdbarch = python_gdbarch;
 123   env->language = python_language;
 124
 125   python_gdbarch = gdbarch;
 126   python_language = language;
 127
 128   /* Save it and ensure ! PyErr_Occurred () afterwards.  */
 129   PyErr_Fetch (&env->error_type, &env->error_value, &env->error_traceback);
 130
 131   return make_cleanup (restore_python_env, env);
 132 }
 133
 134
 135 /* Given a command_line, return a command string suitable for passing
 136    to Python.  Lines in the string are separated by newlines.  The
 137    return value is allocated using xmalloc and the caller is
 138    responsible for freeing it.  */
 139
 140 static char *
 141 compute_python_string (struct command_line *l)
 142 {
 143   struct command_line *iter;
 144   char *script = NULL;
 145   int size = 0;
 146   int here;
 147
 148   for (iter = l; iter; iter = iter->next)
 149     size += strlen (iter->line) + 1;
 150
 151   script = xmalloc (size + 1);
 152   here = 0;
 153   for (iter = l; iter; iter = iter->next)
 154     {
 155       int len = strlen (iter->line);
 156
 157       strcpy (&script[here], iter->line);
 158       here += len;
 159       script[here++] = '\n';
 160     }
 161   script[here] = '\0';
 162   return script;
 163 }
 164
 165 /* Take a command line structure representing a 'python' command, and
 166    evaluate its body using the Python interpreter.  */
 167
 168 void
 169 eval_python_from_control_command (struct command_line *cmd)
 170 {
 171   int ret;
 172   char *script;
 173   struct cleanup *cleanup;
 174
 175   if (cmd->body_count != 1)
 176     error (_("Invalid \"python\" block structure."));
 177
 178   cleanup = ensure_python_env (get_current_arch (), current_language);
 179
 180   script = compute_python_string (cmd->body_list[0]);
 181   ret = PyRun_SimpleString (script);
 182   xfree (script);
 183   if (ret)
 184     {
 185       gdbpy_print_stack ();
 186       error (_("Error while executing Python code."));
 187     }
 188
 189   do_cleanups (cleanup);
 190 }
 191
 192 /* Implementation of the gdb "python" command.  */
 193
 194 static void
 195 python_command (char *arg, int from_tty)
 196 {
 197   struct cleanup *cleanup;
 198
 199   cleanup = ensure_python_env (get_current_arch (), current_language);
 200   while (arg && *arg && isspace (*arg))
 201     ++arg;
 202   if (arg && *arg)
 203     {
 204       if (PyRun_SimpleString (arg))
 205         {
 206           gdbpy_print_stack ();
 207           error (_("Error while executing Python code."));
 208         }
 209     }
 210   else
 211     {
 212       struct command_line *l = get_command_line (python_control, "");
 213
 214       make_cleanup_free_command_lines (&l);
 215       execute_control_command_untraced (l);
 216     }
 217
 218   do_cleanups (cleanup);
 219 }
 220
 221 \f
 222
 223 /* Transform a gdb parameters's value into a Python value.  May return
 224    NULL (and set a Python exception) on error.  Helper function for
 225    get_parameter.  */
 226 PyObject *
 227 gdbpy_parameter_value (enum var_types type, void *var)
 228 {
 229   switch (type)
 230     {
 231     case var_string:
 232     case var_string_noescape:
 233     case var_optional_filename:
 234     case var_filename:
 235     case var_enum:
 236       {
 237         char *str = * (char **) var;
 238
 239         if (! str)
 240           str = "";
 241         return PyString_Decode (str, strlen (str), host_charset (), NULL);
 242       }
 243
 244     case var_boolean:
 245       {
 246         if (* (int *) var)
 247           Py_RETURN_TRUE;
 248         else
 249           Py_RETURN_FALSE;
 250       }
 251
 252     case var_auto_boolean:
 253       {
 254         enum auto_boolean ab = * (enum auto_boolean *) var;
 255
 256         if (ab == AUTO_BOOLEAN_TRUE)
 257           Py_RETURN_TRUE;
 258         else if (ab == AUTO_BOOLEAN_FALSE)
 259           Py_RETURN_FALSE;
 260         else
 261           Py_RETURN_NONE;
 262       }
 263
 264     case var_integer:
 265       if ((* (int *) var) == INT_MAX)
 266         Py_RETURN_NONE;
 267       /* Fall through.  */
 268     case var_zinteger:
 269       return PyLong_FromLong (* (int *) var);
 270
 271     case var_uinteger:
 272       {
 273         unsigned int val = * (unsigned int *) var;
 274
 275         if (val == UINT_MAX)
 276           Py_RETURN_NONE;
 277         return PyLong_FromUnsignedLong (val);
 278       }
 279     }
 280
 281   return PyErr_Format (PyExc_RuntimeError,
 282                        _("Programmer error: unhandled type."));
 283 }
 284
 285 /* A Python function which returns a gdb parameter's value as a Python
 286    value.  */
 287
 288 PyObject *
 289 gdbpy_parameter (PyObject *self, PyObject *args)
 290 {
 291   struct cmd_list_element *alias, *prefix, *cmd;
 292   char *arg, *newarg;
 293   int found = -1;
 294   volatile struct gdb_exception except;
 295
 296   if (! PyArg_ParseTuple (args, "s", &arg))
 297     return NULL;
 298
 299   newarg = concat ("show ", arg, (char *) NULL);
 300
 301   TRY_CATCH (except, RETURN_MASK_ALL)
 302     {
 303       found = lookup_cmd_composition (newarg, &alias, &prefix, &cmd);
 304     }
 305   xfree (newarg);
 306   GDB_PY_HANDLE_EXCEPTION (except);
 307   if (!found)
 308     return PyErr_Format (PyExc_RuntimeError,
 309                          _("Could not find parameter `%s'."), arg);
 310
 311   if (! cmd->var)
 312     return PyErr_Format (PyExc_RuntimeError,
 313                          _("`%s' is not a parameter."), arg);
 314   return gdbpy_parameter_value (cmd->var_type, cmd->var);
 315 }
 316
 317 /* Wrapper for target_charset.  */
 318
 319 static PyObject *
 320 gdbpy_target_charset (PyObject *self, PyObject *args)
 321 {
 322   const char *cset = target_charset (python_gdbarch);
 323
 324   return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL);
 325 }
 326
 327 /* Wrapper for target_wide_charset.  */
 328
 329 static PyObject *
 330 gdbpy_target_wide_charset (PyObject *self, PyObject *args)
 331 {
 332   const char *cset = target_wide_charset (python_gdbarch);
 333
 334   return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL);
 335 }
 336
 337 /* A Python function which evaluates a string using the gdb CLI.  */
 338
 339 static PyObject *
 340 execute_gdb_command (PyObject *self, PyObject *args, PyObject *kw)
 341 {
 342   char *arg;
 343   PyObject *from_tty_obj = NULL, *to_string_obj = NULL;
 344   int from_tty, to_string;
 345   volatile struct gdb_exception except;
 346   static char *keywords[] = {"command", "from_tty", "to_string", NULL };
 347   char *result = NULL;
 348
 349   if (! PyArg_ParseTupleAndKeywords (args, kw, "s|O!O!", keywords, &arg,
 350                                      &PyBool_Type, &from_tty_obj,
 351                                      &PyBool_Type, &to_string_obj))
 352     return NULL;
 353
 354   from_tty = 0;
 355   if (from_tty_obj)
 356     {
 357       int cmp = PyObject_IsTrue (from_tty_obj);
 358       if (cmp < 0)
 359         return NULL;
 360       from_tty = cmp;
 361     }
 362
 363   to_string = 0;
 364   if (to_string_obj)
 365     {
 366       int cmp = PyObject_IsTrue (to_string_obj);
 367       if (cmp < 0)
 368         return NULL;
 369       to_string = cmp;
 370     }
 371
 372   TRY_CATCH (except, RETURN_MASK_ALL)
 373     {
 374       /* Copy the argument text in case the command modifies it.  */
 375       char *copy = xstrdup (arg);
 376       struct cleanup *cleanup = make_cleanup (xfree, copy);
 377
 378       if (to_string)
 379         result = execute_command_to_string (copy, from_tty);
 380       else
 381         {
 382           result = NULL;
 383           execute_command (copy, from_tty);
 384         }
 385
 386       do_cleanups (cleanup);
 387     }
 388   GDB_PY_HANDLE_EXCEPTION (except);
 389
 390   /* Do any commands attached to breakpoint we stopped at.  */
 391   bpstat_do_actions ();
 392
 393   if (result)
 394     {
 395       PyObject *r = PyString_FromString (result);
 396       xfree (result);
 397       return r;
 398     }
 399   Py_RETURN_NONE;
 400 }
 401
 402 /* Implementation of gdb.solib_name (Long) -> String.
 403    Returns the name of the shared library holding a given address, or None.  */
 404
 405 static PyObject *
 406 gdbpy_solib_name (PyObject *self, PyObject *args)
 407 {
 408   char *soname;
 409   PyObject *str_obj;
 410 #ifdef PY_LONG_LONG
 411   unsigned PY_LONG_LONG pc;
 412   /* To be compatible with Python 2.4 the format strings are not const.  */
 413   char *format = "K";
 414 #else
 415   unsigned long pc;
 416   char *format = "k";
 417 #endif
 418
 419   if (!PyArg_ParseTuple (args, format, &pc))
 420     return NULL;
 421
 422   soname = solib_name_from_address (current_program_space, pc);
 423   if (soname)
 424     str_obj = PyString_Decode (soname, strlen (soname), host_charset (), NULL);
 425   else
 426     {
 427       str_obj = Py_None;
 428       Py_INCREF (Py_None);
 429     }
 430
 431   return str_obj;
 432 }
 433
 434 /* A Python function which is a wrapper for decode_line_1.  */
 435
 436 static PyObject *
 437 gdbpy_decode_line (PyObject *self, PyObject *args)
 438 {
 439   struct symtabs_and_lines sals = { NULL, 0 }; /* Initialize to appease gcc.  */
 440   struct symtab_and_line sal;
 441   char *arg = NULL;
 442   char *copy = NULL;
 443   struct cleanup *cleanups;
 444   PyObject *result = NULL;
 445   PyObject *return_result = NULL;
 446   PyObject *unparsed = NULL;
 447   volatile struct gdb_exception except;
 448
 449   if (! PyArg_ParseTuple (args, "|s", &arg))
 450     return NULL;
 451
 452   cleanups = ensure_python_env (get_current_arch (), current_language);
 453
 454   TRY_CATCH (except, RETURN_MASK_ALL)
 455     {
 456       if (arg)
 457         {
 458           arg = xstrdup (arg);
 459           make_cleanup (xfree, arg);
 460           copy = arg;
 461           sals = decode_line_1 (&copy, 0, 0, 0, 0, 0);
 462           make_cleanup (xfree, sals.sals);
 463         }
 464       else
 465         {
 466           set_default_source_symtab_and_line ();
 467           sal = get_current_source_symtab_and_line ();
 468           sals.sals = &sal;
 469           sals.nelts = 1;
 470         }
 471     }
 472   if (except.reason < 0)
 473     {
 474       do_cleanups (cleanups);
 475       /* We know this will always throw.  */
 476       GDB_PY_HANDLE_EXCEPTION (except);
 477     }
 478
 479   if (sals.nelts)
 480     {
 481       int i;
 482
 483       result = PyTuple_New (sals.nelts);
 484       if (! result)
 485         goto error;
 486       for (i = 0; i < sals.nelts; ++i)
 487         {
 488           PyObject *obj;
 489           char *str;
 490
 491           obj = symtab_and_line_to_sal_object (sals.sals[i]);
 492           if (! obj)
 493             {
 494               Py_DECREF (result);
 495               goto error;
 496             }
 497
 498           PyTuple_SetItem (result, i, obj);
 499         }
 500     }
 501   else
 502     {
 503       result = Py_None;
 504       Py_INCREF (Py_None);
 505     }
 506
 507   return_result = PyTuple_New (2);
 508   if (! return_result)
 509     {
 510       Py_DECREF (result);
 511       goto error;
 512     }
 513
 514   if (copy && strlen (copy) > 0)
 515     unparsed = PyString_FromString (copy);
 516   else
 517     {
 518       unparsed = Py_None;
 519       Py_INCREF (Py_None);
 520     }
 521
 522   PyTuple_SetItem (return_result, 0, unparsed);
 523   PyTuple_SetItem (return_result, 1, result);
 524
 525   do_cleanups (cleanups);
 526
 527   return return_result;
 528
 529  error:
 530   do_cleanups (cleanups);
 531   return NULL;
 532 }
 533
 534 /* Parse a string and evaluate it as an expression.  */
 535 static PyObject *
 536 gdbpy_parse_and_eval (PyObject *self, PyObject *args)
 537 {
 538   char *expr_str;
 539   struct value *result = NULL;
 540   volatile struct gdb_exception except;
 541
 542   if (!PyArg_ParseTuple (args, "s", &expr_str))
 543     return NULL;
 544
 545   TRY_CATCH (except, RETURN_MASK_ALL)
 546     {
 547       result = parse_and_eval (expr_str);
 548     }
 549   GDB_PY_HANDLE_EXCEPTION (except);
 550
 551   return value_to_value_object (result);
 552 }
 553
 554 /* Read a file as Python code.  STREAM is the input file; FILE is the
 555    name of the file.
 556    STREAM is not closed, that is the caller's responsibility.  */
 557
 558 void
 559 source_python_script (FILE *stream, const char *file)
 560 {
 561   struct cleanup *cleanup;
 562
 563   cleanup = ensure_python_env (get_current_arch (), current_language);
 564
 565   /* Note: If an exception occurs python will print the traceback and
 566      clear the error indicator.  */
 567   PyRun_SimpleFile (stream, file);
 568
 569   do_cleanups (cleanup);
 570 }
 571
 572 \f
 573
 574 /* Posting and handling events.  */
 575
 576 /* A single event.  */
 577 struct gdbpy_event
 578 {
 579   /* The Python event.  This is just a callable object.  */
 580   PyObject *event;
 581   /* The next event.  */
 582   struct gdbpy_event *next;
 583 };
 584
 585 /* All pending events.  */
 586 static struct gdbpy_event *gdbpy_event_list;
 587 /* The final link of the event list.  */
 588 static struct gdbpy_event **gdbpy_event_list_end;
 589
 590 /* We use a file handler, and not an async handler, so that we can
 591    wake up the main thread even when it is blocked in poll().  */
 592 static struct serial *gdbpy_event_fds[2];
 593
 594 /* The file handler callback.  This reads from the internal pipe, and
 595    then processes the Python event queue.  This will always be run in
 596    the main gdb thread.  */
 597
 598 static void
 599 gdbpy_run_events (struct serial *scb, void *context)
 600 {
 601   struct cleanup *cleanup;
 602   int r;
 603
 604   cleanup = ensure_python_env (get_current_arch (), current_language);
 605
 606   /* Flush the fd.  Do this before flushing the events list, so that
 607      any new event post afterwards is sure to re-awake the event
 608      loop.  */
 609   while (serial_readchar (gdbpy_event_fds[0], 0) >= 0)
 610     ;
 611
 612   while (gdbpy_event_list)
 613     {
 614       /* Dispatching the event might push a new element onto the event
 615          loop, so we update here "atomically enough".  */
 616       struct gdbpy_event *item = gdbpy_event_list;
 617       gdbpy_event_list = gdbpy_event_list->next;
 618       if (gdbpy_event_list == NULL)
 619         gdbpy_event_list_end = &gdbpy_event_list;
 620
 621       /* Ignore errors.  */
 622       if (PyObject_CallObject (item->event, NULL) == NULL)
 623         PyErr_Clear ();
 624
 625       Py_DECREF (item->event);
 626       xfree (item);
 627     }
 628
 629   do_cleanups (cleanup);
 630 }
 631
 632 /* Submit an event to the gdb thread.  */
 633 static PyObject *
 634 gdbpy_post_event (PyObject *self, PyObject *args)
 635 {
 636   struct gdbpy_event *event;
 637   PyObject *func;
 638   int wakeup;
 639
 640   if (!PyArg_ParseTuple (args, "O", &func))
 641     return NULL;
 642
 643   if (!PyCallable_Check (func))
 644     {
 645       PyErr_SetString (PyExc_RuntimeError,
 646                        _("Posted event is not callable"));
 647       return NULL;
 648     }
 649
 650   Py_INCREF (func);
 651
 652   /* From here until the end of the function, we have the GIL, so we
 653      can operate on our global data structures without worrying.  */
 654   wakeup = gdbpy_event_list == NULL;
 655
 656   event = XNEW (struct gdbpy_event);
 657   event->event = func;
 658   event->next = NULL;
 659   *gdbpy_event_list_end = event;
 660   gdbpy_event_list_end = &event->next;
 661
 662   /* Wake up gdb when needed.  */
 663   if (wakeup)
 664     {
 665       char c = 'q';             /* Anything. */
 666
 667       if (serial_write (gdbpy_event_fds[1], &c, 1))
 668         return PyErr_SetFromErrno (PyExc_IOError);
 669     }
 670
 671   Py_RETURN_NONE;
 672 }
 673
 674 /* Initialize the Python event handler.  */
 675 static void
 676 gdbpy_initialize_events (void)
 677 {
 678   if (serial_pipe (gdbpy_event_fds) == 0)
 679     {
 680       gdbpy_event_list_end = &gdbpy_event_list;
 681       serial_async (gdbpy_event_fds[0], gdbpy_run_events, NULL);
 682     }
 683 }
 684
 685 /* Printing.  */
 686
 687 /* A python function to write a single string using gdb's filtered
 688    output stream.  */
 689 static PyObject *
 690 gdbpy_write (PyObject *self, PyObject *args)
 691 {
 692   char *arg;
 693
 694   if (! PyArg_ParseTuple (args, "s", &arg))
 695     return NULL;
 696   printf_filtered ("%s", arg);
 697   Py_RETURN_NONE;
 698 }
 699
 700 /* A python function to flush gdb's filtered output stream.  */
 701 static PyObject *
 702 gdbpy_flush (PyObject *self, PyObject *args)
 703 {
 704   gdb_flush (gdb_stdout);
 705   Py_RETURN_NONE;
 706 }
 707
 708 /* Print a python exception trace, or print nothing and clear the
 709    python exception, depending on gdbpy_should_print_stack.  Only call
 710    this if a python exception is set.  */
 711 void
 712 gdbpy_print_stack (void)
 713 {
 714   if (gdbpy_should_print_stack)
 715     {
 716       PyErr_Print ();
 717       /* PyErr_Print doesn't necessarily end output with a newline.
 718          This works because Python's stdout/stderr is fed through
 719          printf_filtered.  */
 720       begin_line ();
 721     }
 722   else
 723     PyErr_Clear ();
 724 }
 725
 726 \f
 727
 728 /* Return the current Progspace.
 729    There always is one.  */
 730
 731 static PyObject *
 732 gdbpy_get_current_progspace (PyObject *unused1, PyObject *unused2)
 733 {
 734   PyObject *result;
 735
 736   result = pspace_to_pspace_object (current_program_space);
 737   if (result)
 738     Py_INCREF (result);
 739   return result;
 740 }
 741
 742 /* Return a sequence holding all the Progspaces.  */
 743
 744 static PyObject *
 745 gdbpy_progspaces (PyObject *unused1, PyObject *unused2)
 746 {
 747   struct program_space *ps;
 748   PyObject *list;
 749
 750   list = PyList_New (0);
 751   if (!list)
 752     return NULL;
 753
 754   ALL_PSPACES (ps)
 755   {
 756     PyObject *item = pspace_to_pspace_object (ps);
 757
 758     if (!item || PyList_Append (list, item) == -1)
 759       {
 760         Py_DECREF (list);
 761         return NULL;
 762       }
 763   }
 764
 765   return list;
 766 }
 767
 768 \f
 769
 770 /* The "current" objfile.  This is set when gdb detects that a new
 771    objfile has been loaded.  It is only set for the duration of a call to
 772    source_python_script_for_objfile; it is NULL at other times.  */
 773 static struct objfile *gdbpy_current_objfile;
 774
 775 /* Set the current objfile to OBJFILE and then read STREAM,FILE as
 776    Python code.  */
 777
 778 void
 779 source_python_script_for_objfile (struct objfile *objfile,
 780                                   FILE *stream, const char *file)
 781 {
 782   struct cleanup *cleanups;
 783
 784   cleanups = ensure_python_env (get_objfile_arch (objfile), current_language);
 785   gdbpy_current_objfile = objfile;
 786
 787   /* Note: If an exception occurs python will print the traceback and
 788      clear the error indicator.  */
 789   PyRun_SimpleFile (stream, file);
 790
 791   do_cleanups (cleanups);
 792   gdbpy_current_objfile = NULL;
 793 }
 794
 795 /* Return the current Objfile, or None if there isn't one.  */
 796
 797 static PyObject *
 798 gdbpy_get_current_objfile (PyObject *unused1, PyObject *unused2)
 799 {
 800   PyObject *result;
 801
 802   if (! gdbpy_current_objfile)
 803     Py_RETURN_NONE;
 804
 805   result = objfile_to_objfile_object (gdbpy_current_objfile);
 806   if (result)
 807     Py_INCREF (result);
 808   return result;
 809 }
 810
 811 /* Return a sequence holding all the Objfiles.  */
 812
 813 static PyObject *
 814 gdbpy_objfiles (PyObject *unused1, PyObject *unused2)
 815 {
 816   struct objfile *objf;
 817   PyObject *list;
 818
 819   list = PyList_New (0);
 820   if (!list)
 821     return NULL;
 822
 823   ALL_OBJFILES (objf)
 824   {
 825     PyObject *item = objfile_to_objfile_object (objf);
 826
 827     if (!item || PyList_Append (list, item) == -1)
 828       {
 829         Py_DECREF (list);
 830         return NULL;
 831       }
 832   }
 833
 834   return list;
 835 }
 836
 837 #else /* HAVE_PYTHON */
 838
 839 /* Dummy implementation of the gdb "python" command.  */
 840
 841 static void
 842 python_command (char *arg, int from_tty)
 843 {
 844   while (arg && *arg && isspace (*arg))
 845     ++arg;
 846   if (arg && *arg)
 847     error (_("Python scripting is not supported in this copy of GDB."));
 848   else
 849     {
 850       struct command_line *l = get_command_line (python_control, "");
 851       struct cleanup *cleanups = make_cleanup_free_command_lines (&l);
 852
 853       execute_control_command_untraced (l);
 854       do_cleanups (cleanups);
 855     }
 856 }
 857
 858 void
 859 eval_python_from_control_command (struct command_line *cmd)
 860 {
 861   error (_("Python scripting is not supported in this copy of GDB."));
 862 }
 863
 864 void
 865 source_python_script (FILE *stream, const char *file)
 866 {
 867   throw_error (UNSUPPORTED_ERROR,
 868                _("Python scripting is not supported in this copy of GDB."));
 869 }
 870
 871 #endif /* HAVE_PYTHON */
 872
 873 \f
 874
 875 /* Lists for 'maint set python' commands.  */
 876
 877 struct cmd_list_element *set_python_list;
 878 struct cmd_list_element *show_python_list;
 879
 880 /* Function for use by 'maint set python' prefix command.  */
 881
 882 static void
 883 set_python (char *args, int from_tty)
 884 {
 885   help_list (set_python_list, "maintenance set python ", -1, gdb_stdout);
 886 }
 887
 888 /* Function for use by 'maint show python' prefix command.  */
 889
 890 static void
 891 show_python (char *args, int from_tty)
 892 {
 893   cmd_show_list (show_python_list, from_tty, "");
 894 }
 895
 896 /* Initialize the Python code.  */
 897
 898 /* Provide a prototype to silence -Wmissing-prototypes.  */
 899 extern initialize_file_ftype _initialize_python;
 900
 901 void
 902 _initialize_python (void)
 903 {
 904   add_com ("python", class_obscure, python_command,
 905 #ifdef HAVE_PYTHON
 906            _("\
 907 Evaluate a Python command.\n\
 908 \n\
 909 The command can be given as an argument, for instance:\n\
 910 \n\
 911     python print 23\n\
 912 \n\
 913 If no argument is given, the following lines are read and used\n\
 914 as the Python commands.  Type a line containing \"end\" to indicate\n\
 915 the end of the command.")
 916 #else /* HAVE_PYTHON */
 917            _("\
 918 Evaluate a Python command.\n\
 919 \n\
 920 Python scripting is not supported in this copy of GDB.\n\
 921 This command is only a placeholder.")
 922 #endif /* HAVE_PYTHON */
 923            );
 924
 925   add_prefix_cmd ("python", no_class, show_python,
 926                   _("Prefix command for python maintenance settings."),
 927                   &show_python_list, "maintenance show python ", 0,
 928                   &maintenance_show_cmdlist);
 929   add_prefix_cmd ("python", no_class, set_python,
 930                   _("Prefix command for python maintenance settings."),
 931                   &set_python_list, "maintenance set python ", 0,
 932                   &maintenance_set_cmdlist);
 933
 934   add_setshow_boolean_cmd ("print-stack", class_maintenance,
 935                            &gdbpy_should_print_stack, _("\
 936 Enable or disable printing of Python stack dump on error."), _("\
 937 Show whether Python stack will be printed on error."), _("\
 938 Enables or disables printing of Python stack traces."),
 939                            NULL, NULL,
 940                            &set_python_list,
 941                            &show_python_list);
 942
 943 #ifdef HAVE_PYTHON
 944 #ifdef WITH_PYTHON_PATH
 945   /* Work around problem where python gets confused about where it is,
 946      and then can't find its libraries, etc.
 947      NOTE: Python assumes the following layout:
 948      /foo/bin/python
 949      /foo/lib/pythonX.Y/...
 950      This must be done before calling Py_Initialize.  */
 951   Py_SetProgramName (concat (ldirname (python_libdir), SLASH_STRING, "bin",
 952                              SLASH_STRING, "python", NULL));
 953 #endif
 954
 955   Py_Initialize ();
 956   PyEval_InitThreads ();
 957
 958   gdb_module = Py_InitModule ("gdb", GdbMethods);
 959
 960   /* The casts to (char*) are for python 2.4.  */
 961   PyModule_AddStringConstant (gdb_module, "VERSION", (char*) version);
 962   PyModule_AddStringConstant (gdb_module, "HOST_CONFIG", (char*) host_name);
 963   PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG", (char*) target_name);
 964
 965   /* gdb.parameter ("data-directory") doesn't necessarily exist when the python
 966      script below is run (depending on order of _initialize_* functions).
 967      Define the initial value of gdb.PYTHONDIR here.  */
 968   {
 969     char *gdb_pythondir;
 970
 971     gdb_pythondir = concat (gdb_datadir, SLASH_STRING, "python", NULL);
 972     PyModule_AddStringConstant (gdb_module, "PYTHONDIR", gdb_pythondir);
 973     xfree (gdb_pythondir);
 974   }
 975
 976   gdbpy_gdb_error = PyErr_NewException ("gdb.error", PyExc_RuntimeError, NULL);
 977   PyModule_AddObject (gdb_module, "error", gdbpy_gdb_error);
 978
 979   gdbpy_gdb_memory_error = PyErr_NewException ("gdb.MemoryError",
 980                                                gdbpy_gdb_error, NULL);
 981   PyModule_AddObject (gdb_module, "MemoryError", gdbpy_gdb_memory_error);
 982
 983   gdbpy_gdberror_exc = PyErr_NewException ("gdb.GdbError", NULL, NULL);
 984   PyModule_AddObject (gdb_module, "GdbError", gdbpy_gdberror_exc);
 985
 986   gdbpy_initialize_auto_load ();
 987   gdbpy_initialize_values ();
 988   gdbpy_initialize_frames ();
 989   gdbpy_initialize_commands ();
 990   gdbpy_initialize_symbols ();
 991   gdbpy_initialize_symtabs ();
 992   gdbpy_initialize_blocks ();
 993   gdbpy_initialize_functions ();
 994   gdbpy_initialize_parameters ();
 995   gdbpy_initialize_types ();
 996   gdbpy_initialize_pspace ();
 997   gdbpy_initialize_objfile ();
 998   gdbpy_initialize_breakpoints ();
 999   gdbpy_initialize_lazy_string ();
1000   gdbpy_initialize_thread ();
1001   gdbpy_initialize_inferior ();
1002   gdbpy_initialize_events ();
1003
1004   PyRun_SimpleString ("import gdb");
1005   PyRun_SimpleString ("gdb.pretty_printers = []");
1006
1007   gdbpy_to_string_cst = PyString_FromString ("to_string");
1008   gdbpy_children_cst = PyString_FromString ("children");
1009   gdbpy_display_hint_cst = PyString_FromString ("display_hint");
1010   gdbpy_doc_cst = PyString_FromString ("__doc__");
1011   gdbpy_enabled_cst = PyString_FromString ("enabled");
1012
1013   /* Release the GIL while gdb runs.  */
1014   PyThreadState_Swap (NULL);
1015   PyEval_ReleaseLock ();
1016
1017 #endif /* HAVE_PYTHON */
1018 }
1019
1020 #ifdef HAVE_PYTHON
1021
1022 /* Perform the remaining python initializations.
1023    These must be done after GDB is at least mostly initialized.
1024    E.g., The "info pretty-printer" command needs the "info" prefix
1025    command installed.  */
1026
1027 void
1028 finish_python_initialization (void)
1029 {
1030   struct cleanup *cleanup;
1031
1032   cleanup = ensure_python_env (get_current_arch (), current_language);
1033
1034   PyRun_SimpleString ("\
1035 import os\n\
1036 import sys\n\
1037 \n\
1038 class GdbOutputFile:\n\
1039   def close(self):\n\
1040     # Do nothing.\n\
1041     return None\n\
1042 \n\
1043   def isatty(self):\n\
1044     return False\n\
1045 \n\
1046   def write(self, s):\n\
1047     gdb.write(s)\n\
1048 \n\
1049   def writelines(self, iterable):\n\
1050     for line in iterable:\n\
1051       self.write(line)\n\
1052 \n\
1053   def flush(self):\n\
1054     gdb.flush()\n\
1055 \n\
1056 sys.stderr = GdbOutputFile()\n\
1057 sys.stdout = GdbOutputFile()\n\
1058 \n\
1059 # Ideally this would live in the gdb module, but it's intentionally written\n\
1060 # in python, and we need this to bootstrap the gdb module.\n\
1061 \n\
1062 def GdbSetPythonDirectory (dir):\n\
1063   \"Set gdb.PYTHONDIR and update sys.path,etc.\"\n\
1064   old_dir = gdb.PYTHONDIR\n\
1065   gdb.PYTHONDIR = dir\n\
1066   # GDB's python scripts are stored inside gdb.PYTHONDIR.  So insert\n\
1067   # that directory name at the start of sys.path to allow the Python\n\
1068   # interpreter to find them.\n\
1069   if old_dir in sys.path:\n\
1070     sys.path.remove (old_dir)\n\
1071   sys.path.insert (0, gdb.PYTHONDIR)\n\
1072 \n\
1073   # Tell python where to find submodules of gdb.\n\
1074   gdb.__path__ = [gdb.PYTHONDIR + '/gdb']\n\
1075 \n\
1076   # The gdb module is implemented in C rather than in Python.  As a result,\n\
1077   # the associated __init.py__ script is not not executed by default when\n\
1078   # the gdb module gets imported.  Execute that script manually if it\n\
1079   # exists.\n\
1080   ipy = gdb.PYTHONDIR + '/gdb/__init__.py'\n\
1081   if os.path.exists (ipy):\n\
1082     execfile (ipy)\n\
1083 \n\
1084 # Install the default gdb.PYTHONDIR.\n\
1085 GdbSetPythonDirectory (gdb.PYTHONDIR)\n\
1086 ");
1087
1088   do_cleanups (cleanup);
1089 }
1090
1091 #endif /* HAVE_PYTHON */
1092
1093 \f
1094
1095 #ifdef HAVE_PYTHON
1096
1097 static PyMethodDef GdbMethods[] =
1098 {
1099   { "history", gdbpy_history, METH_VARARGS,
1100     "Get a value from history" },
1101   { "execute", (PyCFunction) execute_gdb_command, METH_VARARGS | METH_KEYWORDS,
1102     "Execute a gdb command" },
1103   { "parameter", gdbpy_parameter, METH_VARARGS,
1104     "Return a gdb parameter's value" },
1105
1106   { "breakpoints", gdbpy_breakpoints, METH_NOARGS,
1107     "Return a tuple of all breakpoint objects" },
1108
1109   { "default_visualizer", gdbpy_default_visualizer, METH_VARARGS,
1110     "Find the default visualizer for a Value." },
1111
1112   { "current_progspace", gdbpy_get_current_progspace, METH_NOARGS,
1113     "Return the current Progspace." },
1114   { "progspaces", gdbpy_progspaces, METH_NOARGS,
1115     "Return a sequence of all progspaces." },
1116
1117   { "current_objfile", gdbpy_get_current_objfile, METH_NOARGS,
1118     "Return the current Objfile being loaded, or None." },
1119   { "objfiles", gdbpy_objfiles, METH_NOARGS,
1120     "Return a sequence of all loaded objfiles." },
1121
1122   { "selected_frame", gdbpy_selected_frame, METH_NOARGS,
1123     "selected_frame () -> gdb.Frame.\n\
1124 Return the selected frame object." },
1125   { "frame_stop_reason_string", gdbpy_frame_stop_reason_string, METH_VARARGS,
1126     "stop_reason_string (Integer) -> String.\n\
1127 Return a string explaining unwind stop reason." },
1128
1129   { "lookup_type", (PyCFunction) gdbpy_lookup_type,
1130     METH_VARARGS | METH_KEYWORDS,
1131     "lookup_type (name [, block]) -> type\n\
1132 Return a Type corresponding to the given name." },
1133   { "lookup_symbol", (PyCFunction) gdbpy_lookup_symbol,
1134     METH_VARARGS | METH_KEYWORDS,
1135     "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
1136 Return a tuple with the symbol corresponding to the given name (or None) and\n\
1137 a boolean indicating if name is a field of the current implied argument\n\
1138 `this' (when the current language is object-oriented)." },
1139   { "block_for_pc", gdbpy_block_for_pc, METH_VARARGS,
1140     "Return the block containing the given pc value, or None." },
1141   { "solib_name", gdbpy_solib_name, METH_VARARGS,
1142     "solib_name (Long) -> String.\n\
1143 Return the name of the shared library holding a given address, or None." },
1144   { "decode_line", gdbpy_decode_line, METH_VARARGS,
1145     "decode_line (String) -> Tuple.  Decode a string argument the way\n\
1146 that 'break' or 'edit' does.  Return a tuple containing two elements.\n\
1147 The first element contains any unparsed portion of the String parameter\n\
1148 (or None if the string was fully parsed).  The second element contains\n\
1149 a tuple that contains all the locations that match, represented as\n\
1150 gdb.Symtab_and_line objects (or None)."},
1151   { "parse_and_eval", gdbpy_parse_and_eval, METH_VARARGS,
1152     "parse_and_eval (String) -> Value.\n\
1153 Parse String as an expression, evaluate it, and return the result as a Value."
1154   },
1155
1156   { "post_event", gdbpy_post_event, METH_VARARGS,
1157     "Post an event into gdb's event loop." },
1158
1159   { "target_charset", gdbpy_target_charset, METH_NOARGS,
1160     "target_charset () -> string.\n\
1161 Return the name of the current target charset." },
1162   { "target_wide_charset", gdbpy_target_wide_charset, METH_NOARGS,
1163     "target_wide_charset () -> string.\n\
1164 Return the name of the current target wide charset." },
1165
1166   { "string_to_argv", gdbpy_string_to_argv, METH_VARARGS,
1167     "string_to_argv (String) -> Array.\n\
1168 Parse String and return an argv-like array.\n\
1169 Arguments are separate by spaces and may be quoted."
1170   },
1171
1172   { "write", gdbpy_write, METH_VARARGS,
1173     "Write a string using gdb's filtered stream." },
1174   { "flush", gdbpy_flush, METH_NOARGS,
1175     "Flush gdb's filtered stdout stream." },
1176   { "selected_thread", gdbpy_selected_thread, METH_NOARGS,
1177     "selected_thread () -> gdb.InferiorThread.\n\
1178 Return the selected thread object." },
1179   { "inferiors", gdbpy_inferiors, METH_NOARGS,
1180     "inferiors () -> (gdb.Inferior, ...).\n\
1181 Return a tuple containing all inferiors." },
1182   {NULL, NULL, 0, NULL}
1183 };
1184
1185 #endif /* HAVE_PYTHON */