/* Python interface to breakpoints
- Copyright (C) 2008-2013 Free Software Foundation, Inc.
+ Copyright (C) 2008-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include "defs.h"
#include "value.h"
-#include "exceptions.h"
#include "python-internal.h"
#include "python.h"
#include "charset.h"
#include "breakpoint.h"
#include "gdbcmd.h"
#include "gdbthread.h"
-#include "observer.h"
+#include "observable.h"
#include "cli/cli-script.h"
#include "ada-lang.h"
#include "arch-utils.h"
#include "language.h"
+#include "location.h"
+#include "py-event.h"
+#include "linespec.h"
/* Number of live breakpoints. */
static int bppy_live;
gdbpy_breakpoint_object *bppy_pending_object;
/* Function that is called when a Python condition is evaluated. */
-static char * const stop_func = "stop";
+static const char stop_func[] = "stop";
/* This is used to initialize various gdb.bp_* constants. */
struct pybp_code
{
gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
int cmp;
- volatile struct gdb_exception except;
BPPY_SET_REQUIRE_VALID (self_bp);
if (newvalue == NULL)
{
- PyErr_SetString (PyExc_TypeError,
+ PyErr_SetString (PyExc_TypeError,
_("Cannot delete `enabled' attribute."));
return -1;
if (cmp < 0)
return -1;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
if (cmp == 1)
enable_breakpoint (self_bp->bp);
else
disable_breakpoint (self_bp->bp);
}
- GDB_PY_SET_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_SET_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
return 0;
}
if (newvalue == NULL)
{
- PyErr_SetString (PyExc_TypeError,
+ PyErr_SetString (PyExc_TypeError,
_("Cannot delete `silent' attribute."));
return -1;
}
if (newvalue == NULL)
{
- PyErr_SetString (PyExc_TypeError,
+ PyErr_SetString (PyExc_TypeError,
_("Cannot delete `thread' attribute."));
return -1;
}
if (! gdb_py_int_as_long (newvalue, &id))
return -1;
- if (! valid_thread_id (id))
+ if (!valid_global_thread_id (id))
{
- PyErr_SetString (PyExc_RuntimeError,
+ PyErr_SetString (PyExc_RuntimeError,
_("Invalid thread ID."));
return -1;
}
gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
long id;
int valid_id = 0;
- volatile struct gdb_exception except;
BPPY_SET_REQUIRE_VALID (self_bp);
if (newvalue == NULL)
{
- PyErr_SetString (PyExc_TypeError,
+ PyErr_SetString (PyExc_TypeError,
_("Cannot delete `task' attribute."));
return -1;
}
if (! gdb_py_int_as_long (newvalue, &id))
return -1;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
valid_id = valid_task_id (id);
}
- GDB_PY_SET_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_SET_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
if (! valid_id)
{
- PyErr_SetString (PyExc_RuntimeError,
+ PyErr_SetString (PyExc_RuntimeError,
_("Invalid task ID."));
return -1;
}
bppy_delete_breakpoint (PyObject *self, PyObject *args)
{
gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
- volatile struct gdb_exception except;
BPPY_REQUIRE_VALID (self_bp);
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
delete_breakpoint (self_bp->bp);
}
- GDB_PY_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
Py_RETURN_NONE;
}
{
gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
long value;
- volatile struct gdb_exception except;
BPPY_SET_REQUIRE_VALID (self_bp);
if (value < 0)
value = 0;
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
set_ignore_count (self_bp->number, (int) value, 0);
}
- GDB_PY_SET_HANDLE_EXCEPTION (except);
+ CATCH (except, RETURN_MASK_ALL)
+ {
+ GDB_PY_SET_HANDLE_EXCEPTION (except);
+ }
+ END_CATCH
return 0;
}
if (newvalue == NULL)
{
- PyErr_SetString (PyExc_TypeError,
+ PyErr_SetString (PyExc_TypeError,
_("Cannot delete `hit_count' attribute."));
return -1;
}
static PyObject *
bppy_get_location (PyObject *self, void *closure)
{
- char *str;
+ const char *str;
gdbpy_breakpoint_object *obj = (gdbpy_breakpoint_object *) self;
BPPY_REQUIRE_VALID (obj);
if (obj->bp->type != bp_breakpoint)
Py_RETURN_NONE;
- str = obj->bp->addr_string;
-
+ struct event_location *location = obj->bp->location.get ();
+ /* "catch throw" makes a breakpoint of type bp_breakpoint that does
+ not have a location. */
+ if (location == nullptr)
+ Py_RETURN_NONE;
+ str = event_location_to_string (location);
if (! str)
str = "";
- return PyString_Decode (str, strlen (str), host_charset (), NULL);
+ return host_string_to_python_string (str).release ();
}
/* Python function to get the breakpoint expression. */
static PyObject *
bppy_get_expression (PyObject *self, void *closure)
{
- char *str;
+ const char *str;
gdbpy_breakpoint_object *obj = (gdbpy_breakpoint_object *) self;
struct watchpoint *wp;
if (! str)
str = "";
- return PyString_Decode (str, strlen (str), host_charset (), NULL);
+ return host_string_to_python_string (str).release ();
}
/* Python function to get the condition expression of a breakpoint. */
if (! str)
Py_RETURN_NONE;
- return PyString_Decode (str, strlen (str), host_charset (), NULL);
+ return host_string_to_python_string (str).release ();
}
/* Returns 0 on success. Returns -1 on error, with a python exception set.
static int
bppy_set_condition (PyObject *self, PyObject *newvalue, void *closure)
{
- char *exp;
+ gdb::unique_xmalloc_ptr<char> exp_holder;
+ const char *exp = NULL;
gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
- volatile struct gdb_exception except;
+ struct gdb_exception except = exception_none;
BPPY_SET_REQUIRE_VALID (self_bp);
if (newvalue == NULL)
{
- PyErr_SetString (PyExc_TypeError,
+ PyErr_SetString (PyExc_TypeError,
_("Cannot delete `condition' attribute."));
return -1;
}
exp = "";
else
{
- exp = python_string_to_host_string (newvalue);
- if (exp == NULL)
+ exp_holder = python_string_to_host_string (newvalue);
+ if (exp_holder == NULL)
return -1;
+ exp = exp_holder.get ();
}
- TRY_CATCH (except, RETURN_MASK_ALL)
+ TRY
{
set_breakpoint_condition (self_bp->bp, exp, 0);
}
-
- if (newvalue != Py_None)
- xfree (exp);
+ CATCH (ex, RETURN_MASK_ALL)
+ {
+ except = ex;
+ }
+ END_CATCH
GDB_PY_SET_HANDLE_EXCEPTION (except);
{
gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
struct breakpoint *bp = self_bp->bp;
- long length;
- volatile struct gdb_exception except;
- struct ui_file *string_file;
- struct cleanup *chain;
- PyObject *result;
- char *cmdstr;
BPPY_REQUIRE_VALID (self_bp);
if (! self_bp->bp->commands)
Py_RETURN_NONE;
- string_file = mem_fileopen ();
- chain = make_cleanup_ui_file_delete (string_file);
+ string_file stb;
- ui_out_redirect (current_uiout, string_file);
- TRY_CATCH (except, RETURN_MASK_ALL)
+ current_uiout->redirect (&stb);
+ TRY
{
print_command_lines (current_uiout, breakpoint_commands (bp), 0);
}
- ui_out_redirect (current_uiout, NULL);
- if (except.reason < 0)
+ CATCH (except, RETURN_MASK_ALL)
{
- do_cleanups (chain);
+ current_uiout->redirect (NULL);
gdbpy_convert_exception (except);
return NULL;
}
+ END_CATCH
- cmdstr = ui_file_xstrdup (string_file, &length);
- make_cleanup (xfree, cmdstr);
- result = PyString_Decode (cmdstr, strlen (cmdstr), host_charset (), NULL);
- do_cleanups (chain);
- return result;
+ current_uiout->redirect (NULL);
+ return host_string_to_python_string (stb.c_str ()).release ();
+}
+
+/* Set the commands attached to a breakpoint. Returns 0 on success.
+ Returns -1 on error, with a python exception set. */
+static int
+bppy_set_commands (PyObject *self, PyObject *newvalue, void *closure)
+{
+ gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
+ struct gdb_exception except = exception_none;
+
+ BPPY_SET_REQUIRE_VALID (self_bp);
+
+ gdb::unique_xmalloc_ptr<char> commands
+ (python_string_to_host_string (newvalue));
+ if (commands == nullptr)
+ return -1;
+
+ TRY
+ {
+ bool first = true;
+ char *save_ptr = nullptr;
+ auto reader
+ = [&] ()
+ {
+ const char *result = strtok_r (first ? commands.get () : nullptr,
+ "\n", &save_ptr);
+ first = false;
+ return result;
+ };
+
+ counted_command_line lines = read_command_lines_1 (reader, 1, nullptr);
+ breakpoint_set_commands (self_bp->bp, std::move (lines));
+ }
+ CATCH (ex, RETURN_MASK_ALL)
+ {
+ except = ex;
+ }
+ END_CATCH
+
+ GDB_PY_SET_HANDLE_EXCEPTION (except);
+
+ return 0;
}
/* Python function to get the breakpoint type. */
BPPY_REQUIRE_VALID (self_bp);
- if (self_bp->bp->number < 0)
- Py_RETURN_FALSE;
+ if (user_breakpoint_p (self_bp->bp))
+ Py_RETURN_TRUE;
- Py_RETURN_TRUE;
+ Py_RETURN_FALSE;
}
/* Python function to determine if the breakpoint is a temporary
Py_RETURN_FALSE;
}
+/* Python function to determine if the breakpoint is a pending
+ breakpoint. */
+
+static PyObject *
+bppy_get_pending (PyObject *self, void *closure)
+{
+ gdbpy_breakpoint_object *self_bp = (gdbpy_breakpoint_object *) self;
+
+ BPPY_REQUIRE_VALID (self_bp);
+
+ if (is_watchpoint (self_bp->bp))
+ Py_RETURN_FALSE;
+ if (pending_breakpoint_p (self_bp->bp))
+ Py_RETURN_TRUE;
+
+ Py_RETURN_FALSE;
+}
+
/* Python function to get the breakpoint's number. */
static PyObject *
bppy_get_number (PyObject *self, void *closure)
return PyInt_FromLong (self_bp->bp->ignore_count);
}
+/* Internal function to validate the Python parameters/keywords
+ provided to bppy_init. */
+
+static int
+bppy_init_validate_args (const char *spec, char *source,
+ char *function, char *label,
+ char *line, enum bptype type)
+{
+ /* If spec is defined, ensure that none of the explicit location
+ keywords are also defined. */
+ if (spec != NULL)
+ {
+ if (source != NULL || function != NULL || label != NULL || line != NULL)
+ {
+ PyErr_SetString (PyExc_RuntimeError,
+ _("Breakpoints specified with spec cannot "
+ "have source, function, label or line defined."));
+ return -1;
+ }
+ }
+ else
+ {
+ /* If spec isn't defined, ensure that the user is not trying to
+ define a watchpoint with an explicit location. */
+ if (type == bp_watchpoint)
+ {
+ PyErr_SetString (PyExc_RuntimeError,
+ _("Watchpoints cannot be set by explicit "
+ "location parameters."));
+ return -1;
+ }
+ else
+ {
+ /* Otherwise, ensure some explicit locations are defined. */
+ if (source == NULL && function == NULL && label == NULL
+ && line == NULL)
+ {
+ PyErr_SetString (PyExc_RuntimeError,
+ _("Neither spec nor explicit location set."));
+ return -1;
+ }
+ /* Finally, if source is specified, ensure that line, label
+ or function are specified too. */
+ if (source != NULL && function == NULL && label == NULL
+ && line == NULL)
+ {
+ PyErr_SetString (PyExc_RuntimeError,
+ _("Specifying a source must also include a "
+ "line, label or function."));
+ return -1;
+ }
+ }
+ }
+ return 1;
+}
+
/* Python function to create a new breakpoint. */
static int
bppy_init (PyObject *self, PyObject *args, PyObject *kwargs)
{
- static char *keywords[] = { "spec", "type", "wp_class", "internal",
- "temporary", NULL };
- const char *spec;
- int type = bp_breakpoint;
+ static const char *keywords[] = { "spec", "type", "wp_class", "internal",
+ "temporary","source", "function",
+ "label", "line", "qualified", NULL };
+ const char *spec = NULL;
+ enum bptype type = bp_breakpoint;
int access_type = hw_write;
PyObject *internal = NULL;
PyObject *temporary = NULL;
+ PyObject *lineobj = NULL;;
int internal_bp = 0;
int temporary_bp = 0;
- volatile struct gdb_exception except;
-
- if (! PyArg_ParseTupleAndKeywords (args, kwargs, "s|iiOO", keywords,
- &spec, &type, &access_type,
- &internal, &temporary))
+ gdb::unique_xmalloc_ptr<char> line;
+ char *label = NULL;
+ char *source = NULL;
+ char *function = NULL;
+ PyObject * qualified = NULL;
+
+ if (!gdb_PyArg_ParseTupleAndKeywords (args, kwargs, "|siiOOsssOO", keywords,
+ &spec, &type, &access_type,
+ &internal,
+ &temporary, &source,
+ &function, &label, &lineobj,
+ &qualified))
return -1;
+
+ if (lineobj != NULL)
+ {
+ if (PyInt_Check (lineobj))
+ line.reset (xstrprintf ("%ld", PyInt_AsLong (lineobj)));
+ else if (PyString_Check (lineobj))
+ line = python_string_to_host_string (lineobj);
+ else
+ {
+ PyErr_SetString (PyExc_RuntimeError,
+ _("Line keyword should be an integer or a string. "));
+ return -1;
+ }
+ }
+
if (internal)
{
internal_bp = PyObject_IsTrue (internal);
return -1;
}
+ if (bppy_init_validate_args (spec, source, function, label, line.get (),
+ type) == -1)
+ return -1;
+
bppy_pending_object = (gdbpy_breakpoint_object *) self;
bppy_pending_object->number = -1;
bppy_pending_object->bp = NULL;
-
- TRY_CATCH (except, RETURN_MASK_ALL)
- {
- char *copy = xstrdup (spec);
- struct cleanup *cleanup = make_cleanup (xfree, copy);
+ TRY
+ {
switch (type)
{
case bp_breakpoint:
{
+ event_location_up location;
+ symbol_name_match_type func_name_match_type
+ = (qualified != NULL && PyObject_IsTrue (qualified)
+ ? symbol_name_match_type::FULL
+ : symbol_name_match_type::WILD);
+
+ if (spec != NULL)
+ {
+ gdb::unique_xmalloc_ptr<char>
+ copy_holder (xstrdup (skip_spaces (spec)));
+ const char *copy = copy_holder.get ();
+
+ location = string_to_event_location (©,
+ current_language,
+ func_name_match_type);
+ }
+ else
+ {
+ struct explicit_location explicit_loc;
+
+ initialize_explicit_location (&explicit_loc);
+ explicit_loc.source_filename = source;
+ explicit_loc.function_name = function;
+ explicit_loc.label_name = label;
+
+ if (line != NULL)
+ explicit_loc.line_offset =
+ linespec_parse_line_offset (line.get ());
+
+ explicit_loc.func_name_match_type = func_name_match_type;
+
+ location = new_explicit_location (&explicit_loc);
+ }
+
create_breakpoint (python_gdbarch,
- copy, NULL, -1, NULL,
+ location.get (), NULL, -1, NULL,
0,
temporary_bp, bp_breakpoint,
0,
0, 1, internal_bp, 0);
break;
}
- case bp_watchpoint:
+ case bp_watchpoint:
{
+ gdb::unique_xmalloc_ptr<char>
+ copy_holder (xstrdup (skip_spaces (spec)));
+ char *copy = copy_holder.get ();
+
if (access_type == hw_write)
watch_command_wrapper (copy, 0, internal_bp);
else if (access_type == hw_access)
default:
error(_("Do not understand breakpoint type to set."));
}
-
- do_cleanups (cleanup);
}
- if (except.reason < 0)
+ CATCH (except, RETURN_MASK_ALL)
{
- PyErr_Format (except.reason == RETURN_QUIT
- ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
- "%s", except.message);
+ bppy_pending_object = NULL;
+ gdbpy_convert_exception (except);
return -1;
}
+ END_CATCH
BPPY_SET_REQUIRE_VALID ((gdbpy_breakpoint_object *) self);
return 0;
static int
build_bp_list (struct breakpoint *b, void *arg)
{
- PyObject *list = arg;
+ PyObject *list = (PyObject *) arg;
PyObject *bp = (PyObject *) b->py_bp_object;
int iserr = 0;
PyObject *
gdbpy_breakpoints (PyObject *self, PyObject *args)
{
- PyObject *list, *tuple;
-
if (bppy_live == 0)
- Py_RETURN_NONE;
+ return PyTuple_New (0);
- list = PyList_New (0);
- if (!list)
+ gdbpy_ref<> list (PyList_New (0));
+ if (list == NULL)
return NULL;
- /* If iteratre_over_breakpoints returns non NULL it signals an error
+ /* If iterate_over_breakpoints returns non NULL it signals an error
condition. In that case abandon building the list and return
NULL. */
- if (iterate_over_breakpoints (build_bp_list, list) != NULL)
- {
- Py_DECREF (list);
- return NULL;
- }
-
- tuple = PyList_AsTuple (list);
- Py_DECREF (list);
+ if (iterate_over_breakpoints (build_bp_list, list.get ()) != NULL)
+ return NULL;
- return tuple;
+ return PyList_AsTuple (list.get ());
}
/* Call the "stop" method (if implemented) in the breakpoint
stopped at the breakpoint. Otherwise the inferior will be
allowed to continue. */
-int
-gdbpy_should_stop (struct gdbpy_breakpoint_object *bp_obj)
+enum ext_lang_bp_stop
+gdbpy_breakpoint_cond_says_stop (const struct extension_language_defn *extlang,
+ struct breakpoint *b)
{
- int stop = 1;
-
+ int stop;
+ struct gdbpy_breakpoint_object *bp_obj = b->py_bp_object;
PyObject *py_bp = (PyObject *) bp_obj;
- struct breakpoint *b = bp_obj->bp;
- struct gdbarch *garch = b->gdbarch ? b->gdbarch : get_current_arch ();
- struct cleanup *cleanup = ensure_python_env (garch, current_language);
+ struct gdbarch *garch;
+
+ if (bp_obj == NULL)
+ return EXT_LANG_BP_STOP_UNSET;
+
+ stop = -1;
+ garch = b->gdbarch ? b->gdbarch : get_current_arch ();
+
+ gdbpy_enter enter_py (garch, current_language);
if (bp_obj->is_finish_bp)
bpfinishpy_pre_stop_hook (bp_obj);
if (PyObject_HasAttrString (py_bp, stop_func))
{
- PyObject *result = PyObject_CallMethod (py_bp, stop_func, NULL);
+ gdbpy_ref<> result (PyObject_CallMethod (py_bp, stop_func, NULL));
- if (result)
+ stop = 1;
+ if (result != NULL)
{
- int evaluate = PyObject_IsTrue (result);
+ int evaluate = PyObject_IsTrue (result.get ());
if (evaluate == -1)
gdbpy_print_stack ();
the Python breakpoint wants GDB to continue. */
if (! evaluate)
stop = 0;
-
- Py_DECREF (result);
}
else
gdbpy_print_stack ();
if (bp_obj->is_finish_bp)
bpfinishpy_post_stop_hook (bp_obj);
- do_cleanups (cleanup);
-
- return stop;
+ if (stop < 0)
+ return EXT_LANG_BP_STOP_UNSET;
+ return stop ? EXT_LANG_BP_STOP_YES : EXT_LANG_BP_STOP_NO;
}
/* Checks if the "stop" method exists in this breakpoint.
conditions. */
int
-gdbpy_breakpoint_has_py_cond (struct gdbpy_breakpoint_object *bp_obj)
+gdbpy_breakpoint_has_cond (const struct extension_language_defn *extlang,
+ struct breakpoint *b)
{
- int has_func = 0;
- PyObject *py_bp = (PyObject *) bp_obj;
- struct gdbarch *garch = bp_obj->bp->gdbarch ? bp_obj->bp->gdbarch :
- get_current_arch ();
- struct cleanup *cleanup = ensure_python_env (garch, current_language);
-
- if (py_bp != NULL)
- has_func = PyObject_HasAttrString (py_bp, stop_func);
+ PyObject *py_bp;
+ struct gdbarch *garch;
- do_cleanups (cleanup);
+ if (b->py_bp_object == NULL)
+ return 0;
- return has_func;
+ py_bp = (PyObject *) b->py_bp_object;
+ garch = b->gdbarch ? b->gdbarch : get_current_arch ();
+
+ gdbpy_enter enter_py (garch, current_language);
+ return PyObject_HasAttrString (py_bp, stop_func);
}
\f
gdbpy_breakpoint_object *newbp;
PyGILState_STATE state;
- if (bp->number < 0 && bppy_pending_object == NULL)
+ if (!user_breakpoint_p (bp) && bppy_pending_object == NULL)
return;
- if (bp->type != bp_breakpoint
+ if (bp->type != bp_breakpoint
&& bp->type != bp_watchpoint
- && bp->type != bp_hardware_watchpoint
+ && bp->type != bp_hardware_watchpoint
&& bp->type != bp_read_watchpoint
&& bp->type != bp_access_watchpoint)
return;
gdbpy_print_stack ();
}
+ if (!evregpy_no_listeners_p (gdb_py_events.breakpoint_created))
+ {
+ if (evpy_emit_event ((PyObject *) newbp,
+ gdb_py_events.breakpoint_created) < 0)
+ gdbpy_print_stack ();
+ }
+
PyGILState_Release (state);
}
int num = b->number;
PyGILState_STATE state;
struct breakpoint *bp = NULL;
- gdbpy_breakpoint_object *bp_obj;
state = PyGILState_Ensure ();
bp = get_breakpoint (num);
if (bp)
{
- bp_obj = bp->py_bp_object;
- if (bp_obj)
+ gdbpy_ref<gdbpy_breakpoint_object> bp_obj (bp->py_bp_object);
+ if (bp_obj != NULL)
{
+ if (!evregpy_no_listeners_p (gdb_py_events.breakpoint_deleted))
+ {
+ if (evpy_emit_event ((PyObject *) bp_obj.get (),
+ gdb_py_events.breakpoint_deleted) < 0)
+ gdbpy_print_stack ();
+ }
+
bp_obj->bp = NULL;
--bppy_live;
- Py_DECREF (bp_obj);
+ }
+ }
+ PyGILState_Release (state);
+}
+
+/* Callback that is used when a breakpoint is modified. */
+
+static void
+gdbpy_breakpoint_modified (struct breakpoint *b)
+{
+ int num = b->number;
+ PyGILState_STATE state;
+ struct breakpoint *bp = NULL;
+
+ state = PyGILState_Ensure ();
+ bp = get_breakpoint (num);
+ if (bp)
+ {
+ PyObject *bp_obj = (PyObject *) bp->py_bp_object;
+ if (bp_obj)
+ {
+ if (!evregpy_no_listeners_p (gdb_py_events.breakpoint_modified))
+ {
+ if (evpy_emit_event (bp_obj,
+ gdb_py_events.breakpoint_modified) < 0)
+ gdbpy_print_stack ();
+ }
}
}
PyGILState_Release (state);
(PyObject *) &breakpoint_object_type) < 0)
return -1;
- observer_attach_breakpoint_created (gdbpy_breakpoint_created);
- observer_attach_breakpoint_deleted (gdbpy_breakpoint_deleted);
+ gdb::observers::breakpoint_created.attach (gdbpy_breakpoint_created);
+ gdb::observers::breakpoint_deleted.attach (gdbpy_breakpoint_deleted);
+ gdb::observers::breakpoint_modified.attach (gdbpy_breakpoint_modified);
/* Add breakpoint types constants. */
for (i = 0; pybp_codes[i].name; ++i)
{
- if (PyModule_AddIntConstant (gdb_module,
- /* Cast needed for Python 2.4. */
- (char *) pybp_codes[i].name,
+ if (PyModule_AddIntConstant (gdb_module, pybp_codes[i].name,
pybp_codes[i].code) < 0)
return -1;
}
/* Add watchpoint types constants. */
for (i = 0; pybp_watch_types[i].name; ++i)
{
- if (PyModule_AddIntConstant (gdb_module,
- /* Cast needed for Python 2.4. */
- (char *) pybp_watch_types[i].name,
+ if (PyModule_AddIntConstant (gdb_module, pybp_watch_types[i].name,
pybp_watch_types[i].code) < 0)
return -1;
}
PyObject_GenericSetAttr to allow extra validation of the attribute
being set. */
-static int
+static int
local_setattro (PyObject *self, PyObject *name, PyObject *v)
{
- gdbpy_breakpoint_object *obj = (gdbpy_breakpoint_object *) self;
- char *attr = python_string_to_host_string (name);
-
+ gdbpy_breakpoint_object *obj = (gdbpy_breakpoint_object *) self;
+ gdb::unique_xmalloc_ptr<char> attr (python_string_to_host_string (name));
+
if (attr == NULL)
return -1;
-
+
/* If the attribute trying to be set is the "stop" method,
- but we already have a condition set in the CLI, disallow this
- operation. */
- if (strcmp (attr, stop_func) == 0 && obj->bp->cond_string)
+ but we already have a condition set in the CLI or other extension
+ language, disallow this operation. */
+ if (strcmp (attr.get (), stop_func) == 0)
{
- xfree (attr);
- PyErr_SetString (PyExc_RuntimeError,
- _("Cannot set 'stop' method. There is an " \
- "existing GDB condition attached to the " \
- "breakpoint."));
- return -1;
+ const struct extension_language_defn *extlang = NULL;
+
+ if (obj->bp->cond_string != NULL)
+ extlang = get_ext_lang_defn (EXT_LANG_GDB);
+ if (extlang == NULL)
+ extlang = get_breakpoint_cond_ext_lang (obj->bp, EXT_LANG_PYTHON);
+ if (extlang != NULL)
+ {
+ std::string error_text
+ = string_printf (_("Only one stop condition allowed. There is"
+ " currently a %s stop condition defined for"
+ " this breakpoint."),
+ ext_lang_capitalized_name (extlang));
+ PyErr_SetString (PyExc_RuntimeError, error_text.c_str ());
+ return -1;
+ }
}
-
- xfree (attr);
-
- return PyObject_GenericSetAttr ((PyObject *)self, name, v);
+
+ return PyObject_GenericSetAttr (self, name, v);
}
-static PyGetSetDef breakpoint_object_getset[] = {
+static gdb_PyGetSetDef breakpoint_object_getset[] = {
{ "enabled", bppy_get_enabled, bppy_set_enabled,
"Boolean telling whether the breakpoint is enabled.", NULL },
{ "silent", bppy_get_silent, bppy_set_silent,
{ "condition", bppy_get_condition, bppy_set_condition,
"Condition of the breakpoint, as specified by the user,\
or None if no condition set."},
- { "commands", bppy_get_commands, NULL,
+ { "commands", bppy_get_commands, bppy_set_commands,
"Commands of the breakpoint, as specified by the user."},
{ "type", bppy_get_type, NULL,
"Type of breakpoint."},
"Whether the breakpoint is visible to the user."},
{ "temporary", bppy_get_temporary, NULL,
"Whether this breakpoint is a temporary breakpoint."},
+ { "pending", bppy_get_pending, NULL,
+ "Whether this breakpoint is a pending breakpoint."},
{ NULL } /* Sentinel. */
};
projects / deliverable / binutils-gdb.git / blobdiff