1 /* Python interface to breakpoints
3 Copyright (C) 2008-2015 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"
34 /* Number of live breakpoints. */
37 /* Variables used to pass information between the Breakpoint
38 constructor and the breakpoint-created hook function. */
39 gdbpy_breakpoint_object
*bppy_pending_object
;
41 /* Function that is called when a Python condition is evaluated. */
42 static char * const stop_func
= "stop";
44 /* This is used to initialize various gdb.bp_* constants. */
53 /* Entries related to the type of user set breakpoints. */
54 static struct pybp_code pybp_codes
[] =
56 { "BP_NONE", bp_none
},
57 { "BP_BREAKPOINT", bp_breakpoint
},
58 { "BP_WATCHPOINT", bp_watchpoint
},
59 { "BP_HARDWARE_WATCHPOINT", bp_hardware_watchpoint
},
60 { "BP_READ_WATCHPOINT", bp_read_watchpoint
},
61 { "BP_ACCESS_WATCHPOINT", bp_access_watchpoint
},
62 {NULL
} /* Sentinel. */
65 /* Entries related to the type of watchpoint. */
66 static struct pybp_code pybp_watch_types
[] =
68 { "WP_READ", hw_read
},
69 { "WP_WRITE", hw_write
},
70 { "WP_ACCESS", hw_access
},
71 {NULL
} /* Sentinel. */
74 /* Python function which checks the validity of a breakpoint object. */
76 bppy_is_valid (PyObject
*self
, PyObject
*args
)
78 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
85 /* Python function to test whether or not the breakpoint is enabled. */
87 bppy_get_enabled (PyObject
*self
, void *closure
)
89 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
91 BPPY_REQUIRE_VALID (self_bp
);
94 if (self_bp
->bp
->enable_state
== bp_enabled
)
99 /* Python function to test whether or not the breakpoint is silent. */
101 bppy_get_silent (PyObject
*self
, void *closure
)
103 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
105 BPPY_REQUIRE_VALID (self_bp
);
106 if (self_bp
->bp
->silent
)
111 /* Python function to set the enabled state of a breakpoint. */
113 bppy_set_enabled (PyObject
*self
, PyObject
*newvalue
, void *closure
)
115 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
117 volatile struct gdb_exception except
;
119 BPPY_SET_REQUIRE_VALID (self_bp
);
121 if (newvalue
== NULL
)
123 PyErr_SetString (PyExc_TypeError
,
124 _("Cannot delete `enabled' attribute."));
128 else if (! PyBool_Check (newvalue
))
130 PyErr_SetString (PyExc_TypeError
,
131 _("The value of `enabled' must be a boolean."));
135 cmp
= PyObject_IsTrue (newvalue
);
139 TRY_CATCH (except
, RETURN_MASK_ALL
)
142 enable_breakpoint (self_bp
->bp
);
144 disable_breakpoint (self_bp
->bp
);
146 GDB_PY_SET_HANDLE_EXCEPTION (except
);
151 /* Python function to set the 'silent' state of a breakpoint. */
153 bppy_set_silent (PyObject
*self
, PyObject
*newvalue
, void *closure
)
155 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
158 BPPY_SET_REQUIRE_VALID (self_bp
);
160 if (newvalue
== NULL
)
162 PyErr_SetString (PyExc_TypeError
,
163 _("Cannot delete `silent' attribute."));
166 else if (! PyBool_Check (newvalue
))
168 PyErr_SetString (PyExc_TypeError
,
169 _("The value of `silent' must be a boolean."));
173 cmp
= PyObject_IsTrue (newvalue
);
177 breakpoint_set_silent (self_bp
->bp
, cmp
);
182 /* Python function to set the thread of a breakpoint. */
184 bppy_set_thread (PyObject
*self
, PyObject
*newvalue
, void *closure
)
186 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
189 BPPY_SET_REQUIRE_VALID (self_bp
);
191 if (newvalue
== NULL
)
193 PyErr_SetString (PyExc_TypeError
,
194 _("Cannot delete `thread' attribute."));
197 else if (PyInt_Check (newvalue
))
199 if (! gdb_py_int_as_long (newvalue
, &id
))
202 if (! valid_thread_id (id
))
204 PyErr_SetString (PyExc_RuntimeError
,
205 _("Invalid thread ID."));
209 else if (newvalue
== Py_None
)
213 PyErr_SetString (PyExc_TypeError
,
214 _("The value of `thread' must be an integer or None."));
218 breakpoint_set_thread (self_bp
->bp
, id
);
223 /* Python function to set the (Ada) task of a breakpoint. */
225 bppy_set_task (PyObject
*self
, PyObject
*newvalue
, void *closure
)
227 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
230 volatile struct gdb_exception except
;
232 BPPY_SET_REQUIRE_VALID (self_bp
);
234 if (newvalue
== NULL
)
236 PyErr_SetString (PyExc_TypeError
,
237 _("Cannot delete `task' attribute."));
240 else if (PyInt_Check (newvalue
))
242 if (! gdb_py_int_as_long (newvalue
, &id
))
245 TRY_CATCH (except
, RETURN_MASK_ALL
)
247 valid_id
= valid_task_id (id
);
249 GDB_PY_SET_HANDLE_EXCEPTION (except
);
253 PyErr_SetString (PyExc_RuntimeError
,
254 _("Invalid task ID."));
258 else if (newvalue
== Py_None
)
262 PyErr_SetString (PyExc_TypeError
,
263 _("The value of `task' must be an integer or None."));
267 breakpoint_set_task (self_bp
->bp
, id
);
272 /* Python function which deletes the underlying GDB breakpoint. This
273 triggers the breakpoint_deleted observer which will call
274 gdbpy_breakpoint_deleted; that function cleans up the Python
278 bppy_delete_breakpoint (PyObject
*self
, PyObject
*args
)
280 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
281 volatile struct gdb_exception except
;
283 BPPY_REQUIRE_VALID (self_bp
);
285 TRY_CATCH (except
, RETURN_MASK_ALL
)
287 delete_breakpoint (self_bp
->bp
);
289 GDB_PY_HANDLE_EXCEPTION (except
);
295 /* Python function to set the ignore count of a breakpoint. */
297 bppy_set_ignore_count (PyObject
*self
, PyObject
*newvalue
, void *closure
)
299 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
301 volatile struct gdb_exception except
;
303 BPPY_SET_REQUIRE_VALID (self_bp
);
305 if (newvalue
== NULL
)
307 PyErr_SetString (PyExc_TypeError
,
308 _("Cannot delete `ignore_count' attribute."));
311 else if (! PyInt_Check (newvalue
))
313 PyErr_SetString (PyExc_TypeError
,
314 _("The value of `ignore_count' must be an integer."));
318 if (! gdb_py_int_as_long (newvalue
, &value
))
324 TRY_CATCH (except
, RETURN_MASK_ALL
)
326 set_ignore_count (self_bp
->number
, (int) value
, 0);
328 GDB_PY_SET_HANDLE_EXCEPTION (except
);
333 /* Python function to set the hit count of a breakpoint. */
335 bppy_set_hit_count (PyObject
*self
, PyObject
*newvalue
, void *closure
)
337 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
339 BPPY_SET_REQUIRE_VALID (self_bp
);
341 if (newvalue
== NULL
)
343 PyErr_SetString (PyExc_TypeError
,
344 _("Cannot delete `hit_count' attribute."));
351 if (! gdb_py_int_as_long (newvalue
, &value
))
356 PyErr_SetString (PyExc_AttributeError
,
357 _("The value of `hit_count' must be zero."));
362 self_bp
->bp
->hit_count
= 0;
367 /* Python function to get the location of a breakpoint. */
369 bppy_get_location (PyObject
*self
, void *closure
)
372 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
374 BPPY_REQUIRE_VALID (obj
);
376 if (obj
->bp
->type
!= bp_breakpoint
)
379 str
= obj
->bp
->addr_string
;
383 return PyString_Decode (str
, strlen (str
), host_charset (), NULL
);
386 /* Python function to get the breakpoint expression. */
388 bppy_get_expression (PyObject
*self
, void *closure
)
391 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
392 struct watchpoint
*wp
;
394 BPPY_REQUIRE_VALID (obj
);
396 if (!is_watchpoint (obj
->bp
))
399 wp
= (struct watchpoint
*) obj
->bp
;
401 str
= wp
->exp_string
;
405 return PyString_Decode (str
, strlen (str
), host_charset (), NULL
);
408 /* Python function to get the condition expression of a breakpoint. */
410 bppy_get_condition (PyObject
*self
, void *closure
)
413 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
415 BPPY_REQUIRE_VALID (obj
);
417 str
= obj
->bp
->cond_string
;
421 return PyString_Decode (str
, strlen (str
), host_charset (), NULL
);
424 /* Returns 0 on success. Returns -1 on error, with a python exception set.
428 bppy_set_condition (PyObject
*self
, PyObject
*newvalue
, void *closure
)
431 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
432 volatile struct gdb_exception except
;
434 BPPY_SET_REQUIRE_VALID (self_bp
);
436 if (newvalue
== NULL
)
438 PyErr_SetString (PyExc_TypeError
,
439 _("Cannot delete `condition' attribute."));
442 else if (newvalue
== Py_None
)
446 exp
= python_string_to_host_string (newvalue
);
451 TRY_CATCH (except
, RETURN_MASK_ALL
)
453 set_breakpoint_condition (self_bp
->bp
, exp
, 0);
456 if (newvalue
!= Py_None
)
459 GDB_PY_SET_HANDLE_EXCEPTION (except
);
464 /* Python function to get the commands attached to a breakpoint. */
466 bppy_get_commands (PyObject
*self
, void *closure
)
468 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
469 struct breakpoint
*bp
= self_bp
->bp
;
471 volatile struct gdb_exception except
;
472 struct ui_file
*string_file
;
473 struct cleanup
*chain
;
477 BPPY_REQUIRE_VALID (self_bp
);
479 if (! self_bp
->bp
->commands
)
482 string_file
= mem_fileopen ();
483 chain
= make_cleanup_ui_file_delete (string_file
);
485 ui_out_redirect (current_uiout
, string_file
);
486 TRY_CATCH (except
, RETURN_MASK_ALL
)
488 print_command_lines (current_uiout
, breakpoint_commands (bp
), 0);
490 ui_out_redirect (current_uiout
, NULL
);
491 if (except
.reason
< 0)
494 gdbpy_convert_exception (except
);
498 cmdstr
= ui_file_xstrdup (string_file
, &length
);
499 make_cleanup (xfree
, cmdstr
);
500 result
= PyString_Decode (cmdstr
, strlen (cmdstr
), host_charset (), NULL
);
505 /* Python function to get the breakpoint type. */
507 bppy_get_type (PyObject
*self
, void *closure
)
509 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
511 BPPY_REQUIRE_VALID (self_bp
);
513 return PyInt_FromLong (self_bp
->bp
->type
);
516 /* Python function to get the visibility of the breakpoint. */
519 bppy_get_visibility (PyObject
*self
, void *closure
)
521 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
523 BPPY_REQUIRE_VALID (self_bp
);
525 if (self_bp
->bp
->number
< 0)
531 /* Python function to determine if the breakpoint is a temporary
535 bppy_get_temporary (PyObject
*self
, void *closure
)
537 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
539 BPPY_REQUIRE_VALID (self_bp
);
541 if (self_bp
->bp
->disposition
== disp_del
542 || self_bp
->bp
->disposition
== disp_del_at_next_stop
)
548 /* Python function to get the breakpoint's number. */
550 bppy_get_number (PyObject
*self
, void *closure
)
552 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
554 BPPY_REQUIRE_VALID (self_bp
);
556 return PyInt_FromLong (self_bp
->number
);
559 /* Python function to get the breakpoint's thread ID. */
561 bppy_get_thread (PyObject
*self
, void *closure
)
563 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
565 BPPY_REQUIRE_VALID (self_bp
);
567 if (self_bp
->bp
->thread
== -1)
570 return PyInt_FromLong (self_bp
->bp
->thread
);
573 /* Python function to get the breakpoint's task ID (in Ada). */
575 bppy_get_task (PyObject
*self
, void *closure
)
577 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
579 BPPY_REQUIRE_VALID (self_bp
);
581 if (self_bp
->bp
->task
== 0)
584 return PyInt_FromLong (self_bp
->bp
->task
);
587 /* Python function to get the breakpoint's hit count. */
589 bppy_get_hit_count (PyObject
*self
, void *closure
)
591 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
593 BPPY_REQUIRE_VALID (self_bp
);
595 return PyInt_FromLong (self_bp
->bp
->hit_count
);
598 /* Python function to get the breakpoint's ignore count. */
600 bppy_get_ignore_count (PyObject
*self
, void *closure
)
602 gdbpy_breakpoint_object
*self_bp
= (gdbpy_breakpoint_object
*) self
;
604 BPPY_REQUIRE_VALID (self_bp
);
606 return PyInt_FromLong (self_bp
->bp
->ignore_count
);
609 /* Python function to create a new breakpoint. */
611 bppy_init (PyObject
*self
, PyObject
*args
, PyObject
*kwargs
)
613 static char *keywords
[] = { "spec", "type", "wp_class", "internal",
616 int type
= bp_breakpoint
;
617 int access_type
= hw_write
;
618 PyObject
*internal
= NULL
;
619 PyObject
*temporary
= NULL
;
621 int temporary_bp
= 0;
622 volatile struct gdb_exception except
;
624 if (! PyArg_ParseTupleAndKeywords (args
, kwargs
, "s|iiOO", keywords
,
625 &spec
, &type
, &access_type
,
626 &internal
, &temporary
))
631 internal_bp
= PyObject_IsTrue (internal
);
632 if (internal_bp
== -1)
636 if (temporary
!= NULL
)
638 temporary_bp
= PyObject_IsTrue (temporary
);
639 if (temporary_bp
== -1)
643 bppy_pending_object
= (gdbpy_breakpoint_object
*) self
;
644 bppy_pending_object
->number
= -1;
645 bppy_pending_object
->bp
= NULL
;
647 TRY_CATCH (except
, RETURN_MASK_ALL
)
649 char *copy
= xstrdup (spec
);
650 struct cleanup
*cleanup
= make_cleanup (xfree
, copy
);
656 create_breakpoint (python_gdbarch
,
657 copy
, NULL
, -1, NULL
,
659 temporary_bp
, bp_breakpoint
,
662 &bkpt_breakpoint_ops
,
663 0, 1, internal_bp
, 0);
668 if (access_type
== hw_write
)
669 watch_command_wrapper (copy
, 0, internal_bp
);
670 else if (access_type
== hw_access
)
671 awatch_command_wrapper (copy
, 0, internal_bp
);
672 else if (access_type
== hw_read
)
673 rwatch_command_wrapper (copy
, 0, internal_bp
);
675 error(_("Cannot understand watchpoint access type."));
679 error(_("Do not understand breakpoint type to set."));
682 do_cleanups (cleanup
);
684 if (except
.reason
< 0)
686 PyErr_Format (except
.reason
== RETURN_QUIT
687 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
688 "%s", except
.message
);
692 BPPY_SET_REQUIRE_VALID ((gdbpy_breakpoint_object
*) self
);
699 build_bp_list (struct breakpoint
*b
, void *arg
)
701 PyObject
*list
= arg
;
702 PyObject
*bp
= (PyObject
*) b
->py_bp_object
;
705 /* Not all breakpoints will have a companion Python object.
706 Only breakpoints that were created via bppy_new, or
707 breakpoints that were created externally and are tracked by
708 the Python Scripting API. */
710 iserr
= PyList_Append (list
, bp
);
718 /* Static function to return a tuple holding all breakpoints. */
721 gdbpy_breakpoints (PyObject
*self
, PyObject
*args
)
723 PyObject
*list
, *tuple
;
728 list
= PyList_New (0);
732 /* If iteratre_over_breakpoints returns non NULL it signals an error
733 condition. In that case abandon building the list and return
735 if (iterate_over_breakpoints (build_bp_list
, list
) != NULL
)
741 tuple
= PyList_AsTuple (list
);
747 /* Call the "stop" method (if implemented) in the breakpoint
748 class. If the method returns True, the inferior will be
749 stopped at the breakpoint. Otherwise the inferior will be
750 allowed to continue. */
752 enum ext_lang_bp_stop
753 gdbpy_breakpoint_cond_says_stop (const struct extension_language_defn
*extlang
,
754 struct breakpoint
*b
)
757 struct gdbpy_breakpoint_object
*bp_obj
= b
->py_bp_object
;
758 PyObject
*py_bp
= (PyObject
*) bp_obj
;
759 struct gdbarch
*garch
;
760 struct cleanup
*cleanup
;
763 return EXT_LANG_BP_STOP_UNSET
;
766 garch
= b
->gdbarch
? b
->gdbarch
: get_current_arch ();
767 cleanup
= ensure_python_env (garch
, current_language
);
769 if (bp_obj
->is_finish_bp
)
770 bpfinishpy_pre_stop_hook (bp_obj
);
772 if (PyObject_HasAttrString (py_bp
, stop_func
))
774 PyObject
*result
= PyObject_CallMethod (py_bp
, stop_func
, NULL
);
779 int evaluate
= PyObject_IsTrue (result
);
782 gdbpy_print_stack ();
784 /* If the "stop" function returns False that means
785 the Python breakpoint wants GDB to continue. */
792 gdbpy_print_stack ();
795 if (bp_obj
->is_finish_bp
)
796 bpfinishpy_post_stop_hook (bp_obj
);
798 do_cleanups (cleanup
);
801 return EXT_LANG_BP_STOP_UNSET
;
802 return stop
? EXT_LANG_BP_STOP_YES
: EXT_LANG_BP_STOP_NO
;
805 /* Checks if the "stop" method exists in this breakpoint.
806 Used by condition_command to ensure mutual exclusion of breakpoint
810 gdbpy_breakpoint_has_cond (const struct extension_language_defn
*extlang
,
811 struct breakpoint
*b
)
815 struct gdbarch
*garch
;
816 struct cleanup
*cleanup
;
818 if (b
->py_bp_object
== NULL
)
821 py_bp
= (PyObject
*) b
->py_bp_object
;
822 garch
= b
->gdbarch
? b
->gdbarch
: get_current_arch ();
823 cleanup
= ensure_python_env (garch
, current_language
);
824 has_func
= PyObject_HasAttrString (py_bp
, stop_func
);
825 do_cleanups (cleanup
);
832 /* Event callback functions. */
834 /* Callback that is used when a breakpoint is created. This function
835 will create a new Python breakpoint object. */
837 gdbpy_breakpoint_created (struct breakpoint
*bp
)
839 gdbpy_breakpoint_object
*newbp
;
840 PyGILState_STATE state
;
842 if (bp
->number
< 0 && bppy_pending_object
== NULL
)
845 if (bp
->type
!= bp_breakpoint
846 && bp
->type
!= bp_watchpoint
847 && bp
->type
!= bp_hardware_watchpoint
848 && bp
->type
!= bp_read_watchpoint
849 && bp
->type
!= bp_access_watchpoint
)
852 state
= PyGILState_Ensure ();
854 if (bppy_pending_object
)
856 newbp
= bppy_pending_object
;
857 bppy_pending_object
= NULL
;
860 newbp
= PyObject_New (gdbpy_breakpoint_object
, &breakpoint_object_type
);
863 newbp
->number
= bp
->number
;
865 newbp
->bp
->py_bp_object
= newbp
;
866 newbp
->is_finish_bp
= 0;
872 PyErr_SetString (PyExc_RuntimeError
,
873 _("Error while creating breakpoint from GDB."));
874 gdbpy_print_stack ();
877 PyGILState_Release (state
);
880 /* Callback that is used when a breakpoint is deleted. This will
881 invalidate the corresponding Python object. */
883 gdbpy_breakpoint_deleted (struct breakpoint
*b
)
886 PyGILState_STATE state
;
887 struct breakpoint
*bp
= NULL
;
888 gdbpy_breakpoint_object
*bp_obj
;
890 state
= PyGILState_Ensure ();
891 bp
= get_breakpoint (num
);
894 bp_obj
= bp
->py_bp_object
;
902 PyGILState_Release (state
);
907 /* Initialize the Python breakpoint code. */
909 gdbpy_initialize_breakpoints (void)
913 breakpoint_object_type
.tp_new
= PyType_GenericNew
;
914 if (PyType_Ready (&breakpoint_object_type
) < 0)
917 if (gdb_pymodule_addobject (gdb_module
, "Breakpoint",
918 (PyObject
*) &breakpoint_object_type
) < 0)
921 observer_attach_breakpoint_created (gdbpy_breakpoint_created
);
922 observer_attach_breakpoint_deleted (gdbpy_breakpoint_deleted
);
924 /* Add breakpoint types constants. */
925 for (i
= 0; pybp_codes
[i
].name
; ++i
)
927 if (PyModule_AddIntConstant (gdb_module
,
928 /* Cast needed for Python 2.4. */
929 (char *) pybp_codes
[i
].name
,
930 pybp_codes
[i
].code
) < 0)
934 /* Add watchpoint types constants. */
935 for (i
= 0; pybp_watch_types
[i
].name
; ++i
)
937 if (PyModule_AddIntConstant (gdb_module
,
938 /* Cast needed for Python 2.4. */
939 (char *) pybp_watch_types
[i
].name
,
940 pybp_watch_types
[i
].code
) < 0)
949 /* Helper function that overrides this Python object's
950 PyObject_GenericSetAttr to allow extra validation of the attribute
954 local_setattro (PyObject
*self
, PyObject
*name
, PyObject
*v
)
956 gdbpy_breakpoint_object
*obj
= (gdbpy_breakpoint_object
*) self
;
957 char *attr
= python_string_to_host_string (name
);
962 /* If the attribute trying to be set is the "stop" method,
963 but we already have a condition set in the CLI or other extension
964 language, disallow this operation. */
965 if (strcmp (attr
, stop_func
) == 0)
967 const struct extension_language_defn
*extlang
= NULL
;
969 if (obj
->bp
->cond_string
!= NULL
)
970 extlang
= get_ext_lang_defn (EXT_LANG_GDB
);
972 extlang
= get_breakpoint_cond_ext_lang (obj
->bp
, EXT_LANG_PYTHON
);
979 = xstrprintf (_("Only one stop condition allowed. There is"
980 " currently a %s stop condition defined for"
981 " this breakpoint."),
982 ext_lang_capitalized_name (extlang
));
983 PyErr_SetString (PyExc_RuntimeError
, error_text
);
991 return PyObject_GenericSetAttr ((PyObject
*)self
, name
, v
);
994 static PyGetSetDef breakpoint_object_getset
[] = {
995 { "enabled", bppy_get_enabled
, bppy_set_enabled
,
996 "Boolean telling whether the breakpoint is enabled.", NULL
},
997 { "silent", bppy_get_silent
, bppy_set_silent
,
998 "Boolean telling whether the breakpoint is silent.", NULL
},
999 { "thread", bppy_get_thread
, bppy_set_thread
,
1000 "Thread ID for the breakpoint.\n\
1001 If the value is a thread ID (integer), then this is a thread-specific breakpoint.\n\
1002 If the value is None, then this breakpoint is not thread-specific.\n\
1003 No other type of value can be used.", NULL
},
1004 { "task", bppy_get_task
, bppy_set_task
,
1005 "Thread ID for the breakpoint.\n\
1006 If the value is a task ID (integer), then this is an Ada task-specific breakpoint.\n\
1007 If the value is None, then this breakpoint is not task-specific.\n\
1008 No other type of value can be used.", NULL
},
1009 { "ignore_count", bppy_get_ignore_count
, bppy_set_ignore_count
,
1010 "Number of times this breakpoint should be automatically continued.",
1012 { "number", bppy_get_number
, NULL
,
1013 "Breakpoint's number assigned by GDB.", NULL
},
1014 { "hit_count", bppy_get_hit_count
, bppy_set_hit_count
,
1015 "Number of times the breakpoint has been hit.\n\
1016 Can be set to zero to clear the count. No other value is valid\n\
1017 when setting this property.", NULL
},
1018 { "location", bppy_get_location
, NULL
,
1019 "Location of the breakpoint, as specified by the user.", NULL
},
1020 { "expression", bppy_get_expression
, NULL
,
1021 "Expression of the breakpoint, as specified by the user.", NULL
},
1022 { "condition", bppy_get_condition
, bppy_set_condition
,
1023 "Condition of the breakpoint, as specified by the user,\
1024 or None if no condition set."},
1025 { "commands", bppy_get_commands
, NULL
,
1026 "Commands of the breakpoint, as specified by the user."},
1027 { "type", bppy_get_type
, NULL
,
1028 "Type of breakpoint."},
1029 { "visible", bppy_get_visibility
, NULL
,
1030 "Whether the breakpoint is visible to the user."},
1031 { "temporary", bppy_get_temporary
, NULL
,
1032 "Whether this breakpoint is a temporary breakpoint."},
1033 { NULL
} /* Sentinel. */
1036 static PyMethodDef breakpoint_object_methods
[] =
1038 { "is_valid", bppy_is_valid
, METH_NOARGS
,
1039 "Return true if this breakpoint is valid, false if not." },
1040 { "delete", bppy_delete_breakpoint
, METH_NOARGS
,
1041 "Delete the underlying GDB breakpoint." },
1042 { NULL
} /* Sentinel. */
1045 PyTypeObject breakpoint_object_type
=
1047 PyVarObject_HEAD_INIT (NULL
, 0)
1048 "gdb.Breakpoint", /*tp_name*/
1049 sizeof (gdbpy_breakpoint_object
), /*tp_basicsize*/
1058 0, /*tp_as_sequence*/
1059 0, /*tp_as_mapping*/
1064 (setattrofunc
)local_setattro
, /*tp_setattro */
1066 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1067 "GDB breakpoint object", /* tp_doc */
1068 0, /* tp_traverse */
1070 0, /* tp_richcompare */
1071 0, /* tp_weaklistoffset */
1073 0, /* tp_iternext */
1074 breakpoint_object_methods
, /* tp_methods */
1076 breakpoint_object_getset
, /* tp_getset */
1079 0, /* tp_descr_get */
1080 0, /* tp_descr_set */
1081 0, /* tp_dictoffset */
1082 bppy_init
, /* tp_init */