1 /* Python interface to breakpoints
3 Copyright (C) 2008-2012 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"
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 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 breakpoint_object
*self_bp
= (breakpoint_object
*) self
;
85 /* Python function to test whether or not the breakpoint is enabled. */
87 bppy_get_enabled (PyObject
*self
, void *closure
)
89 breakpoint_object
*self_bp
= (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 breakpoint_object
*self_bp
= (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 breakpoint_object
*self_bp
= (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 breakpoint_object
*self_bp
= (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 breakpoint_object
*self_bp
= (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 breakpoint_object
*self_bp
= (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 breakpoint_object
*self_bp
= (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 breakpoint_object
*self_bp
= (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 breakpoint_object
*self_bp
= (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 breakpoint_object
*obj
= (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 breakpoint_object
*obj
= (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 breakpoint_object
*obj
= (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 breakpoint_object
*self_bp
= (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 breakpoint_object
*self_bp
= (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 GDB_PY_HANDLE_EXCEPTION (except
);
493 cmdstr
= ui_file_xstrdup (string_file
, &length
);
494 make_cleanup (xfree
, cmdstr
);
495 result
= PyString_Decode (cmdstr
, strlen (cmdstr
), host_charset (), NULL
);
500 /* Python function to get the breakpoint type. */
502 bppy_get_type (PyObject
*self
, void *closure
)
504 breakpoint_object
*self_bp
= (breakpoint_object
*) self
;
506 BPPY_REQUIRE_VALID (self_bp
);
508 return PyInt_FromLong (self_bp
->bp
->type
);
511 /* Python function to get the visibility of the breakpoint. */
514 bppy_get_visibility (PyObject
*self
, void *closure
)
516 breakpoint_object
*self_bp
= (breakpoint_object
*) self
;
518 BPPY_REQUIRE_VALID (self_bp
);
520 if (self_bp
->bp
->number
< 0)
526 /* Python function to get the breakpoint's number. */
528 bppy_get_number (PyObject
*self
, void *closure
)
530 breakpoint_object
*self_bp
= (breakpoint_object
*) self
;
532 BPPY_REQUIRE_VALID (self_bp
);
534 return PyInt_FromLong (self_bp
->number
);
537 /* Python function to get the breakpoint's thread ID. */
539 bppy_get_thread (PyObject
*self
, void *closure
)
541 breakpoint_object
*self_bp
= (breakpoint_object
*) self
;
543 BPPY_REQUIRE_VALID (self_bp
);
545 if (self_bp
->bp
->thread
== -1)
548 return PyInt_FromLong (self_bp
->bp
->thread
);
551 /* Python function to get the breakpoint's task ID (in Ada). */
553 bppy_get_task (PyObject
*self
, void *closure
)
555 breakpoint_object
*self_bp
= (breakpoint_object
*) self
;
557 BPPY_REQUIRE_VALID (self_bp
);
559 if (self_bp
->bp
->task
== 0)
562 return PyInt_FromLong (self_bp
->bp
->task
);
565 /* Python function to get the breakpoint's hit count. */
567 bppy_get_hit_count (PyObject
*self
, void *closure
)
569 breakpoint_object
*self_bp
= (breakpoint_object
*) self
;
571 BPPY_REQUIRE_VALID (self_bp
);
573 return PyInt_FromLong (self_bp
->bp
->hit_count
);
576 /* Python function to get the breakpoint's ignore count. */
578 bppy_get_ignore_count (PyObject
*self
, void *closure
)
580 breakpoint_object
*self_bp
= (breakpoint_object
*) self
;
582 BPPY_REQUIRE_VALID (self_bp
);
584 return PyInt_FromLong (self_bp
->bp
->ignore_count
);
587 /* Python function to create a new breakpoint. */
589 bppy_init (PyObject
*self
, PyObject
*args
, PyObject
*kwargs
)
591 static char *keywords
[] = { "spec", "type", "wp_class", "internal", NULL
};
593 int type
= bp_breakpoint
;
594 int access_type
= hw_write
;
595 PyObject
*internal
= NULL
;
597 volatile struct gdb_exception except
;
599 if (! PyArg_ParseTupleAndKeywords (args
, kwargs
, "s|iiO", keywords
,
600 &spec
, &type
, &access_type
, &internal
))
605 internal_bp
= PyObject_IsTrue (internal
);
606 if (internal_bp
== -1)
610 bppy_pending_object
= (breakpoint_object
*) self
;
611 bppy_pending_object
->number
= -1;
612 bppy_pending_object
->bp
= NULL
;
614 TRY_CATCH (except
, RETURN_MASK_ALL
)
616 char *copy
= xstrdup (spec
);
617 struct cleanup
*cleanup
= make_cleanup (xfree
, copy
);
623 create_breakpoint (python_gdbarch
,
629 &bkpt_breakpoint_ops
,
635 if (access_type
== hw_write
)
636 watch_command_wrapper (copy
, 0, internal_bp
);
637 else if (access_type
== hw_access
)
638 awatch_command_wrapper (copy
, 0, internal_bp
);
639 else if (access_type
== hw_read
)
640 rwatch_command_wrapper (copy
, 0, internal_bp
);
642 error(_("Cannot understand watchpoint access type."));
646 error(_("Do not understand breakpoint type to set."));
649 do_cleanups (cleanup
);
651 if (except
.reason
< 0)
653 PyErr_Format (except
.reason
== RETURN_QUIT
654 ? PyExc_KeyboardInterrupt
: PyExc_RuntimeError
,
655 "%s", except
.message
);
659 BPPY_SET_REQUIRE_VALID ((breakpoint_object
*) self
);
666 build_bp_list (struct breakpoint
*b
, void *arg
)
668 PyObject
*list
= arg
;
669 PyObject
*bp
= (PyObject
*) b
->py_bp_object
;
672 /* Not all breakpoints will have a companion Python object.
673 Only breakpoints that were created via bppy_new, or
674 breakpoints that were created externally and are tracked by
675 the Python Scripting API. */
677 iserr
= PyList_Append (list
, bp
);
685 /* Static function to return a tuple holding all breakpoints. */
688 gdbpy_breakpoints (PyObject
*self
, PyObject
*args
)
690 PyObject
*list
, *tuple
;
695 list
= PyList_New (0);
699 /* If iteratre_over_breakpoints returns non NULL it signals an error
700 condition. In that case abandon building the list and return
702 if (iterate_over_breakpoints (build_bp_list
, list
) != NULL
)
708 tuple
= PyList_AsTuple (list
);
714 /* Call the "stop" method (if implemented) in the breakpoint
715 class. If the method returns True, the inferior will be
716 stopped at the breakpoint. Otherwise the inferior will be
717 allowed to continue. */
720 gdbpy_should_stop (struct breakpoint_object
*bp_obj
)
724 PyObject
*py_bp
= (PyObject
*) bp_obj
;
725 struct breakpoint
*b
= bp_obj
->bp
;
726 struct gdbarch
*garch
= b
->gdbarch
? b
->gdbarch
: get_current_arch ();
727 struct cleanup
*cleanup
= ensure_python_env (garch
, current_language
);
729 if (bp_obj
->is_finish_bp
)
730 bpfinishpy_pre_stop_hook (bp_obj
);
732 if (PyObject_HasAttrString (py_bp
, stop_func
))
734 PyObject
*result
= PyObject_CallMethod (py_bp
, stop_func
, NULL
);
738 int evaluate
= PyObject_IsTrue (result
);
741 gdbpy_print_stack ();
743 /* If the "stop" function returns False that means
744 the Python breakpoint wants GDB to continue. */
751 gdbpy_print_stack ();
754 if (bp_obj
->is_finish_bp
)
755 bpfinishpy_post_stop_hook (bp_obj
);
757 do_cleanups (cleanup
);
762 /* Checks if the "stop" method exists in this breakpoint.
763 Used by condition_command to ensure mutual exclusion of breakpoint
767 gdbpy_breakpoint_has_py_cond (struct breakpoint_object
*bp_obj
)
770 PyObject
*py_bp
= (PyObject
*) bp_obj
;
771 struct gdbarch
*garch
= bp_obj
->bp
->gdbarch
? bp_obj
->bp
->gdbarch
:
773 struct cleanup
*cleanup
= ensure_python_env (garch
, current_language
);
776 has_func
= PyObject_HasAttrString (py_bp
, stop_func
);
778 do_cleanups (cleanup
);
785 /* Event callback functions. */
787 /* Callback that is used when a breakpoint is created. This function
788 will create a new Python breakpoint object. */
790 gdbpy_breakpoint_created (struct breakpoint
*bp
)
792 breakpoint_object
*newbp
;
793 PyGILState_STATE state
;
795 if (bp
->number
< 0 && bppy_pending_object
== NULL
)
798 if (bp
->type
!= bp_breakpoint
799 && bp
->type
!= bp_watchpoint
800 && bp
->type
!= bp_hardware_watchpoint
801 && bp
->type
!= bp_read_watchpoint
802 && bp
->type
!= bp_access_watchpoint
)
805 state
= PyGILState_Ensure ();
807 if (bppy_pending_object
)
809 newbp
= bppy_pending_object
;
810 bppy_pending_object
= NULL
;
813 newbp
= PyObject_New (breakpoint_object
, &breakpoint_object_type
);
816 newbp
->number
= bp
->number
;
818 newbp
->bp
->py_bp_object
= newbp
;
819 newbp
->is_finish_bp
= 0;
825 PyErr_SetString (PyExc_RuntimeError
,
826 _("Error while creating breakpoint from GDB."));
827 gdbpy_print_stack ();
830 PyGILState_Release (state
);
833 /* Callback that is used when a breakpoint is deleted. This will
834 invalidate the corresponding Python object. */
836 gdbpy_breakpoint_deleted (struct breakpoint
*b
)
839 PyGILState_STATE state
;
840 struct breakpoint
*bp
= NULL
;
841 breakpoint_object
*bp_obj
;
843 state
= PyGILState_Ensure ();
844 bp
= get_breakpoint (num
);
847 bp_obj
= bp
->py_bp_object
;
855 PyGILState_Release (state
);
860 /* Initialize the Python breakpoint code. */
862 gdbpy_initialize_breakpoints (void)
866 breakpoint_object_type
.tp_new
= PyType_GenericNew
;
867 if (PyType_Ready (&breakpoint_object_type
) < 0)
870 Py_INCREF (&breakpoint_object_type
);
871 PyModule_AddObject (gdb_module
, "Breakpoint",
872 (PyObject
*) &breakpoint_object_type
);
874 observer_attach_breakpoint_created (gdbpy_breakpoint_created
);
875 observer_attach_breakpoint_deleted (gdbpy_breakpoint_deleted
);
877 /* Add breakpoint types constants. */
878 for (i
= 0; pybp_codes
[i
].name
; ++i
)
880 if (PyModule_AddIntConstant (gdb_module
,
881 /* Cast needed for Python 2.4. */
882 (char *) pybp_codes
[i
].name
,
883 pybp_codes
[i
].code
) < 0)
887 /* Add watchpoint types constants. */
888 for (i
= 0; pybp_watch_types
[i
].name
; ++i
)
890 if (PyModule_AddIntConstant (gdb_module
,
891 /* Cast needed for Python 2.4. */
892 (char *) pybp_watch_types
[i
].name
,
893 pybp_watch_types
[i
].code
) < 0)
901 /* Helper function that overrides this Python object's
902 PyObject_GenericSetAttr to allow extra validation of the attribute
906 local_setattro (PyObject
*self
, PyObject
*name
, PyObject
*v
)
908 breakpoint_object
*obj
= (breakpoint_object
*) self
;
909 char *attr
= python_string_to_host_string (name
);
914 /* If the attribute trying to be set is the "stop" method,
915 but we already have a condition set in the CLI, disallow this
917 if (strcmp (attr
, stop_func
) == 0 && obj
->bp
->cond_string
)
920 PyErr_SetString (PyExc_RuntimeError
,
921 _("Cannot set 'stop' method. There is an " \
922 "existing GDB condition attached to the " \
929 return PyObject_GenericSetAttr ((PyObject
*)self
, name
, v
);
932 static PyGetSetDef breakpoint_object_getset
[] = {
933 { "enabled", bppy_get_enabled
, bppy_set_enabled
,
934 "Boolean telling whether the breakpoint is enabled.", NULL
},
935 { "silent", bppy_get_silent
, bppy_set_silent
,
936 "Boolean telling whether the breakpoint is silent.", NULL
},
937 { "thread", bppy_get_thread
, bppy_set_thread
,
938 "Thread ID for the breakpoint.\n\
939 If the value is a thread ID (integer), then this is a thread-specific breakpoint.\n\
940 If the value is None, then this breakpoint is not thread-specific.\n\
941 No other type of value can be used.", NULL
},
942 { "task", bppy_get_task
, bppy_set_task
,
943 "Thread ID for the breakpoint.\n\
944 If the value is a task ID (integer), then this is an Ada task-specific breakpoint.\n\
945 If the value is None, then this breakpoint is not task-specific.\n\
946 No other type of value can be used.", NULL
},
947 { "ignore_count", bppy_get_ignore_count
, bppy_set_ignore_count
,
948 "Number of times this breakpoint should be automatically continued.",
950 { "number", bppy_get_number
, NULL
,
951 "Breakpoint's number assigned by GDB.", NULL
},
952 { "hit_count", bppy_get_hit_count
, bppy_set_hit_count
,
953 "Number of times the breakpoint has been hit.\n\
954 Can be set to zero to clear the count. No other value is valid\n\
955 when setting this property.", NULL
},
956 { "location", bppy_get_location
, NULL
,
957 "Location of the breakpoint, as specified by the user.", NULL
},
958 { "expression", bppy_get_expression
, NULL
,
959 "Expression of the breakpoint, as specified by the user.", NULL
},
960 { "condition", bppy_get_condition
, bppy_set_condition
,
961 "Condition of the breakpoint, as specified by the user,\
962 or None if no condition set."},
963 { "commands", bppy_get_commands
, NULL
,
964 "Commands of the breakpoint, as specified by the user."},
965 { "type", bppy_get_type
, NULL
,
966 "Type of breakpoint."},
967 { "visible", bppy_get_visibility
, NULL
,
968 "Whether the breakpoint is visible to the user."},
969 { NULL
} /* Sentinel. */
972 static PyMethodDef breakpoint_object_methods
[] =
974 { "is_valid", bppy_is_valid
, METH_NOARGS
,
975 "Return true if this breakpoint is valid, false if not." },
976 { "delete", bppy_delete_breakpoint
, METH_NOARGS
,
977 "Delete the underlying GDB breakpoint." },
978 { NULL
} /* Sentinel. */
981 PyTypeObject breakpoint_object_type
=
983 PyObject_HEAD_INIT (NULL
)
985 "gdb.Breakpoint", /*tp_name*/
986 sizeof (breakpoint_object
), /*tp_basicsize*/
995 0, /*tp_as_sequence*/
1001 (setattrofunc
)local_setattro
, /*tp_setattro */
1003 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
, /*tp_flags*/
1004 "GDB breakpoint object", /* tp_doc */
1005 0, /* tp_traverse */
1007 0, /* tp_richcompare */
1008 0, /* tp_weaklistoffset */
1010 0, /* tp_iternext */
1011 breakpoint_object_methods
, /* tp_methods */
1013 breakpoint_object_getset
, /* tp_getset */
1016 0, /* tp_descr_get */
1017 0, /* tp_descr_set */
1018 0, /* tp_dictoffset */
1019 bppy_init
, /* tp_init */