1 /* Python interface to breakpoints
3 Copyright (C) 2008-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
22 #include "exceptions.h"
23 #include "python-internal.h"
26 #include "breakpoint.h"
28 #include "gdbthread.h"
30 #include "cli/cli-script.h"
32 #include "arch-utils.h"
35 /* Number of live breakpoints. */
38 /* Variables used to pass information between the Breakpoint
39 constructor and the breakpoint-created hook function. */
40 gdbpy_breakpoint_object
*bppy_pending_object
;
42 /* Function that is called when a Python condition is evaluated. */
43 static char * const stop_func
= "stop";
45 /* This is used to initialize various gdb.bp_* constants. */
54 /* Entries related to the type of user set breakpoints. */
55 static struct pybp_code pybp_codes
[] =
57 { "BP_NONE", bp_none
},
58 { "BP_BREAKPOINT", bp_breakpoint
},
59 { "BP_WATCHPOINT", bp_watchpoint
},
60 { "BP_HARDWARE_WATCHPOINT", bp_hardware_watchpoint
},
61 { "BP_READ_WATCHPOINT", bp_read_watchpoint
},
62 { "BP_ACCESS_WATCHPOINT", bp_access_watchpoint
},
63 {NULL
} /* Sentinel. */
66 /* Entries related to the type of watchpoint. */
67 static struct pybp_code pybp_watch_types
[] =
69 { "WP_READ", hw_read
},
70 { "WP_WRITE", hw_write
},
71 { "WP_ACCESS", hw_access
},
72 {NULL
} /* Sentinel. */
75 /* Python function which checks the validity of a breakpoint object. */
77 bppy_is_valid (PyObject
*self
, PyObject
*args
)
79 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
86 /* Python function to test whether or not the breakpoint is enabled. */
88 bppy_get_enabled (PyObject
*self
, void *closure
)
90 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
92 BPPY_REQUIRE_VALID (self_bp
);
95 if (self_bp
->bp
->enable_state
== bp_enabled
)
100 /* Python function to test whether or not the breakpoint is silent. */
102 bppy_get_silent (PyObject
*self
, void *closure
)
104 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
106 BPPY_REQUIRE_VALID (self_bp
);
107 if (self_bp
->bp
->silent
)
112 /* Python function to set the enabled state of a breakpoint. */
114 bppy_set_enabled (PyObject
*self
, PyObject
*newvalue
, void *closure
)
116 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
118 volatile struct gdb_exception except
;
120 BPPY_SET_REQUIRE_VALID (self_bp
);
122 if (newvalue
== NULL
)
124 PyErr_SetString (PyExc_TypeError
,
125 _("Cannot delete `enabled' attribute."));
129 else if (! PyBool_Check (newvalue
))
131 PyErr_SetString (PyExc_TypeError
,
132 _("The value of `enabled' must be a boolean."));
136 cmp
= PyObject_IsTrue (newvalue
);
140 TRY_CATCH (except
, RETURN_MASK_ALL
)
143 enable_breakpoint (self_bp
->bp
);
145 disable_breakpoint (self_bp
->bp
);
147 GDB_PY_SET_HANDLE_EXCEPTION (except
);
152 /* Python function to set the 'silent' state of a breakpoint. */
154 bppy_set_silent (PyObject
*self
, PyObject
*newvalue
, void *closure
)
156 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
159 BPPY_SET_REQUIRE_VALID (self_bp
);
161 if (newvalue
== NULL
)
163 PyErr_SetString (PyExc_TypeError
,
164 _("Cannot delete `silent' attribute."));
167 else if (! PyBool_Check (newvalue
))
169 PyErr_SetString (PyExc_TypeError
,
170 _("The value of `silent' must be a boolean."));
174 cmp
= PyObject_IsTrue (newvalue
);
178 breakpoint_set_silent (self_bp
->bp
, cmp
);
183 /* Python function to set the thread of a breakpoint. */
185 bppy_set_thread (PyObject
*self
, PyObject
*newvalue
, void *closure
)
187 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
190 BPPY_SET_REQUIRE_VALID (self_bp
);
192 if (newvalue
== NULL
)
194 PyErr_SetString (PyExc_TypeError
,
195 _("Cannot delete `thread' attribute."));
198 else if (PyInt_Check (newvalue
))
200 if (! gdb_py_int_as_long (newvalue
, &id
))
203 if (! valid_thread_id (id
))
205 PyErr_SetString (PyExc_RuntimeError
,
206 _("Invalid thread ID."));
210 else if (newvalue
== Py_None
)
214 PyErr_SetString (PyExc_TypeError
,
215 _("The value of `thread' must be an integer or None."));
219 breakpoint_set_thread (self_bp
->bp
, id
);
224 /* Python function to set the (Ada) task of a breakpoint. */
226 bppy_set_task (PyObject
*self
, PyObject
*newvalue
, void *closure
)
228 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
231 volatile struct gdb_exception except
;
233 BPPY_SET_REQUIRE_VALID (self_bp
);
235 if (newvalue
== NULL
)
237 PyErr_SetString (PyExc_TypeError
,
238 _("Cannot delete `task' attribute."));
241 else if (PyInt_Check (newvalue
))
243 if (! gdb_py_int_as_long (newvalue
, &id
))
246 TRY_CATCH (except
, RETURN_MASK_ALL
)
248 valid_id
= valid_task_id (id
);
250 GDB_PY_SET_HANDLE_EXCEPTION (except
);
254 PyErr_SetString (PyExc_RuntimeError
,
255 _("Invalid task ID."));
259 else if (newvalue
== Py_None
)
263 PyErr_SetString (PyExc_TypeError
,
264 _("The value of `task' must be an integer or None."));
268 breakpoint_set_task (self_bp
->bp
, id
);
273 /* Python function which deletes the underlying GDB breakpoint. This
274 triggers the breakpoint_deleted observer which will call
275 gdbpy_breakpoint_deleted; that function cleans up the Python
279 bppy_delete_breakpoint (PyObject
*self
, PyObject
*args
)
281 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
282 volatile struct gdb_exception except
;
284 BPPY_REQUIRE_VALID (self_bp
);
286 TRY_CATCH (except
, RETURN_MASK_ALL
)
288 delete_breakpoint (self_bp
->bp
);
290 GDB_PY_HANDLE_EXCEPTION (except
);
296 /* Python function to set the ignore count of a breakpoint. */
298 bppy_set_ignore_count (PyObject
*self
, PyObject
*newvalue
, void *closure
)
300 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
302 volatile struct gdb_exception except
;
304 BPPY_SET_REQUIRE_VALID (self_bp
);
306 if (newvalue
== NULL
)
308 PyErr_SetString (PyExc_TypeError
,
309 _("Cannot delete `ignore_count' attribute."));
312 else if (! PyInt_Check (newvalue
))
314 PyErr_SetString (PyExc_TypeError
,
315 _("The value of `ignore_count' must be an integer."));
319 if (! gdb_py_int_as_long (newvalue
, &value
))
325 TRY_CATCH (except
, RETURN_MASK_ALL
)
327 set_ignore_count (self_bp
->number
, (int) value
, 0);
329 GDB_PY_SET_HANDLE_EXCEPTION (except
);
334 /* Python function to set the hit count of a breakpoint. */
336 bppy_set_hit_count (PyObject
*self
, PyObject
*newvalue
, void *closure
)
338 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
340 BPPY_SET_REQUIRE_VALID (self_bp
);
342 if (newvalue
== NULL
)
344 PyErr_SetString (PyExc_TypeError
,
345 _("Cannot delete `hit_count' attribute."));
352 if (! gdb_py_int_as_long (newvalue
, &value
))
357 PyErr_SetString (PyExc_AttributeError
,
358 _("The value of `hit_count' must be zero."));
363 self_bp
->bp
->hit_count
= 0;
368 /* Python function to get the location of a breakpoint. */
370 bppy_get_location (PyObject
*self
, void *closure
)
373 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
375 BPPY_REQUIRE_VALID (obj
);
377 if (obj
->bp
->type
!= bp_breakpoint
)
380 str
= obj
->bp
->addr_string
;
384 return PyString_Decode (str
, strlen (str
), host_charset (), NULL
);
387 /* Python function to get the breakpoint expression. */
389 bppy_get_expression (PyObject
*self
, void *closure
)
392 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
393 struct watchpoint
*wp
;
395 BPPY_REQUIRE_VALID (obj
);
397 if (!is_watchpoint (obj
->bp
))
400 wp
= (struct watchpoint
*) obj
->bp
;
402 str
= wp
->exp_string
;
406 return PyString_Decode (str
, strlen (str
), host_charset (), NULL
);
409 /* Python function to get the condition expression of a breakpoint. */
411 bppy_get_condition (PyObject
*self
, void *closure
)
414 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
416 BPPY_REQUIRE_VALID (obj
);
418 str
= obj
->bp
->cond_string
;
422 return PyString_Decode (str
, strlen (str
), host_charset (), NULL
);
425 /* Returns 0 on success. Returns -1 on error, with a python exception set.
429 bppy_set_condition (PyObject
*self
, PyObject
*newvalue
, void *closure
)
432 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
433 volatile struct gdb_exception except
;
435 BPPY_SET_REQUIRE_VALID (self_bp
);
437 if (newvalue
== NULL
)
439 PyErr_SetString (PyExc_TypeError
,
440 _("Cannot delete `condition' attribute."));
443 else if (newvalue
== Py_None
)
447 exp
= python_string_to_host_string (newvalue
);
452 TRY_CATCH (except
, RETURN_MASK_ALL
)
454 set_breakpoint_condition (self_bp
->bp
, exp
, 0);
457 if (newvalue
!= Py_None
)
460 GDB_PY_SET_HANDLE_EXCEPTION (except
);
465 /* Python function to get the commands attached to a breakpoint. */
467 bppy_get_commands (PyObject
*self
, void *closure
)
469 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
470 struct breakpoint
*bp
= self_bp
->bp
;
472 volatile struct gdb_exception except
;
473 struct ui_file
*string_file
;
474 struct cleanup
*chain
;
478 BPPY_REQUIRE_VALID (self_bp
);
480 if (! self_bp
->bp
->commands
)
483 string_file
= mem_fileopen ();
484 chain
= make_cleanup_ui_file_delete (string_file
);
486 ui_out_redirect (current_uiout
, string_file
);
487 TRY_CATCH (except
, RETURN_MASK_ALL
)
489 print_command_lines (current_uiout
, breakpoint_commands (bp
), 0);
491 ui_out_redirect (current_uiout
, NULL
);
492 if (except
.reason
< 0)
495 gdbpy_convert_exception (except
);
499 cmdstr
= ui_file_xstrdup (string_file
, &length
);
500 make_cleanup (xfree
, cmdstr
);
501 result
= PyString_Decode (cmdstr
, strlen (cmdstr
), host_charset (), NULL
);
506 /* Python function to get the breakpoint type. */
508 bppy_get_type (PyObject
*self
, void *closure
)
510 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
512 BPPY_REQUIRE_VALID (self_bp
);
514 return PyInt_FromLong (self_bp
->bp
->type
);
517 /* Python function to get the visibility of the breakpoint. */
520 bppy_get_visibility (PyObject
*self
, void *closure
)
522 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
524 BPPY_REQUIRE_VALID (self_bp
);
526 if (self_bp
->bp
->number
< 0)
532 /* Python function to determine if the breakpoint is a temporary
536 bppy_get_temporary (PyObject
*self
, void *closure
)
538 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
540 BPPY_REQUIRE_VALID (self_bp
);
542 if (self_bp
->bp
->disposition
== disp_del
543 || self_bp
->bp
->disposition
== disp_del_at_next_stop
)
549 /* Python function to get the breakpoint's number. */
551 bppy_get_number (PyObject
*self
, void *closure
)
553 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
555 BPPY_REQUIRE_VALID (self_bp
);
557 return PyInt_FromLong (self_bp
->number
);
560 /* Python function to get the breakpoint's thread ID. */
562 bppy_get_thread (PyObject
*self
, void *closure
)
564 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
566 BPPY_REQUIRE_VALID (self_bp
);
568 if (self_bp
->bp
->thread
== -1)
571 return PyInt_FromLong (self_bp
->bp
->thread
);
574 /* Python function to get the breakpoint's task ID (in Ada). */
576 bppy_get_task (PyObject
*self
, void *closure
)
578 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
580 BPPY_REQUIRE_VALID (self_bp
);
582 if (self_bp
->bp
->task
== 0)
585 return PyInt_FromLong (self_bp
->bp
->task
);
588 /* Python function to get the breakpoint's hit count. */
590 bppy_get_hit_count (PyObject
*self
, void *closure
)
592 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
594 BPPY_REQUIRE_VALID (self_bp
);
596 return PyInt_FromLong (self_bp
->bp
->hit_count
);
599 /* Python function to get the breakpoint's ignore count. */
601 bppy_get_ignore_count (PyObject
*self
, void *closure
)
603 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
605 BPPY_REQUIRE_VALID (self_bp
);
607 return PyInt_FromLong (self_bp
->bp
->ignore_count
);
610 /* Python function to create a new breakpoint. */
612 bppy_init (PyObject
*self
, PyObject
*args
, PyObject
*kwargs
)
614 static char *keywords
[] = { "spec", "type", "wp_class", "internal",
617 int type
= bp_breakpoint
;
618 int access_type
= hw_write
;
619 PyObject
*internal
= NULL
;
620 PyObject
*temporary
= NULL
;
622 int temporary_bp
= 0;
623 volatile struct gdb_exception except
;
625 if (! PyArg_ParseTupleAndKeywords (args
, kwargs
, "s|iiOO", keywords
,
626 &spec
, &type
, &access_type
,
627 &internal
, &temporary
))
632 internal_bp
= PyObject_IsTrue (internal
);
633 if (internal_bp
== -1)
637 if (temporary
!= NULL
)
639 temporary_bp
= PyObject_IsTrue (temporary
);
640 if (temporary_bp
== -1)
644 bppy_pending_object
= (gdbpy_breakpoint_object
*) self
;
645 bppy_pending_object
->number
= -1;
646 bppy_pending_object
->bp
= NULL
;
648 TRY_CATCH (except
, RETURN_MASK_ALL
)
650 char *copy
= xstrdup (spec
);
651 struct cleanup
*cleanup
= make_cleanup (xfree
, copy
);
657 create_breakpoint (python_gdbarch
,
658 copy
, NULL
, -1, NULL
,
660 temporary_bp
, bp_breakpoint
,
663 &bkpt_breakpoint_ops
,
664 0, 1, internal_bp
, 0);
669 if (access_type
== hw_write
)
670 watch_command_wrapper (copy
, 0, internal_bp
);
671 else if (access_type
== hw_access
)
672 awatch_command_wrapper (copy
, 0, internal_bp
);
673 else if (access_type
== hw_read
)
674 rwatch_command_wrapper (copy
, 0, internal_bp
);
676 error(_("Cannot understand watchpoint access type."));
680 error(_("Do not understand breakpoint type to set."));
683 do_cleanups (cleanup
);
685 if (except
.reason
< 0)
687 PyErr_Format (except
.reason
== RETURN_QUIT
688 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
689 "%s", except
.message
);
693 BPPY_SET_REQUIRE_VALID ((gdbpy_breakpoint_object
*) self
);
700 build_bp_list (struct breakpoint
*b
, void *arg
)
702 PyObject
*list
= arg
;
703 PyObject
*bp
= (PyObject
*) b
->py_bp_object
;
706 /* Not all breakpoints will have a companion Python object.
707 Only breakpoints that were created via bppy_new, or
708 breakpoints that were created externally and are tracked by
709 the Python Scripting API. */
711 iserr
= PyList_Append (list
, bp
);
719 /* Static function to return a tuple holding all breakpoints. */
722 gdbpy_breakpoints (PyObject
*self
, PyObject
*args
)
724 PyObject
*list
, *tuple
;
729 list
= PyList_New (0);
733 /* If iteratre_over_breakpoints returns non NULL it signals an error
734 condition. In that case abandon building the list and return
736 if (iterate_over_breakpoints (build_bp_list
, list
) != NULL
)
742 tuple
= PyList_AsTuple (list
);
748 /* Call the "stop" method (if implemented) in the breakpoint
749 class. If the method returns True, the inferior will be
750 stopped at the breakpoint. Otherwise the inferior will be
751 allowed to continue. */
754 gdbpy_should_stop (struct gdbpy_breakpoint_object
*bp_obj
)
758 PyObject
*py_bp
= (PyObject
*) bp_obj
;
759 struct breakpoint
*b
= bp_obj
->bp
;
760 struct gdbarch
*garch
= b
->gdbarch
? b
->gdbarch
: get_current_arch ();
761 struct cleanup
*cleanup
= ensure_python_env (garch
, current_language
);
763 if (bp_obj
->is_finish_bp
)
764 bpfinishpy_pre_stop_hook (bp_obj
);
766 if (PyObject_HasAttrString (py_bp
, stop_func
))
768 PyObject
*result
= PyObject_CallMethod (py_bp
, stop_func
, NULL
);
772 int evaluate
= PyObject_IsTrue (result
);
775 gdbpy_print_stack ();
777 /* If the "stop" function returns False that means
778 the Python breakpoint wants GDB to continue. */
785 gdbpy_print_stack ();
788 if (bp_obj
->is_finish_bp
)
789 bpfinishpy_post_stop_hook (bp_obj
);
791 do_cleanups (cleanup
);
796 /* Checks if the "stop" method exists in this breakpoint.
797 Used by condition_command to ensure mutual exclusion of breakpoint
801 gdbpy_breakpoint_has_py_cond (struct gdbpy_breakpoint_object
*bp_obj
)
804 PyObject
*py_bp
= (PyObject
*) bp_obj
;
805 struct gdbarch
*garch
= bp_obj
->bp
->gdbarch
? bp_obj
->bp
->gdbarch
:
807 struct cleanup
*cleanup
= ensure_python_env (garch
, current_language
);
810 has_func
= PyObject_HasAttrString (py_bp
, stop_func
);
812 do_cleanups (cleanup
);
819 /* Event callback functions. */
821 /* Callback that is used when a breakpoint is created. This function
822 will create a new Python breakpoint object. */
824 gdbpy_breakpoint_created (struct breakpoint
*bp
)
826 gdbpy_breakpoint_object
*newbp
;
827 PyGILState_STATE state
;
829 if (bp
->number
< 0 && bppy_pending_object
== NULL
)
832 if (bp
->type
!= bp_breakpoint
833 && bp
->type
!= bp_watchpoint
834 && bp
->type
!= bp_hardware_watchpoint
835 && bp
->type
!= bp_read_watchpoint
836 && bp
->type
!= bp_access_watchpoint
)
839 state
= PyGILState_Ensure ();
841 if (bppy_pending_object
)
843 newbp
= bppy_pending_object
;
844 bppy_pending_object
= NULL
;
847 newbp
= PyObject_New (gdbpy_breakpoint_object
, &breakpoint_object_type
);
850 newbp
->number
= bp
->number
;
852 newbp
->bp
->py_bp_object
= newbp
;
853 newbp
->is_finish_bp
= 0;
859 PyErr_SetString (PyExc_RuntimeError
,
860 _("Error while creating breakpoint from GDB."));
861 gdbpy_print_stack ();
864 PyGILState_Release (state
);
867 /* Callback that is used when a breakpoint is deleted. This will
868 invalidate the corresponding Python object. */
870 gdbpy_breakpoint_deleted (struct breakpoint
*b
)
873 PyGILState_STATE state
;
874 struct breakpoint
*bp
= NULL
;
875 gdbpy_breakpoint_object
*bp_obj
;
877 state
= PyGILState_Ensure ();
878 bp
= get_breakpoint (num
);
881 bp_obj
= bp
->py_bp_object
;
889 PyGILState_Release (state
);
894 /* Initialize the Python breakpoint code. */
896 gdbpy_initialize_breakpoints (void)
900 breakpoint_object_type
.tp_new
= PyType_GenericNew
;
901 if (PyType_Ready (&breakpoint_object_type
) < 0)
904 if (gdb_pymodule_addobject (gdb_module
, "Breakpoint",
905 (PyObject
*) &breakpoint_object_type
) < 0)
908 observer_attach_breakpoint_created (gdbpy_breakpoint_created
);
909 observer_attach_breakpoint_deleted (gdbpy_breakpoint_deleted
);
911 /* Add breakpoint types constants. */
912 for (i
= 0; pybp_codes
[i
].name
; ++i
)
914 if (PyModule_AddIntConstant (gdb_module
,
915 /* Cast needed for Python 2.4. */
916 (char *) pybp_codes
[i
].name
,
917 pybp_codes
[i
].code
) < 0)
921 /* Add watchpoint types constants. */
922 for (i
= 0; pybp_watch_types
[i
].name
; ++i
)
924 if (PyModule_AddIntConstant (gdb_module
,
925 /* Cast needed for Python 2.4. */
926 (char *) pybp_watch_types
[i
].name
,
927 pybp_watch_types
[i
].code
) < 0)
936 /* Helper function that overrides this Python object's
937 PyObject_GenericSetAttr to allow extra validation of the attribute
941 local_setattro (PyObject
*self
, PyObject
*name
, PyObject
*v
)
943 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
944 char *attr
= python_string_to_host_string (name
);
949 /* If the attribute trying to be set is the "stop" method,
950 but we already have a condition set in the CLI, disallow this
952 if (strcmp (attr
, stop_func
) == 0 && obj
->bp
->cond_string
)
955 PyErr_SetString (PyExc_RuntimeError
,
956 _("Cannot set 'stop' method. There is an " \
957 "existing GDB condition attached to the " \
964 return PyObject_GenericSetAttr ((PyObject
*)self
, name
, v
);
967 static PyGetSetDef breakpoint_object_getset
[] = {
968 { "enabled", bppy_get_enabled
, bppy_set_enabled
,
969 "Boolean telling whether the breakpoint is enabled.", NULL
},
970 { "silent", bppy_get_silent
, bppy_set_silent
,
971 "Boolean telling whether the breakpoint is silent.", NULL
},
972 { "thread", bppy_get_thread
, bppy_set_thread
,
973 "Thread ID for the breakpoint.\n\
974 If the value is a thread ID (integer), then this is a thread-specific breakpoint.\n\
975 If the value is None, then this breakpoint is not thread-specific.\n\
976 No other type of value can be used.", NULL
},
977 { "task", bppy_get_task
, bppy_set_task
,
978 "Thread ID for the breakpoint.\n\
979 If the value is a task ID (integer), then this is an Ada task-specific breakpoint.\n\
980 If the value is None, then this breakpoint is not task-specific.\n\
981 No other type of value can be used.", NULL
},
982 { "ignore_count", bppy_get_ignore_count
, bppy_set_ignore_count
,
983 "Number of times this breakpoint should be automatically continued.",
985 { "number", bppy_get_number
, NULL
,
986 "Breakpoint's number assigned by GDB.", NULL
},
987 { "hit_count", bppy_get_hit_count
, bppy_set_hit_count
,
988 "Number of times the breakpoint has been hit.\n\
989 Can be set to zero to clear the count. No other value is valid\n\
990 when setting this property.", NULL
},
991 { "location", bppy_get_location
, NULL
,
992 "Location of the breakpoint, as specified by the user.", NULL
},
993 { "expression", bppy_get_expression
, NULL
,
994 "Expression of the breakpoint, as specified by the user.", NULL
},
995 { "condition", bppy_get_condition
, bppy_set_condition
,
996 "Condition of the breakpoint, as specified by the user,\
997 or None if no condition set."},
998 { "commands", bppy_get_commands
, NULL
,
999 "Commands of the breakpoint, as specified by the user."},
1000 { "type", bppy_get_type
, NULL
,
1001 "Type of breakpoint."},
1002 { "visible", bppy_get_visibility
, NULL
,
1003 "Whether the breakpoint is visible to the user."},
1004 { "temporary", bppy_get_temporary
, NULL
,
1005 "Whether this breakpoint is a temporary breakpoint."},
1006 { NULL
} /* Sentinel. */
1009 static PyMethodDef breakpoint_object_methods
[] =
1011 { "is_valid", bppy_is_valid
, METH_NOARGS
,
1012 "Return true if this breakpoint is valid, false if not." },
1013 { "delete", bppy_delete_breakpoint
, METH_NOARGS
,
1014 "Delete the underlying GDB breakpoint." },
1015 { NULL
} /* Sentinel. */
1018 PyTypeObject breakpoint_object_type
=
1020 PyVarObject_HEAD_INIT (NULL
, 0)
1021 "gdb.Breakpoint", /*tp_name*/
1022 sizeof (gdbpy_breakpoint_object
), /*tp_basicsize*/
1031 0, /*tp_as_sequence*/
1032 0, /*tp_as_mapping*/
1037 (setattrofunc
)local_setattro
, /*tp_setattro */
1039 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1040 "GDB breakpoint object", /* tp_doc */
1041 0, /* tp_traverse */
1043 0, /* tp_richcompare */
1044 0, /* tp_weaklistoffset */
1046 0, /* tp_iternext */
1047 breakpoint_object_methods
, /* tp_methods */
1049 breakpoint_object_getset
, /* tp_getset */
1052 0, /* tp_descr_get */
1053 0, /* tp_descr_set */
1054 0, /* tp_dictoffset */
1055 bppy_init
, /* tp_init */