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"
37 /* Number of live breakpoints. */
40 /* Variables used to pass information between the Breakpoint
41 constructor and the breakpoint-created hook function. */
42 gdbpy_breakpoint_object *bppy_pending_object;
44 /* Function that is called when a Python condition is evaluated. */
45 static const char stop_func[] = "stop";
47 /* This is used to initialize various gdb.bp_* constants. */
56 /* Entries related to the type of user set breakpoints. */
57 static struct pybp_code pybp_codes[] =
59 { "BP_NONE", bp_none},
60 { "BP_BREAKPOINT", bp_breakpoint},
61 { "BP_WATCHPOINT", bp_watchpoint},
62 { "BP_HARDWARE_WATCHPOINT", bp_hardware_watchpoint},
63 { "BP_READ_WATCHPOINT", bp_read_watchpoint},
64 { "BP_ACCESS_WATCHPOINT", bp_access_watchpoint},
65 {NULL} /* Sentinel. */
68 /* Entries related to the type of watchpoint. */
69 static struct pybp_code pybp_watch_types[] =
71 { "WP_READ", hw_read},
72 { "WP_WRITE", hw_write},
73 { "WP_ACCESS", hw_access},
74 {NULL} /* Sentinel. */
77 /* Python function which checks the validity of a breakpoint object. */
79 bppy_is_valid (PyObject *self, PyObject *args)
81 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
88 /* Python function to test whether or not the breakpoint is enabled. */
90 bppy_get_enabled (PyObject *self, void *closure)
92 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
94 BPPY_REQUIRE_VALID (self_bp);
97 if (self_bp->bp->enable_state == bp_enabled)
102 /* Python function to test whether or not the breakpoint is silent. */
104 bppy_get_silent (PyObject *self, void *closure)
106 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
108 BPPY_REQUIRE_VALID (self_bp);
109 if (self_bp->bp->silent)
114 /* Python function to set the enabled state of a breakpoint. */
116 bppy_set_enabled (PyObject *self, PyObject *newvalue, void *closure)
118 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
121 BPPY_SET_REQUIRE_VALID (self_bp);
123 if (newvalue == NULL)
125 PyErr_SetString (PyExc_TypeError,
126 _("Cannot delete `enabled' attribute."));
130 else if (! PyBool_Check (newvalue))
132 PyErr_SetString (PyExc_TypeError,
133 _("The value of `enabled' must be a boolean."));
137 cmp = PyObject_IsTrue (newvalue);
144 enable_breakpoint (self_bp->bp);
146 disable_breakpoint (self_bp->bp);
148 CATCH (except, RETURN_MASK_ALL)
150 GDB_PY_SET_HANDLE_EXCEPTION (except);
157 /* Python function to set the 'silent' state of a breakpoint. */
159 bppy_set_silent (PyObject *self, PyObject *newvalue, void *closure)
161 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
164 BPPY_SET_REQUIRE_VALID (self_bp);
166 if (newvalue == NULL)
168 PyErr_SetString (PyExc_TypeError,
169 _("Cannot delete `silent' attribute."));
172 else if (! PyBool_Check (newvalue))
174 PyErr_SetString (PyExc_TypeError,
175 _("The value of `silent' must be a boolean."));
179 cmp = PyObject_IsTrue (newvalue);
183 breakpoint_set_silent (self_bp->bp, cmp);
188 /* Python function to set the thread of a breakpoint. */
190 bppy_set_thread (PyObject *self, PyObject *newvalue, void *closure)
192 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
195 BPPY_SET_REQUIRE_VALID (self_bp);
197 if (newvalue == NULL)
199 PyErr_SetString (PyExc_TypeError,
200 _("Cannot delete `thread' attribute."));
203 else if (PyInt_Check (newvalue))
205 if (! gdb_py_int_as_long (newvalue, &id))
208 if (!valid_global_thread_id (id))
210 PyErr_SetString (PyExc_RuntimeError,
211 _("Invalid thread ID."));
215 else if (newvalue == Py_None)
219 PyErr_SetString (PyExc_TypeError,
220 _("The value of `thread' must be an integer or None."));
224 breakpoint_set_thread (self_bp->bp, id);
229 /* Python function to set the (Ada) task of a breakpoint. */
231 bppy_set_task (PyObject *self, PyObject *newvalue, void *closure)
233 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
237 BPPY_SET_REQUIRE_VALID (self_bp);
239 if (newvalue == NULL)
241 PyErr_SetString (PyExc_TypeError,
242 _("Cannot delete `task' attribute."));
245 else if (PyInt_Check (newvalue))
247 if (! gdb_py_int_as_long (newvalue, &id))
252 valid_id = valid_task_id (id);
254 CATCH (except, RETURN_MASK_ALL)
256 GDB_PY_SET_HANDLE_EXCEPTION (except);
262 PyErr_SetString (PyExc_RuntimeError,
263 _("Invalid task ID."));
267 else if (newvalue == Py_None)
271 PyErr_SetString (PyExc_TypeError,
272 _("The value of `task' must be an integer or None."));
276 breakpoint_set_task (self_bp->bp, id);
281 /* Python function which deletes the underlying GDB breakpoint. This
282 triggers the breakpoint_deleted observer which will call
283 gdbpy_breakpoint_deleted; that function cleans up the Python
287 bppy_delete_breakpoint (PyObject *self, PyObject *args)
289 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
291 BPPY_REQUIRE_VALID (self_bp);
295 delete_breakpoint (self_bp->bp);
297 CATCH (except, RETURN_MASK_ALL)
299 GDB_PY_HANDLE_EXCEPTION (except);
307 /* Python function to set the ignore count of a breakpoint. */
309 bppy_set_ignore_count (PyObject *self, PyObject *newvalue, void *closure)
311 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
314 BPPY_SET_REQUIRE_VALID (self_bp);
316 if (newvalue == NULL)
318 PyErr_SetString (PyExc_TypeError,
319 _("Cannot delete `ignore_count' attribute."));
322 else if (! PyInt_Check (newvalue))
324 PyErr_SetString (PyExc_TypeError,
325 _("The value of `ignore_count' must be an integer."));
329 if (! gdb_py_int_as_long (newvalue, &value))
337 set_ignore_count (self_bp->number, (int) value, 0);
339 CATCH (except, RETURN_MASK_ALL)
341 GDB_PY_SET_HANDLE_EXCEPTION (except);
348 /* Python function to set the hit count of a breakpoint. */
350 bppy_set_hit_count (PyObject *self, PyObject *newvalue, void *closure)
352 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
354 BPPY_SET_REQUIRE_VALID (self_bp);
356 if (newvalue == NULL)
358 PyErr_SetString (PyExc_TypeError,
359 _("Cannot delete `hit_count' attribute."));
366 if (! gdb_py_int_as_long (newvalue, &value))
371 PyErr_SetString (PyExc_AttributeError,
372 _("The value of `hit_count' must be zero."));
377 self_bp->bp->hit_count = 0;
382 /* Python function to get the location of a breakpoint. */
384 bppy_get_location (PyObject *self, void *closure)
387 gdbpy_breakpoint_object *obj = (gdbpy_breakpoint_object *) self;
389 BPPY_REQUIRE_VALID (obj);
391 if (obj->bp->type != bp_breakpoint)
394 str = event_location_to_string (obj->bp->location.get ());
397 return host_string_to_python_string (str);
400 /* Python function to get the breakpoint expression. */
402 bppy_get_expression (PyObject *self, void *closure)
405 gdbpy_breakpoint_object *obj = (gdbpy_breakpoint_object *) self;
406 struct watchpoint *wp;
408 BPPY_REQUIRE_VALID (obj);
410 if (!is_watchpoint (obj->bp))
413 wp = (struct watchpoint *) obj->bp;
415 str = wp->exp_string;
419 return host_string_to_python_string (str);
422 /* Python function to get the condition expression of a breakpoint. */
424 bppy_get_condition (PyObject *self, void *closure)
427 gdbpy_breakpoint_object *obj = (gdbpy_breakpoint_object *) self;
429 BPPY_REQUIRE_VALID (obj);
431 str = obj->bp->cond_string;
435 return host_string_to_python_string (str);
438 /* Returns 0 on success. Returns -1 on error, with a python exception set.
442 bppy_set_condition (PyObject *self, PyObject *newvalue, void *closure)
444 gdb::unique_xmalloc_ptr<char> exp_holder;
445 const char *exp = NULL;
446 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
447 struct gdb_exception except = exception_none;
449 BPPY_SET_REQUIRE_VALID (self_bp);
451 if (newvalue == NULL)
453 PyErr_SetString (PyExc_TypeError,
454 _("Cannot delete `condition' attribute."));
457 else if (newvalue == Py_None)
461 exp_holder = python_string_to_host_string (newvalue);
462 if (exp_holder == NULL)
464 exp = exp_holder.get ();
469 set_breakpoint_condition (self_bp->bp, exp, 0);
471 CATCH (ex, RETURN_MASK_ALL)
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 BPPY_REQUIRE_VALID (self_bp);
491 if (! self_bp->bp->commands)
496 current_uiout->redirect (&stb);
499 print_command_lines (current_uiout, breakpoint_commands (bp), 0);
501 CATCH (except, RETURN_MASK_ALL)
503 current_uiout->redirect (NULL);
504 gdbpy_convert_exception (except);
509 current_uiout->redirect (NULL);
510 return host_string_to_python_string (stb.c_str ());
513 /* Python function to get the breakpoint type. */
515 bppy_get_type (PyObject *self, void *closure)
517 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
519 BPPY_REQUIRE_VALID (self_bp);
521 return PyInt_FromLong (self_bp->bp->type);
524 /* Python function to get the visibility of the breakpoint. */
527 bppy_get_visibility (PyObject *self, void *closure)
529 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
531 BPPY_REQUIRE_VALID (self_bp);
533 if (user_breakpoint_p (self_bp->bp))
539 /* Python function to determine if the breakpoint is a temporary
543 bppy_get_temporary (PyObject *self, void *closure)
545 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
547 BPPY_REQUIRE_VALID (self_bp);
549 if (self_bp->bp->disposition == disp_del
550 || self_bp->bp->disposition == disp_del_at_next_stop)
556 /* Python function to determine if the breakpoint is a pending
560 bppy_get_pending (PyObject *self, void *closure)
562 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
564 BPPY_REQUIRE_VALID (self_bp);
566 if (is_watchpoint (self_bp->bp))
568 if (pending_breakpoint_p (self_bp->bp))
574 /* Python function to get the breakpoint's number. */
576 bppy_get_number (PyObject *self, void *closure)
578 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
580 BPPY_REQUIRE_VALID (self_bp);
582 return PyInt_FromLong (self_bp->number);
585 /* Python function to get the breakpoint's thread ID. */
587 bppy_get_thread (PyObject *self, void *closure)
589 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
591 BPPY_REQUIRE_VALID (self_bp);
593 if (self_bp->bp->thread == -1)
596 return PyInt_FromLong (self_bp->bp->thread);
599 /* Python function to get the breakpoint's task ID (in Ada). */
601 bppy_get_task (PyObject *self, void *closure)
603 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
605 BPPY_REQUIRE_VALID (self_bp);
607 if (self_bp->bp->task == 0)
610 return PyInt_FromLong (self_bp->bp->task);
613 /* Python function to get the breakpoint's hit count. */
615 bppy_get_hit_count (PyObject *self, void *closure)
617 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
619 BPPY_REQUIRE_VALID (self_bp);
621 return PyInt_FromLong (self_bp->bp->hit_count);
624 /* Python function to get the breakpoint's ignore count. */
626 bppy_get_ignore_count (PyObject *self, void *closure)
628 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
630 BPPY_REQUIRE_VALID (self_bp);
632 return PyInt_FromLong (self_bp->bp->ignore_count);
635 /* Internal function to validate the Python parameters/keywords
636 provided to bppy_init. */
639 bppy_init_validate_args (const char *spec, char *source,
640 char *function, char *label,
641 char *line, enum bptype type)
643 /* If spec is defined, ensure that none of the explicit location
644 keywords are also defined. */
647 if (source != NULL || function != NULL || label != NULL || line != NULL)
649 PyErr_SetString (PyExc_RuntimeError,
650 _("Breakpoints specified with spec cannot "
651 "have source, function, label or line defined."));
657 /* If spec isn't defined, ensure that the user is not trying to
658 define a watchpoint with an explicit location. */
659 if (type == bp_watchpoint)
661 PyErr_SetString (PyExc_RuntimeError,
662 _("Watchpoints cannot be set by explicit "
663 "location parameters."));
668 /* Otherwise, ensure some explicit locations are defined. */
669 if (source == NULL && function == NULL && label == NULL
672 PyErr_SetString (PyExc_RuntimeError,
673 _("Neither spec nor explicit location set."));
676 /* Finally, if source is specified, ensure that line, label
677 or function are specified too. */
678 if (source != NULL && function == NULL && label == NULL
681 PyErr_SetString (PyExc_RuntimeError,
682 _("Specifying a source must also include a "
683 "line, label or function."));
691 /* Python function to create a new breakpoint. */
693 bppy_init (PyObject *self, PyObject *args, PyObject *kwargs)
695 static const char *keywords[] = { "spec", "type", "wp_class", "internal",
696 "temporary","source", "function",
697 "label", "line", "qualified", NULL };
698 const char *spec = NULL;
699 enum bptype type = bp_breakpoint;
700 int access_type = hw_write;
701 PyObject *internal = NULL;
702 PyObject *temporary = NULL;
703 PyObject *lineobj = NULL;;
705 int temporary_bp = 0;
706 gdb::unique_xmalloc_ptr<char> line;
709 char *function = NULL;
710 PyObject * qualified = NULL;
712 if (!gdb_PyArg_ParseTupleAndKeywords (args, kwargs, "|siiOOsssOO", keywords,
713 &spec, &type, &access_type,
716 &function, &label, &lineobj,
723 if (PyInt_Check (lineobj))
724 line.reset (xstrprintf ("%ld", PyInt_AsLong (lineobj)));
725 else if (PyString_Check (lineobj))
726 line = python_string_to_host_string (lineobj);
729 PyErr_SetString (PyExc_RuntimeError,
730 _("Line keyword should be an integer or a string. "));
737 internal_bp = PyObject_IsTrue (internal);
738 if (internal_bp == -1)
742 if (temporary != NULL)
744 temporary_bp = PyObject_IsTrue (temporary);
745 if (temporary_bp == -1)
749 if (bppy_init_validate_args (spec, source, function, label, line.get (),
753 bppy_pending_object = (gdbpy_breakpoint_object *) self;
754 bppy_pending_object->number = -1;
755 bppy_pending_object->bp = NULL;
763 event_location_up location;
764 symbol_name_match_type func_name_match_type
765 = (qualified != NULL && PyObject_IsTrue (qualified)
766 ? symbol_name_match_type::FULL
767 : symbol_name_match_type::WILD);
771 gdb::unique_xmalloc_ptr<char>
772 copy_holder (xstrdup (skip_spaces (spec)));
773 const char *copy = copy_holder.get ();
775 location = string_to_event_location (©,
777 func_name_match_type);
781 struct explicit_location explicit_loc;
783 initialize_explicit_location (&explicit_loc);
784 explicit_loc.source_filename = source;
785 explicit_loc.function_name = function;
786 explicit_loc.label_name = label;
789 explicit_loc.line_offset =
790 linespec_parse_line_offset (line.get ());
792 explicit_loc.func_name_match_type = func_name_match_type;
794 location = new_explicit_location (&explicit_loc);
797 create_breakpoint (python_gdbarch,
798 location.get (), NULL, -1, NULL,
800 temporary_bp, bp_breakpoint,
803 &bkpt_breakpoint_ops,
804 0, 1, internal_bp, 0);
809 gdb::unique_xmalloc_ptr<char>
810 copy_holder (xstrdup (skip_spaces (spec)));
811 char *copy = copy_holder.get ();
813 if (access_type == hw_write)
814 watch_command_wrapper (copy, 0, internal_bp);
815 else if (access_type == hw_access)
816 awatch_command_wrapper (copy, 0, internal_bp);
817 else if (access_type == hw_read)
818 rwatch_command_wrapper (copy, 0, internal_bp);
820 error(_("Cannot understand watchpoint access type."));
824 error(_("Do not understand breakpoint type to set."));
827 CATCH (except, RETURN_MASK_ALL)
829 bppy_pending_object = NULL;
830 PyErr_Format (except.reason == RETURN_QUIT
831 ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
832 "%s", except.message);
837 BPPY_SET_REQUIRE_VALID ((gdbpy_breakpoint_object *) self);
844 build_bp_list (struct breakpoint *b, void *arg)
846 PyObject *list = (PyObject *) arg;
847 PyObject *bp = (PyObject *) b->py_bp_object;
850 /* Not all breakpoints will have a companion Python object.
851 Only breakpoints that were created via bppy_new, or
852 breakpoints that were created externally and are tracked by
853 the Python Scripting API. */
855 iserr = PyList_Append (list, bp);
863 /* Static function to return a tuple holding all breakpoints. */
866 gdbpy_breakpoints (PyObject *self, PyObject *args)
869 return PyTuple_New (0);
871 gdbpy_ref<> list (PyList_New (0));
875 /* If iterate_over_breakpoints returns non NULL it signals an error
876 condition. In that case abandon building the list and return
878 if (iterate_over_breakpoints (build_bp_list, list.get ()) != NULL)
881 return PyList_AsTuple (list.get ());
884 /* Call the "stop" method (if implemented) in the breakpoint
885 class. If the method returns True, the inferior will be
886 stopped at the breakpoint. Otherwise the inferior will be
887 allowed to continue. */
889 enum ext_lang_bp_stop
890 gdbpy_breakpoint_cond_says_stop (const struct extension_language_defn *extlang,
891 struct breakpoint *b)
894 struct gdbpy_breakpoint_object *bp_obj = b->py_bp_object;
895 PyObject *py_bp = (PyObject *) bp_obj;
896 struct gdbarch *garch;
899 return EXT_LANG_BP_STOP_UNSET;
902 garch = b->gdbarch ? b->gdbarch : get_current_arch ();
904 gdbpy_enter enter_py (garch, current_language);
906 if (bp_obj->is_finish_bp)
907 bpfinishpy_pre_stop_hook (bp_obj);
909 if (PyObject_HasAttrString (py_bp, stop_func))
911 gdbpy_ref<> result (PyObject_CallMethod (py_bp, stop_func, NULL));
916 int evaluate = PyObject_IsTrue (result.get ());
919 gdbpy_print_stack ();
921 /* If the "stop" function returns False that means
922 the Python breakpoint wants GDB to continue. */
927 gdbpy_print_stack ();
930 if (bp_obj->is_finish_bp)
931 bpfinishpy_post_stop_hook (bp_obj);
934 return EXT_LANG_BP_STOP_UNSET;
935 return stop ? EXT_LANG_BP_STOP_YES : EXT_LANG_BP_STOP_NO;
938 /* Checks if the "stop" method exists in this breakpoint.
939 Used by condition_command to ensure mutual exclusion of breakpoint
943 gdbpy_breakpoint_has_cond (const struct extension_language_defn *extlang,
944 struct breakpoint *b)
947 struct gdbarch *garch;
949 if (b->py_bp_object == NULL)
952 py_bp = (PyObject *) b->py_bp_object;
953 garch = b->gdbarch ? b->gdbarch : get_current_arch ();
955 gdbpy_enter enter_py (garch, current_language);
956 return PyObject_HasAttrString (py_bp, stop_func);
961 /* Event callback functions. */
963 /* Callback that is used when a breakpoint is created. This function
964 will create a new Python breakpoint object. */
966 gdbpy_breakpoint_created (struct breakpoint *bp)
968 gdbpy_breakpoint_object *newbp;
969 PyGILState_STATE state;
971 if (!user_breakpoint_p (bp) && bppy_pending_object == NULL)
974 if (bp->type != bp_breakpoint
975 && bp->type != bp_watchpoint
976 && bp->type != bp_hardware_watchpoint
977 && bp->type != bp_read_watchpoint
978 && bp->type != bp_access_watchpoint)
981 state = PyGILState_Ensure ();
983 if (bppy_pending_object)
985 newbp = bppy_pending_object;
986 bppy_pending_object = NULL;
989 newbp = PyObject_New (gdbpy_breakpoint_object, &breakpoint_object_type);
992 newbp->number = bp->number;
994 newbp->bp->py_bp_object = newbp;
995 newbp->is_finish_bp = 0;
1001 PyErr_SetString (PyExc_RuntimeError,
1002 _("Error while creating breakpoint from GDB."));
1003 gdbpy_print_stack ();
1006 if (!evregpy_no_listeners_p (gdb_py_events.breakpoint_created))
1008 if (evpy_emit_event ((PyObject *) newbp,
1009 gdb_py_events.breakpoint_created) < 0)
1010 gdbpy_print_stack ();
1013 PyGILState_Release (state);
1016 /* Callback that is used when a breakpoint is deleted. This will
1017 invalidate the corresponding Python object. */
1019 gdbpy_breakpoint_deleted (struct breakpoint *b)
1021 int num = b->number;
1022 PyGILState_STATE state;
1023 struct breakpoint *bp = NULL;
1025 state = PyGILState_Ensure ();
1026 bp = get_breakpoint (num);
1029 gdbpy_ref<gdbpy_breakpoint_object> bp_obj (bp->py_bp_object);
1032 if (!evregpy_no_listeners_p (gdb_py_events.breakpoint_deleted))
1034 if (evpy_emit_event ((PyObject *) bp_obj.get (),
1035 gdb_py_events.breakpoint_deleted) < 0)
1036 gdbpy_print_stack ();
1043 PyGILState_Release (state);
1046 /* Callback that is used when a breakpoint is modified. */
1049 gdbpy_breakpoint_modified (struct breakpoint *b)
1051 int num = b->number;
1052 PyGILState_STATE state;
1053 struct breakpoint *bp = NULL;
1055 state = PyGILState_Ensure ();
1056 bp = get_breakpoint (num);
1059 PyObject *bp_obj = (PyObject *) bp->py_bp_object;
1062 if (!evregpy_no_listeners_p (gdb_py_events.breakpoint_modified))
1064 if (evpy_emit_event (bp_obj,
1065 gdb_py_events.breakpoint_modified) < 0)
1066 gdbpy_print_stack ();
1070 PyGILState_Release (state);
1075 /* Initialize the Python breakpoint code. */
1077 gdbpy_initialize_breakpoints (void)
1081 breakpoint_object_type.tp_new = PyType_GenericNew;
1082 if (PyType_Ready (&breakpoint_object_type) < 0)
1085 if (gdb_pymodule_addobject (gdb_module, "Breakpoint",
1086 (PyObject *) &breakpoint_object_type) < 0)
1089 observer_attach_breakpoint_created (gdbpy_breakpoint_created);
1090 observer_attach_breakpoint_deleted (gdbpy_breakpoint_deleted);
1091 observer_attach_breakpoint_modified (gdbpy_breakpoint_modified);
1093 /* Add breakpoint types constants. */
1094 for (i = 0; pybp_codes[i].name; ++i)
1096 if (PyModule_AddIntConstant (gdb_module,
1097 /* Cast needed for Python 2.4. */
1098 (char *) pybp_codes[i].name,
1099 pybp_codes[i].code) < 0)
1103 /* Add watchpoint types constants. */
1104 for (i = 0; pybp_watch_types[i].name; ++i)
1106 if (PyModule_AddIntConstant (gdb_module,
1107 /* Cast needed for Python 2.4. */
1108 (char *) pybp_watch_types[i].name,
1109 pybp_watch_types[i].code) < 0)
1118 /* Helper function that overrides this Python object's
1119 PyObject_GenericSetAttr to allow extra validation of the attribute
1123 local_setattro (PyObject *self, PyObject *name, PyObject *v)
1125 gdbpy_breakpoint_object *obj = (gdbpy_breakpoint_object *) self;
1126 gdb::unique_xmalloc_ptr<char> attr (python_string_to_host_string (name));
1131 /* If the attribute trying to be set is the "stop" method,
1132 but we already have a condition set in the CLI or other extension
1133 language, disallow this operation. */
1134 if (strcmp (attr.get (), stop_func) == 0)
1136 const struct extension_language_defn *extlang = NULL;
1138 if (obj->bp->cond_string != NULL)
1139 extlang = get_ext_lang_defn (EXT_LANG_GDB);
1140 if (extlang == NULL)
1141 extlang = get_breakpoint_cond_ext_lang (obj->bp, EXT_LANG_PYTHON);
1142 if (extlang != NULL)
1144 std::string error_text
1145 = string_printf (_("Only one stop condition allowed. There is"
1146 " currently a %s stop condition defined for"
1147 " this breakpoint."),
1148 ext_lang_capitalized_name (extlang));
1149 PyErr_SetString (PyExc_RuntimeError, error_text.c_str ());
1154 return PyObject_GenericSetAttr ((PyObject *)self, name, v);
1157 static gdb_PyGetSetDef breakpoint_object_getset[] = {
1158 { "enabled", bppy_get_enabled, bppy_set_enabled,
1159 "Boolean telling whether the breakpoint is enabled.", NULL },
1160 { "silent", bppy_get_silent, bppy_set_silent,
1161 "Boolean telling whether the breakpoint is silent.", NULL },
1162 { "thread", bppy_get_thread, bppy_set_thread,
1163 "Thread ID for the breakpoint.\n\
1164 If the value is a thread ID (integer), then this is a thread-specific breakpoint.\n\
1165 If the value is None, then this breakpoint is not thread-specific.\n\
1166 No other type of value can be used.", NULL },
1167 { "task", bppy_get_task, bppy_set_task,
1168 "Thread ID for the breakpoint.\n\
1169 If the value is a task ID (integer), then this is an Ada task-specific breakpoint.\n\
1170 If the value is None, then this breakpoint is not task-specific.\n\
1171 No other type of value can be used.", NULL },
1172 { "ignore_count", bppy_get_ignore_count, bppy_set_ignore_count,
1173 "Number of times this breakpoint should be automatically continued.",
1175 { "number", bppy_get_number, NULL,
1176 "Breakpoint's number assigned by GDB.", NULL },
1177 { "hit_count", bppy_get_hit_count, bppy_set_hit_count,
1178 "Number of times the breakpoint has been hit.\n\
1179 Can be set to zero to clear the count. No other value is valid\n\
1180 when setting this property.", NULL },
1181 { "location", bppy_get_location, NULL,
1182 "Location of the breakpoint, as specified by the user.", NULL},
1183 { "expression", bppy_get_expression, NULL,
1184 "Expression of the breakpoint, as specified by the user.", NULL},
1185 { "condition", bppy_get_condition, bppy_set_condition,
1186 "Condition of the breakpoint, as specified by the user,\
1187 or None if no condition set."},
1188 { "commands", bppy_get_commands, NULL,
1189 "Commands of the breakpoint, as specified by the user."},
1190 { "type", bppy_get_type, NULL,
1191 "Type of breakpoint."},
1192 { "visible", bppy_get_visibility, NULL,
1193 "Whether the breakpoint is visible to the user."},
1194 { "temporary", bppy_get_temporary, NULL,
1195 "Whether this breakpoint is a temporary breakpoint."},
1196 { "pending", bppy_get_pending, NULL,
1197 "Whether this breakpoint is a pending breakpoint."},
1198 { NULL } /* Sentinel. */
1201 static PyMethodDef breakpoint_object_methods[] =
1203 { "is_valid", bppy_is_valid, METH_NOARGS,
1204 "Return true if this breakpoint is valid, false if not." },
1205 { "delete", bppy_delete_breakpoint, METH_NOARGS,
1206 "Delete the underlying GDB breakpoint." },
1207 { NULL } /* Sentinel. */
1210 PyTypeObject breakpoint_object_type =
1212 PyVarObject_HEAD_INIT (NULL, 0)
1213 "gdb.Breakpoint", /*tp_name*/
1214 sizeof (gdbpy_breakpoint_object), /*tp_basicsize*/
1223 0, /*tp_as_sequence*/
1224 0, /*tp_as_mapping*/
1229 (setattrofunc)local_setattro, /*tp_setattro */
1231 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
1232 "GDB breakpoint object", /* tp_doc */
1233 0, /* tp_traverse */
1235 0, /* tp_richcompare */
1236 0, /* tp_weaklistoffset */
1238 0, /* tp_iternext */
1239 breakpoint_object_methods, /* tp_methods */
1241 breakpoint_object_getset, /* tp_getset */
1244 0, /* tp_descr_get */
1245 0, /* tp_descr_set */
1246 0, /* tp_dictoffset */
1247 bppy_init, /* tp_init */