1 /* Python interface to breakpoints 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 "value.h" 22 #include "exceptions.h" 23 #include "python-internal.h" 24 #include "charset.h" 25 #include "breakpoint.h" 26 #include "gdbcmd.h" 27 #include "gdbthread.h" 28 #include "observer.h" 29 #include "cli/cli-script.h" 30 #include "ada-lang.h" 31 #include "arch-utils.h" 32 #include "language.h" 33 34 static PyTypeObject breakpoint_object_type; 35 36 /* Number of live breakpoints. */ 37 static int bppy_live; 38 39 /* Variables used to pass information between the Breakpoint 40 constructor and the breakpoint-created hook function. */ 41 static breakpoint_object *bppy_pending_object; 42 43 /* Function that is called when a Python condition is evaluated. */ 44 static char * const stop_func = "stop"; 45 46 struct breakpoint_object 47 { 48 PyObject_HEAD 49 50 /* The breakpoint number according to gdb. */ 51 int number; 52 53 /* The gdb breakpoint object, or NULL if the breakpoint has been 54 deleted. */ 55 struct breakpoint *bp; 56 }; 57 58 /* Require that BREAKPOINT be a valid breakpoint ID; throw a Python 59 exception if it is invalid. */ 60 #define BPPY_REQUIRE_VALID(Breakpoint) \ 61 do { \ 62 if ((Breakpoint)->bp == NULL) \ 63 return PyErr_Format (PyExc_RuntimeError, \ 64 _("Breakpoint %d is invalid."), \ 65 (Breakpoint)->number); \ 66 } while (0) 67 68 /* Require that BREAKPOINT be a valid breakpoint ID; throw a Python 69 exception if it is invalid. This macro is for use in setter functions. */ 70 #define BPPY_SET_REQUIRE_VALID(Breakpoint) \ 71 do { \ 72 if ((Breakpoint)->bp == NULL) \ 73 { \ 74 PyErr_Format (PyExc_RuntimeError, _("Breakpoint %d is invalid."), \ 75 (Breakpoint)->number); \ 76 return -1; \ 77 } \ 78 } while (0) 79 80 /* This is used to initialize various gdb.bp_* constants. */ 81 struct pybp_code 82 { 83 /* The name. */ 84 const char *name; 85 /* The code. */ 86 enum type_code code; 87 }; 88 89 /* Entries related to the type of user set breakpoints. */ 90 static struct pybp_code pybp_codes[] = 91 { 92 { "BP_NONE", bp_none}, 93 { "BP_BREAKPOINT", bp_breakpoint}, 94 { "BP_WATCHPOINT", bp_watchpoint}, 95 { "BP_HARDWARE_WATCHPOINT", bp_hardware_watchpoint}, 96 { "BP_READ_WATCHPOINT", bp_read_watchpoint}, 97 { "BP_ACCESS_WATCHPOINT", bp_access_watchpoint}, 98 {NULL} /* Sentinel. */ 99 }; 100 101 /* Entries related to the type of watchpoint. */ 102 static struct pybp_code pybp_watch_types[] = 103 { 104 { "WP_READ", hw_read}, 105 { "WP_WRITE", hw_write}, 106 { "WP_ACCESS", hw_access}, 107 {NULL} /* Sentinel. */ 108 }; 109 110 /* Python function which checks the validity of a breakpoint object. */ 111 static PyObject * 112 bppy_is_valid (PyObject *self, PyObject *args) 113 { 114 breakpoint_object *self_bp = (breakpoint_object *) self; 115 116 if (self_bp->bp) 117 Py_RETURN_TRUE; 118 Py_RETURN_FALSE; 119 } 120 121 /* Python function to test whether or not the breakpoint is enabled. */ 122 static PyObject * 123 bppy_get_enabled (PyObject *self, void *closure) 124 { 125 breakpoint_object *self_bp = (breakpoint_object *) self; 126 127 BPPY_REQUIRE_VALID (self_bp); 128 if (! self_bp->bp) 129 Py_RETURN_FALSE; 130 if (self_bp->bp->enable_state == bp_enabled) 131 Py_RETURN_TRUE; 132 Py_RETURN_FALSE; 133 } 134 135 /* Python function to test whether or not the breakpoint is silent. */ 136 static PyObject * 137 bppy_get_silent (PyObject *self, void *closure) 138 { 139 breakpoint_object *self_bp = (breakpoint_object *) self; 140 141 BPPY_REQUIRE_VALID (self_bp); 142 if (self_bp->bp->silent) 143 Py_RETURN_TRUE; 144 Py_RETURN_FALSE; 145 } 146 147 /* Python function to set the enabled state of a breakpoint. */ 148 static int 149 bppy_set_enabled (PyObject *self, PyObject *newvalue, void *closure) 150 { 151 breakpoint_object *self_bp = (breakpoint_object *) self; 152 int cmp; 153 154 BPPY_SET_REQUIRE_VALID (self_bp); 155 156 if (newvalue == NULL) 157 { 158 PyErr_SetString (PyExc_TypeError, 159 _("Cannot delete `enabled' attribute.")); 160 161 return -1; 162 } 163 else if (! PyBool_Check (newvalue)) 164 { 165 PyErr_SetString (PyExc_TypeError, 166 _("The value of `enabled' must be a boolean.")); 167 return -1; 168 } 169 170 cmp = PyObject_IsTrue (newvalue); 171 if (cmp < 0) 172 return -1; 173 else if (cmp == 1) 174 enable_breakpoint (self_bp->bp); 175 else 176 disable_breakpoint (self_bp->bp); 177 return 0; 178 } 179 180 /* Python function to set the 'silent' state of a breakpoint. */ 181 static int 182 bppy_set_silent (PyObject *self, PyObject *newvalue, void *closure) 183 { 184 breakpoint_object *self_bp = (breakpoint_object *) self; 185 int cmp; 186 187 BPPY_SET_REQUIRE_VALID (self_bp); 188 189 if (newvalue == NULL) 190 { 191 PyErr_SetString (PyExc_TypeError, 192 _("Cannot delete `silent' attribute.")); 193 return -1; 194 } 195 else if (! PyBool_Check (newvalue)) 196 { 197 PyErr_SetString (PyExc_TypeError, 198 _("The value of `silent' must be a boolean.")); 199 return -1; 200 } 201 202 cmp = PyObject_IsTrue (newvalue); 203 if (cmp < 0) 204 return -1; 205 else 206 breakpoint_set_silent (self_bp->bp, cmp); 207 208 return 0; 209 } 210 211 /* Python function to set the thread of a breakpoint. */ 212 static int 213 bppy_set_thread (PyObject *self, PyObject *newvalue, void *closure) 214 { 215 breakpoint_object *self_bp = (breakpoint_object *) self; 216 long id; 217 218 BPPY_SET_REQUIRE_VALID (self_bp); 219 220 if (newvalue == NULL) 221 { 222 PyErr_SetString (PyExc_TypeError, 223 _("Cannot delete `thread' attribute.")); 224 return -1; 225 } 226 else if (PyInt_Check (newvalue)) 227 { 228 if (! gdb_py_int_as_long (newvalue, &id)) 229 return -1; 230 231 if (! valid_thread_id (id)) 232 { 233 PyErr_SetString (PyExc_RuntimeError, 234 _("Invalid thread ID.")); 235 return -1; 236 } 237 } 238 else if (newvalue == Py_None) 239 id = -1; 240 else 241 { 242 PyErr_SetString (PyExc_TypeError, 243 _("The value of `thread' must be an integer or None.")); 244 return -1; 245 } 246 247 breakpoint_set_thread (self_bp->bp, id); 248 249 return 0; 250 } 251 252 /* Python function to set the (Ada) task of a breakpoint. */ 253 static int 254 bppy_set_task (PyObject *self, PyObject *newvalue, void *closure) 255 { 256 breakpoint_object *self_bp = (breakpoint_object *) self; 257 long id; 258 259 BPPY_SET_REQUIRE_VALID (self_bp); 260 261 if (newvalue == NULL) 262 { 263 PyErr_SetString (PyExc_TypeError, 264 _("Cannot delete `task' attribute.")); 265 return -1; 266 } 267 else if (PyInt_Check (newvalue)) 268 { 269 if (! gdb_py_int_as_long (newvalue, &id)) 270 return -1; 271 272 if (! valid_task_id (id)) 273 { 274 PyErr_SetString (PyExc_RuntimeError, 275 _("Invalid task ID.")); 276 return -1; 277 } 278 } 279 else if (newvalue == Py_None) 280 id = 0; 281 else 282 { 283 PyErr_SetString (PyExc_TypeError, 284 _("The value of `task' must be an integer or None.")); 285 return -1; 286 } 287 288 breakpoint_set_task (self_bp->bp, id); 289 290 return 0; 291 } 292 293 /* Python function which deletes the underlying GDB breakpoint. This 294 triggers the breakpoint_deleted observer which will call 295 gdbpy_breakpoint_deleted; that function cleans up the Python 296 sections. */ 297 298 static PyObject * 299 bppy_delete_breakpoint (PyObject *self, PyObject *args) 300 { 301 breakpoint_object *self_bp = (breakpoint_object *) self; 302 303 BPPY_REQUIRE_VALID (self_bp); 304 305 delete_breakpoint (self_bp->bp); 306 307 Py_RETURN_NONE; 308 } 309 310 311 /* Python function to set the ignore count of a breakpoint. */ 312 static int 313 bppy_set_ignore_count (PyObject *self, PyObject *newvalue, void *closure) 314 { 315 breakpoint_object *self_bp = (breakpoint_object *) self; 316 long value; 317 318 BPPY_SET_REQUIRE_VALID (self_bp); 319 320 if (newvalue == NULL) 321 { 322 PyErr_SetString (PyExc_TypeError, 323 _("Cannot delete `ignore_count' attribute.")); 324 return -1; 325 } 326 else if (! PyInt_Check (newvalue)) 327 { 328 PyErr_SetString (PyExc_TypeError, 329 _("The value of `ignore_count' must be an integer.")); 330 return -1; 331 } 332 333 if (! gdb_py_int_as_long (newvalue, &value)) 334 return -1; 335 336 if (value < 0) 337 value = 0; 338 set_ignore_count (self_bp->number, (int) value, 0); 339 340 return 0; 341 } 342 343 /* Python function to set the hit count of a breakpoint. */ 344 static int 345 bppy_set_hit_count (PyObject *self, PyObject *newvalue, void *closure) 346 { 347 breakpoint_object *self_bp = (breakpoint_object *) self; 348 349 BPPY_SET_REQUIRE_VALID (self_bp); 350 351 if (newvalue == NULL) 352 { 353 PyErr_SetString (PyExc_TypeError, 354 _("Cannot delete `hit_count' attribute.")); 355 return -1; 356 } 357 else 358 { 359 long value; 360 361 if (! gdb_py_int_as_long (newvalue, &value)) 362 return -1; 363 364 if (value != 0) 365 { 366 PyErr_SetString (PyExc_AttributeError, 367 _("The value of `hit_count' must be zero.")); 368 return -1; 369 } 370 } 371 372 self_bp->bp->hit_count = 0; 373 374 return 0; 375 } 376 377 /* Python function to get the location of a breakpoint. */ 378 static PyObject * 379 bppy_get_location (PyObject *self, void *closure) 380 { 381 char *str; 382 breakpoint_object *obj = (breakpoint_object *) self; 383 384 BPPY_REQUIRE_VALID (obj); 385 386 if (obj->bp->type != bp_breakpoint) 387 Py_RETURN_NONE; 388 389 str = obj->bp->addr_string; 390 391 if (! str) 392 str = ""; 393 return PyString_Decode (str, strlen (str), host_charset (), NULL); 394 } 395 396 /* Python function to get the breakpoint expression. */ 397 static PyObject * 398 bppy_get_expression (PyObject *self, void *closure) 399 { 400 char *str; 401 breakpoint_object *obj = (breakpoint_object *) self; 402 403 BPPY_REQUIRE_VALID (obj); 404 405 if (obj->bp->type != bp_watchpoint 406 && obj->bp->type != bp_hardware_watchpoint 407 && obj->bp->type != bp_read_watchpoint 408 && obj->bp->type != bp_access_watchpoint) 409 Py_RETURN_NONE; 410 411 str = obj->bp->exp_string; 412 if (! str) 413 str = ""; 414 415 return PyString_Decode (str, strlen (str), host_charset (), NULL); 416 } 417 418 /* Python function to get the condition expression of a breakpoint. */ 419 static PyObject * 420 bppy_get_condition (PyObject *self, void *closure) 421 { 422 char *str; 423 breakpoint_object *obj = (breakpoint_object *) self; 424 425 BPPY_REQUIRE_VALID (obj); 426 427 str = obj->bp->cond_string; 428 if (! str) 429 Py_RETURN_NONE; 430 431 return PyString_Decode (str, strlen (str), host_charset (), NULL); 432 } 433 434 /* Returns 0 on success. Returns -1 on error, with a python exception set. 435 */ 436 437 static int 438 bppy_set_condition (PyObject *self, PyObject *newvalue, void *closure) 439 { 440 char *exp; 441 breakpoint_object *self_bp = (breakpoint_object *) self; 442 volatile struct gdb_exception except; 443 444 BPPY_SET_REQUIRE_VALID (self_bp); 445 446 if (newvalue == NULL) 447 { 448 PyErr_SetString (PyExc_TypeError, 449 _("Cannot delete `condition' attribute.")); 450 return -1; 451 } 452 else if (newvalue == Py_None) 453 exp = ""; 454 else 455 { 456 exp = python_string_to_host_string (newvalue); 457 if (exp == NULL) 458 return -1; 459 } 460 461 TRY_CATCH (except, RETURN_MASK_ALL) 462 { 463 set_breakpoint_condition (self_bp->bp, exp, 0); 464 } 465 466 if (newvalue != Py_None) 467 xfree (exp); 468 469 GDB_PY_SET_HANDLE_EXCEPTION (except); 470 471 return 0; 472 } 473 474 /* Python function to get the commands attached to a breakpoint. */ 475 static PyObject * 476 bppy_get_commands (PyObject *self, void *closure) 477 { 478 breakpoint_object *self_bp = (breakpoint_object *) self; 479 struct breakpoint *bp = self_bp->bp; 480 long length; 481 volatile struct gdb_exception except; 482 struct ui_file *string_file; 483 struct cleanup *chain; 484 PyObject *result; 485 char *cmdstr; 486 487 BPPY_REQUIRE_VALID (self_bp); 488 489 if (! self_bp->bp->commands) 490 Py_RETURN_NONE; 491 492 string_file = mem_fileopen (); 493 chain = make_cleanup_ui_file_delete (string_file); 494 495 ui_out_redirect (uiout, string_file); 496 TRY_CATCH (except, RETURN_MASK_ALL) 497 { 498 print_command_lines (uiout, breakpoint_commands (bp), 0); 499 } 500 ui_out_redirect (uiout, NULL); 501 GDB_PY_HANDLE_EXCEPTION (except); 502 503 cmdstr = ui_file_xstrdup (string_file, &length); 504 make_cleanup (xfree, cmdstr); 505 result = PyString_Decode (cmdstr, strlen (cmdstr), host_charset (), NULL); 506 do_cleanups (chain); 507 return result; 508 } 509 510 /* Python function to get the breakpoint type. */ 511 static PyObject * 512 bppy_get_type (PyObject *self, void *closure) 513 { 514 breakpoint_object *self_bp = (breakpoint_object *) self; 515 516 BPPY_REQUIRE_VALID (self_bp); 517 518 return PyInt_FromLong (self_bp->bp->type); 519 } 520 521 /* Python function to get the visibility of the breakpoint. */ 522 523 static PyObject * 524 bppy_get_visibility (PyObject *self, void *closure) 525 { 526 breakpoint_object *self_bp = (breakpoint_object *) self; 527 528 BPPY_REQUIRE_VALID (self_bp); 529 530 if (self_bp->bp->number < 0) 531 Py_RETURN_FALSE; 532 533 Py_RETURN_TRUE; 534 } 535 536 /* Python function to get the breakpoint's number. */ 537 static PyObject * 538 bppy_get_number (PyObject *self, void *closure) 539 { 540 breakpoint_object *self_bp = (breakpoint_object *) self; 541 542 BPPY_REQUIRE_VALID (self_bp); 543 544 return PyInt_FromLong (self_bp->number); 545 } 546 547 /* Python function to get the breakpoint's thread ID. */ 548 static PyObject * 549 bppy_get_thread (PyObject *self, void *closure) 550 { 551 breakpoint_object *self_bp = (breakpoint_object *) self; 552 553 BPPY_REQUIRE_VALID (self_bp); 554 555 if (self_bp->bp->thread == -1) 556 Py_RETURN_NONE; 557 558 return PyInt_FromLong (self_bp->bp->thread); 559 } 560 561 /* Python function to get the breakpoint's task ID (in Ada). */ 562 static PyObject * 563 bppy_get_task (PyObject *self, void *closure) 564 { 565 breakpoint_object *self_bp = (breakpoint_object *) self; 566 567 BPPY_REQUIRE_VALID (self_bp); 568 569 if (self_bp->bp->task == 0) 570 Py_RETURN_NONE; 571 572 return PyInt_FromLong (self_bp->bp->task); 573 } 574 575 /* Python function to get the breakpoint's hit count. */ 576 static PyObject * 577 bppy_get_hit_count (PyObject *self, void *closure) 578 { 579 breakpoint_object *self_bp = (breakpoint_object *) self; 580 581 BPPY_REQUIRE_VALID (self_bp); 582 583 return PyInt_FromLong (self_bp->bp->hit_count); 584 } 585 586 /* Python function to get the breakpoint's ignore count. */ 587 static PyObject * 588 bppy_get_ignore_count (PyObject *self, void *closure) 589 { 590 breakpoint_object *self_bp = (breakpoint_object *) self; 591 592 BPPY_REQUIRE_VALID (self_bp); 593 594 return PyInt_FromLong (self_bp->bp->ignore_count); 595 } 596 597 /* Python function to create a new breakpoint. */ 598 static int 599 bppy_init (PyObject *self, PyObject *args, PyObject *kwargs) 600 { 601 static char *keywords[] = { "spec", "type", "wp_class", "internal", NULL }; 602 char *spec; 603 int type = bp_breakpoint; 604 int access_type = hw_write; 605 PyObject *internal = NULL; 606 int internal_bp = 0; 607 volatile struct gdb_exception except; 608 609 if (! PyArg_ParseTupleAndKeywords (args, kwargs, "s|iiO", keywords, 610 &spec, &type, &access_type, &internal)) 611 return -1; 612 613 if (internal) 614 { 615 internal_bp = PyObject_IsTrue (internal); 616 if (internal_bp == -1) 617 return -1; 618 } 619 620 bppy_pending_object = (breakpoint_object *) self; 621 bppy_pending_object->number = -1; 622 bppy_pending_object->bp = NULL; 623 624 TRY_CATCH (except, RETURN_MASK_ALL) 625 { 626 switch (type) 627 { 628 case bp_breakpoint: 629 { 630 create_breakpoint (python_gdbarch, 631 spec, NULL, -1, 632 0, 633 0, bp_breakpoint, 634 0, 635 AUTO_BOOLEAN_TRUE, 636 NULL, 0, 1, internal_bp); 637 break; 638 } 639 case bp_watchpoint: 640 { 641 if (access_type == hw_write) 642 watch_command_wrapper (spec, 0, internal_bp); 643 else if (access_type == hw_access) 644 awatch_command_wrapper (spec, 0, internal_bp); 645 else if (access_type == hw_read) 646 rwatch_command_wrapper (spec, 0, internal_bp); 647 else 648 error(_("Cannot understand watchpoint access type.")); 649 break; 650 } 651 default: 652 error(_("Do not understand breakpoint type to set.")); 653 } 654 } 655 if (except.reason < 0) 656 { 657 PyErr_Format (except.reason == RETURN_QUIT 658 ? PyExc_KeyboardInterrupt : PyExc_RuntimeError, 659 "%s", except.message); 660 return -1; 661 } 662 663 BPPY_SET_REQUIRE_VALID ((breakpoint_object *) self); 664 return 0; 665 } 666 667 668 669 static int 670 build_bp_list (struct breakpoint *b, void *arg) 671 { 672 PyObject *list = arg; 673 PyObject *bp = (PyObject *) b->py_bp_object; 674 int iserr = 0; 675 676 /* Not all breakpoints will have a companion Python object. 677 Only breakpoints that were created via bppy_new, or 678 breakpoints that were created externally and are tracked by 679 the Python Scripting API. */ 680 if (bp) 681 iserr = PyList_Append (list, bp); 682 683 if (iserr == -1) 684 return 1; 685 686 return 0; 687 } 688 689 /* Static function to return a tuple holding all breakpoints. */ 690 691 PyObject * 692 gdbpy_breakpoints (PyObject *self, PyObject *args) 693 { 694 PyObject *list; 695 696 if (bppy_live == 0) 697 Py_RETURN_NONE; 698 699 list = PyList_New (0); 700 if (!list) 701 return NULL; 702 703 /* If iteratre_over_breakpoints returns non NULL it signals an error 704 condition. In that case abandon building the list and return 705 NULL. */ 706 if (iterate_over_breakpoints (build_bp_list, list) != NULL) 707 { 708 Py_DECREF (list); 709 return NULL; 710 } 711 712 return PyList_AsTuple (list); 713 } 714 715 /* Call the "stop" method (if implemented) in the breakpoint 716 class. If the method returns True, the inferior will be 717 stopped at the breakpoint. Otherwise the inferior will be 718 allowed to continue. */ 719 720 int 721 gdbpy_should_stop (struct breakpoint_object *bp_obj) 722 { 723 int stop = 1; 724 725 PyObject *py_bp = (PyObject *) bp_obj; 726 struct breakpoint *b = bp_obj->bp; 727 struct gdbarch *garch = b->gdbarch ? b->gdbarch : get_current_arch (); 728 struct cleanup *cleanup = ensure_python_env (garch, current_language); 729 730 if (PyObject_HasAttrString (py_bp, stop_func)) 731 { 732 PyObject *result = PyObject_CallMethod (py_bp, stop_func, NULL); 733 734 if (result) 735 { 736 int evaluate = PyObject_IsTrue (result); 737 738 if (evaluate == -1) 739 gdbpy_print_stack (); 740 741 /* If the "stop" function returns False that means 742 the Python breakpoint wants GDB to continue. */ 743 if (! evaluate) 744 stop = 0; 745 746 Py_DECREF (result); 747 } 748 else 749 gdbpy_print_stack (); 750 } 751 do_cleanups (cleanup); 752 753 return stop; 754 } 755 756 /* Checks if the "stop" method exists in this breakpoint. 757 Used by condition_command to ensure mutual exclusion of breakpoint 758 conditions. */ 759 760 int 761 gdbpy_breakpoint_has_py_cond (struct breakpoint_object *bp_obj) 762 { 763 int has_func = 0; 764 PyObject *py_bp = (PyObject *) bp_obj; 765 struct gdbarch *garch = bp_obj->bp->gdbarch ? bp_obj->bp->gdbarch : 766 get_current_arch (); 767 struct cleanup *cleanup = ensure_python_env (garch, current_language); 768 769 if (py_bp == NULL) 770 return 0; 771 772 has_func = PyObject_HasAttrString (py_bp, stop_func); 773 do_cleanups (cleanup); 774 775 return has_func; 776 } 777 778 779 780 /* Event callback functions. */ 781 782 /* Callback that is used when a breakpoint is created. This function 783 will create a new Python breakpoint object. */ 784 static void 785 gdbpy_breakpoint_created (int num) 786 { 787 breakpoint_object *newbp; 788 struct breakpoint *bp = NULL; 789 PyGILState_STATE state; 790 791 bp = get_breakpoint (num); 792 if (! bp) 793 return; 794 795 if (num < 0 && bppy_pending_object == NULL) 796 return; 797 798 if (bp->type != bp_breakpoint 799 && bp->type != bp_watchpoint 800 && bp->type != bp_hardware_watchpoint 801 && bp->type != bp_read_watchpoint 802 && bp->type != bp_access_watchpoint) 803 return; 804 805 state = PyGILState_Ensure (); 806 807 if (bppy_pending_object) 808 { 809 newbp = bppy_pending_object; 810 bppy_pending_object = NULL; 811 } 812 else 813 newbp = PyObject_New (breakpoint_object, &breakpoint_object_type); 814 if (newbp) 815 { 816 newbp->number = num; 817 newbp->bp = bp; 818 newbp->bp->py_bp_object = newbp; 819 Py_INCREF (newbp); 820 ++bppy_live; 821 } 822 else 823 { 824 PyErr_SetString (PyExc_RuntimeError, 825 _("Error while creating breakpoint from GDB.")); 826 gdbpy_print_stack (); 827 } 828 829 PyGILState_Release (state); 830 } 831 832 /* Callback that is used when a breakpoint is deleted. This will 833 invalidate the corresponding Python object. */ 834 static void 835 gdbpy_breakpoint_deleted (int num) 836 { 837 PyGILState_STATE state; 838 struct breakpoint *bp = NULL; 839 breakpoint_object *bp_obj; 840 841 state = PyGILState_Ensure (); 842 bp = get_breakpoint (num); 843 if (! bp) 844 return; 845 846 bp_obj = bp->py_bp_object; 847 if (bp_obj) 848 { 849 bp_obj->bp = NULL; 850 --bppy_live; 851 Py_DECREF (bp_obj); 852 } 853 PyGILState_Release (state); 854 } 855 856 857 858 /* Initialize the Python breakpoint code. */ 859 void 860 gdbpy_initialize_breakpoints (void) 861 { 862 int i; 863 864 if (PyType_Ready (&breakpoint_object_type) < 0) 865 return; 866 867 Py_INCREF (&breakpoint_object_type); 868 PyModule_AddObject (gdb_module, "Breakpoint", 869 (PyObject *) &breakpoint_object_type); 870 871 observer_attach_breakpoint_created (gdbpy_breakpoint_created); 872 observer_attach_breakpoint_deleted (gdbpy_breakpoint_deleted); 873 874 /* Add breakpoint types constants. */ 875 for (i = 0; pybp_codes[i].name; ++i) 876 { 877 if (PyModule_AddIntConstant (gdb_module, 878 /* Cast needed for Python 2.4. */ 879 (char *) pybp_codes[i].name, 880 pybp_codes[i].code) < 0) 881 return; 882 } 883 884 /* Add watchpoint types constants. */ 885 for (i = 0; pybp_watch_types[i].name; ++i) 886 { 887 if (PyModule_AddIntConstant (gdb_module, 888 /* Cast needed for Python 2.4. */ 889 (char *) pybp_watch_types[i].name, 890 pybp_watch_types[i].code) < 0) 891 return; 892 } 893 894 } 895 896 897 898 /* Helper function that overrides this Python object's 899 PyObject_GenericSetAttr to allow extra validation of the attribute 900 being set. */ 901 902 static int 903 local_setattro (PyObject *self, PyObject *name, PyObject *v) 904 { 905 breakpoint_object *obj = (breakpoint_object *) self; 906 char *attr = python_string_to_host_string (name); 907 908 if (attr == NULL) 909 return -1; 910 911 /* If the attribute trying to be set is the "stop" method, 912 but we already have a condition set in the CLI, disallow this 913 operation. */ 914 if (strcmp (attr, stop_func) == 0 && obj->bp->cond_string) 915 { 916 xfree (attr); 917 PyErr_SetString (PyExc_RuntimeError, 918 _("Cannot set 'stop' method. There is an " \ 919 "existing GDB condition attached to the " \ 920 "breakpoint.")); 921 return -1; 922 } 923 924 xfree (attr); 925 926 return PyObject_GenericSetAttr ((PyObject *)self, name, v); 927 } 928 929 static PyGetSetDef breakpoint_object_getset[] = { 930 { "enabled", bppy_get_enabled, bppy_set_enabled, 931 "Boolean telling whether the breakpoint is enabled.", NULL }, 932 { "silent", bppy_get_silent, bppy_set_silent, 933 "Boolean telling whether the breakpoint is silent.", NULL }, 934 { "thread", bppy_get_thread, bppy_set_thread, 935 "Thread ID for the breakpoint.\n\ 936 If the value is a thread ID (integer), then this is a thread-specific breakpoint.\n\ 937 If the value is None, then this breakpoint is not thread-specific.\n\ 938 No other type of value can be used.", NULL }, 939 { "task", bppy_get_task, bppy_set_task, 940 "Thread ID for the breakpoint.\n\ 941 If the value is a task ID (integer), then this is an Ada task-specific breakpoint.\n\ 942 If the value is None, then this breakpoint is not task-specific.\n\ 943 No other type of value can be used.", NULL }, 944 { "ignore_count", bppy_get_ignore_count, bppy_set_ignore_count, 945 "Number of times this breakpoint should be automatically continued.", 946 NULL }, 947 { "number", bppy_get_number, NULL, 948 "Breakpoint's number assigned by GDB.", NULL }, 949 { "hit_count", bppy_get_hit_count, bppy_set_hit_count, 950 "Number of times the breakpoint has been hit.\n\ 951 Can be set to zero to clear the count. No other value is valid\n\ 952 when setting this property.", NULL }, 953 { "location", bppy_get_location, NULL, 954 "Location of the breakpoint, as specified by the user.", NULL}, 955 { "expression", bppy_get_expression, NULL, 956 "Expression of the breakpoint, as specified by the user.", NULL}, 957 { "condition", bppy_get_condition, bppy_set_condition, 958 "Condition of the breakpoint, as specified by the user,\ 959 or None if no condition set."}, 960 { "commands", bppy_get_commands, NULL, 961 "Commands of the breakpoint, as specified by the user."}, 962 { "type", bppy_get_type, NULL, 963 "Type of breakpoint."}, 964 { "visible", bppy_get_visibility, NULL, 965 "Whether the breakpoint is visible to the user."}, 966 { NULL } /* Sentinel. */ 967 }; 968 969 static PyMethodDef breakpoint_object_methods[] = 970 { 971 { "is_valid", bppy_is_valid, METH_NOARGS, 972 "Return true if this breakpoint is valid, false if not." }, 973 { "delete", bppy_delete_breakpoint, METH_NOARGS, 974 "Delete the underlying GDB breakpoint." }, 975 { NULL } /* Sentinel. */ 976 }; 977 978 static PyTypeObject breakpoint_object_type = 979 { 980 PyObject_HEAD_INIT (NULL) 981 0, /*ob_size*/ 982 "gdb.Breakpoint", /*tp_name*/ 983 sizeof (breakpoint_object), /*tp_basicsize*/ 984 0, /*tp_itemsize*/ 985 0, /*tp_dealloc*/ 986 0, /*tp_print*/ 987 0, /*tp_getattr*/ 988 0, /*tp_setattr*/ 989 0, /*tp_compare*/ 990 0, /*tp_repr*/ 991 0, /*tp_as_number*/ 992 0, /*tp_as_sequence*/ 993 0, /*tp_as_mapping*/ 994 0, /*tp_hash */ 995 0, /*tp_call*/ 996 0, /*tp_str*/ 997 0, /*tp_getattro*/ 998 (setattrofunc)local_setattro, /*tp_setattro */ 999 0, /*tp_as_buffer*/ 1000 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ 1001 "GDB breakpoint object", /* tp_doc */ 1002 0, /* tp_traverse */ 1003 0, /* tp_clear */ 1004 0, /* tp_richcompare */ 1005 0, /* tp_weaklistoffset */ 1006 0, /* tp_iter */ 1007 0, /* tp_iternext */ 1008 breakpoint_object_methods, /* tp_methods */ 1009 0, /* tp_members */ 1010 breakpoint_object_getset, /* tp_getset */ 1011 0, /* tp_base */ 1012 0, /* tp_dict */ 1013 0, /* tp_descr_get */ 1014 0, /* tp_descr_set */ 1015 0, /* tp_dictoffset */ 1016 bppy_init, /* tp_init */ 1017 0, /* tp_alloc */ 1018 PyType_GenericNew /* tp_new */ 1019 }; 1020