1 /* Python interface to breakpoints
3 Copyright (C) 2008-2017 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
)
443 gdb::unique_xmalloc_ptr
<char> exp_holder
;
444 const char *exp
= NULL
;
445 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
446 struct gdb_exception except
= exception_none
;
448 BPPY_SET_REQUIRE_VALID (self_bp
);
450 if (newvalue
== NULL
)
452 PyErr_SetString (PyExc_TypeError
,
453 _("Cannot delete `condition' attribute."));
456 else if (newvalue
== Py_None
)
460 exp_holder
= python_string_to_host_string (newvalue
);
461 if (exp_holder
== NULL
)
463 exp
= exp_holder
.get ();
468 set_breakpoint_condition (self_bp
->bp
, exp
, 0);
470 CATCH (ex
, RETURN_MASK_ALL
)
476 GDB_PY_SET_HANDLE_EXCEPTION (except
);
481 /* Python function to get the commands attached to a breakpoint. */
483 bppy_get_commands (PyObject
*self
, void *closure
)
485 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
486 struct breakpoint
*bp
= self_bp
->bp
;
490 BPPY_REQUIRE_VALID (self_bp
);
492 if (! self_bp
->bp
->commands
)
497 current_uiout
->redirect (&stb
);
500 print_command_lines (current_uiout
, breakpoint_commands (bp
), 0);
502 CATCH (except
, RETURN_MASK_ALL
)
504 current_uiout
->redirect (NULL
);
505 gdbpy_convert_exception (except
);
510 current_uiout
->redirect (NULL
);
511 return host_string_to_python_string (stb
.c_str ());
514 /* Python function to get the breakpoint type. */
516 bppy_get_type (PyObject
*self
, void *closure
)
518 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
520 BPPY_REQUIRE_VALID (self_bp
);
522 return PyInt_FromLong (self_bp
->bp
->type
);
525 /* Python function to get the visibility of the breakpoint. */
528 bppy_get_visibility (PyObject
*self
, void *closure
)
530 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
532 BPPY_REQUIRE_VALID (self_bp
);
534 if (user_breakpoint_p (self_bp
->bp
))
540 /* Python function to determine if the breakpoint is a temporary
544 bppy_get_temporary (PyObject
*self
, void *closure
)
546 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
548 BPPY_REQUIRE_VALID (self_bp
);
550 if (self_bp
->bp
->disposition
== disp_del
551 || self_bp
->bp
->disposition
== disp_del_at_next_stop
)
557 /* Python function to determine if the breakpoint is a pending
561 bppy_get_pending (PyObject
*self
, void *closure
)
563 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
565 BPPY_REQUIRE_VALID (self_bp
);
567 if (is_watchpoint (self_bp
->bp
))
569 if (pending_breakpoint_p (self_bp
->bp
))
575 /* Python function to get the breakpoint's number. */
577 bppy_get_number (PyObject
*self
, void *closure
)
579 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
581 BPPY_REQUIRE_VALID (self_bp
);
583 return PyInt_FromLong (self_bp
->number
);
586 /* Python function to get the breakpoint's thread ID. */
588 bppy_get_thread (PyObject
*self
, void *closure
)
590 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
592 BPPY_REQUIRE_VALID (self_bp
);
594 if (self_bp
->bp
->thread
== -1)
597 return PyInt_FromLong (self_bp
->bp
->thread
);
600 /* Python function to get the breakpoint's task ID (in Ada). */
602 bppy_get_task (PyObject
*self
, void *closure
)
604 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
606 BPPY_REQUIRE_VALID (self_bp
);
608 if (self_bp
->bp
->task
== 0)
611 return PyInt_FromLong (self_bp
->bp
->task
);
614 /* Python function to get the breakpoint's hit count. */
616 bppy_get_hit_count (PyObject
*self
, void *closure
)
618 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
620 BPPY_REQUIRE_VALID (self_bp
);
622 return PyInt_FromLong (self_bp
->bp
->hit_count
);
625 /* Python function to get the breakpoint's ignore count. */
627 bppy_get_ignore_count (PyObject
*self
, void *closure
)
629 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
631 BPPY_REQUIRE_VALID (self_bp
);
633 return PyInt_FromLong (self_bp
->bp
->ignore_count
);
636 /* Python function to create a new breakpoint. */
638 bppy_init (PyObject
*self
, PyObject
*args
, PyObject
*kwargs
)
640 static char *keywords
[] = { "spec", "type", "wp_class", "internal",
643 int type
= bp_breakpoint
;
644 int access_type
= hw_write
;
645 PyObject
*internal
= NULL
;
646 PyObject
*temporary
= NULL
;
648 int temporary_bp
= 0;
650 if (! PyArg_ParseTupleAndKeywords (args
, kwargs
, "s|iiOO", keywords
,
651 &spec
, &type
, &access_type
,
652 &internal
, &temporary
))
657 internal_bp
= PyObject_IsTrue (internal
);
658 if (internal_bp
== -1)
662 if (temporary
!= NULL
)
664 temporary_bp
= PyObject_IsTrue (temporary
);
665 if (temporary_bp
== -1)
669 bppy_pending_object
= (gdbpy_breakpoint_object
*) self
;
670 bppy_pending_object
->number
= -1;
671 bppy_pending_object
->bp
= NULL
;
675 gdb::unique_xmalloc_ptr
<char>
676 copy_holder (xstrdup (skip_spaces_const (spec
)));
677 char *copy
= copy_holder
.get ();
683 struct event_location
*location
;
684 struct cleanup
*cleanup
;
687 = string_to_event_location_basic (©
, current_language
);
688 cleanup
= make_cleanup_delete_event_location (location
);
689 create_breakpoint (python_gdbarch
,
690 location
, NULL
, -1, NULL
,
692 temporary_bp
, bp_breakpoint
,
695 &bkpt_breakpoint_ops
,
696 0, 1, internal_bp
, 0);
698 do_cleanups (cleanup
);
703 if (access_type
== hw_write
)
704 watch_command_wrapper (copy
, 0, internal_bp
);
705 else if (access_type
== hw_access
)
706 awatch_command_wrapper (copy
, 0, internal_bp
);
707 else if (access_type
== hw_read
)
708 rwatch_command_wrapper (copy
, 0, internal_bp
);
710 error(_("Cannot understand watchpoint access type."));
714 error(_("Do not understand breakpoint type to set."));
717 CATCH (except
, RETURN_MASK_ALL
)
719 bppy_pending_object
= NULL
;
720 PyErr_Format (except
.reason
== RETURN_QUIT
721 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
722 "%s", except
.message
);
727 BPPY_SET_REQUIRE_VALID ((gdbpy_breakpoint_object
*) self
);
734 build_bp_list (struct breakpoint
*b
, void *arg
)
736 PyObject
*list
= (PyObject
*) arg
;
737 PyObject
*bp
= (PyObject
*) b
->py_bp_object
;
740 /* Not all breakpoints will have a companion Python object.
741 Only breakpoints that were created via bppy_new, or
742 breakpoints that were created externally and are tracked by
743 the Python Scripting API. */
745 iserr
= PyList_Append (list
, bp
);
753 /* Static function to return a tuple holding all breakpoints. */
756 gdbpy_breakpoints (PyObject
*self
, PyObject
*args
)
759 return PyTuple_New (0);
761 gdbpy_ref
<> list (PyList_New (0));
765 /* If iterate_over_breakpoints returns non NULL it signals an error
766 condition. In that case abandon building the list and return
768 if (iterate_over_breakpoints (build_bp_list
, list
.get ()) != NULL
)
771 return PyList_AsTuple (list
.get ());
774 /* Call the "stop" method (if implemented) in the breakpoint
775 class. If the method returns True, the inferior will be
776 stopped at the breakpoint. Otherwise the inferior will be
777 allowed to continue. */
779 enum ext_lang_bp_stop
780 gdbpy_breakpoint_cond_says_stop (const struct extension_language_defn
*extlang
,
781 struct breakpoint
*b
)
784 struct gdbpy_breakpoint_object
*bp_obj
= b
->py_bp_object
;
785 PyObject
*py_bp
= (PyObject
*) bp_obj
;
786 struct gdbarch
*garch
;
789 return EXT_LANG_BP_STOP_UNSET
;
792 garch
= b
->gdbarch
? b
->gdbarch
: get_current_arch ();
794 gdbpy_enter
enter_py (garch
, current_language
);
796 if (bp_obj
->is_finish_bp
)
797 bpfinishpy_pre_stop_hook (bp_obj
);
799 if (PyObject_HasAttrString (py_bp
, stop_func
))
801 gdbpy_ref
<> result (PyObject_CallMethod (py_bp
, stop_func
, NULL
));
806 int evaluate
= PyObject_IsTrue (result
.get ());
809 gdbpy_print_stack ();
811 /* If the "stop" function returns False that means
812 the Python breakpoint wants GDB to continue. */
817 gdbpy_print_stack ();
820 if (bp_obj
->is_finish_bp
)
821 bpfinishpy_post_stop_hook (bp_obj
);
824 return EXT_LANG_BP_STOP_UNSET
;
825 return stop
? EXT_LANG_BP_STOP_YES
: EXT_LANG_BP_STOP_NO
;
828 /* Checks if the "stop" method exists in this breakpoint.
829 Used by condition_command to ensure mutual exclusion of breakpoint
833 gdbpy_breakpoint_has_cond (const struct extension_language_defn
*extlang
,
834 struct breakpoint
*b
)
837 struct gdbarch
*garch
;
839 if (b
->py_bp_object
== NULL
)
842 py_bp
= (PyObject
*) b
->py_bp_object
;
843 garch
= b
->gdbarch
? b
->gdbarch
: get_current_arch ();
845 gdbpy_enter
enter_py (garch
, current_language
);
846 return PyObject_HasAttrString (py_bp
, stop_func
);
851 /* Event callback functions. */
853 /* Callback that is used when a breakpoint is created. This function
854 will create a new Python breakpoint object. */
856 gdbpy_breakpoint_created (struct breakpoint
*bp
)
858 gdbpy_breakpoint_object
*newbp
;
859 PyGILState_STATE state
;
861 if (!user_breakpoint_p (bp
) && bppy_pending_object
== NULL
)
864 if (bp
->type
!= bp_breakpoint
865 && bp
->type
!= bp_watchpoint
866 && bp
->type
!= bp_hardware_watchpoint
867 && bp
->type
!= bp_read_watchpoint
868 && bp
->type
!= bp_access_watchpoint
)
871 state
= PyGILState_Ensure ();
873 if (bppy_pending_object
)
875 newbp
= bppy_pending_object
;
876 bppy_pending_object
= NULL
;
879 newbp
= PyObject_New (gdbpy_breakpoint_object
, &breakpoint_object_type
);
882 newbp
->number
= bp
->number
;
884 newbp
->bp
->py_bp_object
= newbp
;
885 newbp
->is_finish_bp
= 0;
891 PyErr_SetString (PyExc_RuntimeError
,
892 _("Error while creating breakpoint from GDB."));
893 gdbpy_print_stack ();
896 if (!evregpy_no_listeners_p (gdb_py_events
.breakpoint_created
))
898 if (evpy_emit_event ((PyObject
*) newbp
,
899 gdb_py_events
.breakpoint_created
) < 0)
900 gdbpy_print_stack ();
903 PyGILState_Release (state
);
906 /* Callback that is used when a breakpoint is deleted. This will
907 invalidate the corresponding Python object. */
909 gdbpy_breakpoint_deleted (struct breakpoint
*b
)
912 PyGILState_STATE state
;
913 struct breakpoint
*bp
= NULL
;
915 state
= PyGILState_Ensure ();
916 bp
= get_breakpoint (num
);
919 gdbpy_ref
<gdbpy_breakpoint_object
> bp_obj (bp
->py_bp_object
);
922 if (!evregpy_no_listeners_p (gdb_py_events
.breakpoint_deleted
))
924 if (evpy_emit_event ((PyObject
*) bp_obj
.get (),
925 gdb_py_events
.breakpoint_deleted
) < 0)
926 gdbpy_print_stack ();
933 PyGILState_Release (state
);
936 /* Callback that is used when a breakpoint is modified. */
939 gdbpy_breakpoint_modified (struct breakpoint
*b
)
942 PyGILState_STATE state
;
943 struct breakpoint
*bp
= NULL
;
944 gdbpy_breakpoint_object
*bp_obj
;
946 state
= PyGILState_Ensure ();
947 bp
= get_breakpoint (num
);
950 PyObject
*bp_obj
= (PyObject
*) bp
->py_bp_object
;
953 if (!evregpy_no_listeners_p (gdb_py_events
.breakpoint_modified
))
955 if (evpy_emit_event (bp_obj
,
956 gdb_py_events
.breakpoint_modified
) < 0)
957 gdbpy_print_stack ();
961 PyGILState_Release (state
);
966 /* Initialize the Python breakpoint code. */
968 gdbpy_initialize_breakpoints (void)
972 breakpoint_object_type
.tp_new
= PyType_GenericNew
;
973 if (PyType_Ready (&breakpoint_object_type
) < 0)
976 if (gdb_pymodule_addobject (gdb_module
, "Breakpoint",
977 (PyObject
*) &breakpoint_object_type
) < 0)
980 observer_attach_breakpoint_created (gdbpy_breakpoint_created
);
981 observer_attach_breakpoint_deleted (gdbpy_breakpoint_deleted
);
982 observer_attach_breakpoint_modified (gdbpy_breakpoint_modified
);
984 /* Add breakpoint types constants. */
985 for (i
= 0; pybp_codes
[i
].name
; ++i
)
987 if (PyModule_AddIntConstant (gdb_module
,
988 /* Cast needed for Python 2.4. */
989 (char *) pybp_codes
[i
].name
,
990 pybp_codes
[i
].code
) < 0)
994 /* Add watchpoint types constants. */
995 for (i
= 0; pybp_watch_types
[i
].name
; ++i
)
997 if (PyModule_AddIntConstant (gdb_module
,
998 /* Cast needed for Python 2.4. */
999 (char *) pybp_watch_types
[i
].name
,
1000 pybp_watch_types
[i
].code
) < 0)
1009 /* Helper function that overrides this Python object's
1010 PyObject_GenericSetAttr to allow extra validation of the attribute
1014 local_setattro (PyObject
*self
, PyObject
*name
, PyObject
*v
)
1016 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
1017 gdb::unique_xmalloc_ptr
<char> attr (python_string_to_host_string (name
));
1022 /* If the attribute trying to be set is the "stop" method,
1023 but we already have a condition set in the CLI or other extension
1024 language, disallow this operation. */
1025 if (strcmp (attr
.get (), stop_func
) == 0)
1027 const struct extension_language_defn
*extlang
= NULL
;
1029 if (obj
->bp
->cond_string
!= NULL
)
1030 extlang
= get_ext_lang_defn (EXT_LANG_GDB
);
1031 if (extlang
== NULL
)
1032 extlang
= get_breakpoint_cond_ext_lang (obj
->bp
, EXT_LANG_PYTHON
);
1033 if (extlang
!= NULL
)
1038 = xstrprintf (_("Only one stop condition allowed. There is"
1039 " currently a %s stop condition defined for"
1040 " this breakpoint."),
1041 ext_lang_capitalized_name (extlang
));
1042 PyErr_SetString (PyExc_RuntimeError
, error_text
);
1048 return PyObject_GenericSetAttr ((PyObject
*)self
, name
, v
);
1051 static PyGetSetDef breakpoint_object_getset
[] = {
1052 { "enabled", bppy_get_enabled
, bppy_set_enabled
,
1053 "Boolean telling whether the breakpoint is enabled.", NULL
},
1054 { "silent", bppy_get_silent
, bppy_set_silent
,
1055 "Boolean telling whether the breakpoint is silent.", NULL
},
1056 { "thread", bppy_get_thread
, bppy_set_thread
,
1057 "Thread ID for the breakpoint.\n\
1058 If the value is a thread ID (integer), then this is a thread-specific breakpoint.\n\
1059 If the value is None, then this breakpoint is not thread-specific.\n\
1060 No other type of value can be used.", NULL
},
1061 { "task", bppy_get_task
, bppy_set_task
,
1062 "Thread ID for the breakpoint.\n\
1063 If the value is a task ID (integer), then this is an Ada task-specific breakpoint.\n\
1064 If the value is None, then this breakpoint is not task-specific.\n\
1065 No other type of value can be used.", NULL
},
1066 { "ignore_count", bppy_get_ignore_count
, bppy_set_ignore_count
,
1067 "Number of times this breakpoint should be automatically continued.",
1069 { "number", bppy_get_number
, NULL
,
1070 "Breakpoint's number assigned by GDB.", NULL
},
1071 { "hit_count", bppy_get_hit_count
, bppy_set_hit_count
,
1072 "Number of times the breakpoint has been hit.\n\
1073 Can be set to zero to clear the count. No other value is valid\n\
1074 when setting this property.", NULL
},
1075 { "location", bppy_get_location
, NULL
,
1076 "Location of the breakpoint, as specified by the user.", NULL
},
1077 { "expression", bppy_get_expression
, NULL
,
1078 "Expression of the breakpoint, as specified by the user.", NULL
},
1079 { "condition", bppy_get_condition
, bppy_set_condition
,
1080 "Condition of the breakpoint, as specified by the user,\
1081 or None if no condition set."},
1082 { "commands", bppy_get_commands
, NULL
,
1083 "Commands of the breakpoint, as specified by the user."},
1084 { "type", bppy_get_type
, NULL
,
1085 "Type of breakpoint."},
1086 { "visible", bppy_get_visibility
, NULL
,
1087 "Whether the breakpoint is visible to the user."},
1088 { "temporary", bppy_get_temporary
, NULL
,
1089 "Whether this breakpoint is a temporary breakpoint."},
1090 { "pending", bppy_get_pending
, NULL
,
1091 "Whether this breakpoint is a pending breakpoint."},
1092 { NULL
} /* Sentinel. */
1095 static PyMethodDef breakpoint_object_methods
[] =
1097 { "is_valid", bppy_is_valid
, METH_NOARGS
,
1098 "Return true if this breakpoint is valid, false if not." },
1099 { "delete", bppy_delete_breakpoint
, METH_NOARGS
,
1100 "Delete the underlying GDB breakpoint." },
1101 { NULL
} /* Sentinel. */
1104 PyTypeObject breakpoint_object_type
=
1106 PyVarObject_HEAD_INIT (NULL
, 0)
1107 "gdb.Breakpoint", /*tp_name*/
1108 sizeof (gdbpy_breakpoint_object
), /*tp_basicsize*/
1117 0, /*tp_as_sequence*/
1118 0, /*tp_as_mapping*/
1123 (setattrofunc
)local_setattro
, /*tp_setattro */
1125 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1126 "GDB breakpoint object", /* tp_doc */
1127 0, /* tp_traverse */
1129 0, /* tp_richcompare */
1130 0, /* tp_weaklistoffset */
1132 0, /* tp_iternext */
1133 breakpoint_object_methods
, /* tp_methods */
1135 breakpoint_object_getset
, /* tp_getset */
1138 0, /* tp_descr_get */
1139 0, /* tp_descr_set */
1140 0, /* tp_dictoffset */
1141 bppy_init
, /* tp_init */