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
;
914 gdbpy_breakpoint_object
*bp_obj
;
916 state
= PyGILState_Ensure ();
917 bp
= get_breakpoint (num
);
920 bp_obj
= bp
->py_bp_object
;
923 if (!evregpy_no_listeners_p (gdb_py_events
.breakpoint_deleted
))
925 if (evpy_emit_event ((PyObject
*) bp_obj
,
926 gdb_py_events
.breakpoint_deleted
) < 0)
927 gdbpy_print_stack ();
935 PyGILState_Release (state
);
938 /* Callback that is used when a breakpoint is modified. */
941 gdbpy_breakpoint_modified (struct breakpoint
*b
)
944 PyGILState_STATE state
;
945 struct breakpoint
*bp
= NULL
;
946 gdbpy_breakpoint_object
*bp_obj
;
948 state
= PyGILState_Ensure ();
949 bp
= get_breakpoint (num
);
952 PyObject
*bp_obj
= (PyObject
*) bp
->py_bp_object
;
955 if (!evregpy_no_listeners_p (gdb_py_events
.breakpoint_modified
))
957 if (evpy_emit_event (bp_obj
,
958 gdb_py_events
.breakpoint_modified
) < 0)
959 gdbpy_print_stack ();
963 PyGILState_Release (state
);
968 /* Initialize the Python breakpoint code. */
970 gdbpy_initialize_breakpoints (void)
974 breakpoint_object_type
.tp_new
= PyType_GenericNew
;
975 if (PyType_Ready (&breakpoint_object_type
) < 0)
978 if (gdb_pymodule_addobject (gdb_module
, "Breakpoint",
979 (PyObject
*) &breakpoint_object_type
) < 0)
982 observer_attach_breakpoint_created (gdbpy_breakpoint_created
);
983 observer_attach_breakpoint_deleted (gdbpy_breakpoint_deleted
);
984 observer_attach_breakpoint_modified (gdbpy_breakpoint_modified
);
986 /* Add breakpoint types constants. */
987 for (i
= 0; pybp_codes
[i
].name
; ++i
)
989 if (PyModule_AddIntConstant (gdb_module
,
990 /* Cast needed for Python 2.4. */
991 (char *) pybp_codes
[i
].name
,
992 pybp_codes
[i
].code
) < 0)
996 /* Add watchpoint types constants. */
997 for (i
= 0; pybp_watch_types
[i
].name
; ++i
)
999 if (PyModule_AddIntConstant (gdb_module
,
1000 /* Cast needed for Python 2.4. */
1001 (char *) pybp_watch_types
[i
].name
,
1002 pybp_watch_types
[i
].code
) < 0)
1011 /* Helper function that overrides this Python object's
1012 PyObject_GenericSetAttr to allow extra validation of the attribute
1016 local_setattro (PyObject
*self
, PyObject
*name
, PyObject
*v
)
1018 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
1019 gdb::unique_xmalloc_ptr
<char> attr (python_string_to_host_string (name
));
1024 /* If the attribute trying to be set is the "stop" method,
1025 but we already have a condition set in the CLI or other extension
1026 language, disallow this operation. */
1027 if (strcmp (attr
.get (), stop_func
) == 0)
1029 const struct extension_language_defn
*extlang
= NULL
;
1031 if (obj
->bp
->cond_string
!= NULL
)
1032 extlang
= get_ext_lang_defn (EXT_LANG_GDB
);
1033 if (extlang
== NULL
)
1034 extlang
= get_breakpoint_cond_ext_lang (obj
->bp
, EXT_LANG_PYTHON
);
1035 if (extlang
!= NULL
)
1040 = xstrprintf (_("Only one stop condition allowed. There is"
1041 " currently a %s stop condition defined for"
1042 " this breakpoint."),
1043 ext_lang_capitalized_name (extlang
));
1044 PyErr_SetString (PyExc_RuntimeError
, error_text
);
1050 return PyObject_GenericSetAttr ((PyObject
*)self
, name
, v
);
1053 static PyGetSetDef breakpoint_object_getset
[] = {
1054 { "enabled", bppy_get_enabled
, bppy_set_enabled
,
1055 "Boolean telling whether the breakpoint is enabled.", NULL
},
1056 { "silent", bppy_get_silent
, bppy_set_silent
,
1057 "Boolean telling whether the breakpoint is silent.", NULL
},
1058 { "thread", bppy_get_thread
, bppy_set_thread
,
1059 "Thread ID for the breakpoint.\n\
1060 If the value is a thread ID (integer), then this is a thread-specific breakpoint.\n\
1061 If the value is None, then this breakpoint is not thread-specific.\n\
1062 No other type of value can be used.", NULL
},
1063 { "task", bppy_get_task
, bppy_set_task
,
1064 "Thread ID for the breakpoint.\n\
1065 If the value is a task ID (integer), then this is an Ada task-specific breakpoint.\n\
1066 If the value is None, then this breakpoint is not task-specific.\n\
1067 No other type of value can be used.", NULL
},
1068 { "ignore_count", bppy_get_ignore_count
, bppy_set_ignore_count
,
1069 "Number of times this breakpoint should be automatically continued.",
1071 { "number", bppy_get_number
, NULL
,
1072 "Breakpoint's number assigned by GDB.", NULL
},
1073 { "hit_count", bppy_get_hit_count
, bppy_set_hit_count
,
1074 "Number of times the breakpoint has been hit.\n\
1075 Can be set to zero to clear the count. No other value is valid\n\
1076 when setting this property.", NULL
},
1077 { "location", bppy_get_location
, NULL
,
1078 "Location of the breakpoint, as specified by the user.", NULL
},
1079 { "expression", bppy_get_expression
, NULL
,
1080 "Expression of the breakpoint, as specified by the user.", NULL
},
1081 { "condition", bppy_get_condition
, bppy_set_condition
,
1082 "Condition of the breakpoint, as specified by the user,\
1083 or None if no condition set."},
1084 { "commands", bppy_get_commands
, NULL
,
1085 "Commands of the breakpoint, as specified by the user."},
1086 { "type", bppy_get_type
, NULL
,
1087 "Type of breakpoint."},
1088 { "visible", bppy_get_visibility
, NULL
,
1089 "Whether the breakpoint is visible to the user."},
1090 { "temporary", bppy_get_temporary
, NULL
,
1091 "Whether this breakpoint is a temporary breakpoint."},
1092 { "pending", bppy_get_pending
, NULL
,
1093 "Whether this breakpoint is a pending breakpoint."},
1094 { NULL
} /* Sentinel. */
1097 static PyMethodDef breakpoint_object_methods
[] =
1099 { "is_valid", bppy_is_valid
, METH_NOARGS
,
1100 "Return true if this breakpoint is valid, false if not." },
1101 { "delete", bppy_delete_breakpoint
, METH_NOARGS
,
1102 "Delete the underlying GDB breakpoint." },
1103 { NULL
} /* Sentinel. */
1106 PyTypeObject breakpoint_object_type
=
1108 PyVarObject_HEAD_INIT (NULL
, 0)
1109 "gdb.Breakpoint", /*tp_name*/
1110 sizeof (gdbpy_breakpoint_object
), /*tp_basicsize*/
1119 0, /*tp_as_sequence*/
1120 0, /*tp_as_mapping*/
1125 (setattrofunc
)local_setattro
, /*tp_setattro */
1127 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1128 "GDB breakpoint object", /* tp_doc */
1129 0, /* tp_traverse */
1131 0, /* tp_richcompare */
1132 0, /* tp_weaklistoffset */
1134 0, /* tp_iternext */
1135 breakpoint_object_methods
, /* tp_methods */
1137 breakpoint_object_getset
, /* tp_getset */
1140 0, /* tp_descr_get */
1141 0, /* tp_descr_set */
1142 0, /* tp_dictoffset */
1143 bppy_init
, /* tp_init */