1 /* Python interface to breakpoints
3 Copyright (C) 2008-2014 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 "exceptions.h"
23 #include "python-internal.h"
26 #include "breakpoint.h"
28 #include "gdbthread.h"
30 #include "cli/cli-script.h"
32 #include "arch-utils.h"
35 /* Number of live breakpoints. */
38 /* Variables used to pass information between the Breakpoint
39 constructor and the breakpoint-created hook function. */
40 gdbpy_breakpoint_object
*bppy_pending_object
;
42 /* Function that is called when a Python condition is evaluated. */
43 static char * const stop_func
= "stop";
45 /* This is used to initialize various gdb.bp_* constants. */
54 /* Entries related to the type of user set breakpoints. */
55 static struct pybp_code pybp_codes
[] =
57 { "BP_NONE", bp_none
},
58 { "BP_BREAKPOINT", bp_breakpoint
},
59 { "BP_WATCHPOINT", bp_watchpoint
},
60 { "BP_HARDWARE_WATCHPOINT", bp_hardware_watchpoint
},
61 { "BP_READ_WATCHPOINT", bp_read_watchpoint
},
62 { "BP_ACCESS_WATCHPOINT", bp_access_watchpoint
},
63 {NULL
} /* Sentinel. */
66 /* Entries related to the type of watchpoint. */
67 static struct pybp_code pybp_watch_types
[] =
69 { "WP_READ", hw_read
},
70 { "WP_WRITE", hw_write
},
71 { "WP_ACCESS", hw_access
},
72 {NULL
} /* Sentinel. */
75 /* Python function which checks the validity of a breakpoint object. */
77 bppy_is_valid (PyObject
*self
, PyObject
*args
)
79 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
86 /* Python function to test whether or not the breakpoint is enabled. */
88 bppy_get_enabled (PyObject
*self
, void *closure
)
90 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
92 BPPY_REQUIRE_VALID (self_bp
);
95 if (self_bp
->bp
->enable_state
== bp_enabled
)
100 /* Python function to test whether or not the breakpoint is silent. */
102 bppy_get_silent (PyObject
*self
, void *closure
)
104 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
106 BPPY_REQUIRE_VALID (self_bp
);
107 if (self_bp
->bp
->silent
)
112 /* Python function to set the enabled state of a breakpoint. */
114 bppy_set_enabled (PyObject
*self
, PyObject
*newvalue
, void *closure
)
116 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
118 volatile struct gdb_exception except
;
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
);
140 TRY_CATCH (except
, RETURN_MASK_ALL
)
143 enable_breakpoint (self_bp
->bp
);
145 disable_breakpoint (self_bp
->bp
);
147 GDB_PY_SET_HANDLE_EXCEPTION (except
);
152 /* Python function to set the 'silent' state of a breakpoint. */
154 bppy_set_silent (PyObject
*self
, PyObject
*newvalue
, void *closure
)
156 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
159 BPPY_SET_REQUIRE_VALID (self_bp
);
161 if (newvalue
== NULL
)
163 PyErr_SetString (PyExc_TypeError
,
164 _("Cannot delete `silent' attribute."));
167 else if (! PyBool_Check (newvalue
))
169 PyErr_SetString (PyExc_TypeError
,
170 _("The value of `silent' must be a boolean."));
174 cmp
= PyObject_IsTrue (newvalue
);
178 breakpoint_set_silent (self_bp
->bp
, cmp
);
183 /* Python function to set the thread of a breakpoint. */
185 bppy_set_thread (PyObject
*self
, PyObject
*newvalue
, void *closure
)
187 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
190 BPPY_SET_REQUIRE_VALID (self_bp
);
192 if (newvalue
== NULL
)
194 PyErr_SetString (PyExc_TypeError
,
195 _("Cannot delete `thread' attribute."));
198 else if (PyInt_Check (newvalue
))
200 if (! gdb_py_int_as_long (newvalue
, &id
))
203 if (! valid_thread_id (id
))
205 PyErr_SetString (PyExc_RuntimeError
,
206 _("Invalid thread ID."));
210 else if (newvalue
== Py_None
)
214 PyErr_SetString (PyExc_TypeError
,
215 _("The value of `thread' must be an integer or None."));
219 breakpoint_set_thread (self_bp
->bp
, id
);
224 /* Python function to set the (Ada) task of a breakpoint. */
226 bppy_set_task (PyObject
*self
, PyObject
*newvalue
, void *closure
)
228 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
231 volatile struct gdb_exception except
;
233 BPPY_SET_REQUIRE_VALID (self_bp
);
235 if (newvalue
== NULL
)
237 PyErr_SetString (PyExc_TypeError
,
238 _("Cannot delete `task' attribute."));
241 else if (PyInt_Check (newvalue
))
243 if (! gdb_py_int_as_long (newvalue
, &id
))
246 TRY_CATCH (except
, RETURN_MASK_ALL
)
248 valid_id
= valid_task_id (id
);
250 GDB_PY_SET_HANDLE_EXCEPTION (except
);
254 PyErr_SetString (PyExc_RuntimeError
,
255 _("Invalid task ID."));
259 else if (newvalue
== Py_None
)
263 PyErr_SetString (PyExc_TypeError
,
264 _("The value of `task' must be an integer or None."));
268 breakpoint_set_task (self_bp
->bp
, id
);
273 /* Python function which deletes the underlying GDB breakpoint. This
274 triggers the breakpoint_deleted observer which will call
275 gdbpy_breakpoint_deleted; that function cleans up the Python
279 bppy_delete_breakpoint (PyObject
*self
, PyObject
*args
)
281 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
282 volatile struct gdb_exception except
;
284 BPPY_REQUIRE_VALID (self_bp
);
286 TRY_CATCH (except
, RETURN_MASK_ALL
)
288 delete_breakpoint (self_bp
->bp
);
290 GDB_PY_HANDLE_EXCEPTION (except
);
296 /* Python function to set the ignore count of a breakpoint. */
298 bppy_set_ignore_count (PyObject
*self
, PyObject
*newvalue
, void *closure
)
300 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
302 volatile struct gdb_exception except
;
304 BPPY_SET_REQUIRE_VALID (self_bp
);
306 if (newvalue
== NULL
)
308 PyErr_SetString (PyExc_TypeError
,
309 _("Cannot delete `ignore_count' attribute."));
312 else if (! PyInt_Check (newvalue
))
314 PyErr_SetString (PyExc_TypeError
,
315 _("The value of `ignore_count' must be an integer."));
319 if (! gdb_py_int_as_long (newvalue
, &value
))
325 TRY_CATCH (except
, RETURN_MASK_ALL
)
327 set_ignore_count (self_bp
->number
, (int) value
, 0);
329 GDB_PY_SET_HANDLE_EXCEPTION (except
);
334 /* Python function to set the hit count of a breakpoint. */
336 bppy_set_hit_count (PyObject
*self
, PyObject
*newvalue
, void *closure
)
338 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
340 BPPY_SET_REQUIRE_VALID (self_bp
);
342 if (newvalue
== NULL
)
344 PyErr_SetString (PyExc_TypeError
,
345 _("Cannot delete `hit_count' attribute."));
352 if (! gdb_py_int_as_long (newvalue
, &value
))
357 PyErr_SetString (PyExc_AttributeError
,
358 _("The value of `hit_count' must be zero."));
363 self_bp
->bp
->hit_count
= 0;
368 /* Python function to get the location of a breakpoint. */
370 bppy_get_location (PyObject
*self
, void *closure
)
373 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
375 BPPY_REQUIRE_VALID (obj
);
377 if (obj
->bp
->type
!= bp_breakpoint
)
380 str
= obj
->bp
->addr_string
;
384 return PyString_Decode (str
, strlen (str
), host_charset (), NULL
);
387 /* Python function to get the breakpoint expression. */
389 bppy_get_expression (PyObject
*self
, void *closure
)
392 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
393 struct watchpoint
*wp
;
395 BPPY_REQUIRE_VALID (obj
);
397 if (!is_watchpoint (obj
->bp
))
400 wp
= (struct watchpoint
*) obj
->bp
;
402 str
= wp
->exp_string
;
406 return PyString_Decode (str
, strlen (str
), host_charset (), NULL
);
409 /* Python function to get the condition expression of a breakpoint. */
411 bppy_get_condition (PyObject
*self
, void *closure
)
414 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
416 BPPY_REQUIRE_VALID (obj
);
418 str
= obj
->bp
->cond_string
;
422 return PyString_Decode (str
, strlen (str
), host_charset (), NULL
);
425 /* Returns 0 on success. Returns -1 on error, with a python exception set.
429 bppy_set_condition (PyObject
*self
, PyObject
*newvalue
, void *closure
)
432 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
433 volatile struct gdb_exception except
;
435 BPPY_SET_REQUIRE_VALID (self_bp
);
437 if (newvalue
== NULL
)
439 PyErr_SetString (PyExc_TypeError
,
440 _("Cannot delete `condition' attribute."));
443 else if (newvalue
== Py_None
)
447 exp
= python_string_to_host_string (newvalue
);
452 TRY_CATCH (except
, RETURN_MASK_ALL
)
454 set_breakpoint_condition (self_bp
->bp
, exp
, 0);
457 if (newvalue
!= Py_None
)
460 GDB_PY_SET_HANDLE_EXCEPTION (except
);
465 /* Python function to get the commands attached to a breakpoint. */
467 bppy_get_commands (PyObject
*self
, void *closure
)
469 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
470 struct breakpoint
*bp
= self_bp
->bp
;
472 volatile struct gdb_exception except
;
473 struct ui_file
*string_file
;
474 struct cleanup
*chain
;
478 BPPY_REQUIRE_VALID (self_bp
);
480 if (! self_bp
->bp
->commands
)
483 string_file
= mem_fileopen ();
484 chain
= make_cleanup_ui_file_delete (string_file
);
486 ui_out_redirect (current_uiout
, string_file
);
487 TRY_CATCH (except
, RETURN_MASK_ALL
)
489 print_command_lines (current_uiout
, breakpoint_commands (bp
), 0);
491 ui_out_redirect (current_uiout
, NULL
);
492 if (except
.reason
< 0)
495 gdbpy_convert_exception (except
);
499 cmdstr
= ui_file_xstrdup (string_file
, &length
);
500 make_cleanup (xfree
, cmdstr
);
501 result
= PyString_Decode (cmdstr
, strlen (cmdstr
), host_charset (), NULL
);
506 /* Python function to get the breakpoint type. */
508 bppy_get_type (PyObject
*self
, void *closure
)
510 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
512 BPPY_REQUIRE_VALID (self_bp
);
514 return PyInt_FromLong (self_bp
->bp
->type
);
517 /* Python function to get the visibility of the breakpoint. */
520 bppy_get_visibility (PyObject
*self
, void *closure
)
522 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
524 BPPY_REQUIRE_VALID (self_bp
);
526 if (self_bp
->bp
->number
< 0)
532 /* Python function to determine if the breakpoint is a temporary
536 bppy_get_temporary (PyObject
*self
, void *closure
)
538 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
540 BPPY_REQUIRE_VALID (self_bp
);
542 if (self_bp
->bp
->disposition
== disp_del
543 || self_bp
->bp
->disposition
== disp_del_at_next_stop
)
549 /* Python function to get the breakpoint's number. */
551 bppy_get_number (PyObject
*self
, void *closure
)
553 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
555 BPPY_REQUIRE_VALID (self_bp
);
557 return PyInt_FromLong (self_bp
->number
);
560 /* Python function to get the breakpoint's thread ID. */
562 bppy_get_thread (PyObject
*self
, void *closure
)
564 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
566 BPPY_REQUIRE_VALID (self_bp
);
568 if (self_bp
->bp
->thread
== -1)
571 return PyInt_FromLong (self_bp
->bp
->thread
);
574 /* Python function to get the breakpoint's task ID (in Ada). */
576 bppy_get_task (PyObject
*self
, void *closure
)
578 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
580 BPPY_REQUIRE_VALID (self_bp
);
582 if (self_bp
->bp
->task
== 0)
585 return PyInt_FromLong (self_bp
->bp
->task
);
588 /* Python function to get the breakpoint's hit count. */
590 bppy_get_hit_count (PyObject
*self
, void *closure
)
592 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
594 BPPY_REQUIRE_VALID (self_bp
);
596 return PyInt_FromLong (self_bp
->bp
->hit_count
);
599 /* Python function to get the breakpoint's ignore count. */
601 bppy_get_ignore_count (PyObject
*self
, void *closure
)
603 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
605 BPPY_REQUIRE_VALID (self_bp
);
607 return PyInt_FromLong (self_bp
->bp
->ignore_count
);
610 /* Python function to create a new breakpoint. */
612 bppy_init (PyObject
*self
, PyObject
*args
, PyObject
*kwargs
)
614 static char *keywords
[] = { "spec", "type", "wp_class", "internal",
617 int type
= bp_breakpoint
;
618 int access_type
= hw_write
;
619 PyObject
*internal
= NULL
;
620 PyObject
*temporary
= NULL
;
622 int temporary_bp
= 0;
623 volatile struct gdb_exception except
;
625 if (! PyArg_ParseTupleAndKeywords (args
, kwargs
, "s|iiOO", keywords
,
626 &spec
, &type
, &access_type
,
627 &internal
, &temporary
))
632 internal_bp
= PyObject_IsTrue (internal
);
633 if (internal_bp
== -1)
637 if (temporary
!= NULL
)
639 temporary_bp
= PyObject_IsTrue (temporary
);
640 if (temporary_bp
== -1)
644 bppy_pending_object
= (gdbpy_breakpoint_object
*) self
;
645 bppy_pending_object
->number
= -1;
646 bppy_pending_object
->bp
= NULL
;
648 TRY_CATCH (except
, RETURN_MASK_ALL
)
650 char *copy
= xstrdup (spec
);
651 struct cleanup
*cleanup
= make_cleanup (xfree
, copy
);
657 create_breakpoint (python_gdbarch
,
658 copy
, NULL
, -1, NULL
,
660 temporary_bp
, bp_breakpoint
,
663 &bkpt_breakpoint_ops
,
664 0, 1, internal_bp
, 0);
669 if (access_type
== hw_write
)
670 watch_command_wrapper (copy
, 0, internal_bp
);
671 else if (access_type
== hw_access
)
672 awatch_command_wrapper (copy
, 0, internal_bp
);
673 else if (access_type
== hw_read
)
674 rwatch_command_wrapper (copy
, 0, internal_bp
);
676 error(_("Cannot understand watchpoint access type."));
680 error(_("Do not understand breakpoint type to set."));
683 do_cleanups (cleanup
);
685 if (except
.reason
< 0)
687 PyErr_Format (except
.reason
== RETURN_QUIT
688 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
689 "%s", except
.message
);
693 BPPY_SET_REQUIRE_VALID ((gdbpy_breakpoint_object
*) self
);
700 build_bp_list (struct breakpoint
*b
, void *arg
)
702 PyObject
*list
= arg
;
703 PyObject
*bp
= (PyObject
*) b
->py_bp_object
;
706 /* Not all breakpoints will have a companion Python object.
707 Only breakpoints that were created via bppy_new, or
708 breakpoints that were created externally and are tracked by
709 the Python Scripting API. */
711 iserr
= PyList_Append (list
, bp
);
719 /* Static function to return a tuple holding all breakpoints. */
722 gdbpy_breakpoints (PyObject
*self
, PyObject
*args
)
724 PyObject
*list
, *tuple
;
729 list
= PyList_New (0);
733 /* If iteratre_over_breakpoints returns non NULL it signals an error
734 condition. In that case abandon building the list and return
736 if (iterate_over_breakpoints (build_bp_list
, list
) != NULL
)
742 tuple
= PyList_AsTuple (list
);
748 /* Call the "stop" method (if implemented) in the breakpoint
749 class. If the method returns True, the inferior will be
750 stopped at the breakpoint. Otherwise the inferior will be
751 allowed to continue. */
753 enum ext_lang_bp_stop
754 gdbpy_breakpoint_cond_says_stop (const struct extension_language_defn
*extlang
,
755 struct breakpoint
*b
)
758 struct gdbpy_breakpoint_object
*bp_obj
= b
->py_bp_object
;
759 PyObject
*py_bp
= (PyObject
*) bp_obj
;
760 struct gdbarch
*garch
;
761 struct cleanup
*cleanup
;
764 return EXT_LANG_BP_STOP_UNSET
;
767 garch
= b
->gdbarch
? b
->gdbarch
: get_current_arch ();
768 cleanup
= ensure_python_env (garch
, current_language
);
770 if (bp_obj
->is_finish_bp
)
771 bpfinishpy_pre_stop_hook (bp_obj
);
773 if (PyObject_HasAttrString (py_bp
, stop_func
))
775 PyObject
*result
= PyObject_CallMethod (py_bp
, stop_func
, NULL
);
780 int evaluate
= PyObject_IsTrue (result
);
783 gdbpy_print_stack ();
785 /* If the "stop" function returns False that means
786 the Python breakpoint wants GDB to continue. */
793 gdbpy_print_stack ();
796 if (bp_obj
->is_finish_bp
)
797 bpfinishpy_post_stop_hook (bp_obj
);
799 do_cleanups (cleanup
);
802 return EXT_LANG_BP_STOP_UNSET
;
803 return stop
? EXT_LANG_BP_STOP_YES
: EXT_LANG_BP_STOP_NO
;
806 /* Checks if the "stop" method exists in this breakpoint.
807 Used by condition_command to ensure mutual exclusion of breakpoint
811 gdbpy_breakpoint_has_cond (const struct extension_language_defn
*extlang
,
812 struct breakpoint
*b
)
816 struct gdbarch
*garch
;
817 struct cleanup
*cleanup
;
819 if (b
->py_bp_object
== NULL
)
822 py_bp
= (PyObject
*) b
->py_bp_object
;
823 garch
= b
->gdbarch
? b
->gdbarch
: get_current_arch ();
824 cleanup
= ensure_python_env (garch
, current_language
);
825 has_func
= PyObject_HasAttrString (py_bp
, stop_func
);
826 do_cleanups (cleanup
);
833 /* Event callback functions. */
835 /* Callback that is used when a breakpoint is created. This function
836 will create a new Python breakpoint object. */
838 gdbpy_breakpoint_created (struct breakpoint
*bp
)
840 gdbpy_breakpoint_object
*newbp
;
841 PyGILState_STATE state
;
843 if (bp
->number
< 0 && bppy_pending_object
== NULL
)
846 if (bp
->type
!= bp_breakpoint
847 && bp
->type
!= bp_watchpoint
848 && bp
->type
!= bp_hardware_watchpoint
849 && bp
->type
!= bp_read_watchpoint
850 && bp
->type
!= bp_access_watchpoint
)
853 state
= PyGILState_Ensure ();
855 if (bppy_pending_object
)
857 newbp
= bppy_pending_object
;
858 bppy_pending_object
= NULL
;
861 newbp
= PyObject_New (gdbpy_breakpoint_object
, &breakpoint_object_type
);
864 newbp
->number
= bp
->number
;
866 newbp
->bp
->py_bp_object
= newbp
;
867 newbp
->is_finish_bp
= 0;
873 PyErr_SetString (PyExc_RuntimeError
,
874 _("Error while creating breakpoint from GDB."));
875 gdbpy_print_stack ();
878 PyGILState_Release (state
);
881 /* Callback that is used when a breakpoint is deleted. This will
882 invalidate the corresponding Python object. */
884 gdbpy_breakpoint_deleted (struct breakpoint
*b
)
887 PyGILState_STATE state
;
888 struct breakpoint
*bp
= NULL
;
889 gdbpy_breakpoint_object
*bp_obj
;
891 state
= PyGILState_Ensure ();
892 bp
= get_breakpoint (num
);
895 bp_obj
= bp
->py_bp_object
;
903 PyGILState_Release (state
);
908 /* Initialize the Python breakpoint code. */
910 gdbpy_initialize_breakpoints (void)
914 breakpoint_object_type
.tp_new
= PyType_GenericNew
;
915 if (PyType_Ready (&breakpoint_object_type
) < 0)
918 if (gdb_pymodule_addobject (gdb_module
, "Breakpoint",
919 (PyObject
*) &breakpoint_object_type
) < 0)
922 observer_attach_breakpoint_created (gdbpy_breakpoint_created
);
923 observer_attach_breakpoint_deleted (gdbpy_breakpoint_deleted
);
925 /* Add breakpoint types constants. */
926 for (i
= 0; pybp_codes
[i
].name
; ++i
)
928 if (PyModule_AddIntConstant (gdb_module
,
929 /* Cast needed for Python 2.4. */
930 (char *) pybp_codes
[i
].name
,
931 pybp_codes
[i
].code
) < 0)
935 /* Add watchpoint types constants. */
936 for (i
= 0; pybp_watch_types
[i
].name
; ++i
)
938 if (PyModule_AddIntConstant (gdb_module
,
939 /* Cast needed for Python 2.4. */
940 (char *) pybp_watch_types
[i
].name
,
941 pybp_watch_types
[i
].code
) < 0)
950 /* Helper function that overrides this Python object's
951 PyObject_GenericSetAttr to allow extra validation of the attribute
955 local_setattro (PyObject
*self
, PyObject
*name
, PyObject
*v
)
957 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
958 char *attr
= python_string_to_host_string (name
);
963 /* If the attribute trying to be set is the "stop" method,
964 but we already have a condition set in the CLI or other extension
965 language, disallow this operation. */
966 if (strcmp (attr
, stop_func
) == 0)
968 const struct extension_language_defn
*extlang
= NULL
;
970 if (obj
->bp
->cond_string
!= NULL
)
971 extlang
= get_ext_lang_defn (EXT_LANG_GDB
);
973 extlang
= get_breakpoint_cond_ext_lang (obj
->bp
, EXT_LANG_PYTHON
);
980 = xstrprintf (_("Only one stop condition allowed. There is"
981 " currently a %s stop condition defined for"
982 " this breakpoint."),
983 ext_lang_capitalized_name (extlang
));
984 PyErr_SetString (PyExc_RuntimeError
, error_text
);
992 return PyObject_GenericSetAttr ((PyObject
*)self
, name
, v
);
995 static PyGetSetDef breakpoint_object_getset
[] = {
996 { "enabled", bppy_get_enabled
, bppy_set_enabled
,
997 "Boolean telling whether the breakpoint is enabled.", NULL
},
998 { "silent", bppy_get_silent
, bppy_set_silent
,
999 "Boolean telling whether the breakpoint is silent.", NULL
},
1000 { "thread", bppy_get_thread
, bppy_set_thread
,
1001 "Thread ID for the breakpoint.\n\
1002 If the value is a thread ID (integer), then this is a thread-specific breakpoint.\n\
1003 If the value is None, then this breakpoint is not thread-specific.\n\
1004 No other type of value can be used.", NULL
},
1005 { "task", bppy_get_task
, bppy_set_task
,
1006 "Thread ID for the breakpoint.\n\
1007 If the value is a task ID (integer), then this is an Ada task-specific breakpoint.\n\
1008 If the value is None, then this breakpoint is not task-specific.\n\
1009 No other type of value can be used.", NULL
},
1010 { "ignore_count", bppy_get_ignore_count
, bppy_set_ignore_count
,
1011 "Number of times this breakpoint should be automatically continued.",
1013 { "number", bppy_get_number
, NULL
,
1014 "Breakpoint's number assigned by GDB.", NULL
},
1015 { "hit_count", bppy_get_hit_count
, bppy_set_hit_count
,
1016 "Number of times the breakpoint has been hit.\n\
1017 Can be set to zero to clear the count. No other value is valid\n\
1018 when setting this property.", NULL
},
1019 { "location", bppy_get_location
, NULL
,
1020 "Location of the breakpoint, as specified by the user.", NULL
},
1021 { "expression", bppy_get_expression
, NULL
,
1022 "Expression of the breakpoint, as specified by the user.", NULL
},
1023 { "condition", bppy_get_condition
, bppy_set_condition
,
1024 "Condition of the breakpoint, as specified by the user,\
1025 or None if no condition set."},
1026 { "commands", bppy_get_commands
, NULL
,
1027 "Commands of the breakpoint, as specified by the user."},
1028 { "type", bppy_get_type
, NULL
,
1029 "Type of breakpoint."},
1030 { "visible", bppy_get_visibility
, NULL
,
1031 "Whether the breakpoint is visible to the user."},
1032 { "temporary", bppy_get_temporary
, NULL
,
1033 "Whether this breakpoint is a temporary breakpoint."},
1034 { NULL
} /* Sentinel. */
1037 static PyMethodDef breakpoint_object_methods
[] =
1039 { "is_valid", bppy_is_valid
, METH_NOARGS
,
1040 "Return true if this breakpoint is valid, false if not." },
1041 { "delete", bppy_delete_breakpoint
, METH_NOARGS
,
1042 "Delete the underlying GDB breakpoint." },
1043 { NULL
} /* Sentinel. */
1046 PyTypeObject breakpoint_object_type
=
1048 PyVarObject_HEAD_INIT (NULL
, 0)
1049 "gdb.Breakpoint", /*tp_name*/
1050 sizeof (gdbpy_breakpoint_object
), /*tp_basicsize*/
1059 0, /*tp_as_sequence*/
1060 0, /*tp_as_mapping*/
1065 (setattrofunc
)local_setattro
, /*tp_setattro */
1067 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1068 "GDB breakpoint object", /* tp_doc */
1069 0, /* tp_traverse */
1071 0, /* tp_richcompare */
1072 0, /* tp_weaklistoffset */
1074 0, /* tp_iternext */
1075 breakpoint_object_methods
, /* tp_methods */
1077 breakpoint_object_getset
, /* tp_getset */
1080 0, /* tp_descr_get */
1081 0, /* tp_descr_set */
1082 0, /* tp_dictoffset */
1083 bppy_init
, /* tp_init */