1 /* Python interface to breakpoints
3 Copyright (C) 2008-2016 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)
444 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
445 struct gdb_exception except = exception_none;
447 BPPY_SET_REQUIRE_VALID (self_bp);
449 if (newvalue == NULL)
451 PyErr_SetString (PyExc_TypeError,
452 _("Cannot delete `condition' attribute."));
455 else if (newvalue == Py_None)
459 exp = python_string_to_host_string (newvalue);
466 set_breakpoint_condition (self_bp->bp, exp, 0);
468 CATCH (ex, RETURN_MASK_ALL)
474 if (newvalue != Py_None)
477 GDB_PY_SET_HANDLE_EXCEPTION (except);
482 /* Python function to get the commands attached to a breakpoint. */
484 bppy_get_commands (PyObject *self, void *closure)
486 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
487 struct breakpoint *bp = self_bp->bp;
489 struct ui_file *string_file;
490 struct cleanup *chain;
494 BPPY_REQUIRE_VALID (self_bp);
496 if (! self_bp->bp->commands)
499 string_file = mem_fileopen ();
500 chain = make_cleanup_ui_file_delete (string_file);
502 ui_out_redirect (current_uiout, string_file);
505 print_command_lines (current_uiout, breakpoint_commands (bp), 0);
507 CATCH (except, RETURN_MASK_ALL)
509 ui_out_redirect (current_uiout, NULL);
511 gdbpy_convert_exception (except);
516 ui_out_redirect (current_uiout, NULL);
517 cmdstr = ui_file_xstrdup (string_file, &length);
518 make_cleanup (xfree, cmdstr);
519 result = host_string_to_python_string (cmdstr);
524 /* Python function to get the breakpoint type. */
526 bppy_get_type (PyObject *self, void *closure)
528 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
530 BPPY_REQUIRE_VALID (self_bp);
532 return PyInt_FromLong (self_bp->bp->type);
535 /* Python function to get the visibility of the breakpoint. */
538 bppy_get_visibility (PyObject *self, void *closure)
540 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
542 BPPY_REQUIRE_VALID (self_bp);
544 if (user_breakpoint_p (self_bp->bp))
550 /* Python function to determine if the breakpoint is a temporary
554 bppy_get_temporary (PyObject *self, void *closure)
556 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
558 BPPY_REQUIRE_VALID (self_bp);
560 if (self_bp->bp->disposition == disp_del
561 || self_bp->bp->disposition == disp_del_at_next_stop)
567 /* Python function to determine if the breakpoint is a pending
571 bppy_get_pending (PyObject *self, void *closure)
573 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
575 BPPY_REQUIRE_VALID (self_bp);
577 if (is_watchpoint (self_bp->bp))
579 if (pending_breakpoint_p (self_bp->bp))
585 /* Python function to get the breakpoint's number. */
587 bppy_get_number (PyObject *self, void *closure)
589 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
591 BPPY_REQUIRE_VALID (self_bp);
593 return PyInt_FromLong (self_bp->number);
596 /* Python function to get the breakpoint's thread ID. */
598 bppy_get_thread (PyObject *self, void *closure)
600 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
602 BPPY_REQUIRE_VALID (self_bp);
604 if (self_bp->bp->thread == -1)
607 return PyInt_FromLong (self_bp->bp->thread);
610 /* Python function to get the breakpoint's task ID (in Ada). */
612 bppy_get_task (PyObject *self, void *closure)
614 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
616 BPPY_REQUIRE_VALID (self_bp);
618 if (self_bp->bp->task == 0)
621 return PyInt_FromLong (self_bp->bp->task);
624 /* Python function to get the breakpoint's hit count. */
626 bppy_get_hit_count (PyObject *self, void *closure)
628 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
630 BPPY_REQUIRE_VALID (self_bp);
632 return PyInt_FromLong (self_bp->bp->hit_count);
635 /* Python function to get the breakpoint's ignore count. */
637 bppy_get_ignore_count (PyObject *self, void *closure)
639 gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
641 BPPY_REQUIRE_VALID (self_bp);
643 return PyInt_FromLong (self_bp->bp->ignore_count);
646 /* Python function to create a new breakpoint. */
648 bppy_init (PyObject *self, PyObject *args, PyObject *kwargs)
650 static char *keywords[] = { "spec", "type", "wp_class", "internal",
653 int type = bp_breakpoint;
654 int access_type = hw_write;
655 PyObject *internal = NULL;
656 PyObject *temporary = NULL;
658 int temporary_bp = 0;
660 if (! PyArg_ParseTupleAndKeywords (args, kwargs, "s|iiOO", keywords,
661 &spec, &type, &access_type,
662 &internal, &temporary))
667 internal_bp = PyObject_IsTrue (internal);
668 if (internal_bp == -1)
672 if (temporary != NULL)
674 temporary_bp = PyObject_IsTrue (temporary);
675 if (temporary_bp == -1)
679 bppy_pending_object = (gdbpy_breakpoint_object *) self;
680 bppy_pending_object->number = -1;
681 bppy_pending_object->bp = NULL;
685 char *copy = xstrdup (skip_spaces_const (spec));
686 struct cleanup *cleanup = make_cleanup (xfree, copy);
692 struct event_location *location;
695 = string_to_event_location_basic (©, current_language);
696 make_cleanup_delete_event_location (location);
697 create_breakpoint (python_gdbarch,
698 location, NULL, -1, NULL,
700 temporary_bp, bp_breakpoint,
703 &bkpt_breakpoint_ops,
704 0, 1, internal_bp, 0);
709 if (access_type == hw_write)
710 watch_command_wrapper (copy, 0, internal_bp);
711 else if (access_type == hw_access)
712 awatch_command_wrapper (copy, 0, internal_bp);
713 else if (access_type == hw_read)
714 rwatch_command_wrapper (copy, 0, internal_bp);
716 error(_("Cannot understand watchpoint access type."));
720 error(_("Do not understand breakpoint type to set."));
723 do_cleanups (cleanup);
725 CATCH (except, RETURN_MASK_ALL)
727 bppy_pending_object = NULL;
728 PyErr_Format (except.reason == RETURN_QUIT
729 ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
730 "%s", except.message);
735 BPPY_SET_REQUIRE_VALID ((gdbpy_breakpoint_object *) self);
742 build_bp_list (struct breakpoint *b, void *arg)
744 PyObject *list = (PyObject *) arg;
745 PyObject *bp = (PyObject *) b->py_bp_object;
748 /* Not all breakpoints will have a companion Python object.
749 Only breakpoints that were created via bppy_new, or
750 breakpoints that were created externally and are tracked by
751 the Python Scripting API. */
753 iserr = PyList_Append (list, bp);
761 /* Static function to return a tuple holding all breakpoints. */
764 gdbpy_breakpoints (PyObject *self, PyObject *args)
766 PyObject *list, *tuple;
769 return PyTuple_New (0);
771 list = PyList_New (0);
775 /* If iterate_over_breakpoints returns non NULL it signals an error
776 condition. In that case abandon building the list and return
778 if (iterate_over_breakpoints (build_bp_list, list) != NULL)
784 tuple = PyList_AsTuple (list);
790 /* Call the "stop" method (if implemented) in the breakpoint
791 class. If the method returns True, the inferior will be
792 stopped at the breakpoint. Otherwise the inferior will be
793 allowed to continue. */
795 enum ext_lang_bp_stop
796 gdbpy_breakpoint_cond_says_stop (const struct extension_language_defn *extlang,
797 struct breakpoint *b)
800 struct gdbpy_breakpoint_object *bp_obj = b->py_bp_object;
801 PyObject *py_bp = (PyObject *) bp_obj;
802 struct gdbarch *garch;
803 struct cleanup *cleanup;
806 return EXT_LANG_BP_STOP_UNSET;
809 garch = b->gdbarch ? b->gdbarch : get_current_arch ();
810 cleanup = ensure_python_env (garch, current_language);
812 if (bp_obj->is_finish_bp)
813 bpfinishpy_pre_stop_hook (bp_obj);
815 if (PyObject_HasAttrString (py_bp, stop_func))
817 PyObject *result = PyObject_CallMethod (py_bp, stop_func, NULL);
822 int evaluate = PyObject_IsTrue (result);
825 gdbpy_print_stack ();
827 /* If the "stop" function returns False that means
828 the Python breakpoint wants GDB to continue. */
835 gdbpy_print_stack ();
838 if (bp_obj->is_finish_bp)
839 bpfinishpy_post_stop_hook (bp_obj);
841 do_cleanups (cleanup);
844 return EXT_LANG_BP_STOP_UNSET;
845 return stop ? EXT_LANG_BP_STOP_YES : EXT_LANG_BP_STOP_NO;
848 /* Checks if the "stop" method exists in this breakpoint.
849 Used by condition_command to ensure mutual exclusion of breakpoint
853 gdbpy_breakpoint_has_cond (const struct extension_language_defn *extlang,
854 struct breakpoint *b)
858 struct gdbarch *garch;
859 struct cleanup *cleanup;
861 if (b->py_bp_object == NULL)
864 py_bp = (PyObject *) b->py_bp_object;
865 garch = b->gdbarch ? b->gdbarch : get_current_arch ();
866 cleanup = ensure_python_env (garch, current_language);
867 has_func = PyObject_HasAttrString (py_bp, stop_func);
868 do_cleanups (cleanup);
875 /* Event callback functions. */
877 /* Callback that is used when a breakpoint is created. This function
878 will create a new Python breakpoint object. */
880 gdbpy_breakpoint_created (struct breakpoint *bp)
882 gdbpy_breakpoint_object *newbp;
883 PyGILState_STATE state;
885 if (!user_breakpoint_p (bp) && bppy_pending_object == NULL)
888 if (bp->type != bp_breakpoint
889 && bp->type != bp_watchpoint
890 && bp->type != bp_hardware_watchpoint
891 && bp->type != bp_read_watchpoint
892 && bp->type != bp_access_watchpoint)
895 state = PyGILState_Ensure ();
897 if (bppy_pending_object)
899 newbp = bppy_pending_object;
900 bppy_pending_object = NULL;
903 newbp = PyObject_New (gdbpy_breakpoint_object, &breakpoint_object_type);
906 newbp->number = bp->number;
908 newbp->bp->py_bp_object = newbp;
909 newbp->is_finish_bp = 0;
915 PyErr_SetString (PyExc_RuntimeError,
916 _("Error while creating breakpoint from GDB."));
917 gdbpy_print_stack ();
920 if (!evregpy_no_listeners_p (gdb_py_events.breakpoint_created))
923 if (evpy_emit_event ((PyObject *) newbp,
924 gdb_py_events.breakpoint_created) < 0)
925 gdbpy_print_stack ();
928 PyGILState_Release (state);
931 /* Callback that is used when a breakpoint is deleted. This will
932 invalidate the corresponding Python object. */
934 gdbpy_breakpoint_deleted (struct breakpoint *b)
937 PyGILState_STATE state;
938 struct breakpoint *bp = NULL;
939 gdbpy_breakpoint_object *bp_obj;
941 state = PyGILState_Ensure ();
942 bp = get_breakpoint (num);
945 bp_obj = bp->py_bp_object;
948 if (!evregpy_no_listeners_p (gdb_py_events.breakpoint_deleted))
950 PyObject *bp_obj_alias = (PyObject *) bp_obj;
952 Py_INCREF (bp_obj_alias);
953 if (evpy_emit_event (bp_obj_alias,
954 gdb_py_events.breakpoint_deleted) < 0)
955 gdbpy_print_stack ();
963 PyGILState_Release (state);
966 /* Callback that is used when a breakpoint is modified. */
969 gdbpy_breakpoint_modified (struct breakpoint *b)
972 PyGILState_STATE state;
973 struct breakpoint *bp = NULL;
974 gdbpy_breakpoint_object *bp_obj;
976 state = PyGILState_Ensure ();
977 bp = get_breakpoint (num);
980 PyObject *bp_obj = (PyObject *) bp->py_bp_object;
983 if (!evregpy_no_listeners_p (gdb_py_events.breakpoint_modified))
986 if (evpy_emit_event (bp_obj,
987 gdb_py_events.breakpoint_modified) < 0)
988 gdbpy_print_stack ();
992 PyGILState_Release (state);
997 /* Initialize the Python breakpoint code. */
999 gdbpy_initialize_breakpoints (void)
1003 breakpoint_object_type.tp_new = PyType_GenericNew;
1004 if (PyType_Ready (&breakpoint_object_type) < 0)
1007 if (gdb_pymodule_addobject (gdb_module, "Breakpoint",
1008 (PyObject *) &breakpoint_object_type) < 0)
1011 observer_attach_breakpoint_created (gdbpy_breakpoint_created);
1012 observer_attach_breakpoint_deleted (gdbpy_breakpoint_deleted);
1013 observer_attach_breakpoint_modified (gdbpy_breakpoint_modified);
1015 /* Add breakpoint types constants. */
1016 for (i = 0; pybp_codes[i].name; ++i)
1018 if (PyModule_AddIntConstant (gdb_module,
1019 /* Cast needed for Python 2.4. */
1020 (char *) pybp_codes[i].name,
1021 pybp_codes[i].code) < 0)
1025 /* Add watchpoint types constants. */
1026 for (i = 0; pybp_watch_types[i].name; ++i)
1028 if (PyModule_AddIntConstant (gdb_module,
1029 /* Cast needed for Python 2.4. */
1030 (char *) pybp_watch_types[i].name,
1031 pybp_watch_types[i].code) < 0)
1040 /* Helper function that overrides this Python object's
1041 PyObject_GenericSetAttr to allow extra validation of the attribute
1045 local_setattro (PyObject *self, PyObject *name, PyObject *v)
1047 gdbpy_breakpoint_object *obj = (gdbpy_breakpoint_object *) self;
1048 char *attr = python_string_to_host_string (name);
1053 /* If the attribute trying to be set is the "stop" method,
1054 but we already have a condition set in the CLI or other extension
1055 language, disallow this operation. */
1056 if (strcmp (attr, stop_func) == 0)
1058 const struct extension_language_defn *extlang = NULL;
1060 if (obj->bp->cond_string != NULL)
1061 extlang = get_ext_lang_defn (EXT_LANG_GDB);
1062 if (extlang == NULL)
1063 extlang = get_breakpoint_cond_ext_lang (obj->bp, EXT_LANG_PYTHON);
1064 if (extlang != NULL)
1070 = xstrprintf (_("Only one stop condition allowed. There is"
1071 " currently a %s stop condition defined for"
1072 " this breakpoint."),
1073 ext_lang_capitalized_name (extlang));
1074 PyErr_SetString (PyExc_RuntimeError, error_text);
1082 return PyObject_GenericSetAttr ((PyObject *)self, name, v);
1085 static PyGetSetDef breakpoint_object_getset[] = {
1086 { "enabled", bppy_get_enabled, bppy_set_enabled,
1087 "Boolean telling whether the breakpoint is enabled.", NULL },
1088 { "silent", bppy_get_silent, bppy_set_silent,
1089 "Boolean telling whether the breakpoint is silent.", NULL },
1090 { "thread", bppy_get_thread, bppy_set_thread,
1091 "Thread ID for the breakpoint.\n\
1092 If the value is a thread ID (integer), then this is a thread-specific breakpoint.\n\
1093 If the value is None, then this breakpoint is not thread-specific.\n\
1094 No other type of value can be used.", NULL },
1095 { "task", bppy_get_task, bppy_set_task,
1096 "Thread ID for the breakpoint.\n\
1097 If the value is a task ID (integer), then this is an Ada task-specific breakpoint.\n\
1098 If the value is None, then this breakpoint is not task-specific.\n\
1099 No other type of value can be used.", NULL },
1100 { "ignore_count", bppy_get_ignore_count, bppy_set_ignore_count,
1101 "Number of times this breakpoint should be automatically continued.",
1103 { "number", bppy_get_number, NULL,
1104 "Breakpoint's number assigned by GDB.", NULL },
1105 { "hit_count", bppy_get_hit_count, bppy_set_hit_count,
1106 "Number of times the breakpoint has been hit.\n\
1107 Can be set to zero to clear the count. No other value is valid\n\
1108 when setting this property.", NULL },
1109 { "location", bppy_get_location, NULL,
1110 "Location of the breakpoint, as specified by the user.", NULL},
1111 { "expression", bppy_get_expression, NULL,
1112 "Expression of the breakpoint, as specified by the user.", NULL},
1113 { "condition", bppy_get_condition, bppy_set_condition,
1114 "Condition of the breakpoint, as specified by the user,\
1115 or None if no condition set."},
1116 { "commands", bppy_get_commands, NULL,
1117 "Commands of the breakpoint, as specified by the user."},
1118 { "type", bppy_get_type, NULL,
1119 "Type of breakpoint."},
1120 { "visible", bppy_get_visibility, NULL,
1121 "Whether the breakpoint is visible to the user."},
1122 { "temporary", bppy_get_temporary, NULL,
1123 "Whether this breakpoint is a temporary breakpoint."},
1124 { "pending", bppy_get_pending, NULL,
1125 "Whether this breakpoint is a pending breakpoint."},
1126 { NULL } /* Sentinel. */
1129 static PyMethodDef breakpoint_object_methods[] =
1131 { "is_valid", bppy_is_valid, METH_NOARGS,
1132 "Return true if this breakpoint is valid, false if not." },
1133 { "delete", bppy_delete_breakpoint, METH_NOARGS,
1134 "Delete the underlying GDB breakpoint." },
1135 { NULL } /* Sentinel. */
1138 PyTypeObject breakpoint_object_type =
1140 PyVarObject_HEAD_INIT (NULL, 0)
1141 "gdb.Breakpoint", /*tp_name*/
1142 sizeof (gdbpy_breakpoint_object), /*tp_basicsize*/
1151 0, /*tp_as_sequence*/
1152 0, /*tp_as_mapping*/
1157 (setattrofunc)local_setattro, /*tp_setattro */
1159 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
1160 "GDB breakpoint object", /* tp_doc */
1161 0, /* tp_traverse */
1163 0, /* tp_richcompare */
1164 0, /* tp_weaklistoffset */
1166 0, /* tp_iternext */
1167 breakpoint_object_methods, /* tp_methods */
1169 breakpoint_object_getset, /* tp_getset */
1172 0, /* tp_descr_get */
1173 0, /* tp_descr_set */
1174 0, /* tp_dictoffset */
1175 bppy_init, /* tp_init */