2076 lines
64 KiB
C
2076 lines
64 KiB
C
/* ide-debugger.c
|
|
*
|
|
* Copyright 2017-2019 Christian Hergert <chergert@redhat.com>
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* SPDX-License-Identifier: GPL-3.0-or-later
|
|
*/
|
|
|
|
#define G_LOG_DOMAIN "ide-debugger"
|
|
|
|
#include "config.h"
|
|
|
|
#include "ide-debugger.h"
|
|
#include "ide-debugger-address-map-private.h"
|
|
#include "ide-debugger-private.h"
|
|
|
|
/**
|
|
* SECTION:ide-debugger
|
|
* @title: IdeDebugger
|
|
* @short_description: Base class for debugger implementations
|
|
*
|
|
* The IdeDebugger abstract base class is used by debugger implementations.
|
|
* They should bridge their backend-specific features into those supported
|
|
* by the API using the series of "emit" functions provided as part of
|
|
* this class.
|
|
*
|
|
* For example, when the inferior creates a new thread, the debugger
|
|
* implementation should call ide_debugger_emit_thread_added().
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
|
|
typedef struct
|
|
{
|
|
gchar *display_name;
|
|
GListStore *breakpoints;
|
|
GListStore *threads;
|
|
GListStore *thread_groups;
|
|
IdeDebuggerThread *selected;
|
|
IdeDebuggerAddressMap *map;
|
|
guint has_started : 1;
|
|
guint is_running : 1;
|
|
} IdeDebuggerPrivate;
|
|
|
|
G_DEFINE_ABSTRACT_TYPE_WITH_CODE (IdeDebugger, ide_debugger, IDE_TYPE_OBJECT,
|
|
G_ADD_PRIVATE (IdeDebugger)
|
|
G_IMPLEMENT_INTERFACE (G_TYPE_ACTION_GROUP,
|
|
_ide_debugger_class_init_actions))
|
|
|
|
enum {
|
|
PROP_0,
|
|
PROP_DISPLAY_NAME,
|
|
PROP_SELECTED_THREAD,
|
|
N_PROPS
|
|
};
|
|
|
|
enum {
|
|
LOG,
|
|
|
|
THREAD_GROUP_ADDED,
|
|
THREAD_GROUP_EXITED,
|
|
THREAD_GROUP_REMOVED,
|
|
THREAD_GROUP_STARTED,
|
|
|
|
THREAD_ADDED,
|
|
THREAD_REMOVED,
|
|
THREAD_SELECTED,
|
|
|
|
BREAKPOINT_ADDED,
|
|
BREAKPOINT_MODIFIED,
|
|
BREAKPOINT_REMOVED,
|
|
|
|
RUNNING,
|
|
STOPPED,
|
|
|
|
LIBRARY_LOADED,
|
|
LIBRARY_UNLOADED,
|
|
|
|
N_SIGNALS
|
|
};
|
|
|
|
static GParamSpec *properties [N_PROPS];
|
|
static guint signals [N_SIGNALS];
|
|
|
|
static void
|
|
ide_debugger_real_breakpoint_added (IdeDebugger *self,
|
|
IdeDebuggerBreakpoint *breakpoint)
|
|
{
|
|
IdeDebuggerPrivate *priv = ide_debugger_get_instance_private (self);
|
|
|
|
g_assert (IDE_IS_DEBUGGER (self));
|
|
g_assert (IDE_IS_DEBUGGER_BREAKPOINT (breakpoint));
|
|
|
|
g_debug ("Added breakpoint %s",
|
|
ide_debugger_breakpoint_get_id (breakpoint));
|
|
|
|
g_list_store_insert_sorted (priv->breakpoints,
|
|
breakpoint,
|
|
(GCompareDataFunc)ide_debugger_breakpoint_compare,
|
|
NULL);
|
|
}
|
|
|
|
static void
|
|
ide_debugger_real_breakpoint_removed (IdeDebugger *self,
|
|
IdeDebuggerBreakpoint *breakpoint)
|
|
{
|
|
IdeDebuggerPrivate *priv = ide_debugger_get_instance_private (self);
|
|
guint n_items;
|
|
|
|
g_assert (IDE_IS_DEBUGGER (self));
|
|
g_assert (IDE_IS_DEBUGGER_BREAKPOINT (breakpoint));
|
|
|
|
g_debug ("Removed breakpoint %s",
|
|
ide_debugger_breakpoint_get_id (breakpoint));
|
|
|
|
n_items = g_list_model_get_n_items (G_LIST_MODEL (priv->breakpoints));
|
|
|
|
for (guint i = 0; i < n_items; i++)
|
|
{
|
|
g_autoptr(IdeDebuggerBreakpoint) element = NULL;
|
|
|
|
element = g_list_model_get_item (G_LIST_MODEL (priv->breakpoints), i);
|
|
|
|
g_assert (element != NULL);
|
|
g_assert (IDE_IS_DEBUGGER_BREAKPOINT (element));
|
|
|
|
if (breakpoint == element)
|
|
break;
|
|
|
|
if (ide_debugger_breakpoint_compare (breakpoint, element) == 0)
|
|
{
|
|
g_list_store_remove (priv->breakpoints, i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
ide_debugger_real_breakpoint_modified (IdeDebugger *self,
|
|
IdeDebuggerBreakpoint *breakpoint)
|
|
{
|
|
g_assert (IDE_IS_DEBUGGER (self));
|
|
g_assert (IDE_IS_DEBUGGER_BREAKPOINT (breakpoint));
|
|
|
|
g_debug ("Modified breakpoint %s (%s)",
|
|
ide_debugger_breakpoint_get_id (breakpoint),
|
|
ide_debugger_breakpoint_get_enabled (breakpoint) ? "enabled" : "disabled");
|
|
|
|
/*
|
|
* If we add API to GListStore, we could make this a single
|
|
* operation instead of 2 signal emissions.
|
|
*/
|
|
ide_debugger_real_breakpoint_removed (self, breakpoint);
|
|
ide_debugger_real_breakpoint_added (self, breakpoint);
|
|
}
|
|
|
|
static void
|
|
ide_debugger_real_thread_group_added (IdeDebugger *self,
|
|
IdeDebuggerThreadGroup *thread_group)
|
|
{
|
|
IdeDebuggerPrivate *priv = ide_debugger_get_instance_private (self);
|
|
|
|
g_assert (IDE_IS_DEBUGGER (self));
|
|
g_assert (IDE_IS_DEBUGGER_THREAD_GROUP (thread_group));
|
|
|
|
g_debug ("Added thread group %s",
|
|
ide_debugger_thread_group_get_id (thread_group));
|
|
|
|
g_list_store_insert_sorted (priv->thread_groups,
|
|
thread_group,
|
|
(GCompareDataFunc)ide_debugger_thread_group_compare,
|
|
NULL);
|
|
}
|
|
|
|
static void
|
|
ide_debugger_real_thread_group_removed (IdeDebugger *self,
|
|
IdeDebuggerThreadGroup *thread_group)
|
|
{
|
|
IdeDebuggerPrivate *priv = ide_debugger_get_instance_private (self);
|
|
guint n_items;
|
|
|
|
g_assert (IDE_IS_DEBUGGER (self));
|
|
g_assert (IDE_IS_DEBUGGER_THREAD_GROUP (thread_group));
|
|
|
|
g_debug ("Removed thread group %s",
|
|
ide_debugger_thread_group_get_id (thread_group));
|
|
|
|
n_items = g_list_model_get_n_items (G_LIST_MODEL (priv->thread_groups));
|
|
|
|
for (guint i = 0; i < n_items; i++)
|
|
{
|
|
g_autoptr(IdeDebuggerThreadGroup) element = NULL;
|
|
|
|
element = g_list_model_get_item (G_LIST_MODEL (priv->thread_groups), i);
|
|
|
|
g_assert (element != NULL);
|
|
g_assert (IDE_IS_DEBUGGER_THREAD_GROUP (element));
|
|
|
|
if (thread_group == element)
|
|
break;
|
|
|
|
if (ide_debugger_thread_group_compare (thread_group, element) == 0)
|
|
{
|
|
g_list_store_remove (priv->thread_groups, i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
ide_debugger_real_thread_added (IdeDebugger *self,
|
|
IdeDebuggerThread *thread)
|
|
{
|
|
IdeDebuggerPrivate *priv = ide_debugger_get_instance_private (self);
|
|
|
|
g_assert (IDE_IS_DEBUGGER (self));
|
|
g_assert (IDE_IS_DEBUGGER_THREAD (thread));
|
|
|
|
g_debug ("Added thread %s", ide_debugger_thread_get_id (thread));
|
|
|
|
g_list_store_insert_sorted (priv->threads,
|
|
thread,
|
|
(GCompareDataFunc)ide_debugger_thread_compare,
|
|
NULL);
|
|
}
|
|
|
|
static void
|
|
ide_debugger_real_thread_removed (IdeDebugger *self,
|
|
IdeDebuggerThread *thread)
|
|
{
|
|
IdeDebuggerPrivate *priv = ide_debugger_get_instance_private (self);
|
|
guint n_items;
|
|
|
|
g_assert (IDE_IS_DEBUGGER (self));
|
|
g_assert (IDE_IS_DEBUGGER_THREAD (thread));
|
|
|
|
g_debug ("Removed thread %s", ide_debugger_thread_get_id (thread));
|
|
|
|
n_items = g_list_model_get_n_items (G_LIST_MODEL (priv->threads));
|
|
|
|
for (guint i = 0; i < n_items; i++)
|
|
{
|
|
g_autoptr(IdeDebuggerThread) element = NULL;
|
|
|
|
element = g_list_model_get_item (G_LIST_MODEL (priv->threads), i);
|
|
|
|
g_assert (element != NULL);
|
|
g_assert (IDE_IS_DEBUGGER_THREAD (element));
|
|
|
|
if (thread == element)
|
|
break;
|
|
|
|
if (ide_debugger_thread_compare (thread, element) == 0)
|
|
{
|
|
g_list_store_remove (priv->threads, i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
ide_debugger_real_running (IdeDebugger *self)
|
|
{
|
|
IdeDebuggerPrivate *priv = ide_debugger_get_instance_private (self);
|
|
|
|
g_assert (IDE_IS_DEBUGGER (self));
|
|
|
|
priv->is_running = TRUE;
|
|
priv->has_started = TRUE;
|
|
|
|
_ide_debugger_update_actions (self);
|
|
}
|
|
|
|
static void
|
|
ide_debugger_real_stopped (IdeDebugger *self,
|
|
IdeDebuggerStopReason stop_reason,
|
|
IdeDebuggerBreakpoint *breakpoint)
|
|
{
|
|
IdeDebuggerPrivate *priv = ide_debugger_get_instance_private (self);
|
|
|
|
g_assert (IDE_IS_DEBUGGER (self));
|
|
g_assert (IDE_IS_DEBUGGER_STOP_REASON (stop_reason));
|
|
g_assert (!breakpoint || IDE_IS_DEBUGGER_BREAKPOINT (breakpoint));
|
|
|
|
/* We might need to eventually track this by thread group */
|
|
priv->is_running = FALSE;
|
|
|
|
if (IDE_DEBUGGER_STOP_IS_TERMINAL (stop_reason))
|
|
priv->has_started = FALSE;
|
|
|
|
_ide_debugger_update_actions (self);
|
|
}
|
|
|
|
static void
|
|
ide_debugger_real_thread_selected (IdeDebugger *self,
|
|
IdeDebuggerThread *thread)
|
|
{
|
|
IdeDebuggerPrivate *priv = ide_debugger_get_instance_private (self);
|
|
|
|
g_assert (IDE_IS_DEBUGGER (self));
|
|
g_assert (IDE_IS_DEBUGGER_THREAD (thread));
|
|
|
|
if (g_set_object (&priv->selected, thread))
|
|
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_SELECTED_THREAD]);
|
|
}
|
|
|
|
static void
|
|
ide_debugger_finalize (GObject *object)
|
|
{
|
|
IdeDebugger *self = (IdeDebugger *)object;
|
|
IdeDebuggerPrivate *priv = ide_debugger_get_instance_private (self);
|
|
|
|
g_clear_pointer (&priv->map, ide_debugger_address_map_free);
|
|
g_clear_pointer (&priv->display_name, g_free);
|
|
g_clear_object (&priv->breakpoints);
|
|
g_clear_object (&priv->threads);
|
|
g_clear_object (&priv->thread_groups);
|
|
g_clear_object (&priv->selected);
|
|
|
|
G_OBJECT_CLASS (ide_debugger_parent_class)->finalize (object);
|
|
}
|
|
|
|
static gboolean
|
|
ide_debugger_real_get_can_move (IdeDebugger *self,
|
|
IdeDebuggerMovement movement)
|
|
{
|
|
g_return_val_if_fail (IDE_IS_DEBUGGER (self), FALSE);
|
|
g_return_val_if_fail (IDE_IS_DEBUGGER_MOVEMENT (movement), FALSE);
|
|
|
|
switch (movement)
|
|
{
|
|
case IDE_DEBUGGER_MOVEMENT_START:
|
|
return !ide_debugger_get_is_running (self);
|
|
|
|
case IDE_DEBUGGER_MOVEMENT_FINISH:
|
|
case IDE_DEBUGGER_MOVEMENT_CONTINUE:
|
|
case IDE_DEBUGGER_MOVEMENT_STEP_IN:
|
|
case IDE_DEBUGGER_MOVEMENT_STEP_OVER:
|
|
return _ide_debugger_get_has_started (self) &&
|
|
!ide_debugger_get_is_running (self);
|
|
|
|
default:
|
|
g_return_val_if_reached (FALSE);
|
|
}
|
|
}
|
|
|
|
static void
|
|
ide_debugger_real_library_loaded (IdeDebugger *self,
|
|
IdeDebuggerLibrary *library)
|
|
{
|
|
IdeDebuggerPrivate *priv = ide_debugger_get_instance_private (self);
|
|
IdeDebuggerAddressMapEntry entry = { 0 };
|
|
GPtrArray *ranges;
|
|
|
|
g_assert (IDE_IS_DEBUGGER (self));
|
|
g_assert (IDE_IS_DEBUGGER_LIBRARY (library));
|
|
|
|
/* We don't yet have this information */
|
|
entry.offset = 0;
|
|
entry.filename = ide_debugger_library_get_target_name (library);
|
|
|
|
ranges = ide_debugger_library_get_ranges (library);
|
|
|
|
if (ranges != NULL)
|
|
{
|
|
for (guint i = 0; i < ranges->len; i++)
|
|
{
|
|
const IdeDebuggerAddressRange *range = g_ptr_array_index (ranges, i);
|
|
|
|
entry.start = range->from;
|
|
entry.end = range->to;
|
|
|
|
ide_debugger_address_map_insert (priv->map, &entry);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
ide_debugger_real_library_unloaded (IdeDebugger *self,
|
|
IdeDebuggerLibrary *library)
|
|
{
|
|
IdeDebuggerPrivate *priv = ide_debugger_get_instance_private (self);
|
|
GPtrArray *ranges;
|
|
|
|
g_assert (IDE_IS_DEBUGGER (self));
|
|
g_assert (IDE_IS_DEBUGGER_LIBRARY (library));
|
|
|
|
ranges = ide_debugger_library_get_ranges (library);
|
|
|
|
if (ranges != NULL)
|
|
{
|
|
for (guint i = 0; i < ranges->len; i++)
|
|
{
|
|
const IdeDebuggerAddressRange *range = g_ptr_array_index (ranges, i);
|
|
|
|
ide_debugger_address_map_remove (priv->map, range->from);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
ide_debugger_get_property (GObject *object,
|
|
guint prop_id,
|
|
GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
IdeDebugger *self = IDE_DEBUGGER (object);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_DISPLAY_NAME:
|
|
g_value_set_string (value, ide_debugger_get_display_name (self));
|
|
break;
|
|
|
|
case PROP_SELECTED_THREAD:
|
|
g_value_set_object (value, ide_debugger_get_selected_thread (self));
|
|
break;
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
}
|
|
}
|
|
|
|
static void
|
|
ide_debugger_set_property (GObject *object,
|
|
guint prop_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
IdeDebugger *self = IDE_DEBUGGER (object);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_DISPLAY_NAME:
|
|
ide_debugger_set_display_name (self, g_value_get_string (value));
|
|
break;
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
}
|
|
}
|
|
|
|
static void
|
|
ide_debugger_class_init (IdeDebuggerClass *klass)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
|
|
object_class->finalize = ide_debugger_finalize;
|
|
object_class->get_property = ide_debugger_get_property;
|
|
object_class->set_property = ide_debugger_set_property;
|
|
|
|
klass->breakpoint_added = ide_debugger_real_breakpoint_added;
|
|
klass->breakpoint_modified = ide_debugger_real_breakpoint_modified;
|
|
klass->breakpoint_removed = ide_debugger_real_breakpoint_removed;
|
|
klass->disassemble_async = _ide_debugger_real_disassemble_async;
|
|
klass->disassemble_finish = _ide_debugger_real_disassemble_finish;
|
|
klass->get_can_move = ide_debugger_real_get_can_move;
|
|
klass->interrupt_async = _ide_debugger_real_interrupt_async;
|
|
klass->interrupt_finish = _ide_debugger_real_interrupt_finish;
|
|
klass->library_loaded = ide_debugger_real_library_loaded;
|
|
klass->library_unloaded = ide_debugger_real_library_unloaded;
|
|
klass->list_frames_async = _ide_debugger_real_list_frames_async;
|
|
klass->list_frames_finish = _ide_debugger_real_list_frames_finish;
|
|
klass->list_locals_async = _ide_debugger_real_list_locals_async;
|
|
klass->list_locals_finish = _ide_debugger_real_list_locals_finish;
|
|
klass->list_params_async = _ide_debugger_real_list_params_async;
|
|
klass->list_params_finish = _ide_debugger_real_list_params_finish;
|
|
klass->list_registers_async = _ide_debugger_real_list_registers_async;
|
|
klass->list_registers_finish = _ide_debugger_real_list_registers_finish;
|
|
klass->modify_breakpoint_async = _ide_debugger_real_modify_breakpoint_async;
|
|
klass->modify_breakpoint_finish = _ide_debugger_real_modify_breakpoint_finish;
|
|
klass->running = ide_debugger_real_running;
|
|
klass->send_signal_async = _ide_debugger_real_send_signal_async;
|
|
klass->send_signal_finish = _ide_debugger_real_send_signal_finish;
|
|
klass->stopped = ide_debugger_real_stopped;
|
|
klass->thread_added = ide_debugger_real_thread_added;
|
|
klass->thread_group_added = ide_debugger_real_thread_group_added;
|
|
klass->thread_group_removed = ide_debugger_real_thread_group_removed;
|
|
klass->thread_removed = ide_debugger_real_thread_removed;
|
|
klass->thread_selected = ide_debugger_real_thread_selected;
|
|
klass->interpret_async = _ide_debugger_real_interpret_async;
|
|
klass->interpret_finish = _ide_debugger_real_interpret_finish;
|
|
|
|
/**
|
|
* IdeDebugger:display-name:
|
|
*
|
|
* The "display-name" property is used by UI to when it is necessary
|
|
* to display the name of the debugger. You might set this to "GNU Debugger"
|
|
* or "Python Debugger", etc.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
properties [PROP_DISPLAY_NAME] =
|
|
g_param_spec_string ("display-name",
|
|
"Display Name",
|
|
"The name of the debugger to use in various UI components",
|
|
NULL,
|
|
(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* IdeDebugger:selected-thread:
|
|
*
|
|
* The currently selected thread.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
properties [PROP_SELECTED_THREAD] =
|
|
g_param_spec_object ("selected-thread",
|
|
"Selected Thread",
|
|
"The currently selected thread",
|
|
IDE_TYPE_DEBUGGER_THREAD,
|
|
(G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
|
|
|
|
g_object_class_install_properties (object_class, N_PROPS, properties);
|
|
|
|
/**
|
|
* IdeDebugger::log:
|
|
* @self: An #IdeDebugger.
|
|
* @stream: the stream to append to.
|
|
* @content: the contents for the stream.
|
|
*
|
|
* The "log" signal is emitted when there is new content to be
|
|
* appended to one of the streams.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
signals [LOG] =
|
|
g_signal_new ("log",
|
|
G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_LAST,
|
|
G_STRUCT_OFFSET (IdeDebuggerClass, log),
|
|
NULL, NULL, NULL,
|
|
G_TYPE_NONE,
|
|
2,
|
|
IDE_TYPE_DEBUGGER_STREAM,
|
|
G_TYPE_BYTES | G_SIGNAL_TYPE_STATIC_SCOPE);
|
|
|
|
/**
|
|
* IdeDebugger::thread-group-added:
|
|
* @self: an #IdeDebugger
|
|
* @thread_group: an #IdeDebuggerThreadGroup
|
|
*
|
|
* This signal is emitted when a thread-group has been added.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
signals [THREAD_GROUP_ADDED] =
|
|
g_signal_new ("thread-group-added",
|
|
G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_LAST,
|
|
G_STRUCT_OFFSET (IdeDebuggerClass, thread_group_added),
|
|
NULL, NULL, NULL,
|
|
G_TYPE_NONE,
|
|
1,
|
|
IDE_TYPE_DEBUGGER_THREAD_GROUP);
|
|
|
|
/**
|
|
* IdeDebugger::thread-group-removed:
|
|
* @self: an #IdeDebugger
|
|
* @thread_group: an #IdeDebuggerThreadGroup
|
|
*
|
|
* This signal is emitted when a thread-group has been removed.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
signals [THREAD_GROUP_REMOVED] =
|
|
g_signal_new ("thread-group-removed",
|
|
G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_LAST,
|
|
G_STRUCT_OFFSET (IdeDebuggerClass, thread_group_removed),
|
|
NULL, NULL, NULL,
|
|
G_TYPE_NONE,
|
|
1,
|
|
IDE_TYPE_DEBUGGER_THREAD_GROUP);
|
|
|
|
/**
|
|
* IdeDebugger::thread-group-started:
|
|
* @self: an #IdeDebugger
|
|
* @thread_group: an #IdeDebuggerThreadGroup
|
|
*
|
|
* This signal is emitted when a thread-group has been started.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
signals [THREAD_GROUP_STARTED] =
|
|
g_signal_new ("thread-group-started",
|
|
G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_LAST,
|
|
G_STRUCT_OFFSET (IdeDebuggerClass, thread_group_started),
|
|
NULL, NULL, NULL,
|
|
G_TYPE_NONE,
|
|
1,
|
|
IDE_TYPE_DEBUGGER_THREAD_GROUP);
|
|
|
|
/**
|
|
* IdeDebugger::thread-group-exited:
|
|
* @self: an #IdeDebugger
|
|
* @thread_group: an #IdeDebuggerThreadGroup
|
|
*
|
|
* This signal is emitted when a thread-group has exited.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
signals [THREAD_GROUP_EXITED] =
|
|
g_signal_new ("thread-group-exited",
|
|
G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_LAST,
|
|
G_STRUCT_OFFSET (IdeDebuggerClass, thread_group_exited),
|
|
NULL, NULL, NULL,
|
|
G_TYPE_NONE, 1, IDE_TYPE_DEBUGGER_THREAD_GROUP);
|
|
|
|
/**
|
|
* IdeDebugger::thread-added:
|
|
* @self: an #IdeDebugger
|
|
* @thread: an #IdeDebuggerThread
|
|
*
|
|
* The signal is emitted when a thread is added to the inferior.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
signals [THREAD_ADDED] =
|
|
g_signal_new ("thread-added",
|
|
G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_LAST,
|
|
G_STRUCT_OFFSET (IdeDebuggerClass, thread_added),
|
|
NULL, NULL, NULL,
|
|
G_TYPE_NONE, 1, IDE_TYPE_DEBUGGER_THREAD);
|
|
|
|
/**
|
|
* IdeDebugger::thread-removed:
|
|
* @self: an #IdeDebugger
|
|
* @thread: an #IdeDebuggerThread
|
|
*
|
|
* The signal is emitted when a thread is removed from the inferior.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
signals [THREAD_REMOVED] =
|
|
g_signal_new ("thread-removed",
|
|
G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_LAST,
|
|
G_STRUCT_OFFSET (IdeDebuggerClass, thread_removed),
|
|
NULL, NULL, NULL,
|
|
G_TYPE_NONE, 1, IDE_TYPE_DEBUGGER_THREAD);
|
|
|
|
/**
|
|
* IdeDebugger::thread-selected:
|
|
* @self: an #IdeDebugger
|
|
* @thread: an #IdeDebuggerThread
|
|
*
|
|
* The signal is emitted when a thread is selected in the debugger.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
signals [THREAD_SELECTED] =
|
|
g_signal_new ("thread-selected",
|
|
G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_LAST,
|
|
G_STRUCT_OFFSET (IdeDebuggerClass, thread_selected),
|
|
NULL, NULL, NULL,
|
|
G_TYPE_NONE, 1, IDE_TYPE_DEBUGGER_THREAD);
|
|
|
|
/**
|
|
* IdeDebugger::breakpoint-added:
|
|
* @self: an #IdeDebugger
|
|
* @breakpoint: an #IdeDebuggerBreakpoint
|
|
*
|
|
* The "breakpoint-added" signal is emitted when a breakpoint has been
|
|
* added to the debugger.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
signals [BREAKPOINT_ADDED] =
|
|
g_signal_new ("breakpoint-added",
|
|
G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_LAST,
|
|
G_STRUCT_OFFSET (IdeDebuggerClass, breakpoint_added),
|
|
NULL, NULL, NULL,
|
|
G_TYPE_NONE, 1, IDE_TYPE_DEBUGGER_BREAKPOINT);
|
|
|
|
/**
|
|
* IdeDebugger::breakpoint-removed:
|
|
* @self: an #IdeDebugger
|
|
* @breakpoint: an #IdeDebuggerBreakpoint
|
|
*
|
|
* The "breakpoint-removed" signal is emitted when a breakpoint has been
|
|
* removed from the debugger.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
signals [BREAKPOINT_REMOVED] =
|
|
g_signal_new ("breakpoint-removed",
|
|
G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_LAST,
|
|
G_STRUCT_OFFSET (IdeDebuggerClass, breakpoint_removed),
|
|
NULL, NULL, NULL,
|
|
G_TYPE_NONE, 1, IDE_TYPE_DEBUGGER_BREAKPOINT);
|
|
|
|
/**
|
|
* IdeDebugger::breakpoint-modified:
|
|
* @self: an #IdeDebugger
|
|
* @breakpoint: an #IdeDebuggerBreakpoint
|
|
*
|
|
* The "breakpoint-modified" signal is emitted when a breakpoint has been
|
|
* modified by the debugger.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
signals [BREAKPOINT_MODIFIED] =
|
|
g_signal_new ("breakpoint-modified",
|
|
G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_LAST,
|
|
G_STRUCT_OFFSET (IdeDebuggerClass, breakpoint_modified),
|
|
NULL, NULL, NULL,
|
|
G_TYPE_NONE, 1, IDE_TYPE_DEBUGGER_BREAKPOINT);
|
|
|
|
/**
|
|
* IdeDebugger::running:
|
|
* @self: a #IdeDebugger
|
|
*
|
|
* This signal is emitted when the debugger starts or resumes executing
|
|
* the inferior.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
signals [RUNNING] =
|
|
g_signal_new ("running",
|
|
G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_LAST,
|
|
G_STRUCT_OFFSET (IdeDebuggerClass, running),
|
|
NULL, NULL, NULL, G_TYPE_NONE, 0);
|
|
|
|
/**
|
|
* IdeDebugger::stopped:
|
|
* @self: a #IdeDebugger
|
|
* @stop_reason: An #IdeDebuggerStopReason
|
|
* @breakpoint: (nullable): An #IdeDebuggerBreakpoint if any
|
|
*
|
|
* This signal is emitted when the debugger has stopped executing the
|
|
* inferior for a variety of reasons.
|
|
*
|
|
* If possible, the debugger implementation will provide the breakpoint of
|
|
* the location the debugger stopped. That location may not always be
|
|
* representable by source in the project (such as memory address based
|
|
* breakpoints).
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
signals [STOPPED] =
|
|
g_signal_new ("stopped",
|
|
G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_LAST,
|
|
G_STRUCT_OFFSET (IdeDebuggerClass, stopped),
|
|
NULL, NULL, NULL,
|
|
G_TYPE_NONE,
|
|
2,
|
|
IDE_TYPE_DEBUGGER_STOP_REASON,
|
|
IDE_TYPE_DEBUGGER_BREAKPOINT);
|
|
|
|
/**
|
|
* IdeDebugger::library-loaded:
|
|
* @self: An #IdeDebugger
|
|
* @library: An #IdeDebuggerLibrary
|
|
*
|
|
* This signal is emitted when a library has been loaded by the debugger.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
signals [LIBRARY_LOADED] =
|
|
g_signal_new ("library-loaded",
|
|
G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_LAST,
|
|
G_STRUCT_OFFSET (IdeDebuggerClass, library_loaded),
|
|
NULL, NULL, NULL,
|
|
G_TYPE_NONE, 1, IDE_TYPE_DEBUGGER_LIBRARY);
|
|
|
|
/**
|
|
* IdeDebugger::library-unloaded:
|
|
* @self: An #IdeDebugger
|
|
* @library: An #IdeDebuggerLibrary
|
|
*
|
|
* This signal is emitted when a library has been unloaded by the debugger.
|
|
* Generally, this means that the library was a module and loaded in such a
|
|
* way that allowed unloading.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
signals [LIBRARY_UNLOADED] =
|
|
g_signal_new ("library-unloaded",
|
|
G_TYPE_FROM_CLASS (klass),
|
|
G_SIGNAL_RUN_LAST,
|
|
G_STRUCT_OFFSET (IdeDebuggerClass, library_unloaded),
|
|
NULL, NULL, NULL,
|
|
G_TYPE_NONE, 1, IDE_TYPE_DEBUGGER_LIBRARY);
|
|
}
|
|
|
|
static void
|
|
ide_debugger_init (IdeDebugger *self)
|
|
{
|
|
IdeDebuggerPrivate *priv = ide_debugger_get_instance_private (self);
|
|
|
|
priv->breakpoints = g_list_store_new (IDE_TYPE_DEBUGGER_BREAKPOINT);
|
|
priv->map = ide_debugger_address_map_new ();
|
|
priv->thread_groups = g_list_store_new (IDE_TYPE_DEBUGGER_THREAD_GROUP);
|
|
priv->threads = g_list_store_new (IDE_TYPE_DEBUGGER_THREAD);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_get_display_name:
|
|
* @self: a #IdeDebugger
|
|
*
|
|
* Gets the display name for the debugger as the user should see it in various
|
|
* UI components.
|
|
*
|
|
* Returns: The display name for the debugger
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
const gchar *
|
|
ide_debugger_get_display_name (IdeDebugger *self)
|
|
{
|
|
IdeDebuggerPrivate *priv = ide_debugger_get_instance_private (self);
|
|
|
|
g_return_val_if_fail (IDE_IS_DEBUGGER (self), NULL);
|
|
|
|
return priv->display_name;
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_set_display_name:
|
|
* @self: a #IdeDebugger
|
|
*
|
|
* Sets the #IdeDebugger:display-name property.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_set_display_name (IdeDebugger *self,
|
|
const gchar *display_name)
|
|
{
|
|
IdeDebuggerPrivate *priv = ide_debugger_get_instance_private (self);
|
|
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
|
|
if (g_strcmp0 (priv->display_name, display_name) != 0)
|
|
{
|
|
g_free (priv->display_name);
|
|
priv->display_name = g_strdup (display_name);
|
|
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_DISPLAY_NAME]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_get_can_move:
|
|
* @self: a #IdeDebugger
|
|
* @movement: the movement to check
|
|
*
|
|
* Checks to see if the debugger can make the movement matching @movement.
|
|
*
|
|
* Returns: %TRUE if @movement can be performed.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
gboolean
|
|
ide_debugger_get_can_move (IdeDebugger *self,
|
|
IdeDebuggerMovement movement)
|
|
{
|
|
g_return_val_if_fail (IDE_IS_DEBUGGER (self), FALSE);
|
|
|
|
if (IDE_DEBUGGER_GET_CLASS (self)->get_can_move)
|
|
return IDE_DEBUGGER_GET_CLASS (self)->get_can_move (self, movement);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_move_async:
|
|
* @self: a #IdeDebugger
|
|
* @movement: An #IdeDebuggerMovement
|
|
* @cancellable: (nullable): a #GCancellable or %NULL
|
|
* @callback: (scope async) (closure user_data): A callback to call upon
|
|
* completion of the operation.
|
|
* @user_data: user data for @callback
|
|
*
|
|
* Advances the debugger to the next breakpoint or until the debugger stops.
|
|
* @movement should describe the type of movement to perform.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_move_async (IdeDebugger *self,
|
|
IdeDebuggerMovement movement,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (IDE_IS_DEBUGGER_MOVEMENT (movement));
|
|
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
|
|
|
|
IDE_DEBUGGER_GET_CLASS (self)->move_async (self, movement, cancellable, callback, user_data);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_move_finish:
|
|
* @self: a #IdeDebugger
|
|
* @result: a #GAsyncResult provided to the callback
|
|
* @error: A location for a #GError, or %NULL
|
|
*
|
|
* Notifies that the movement request has been submitted to the debugger.
|
|
*
|
|
* Note that this does not indicate that the movement has completed successfully,
|
|
* only that the command has be submitted.
|
|
*
|
|
* Returns: %TRUE if successful, otherwise %FALSE
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
gboolean
|
|
ide_debugger_move_finish (IdeDebugger *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (IDE_IS_DEBUGGER (self), FALSE);
|
|
g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
|
|
|
|
return IDE_DEBUGGER_GET_CLASS (self)->move_finish (self, result, error);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_emit_log:
|
|
* @self: a #IdeDebugger
|
|
*
|
|
* Emits the "log" signal.
|
|
*
|
|
* Debugger implementations should use this to notify any listeners
|
|
* that incoming log information has been recieved.
|
|
*
|
|
* Use the #IdeDebuggerStream to denote the particular stream.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_emit_log (IdeDebugger *self,
|
|
IdeDebuggerStream stream,
|
|
GBytes *content)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (IDE_IS_DEBUGGER_STREAM (stream));
|
|
g_return_if_fail (content != NULL);
|
|
|
|
g_signal_emit (self, signals [LOG], 0, stream, content);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_thread_group_added:
|
|
* @self: an #IdeDebugger
|
|
* @thread_group: an #IdeDebuggerThreadGroup
|
|
*
|
|
* Debugger implementations should call this to notify that a thread group has
|
|
* been added to the inferior.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_emit_thread_group_added (IdeDebugger *self,
|
|
IdeDebuggerThreadGroup *thread_group)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (IDE_IS_DEBUGGER_THREAD_GROUP (thread_group));
|
|
|
|
g_signal_emit (self, signals [THREAD_GROUP_ADDED], 0, thread_group);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_thread_group_removed:
|
|
* @self: an #IdeDebugger
|
|
* @thread_group: an #IdeDebuggerThreadGroup
|
|
*
|
|
* Debugger implementations should call this to notify that a thread group has
|
|
* been removed from the inferior.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_emit_thread_group_removed (IdeDebugger *self,
|
|
IdeDebuggerThreadGroup *thread_group)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (IDE_IS_DEBUGGER_THREAD_GROUP (thread_group));
|
|
|
|
g_signal_emit (self, signals [THREAD_GROUP_REMOVED], 0, thread_group);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_thread_group_started:
|
|
* @self: an #IdeDebugger
|
|
* @thread_group: an #IdeDebuggerThreadGroup
|
|
*
|
|
* Debugger implementations should call this to notify that a thread group has
|
|
* started executing.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_emit_thread_group_started (IdeDebugger *self,
|
|
IdeDebuggerThreadGroup *thread_group)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (IDE_IS_DEBUGGER_THREAD_GROUP (thread_group));
|
|
|
|
g_signal_emit (self, signals [THREAD_GROUP_STARTED], 0, thread_group);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_thread_group_exited:
|
|
* @self: an #IdeDebugger
|
|
* @thread_group: an #IdeDebuggerThreadGroup
|
|
*
|
|
* Debugger implementations should call this to notify that a thread group has
|
|
* exited.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_emit_thread_group_exited (IdeDebugger *self,
|
|
IdeDebuggerThreadGroup *thread_group)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (IDE_IS_DEBUGGER_THREAD_GROUP (thread_group));
|
|
|
|
g_signal_emit (self, signals [THREAD_GROUP_EXITED], 0, thread_group);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_emit_thread_added:
|
|
* @self: an #IdeDebugger
|
|
* @thread: an #IdeDebuggerThread
|
|
*
|
|
* Emits the #IdeDebugger::thread-added signal notifying that a new thread
|
|
* has been added to the inferior.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_emit_thread_added (IdeDebugger *self,
|
|
IdeDebuggerThread *thread)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (IDE_IS_DEBUGGER_THREAD (thread));
|
|
|
|
g_signal_emit (self, signals [THREAD_ADDED], 0, thread);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_emit_thread_removed:
|
|
* @self: an #IdeDebugger
|
|
* @thread: an #IdeDebuggerThread
|
|
*
|
|
* Emits the #IdeDebugger::thread-removed signal notifying that a thread has
|
|
* been removed to the inferior.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_emit_thread_removed (IdeDebugger *self,
|
|
IdeDebuggerThread *thread)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (IDE_IS_DEBUGGER_THREAD (thread));
|
|
|
|
g_signal_emit (self, signals [THREAD_REMOVED], 0, thread);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_emit_thread_selected:
|
|
* @self: an #IdeDebugger
|
|
* @thread: an #IdeDebuggerThread
|
|
*
|
|
* Emits the #IdeDebugger::thread-selected signal notifying that a thread
|
|
* has been set as the current debugging thread.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_emit_thread_selected (IdeDebugger *self,
|
|
IdeDebuggerThread *thread)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (IDE_IS_DEBUGGER_THREAD (thread));
|
|
|
|
g_signal_emit (self, signals [THREAD_SELECTED], 0, thread);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_emit_breakpoint_added:
|
|
* @self: an #IdeDebugger
|
|
* @breakpoint: an #IdeDebuggerBreakpoint
|
|
*
|
|
* Emits the #IdeDebugger::breakpoint-added signal.
|
|
*
|
|
* Debugger implementations should call this when a new breakpoint
|
|
* has been registered with the debugger.
|
|
*
|
|
* If a breakpoint has changed, you should use
|
|
* ide_debugger_emit_breakpoint_modified() to notify of the modification.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_emit_breakpoint_added (IdeDebugger *self,
|
|
IdeDebuggerBreakpoint *breakpoint)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (IDE_IS_DEBUGGER_BREAKPOINT (breakpoint));
|
|
|
|
g_signal_emit (self, signals [BREAKPOINT_ADDED], 0, breakpoint);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_emit_breakpoint_removed:
|
|
* @self: an #IdeDebugger
|
|
* @breakpoint: an #IdeDebuggerBreakpoint
|
|
*
|
|
* Emits the #IdeDebugger::breakpoint-removed signal.
|
|
*
|
|
* Debugger implementations should call this when a breakpoint has been removed
|
|
* either manually or automatically by the debugger.
|
|
*
|
|
* If a breakpoint has changed, you should use
|
|
* ide_debugger_emit_breakpoint_modified() to notify of the modification.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_emit_breakpoint_removed (IdeDebugger *self,
|
|
IdeDebuggerBreakpoint *breakpoint)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (IDE_IS_DEBUGGER_BREAKPOINT (breakpoint));
|
|
|
|
g_signal_emit (self, signals [BREAKPOINT_REMOVED], 0, breakpoint);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_emit_breakpoint_modified:
|
|
* @self: an #IdeDebugger
|
|
* @breakpoint: an #IdeDebuggerBreakpoint
|
|
*
|
|
* Emits the #IdeDebugger::breakpoint-modified signal.
|
|
*
|
|
* Debugger implementations should call this when a breakpoint has changed
|
|
* in the underlying debugger.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_emit_breakpoint_modified (IdeDebugger *self,
|
|
IdeDebuggerBreakpoint *breakpoint)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (IDE_IS_DEBUGGER_BREAKPOINT (breakpoint));
|
|
|
|
g_signal_emit (self, signals [BREAKPOINT_MODIFIED], 0, breakpoint);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_emit_running:
|
|
* @self: an #IdeDebugger
|
|
*
|
|
* Emits the "running" signal.
|
|
*
|
|
* Debugger implementations should call this when the debugger has started
|
|
* or restarted executing the inferior.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_emit_running (IdeDebugger *self)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
|
|
g_signal_emit (self, signals [RUNNING], 0);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_emit_stopped:
|
|
* @self: an #IdeDebugger
|
|
* @stop_reason: the reason the debugger stopped
|
|
* @breakpoint: the breakpoint representing the stop location
|
|
*
|
|
* Emits the "stopped" signal.
|
|
*
|
|
* Debugger implementations should call this when the debugger has stopped
|
|
* and include the reason and location of the stop.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_emit_stopped (IdeDebugger *self,
|
|
IdeDebuggerStopReason stop_reason,
|
|
IdeDebuggerBreakpoint *breakpoint)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (IDE_IS_DEBUGGER_STOP_REASON (stop_reason));
|
|
g_return_if_fail (IDE_IS_DEBUGGER_BREAKPOINT (breakpoint));
|
|
|
|
g_signal_emit (self, signals [STOPPED], 0, stop_reason, breakpoint);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_emit_library_loaded:
|
|
* @self: an #IdeDebugger
|
|
* @library: an #IdeDebuggerLibrary
|
|
*
|
|
* Emits the "library-loaded" signal.
|
|
*
|
|
* Debugger implementations should call this when the debugger has loaded
|
|
* a new library.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_emit_library_loaded (IdeDebugger *self,
|
|
IdeDebuggerLibrary *library)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (IDE_IS_DEBUGGER_LIBRARY (library));
|
|
|
|
g_signal_emit (self, signals [LIBRARY_LOADED], 0, library);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_emit_library_unloaded:
|
|
* @self: an #IdeDebugger
|
|
* @library: an #IdeDebuggerLibrary
|
|
*
|
|
* Emits the "library-unloaded" signal.
|
|
*
|
|
* Debugger implementations should call this when the debugger has unloaded a
|
|
* library.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_emit_library_unloaded (IdeDebugger *self,
|
|
IdeDebuggerLibrary *library)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (IDE_IS_DEBUGGER_LIBRARY (library));
|
|
|
|
g_signal_emit (self, signals [LIBRARY_UNLOADED], 0, library);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_list_breakpoints_async:
|
|
* @self: An #IdeDebugger
|
|
* @cancellable: (nullable): a #GCancellable, or %NULL
|
|
* @callback: a callback to call upon completion
|
|
* @user_data: user data for @callback
|
|
*
|
|
* Asynchronously requests the list of current breakpoints from the debugger.
|
|
*
|
|
* #IdeDebugger implementations must implement the virtual function
|
|
* for this method.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_list_breakpoints_async (IdeDebugger *self,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
|
|
|
|
IDE_DEBUGGER_GET_CLASS (self)->list_breakpoints_async (self, cancellable, callback, user_data);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_list_breakpoints_finish:
|
|
* @self: An #IdeDebugger
|
|
* @result: a #GAsyncResult provided to the async callback
|
|
* @error: a location for a #GError or %NULL
|
|
*
|
|
* Gets the list of breakpoints from the debugger.
|
|
*
|
|
* Returns: (transfer full) (element-type Ide.DebuggerBreakpoint): a #GPtrArray
|
|
* of breakpoints that are registered with the debugger.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
GPtrArray *
|
|
ide_debugger_list_breakpoints_finish (IdeDebugger *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (IDE_IS_DEBUGGER (self), NULL);
|
|
g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL);
|
|
|
|
return IDE_DEBUGGER_GET_CLASS (self)->list_breakpoints_finish (self, result, error);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_insert_breakpoint_async:
|
|
* @self: An #IdeDebugger
|
|
* @breakpoint: An #IdeDebuggerBreakpoint
|
|
* @cancellable: (nullable): a #GCancellable or %NULL
|
|
* @callback: an async callback to complete the operation
|
|
* @user_data: user data for @callback
|
|
*
|
|
* Asynchronously requests that a breakpoint is added to the debugger.
|
|
*
|
|
* This asynchronous function may complete before the breakpoint has been
|
|
* registered in the debugger. Debugger implementations will emit
|
|
* #IdeDebugger::breakpoint-added when a breakpoint has been registered.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_insert_breakpoint_async (IdeDebugger *self,
|
|
IdeDebuggerBreakpoint *breakpoint,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (IDE_IS_DEBUGGER_BREAKPOINT (breakpoint));
|
|
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
|
|
|
|
IDE_DEBUGGER_GET_CLASS (self)->insert_breakpoint_async (self,
|
|
breakpoint,
|
|
cancellable,
|
|
callback,
|
|
user_data);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_insert_breakpoint_finish:
|
|
* @self: An #IdeDebugger
|
|
* @result: a #GAsyncResult or %NULL
|
|
* @error: a #GError, or %NULL
|
|
*
|
|
* Completes a request to asynchronously insert a breakpoint.
|
|
*
|
|
* See also: ide_debugger_insert_breakpoint_async()
|
|
*
|
|
* Returns: %TRUE if the command was submitted successfully; otherwise %FALSE
|
|
* and @error is set.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
gboolean
|
|
ide_debugger_insert_breakpoint_finish (IdeDebugger *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (IDE_IS_DEBUGGER (self), FALSE);
|
|
g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
|
|
|
|
return IDE_DEBUGGER_GET_CLASS (self)->insert_breakpoint_finish (self, result, error);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_remove_breakpoint_async:
|
|
* @self: An #IdeDebugger
|
|
* @breakpoint: An #IdeDebuggerBreakpoint
|
|
* @cancellable: (nullable): a #GCancellable or %NULL
|
|
* @callback: an async callback to complete the operation
|
|
* @user_data: user data for @callback
|
|
*
|
|
* Asynchronously requests that a breakpoint is removed from the debugger.
|
|
*
|
|
* This asynchronous function may complete before the breakpoint has been
|
|
* removed by the debugger. Debugger implementations will emit
|
|
* #IdeDebugger::breakpoint-removed when a breakpoint has been removed.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_remove_breakpoint_async (IdeDebugger *self,
|
|
IdeDebuggerBreakpoint *breakpoint,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (IDE_IS_DEBUGGER_BREAKPOINT (breakpoint));
|
|
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
|
|
|
|
IDE_DEBUGGER_GET_CLASS (self)->remove_breakpoint_async (self,
|
|
breakpoint,
|
|
cancellable,
|
|
callback,
|
|
user_data);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_remove_breakpoint_finish:
|
|
* @self: An #IdeDebugger
|
|
* @result: a #GAsyncResult or %NULL
|
|
* @error: a #GError, or %NULL
|
|
*
|
|
* Completes a request to asynchronously remove a breakpoint.
|
|
*
|
|
* See also: ide_debugger_remove_breakpoint_async()
|
|
*
|
|
* Returns: %TRUE if the command was submitted successfully; otherwise %FALSE and @error is set.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
gboolean
|
|
ide_debugger_remove_breakpoint_finish (IdeDebugger *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (IDE_IS_DEBUGGER (self), FALSE);
|
|
g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
|
|
|
|
return IDE_DEBUGGER_GET_CLASS (self)->remove_breakpoint_finish (self, result, error);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_modify_breakpoint_async:
|
|
* @self: An #IdeDebugger
|
|
* @change: An #IdeDebuggerBreakpointChange
|
|
* @breakpoint: An #IdeDebuggerBreakpoint
|
|
* @cancellable: (nullable): a #GCancellable or %NULL
|
|
* @callback: an async callback to complete the operation
|
|
* @user_data: user data for @callback
|
|
*
|
|
* Asynchronously requests that a breakpoint is modified by the debugger backend.
|
|
*
|
|
* Specify @change for how to modify the breakpoint.
|
|
*
|
|
* This asynchronous function may complete before the breakpoint has been
|
|
* modified by the debugger. Debugger implementations will emit
|
|
* #IdeDebugger::breakpoint-modified when a breakpoint has been removed.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_modify_breakpoint_async (IdeDebugger *self,
|
|
IdeDebuggerBreakpointChange change,
|
|
IdeDebuggerBreakpoint *breakpoint,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (IDE_IS_DEBUGGER_BREAKPOINT_CHANGE (change));
|
|
g_return_if_fail (IDE_IS_DEBUGGER_BREAKPOINT (breakpoint));
|
|
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
|
|
|
|
IDE_DEBUGGER_GET_CLASS (self)->modify_breakpoint_async (self,
|
|
change,
|
|
breakpoint,
|
|
cancellable,
|
|
callback,
|
|
user_data);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_modify_breakpoint_finish:
|
|
* @self: a #IdeDebugger
|
|
* @result: a #GAsyncResult
|
|
* @error: a location for a #GError or %NULL
|
|
*
|
|
* Completes an asynchronous request to modify a breakpoint.
|
|
*
|
|
* Note that this only completes the submission of the request, if you need to
|
|
* know when the breakpoint has been modified, listen to the
|
|
* #IdeDebugger::breakpoint-modified signal.
|
|
*
|
|
* Returns: %TRUE if successful; otherwise %FALSE and @error is set.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
gboolean
|
|
ide_debugger_modify_breakpoint_finish (IdeDebugger *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (IDE_IS_DEBUGGER (self), FALSE);
|
|
g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
|
|
|
|
return IDE_DEBUGGER_GET_CLASS (self)->modify_breakpoint_finish (self, result, error);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_get_breakpoints:
|
|
* @self: An #IdeDebugger
|
|
*
|
|
* Gets the breakpoints for the #IdeDebugger.
|
|
*
|
|
* Contrast this to ide_debugger_list_breakpoints_async() which will query
|
|
* the debugger backend for breakpoints. This #GListModel containing
|
|
* #IdeDebuggerBreakpoint instances is updated as necessary by listening
|
|
* to various breakpoint related signals on the #IdeDebugger instance.
|
|
*
|
|
* This is primarily out of convenience to be used by UI which wants to
|
|
* display information on breakpoints.
|
|
*
|
|
* Returns: (transfer none) (not nullable): a #GListModel of #IdeDebuggerBreakpoint
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
GListModel *
|
|
ide_debugger_get_breakpoints (IdeDebugger *self)
|
|
{
|
|
IdeDebuggerPrivate *priv = ide_debugger_get_instance_private (self);
|
|
|
|
g_return_val_if_fail (IDE_IS_DEBUGGER (self), NULL);
|
|
|
|
return G_LIST_MODEL (priv->breakpoints);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_get_thread_groups:
|
|
* @self: a #IdeDebugger
|
|
*
|
|
* Gets the thread groups that have been registered by the debugger.
|
|
*
|
|
* The resulting #GListModel accuracy is based on the #IdeDebugger
|
|
* implementation emitting varous thread-group modification signals correctly.
|
|
*
|
|
* Returns: (transfer none) (not nullable): a #GListModel of #IdeDebuggerThreadGroup
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
GListModel *
|
|
ide_debugger_get_thread_groups (IdeDebugger *self)
|
|
{
|
|
IdeDebuggerPrivate *priv = ide_debugger_get_instance_private (self);
|
|
|
|
g_return_val_if_fail (IDE_IS_DEBUGGER (self), NULL);
|
|
|
|
return G_LIST_MODEL (priv->thread_groups);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_get_threads:
|
|
* @self: a #IdeDebugger
|
|
*
|
|
* Gets the threads that have been registered by the debugger.
|
|
*
|
|
* The resulting #GListModel accuracy is based on the #IdeDebugger
|
|
* implementation emitting varous thread modification signals correctly.
|
|
*
|
|
* Returns: (transfer none) (not nullable): a #GListModel of #IdeDebuggerThread
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
GListModel *
|
|
ide_debugger_get_threads (IdeDebugger *self)
|
|
{
|
|
IdeDebuggerPrivate *priv = ide_debugger_get_instance_private (self);
|
|
|
|
g_return_val_if_fail (IDE_IS_DEBUGGER (self), NULL);
|
|
|
|
return G_LIST_MODEL (priv->threads);
|
|
}
|
|
|
|
void
|
|
ide_debugger_list_frames_async (IdeDebugger *self,
|
|
IdeDebuggerThread *thread,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (IDE_IS_DEBUGGER_THREAD (thread));
|
|
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
|
|
|
|
IDE_DEBUGGER_GET_CLASS (self)->list_frames_async (self, thread, cancellable, callback, user_data);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_list_frames_finish:
|
|
*
|
|
*
|
|
*
|
|
* Returns: (transfer full) (element-type Ide.DebuggerFrame) (nullable): An
|
|
* array of debugger frames or %NULL and @error is set.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
GPtrArray *
|
|
ide_debugger_list_frames_finish (IdeDebugger *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (IDE_IS_DEBUGGER (self), NULL);
|
|
g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL);
|
|
|
|
return IDE_DEBUGGER_GET_CLASS (self)->list_frames_finish (self, result, error);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_get_selected_thread:
|
|
* @self: An #IdeDebugger
|
|
*
|
|
* Gets the current selected thread by the debugger.
|
|
*
|
|
* Returns: (transfer none) (nullable): An #IdeDebuggerThread or %NULL
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
IdeDebuggerThread *
|
|
ide_debugger_get_selected_thread (IdeDebugger *self)
|
|
{
|
|
IdeDebuggerPrivate *priv = ide_debugger_get_instance_private (self);
|
|
|
|
g_return_val_if_fail (IDE_IS_DEBUGGER (self), NULL);
|
|
|
|
return priv->selected;
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_interrupt_async:
|
|
* @self: a #IdeDebugger
|
|
* @thread_group: (nullable): An #IdeDebuggerThreadGroup
|
|
* @cancellable: (nullable): a #GCancellable or %NULL
|
|
* @callback: (closure user_data): a callback to execute upon completion
|
|
* @user_data: closure data for @callback
|
|
*
|
|
* Asynchronously requests that the debugger interrupts execution of a thread
|
|
* group. Thread groups are a collection of threads that are executed or
|
|
* stopped together and on gdb on Linux, this is the default for all threads in
|
|
* the process.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_interrupt_async (IdeDebugger *self,
|
|
IdeDebuggerThreadGroup *thread_group,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (!thread_group || IDE_IS_DEBUGGER_THREAD_GROUP (thread_group));
|
|
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
|
|
|
|
IDE_DEBUGGER_GET_CLASS (self)->interrupt_async (self, thread_group, cancellable, callback, user_data);
|
|
}
|
|
|
|
gboolean
|
|
ide_debugger_interrupt_finish (IdeDebugger *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (IDE_IS_DEBUGGER (self), FALSE);
|
|
g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
|
|
|
|
return IDE_DEBUGGER_GET_CLASS (self)->interrupt_finish (self, result, error);
|
|
}
|
|
|
|
gboolean
|
|
ide_debugger_get_is_running (IdeDebugger *self)
|
|
{
|
|
IdeDebuggerPrivate *priv = ide_debugger_get_instance_private (self);
|
|
|
|
g_return_val_if_fail (IDE_IS_DEBUGGER (self), FALSE);
|
|
|
|
return priv->is_running;
|
|
}
|
|
|
|
gboolean
|
|
_ide_debugger_get_has_started (IdeDebugger *self)
|
|
{
|
|
IdeDebuggerPrivate *priv = ide_debugger_get_instance_private (self);
|
|
|
|
g_return_val_if_fail (IDE_IS_DEBUGGER (self), FALSE);
|
|
|
|
return priv->has_started;
|
|
}
|
|
|
|
void
|
|
ide_debugger_send_signal_async (IdeDebugger *self,
|
|
gint signum,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
|
|
|
|
IDE_DEBUGGER_GET_CLASS (self)->send_signal_async (self, signum, cancellable, callback, user_data);
|
|
}
|
|
|
|
gboolean
|
|
ide_debugger_send_signal_finish (IdeDebugger *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (IDE_IS_DEBUGGER (self), FALSE);
|
|
g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
|
|
|
|
return IDE_DEBUGGER_GET_CLASS (self)->send_signal_finish (self, result, error);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_locate_binary_at_address:
|
|
* @self: a #IdeDebugger
|
|
* @address: the address within the inferior process space
|
|
*
|
|
* Attempts to locate the binary that contains a given address.
|
|
*
|
|
* @address should be an address within the inferiors process space.
|
|
*
|
|
* This works by keeping track of libraries as they are loaded and unloaded and
|
|
* their associated file mappings.
|
|
*
|
|
* Currently, the filename will match the name in the inferior mount namespace,
|
|
* but that may change based on future design changes.
|
|
*
|
|
* Returns: the filename of the binary or %NULL
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
const gchar *
|
|
ide_debugger_locate_binary_at_address (IdeDebugger *self,
|
|
IdeDebuggerAddress address)
|
|
{
|
|
IdeDebuggerPrivate *priv = ide_debugger_get_instance_private (self);
|
|
const IdeDebuggerAddressMapEntry *entry;
|
|
|
|
g_return_val_if_fail (IDE_IS_DEBUGGER (self), NULL);
|
|
|
|
entry = ide_debugger_address_map_lookup (priv->map, address);
|
|
|
|
if (entry != NULL)
|
|
return entry->filename;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_list_locals_async:
|
|
* @self: an #IdeDebugger
|
|
* @thread: an #IdeDebuggerThread
|
|
* @frame: an #IdeDebuggerFrame
|
|
* @cancellable: (nullable): a #GCancellable or %NULL
|
|
* @callback: A callback to call once the operation has finished
|
|
* @user_data: user data for @callback
|
|
*
|
|
* Requests the debugger backend to list the locals that are available to the
|
|
* given @frame of @thread.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_list_locals_async (IdeDebugger *self,
|
|
IdeDebuggerThread *thread,
|
|
IdeDebuggerFrame *frame,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (IDE_IS_DEBUGGER_THREAD (thread));
|
|
g_return_if_fail (IDE_IS_DEBUGGER_FRAME (frame));
|
|
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
|
|
|
|
IDE_DEBUGGER_GET_CLASS (self)->list_locals_async (self,
|
|
thread,
|
|
frame,
|
|
cancellable,
|
|
callback,
|
|
user_data);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_list_locals_finish:
|
|
* @self: a #IdeDebugger
|
|
* @result: a #GAsyncResult
|
|
* @error: a location for a #GError or %NULL
|
|
*
|
|
* Completes an asynchronous request to ide_debugger_list_locals_async().
|
|
*
|
|
* Returns: (transfer full) (element-type Ide.DebuggerVariable): a #GPtrArray of
|
|
* #IdeDebuggerVariable if successful; otherwise %NULL and error is set.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
GPtrArray *
|
|
ide_debugger_list_locals_finish (IdeDebugger *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (IDE_IS_DEBUGGER (self), NULL);
|
|
g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL);
|
|
|
|
return IDE_DEBUGGER_GET_CLASS (self)->list_locals_finish (self, result, error);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_list_params_async:
|
|
* @self: an #IdeDebugger
|
|
* @thread: an #IdeDebuggerThread
|
|
* @frame: an #IdeDebuggerFrame
|
|
* @cancellable: (nullable): a #GCancellable or %NULL
|
|
* @callback: A callback to call once the operation has finished
|
|
* @user_data: user data for @callback
|
|
*
|
|
* Requests the debugger backend to list the parameters to the given stack
|
|
* frame.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_list_params_async (IdeDebugger *self,
|
|
IdeDebuggerThread *thread,
|
|
IdeDebuggerFrame *frame,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (IDE_IS_DEBUGGER_THREAD (thread));
|
|
g_return_if_fail (IDE_IS_DEBUGGER_FRAME (frame));
|
|
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
|
|
|
|
IDE_DEBUGGER_GET_CLASS (self)->list_params_async (self,
|
|
thread,
|
|
frame,
|
|
cancellable,
|
|
callback,
|
|
user_data);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_list_params_finish:
|
|
* @self: a #IdeDebugger
|
|
* @result: a #GAsyncResult
|
|
* @error: a location for a #GError or %NULL
|
|
*
|
|
* Completes an asynchronous request to ide_debugger_list_params_async().
|
|
*
|
|
* Returns: (transfer full) (element-type Ide.DebuggerVariable): a #GPtrArray of
|
|
* #IdeDebuggerVariable if successful; otherwise %NULL and error is set.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
GPtrArray *
|
|
ide_debugger_list_params_finish (IdeDebugger *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (IDE_IS_DEBUGGER (self), NULL);
|
|
g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL);
|
|
|
|
return IDE_DEBUGGER_GET_CLASS (self)->list_params_finish (self, result, error);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_list_registers_async:
|
|
* @self: an #IdeDebugger
|
|
* @cancellable: (nullable): a #GCancellable or %NULL
|
|
* @callback: A callback to call once the operation has finished
|
|
* @user_data: user data for @callback
|
|
*
|
|
* Requests the list of registers and their values.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_list_registers_async (IdeDebugger *self,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
|
|
|
|
IDE_DEBUGGER_GET_CLASS (self)->list_registers_async (self, cancellable, callback, user_data);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_list_registers_finish:
|
|
* @self: a #IdeDebugger
|
|
* @result: a #GAsyncResult
|
|
* @error: a location for a #GError or %NULL
|
|
*
|
|
* Completes an asynchronous request to ide_debugger_list_registers_async().
|
|
*
|
|
* Returns: (transfer full) (element-type Ide.DebuggerRegister): a #GPtrArray of
|
|
* #IdeDebuggerRegister if successful; otherwise %NULL and error is set.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
GPtrArray *
|
|
ide_debugger_list_registers_finish (IdeDebugger *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (IDE_IS_DEBUGGER (self), NULL);
|
|
g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL);
|
|
|
|
return IDE_DEBUGGER_GET_CLASS (self)->list_registers_finish (self, result, error);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_disassemble_async:
|
|
* @self: an #IdeDebugger
|
|
* @range: an #IdeDebuggerAddressRange to disassemble
|
|
* @cancellable: (nullable): a #GCancellable or %NULL
|
|
* @callback: A callback to call once the operation has finished
|
|
* @user_data: user data for @callback
|
|
*
|
|
* Disassembles the address range requested.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_disassemble_async (IdeDebugger *self,
|
|
const IdeDebuggerAddressRange *range,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (range != NULL);
|
|
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
|
|
|
|
IDE_DEBUGGER_GET_CLASS (self)->disassemble_async (self, range, cancellable, callback, user_data);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_disassemble_finish:
|
|
* @self: a #IdeDebugger
|
|
* @result: a #GAsyncResult
|
|
* @error: a location for a #GError or %NULL
|
|
*
|
|
* Completes an asynchronous request to ide_debugger_disassemble_async().
|
|
*
|
|
* Returns: (transfer full) (element-type Ide.DebuggerInstruction): a #GPtrArray
|
|
* of #IdeDebuggerInstruction if successful; otherwise %NULL and error is set.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
GPtrArray *
|
|
ide_debugger_disassemble_finish (IdeDebugger *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (IDE_IS_DEBUGGER (self), NULL);
|
|
g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL);
|
|
|
|
return IDE_DEBUGGER_GET_CLASS (self)->disassemble_finish (self, result, error);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_supports_runner:
|
|
* @self: an #IdeDebugger
|
|
* @runner: an #IdeRunner
|
|
* @priority: (out): A location for a priority
|
|
*
|
|
* Checks if the debugger supports a given runner. The debugger may need
|
|
* to check if the binary type matches it's expectation.
|
|
*
|
|
* Returns: %TRUE if the #IdeDebugger supports the runner.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
gboolean
|
|
ide_debugger_supports_runner (IdeDebugger *self,
|
|
IdeRunner *runner,
|
|
gint *priority)
|
|
{
|
|
gint dummy = 0;
|
|
|
|
g_return_val_if_fail (IDE_IS_DEBUGGER (self), FALSE);
|
|
g_return_val_if_fail (IDE_IS_RUNNER (runner), FALSE);
|
|
|
|
if (priority == NULL)
|
|
priority = &dummy;
|
|
else
|
|
*priority = 0;
|
|
|
|
return IDE_DEBUGGER_GET_CLASS (self)->supports_runner (self, runner, priority);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_prepare:
|
|
* @self: an #IdeDebugger
|
|
* @runner: an #IdeRunner
|
|
*
|
|
* Prepares the runner to launch a debugger and target process.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_prepare (IdeDebugger *self,
|
|
IdeRunner *runner)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (IDE_IS_RUNNER (runner));
|
|
|
|
if (IDE_DEBUGGER_GET_CLASS (self)->prepare)
|
|
IDE_DEBUGGER_GET_CLASS (self)->prepare (self, runner);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_interpret_async:
|
|
* @self: an #IdeDebugger
|
|
* @command: a command to execute
|
|
* @cancellable: (nullable): a #GCancellable or %NULL
|
|
* @callback: a callback to execute, or %NULL
|
|
* @user_data: user data for @callback
|
|
*
|
|
* Asynchronously requests that the debugger interpret the command.
|
|
*
|
|
* This is used by the interactive-console to submit commands to the debugger
|
|
* that are in the native syntax of that debugger.
|
|
*
|
|
* The debugger is expected to return any textual output via the
|
|
* IdeDebugger::log signal.
|
|
*
|
|
* Call ide_debugger_interpret_finish() from @callback to determine if the
|
|
* command was interpreted.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
void
|
|
ide_debugger_interpret_async (IdeDebugger *self,
|
|
const gchar *command,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
g_return_if_fail (IDE_IS_DEBUGGER (self));
|
|
g_return_if_fail (command != NULL);
|
|
|
|
return IDE_DEBUGGER_GET_CLASS (self)->interpret_async (self, command, cancellable, callback, user_data);
|
|
}
|
|
|
|
/**
|
|
* ide_debugger_interpret_finish:
|
|
* @self: an #IdeDebugger
|
|
* @result: a #GAsyncResult provided to callback
|
|
* @error: a location for a #GError, or %NULL
|
|
*
|
|
* Retrieves the result of the asynchronous operation to interpret a debugger
|
|
* command.
|
|
*
|
|
* Returns: %TRUE if the command was interpreted, otherwise %FALSE and
|
|
* @error is set.
|
|
*
|
|
* Since: 3.32
|
|
*/
|
|
gboolean
|
|
ide_debugger_interpret_finish (IdeDebugger *self,
|
|
GAsyncResult *result,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (IDE_IS_DEBUGGER (self), FALSE);
|
|
g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
|
|
|
|
return IDE_DEBUGGER_GET_CLASS (self)->interpret_finish (self, result, error);
|
|
}
|