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