1 /* Python interface to breakpoints
3 Copyright (C) 2008-2016 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 "python-internal.h"
25 #include "breakpoint.h"
27 #include "gdbthread.h"
29 #include "cli/cli-script.h"
31 #include "arch-utils.h"
36 /* Number of live breakpoints. */
39 /* Variables used to pass information between the Breakpoint
40 constructor and the breakpoint-created hook function. */
41 gdbpy_breakpoint_object
*bppy_pending_object
;
43 /* Function that is called when a Python condition is evaluated. */
44 static char * const stop_func
= "stop";
46 /* This is used to initialize various gdb.bp_* constants. */
55 /* Entries related to the type of user set breakpoints. */
56 static struct pybp_code pybp_codes
[] =
58 { "BP_NONE", bp_none
},
59 { "BP_BREAKPOINT", bp_breakpoint
},
60 { "BP_WATCHPOINT", bp_watchpoint
},
61 { "BP_HARDWARE_WATCHPOINT", bp_hardware_watchpoint
},
62 { "BP_READ_WATCHPOINT", bp_read_watchpoint
},
63 { "BP_ACCESS_WATCHPOINT", bp_access_watchpoint
},
64 {NULL
} /* Sentinel. */
67 /* Entries related to the type of watchpoint. */
68 static struct pybp_code pybp_watch_types
[] =
70 { "WP_READ", hw_read
},
71 { "WP_WRITE", hw_write
},
72 { "WP_ACCESS", hw_access
},
73 {NULL
} /* Sentinel. */
76 /* Python function which checks the validity of a breakpoint object. */
78 bppy_is_valid (PyObject
*self
, PyObject
*args
)
80 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
87 /* Python function to test whether or not the breakpoint is enabled. */
89 bppy_get_enabled (PyObject
*self
, void *closure
)
91 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
93 BPPY_REQUIRE_VALID (self_bp
);
96 if (self_bp
->bp
->enable_state
== bp_enabled
)
101 /* Python function to test whether or not the breakpoint is silent. */
103 bppy_get_silent (PyObject
*self
, void *closure
)
105 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
107 BPPY_REQUIRE_VALID (self_bp
);
108 if (self_bp
->bp
->silent
)
113 /* Python function to set the enabled state of a breakpoint. */
115 bppy_set_enabled (PyObject
*self
, PyObject
*newvalue
, void *closure
)
117 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
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
);
143 enable_breakpoint (self_bp
->bp
);
145 disable_breakpoint (self_bp
->bp
);
147 CATCH (except
, RETURN_MASK_ALL
)
149 GDB_PY_SET_HANDLE_EXCEPTION (except
);
156 /* Python function to set the 'silent' state of a breakpoint. */
158 bppy_set_silent (PyObject
*self
, PyObject
*newvalue
, void *closure
)
160 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
163 BPPY_SET_REQUIRE_VALID (self_bp
);
165 if (newvalue
== NULL
)
167 PyErr_SetString (PyExc_TypeError
,
168 _("Cannot delete `silent' attribute."));
171 else if (! PyBool_Check (newvalue
))
173 PyErr_SetString (PyExc_TypeError
,
174 _("The value of `silent' must be a boolean."));
178 cmp
= PyObject_IsTrue (newvalue
);
182 breakpoint_set_silent (self_bp
->bp
, cmp
);
187 /* Python function to set the thread of a breakpoint. */
189 bppy_set_thread (PyObject
*self
, PyObject
*newvalue
, void *closure
)
191 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
194 BPPY_SET_REQUIRE_VALID (self_bp
);
196 if (newvalue
== NULL
)
198 PyErr_SetString (PyExc_TypeError
,
199 _("Cannot delete `thread' attribute."));
202 else if (PyInt_Check (newvalue
))
204 if (! gdb_py_int_as_long (newvalue
, &id
))
207 if (!valid_global_thread_id (id
))
209 PyErr_SetString (PyExc_RuntimeError
,
210 _("Invalid thread ID."));
214 else if (newvalue
== Py_None
)
218 PyErr_SetString (PyExc_TypeError
,
219 _("The value of `thread' must be an integer or None."));
223 breakpoint_set_thread (self_bp
->bp
, id
);
228 /* Python function to set the (Ada) task of a breakpoint. */
230 bppy_set_task (PyObject
*self
, PyObject
*newvalue
, void *closure
)
232 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
236 BPPY_SET_REQUIRE_VALID (self_bp
);
238 if (newvalue
== NULL
)
240 PyErr_SetString (PyExc_TypeError
,
241 _("Cannot delete `task' attribute."));
244 else if (PyInt_Check (newvalue
))
246 if (! gdb_py_int_as_long (newvalue
, &id
))
251 valid_id
= valid_task_id (id
);
253 CATCH (except
, RETURN_MASK_ALL
)
255 GDB_PY_SET_HANDLE_EXCEPTION (except
);
261 PyErr_SetString (PyExc_RuntimeError
,
262 _("Invalid task ID."));
266 else if (newvalue
== Py_None
)
270 PyErr_SetString (PyExc_TypeError
,
271 _("The value of `task' must be an integer or None."));
275 breakpoint_set_task (self_bp
->bp
, id
);
280 /* Python function which deletes the underlying GDB breakpoint. This
281 triggers the breakpoint_deleted observer which will call
282 gdbpy_breakpoint_deleted; that function cleans up the Python
286 bppy_delete_breakpoint (PyObject
*self
, PyObject
*args
)
288 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
290 BPPY_REQUIRE_VALID (self_bp
);
294 delete_breakpoint (self_bp
->bp
);
296 CATCH (except
, RETURN_MASK_ALL
)
298 GDB_PY_HANDLE_EXCEPTION (except
);
306 /* Python function to set the ignore count of a breakpoint. */
308 bppy_set_ignore_count (PyObject
*self
, PyObject
*newvalue
, void *closure
)
310 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
313 BPPY_SET_REQUIRE_VALID (self_bp
);
315 if (newvalue
== NULL
)
317 PyErr_SetString (PyExc_TypeError
,
318 _("Cannot delete `ignore_count' attribute."));
321 else if (! PyInt_Check (newvalue
))
323 PyErr_SetString (PyExc_TypeError
,
324 _("The value of `ignore_count' must be an integer."));
328 if (! gdb_py_int_as_long (newvalue
, &value
))
336 set_ignore_count (self_bp
->number
, (int) value
, 0);
338 CATCH (except
, RETURN_MASK_ALL
)
340 GDB_PY_SET_HANDLE_EXCEPTION (except
);
347 /* Python function to set the hit count of a breakpoint. */
349 bppy_set_hit_count (PyObject
*self
, PyObject
*newvalue
, void *closure
)
351 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
353 BPPY_SET_REQUIRE_VALID (self_bp
);
355 if (newvalue
== NULL
)
357 PyErr_SetString (PyExc_TypeError
,
358 _("Cannot delete `hit_count' attribute."));
365 if (! gdb_py_int_as_long (newvalue
, &value
))
370 PyErr_SetString (PyExc_AttributeError
,
371 _("The value of `hit_count' must be zero."));
376 self_bp
->bp
->hit_count
= 0;
381 /* Python function to get the location of a breakpoint. */
383 bppy_get_location (PyObject
*self
, void *closure
)
386 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
388 BPPY_REQUIRE_VALID (obj
);
390 if (obj
->bp
->type
!= bp_breakpoint
)
393 str
= event_location_to_string (obj
->bp
->location
);
396 return host_string_to_python_string (str
);
399 /* Python function to get the breakpoint expression. */
401 bppy_get_expression (PyObject
*self
, void *closure
)
404 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
405 struct watchpoint
*wp
;
407 BPPY_REQUIRE_VALID (obj
);
409 if (!is_watchpoint (obj
->bp
))
412 wp
= (struct watchpoint
*) obj
->bp
;
414 str
= wp
->exp_string
;
418 return host_string_to_python_string (str
);
421 /* Python function to get the condition expression of a breakpoint. */
423 bppy_get_condition (PyObject
*self
, void *closure
)
426 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
428 BPPY_REQUIRE_VALID (obj
);
430 str
= obj
->bp
->cond_string
;
434 return host_string_to_python_string (str
);
437 /* Returns 0 on success. Returns -1 on error, with a python exception set.
441 bppy_set_condition (PyObject
*self
, PyObject
*newvalue
, void *closure
)
444 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
445 struct gdb_exception except
= exception_none
;
447 BPPY_SET_REQUIRE_VALID (self_bp
);
449 if (newvalue
== NULL
)
451 PyErr_SetString (PyExc_TypeError
,
452 _("Cannot delete `condition' attribute."));
455 else if (newvalue
== Py_None
)
459 exp
= python_string_to_host_string (newvalue
);
466 set_breakpoint_condition (self_bp
->bp
, exp
, 0);
468 CATCH (ex
, RETURN_MASK_ALL
)
474 if (newvalue
!= Py_None
)
477 GDB_PY_SET_HANDLE_EXCEPTION (except
);
482 /* Python function to get the commands attached to a breakpoint. */
484 bppy_get_commands (PyObject
*self
, void *closure
)
486 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
487 struct breakpoint
*bp
= self_bp
->bp
;
489 struct ui_file
*string_file
;
491 struct cleanup
*chain
;
493 BPPY_REQUIRE_VALID (self_bp
);
495 if (! self_bp
->bp
->commands
)
498 string_file
= mem_fileopen ();
499 chain
= make_cleanup_ui_file_delete (string_file
);
501 ui_out_redirect (current_uiout
, string_file
);
504 print_command_lines (current_uiout
, breakpoint_commands (bp
), 0);
506 CATCH (except
, RETURN_MASK_ALL
)
508 ui_out_redirect (current_uiout
, NULL
);
510 gdbpy_convert_exception (except
);
515 ui_out_redirect (current_uiout
, NULL
);
516 std::string cmdstr
= ui_file_as_string (string_file
);
517 result
= host_string_to_python_string (cmdstr
.c_str ());
522 /* Python function to get the breakpoint type. */
524 bppy_get_type (PyObject
*self
, void *closure
)
526 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
528 BPPY_REQUIRE_VALID (self_bp
);
530 return PyInt_FromLong (self_bp
->bp
->type
);
533 /* Python function to get the visibility of the breakpoint. */
536 bppy_get_visibility (PyObject
*self
, void *closure
)
538 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
540 BPPY_REQUIRE_VALID (self_bp
);
542 if (user_breakpoint_p (self_bp
->bp
))
548 /* Python function to determine if the breakpoint is a temporary
552 bppy_get_temporary (PyObject
*self
, void *closure
)
554 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
556 BPPY_REQUIRE_VALID (self_bp
);
558 if (self_bp
->bp
->disposition
== disp_del
559 || self_bp
->bp
->disposition
== disp_del_at_next_stop
)
565 /* Python function to determine if the breakpoint is a pending
569 bppy_get_pending (PyObject
*self
, void *closure
)
571 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
573 BPPY_REQUIRE_VALID (self_bp
);
575 if (is_watchpoint (self_bp
->bp
))
577 if (pending_breakpoint_p (self_bp
->bp
))
583 /* Python function to get the breakpoint's number. */
585 bppy_get_number (PyObject
*self
, void *closure
)
587 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
589 BPPY_REQUIRE_VALID (self_bp
);
591 return PyInt_FromLong (self_bp
->number
);
594 /* Python function to get the breakpoint's thread ID. */
596 bppy_get_thread (PyObject
*self
, void *closure
)
598 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
600 BPPY_REQUIRE_VALID (self_bp
);
602 if (self_bp
->bp
->thread
== -1)
605 return PyInt_FromLong (self_bp
->bp
->thread
);
608 /* Python function to get the breakpoint's task ID (in Ada). */
610 bppy_get_task (PyObject
*self
, void *closure
)
612 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
614 BPPY_REQUIRE_VALID (self_bp
);
616 if (self_bp
->bp
->task
== 0)
619 return PyInt_FromLong (self_bp
->bp
->task
);
622 /* Python function to get the breakpoint's hit count. */
624 bppy_get_hit_count (PyObject
*self
, void *closure
)
626 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
628 BPPY_REQUIRE_VALID (self_bp
);
630 return PyInt_FromLong (self_bp
->bp
->hit_count
);
633 /* Python function to get the breakpoint's ignore count. */
635 bppy_get_ignore_count (PyObject
*self
, void *closure
)
637 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
639 BPPY_REQUIRE_VALID (self_bp
);
641 return PyInt_FromLong (self_bp
->bp
->ignore_count
);
644 /* Python function to create a new breakpoint. */
646 bppy_init (PyObject
*self
, PyObject
*args
, PyObject
*kwargs
)
648 static char *keywords
[] = { "spec", "type", "wp_class", "internal",
651 int type
= bp_breakpoint
;
652 int access_type
= hw_write
;
653 PyObject
*internal
= NULL
;
654 PyObject
*temporary
= NULL
;
656 int temporary_bp
= 0;
658 if (! PyArg_ParseTupleAndKeywords (args
, kwargs
, "s|iiOO", keywords
,
659 &spec
, &type
, &access_type
,
660 &internal
, &temporary
))
665 internal_bp
= PyObject_IsTrue (internal
);
666 if (internal_bp
== -1)
670 if (temporary
!= NULL
)
672 temporary_bp
= PyObject_IsTrue (temporary
);
673 if (temporary_bp
== -1)
677 bppy_pending_object
= (gdbpy_breakpoint_object
*) self
;
678 bppy_pending_object
->number
= -1;
679 bppy_pending_object
->bp
= NULL
;
683 char *copy
= xstrdup (skip_spaces_const (spec
));
684 struct cleanup
*cleanup
= make_cleanup (xfree
, copy
);
690 struct event_location
*location
;
693 = string_to_event_location_basic (©
, current_language
);
694 make_cleanup_delete_event_location (location
);
695 create_breakpoint (python_gdbarch
,
696 location
, NULL
, -1, NULL
,
698 temporary_bp
, bp_breakpoint
,
701 &bkpt_breakpoint_ops
,
702 0, 1, internal_bp
, 0);
707 if (access_type
== hw_write
)
708 watch_command_wrapper (copy
, 0, internal_bp
);
709 else if (access_type
== hw_access
)
710 awatch_command_wrapper (copy
, 0, internal_bp
);
711 else if (access_type
== hw_read
)
712 rwatch_command_wrapper (copy
, 0, internal_bp
);
714 error(_("Cannot understand watchpoint access type."));
718 error(_("Do not understand breakpoint type to set."));
721 do_cleanups (cleanup
);
723 CATCH (except
, RETURN_MASK_ALL
)
725 bppy_pending_object
= NULL
;
726 PyErr_Format (except
.reason
== RETURN_QUIT
727 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
728 "%s", except
.message
);
733 BPPY_SET_REQUIRE_VALID ((gdbpy_breakpoint_object
*) self
);
740 build_bp_list (struct breakpoint
*b
, void *arg
)
742 PyObject
*list
= (PyObject
*) arg
;
743 PyObject
*bp
= (PyObject
*) b
->py_bp_object
;
746 /* Not all breakpoints will have a companion Python object.
747 Only breakpoints that were created via bppy_new, or
748 breakpoints that were created externally and are tracked by
749 the Python Scripting API. */
751 iserr
= PyList_Append (list
, bp
);
759 /* Static function to return a tuple holding all breakpoints. */
762 gdbpy_breakpoints (PyObject
*self
, PyObject
*args
)
764 PyObject
*list
, *tuple
;
767 return PyTuple_New (0);
769 list
= PyList_New (0);
773 /* If iterate_over_breakpoints returns non NULL it signals an error
774 condition. In that case abandon building the list and return
776 if (iterate_over_breakpoints (build_bp_list
, list
) != NULL
)
782 tuple
= PyList_AsTuple (list
);
788 /* Call the "stop" method (if implemented) in the breakpoint
789 class. If the method returns True, the inferior will be
790 stopped at the breakpoint. Otherwise the inferior will be
791 allowed to continue. */
793 enum ext_lang_bp_stop
794 gdbpy_breakpoint_cond_says_stop (const struct extension_language_defn
*extlang
,
795 struct breakpoint
*b
)
798 struct gdbpy_breakpoint_object
*bp_obj
= b
->py_bp_object
;
799 PyObject
*py_bp
= (PyObject
*) bp_obj
;
800 struct gdbarch
*garch
;
801 struct cleanup
*cleanup
;
804 return EXT_LANG_BP_STOP_UNSET
;
807 garch
= b
->gdbarch
? b
->gdbarch
: get_current_arch ();
808 cleanup
= ensure_python_env (garch
, current_language
);
810 if (bp_obj
->is_finish_bp
)
811 bpfinishpy_pre_stop_hook (bp_obj
);
813 if (PyObject_HasAttrString (py_bp
, stop_func
))
815 PyObject
*result
= PyObject_CallMethod (py_bp
, stop_func
, NULL
);
820 int evaluate
= PyObject_IsTrue (result
);
823 gdbpy_print_stack ();
825 /* If the "stop" function returns False that means
826 the Python breakpoint wants GDB to continue. */
833 gdbpy_print_stack ();
836 if (bp_obj
->is_finish_bp
)
837 bpfinishpy_post_stop_hook (bp_obj
);
839 do_cleanups (cleanup
);
842 return EXT_LANG_BP_STOP_UNSET
;
843 return stop
? EXT_LANG_BP_STOP_YES
: EXT_LANG_BP_STOP_NO
;
846 /* Checks if the "stop" method exists in this breakpoint.
847 Used by condition_command to ensure mutual exclusion of breakpoint
851 gdbpy_breakpoint_has_cond (const struct extension_language_defn
*extlang
,
852 struct breakpoint
*b
)
856 struct gdbarch
*garch
;
857 struct cleanup
*cleanup
;
859 if (b
->py_bp_object
== NULL
)
862 py_bp
= (PyObject
*) b
->py_bp_object
;
863 garch
= b
->gdbarch
? b
->gdbarch
: get_current_arch ();
864 cleanup
= ensure_python_env (garch
, current_language
);
865 has_func
= PyObject_HasAttrString (py_bp
, stop_func
);
866 do_cleanups (cleanup
);
873 /* Event callback functions. */
875 /* Callback that is used when a breakpoint is created. This function
876 will create a new Python breakpoint object. */
878 gdbpy_breakpoint_created (struct breakpoint
*bp
)
880 gdbpy_breakpoint_object
*newbp
;
881 PyGILState_STATE state
;
883 if (!user_breakpoint_p (bp
) && bppy_pending_object
== NULL
)
886 if (bp
->type
!= bp_breakpoint
887 && bp
->type
!= bp_watchpoint
888 && bp
->type
!= bp_hardware_watchpoint
889 && bp
->type
!= bp_read_watchpoint
890 && bp
->type
!= bp_access_watchpoint
)
893 state
= PyGILState_Ensure ();
895 if (bppy_pending_object
)
897 newbp
= bppy_pending_object
;
898 bppy_pending_object
= NULL
;
901 newbp
= PyObject_New (gdbpy_breakpoint_object
, &breakpoint_object_type
);
904 newbp
->number
= bp
->number
;
906 newbp
->bp
->py_bp_object
= newbp
;
907 newbp
->is_finish_bp
= 0;
913 PyErr_SetString (PyExc_RuntimeError
,
914 _("Error while creating breakpoint from GDB."));
915 gdbpy_print_stack ();
918 if (!evregpy_no_listeners_p (gdb_py_events
.breakpoint_created
))
921 if (evpy_emit_event ((PyObject
*) newbp
,
922 gdb_py_events
.breakpoint_created
) < 0)
923 gdbpy_print_stack ();
926 PyGILState_Release (state
);
929 /* Callback that is used when a breakpoint is deleted. This will
930 invalidate the corresponding Python object. */
932 gdbpy_breakpoint_deleted (struct breakpoint
*b
)
935 PyGILState_STATE state
;
936 struct breakpoint
*bp
= NULL
;
937 gdbpy_breakpoint_object
*bp_obj
;
939 state
= PyGILState_Ensure ();
940 bp
= get_breakpoint (num
);
943 bp_obj
= bp
->py_bp_object
;
946 if (!evregpy_no_listeners_p (gdb_py_events
.breakpoint_deleted
))
948 PyObject
*bp_obj_alias
= (PyObject
*) bp_obj
;
950 Py_INCREF (bp_obj_alias
);
951 if (evpy_emit_event (bp_obj_alias
,
952 gdb_py_events
.breakpoint_deleted
) < 0)
953 gdbpy_print_stack ();
961 PyGILState_Release (state
);
964 /* Callback that is used when a breakpoint is modified. */
967 gdbpy_breakpoint_modified (struct breakpoint
*b
)
970 PyGILState_STATE state
;
971 struct breakpoint
*bp
= NULL
;
972 gdbpy_breakpoint_object
*bp_obj
;
974 state
= PyGILState_Ensure ();
975 bp
= get_breakpoint (num
);
978 PyObject
*bp_obj
= (PyObject
*) bp
->py_bp_object
;
981 if (!evregpy_no_listeners_p (gdb_py_events
.breakpoint_modified
))
984 if (evpy_emit_event (bp_obj
,
985 gdb_py_events
.breakpoint_modified
) < 0)
986 gdbpy_print_stack ();
990 PyGILState_Release (state
);
995 /* Initialize the Python breakpoint code. */
997 gdbpy_initialize_breakpoints (void)
1001 breakpoint_object_type
.tp_new
= PyType_GenericNew
;
1002 if (PyType_Ready (&breakpoint_object_type
) < 0)
1005 if (gdb_pymodule_addobject (gdb_module
, "Breakpoint",
1006 (PyObject
*) &breakpoint_object_type
) < 0)
1009 observer_attach_breakpoint_created (gdbpy_breakpoint_created
);
1010 observer_attach_breakpoint_deleted (gdbpy_breakpoint_deleted
);
1011 observer_attach_breakpoint_modified (gdbpy_breakpoint_modified
);
1013 /* Add breakpoint types constants. */
1014 for (i
= 0; pybp_codes
[i
].name
; ++i
)
1016 if (PyModule_AddIntConstant (gdb_module
,
1017 /* Cast needed for Python 2.4. */
1018 (char *) pybp_codes
[i
].name
,
1019 pybp_codes
[i
].code
) < 0)
1023 /* Add watchpoint types constants. */
1024 for (i
= 0; pybp_watch_types
[i
].name
; ++i
)
1026 if (PyModule_AddIntConstant (gdb_module
,
1027 /* Cast needed for Python 2.4. */
1028 (char *) pybp_watch_types
[i
].name
,
1029 pybp_watch_types
[i
].code
) < 0)
1038 /* Helper function that overrides this Python object's
1039 PyObject_GenericSetAttr to allow extra validation of the attribute
1043 local_setattro (PyObject
*self
, PyObject
*name
, PyObject
*v
)
1045 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
1046 char *attr
= python_string_to_host_string (name
);
1051 /* If the attribute trying to be set is the "stop" method,
1052 but we already have a condition set in the CLI or other extension
1053 language, disallow this operation. */
1054 if (strcmp (attr
, stop_func
) == 0)
1056 const struct extension_language_defn
*extlang
= NULL
;
1058 if (obj
->bp
->cond_string
!= NULL
)
1059 extlang
= get_ext_lang_defn (EXT_LANG_GDB
);
1060 if (extlang
== NULL
)
1061 extlang
= get_breakpoint_cond_ext_lang (obj
->bp
, EXT_LANG_PYTHON
);
1062 if (extlang
!= NULL
)
1068 = xstrprintf (_("Only one stop condition allowed. There is"
1069 " currently a %s stop condition defined for"
1070 " this breakpoint."),
1071 ext_lang_capitalized_name (extlang
));
1072 PyErr_SetString (PyExc_RuntimeError
, error_text
);
1080 return PyObject_GenericSetAttr ((PyObject
*)self
, name
, v
);
1083 static PyGetSetDef breakpoint_object_getset
[] = {
1084 { "enabled", bppy_get_enabled
, bppy_set_enabled
,
1085 "Boolean telling whether the breakpoint is enabled.", NULL
},
1086 { "silent", bppy_get_silent
, bppy_set_silent
,
1087 "Boolean telling whether the breakpoint is silent.", NULL
},
1088 { "thread", bppy_get_thread
, bppy_set_thread
,
1089 "Thread ID for the breakpoint.\n\
1090 If the value is a thread ID (integer), then this is a thread-specific breakpoint.\n\
1091 If the value is None, then this breakpoint is not thread-specific.\n\
1092 No other type of value can be used.", NULL
},
1093 { "task", bppy_get_task
, bppy_set_task
,
1094 "Thread ID for the breakpoint.\n\
1095 If the value is a task ID (integer), then this is an Ada task-specific breakpoint.\n\
1096 If the value is None, then this breakpoint is not task-specific.\n\
1097 No other type of value can be used.", NULL
},
1098 { "ignore_count", bppy_get_ignore_count
, bppy_set_ignore_count
,
1099 "Number of times this breakpoint should be automatically continued.",
1101 { "number", bppy_get_number
, NULL
,
1102 "Breakpoint's number assigned by GDB.", NULL
},
1103 { "hit_count", bppy_get_hit_count
, bppy_set_hit_count
,
1104 "Number of times the breakpoint has been hit.\n\
1105 Can be set to zero to clear the count. No other value is valid\n\
1106 when setting this property.", NULL
},
1107 { "location", bppy_get_location
, NULL
,
1108 "Location of the breakpoint, as specified by the user.", NULL
},
1109 { "expression", bppy_get_expression
, NULL
,
1110 "Expression of the breakpoint, as specified by the user.", NULL
},
1111 { "condition", bppy_get_condition
, bppy_set_condition
,
1112 "Condition of the breakpoint, as specified by the user,\
1113 or None if no condition set."},
1114 { "commands", bppy_get_commands
, NULL
,
1115 "Commands of the breakpoint, as specified by the user."},
1116 { "type", bppy_get_type
, NULL
,
1117 "Type of breakpoint."},
1118 { "visible", bppy_get_visibility
, NULL
,
1119 "Whether the breakpoint is visible to the user."},
1120 { "temporary", bppy_get_temporary
, NULL
,
1121 "Whether this breakpoint is a temporary breakpoint."},
1122 { "pending", bppy_get_pending
, NULL
,
1123 "Whether this breakpoint is a pending breakpoint."},
1124 { NULL
} /* Sentinel. */
1127 static PyMethodDef breakpoint_object_methods
[] =
1129 { "is_valid", bppy_is_valid
, METH_NOARGS
,
1130 "Return true if this breakpoint is valid, false if not." },
1131 { "delete", bppy_delete_breakpoint
, METH_NOARGS
,
1132 "Delete the underlying GDB breakpoint." },
1133 { NULL
} /* Sentinel. */
1136 PyTypeObject breakpoint_object_type
=
1138 PyVarObject_HEAD_INIT (NULL
, 0)
1139 "gdb.Breakpoint", /*tp_name*/
1140 sizeof (gdbpy_breakpoint_object
), /*tp_basicsize*/
1149 0, /*tp_as_sequence*/
1150 0, /*tp_as_mapping*/
1155 (setattrofunc
)local_setattro
, /*tp_setattro */
1157 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1158 "GDB breakpoint object", /* tp_doc */
1159 0, /* tp_traverse */
1161 0, /* tp_richcompare */
1162 0, /* tp_weaklistoffset */
1164 0, /* tp_iternext */
1165 breakpoint_object_methods
, /* tp_methods */
1167 breakpoint_object_getset
, /* tp_getset */
1170 0, /* tp_descr_get */
1171 0, /* tp_descr_set */
1172 0, /* tp_dictoffset */
1173 bppy_init
, /* tp_init */