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 "progspace.h" 27 #include "objfiles.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 #ifdef HAVE_PYTHON 39 40 #include "python.h" 41 #include "libiberty.h" 42 #include "cli/cli-decode.h" 43 #include "charset.h" 44 #include "top.h" 45 #include "python-internal.h" 46 #include "version.h" 47 #include "target.h" 48 #include "gdbthread.h" 49 50 static PyMethodDef GdbMethods[]; 51 52 PyObject *gdb_module; 53 54 /* Some string constants we may wish to use. */ 55 PyObject *gdbpy_to_string_cst; 56 PyObject *gdbpy_children_cst; 57 PyObject *gdbpy_display_hint_cst; 58 PyObject *gdbpy_doc_cst; 59 PyObject *gdbpy_enabled_cst; 60 61 /* The GdbError exception. */ 62 PyObject *gdbpy_gdberror_exc; 63 64 /* Architecture and language to be used in callbacks from 65 the Python interpreter. */ 66 struct gdbarch *python_gdbarch; 67 const struct language_defn *python_language; 68 69 /* Restore global language and architecture and Python GIL state 70 when leaving the Python interpreter. */ 71 72 struct python_env 73 { 74 PyGILState_STATE state; 75 struct gdbarch *gdbarch; 76 const struct language_defn *language; 77 }; 78 79 static void 80 restore_python_env (void *p) 81 { 82 struct python_env *env = (struct python_env *)p; 83 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 132 strcpy (&script[here], iter->line); 133 here += len; 134 script[here++] = '\n'; 135 } 136 script[here] = '\0'; 137 return script; 138 } 139 140 /* Take a command line structure representing a 'python' command, and 141 evaluate its body using the Python interpreter. */ 142 143 void 144 eval_python_from_control_command (struct command_line *cmd) 145 { 146 int ret; 147 char *script; 148 struct cleanup *cleanup; 149 150 if (cmd->body_count != 1) 151 error (_("Invalid \"python\" block structure.")); 152 153 cleanup = ensure_python_env (get_current_arch (), current_language); 154 155 script = compute_python_string (cmd->body_list[0]); 156 ret = PyRun_SimpleString (script); 157 xfree (script); 158 if (ret) 159 { 160 gdbpy_print_stack (); 161 error (_("Error while executing Python code.")); 162 } 163 164 do_cleanups (cleanup); 165 } 166 167 /* Implementation of the gdb "python" command. */ 168 169 static void 170 python_command (char *arg, int from_tty) 171 { 172 struct cleanup *cleanup; 173 174 cleanup = ensure_python_env (get_current_arch (), current_language); 175 while (arg && *arg && isspace (*arg)) 176 ++arg; 177 if (arg && *arg) 178 { 179 if (PyRun_SimpleString (arg)) 180 { 181 gdbpy_print_stack (); 182 error (_("Error while executing Python code.")); 183 } 184 } 185 else 186 { 187 struct command_line *l = get_command_line (python_control, ""); 188 189 make_cleanup_free_command_lines (&l); 190 execute_control_command_untraced (l); 191 } 192 193 do_cleanups (cleanup); 194 } 195 196 197 198 /* Transform a gdb parameters's value into a Python value. May return 199 NULL (and set a Python exception) on error. Helper function for 200 get_parameter. */ 201 PyObject * 202 gdbpy_parameter_value (enum var_types type, void *var) 203 { 204 switch (type) 205 { 206 case var_string: 207 case var_string_noescape: 208 case var_optional_filename: 209 case var_filename: 210 case var_enum: 211 { 212 char *str = * (char **) var; 213 214 if (! str) 215 str = ""; 216 return PyString_Decode (str, strlen (str), host_charset (), NULL); 217 } 218 219 case var_boolean: 220 { 221 if (* (int *) var) 222 Py_RETURN_TRUE; 223 else 224 Py_RETURN_FALSE; 225 } 226 227 case var_auto_boolean: 228 { 229 enum auto_boolean ab = * (enum auto_boolean *) var; 230 231 if (ab == AUTO_BOOLEAN_TRUE) 232 Py_RETURN_TRUE; 233 else if (ab == AUTO_BOOLEAN_FALSE) 234 Py_RETURN_FALSE; 235 else 236 Py_RETURN_NONE; 237 } 238 239 case var_integer: 240 if ((* (int *) var) == INT_MAX) 241 Py_RETURN_NONE; 242 /* Fall through. */ 243 case var_zinteger: 244 return PyLong_FromLong (* (int *) var); 245 246 case var_uinteger: 247 { 248 unsigned int val = * (unsigned int *) var; 249 250 if (val == UINT_MAX) 251 Py_RETURN_NONE; 252 return PyLong_FromUnsignedLong (val); 253 } 254 } 255 256 return PyErr_Format (PyExc_RuntimeError, 257 _("Programmer error: unhandled type.")); 258 } 259 260 /* A Python function which returns a gdb parameter's value as a Python 261 value. */ 262 263 PyObject * 264 gdbpy_parameter (PyObject *self, PyObject *args) 265 { 266 struct cmd_list_element *alias, *prefix, *cmd; 267 char *arg, *newarg; 268 int found = -1; 269 volatile struct gdb_exception except; 270 271 if (! PyArg_ParseTuple (args, "s", &arg)) 272 return NULL; 273 274 newarg = concat ("show ", arg, (char *) NULL); 275 276 TRY_CATCH (except, RETURN_MASK_ALL) 277 { 278 found = lookup_cmd_composition (newarg, &alias, &prefix, &cmd); 279 } 280 xfree (newarg); 281 GDB_PY_HANDLE_EXCEPTION (except); 282 if (!found) 283 return PyErr_Format (PyExc_RuntimeError, 284 _("Could not find parameter `%s'."), arg); 285 286 if (! cmd->var) 287 return PyErr_Format (PyExc_RuntimeError, 288 _("`%s' is not a parameter."), arg); 289 return gdbpy_parameter_value (cmd->var_type, cmd->var); 290 } 291 292 /* Wrapper for target_charset. */ 293 294 static PyObject * 295 gdbpy_target_charset (PyObject *self, PyObject *args) 296 { 297 const char *cset = target_charset (python_gdbarch); 298 299 return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL); 300 } 301 302 /* Wrapper for target_wide_charset. */ 303 304 static PyObject * 305 gdbpy_target_wide_charset (PyObject *self, PyObject *args) 306 { 307 const char *cset = target_wide_charset (python_gdbarch); 308 309 return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL); 310 } 311 312 /* A Python function which evaluates a string using the gdb CLI. */ 313 314 static PyObject * 315 execute_gdb_command (PyObject *self, PyObject *args, PyObject *kw) 316 { 317 char *arg; 318 PyObject *from_tty_obj = NULL, *to_string_obj = NULL; 319 int from_tty, to_string; 320 volatile struct gdb_exception except; 321 static char *keywords[] = {"command", "from_tty", "to_string", NULL }; 322 char *result = NULL; 323 324 if (! PyArg_ParseTupleAndKeywords (args, kw, "s|O!O!", keywords, &arg, 325 &PyBool_Type, &from_tty_obj, 326 &PyBool_Type, &to_string_obj)) 327 return NULL; 328 329 from_tty = 0; 330 if (from_tty_obj) 331 { 332 int cmp = PyObject_IsTrue (from_tty_obj); 333 if (cmp < 0) 334 return NULL; 335 from_tty = cmp; 336 } 337 338 to_string = 0; 339 if (to_string_obj) 340 { 341 int cmp = PyObject_IsTrue (to_string_obj); 342 if (cmp < 0) 343 return NULL; 344 to_string = cmp; 345 } 346 347 TRY_CATCH (except, RETURN_MASK_ALL) 348 { 349 /* Copy the argument text in case the command modifies it. */ 350 char *copy = xstrdup (arg); 351 struct cleanup *cleanup = make_cleanup (xfree, copy); 352 353 if (to_string) 354 result = execute_command_to_string (copy, from_tty); 355 else 356 { 357 result = NULL; 358 execute_command (copy, from_tty); 359 } 360 361 do_cleanups (cleanup); 362 } 363 GDB_PY_HANDLE_EXCEPTION (except); 364 365 /* Do any commands attached to breakpoint we stopped at. */ 366 bpstat_do_actions (); 367 368 if (result) 369 { 370 PyObject *r = PyString_FromString (result); 371 xfree (result); 372 return r; 373 } 374 Py_RETURN_NONE; 375 } 376 377 /* Parse a string and evaluate it as an expression. */ 378 static PyObject * 379 gdbpy_parse_and_eval (PyObject *self, PyObject *args) 380 { 381 char *expr_str; 382 struct value *result = NULL; 383 volatile struct gdb_exception except; 384 385 if (!PyArg_ParseTuple (args, "s", &expr_str)) 386 return NULL; 387 388 TRY_CATCH (except, RETURN_MASK_ALL) 389 { 390 result = parse_and_eval (expr_str); 391 } 392 GDB_PY_HANDLE_EXCEPTION (except); 393 394 return value_to_value_object (result); 395 } 396 397 /* Read a file as Python code. STREAM is the input file; FILE is the 398 name of the file. 399 STREAM is not closed, that is the caller's responsibility. */ 400 401 void 402 source_python_script (FILE *stream, const char *file) 403 { 404 struct cleanup *cleanup; 405 406 cleanup = ensure_python_env (get_current_arch (), current_language); 407 408 /* Note: If an exception occurs python will print the traceback and 409 clear the error indicator. */ 410 PyRun_SimpleFile (stream, file); 411 412 do_cleanups (cleanup); 413 } 414 415 416 417 /* Printing. */ 418 419 /* A python function to write a single string using gdb's filtered 420 output stream. */ 421 static PyObject * 422 gdbpy_write (PyObject *self, PyObject *args) 423 { 424 char *arg; 425 426 if (! PyArg_ParseTuple (args, "s", &arg)) 427 return NULL; 428 printf_filtered ("%s", arg); 429 Py_RETURN_NONE; 430 } 431 432 /* A python function to flush gdb's filtered output stream. */ 433 static PyObject * 434 gdbpy_flush (PyObject *self, PyObject *args) 435 { 436 gdb_flush (gdb_stdout); 437 Py_RETURN_NONE; 438 } 439 440 /* Print a python exception trace, or print nothing and clear the 441 python exception, depending on gdbpy_should_print_stack. Only call 442 this if a python exception is set. */ 443 void 444 gdbpy_print_stack (void) 445 { 446 if (gdbpy_should_print_stack) 447 { 448 PyErr_Print (); 449 /* PyErr_Print doesn't necessarily end output with a newline. 450 This works because Python's stdout/stderr is fed through 451 printf_filtered. */ 452 begin_line (); 453 } 454 else 455 PyErr_Clear (); 456 } 457 458 459 460 /* Return the current Progspace. 461 There always is one. */ 462 463 static PyObject * 464 gdbpy_get_current_progspace (PyObject *unused1, PyObject *unused2) 465 { 466 PyObject *result; 467 468 result = pspace_to_pspace_object (current_program_space); 469 if (result) 470 Py_INCREF (result); 471 return result; 472 } 473 474 /* Return a sequence holding all the Progspaces. */ 475 476 static PyObject * 477 gdbpy_progspaces (PyObject *unused1, PyObject *unused2) 478 { 479 struct program_space *ps; 480 PyObject *list; 481 482 list = PyList_New (0); 483 if (!list) 484 return NULL; 485 486 ALL_PSPACES (ps) 487 { 488 PyObject *item = pspace_to_pspace_object (ps); 489 490 if (!item || PyList_Append (list, item) == -1) 491 { 492 Py_DECREF (list); 493 return NULL; 494 } 495 } 496 497 return list; 498 } 499 500 501 502 /* The "current" objfile. This is set when gdb detects that a new 503 objfile has been loaded. It is only set for the duration of a call to 504 source_python_script_for_objfile; it is NULL at other times. */ 505 static struct objfile *gdbpy_current_objfile; 506 507 /* Set the current objfile to OBJFILE and then read STREAM,FILE as 508 Python code. */ 509 510 void 511 source_python_script_for_objfile (struct objfile *objfile, 512 FILE *stream, const char *file) 513 { 514 struct cleanup *cleanups; 515 516 cleanups = ensure_python_env (get_objfile_arch (objfile), current_language); 517 gdbpy_current_objfile = objfile; 518 519 /* Note: If an exception occurs python will print the traceback and 520 clear the error indicator. */ 521 PyRun_SimpleFile (stream, file); 522 523 do_cleanups (cleanups); 524 gdbpy_current_objfile = NULL; 525 } 526 527 /* Return the current Objfile, or None if there isn't one. */ 528 529 static PyObject * 530 gdbpy_get_current_objfile (PyObject *unused1, PyObject *unused2) 531 { 532 PyObject *result; 533 534 if (! gdbpy_current_objfile) 535 Py_RETURN_NONE; 536 537 result = objfile_to_objfile_object (gdbpy_current_objfile); 538 if (result) 539 Py_INCREF (result); 540 return result; 541 } 542 543 /* Return a sequence holding all the Objfiles. */ 544 545 static PyObject * 546 gdbpy_objfiles (PyObject *unused1, PyObject *unused2) 547 { 548 struct objfile *objf; 549 PyObject *list; 550 551 list = PyList_New (0); 552 if (!list) 553 return NULL; 554 555 ALL_OBJFILES (objf) 556 { 557 PyObject *item = objfile_to_objfile_object (objf); 558 559 if (!item || PyList_Append (list, item) == -1) 560 { 561 Py_DECREF (list); 562 return NULL; 563 } 564 } 565 566 return list; 567 } 568 569 #else /* HAVE_PYTHON */ 570 571 /* Dummy implementation of the gdb "python" command. */ 572 573 static void 574 python_command (char *arg, int from_tty) 575 { 576 while (arg && *arg && isspace (*arg)) 577 ++arg; 578 if (arg && *arg) 579 error (_("Python scripting is not supported in this copy of GDB.")); 580 else 581 { 582 struct command_line *l = get_command_line (python_control, ""); 583 struct cleanup *cleanups = make_cleanup_free_command_lines (&l); 584 585 execute_control_command_untraced (l); 586 do_cleanups (cleanups); 587 } 588 } 589 590 void 591 eval_python_from_control_command (struct command_line *cmd) 592 { 593 error (_("Python scripting is not supported in this copy of GDB.")); 594 } 595 596 void 597 source_python_script (FILE *stream, const char *file) 598 { 599 throw_error (UNSUPPORTED_ERROR, 600 _("Python scripting is not supported in this copy of GDB.")); 601 } 602 603 #endif /* HAVE_PYTHON */ 604 605 606 607 /* Lists for 'maint set python' commands. */ 608 609 struct cmd_list_element *set_python_list; 610 struct cmd_list_element *show_python_list; 611 612 /* Function for use by 'maint set python' prefix command. */ 613 614 static void 615 set_python (char *args, int from_tty) 616 { 617 help_list (set_python_list, "maintenance set python ", -1, gdb_stdout); 618 } 619 620 /* Function for use by 'maint show python' prefix command. */ 621 622 static void 623 show_python (char *args, int from_tty) 624 { 625 cmd_show_list (show_python_list, from_tty, ""); 626 } 627 628 /* Initialize the Python code. */ 629 630 /* Provide a prototype to silence -Wmissing-prototypes. */ 631 extern initialize_file_ftype _initialize_python; 632 633 void 634 _initialize_python (void) 635 { 636 add_com ("python", class_obscure, python_command, 637 #ifdef HAVE_PYTHON 638 _("\ 639 Evaluate a Python command.\n\ 640 \n\ 641 The command can be given as an argument, for instance:\n\ 642 \n\ 643 python print 23\n\ 644 \n\ 645 If no argument is given, the following lines are read and used\n\ 646 as the Python commands. Type a line containing \"end\" to indicate\n\ 647 the end of the command.") 648 #else /* HAVE_PYTHON */ 649 _("\ 650 Evaluate a Python command.\n\ 651 \n\ 652 Python scripting is not supported in this copy of GDB.\n\ 653 This command is only a placeholder.") 654 #endif /* HAVE_PYTHON */ 655 ); 656 657 add_prefix_cmd ("python", no_class, show_python, 658 _("Prefix command for python maintenance settings."), 659 &show_python_list, "maintenance show python ", 0, 660 &maintenance_show_cmdlist); 661 add_prefix_cmd ("python", no_class, set_python, 662 _("Prefix command for python maintenance settings."), 663 &set_python_list, "maintenance set python ", 0, 664 &maintenance_set_cmdlist); 665 666 add_setshow_boolean_cmd ("print-stack", class_maintenance, 667 &gdbpy_should_print_stack, _("\ 668 Enable or disable printing of Python stack dump on error."), _("\ 669 Show whether Python stack will be printed on error."), _("\ 670 Enables or disables printing of Python stack traces."), 671 NULL, NULL, 672 &set_python_list, 673 &show_python_list); 674 675 #ifdef HAVE_PYTHON 676 #ifdef WITH_PYTHON_PATH 677 /* Work around problem where python gets confused about where it is, 678 and then can't find its libraries, etc. 679 NOTE: Python assumes the following layout: 680 /foo/bin/python 681 /foo/lib/pythonX.Y/... 682 This must be done before calling Py_Initialize. */ 683 Py_SetProgramName (concat (ldirname (python_libdir), SLASH_STRING, "bin", 684 SLASH_STRING, "python", NULL)); 685 #endif 686 687 Py_Initialize (); 688 PyEval_InitThreads (); 689 690 gdb_module = Py_InitModule ("gdb", GdbMethods); 691 692 /* The casts to (char*) are for python 2.4. */ 693 PyModule_AddStringConstant (gdb_module, "VERSION", (char*) version); 694 PyModule_AddStringConstant (gdb_module, "HOST_CONFIG", (char*) host_name); 695 PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG", (char*) target_name); 696 { 697 char *gdb_pythondir; 698 699 gdb_pythondir = concat (gdb_datadir, SLASH_STRING, "python", NULL); 700 PyModule_AddStringConstant (gdb_module, "PYTHONDIR", gdb_pythondir); 701 xfree (gdb_pythondir); 702 } 703 704 gdbpy_gdberror_exc = PyErr_NewException ("gdb.GdbError", NULL, NULL); 705 PyModule_AddObject (gdb_module, "GdbError", gdbpy_gdberror_exc); 706 707 gdbpy_initialize_auto_load (); 708 gdbpy_initialize_values (); 709 gdbpy_initialize_frames (); 710 gdbpy_initialize_commands (); 711 gdbpy_initialize_symbols (); 712 gdbpy_initialize_symtabs (); 713 gdbpy_initialize_blocks (); 714 gdbpy_initialize_functions (); 715 gdbpy_initialize_parameters (); 716 gdbpy_initialize_types (); 717 gdbpy_initialize_pspace (); 718 gdbpy_initialize_objfile (); 719 gdbpy_initialize_breakpoints (); 720 gdbpy_initialize_lazy_string (); 721 gdbpy_initialize_thread (); 722 gdbpy_initialize_inferior (); 723 724 PyRun_SimpleString ("import gdb"); 725 PyRun_SimpleString ("gdb.pretty_printers = []"); 726 727 gdbpy_to_string_cst = PyString_FromString ("to_string"); 728 gdbpy_children_cst = PyString_FromString ("children"); 729 gdbpy_display_hint_cst = PyString_FromString ("display_hint"); 730 gdbpy_doc_cst = PyString_FromString ("__doc__"); 731 gdbpy_enabled_cst = PyString_FromString ("enabled"); 732 733 /* Create a couple objects which are used for Python's stdout and 734 stderr. */ 735 PyRun_SimpleString ("\ 736 import sys\n\ 737 class GdbOutputFile:\n\ 738 def close(self):\n\ 739 # Do nothing.\n\ 740 return None\n\ 741 \n\ 742 def isatty(self):\n\ 743 return False\n\ 744 \n\ 745 def write(self, s):\n\ 746 gdb.write(s)\n\ 747 \n\ 748 def writelines(self, iterable):\n\ 749 for line in iterable:\n\ 750 self.write(line)\n\ 751 \n\ 752 def flush(self):\n\ 753 gdb.flush()\n\ 754 \n\ 755 sys.stderr = GdbOutputFile()\n\ 756 sys.stdout = GdbOutputFile()\n\ 757 \n\ 758 # GDB's python scripts are stored inside gdb.PYTHONDIR. So insert\n\ 759 # that directory name at the start of sys.path to allow the Python\n\ 760 # interpreter to find them.\n\ 761 sys.path.insert(0, gdb.PYTHONDIR)\n\ 762 \n\ 763 # The gdb module is implemented in C rather than in Python. As a result,\n\ 764 # the associated __init.py__ script is not not executed by default when\n\ 765 # the gdb module gets imported. Execute that script manually if it exists.\n\ 766 gdb.__path__ = [gdb.PYTHONDIR + '/gdb']\n\ 767 from os.path import exists\n\ 768 ipy = gdb.PYTHONDIR + '/gdb/__init__.py'\n\ 769 if exists (ipy):\n\ 770 execfile (ipy)\n\ 771 "); 772 773 /* Release the GIL while gdb runs. */ 774 PyThreadState_Swap (NULL); 775 PyEval_ReleaseLock (); 776 777 #endif /* HAVE_PYTHON */ 778 } 779 780 781 782 #if HAVE_PYTHON 783 784 static PyMethodDef GdbMethods[] = 785 { 786 { "history", gdbpy_history, METH_VARARGS, 787 "Get a value from history" }, 788 { "execute", (PyCFunction) execute_gdb_command, METH_VARARGS | METH_KEYWORDS, 789 "Execute a gdb command" }, 790 { "parameter", gdbpy_parameter, METH_VARARGS, 791 "Return a gdb parameter's value" }, 792 793 { "breakpoints", gdbpy_breakpoints, METH_NOARGS, 794 "Return a tuple of all breakpoint objects" }, 795 796 { "default_visualizer", gdbpy_default_visualizer, METH_VARARGS, 797 "Find the default visualizer for a Value." }, 798 799 { "current_progspace", gdbpy_get_current_progspace, METH_NOARGS, 800 "Return the current Progspace." }, 801 { "progspaces", gdbpy_progspaces, METH_NOARGS, 802 "Return a sequence of all progspaces." }, 803 804 { "current_objfile", gdbpy_get_current_objfile, METH_NOARGS, 805 "Return the current Objfile being loaded, or None." }, 806 { "objfiles", gdbpy_objfiles, METH_NOARGS, 807 "Return a sequence of all loaded objfiles." }, 808 809 { "selected_frame", gdbpy_selected_frame, METH_NOARGS, 810 "selected_frame () -> gdb.Frame.\n\ 811 Return the selected frame object." }, 812 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string, METH_VARARGS, 813 "stop_reason_string (Integer) -> String.\n\ 814 Return a string explaining unwind stop reason." }, 815 816 { "lookup_type", (PyCFunction) gdbpy_lookup_type, 817 METH_VARARGS | METH_KEYWORDS, 818 "lookup_type (name [, block]) -> type\n\ 819 Return a Type corresponding to the given name." }, 820 { "lookup_symbol", (PyCFunction) gdbpy_lookup_symbol, 821 METH_VARARGS | METH_KEYWORDS, 822 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\ 823 Return a tuple with the symbol corresponding to the given name (or None) and\n\ 824 a boolean indicating if name is a field of the current implied argument\n\ 825 `this' (when the current language is object-oriented)." }, 826 { "block_for_pc", gdbpy_block_for_pc, METH_VARARGS, 827 "Return the block containing the given pc value, or None." }, 828 { "parse_and_eval", gdbpy_parse_and_eval, METH_VARARGS, 829 "parse_and_eval (String) -> Value.\n\ 830 Parse String as an expression, evaluate it, and return the result as a Value." 831 }, 832 833 { "target_charset", gdbpy_target_charset, METH_NOARGS, 834 "target_charset () -> string.\n\ 835 Return the name of the current target charset." }, 836 { "target_wide_charset", gdbpy_target_wide_charset, METH_NOARGS, 837 "target_wide_charset () -> string.\n\ 838 Return the name of the current target wide charset." }, 839 840 { "string_to_argv", gdbpy_string_to_argv, METH_VARARGS, 841 "string_to_argv (String) -> Array.\n\ 842 Parse String and return an argv-like array.\n\ 843 Arguments are separate by spaces and may be quoted." 844 }, 845 846 { "write", gdbpy_write, METH_VARARGS, 847 "Write a string using gdb's filtered stream." }, 848 { "flush", gdbpy_flush, METH_NOARGS, 849 "Flush gdb's filtered stdout stream." }, 850 { "selected_thread", gdbpy_selected_thread, METH_NOARGS, 851 "selected_thread () -> gdb.InferiorThread.\n\ 852 Return the selected thread object." }, 853 { "inferiors", gdbpy_inferiors, METH_NOARGS, 854 "inferiors () -> (gdb.Inferior, ...).\n\ 855 Return a tuple containing all inferiors." }, 856 {NULL, NULL, 0, NULL} 857 }; 858 859 #endif /* HAVE_PYTHON */ 860