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 const char 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
.get ());
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 const 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 (!gdb_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 (spec
)));
677 const char *copy
= copy_holder
.get ();
683 event_location_up location
684 = string_to_event_location_basic (©
, current_language
);
685 create_breakpoint (python_gdbarch
,
686 location
.get (), NULL
, -1, NULL
,
688 temporary_bp
, bp_breakpoint
,
691 &bkpt_breakpoint_ops
,
692 0, 1, internal_bp
, 0);
697 if (access_type
== hw_write
)
698 watch_command_wrapper (copy
, 0, internal_bp
);
699 else if (access_type
== hw_access
)
700 awatch_command_wrapper (copy
, 0, internal_bp
);
701 else if (access_type
== hw_read
)
702 rwatch_command_wrapper (copy
, 0, internal_bp
);
704 error(_("Cannot understand watchpoint access type."));
708 error(_("Do not understand breakpoint type to set."));
711 CATCH (except
, RETURN_MASK_ALL
)
713 bppy_pending_object
= NULL
;
714 PyErr_Format (except
.reason
== RETURN_QUIT
715 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
716 "%s", except
.message
);
721 BPPY_SET_REQUIRE_VALID ((gdbpy_breakpoint_object
*) self
);
728 build_bp_list (struct breakpoint
*b
, void *arg
)
730 PyObject
*list
= (PyObject
*) arg
;
731 PyObject
*bp
= (PyObject
*) b
->py_bp_object
;
734 /* Not all breakpoints will have a companion Python object.
735 Only breakpoints that were created via bppy_new, or
736 breakpoints that were created externally and are tracked by
737 the Python Scripting API. */
739 iserr
= PyList_Append (list
, bp
);
747 /* Static function to return a tuple holding all breakpoints. */
750 gdbpy_breakpoints (PyObject
*self
, PyObject
*args
)
753 return PyTuple_New (0);
755 gdbpy_ref
<> list (PyList_New (0));
759 /* If iterate_over_breakpoints returns non NULL it signals an error
760 condition. In that case abandon building the list and return
762 if (iterate_over_breakpoints (build_bp_list
, list
.get ()) != NULL
)
765 return PyList_AsTuple (list
.get ());
768 /* Call the "stop" method (if implemented) in the breakpoint
769 class. If the method returns True, the inferior will be
770 stopped at the breakpoint. Otherwise the inferior will be
771 allowed to continue. */
773 enum ext_lang_bp_stop
774 gdbpy_breakpoint_cond_says_stop (const struct extension_language_defn
*extlang
,
775 struct breakpoint
*b
)
778 struct gdbpy_breakpoint_object
*bp_obj
= b
->py_bp_object
;
779 PyObject
*py_bp
= (PyObject
*) bp_obj
;
780 struct gdbarch
*garch
;
783 return EXT_LANG_BP_STOP_UNSET
;
786 garch
= b
->gdbarch
? b
->gdbarch
: get_current_arch ();
788 gdbpy_enter
enter_py (garch
, current_language
);
790 if (bp_obj
->is_finish_bp
)
791 bpfinishpy_pre_stop_hook (bp_obj
);
793 if (PyObject_HasAttrString (py_bp
, stop_func
))
795 gdbpy_ref
<> result (PyObject_CallMethod (py_bp
, stop_func
, NULL
));
800 int evaluate
= PyObject_IsTrue (result
.get ());
803 gdbpy_print_stack ();
805 /* If the "stop" function returns False that means
806 the Python breakpoint wants GDB to continue. */
811 gdbpy_print_stack ();
814 if (bp_obj
->is_finish_bp
)
815 bpfinishpy_post_stop_hook (bp_obj
);
818 return EXT_LANG_BP_STOP_UNSET
;
819 return stop
? EXT_LANG_BP_STOP_YES
: EXT_LANG_BP_STOP_NO
;
822 /* Checks if the "stop" method exists in this breakpoint.
823 Used by condition_command to ensure mutual exclusion of breakpoint
827 gdbpy_breakpoint_has_cond (const struct extension_language_defn
*extlang
,
828 struct breakpoint
*b
)
831 struct gdbarch
*garch
;
833 if (b
->py_bp_object
== NULL
)
836 py_bp
= (PyObject
*) b
->py_bp_object
;
837 garch
= b
->gdbarch
? b
->gdbarch
: get_current_arch ();
839 gdbpy_enter
enter_py (garch
, current_language
);
840 return PyObject_HasAttrString (py_bp
, stop_func
);
845 /* Event callback functions. */
847 /* Callback that is used when a breakpoint is created. This function
848 will create a new Python breakpoint object. */
850 gdbpy_breakpoint_created (struct breakpoint
*bp
)
852 gdbpy_breakpoint_object
*newbp
;
853 PyGILState_STATE state
;
855 if (!user_breakpoint_p (bp
) && bppy_pending_object
== NULL
)
858 if (bp
->type
!= bp_breakpoint
859 && bp
->type
!= bp_watchpoint
860 && bp
->type
!= bp_hardware_watchpoint
861 && bp
->type
!= bp_read_watchpoint
862 && bp
->type
!= bp_access_watchpoint
)
865 state
= PyGILState_Ensure ();
867 if (bppy_pending_object
)
869 newbp
= bppy_pending_object
;
870 bppy_pending_object
= NULL
;
873 newbp
= PyObject_New (gdbpy_breakpoint_object
, &breakpoint_object_type
);
876 newbp
->number
= bp
->number
;
878 newbp
->bp
->py_bp_object
= newbp
;
879 newbp
->is_finish_bp
= 0;
885 PyErr_SetString (PyExc_RuntimeError
,
886 _("Error while creating breakpoint from GDB."));
887 gdbpy_print_stack ();
890 if (!evregpy_no_listeners_p (gdb_py_events
.breakpoint_created
))
892 if (evpy_emit_event ((PyObject
*) newbp
,
893 gdb_py_events
.breakpoint_created
) < 0)
894 gdbpy_print_stack ();
897 PyGILState_Release (state
);
900 /* Callback that is used when a breakpoint is deleted. This will
901 invalidate the corresponding Python object. */
903 gdbpy_breakpoint_deleted (struct breakpoint
*b
)
906 PyGILState_STATE state
;
907 struct breakpoint
*bp
= NULL
;
909 state
= PyGILState_Ensure ();
910 bp
= get_breakpoint (num
);
913 gdbpy_ref
<gdbpy_breakpoint_object
> bp_obj (bp
->py_bp_object
);
916 if (!evregpy_no_listeners_p (gdb_py_events
.breakpoint_deleted
))
918 if (evpy_emit_event ((PyObject
*) bp_obj
.get (),
919 gdb_py_events
.breakpoint_deleted
) < 0)
920 gdbpy_print_stack ();
927 PyGILState_Release (state
);
930 /* Callback that is used when a breakpoint is modified. */
933 gdbpy_breakpoint_modified (struct breakpoint
*b
)
936 PyGILState_STATE state
;
937 struct breakpoint
*bp
= NULL
;
938 gdbpy_breakpoint_object
*bp_obj
;
940 state
= PyGILState_Ensure ();
941 bp
= get_breakpoint (num
);
944 PyObject
*bp_obj
= (PyObject
*) bp
->py_bp_object
;
947 if (!evregpy_no_listeners_p (gdb_py_events
.breakpoint_modified
))
949 if (evpy_emit_event (bp_obj
,
950 gdb_py_events
.breakpoint_modified
) < 0)
951 gdbpy_print_stack ();
955 PyGILState_Release (state
);
960 /* Initialize the Python breakpoint code. */
962 gdbpy_initialize_breakpoints (void)
966 breakpoint_object_type
.tp_new
= PyType_GenericNew
;
967 if (PyType_Ready (&breakpoint_object_type
) < 0)
970 if (gdb_pymodule_addobject (gdb_module
, "Breakpoint",
971 (PyObject
*) &breakpoint_object_type
) < 0)
974 observer_attach_breakpoint_created (gdbpy_breakpoint_created
);
975 observer_attach_breakpoint_deleted (gdbpy_breakpoint_deleted
);
976 observer_attach_breakpoint_modified (gdbpy_breakpoint_modified
);
978 /* Add breakpoint types constants. */
979 for (i
= 0; pybp_codes
[i
].name
; ++i
)
981 if (PyModule_AddIntConstant (gdb_module
,
982 /* Cast needed for Python 2.4. */
983 (char *) pybp_codes
[i
].name
,
984 pybp_codes
[i
].code
) < 0)
988 /* Add watchpoint types constants. */
989 for (i
= 0; pybp_watch_types
[i
].name
; ++i
)
991 if (PyModule_AddIntConstant (gdb_module
,
992 /* Cast needed for Python 2.4. */
993 (char *) pybp_watch_types
[i
].name
,
994 pybp_watch_types
[i
].code
) < 0)
1003 /* Helper function that overrides this Python object's
1004 PyObject_GenericSetAttr to allow extra validation of the attribute
1008 local_setattro (PyObject
*self
, PyObject
*name
, PyObject
*v
)
1010 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
1011 gdb::unique_xmalloc_ptr
<char> attr (python_string_to_host_string (name
));
1016 /* If the attribute trying to be set is the "stop" method,
1017 but we already have a condition set in the CLI or other extension
1018 language, disallow this operation. */
1019 if (strcmp (attr
.get (), stop_func
) == 0)
1021 const struct extension_language_defn
*extlang
= NULL
;
1023 if (obj
->bp
->cond_string
!= NULL
)
1024 extlang
= get_ext_lang_defn (EXT_LANG_GDB
);
1025 if (extlang
== NULL
)
1026 extlang
= get_breakpoint_cond_ext_lang (obj
->bp
, EXT_LANG_PYTHON
);
1027 if (extlang
!= NULL
)
1029 std::string error_text
1030 = string_printf (_("Only one stop condition allowed. There is"
1031 " currently a %s stop condition defined for"
1032 " this breakpoint."),
1033 ext_lang_capitalized_name (extlang
));
1034 PyErr_SetString (PyExc_RuntimeError
, error_text
.c_str ());
1039 return PyObject_GenericSetAttr ((PyObject
*)self
, name
, v
);
1042 static gdb_PyGetSetDef breakpoint_object_getset
[] = {
1043 { "enabled", bppy_get_enabled
, bppy_set_enabled
,
1044 "Boolean telling whether the breakpoint is enabled.", NULL
},
1045 { "silent", bppy_get_silent
, bppy_set_silent
,
1046 "Boolean telling whether the breakpoint is silent.", NULL
},
1047 { "thread", bppy_get_thread
, bppy_set_thread
,
1048 "Thread ID for the breakpoint.\n\
1049 If the value is a thread ID (integer), then this is a thread-specific breakpoint.\n\
1050 If the value is None, then this breakpoint is not thread-specific.\n\
1051 No other type of value can be used.", NULL
},
1052 { "task", bppy_get_task
, bppy_set_task
,
1053 "Thread ID for the breakpoint.\n\
1054 If the value is a task ID (integer), then this is an Ada task-specific breakpoint.\n\
1055 If the value is None, then this breakpoint is not task-specific.\n\
1056 No other type of value can be used.", NULL
},
1057 { "ignore_count", bppy_get_ignore_count
, bppy_set_ignore_count
,
1058 "Number of times this breakpoint should be automatically continued.",
1060 { "number", bppy_get_number
, NULL
,
1061 "Breakpoint's number assigned by GDB.", NULL
},
1062 { "hit_count", bppy_get_hit_count
, bppy_set_hit_count
,
1063 "Number of times the breakpoint has been hit.\n\
1064 Can be set to zero to clear the count. No other value is valid\n\
1065 when setting this property.", NULL
},
1066 { "location", bppy_get_location
, NULL
,
1067 "Location of the breakpoint, as specified by the user.", NULL
},
1068 { "expression", bppy_get_expression
, NULL
,
1069 "Expression of the breakpoint, as specified by the user.", NULL
},
1070 { "condition", bppy_get_condition
, bppy_set_condition
,
1071 "Condition of the breakpoint, as specified by the user,\
1072 or None if no condition set."},
1073 { "commands", bppy_get_commands
, NULL
,
1074 "Commands of the breakpoint, as specified by the user."},
1075 { "type", bppy_get_type
, NULL
,
1076 "Type of breakpoint."},
1077 { "visible", bppy_get_visibility
, NULL
,
1078 "Whether the breakpoint is visible to the user."},
1079 { "temporary", bppy_get_temporary
, NULL
,
1080 "Whether this breakpoint is a temporary breakpoint."},
1081 { "pending", bppy_get_pending
, NULL
,
1082 "Whether this breakpoint is a pending breakpoint."},
1083 { NULL
} /* Sentinel. */
1086 static PyMethodDef breakpoint_object_methods
[] =
1088 { "is_valid", bppy_is_valid
, METH_NOARGS
,
1089 "Return true if this breakpoint is valid, false if not." },
1090 { "delete", bppy_delete_breakpoint
, METH_NOARGS
,
1091 "Delete the underlying GDB breakpoint." },
1092 { NULL
} /* Sentinel. */
1095 PyTypeObject breakpoint_object_type
=
1097 PyVarObject_HEAD_INIT (NULL
, 0)
1098 "gdb.Breakpoint", /*tp_name*/
1099 sizeof (gdbpy_breakpoint_object
), /*tp_basicsize*/
1108 0, /*tp_as_sequence*/
1109 0, /*tp_as_mapping*/
1114 (setattrofunc
)local_setattro
, /*tp_setattro */
1116 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1117 "GDB breakpoint object", /* tp_doc */
1118 0, /* tp_traverse */
1120 0, /* tp_richcompare */
1121 0, /* tp_weaklistoffset */
1123 0, /* tp_iternext */
1124 breakpoint_object_methods
, /* tp_methods */
1126 breakpoint_object_getset
, /* tp_getset */
1129 0, /* tp_descr_get */
1130 0, /* tp_descr_set */
1131 0, /* tp_dictoffset */
1132 bppy_init
, /* tp_init */