[anjuta] debugger: bgo#558954 - Documentation for debug interfaces is incomplete
- From: Sebastien Granjoux <sgranjoux src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [anjuta] debugger: bgo#558954 - Documentation for debug interfaces is incomplete
- Date: Sat, 24 Jul 2010 15:04:18 +0000 (UTC)
commit 60d47aa63a3e467bc88b05e0ffdad2dc28351b46
Author: Sébastien Granjoux <seb sfo free fr>
Date: Sat Jul 24 16:48:44 2010 +0200
debugger: bgo#558954 - Documentation for debug interfaces is incomplete
libanjuta/interfaces/libanjuta.idl | 368 ++++++++++++++++++++++++++++--------
plugins/debug-manager/command.c | 66 ++++----
plugins/gdb/debugger.c | 128 +++++++-------
plugins/gdb/debugger.h | 70 ++++----
plugins/gdb/plugin.c | 77 ++++-----
plugins/js-debugger/debugger-js.c | 28 ++--
plugins/js-debugger/debugger-js.h | 14 +-
plugins/js-debugger/plugin.c | 63 +++----
8 files changed, 504 insertions(+), 310 deletions(-)
---
diff --git a/libanjuta/interfaces/libanjuta.idl b/libanjuta/interfaces/libanjuta.idl
index a9b1288..6d6a9e4 100644
--- a/libanjuta/interfaces/libanjuta.idl
+++ b/libanjuta/interfaces/libanjuta.idl
@@ -1,4 +1,5 @@
// -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
+// -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
//
// libanjuta interfaces. Generate stubs with anjuta-idl-compiler.pl
//
@@ -3629,6 +3630,32 @@ interface IAnjutaDebugger
#include <gio/gio.h>
/* Types */
+ /**
+ * IAnjutaDebuggerError:
+ * @IANJUTA_DEBUGGER_OK: No error
+ * @IANJUTA_DEBUGGER_NOT_READY: Debugger is not ready to execute the command
+ * @IANJUTA_DEBUGGER_NOT_RUNNING: Debugger is not is running state
+ * @IANJUTA_DEBUGGER_NOT_STOPPED: Debugger is not is stopped state
+ * @IANJUTA_DEBUGGER_NOT_LOADED: Debugger is not is loaded state
+ * @IANJUTA_DEBUGGER_NOT_STARTED: Debugger is not in started state
+ * @IANJUTA_DEBUGGER_NOT_CONNECTED: Debugger is not connected:
+ * @IANJUTA_DEBUGGER_NOT_IMPLEMENTED: Corresponding function is not implemented
+ * @IANJUTA_DEBUGGER_CANCEL: Operation has been cancelled
+ * @IANJUTA_DEBUGGER_UNABLE_TO_CREATE_VARIABLE: Debugger cannot create variable
+ * @IANJUTA_DEBUGGER_UNABLE_TO_ACCESS_MEMORY: Debugger cannot access memory
+ * @IANJUTA_DEBUGGER_UNABLE_TO_OPEN_FILE: Debugger cannot open file
+ * @IANJUTA_DEBUGGER_UNSUPPORTED_FILE_TYPE: Debugger cannot debug such file
+ * @IANJUTA_DEBUGGER_UNSUPPORTED_VERSION: Debugger is too old
+ * @IANJUTA_DEBUGGER_UNABLE_TO_FIND_DEBUGGER: Debugger cannot be found
+ * @IANJUTA_DEBUGGER_ALREADY_DONE: Command has already been executed
+ * @IANJUTA_DEBUGGER_PROGRAM_NOT_FOUND: Program cannot be found
+ * @IANJUTA_DEBUGGER_UNABLE_TO_CONNECT: Unable to connect to debugger
+ * @IANJUTA_DEBUGGER_UNKNOWN_ERROR: Unknown error
+ * @IANJUTA_DEBUGGER_OTHER_ERROR: other error
+ *
+ * This enumeration is used to defined the error returned by the debugger
+ * backend.
+ */
enum Error
{
OK = 0,
@@ -3653,15 +3680,16 @@ interface IAnjutaDebugger
OTHER_ERROR
}
- enum Data
- {
- INFORMATION,
- BREAKPOINT,
- FRAME,
- VARIABLE,
- REGISTER
- }
-
+ /**
+ * IAnjutaDebuggerOutputType:
+ * @IANJUTA_DEBUGGER_OUTPUT: Output from debugger
+ * @IANJUTA_DEBUGGER_WARNING_OUTPUT: Warning from debugger
+ * @IANJUTA_DEBUGGER_ERROR_OUTPUT: Error from debugger
+ * @IANJUTA_DEBUGGER_INFO_OUTPUT: Additional message from debugger
+ *
+ * This enumeration is used to defined the kind of output in
+ * #IAnjutaDebuggerOutputCallback
+ */
enum OutputType
{
OUTPUT,
@@ -3670,6 +3698,18 @@ interface IAnjutaDebugger
INFO_OUTPUT
}
+ /**
+ * IAnjutaDebuggerState:
+ * @IANJUTA_DEBUGGER_BUSY: Debugger is executing a command, it can enter in another
+ * at the end of the command.
+ * @IANJUTA_DEBUGGER_STOPPED: Debugger is stopped.
+ * @IANJUTA_DEBUGGER_STARTED: Debugger is started but no program is loaded.
+ * @IANJUTA_DEBUGGER_PROGRAM_LOADED: Debugger is started and has a program loaded.
+ * @IANJUTA_DEBUGGER_PROGRAM_STOPPED: Debugger is started and has a program stopped.
+ * @IANJUTA_DEBUGGER_PROGRAM_RUNNING: Debugger is started and has a program running.
+ *
+ * This enumeration is used to defined the different state of the debugger.
+ */
enum State
{
BUSY,
@@ -3680,6 +3720,19 @@ interface IAnjutaDebugger
PROGRAM_RUNNING
}
+ /**
+ * IAnjutaDebuggerFrame:
+ * @thread: Thread identifier.
+ * @level: Level of the frame, 0 is the topmost one.
+ * @args: List of argument of the caller.
+ * @file: Source file name where is the program counter.
+ * @line: Line number in the file above.
+ * @function: Function name where is the program counter.
+ * @library: Library name where is the program counter.
+ * @address: Address of the program counter.
+ *
+ * This structure keeps all information about a stack frame.
+ */
struct Frame
{
gint thread;
@@ -3692,12 +3745,51 @@ interface IAnjutaDebugger
gulong address;
}
- /* Call back functions */
+ /**
+ * IAnjutaDebuggerCallback:
+ * @data: data
+ * @user_data: user data passed to the function
+ * @error: error
+ *
+ * This callback function is used only by #ianjuta_debugger_callback with a
+ * NULL data.
+ */
typedef void (*Callback) (const gpointer data, gpointer user_data, GError* err);
+
+ /**
+ * IAnjutaDebuggerGListCallback:
+ * @list: list of data
+ * @user_data: user data passed to the function
+ * @error: error
+ *
+ * This callback function is used by several debugger functions. Depending on
+ * the function, the kind of elements in the list is different. It is a string
+ * for #ianjuta_debugger_list_local or a #IAnjutaDebuggerFrame for
+ * #ianjuta_debugger_list_frame.
+ */
typedef void (*GListCallback) (const GList* list, gpointer user_data, GError* err);
+
+ /**
+ * IAnjutaDebuggerCallback:
+ * @data: string
+ * @user_data: user data
+ * @error: error
+ *
+ * This callback function is used by several debugger functions. The data is
+ * a string
+ */
typedef void (*GCharCallback) (const gchar *value, gpointer user_data, GError* err);
+
+ /**
+ * IAnjutaDebuggerCallback:
+ * @data: Self
+ * @user_data: user data
+ * @error: error
+ *
+ * This callback function is used only by #ianjuta_debugger_callback with a
+ * NULL data.
+ */
typedef void (*OutputCallback) (OutputType type, const gchar *output, gpointer user_data);
- typedef void (*MemoryCallback) (gulong address, guint length, const gchar *data, gpointer user_data, GError *err);
/* Signals */
@@ -3998,8 +4090,8 @@ interface IAnjutaDebugger
/**
* ianjuta_debugger_run_from:
* @obj: Self
- * @callback: Callback to call getting a list of frame
- * @user_data: User data that is passed back to the callback
+ * @file: target file name
+ * @line: target line in file
* @err: Error propagation and reporting.
*
* Execute the program from a new position.
@@ -4045,7 +4137,7 @@ interface IAnjutaDebugger
*
* Returns: TRUE if sucessful, otherwise FALSE.
*/
- gboolean inspect (const gchar* name, Callback callback, gpointer user_data);
+ gboolean inspect (const gchar* name, GCharCallback callback, gpointer user_data);
/**
* ianjuta_debugger_evaluate:
@@ -4060,7 +4152,7 @@ interface IAnjutaDebugger
*
* Returns: TRUE if sucessful, otherwise FALSE.
*/
- gboolean evaluate (const gchar* name, const gchar* value, Callback callback, gpointer user_data);
+ gboolean evaluate (const gchar* name, const gchar* value, GCharCallback callback, gpointer user_data);
/**
* ianjuta_debugger_print:
@@ -4074,7 +4166,7 @@ interface IAnjutaDebugger
*
* Returns: TRUE if sucessful, otherwise FALSE.
*/
- gboolean print (const gchar *variable, Callback callback, gpointer user_data);
+ gboolean print (const gchar *variable, GCharCallback callback, gpointer user_data);
/**
* ianjuta_debugger_list_local:
@@ -4087,7 +4179,7 @@ interface IAnjutaDebugger
*
* Returns: TRUE if sucessful, otherwise FALSE.
*/
- gboolean list_local (Callback callback, gpointer user_data);
+ gboolean list_local (GListCallback callback, gpointer user_data);
/**
* ianjuta_debugger_list_argument:
@@ -4100,7 +4192,7 @@ interface IAnjutaDebugger
*
* Returns: TRUE if sucessful, otherwise FALSE.
*/
- gboolean list_argument (Callback callback, gpointer user_data);
+ gboolean list_argument (GListCallback callback, gpointer user_data);
/**
* ianjuta_debugger_info_signal:
@@ -4113,7 +4205,7 @@ interface IAnjutaDebugger
*
* Returns: TRUE if sucessful, otherwise FALSE.
*/
- gboolean info_signal (Callback callback, gpointer user_data);
+ gboolean info_signal (GListCallback callback, gpointer user_data);
/**
* ianjuta_debugger_info_sharedlib:
@@ -4126,7 +4218,7 @@ interface IAnjutaDebugger
*
* Returns: TRUE if sucessful, otherwise FALSE.
*/
- gboolean info_sharedlib (Callback callback, gpointer user_data);
+ gboolean info_sharedlib (GListCallback callback, gpointer user_data);
/**
* ianjuta_debugger_handle_signal:
@@ -4147,7 +4239,7 @@ interface IAnjutaDebugger
* ianjuta_debugger_info_frame:
* @obj: Self
* @frame: frame number, the top frame has the number 0
- * @callback: Callback to call getting a string with all information
+ * @callback: Callback to call getting a list of strings with all information
* @user_data: User data that is passed back to the callback
* @err: Error propagation and reporting.
*
@@ -4155,12 +4247,12 @@ interface IAnjutaDebugger
*
* Returns: TRUE if sucessful, otherwise FALSE.
*/
- gboolean info_frame (guint frame, Callback callback, gpointer user_data);
+ gboolean info_frame (guint frame, GListCallback callback, gpointer user_data);
/**
* ianjuta_debugger_info_args:
* @obj: Self
- * @callback: Callback to call getting a string with all information
+ * @callback: Callback to call getting a list of strings with all information
* @user_data: User data that is passed back to the callback
* @err: Error propagation and reporting.
*
@@ -4168,12 +4260,12 @@ interface IAnjutaDebugger
*
* Returns: TRUE if sucessful, otherwise FALSE.
*/
- gboolean info_args (Callback callback, gpointer user_data);
+ gboolean info_args (GListCallback callback, gpointer user_data);
/**
* ianjuta_debugger_info_target:
* @obj: Self
- * @callback: Callback to call getting a string with all information
+ * @callback: Callback to call getting a list of strings with all information
* @user_data: User data that is passed back to the callback
* @err: Error propagation and reporting.
*
@@ -4181,12 +4273,12 @@ interface IAnjutaDebugger
*
* Returns: TRUE if sucessful, otherwise FALSE.
*/
- gboolean info_target (Callback callback, gpointer user_data);
+ gboolean info_target (GListCallback callback, gpointer user_data);
/**
* ianjuta_debugger_info_program:
* @obj: Self
- * @callback: Callback to call getting a string with all information
+ * @callback: Callback to call getting a list of strings with all information
* @user_data: User data that is passed back to the callback
* @err: Error propagation and reporting.
*
@@ -4194,12 +4286,12 @@ interface IAnjutaDebugger
*
* Returns: TRUE if sucessful, otherwise FALSE.
*/
- gboolean info_program (Callback callback, gpointer user_data);
+ gboolean info_program (GListCallback callback, gpointer user_data);
/**
* ianjuta_debugger_info_udot:
* @obj: Self
- * @callback: Callback to call getting a string with all information
+ * @callback: Callback to call getting a list of strings with all information
* @user_data: User data that is passed back to the callback
* @err: Error propagation and reporting.
*
@@ -4207,13 +4299,13 @@ interface IAnjutaDebugger
*
* Returns: TRUE if sucessful, otherwise FALSE.
*/
- gboolean info_udot (Callback callback, gpointer user_data);
+ gboolean info_udot (GListCallback callback, gpointer user_data);
/**
* ianjuta_debugger_info_variables:
* @obj: Self
- * @callback: Callback to call getting a string with all information
+ * @callback: Callback to call getting a list of strings with all information
* @user_data: User data that is passed back to the callback
* @err: Error propagation and reporting.
*
@@ -4221,12 +4313,12 @@ interface IAnjutaDebugger
*
* Returns: TRUE if sucessful, otherwise FALSE.
*/
- gboolean info_variables (Callback callback, gpointer user_data);
+ gboolean info_variables (GListCallback callback, gpointer user_data);
/**
* ianjuta_debugger_list_frame:
* @obj: Self
- * @callback: Callback to call getting a list of frame
+ * @callback: Callback to call getting a list of #IAnjutaDebuggerFrame
* @user_data: User data that is passed back to the callback
* @err: Error propagation and reporting.
*
@@ -4234,7 +4326,7 @@ interface IAnjutaDebugger
*
* Returns: TRUE if sucessful, otherwise FALSE.
*/
- gboolean list_frame (Callback callback, gpointer user_data);
+ gboolean list_frame (GListCallback callback, gpointer user_data);
/**
* ianjuta_debugger_set_frame:
@@ -4251,7 +4343,7 @@ interface IAnjutaDebugger
/**
* ianjuta_debugger_list_thread:
* @obj: Self
- * @callback: Callback to call getting a list of thread
+ * @callback: Callback to call getting a list of #IAnjutaDebuggerFrame for each thread
* @user_data: User data that is passed back to the callback
* @err: Error propagation and reporting.
*
@@ -4259,7 +4351,7 @@ interface IAnjutaDebugger
*
* Returns: TRUE if sucessful, otherwise FALSE.
*/
- gboolean list_thread (Callback callback, gpointer user_data);
+ gboolean list_thread (GListCallback callback, gpointer user_data);
/**
* ianjuta_debugger_set_thread:
@@ -4277,7 +4369,7 @@ interface IAnjutaDebugger
* ianjuta_debugger_info_thread:
* @obj: Self
* @thread: thread number
- * @callback: Callback to call getting a string with all information
+ * @callback: Callback to call getting a list of strings with all information
* @user_data: User data that is passed back to the callback
* @err: Error propagation and reporting.
*
@@ -4285,20 +4377,7 @@ interface IAnjutaDebugger
*
* Returns: TRUE if sucessful, otherwise FALSE.
*/
- gboolean info_thread (gint thread, Callback callback, gpointer user_data);
-
- /**
- * ianjuta_debugger_list_register:
- * @obj: Self
- * @callback: Callback to call getting a list of registers
- * @user_data: User data that is passed back to the callback
- * @err: Error propagation and reporting.
- *
- * Get the list of registers.
- *
- * Returns: TRUE if sucessful, otherwise FALSE.
- */
- gboolean list_register (Callback callback, gpointer user_data);
+ gboolean info_thread (gint thread, GListCallback callback, gpointer user_data);
/**
* ianjuta_debugger_send_command:
@@ -4317,7 +4396,7 @@ interface IAnjutaDebugger
/**
* ianjuta_debugger_callback:
* @obj: Self
- * @callback: Callback to call
+ * @callback: Callback to call. the data argument is NULL.
* @user_data: User data that is passed back to the callback
* @err: Error propagation and reporting.
*
@@ -4353,7 +4432,7 @@ interface IAnjutaDebugger
/**
* ianjuta_debugger_dump_stack_trace:
* @obj: Self
- * @callback: Callback to call getting a list of frame
+ * @callback: Callback to call getting a list of strings
* @user_data: User data that is passed back to the callback
* @err: Error propagation and reporting.
*
@@ -4362,7 +4441,7 @@ interface IAnjutaDebugger
*
* Returns: TRUE if sucessful, otherwise FALSE.
*/
- gboolean dump_stack_trace (Callback callback, gpointer user_data);
+ gboolean dump_stack_trace (GListCallback callback, gpointer user_data);
/**
* SECTION:ianjuta-debugger-breakpoint
@@ -4376,6 +4455,24 @@ interface IAnjutaDebugger
interface IAnjutaDebuggerBreakpoint
{
+ /**
+ * IAnjutaDebuggerBreakpointType:
+ * @IANJUTA_DEBUGGER_BREAKPOINT_REMOVED: Set for removed breakpoint
+ * @IANJUTA_DEBUGGER_BREAKPOINT_UPDATED: Set for changed breakpoint
+ * @IANJUTA_DEBUGGER_BREAKPOINT_ON_LINE: Set on source line
+ * @IANJUTA_DEBUGGER_BREAKPOINT_ON_ADDRESS: Set on an addresse
+ * @IANJUTA_DEBUGGER_BREAKPOINT_ON_FUNCTION: Set on a function name
+ * @IANJUTA_DEBUGGER_BREAKPOINT_ON_READ: Set on read access
+ * @IANJUTA_DEBUGGER_BREAKPOINT_ON_WRITE: Set on write access
+ * @IANJUTA_DEBUGGER_BREAKPOINT_WITH_ENABLE: Has enable information
+ * @IANJUTA_DEBUGGER_BREAKPOINT_WITH_IGNORE: Has ignore information,
+ * @IANJUTA_DEBUGGER_BREAKPOINT_WITH_TIME: Has counter information
+ * @IANJUTA_DEBUGGER_BREAKPOINT_WITH_CONDITION: Has a condition
+ * @IANJUTA_DEBUGGER_BREAKPOINT_WITH_TEMPORARY: Temporary breakpoint, automatically removed when triggered
+ * @IANJUTA_DEBUGGER_BREAKPOINT_WITH_PENDING: Pending breakpoint
+ *
+ * This enumeration defined various characteristics of the breakpoint.
+ */
enum Type
{
REMOVED = 1 << 0,
@@ -4393,6 +4490,23 @@ interface IAnjutaDebugger
WITH_PENDING = 1 << 14,
}
+ /**
+ * IAnjutaDebuggerBreakpointItem:
+ * @type: type see #IAnjutaBreakpointType enumeration
+ * @id: unique identifier
+ * @file: source file where is the breakpoint
+ * @line: corresponding source file line number
+ * @function: corresponding function name
+ * @address: corresponding address
+ * @enable: TRUE if the breakpoint is enabled
+ * @ignore: TRUE if the breakpoint is ignored
+ * @times: Count how many time the breakpoint is triggered
+ * @condition: Additional condition for triggering the breakpoint
+ * @temporary: TRUE if the breakpoint is temporary
+ * @pending: TRUE if the breakpoint is pending
+ *
+ * This structure keeps all information about a breakpoint.
+ */
struct Item
{
gint type;
@@ -4409,6 +4523,17 @@ interface IAnjutaDebugger
gboolean pending;
}
+ /**
+ * IAnjutaDebuggerBreakpointMethod:
+ * @IANJUTA_DEBUGGER_BREAKPOINT_SET_AT_ADDRESS: Allow to set breakpoint on address
+ * @IANJUTA_DEBUGGER_BREAKPOINT_SET_AT_FUNCTION: Allow to set breakpoint on function name
+ * @IANJUTA_DEBUGGER_BREAKPOINT_ENABLE: Allow to disable breakpoint
+ * @IANJUTA_DEBUGGER_BREAKPOINT_IGNORE: Allow to ignore breakpoint
+ * @IANJUTA_DEBUGGER_BREAKPOINT_CONDITION: Allow to add a condition on breakpoint
+ *
+ * Defines which breakpoint characteristics are supported by the debugger
+ * backend.
+ */
enum Method
{
SET_AT_ADDRESS = 1 << 0,
@@ -4419,13 +4544,23 @@ interface IAnjutaDebugger
}
/**
+ * IAnjutaDebuggerBreakpointCallback:
+ * @data: a #IAnjutaBreakpointItem object
+ * @user_data: user data passed to the function
+ * @error: error
+ *
+ * This callback function is used to return a #IAnjutaBreakpointItem.
+ */
+ typedef void (*Callback) (const Item *data, gpointer user_data, GError* err);
+
+ /**
* ianjuta_debugger_breakpoint_implement_breakpoint:
* @obj: Self
* @err: Error propagation and reporting.
*
* Return all implemented methods.
*
- * Returns: A OR of IAnjutaDebuggerBreakpointMethod
+ * Returns: A OR of #IAnjutaDebuggerBreakpointMethod
* corresponding to all implemented optional methods.
*/
gint implement_breakpoint ();
@@ -4444,7 +4579,7 @@ interface IAnjutaDebugger
* Returns: TRUE if the request succeed and the callback is called. If
* FALSE, the callback will not be called.
*/
- gboolean set_breakpoint_at_line (const gchar* file, guint line, IAnjutaDebuggerCallback callback, gpointer user_data);
+ gboolean set_breakpoint_at_line (const gchar* file, guint line, Callback callback, gpointer user_data);
/**
@@ -4461,7 +4596,7 @@ interface IAnjutaDebugger
* Returns: TRUE if the request succeed and the callback is called. If
* FALSE, the callback will not be called.
*/
- gboolean set_breakpoint_at_address (gulong address, IAnjutaDebuggerCallback callback, gpointer user_data);
+ gboolean set_breakpoint_at_address (gulong address, Callback callback, gpointer user_data);
/**
* ianjuta_debugger_breakpoint_set_breakpoint_at_function:
@@ -4478,7 +4613,7 @@ interface IAnjutaDebugger
* Returns: TRUE if the request succeed and the callback is called. If
* FALSE, the callback will not be called.
*/
- gboolean set_breakpoint_at_function (const gchar* file, const gchar* function, IAnjutaDebuggerCallback callback, gpointer user_data);
+ gboolean set_breakpoint_at_function (const gchar* file, const gchar* function, Callback callback, gpointer user_data);
/**
* ianjuta_debugger_breakpoint_clear_breakpoint:
@@ -4494,12 +4629,12 @@ interface IAnjutaDebugger
* Returns: TRUE if the request succeed and the callback is called. If
* FALSE, the callback will not be called.
*/
- gboolean clear_breakpoint (guint id, IAnjutaDebuggerCallback callback, gpointer user_data);
+ gboolean clear_breakpoint (guint id, Callback callback, gpointer user_data);
/**
* ianjuta_debugger_breakpoint_list_breakpoint:
* @obj: Self
- * @callback: Callback to call with the list of breakpoints
+ * @callback: Callback to call with the list of #IAnjutaDebuggreBreakpointItem
* @user_data: User data that is passed back to the callback
* @err: Error propagation and reporting.
*
@@ -4509,7 +4644,7 @@ interface IAnjutaDebugger
* Returns: TRUE if the request succeed and the callback is called. If
* FALSE, the callback will not be called.
*/
- gboolean list_breakpoint (IAnjutaDebuggerCallback callback, gpointer user_data);
+ gboolean list_breakpoint (IAnjutaDebuggerGListCallback callback, gpointer user_data);
/**
* ianjuta_debugger_breakpoint_enable_breakpoint:
@@ -4525,7 +4660,7 @@ interface IAnjutaDebugger
* Returns: TRUE if the request succeed and the callback is called. If
* FALSE, the callback will not be called.
*/
- gboolean enable_breakpoint (guint id, gboolean enable, IAnjutaDebuggerCallback callback, gpointer user_data);
+ gboolean enable_breakpoint (guint id, gboolean enable, Callback callback, gpointer user_data);
/**
* ianjuta_debugger_breakpoint_ignore_breakpoint:
@@ -4542,7 +4677,7 @@ interface IAnjutaDebugger
* Returns: TRUE if the request succeed and the callback is called. If
* FALSE, the callback will not be called.
*/
- gboolean ignore_breakpoint (guint id, guint ignore, IAnjutaDebuggerCallback callback, gpointer user_data);
+ gboolean ignore_breakpoint (guint id, guint ignore, Callback callback, gpointer user_data);
/**
* ianjuta_debugger_breakpoint_condition_breakpoint:
@@ -4560,7 +4695,7 @@ interface IAnjutaDebugger
* Returns: TRUE if the request succeed and the callback is called. If
* FALSE, the callback will not be called.
*/
- gboolean condition_breakpoint (guint id, const gchar* condition, IAnjutaDebuggerCallback callback, gpointer user_data);
+ gboolean condition_breakpoint (guint id, const gchar* condition, Callback callback, gpointer user_data);
}
/**
@@ -4578,6 +4713,20 @@ interface IAnjutaDebugger
*/
interface IAnjutaDebuggerVariable
{
+ /**
+ * IAnjutaDebuggerVariableObject:
+ * @name: unique variable object name created by backend
+ * @expression: corresponding variable name or expression
+ * @type: variable type
+ * @value: variable value
+ * @changed: TRUE if the variable has changed
+ * @exited: TRUE if the variable is outside current scope
+ * @deleted: TRUE if the variable has been removed
+ * @children: Number of variable children, -1 if unknown
+ * @has_more: TRUE if the children value is wrong
+ *
+ * Defines a variable object.
+ */
struct Object
{
gchar *name;
@@ -4592,6 +4741,16 @@ interface IAnjutaDebugger
}
/**
+ * IAnjutaDebuggerVariableCallback:
+ * @data: a #IAnjutaDebuggerVariableObject object
+ * @user_data: user data passed to the function
+ * @error: error
+ *
+ * This callback function is used to return a #IAnjutaDebuggerVariableObject.
+ */
+ typedef void (*Callback) (const Object *data, gpointer user_data, GError* err);
+
+ /**
* ianjuta_debugger_variable_create:
* @obj: Self
* @expression: Variable expression
@@ -4604,7 +4763,7 @@ interface IAnjutaDebugger
* Returns: TRUE if the request succeed and the callback is
* called. If FALSE, the callback will not be called.
*/
- gboolean create (const gchar *expression, IAnjutaDebuggerCallback callback, gpointer user_data);
+ gboolean create (const gchar *expression, Callback callback, gpointer user_data);
/**
* ianjuta_debugger_variable_list_children:
@@ -4612,7 +4771,7 @@ interface IAnjutaDebugger
* @name: Variable name
* @from: Starting from this children (zero-based)
* @callback: Callback to call when the children have been
- * created
+ * created with a list of variable objects
* @user_data: User data that is passed back to the callback
* @err: Error propagation and reporting.
*
@@ -4627,7 +4786,7 @@ interface IAnjutaDebugger
* Returns: TRUE if the request succeed and the callback is
* called. If FALSE, the callback will not be called.
*/
- gboolean list_children (const gchar *name, guint from, IAnjutaDebuggerCallback callback, gpointer user_data);
+ gboolean list_children (const gchar *name, guint from, IAnjutaDebuggerGListCallback callback, gpointer user_data);
/**
* ianjuta_debugger_variable_evaluate:
@@ -4642,7 +4801,7 @@ interface IAnjutaDebugger
* Returns: TRUE if the request succeed and the callback is
* called. If FALSE, the callback will not be called.
*/
- gboolean evaluate (const gchar *name, IAnjutaDebuggerCallback callback, gpointer user_data);
+ gboolean evaluate (const gchar *name, IAnjutaDebuggerGCharCallback callback, gpointer user_data);
/**
* ianjuta_debugger_variable_assign:
@@ -4662,7 +4821,7 @@ interface IAnjutaDebugger
* ianjuta_debugger_variable_update:
* @obj: Self
* @callback: Callback to call with the list of all changed
- * variables
+ * variable names
* @user_data: User data that is passed back to the callback
* @err: Error propagation and reporting.
*
@@ -4671,7 +4830,7 @@ interface IAnjutaDebugger
* Returns: TRUE if the request succeed and the callback is
* called. If FALSE, the callback will not be called.
*/
- gboolean update (IAnjutaDebuggerCallback callback, gpointer user_data);
+ gboolean update (IAnjutaDebuggerGListCallback callback, gpointer user_data);
/**
* ianjuta_debugger_variable_destroy:
@@ -4701,6 +4860,14 @@ interface IAnjutaDebugger
interface IAnjutaDebuggerRegister
{
+ /**
+ * IAnjutaDebuggerRegisterData:
+ * @num: register identifier
+ * @name: register name
+ * @value: register value
+ *
+ * Defines a register data.
+ */
struct Data
{
guint num;
@@ -4711,7 +4878,7 @@ interface IAnjutaDebugger
/**
* ianjuta_debugger_register_list_register:
* @obj: Self
- * @callback: Callback to call with the register list
+ * @callback: Callback to call with the #IAnjutaDebuggerRegisterData list
* @user_data: User data that is passed back to the callback
* @err: Error propagation and reporting.
*
@@ -4721,12 +4888,12 @@ interface IAnjutaDebugger
* Returns: TRUE if the request succeed and the callback is
* called. If FALSE, the callback will not be called.
*/
- gboolean list_register (IAnjutaDebuggerCallback callback, gpointer user_data);
+ gboolean list_register (IAnjutaDebuggerGListCallback callback, gpointer user_data);
/**
* ianjuta_debugger_register_update_register:
* @obj: Self
- * @callback: Callback call with the list of all modified registers
+ * @callback: Callback call with the list of all modified #IAnjutaDebuggerRegisterData
* @user_data: User data that is passed back to the callback
* @err: Error propagation and reporting.
*
@@ -4736,7 +4903,7 @@ interface IAnjutaDebugger
* Returns: TRUE if the request succeed and the callback is
* called. If FALSE, the callback will not be called.
*/
- gboolean update_register (IAnjutaDebuggerCallback callback, gpointer user_data);
+ gboolean update_register (IAnjutaDebuggerGListCallback callback, gpointer user_data);
/**
* ianjuta_debugger_register_write_register:
@@ -4763,6 +4930,14 @@ interface IAnjutaDebugger
*/
interface IAnjutaDebuggerMemory
{
+ /**
+ * IAnjutaDebuggerRegisterMemoryBlock:
+ * @address: start address of memory block
+ * @length: size of memory block
+ * @data: memory block data
+ *
+ * Represent a block of memory.
+ */
struct Block
{
gulong address;
@@ -4771,6 +4946,16 @@ interface IAnjutaDebugger
}
/**
+ * IAnjutaDebuggerMemoryCallback:
+ * @data: a #IAnjutaDebuggerMemoryBlock object
+ * @user_data: user data passed to the function
+ * @error: error
+ *
+ * This callback function is used to return a #IAnjutaDebuggerMemoryBlock.
+ */
+ typedef void (*Callback) (const Block *data, gpointer user_data, GError* err);
+
+ /**
* ianjuta_debugger_memory_inspect:
* @obj: Self
* @address: Start address of the memory block
@@ -4784,7 +4969,7 @@ interface IAnjutaDebugger
* Returns: TRUE if the request succeed and the callback is
* called. If FALSE, the callback will not be called.
*/
- gboolean inspect (gulong address, guint length, IAnjutaDebuggerCallback callback, gpointer user_data);
+ gboolean inspect (gulong address, guint length, Callback callback, gpointer user_data);
}
/**
@@ -4800,6 +4985,14 @@ interface IAnjutaDebugger
interface IAnjutaDebuggerInstruction
{
+ /**
+ * IAnjutaDebuggerInstructionALine:
+ * @address: Address of the line
+ * @label: Optional label
+ * @text: Diassembled instruction on the line
+ *
+ * Defines a disassembled line
+ */
struct ALine
{
gulong address;
@@ -4807,11 +5000,28 @@ interface IAnjutaDebugger
const gchar *text;
}
+ /**
+ * IAnjutaDebuggerInstructionDisassembly:
+ * @size: Number of line
+ * @data: Array of all lines
+ *
+ * Represents a block of diassembled instructions
+ */
struct Disassembly
{
guint size;
- ALine data[];
- }
+ ALine data[];
+ }
+
+ /**
+ * IAnjutaDebuggerInstructionCallback:
+ * @data: a #IAnjutaDebuggerInstructionDisassembly object
+ * @user_data: user data passed to the function
+ * @error: error
+ *
+ * This callback function is used to return a #IAnjutaDebuggerInstructionDisassembly.
+ */
+ typedef void (*Callback) (const Disassembly *data, gpointer user_data, GError* err);
/**
* ianjuta_debugger_instruction_disassemble:
@@ -4827,7 +5037,7 @@ interface IAnjutaDebugger
* Returns: TRUE if the request succeed and the callback is
* called. If FALSE, the callback will not be called.
*/
- gboolean disassemble (gulong address, guint length, IAnjutaDebuggerCallback callback, gpointer user_data);
+ gboolean disassemble (gulong address, guint length, Callback callback, gpointer user_data);
/**
* ianjuta_debugger_instruction_step_in_instruction:
@@ -4880,7 +5090,7 @@ interface IAnjutaDebugger
*/
gboolean run_from_address (gulong address);
}
-
+
}
/**
diff --git a/plugins/debug-manager/command.c b/plugins/debug-manager/command.c
index d12a873..b5ad54b 100644
--- a/plugins/debug-manager/command.c
+++ b/plugins/debug-manager/command.c
@@ -1276,18 +1276,18 @@ dma_command_run (DmaQueueCommand *cmd, IAnjutaDebugger *debugger,
ret = ianjuta_debugger_interrupt (debugger, err);
break;
case ENABLE_BREAK_COMMAND:
- ret = ianjuta_debugger_breakpoint_enable_breakpoint (IANJUTA_DEBUGGER_BREAKPOINT (debugger), cmd->data.brk.id, cmd->data.brk.enable, callback, queue, err);
+ ret = ianjuta_debugger_breakpoint_enable_breakpoint (IANJUTA_DEBUGGER_BREAKPOINT (debugger), cmd->data.brk.id, cmd->data.brk.enable, (IAnjutaDebuggerBreakpointCallback)callback, queue, err);
break;
case IGNORE_BREAK_COMMAND:
- ret = ianjuta_debugger_breakpoint_ignore_breakpoint (IANJUTA_DEBUGGER_BREAKPOINT (debugger), cmd->data.brk.id, cmd->data.brk.ignore, callback, queue, err);
+ ret = ianjuta_debugger_breakpoint_ignore_breakpoint (IANJUTA_DEBUGGER_BREAKPOINT (debugger), cmd->data.brk.id, cmd->data.brk.ignore, (IAnjutaDebuggerBreakpointCallback)callback, queue, err);
break;
case REMOVE_BREAK_COMMAND:
- ret = ianjuta_debugger_breakpoint_clear_breakpoint (IANJUTA_DEBUGGER_BREAKPOINT (debugger), cmd->data.brk.id, callback, queue, err);
+ ret = ianjuta_debugger_breakpoint_clear_breakpoint (IANJUTA_DEBUGGER_BREAKPOINT (debugger), cmd->data.brk.id, (IAnjutaDebuggerBreakpointCallback)callback, queue, err);
break;
case BREAK_LINE_COMMAND:
if (dma_command_is_breakpoint_pending (cmd))
{
- ret = ianjuta_debugger_breakpoint_set_breakpoint_at_line (IANJUTA_DEBUGGER_BREAKPOINT (debugger), cmd->data.pos.file, cmd->data.pos.line, callback, queue, err);
+ ret = ianjuta_debugger_breakpoint_set_breakpoint_at_line (IANJUTA_DEBUGGER_BREAKPOINT (debugger), cmd->data.pos.file, cmd->data.pos.line, (IAnjutaDebuggerBreakpointCallback)callback, queue, err);
}
else
{
@@ -1297,7 +1297,7 @@ dma_command_run (DmaQueueCommand *cmd, IAnjutaDebugger *debugger,
case BREAK_FUNCTION_COMMAND:
if (dma_command_is_breakpoint_pending (cmd))
{
- ret = ianjuta_debugger_breakpoint_set_breakpoint_at_function (IANJUTA_DEBUGGER_BREAKPOINT (debugger), cmd->data.pos.file, cmd->data.pos.function, callback, queue, err);
+ ret = ianjuta_debugger_breakpoint_set_breakpoint_at_function (IANJUTA_DEBUGGER_BREAKPOINT (debugger), cmd->data.pos.file, cmd->data.pos.function, (IAnjutaDebuggerBreakpointCallback)callback, queue, err);
}
else
{
@@ -1307,7 +1307,7 @@ dma_command_run (DmaQueueCommand *cmd, IAnjutaDebugger *debugger,
case BREAK_ADDRESS_COMMAND:
if (dma_command_is_breakpoint_pending (cmd))
{
- ret = ianjuta_debugger_breakpoint_set_breakpoint_at_address (IANJUTA_DEBUGGER_BREAKPOINT (debugger), cmd->data.pos.address, callback, queue, err);
+ ret = ianjuta_debugger_breakpoint_set_breakpoint_at_address (IANJUTA_DEBUGGER_BREAKPOINT (debugger), cmd->data.pos.address, (IAnjutaDebuggerBreakpointCallback)callback, queue, err);
}
else
{
@@ -1315,70 +1315,70 @@ dma_command_run (DmaQueueCommand *cmd, IAnjutaDebugger *debugger,
}
break;
case CONDITION_BREAK_COMMAND:
- ret = ianjuta_debugger_breakpoint_condition_breakpoint (IANJUTA_DEBUGGER_BREAKPOINT (debugger), cmd->data.brk.id, cmd->data.brk.condition, callback, queue, err);
+ ret = ianjuta_debugger_breakpoint_condition_breakpoint (IANJUTA_DEBUGGER_BREAKPOINT (debugger), cmd->data.brk.id, cmd->data.brk.condition, (IAnjutaDebuggerBreakpointCallback)callback, queue, err);
break;
case LIST_BREAK_COMMAND:
- ret = ianjuta_debugger_breakpoint_list_breakpoint (IANJUTA_DEBUGGER_BREAKPOINT (debugger), callback, queue, err);
+ ret = ianjuta_debugger_breakpoint_list_breakpoint (IANJUTA_DEBUGGER_BREAKPOINT (debugger), (IAnjutaDebuggerGListCallback)callback, queue, err);
break;
case INSPECT_COMMAND:
- ret = ianjuta_debugger_inspect (debugger, cmd->data.watch.name, callback, queue, err);
+ ret = ianjuta_debugger_inspect (debugger, cmd->data.watch.name, (IAnjutaDebuggerGCharCallback)callback, queue, err);
break;
case EVALUATE_COMMAND:
- ret = ianjuta_debugger_evaluate (debugger, cmd->data.watch.name, cmd->data.watch.value, callback, queue, err);
+ ret = ianjuta_debugger_evaluate (debugger, cmd->data.watch.name, cmd->data.watch.value, (IAnjutaDebuggerGCharCallback)callback, queue, err);
break;
case LIST_LOCAL_COMMAND:
- ret = ianjuta_debugger_list_local (debugger, callback, queue, err);
+ ret = ianjuta_debugger_list_local (debugger, (IAnjutaDebuggerGListCallback)callback, queue, err);
break;
case LIST_ARG_COMMAND:
- ret = ianjuta_debugger_list_argument (debugger, callback, queue, err);
+ ret = ianjuta_debugger_list_argument (debugger, (IAnjutaDebuggerGListCallback)callback, queue, err);
break;
case LIST_THREAD_COMMAND:
- ret = ianjuta_debugger_list_thread (debugger, callback, queue, err);
+ ret = ianjuta_debugger_list_thread (debugger, (IAnjutaDebuggerGListCallback)callback, queue, err);
break;
case SET_THREAD_COMMAND:
ret = ianjuta_debugger_set_thread (debugger, cmd->data.frame.frame, err);
break;
case INFO_THREAD_COMMAND:
- ret = ianjuta_debugger_info_thread (debugger, cmd->data.info.id, callback, queue, err);
+ ret = ianjuta_debugger_info_thread (debugger, cmd->data.info.id, (IAnjutaDebuggerGListCallback)callback, queue, err);
break;
case INFO_SIGNAL_COMMAND:
- ret = ianjuta_debugger_info_signal (debugger, callback, queue, err);
+ ret = ianjuta_debugger_info_signal (debugger, (IAnjutaDebuggerGListCallback)callback, queue, err);
break;
case INFO_SHAREDLIB_COMMAND:
- ret = ianjuta_debugger_info_sharedlib (debugger, callback, queue, err);
+ ret = ianjuta_debugger_info_sharedlib (debugger, (IAnjutaDebuggerGListCallback)callback, queue, err);
break;
case INFO_FRAME_COMMAND:
- ret = ianjuta_debugger_info_frame (debugger, 0, callback, queue, err);
+ ret = ianjuta_debugger_info_frame (debugger, 0, (IAnjutaDebuggerGListCallback)callback, queue, err);
break;
case INFO_ARGS_COMMAND:
- ret = ianjuta_debugger_info_args (debugger, callback, queue, err);
+ ret = ianjuta_debugger_info_args (debugger, (IAnjutaDebuggerGListCallback)callback, queue, err);
break;
case INFO_TARGET_COMMAND:
- ret = ianjuta_debugger_info_target (debugger, callback, queue, err);
+ ret = ianjuta_debugger_info_target (debugger, (IAnjutaDebuggerGListCallback)callback, queue, err);
break;
case INFO_PROGRAM_COMMAND:
- ret = ianjuta_debugger_info_program (debugger, callback, queue, err);
+ ret = ianjuta_debugger_info_program (debugger, (IAnjutaDebuggerGListCallback)callback, queue, err);
break;
case INFO_UDOT_COMMAND:
- ret = ianjuta_debugger_info_udot (debugger, callback, queue, err);
+ ret = ianjuta_debugger_info_udot (debugger, (IAnjutaDebuggerGListCallback)callback, queue, err);
break;
case INFO_VARIABLES_COMMAND:
- ret = ianjuta_debugger_info_variables (debugger, callback, queue, err);
+ ret = ianjuta_debugger_info_variables (debugger, (IAnjutaDebuggerGListCallback)callback, queue, err);
break;
case SET_FRAME_COMMAND:
ret = ianjuta_debugger_set_frame (debugger, cmd->data.frame.frame, err);
break;
case LIST_FRAME_COMMAND:
- ret = ianjuta_debugger_list_frame (debugger, callback, queue, err);
+ ret = ianjuta_debugger_list_frame (debugger, (IAnjutaDebuggerGListCallback)callback, queue, err);
break;
case DUMP_STACK_TRACE_COMMAND:
- ret = ianjuta_debugger_dump_stack_trace (debugger, callback, queue, err);
+ ret = ianjuta_debugger_dump_stack_trace (debugger, (IAnjutaDebuggerGListCallback)callback, queue, err);
break;
case LIST_REGISTER_COMMAND:
- ret = ianjuta_debugger_register_list_register (IANJUTA_DEBUGGER_REGISTER (debugger), callback, queue, err);
+ ret = ianjuta_debugger_register_list_register (IANJUTA_DEBUGGER_REGISTER (debugger), (IAnjutaDebuggerGListCallback)callback, queue, err);
break;
case UPDATE_REGISTER_COMMAND:
- ret = ianjuta_debugger_register_update_register (IANJUTA_DEBUGGER_REGISTER (debugger), callback, queue, err);
+ ret = ianjuta_debugger_register_update_register (IANJUTA_DEBUGGER_REGISTER (debugger), (IAnjutaDebuggerGListCallback)callback, queue, err);
break;
case WRITE_REGISTER_COMMAND:
reg.num = cmd->data.watch.id;
@@ -1387,16 +1387,16 @@ dma_command_run (DmaQueueCommand *cmd, IAnjutaDebugger *debugger,
ret = ianjuta_debugger_register_write_register (IANJUTA_DEBUGGER_REGISTER (debugger), ®, err);
break;
case INSPECT_MEMORY_COMMAND:
- ret = ianjuta_debugger_memory_inspect (IANJUTA_DEBUGGER_MEMORY (debugger), cmd->data.mem.address, cmd->data.mem.length, callback, queue, err);
+ ret = ianjuta_debugger_memory_inspect (IANJUTA_DEBUGGER_MEMORY (debugger), cmd->data.mem.address, cmd->data.mem.length, (IAnjutaDebuggerMemoryCallback)callback, queue, err);
break;
case DISASSEMBLE_COMMAND:
- ret = ianjuta_debugger_instruction_disassemble (IANJUTA_DEBUGGER_INSTRUCTION (debugger), cmd->data.mem.address, cmd->data.mem.length, callback, queue, err);
+ ret = ianjuta_debugger_instruction_disassemble (IANJUTA_DEBUGGER_INSTRUCTION (debugger), cmd->data.mem.address, cmd->data.mem.length, (IAnjutaDebuggerInstructionCallback)callback, queue, err);
break;
case USER_COMMAND:
ret = ianjuta_debugger_send_command (debugger, cmd->data.user.cmd, err);
break;
case PRINT_COMMAND:
- ret = ianjuta_debugger_print (debugger, cmd->data.print.var, callback, queue, err);
+ ret = ianjuta_debugger_print (debugger, cmd->data.print.var, (IAnjutaDebuggerGCharCallback)callback, queue, err);
break;
case HANDLE_SIGNAL_COMMAND:
ret = ianjuta_debugger_handle_signal (debugger, cmd->data.signal.name, cmd->data.signal.stop, cmd->data.signal.print, cmd->data.signal.ignore, err);
@@ -1408,16 +1408,16 @@ dma_command_run (DmaQueueCommand *cmd, IAnjutaDebugger *debugger,
ret = ianjuta_debugger_variable_assign (IANJUTA_DEBUGGER_VARIABLE (debugger), cmd->data.var.name, cmd->data.var.value, err);
break;
case EVALUATE_VARIABLE:
- ret = ianjuta_debugger_variable_evaluate (IANJUTA_DEBUGGER_VARIABLE (debugger), cmd->data.var.name, callback, queue, err);
+ ret = ianjuta_debugger_variable_evaluate (IANJUTA_DEBUGGER_VARIABLE (debugger), cmd->data.var.name, (IAnjutaDebuggerGCharCallback)callback, queue, err);
break;
case LIST_VARIABLE_CHILDREN:
- ret = ianjuta_debugger_variable_list_children (IANJUTA_DEBUGGER_VARIABLE (debugger), cmd->data.var.name, cmd->data.var.from, callback, queue, err);
+ ret = ianjuta_debugger_variable_list_children (IANJUTA_DEBUGGER_VARIABLE (debugger), cmd->data.var.name, cmd->data.var.from, (IAnjutaDebuggerGListCallback)callback, queue, err);
break;
case CREATE_VARIABLE:
- ret = ianjuta_debugger_variable_create (IANJUTA_DEBUGGER_VARIABLE (debugger), cmd->data.var.name, callback, queue, err);
+ ret = ianjuta_debugger_variable_create (IANJUTA_DEBUGGER_VARIABLE (debugger), cmd->data.var.name, (IAnjutaDebuggerVariableCallback)callback, queue, err);
break;
case UPDATE_VARIABLE:
- ret = ianjuta_debugger_variable_update (IANJUTA_DEBUGGER_VARIABLE (debugger), callback, queue, err);
+ ret = ianjuta_debugger_variable_update (IANJUTA_DEBUGGER_VARIABLE (debugger), (IAnjutaDebuggerGListCallback)callback, queue, err);
break;
}
diff --git a/plugins/gdb/debugger.c b/plugins/gdb/debugger.c
index cc5c191..2ecb400 100644
--- a/plugins/gdb/debugger.c
+++ b/plugins/gdb/debugger.c
@@ -2630,7 +2630,7 @@ debugger_add_breakpoint_finish (Debugger *debugger, const GDBMIValue *mi_results
}
void
-debugger_add_breakpoint_at_line (Debugger *debugger, const gchar *file, guint line, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_add_breakpoint_at_line (Debugger *debugger, const gchar *file, guint line, IAnjutaDebuggerBreakpointCallback callback, gpointer user_data)
{
gchar *buff;
gchar *quoted_file;
@@ -2644,12 +2644,12 @@ debugger_add_breakpoint_at_line (Debugger *debugger, const gchar *file, guint li
debugger->priv->has_pending_breakpoints ? "-f" : "",
quoted_file, line);
g_free (quoted_file);
- debugger_queue_command (debugger, buff, 0, debugger_add_breakpoint_finish, callback, user_data);
+ debugger_queue_command (debugger, buff, 0, debugger_add_breakpoint_finish, (IAnjutaDebuggerCallback)callback, user_data);
g_free (buff);
}
void
-debugger_add_breakpoint_at_function (Debugger *debugger, const gchar *file, const gchar *function, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_add_breakpoint_at_function (Debugger *debugger, const gchar *file, const gchar *function, IAnjutaDebuggerBreakpointCallback callback, gpointer user_data)
{
gchar *buff;
gchar *quoted_file;
@@ -2667,12 +2667,12 @@ debugger_add_breakpoint_at_function (Debugger *debugger, const gchar *file, cons
function,
file == NULL ? "" : "\"");
g_free (quoted_file);
- debugger_queue_command (debugger, buff, 0, debugger_add_breakpoint_finish, callback, user_data);
+ debugger_queue_command (debugger, buff, 0, debugger_add_breakpoint_finish, (IAnjutaDebuggerCallback)callback, user_data);
g_free (buff);
}
void
-debugger_add_breakpoint_at_address (Debugger *debugger, gulong address, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_add_breakpoint_at_address (Debugger *debugger, gulong address, IAnjutaDebuggerBreakpointCallback callback, gpointer user_data)
{
gchar *buff;
@@ -2683,12 +2683,12 @@ debugger_add_breakpoint_at_address (Debugger *debugger, gulong address, IAnjutaD
buff = g_strdup_printf ("-break-insert %s *0x%lx",
debugger->priv->has_pending_breakpoints ? "-f" : "",
address);
- debugger_queue_command (debugger, buff, 0, debugger_add_breakpoint_finish, callback, user_data);
+ debugger_queue_command (debugger, buff, 0, debugger_add_breakpoint_finish, (IAnjutaDebuggerCallback)callback, user_data);
g_free (buff);
}
void
-debugger_enable_breakpoint (Debugger *debugger, guint id, gboolean enable, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_enable_breakpoint (Debugger *debugger, guint id, gboolean enable, IAnjutaDebuggerBreakpointCallback callback, gpointer user_data)
{
gchar *buff;
@@ -2698,12 +2698,12 @@ debugger_enable_breakpoint (Debugger *debugger, guint id, gboolean enable, IAnju
g_return_if_fail (IS_DEBUGGER (debugger));
buff = g_strdup_printf (enable ? "-break-enable %d" : "-break-disable %d",id);
- debugger_queue_command (debugger, buff, 0, debugger_add_breakpoint_finish, callback, user_data);
+ debugger_queue_command (debugger, buff, 0, debugger_add_breakpoint_finish, (IAnjutaDebuggerCallback)callback, user_data);
g_free (buff);
}
void
-debugger_ignore_breakpoint (Debugger *debugger, guint id, guint ignore, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_ignore_breakpoint (Debugger *debugger, guint id, guint ignore, IAnjutaDebuggerBreakpointCallback callback, gpointer user_data)
{
gchar *buff;
@@ -2712,12 +2712,12 @@ debugger_ignore_breakpoint (Debugger *debugger, guint id, guint ignore, IAnjutaD
g_return_if_fail (IS_DEBUGGER (debugger));
buff = g_strdup_printf ("-break-after %d %d", id, ignore);
- debugger_queue_command (debugger, buff, 0, debugger_add_breakpoint_finish, callback, user_data);
+ debugger_queue_command (debugger, buff, 0, debugger_add_breakpoint_finish, (IAnjutaDebuggerCallback)callback, user_data);
g_free (buff);
}
void
-debugger_condition_breakpoint (Debugger *debugger, guint id, const gchar *condition, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_condition_breakpoint (Debugger *debugger, guint id, const gchar *condition, IAnjutaDebuggerBreakpointCallback callback, gpointer user_data)
{
gchar *buff;
@@ -2726,7 +2726,7 @@ debugger_condition_breakpoint (Debugger *debugger, guint id, const gchar *condit
g_return_if_fail (IS_DEBUGGER (debugger));
buff = g_strdup_printf ("-break-condition %d %s", id, condition == NULL ? "" : condition);
- debugger_queue_command (debugger, buff, 0, debugger_add_breakpoint_finish, callback, user_data);
+ debugger_queue_command (debugger, buff, 0, debugger_add_breakpoint_finish, (IAnjutaDebuggerCallback)callback, user_data);
g_free (buff);
}
@@ -2744,7 +2744,7 @@ debugger_remove_breakpoint_finish (Debugger *debugger, const GDBMIValue *mi_resu
}
void
-debugger_remove_breakpoint (Debugger *debugger, guint id, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_remove_breakpoint (Debugger *debugger, guint id, IAnjutaDebuggerBreakpointCallback callback, gpointer user_data)
{
gchar *buff;
@@ -2753,7 +2753,7 @@ debugger_remove_breakpoint (Debugger *debugger, guint id, IAnjutaDebuggerCallbac
g_return_if_fail (IS_DEBUGGER (debugger));
buff = g_strdup_printf ("-break-delete %d", id);
- debugger_queue_command (debugger, buff, 0, debugger_remove_breakpoint_finish, callback, user_data);
+ debugger_queue_command (debugger, buff, 0, debugger_remove_breakpoint_finish, (IAnjutaDebuggerCallback)callback, user_data);
g_free (buff);
}
@@ -2809,13 +2809,13 @@ debugger_list_breakpoint_finish (Debugger *debugger, const GDBMIValue *mi_result
}
void
-debugger_list_breakpoint (Debugger *debugger, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_list_breakpoint (Debugger *debugger, IAnjutaDebuggerGListCallback callback, gpointer user_data)
{
DEBUG_PRINT ("%s", "In function: debugger_list_breakpoint()");
g_return_if_fail (IS_DEBUGGER (debugger));
- debugger_queue_command (debugger, "-break-list", 0, debugger_list_breakpoint_finish, callback, user_data);
+ debugger_queue_command (debugger, "-break-list", 0, debugger_list_breakpoint_finish, (IAnjutaDebuggerCallback)callback, user_data);
}
static void
@@ -2853,7 +2853,7 @@ debugger_print_finish (Debugger *debugger, const GDBMIValue *mi_results, const G
}
void
-debugger_print (Debugger *debugger, const gchar* variable, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_print (Debugger *debugger, const gchar* variable, IAnjutaDebuggerGCharCallback callback, gpointer user_data)
{
gchar *buff;
@@ -2862,7 +2862,7 @@ debugger_print (Debugger *debugger, const gchar* variable, IAnjutaDebuggerCallba
g_return_if_fail (IS_DEBUGGER (debugger));
buff = g_strdup_printf ("print %s", variable);
- debugger_queue_command (debugger, buff, DEBUGGER_COMMAND_NO_ERROR, debugger_print_finish, callback, user_data);
+ debugger_queue_command (debugger, buff, DEBUGGER_COMMAND_NO_ERROR, debugger_print_finish, (IAnjutaDebuggerCallback)callback, user_data);
g_free (buff);
}
@@ -2883,7 +2883,7 @@ debugger_evaluate_finish (Debugger *debugger, const GDBMIValue *mi_results, cons
}
void
-debugger_evaluate (Debugger *debugger, const gchar* name, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_evaluate (Debugger *debugger, const gchar* name, IAnjutaDebuggerGCharCallback callback, gpointer user_data)
{
gchar *buff;
DEBUG_PRINT ("%s", "In function: debugger_add_watch()");
@@ -2891,7 +2891,7 @@ debugger_evaluate (Debugger *debugger, const gchar* name, IAnjutaDebuggerCallbac
g_return_if_fail (IS_DEBUGGER (debugger));
buff = g_strdup_printf ("-data-evaluate-expression %s", name);
- debugger_queue_command (debugger, buff, DEBUGGER_COMMAND_NO_ERROR, debugger_evaluate_finish, callback, user_data);
+ debugger_queue_command (debugger, buff, DEBUGGER_COMMAND_NO_ERROR, debugger_evaluate_finish, (IAnjutaDebuggerCallback)callback, user_data);
g_free (buff);
}
@@ -2952,7 +2952,7 @@ debugger_list_local_finish (Debugger *debugger, const GDBMIValue *mi_results, co
}
void
-debugger_list_local (Debugger *debugger, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_list_local (Debugger *debugger, IAnjutaDebuggerGListCallback callback, gpointer user_data)
{
gchar *buff;
DEBUG_PRINT ("%s", "In function: debugger_list_local()");
@@ -2962,7 +2962,7 @@ debugger_list_local (Debugger *debugger, IAnjutaDebuggerCallback callback, gpoin
buff = g_strdup_printf("-stack-list-arguments 0 %d %d", debugger->priv->current_frame, debugger->priv->current_frame);
debugger_queue_command (debugger, buff, DEBUGGER_COMMAND_NO_ERROR | DEBUGGER_COMMAND_KEEP_RESULT, NULL, NULL, NULL);
g_free (buff);
- debugger_queue_command (debugger, "-stack-list-locals 0", DEBUGGER_COMMAND_NO_ERROR, debugger_list_local_finish, callback, user_data);
+ debugger_queue_command (debugger, "-stack-list-locals 0", DEBUGGER_COMMAND_NO_ERROR, debugger_list_local_finish, (IAnjutaDebuggerCallback)callback, user_data);
}
static void
@@ -3007,7 +3007,7 @@ debugger_list_argument_finish (Debugger *debugger, const GDBMIValue *mi_results,
}
void
-debugger_list_argument (Debugger *debugger, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_list_argument (Debugger *debugger, IAnjutaDebuggerGListCallback callback, gpointer user_data)
{
gchar *buff;
@@ -3016,7 +3016,7 @@ debugger_list_argument (Debugger *debugger, IAnjutaDebuggerCallback callback, gp
g_return_if_fail (IS_DEBUGGER (debugger));
buff = g_strdup_printf("-stack-list-arguments 0 %d %d", debugger->priv->current_frame, debugger->priv->current_frame);
- debugger_queue_command (debugger, buff, DEBUGGER_COMMAND_NO_ERROR, debugger_list_argument_finish, callback, user_data);
+ debugger_queue_command (debugger, buff, DEBUGGER_COMMAND_NO_ERROR, debugger_list_argument_finish, (IAnjutaDebuggerCallback)callback, user_data);
g_free (buff);
}
@@ -3032,7 +3032,7 @@ debugger_info_finish (Debugger *debugger, const GDBMIValue *mi_results, const GL
}
void
-debugger_info_frame (Debugger *debugger, guint frame, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_info_frame (Debugger *debugger, guint frame, IAnjutaDebuggerGListCallback callback, gpointer user_data)
{
gchar *buff;
@@ -3048,22 +3048,22 @@ debugger_info_frame (Debugger *debugger, guint frame, IAnjutaDebuggerCallback ca
{
buff = g_strdup_printf ("info frame %d", frame);
}
- debugger_queue_command (debugger, buff, DEBUGGER_COMMAND_NO_ERROR, (DebuggerParserFunc)debugger_info_finish, callback, user_data);
+ debugger_queue_command (debugger, buff, DEBUGGER_COMMAND_NO_ERROR, (DebuggerParserFunc)debugger_info_finish, (IAnjutaDebuggerCallback)callback, user_data);
g_free (buff);
}
void
-debugger_info_signal (Debugger *debugger, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_info_signal (Debugger *debugger, IAnjutaDebuggerGListCallback callback, gpointer user_data)
{
DEBUG_PRINT ("%s", "In function: debugger_info_signal()");
g_return_if_fail (IS_DEBUGGER (debugger));
- debugger_queue_command (debugger, "info signals", DEBUGGER_COMMAND_NO_ERROR, (DebuggerParserFunc)debugger_info_finish, callback, user_data);
+ debugger_queue_command (debugger, "info signals", DEBUGGER_COMMAND_NO_ERROR, (DebuggerParserFunc)debugger_info_finish, (IAnjutaDebuggerCallback)callback, user_data);
}
void
-debugger_info_sharedlib (Debugger *debugger, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_info_sharedlib (Debugger *debugger, IAnjutaDebuggerGListCallback callback, gpointer user_data)
{
gchar *buff;
@@ -3072,57 +3072,57 @@ debugger_info_sharedlib (Debugger *debugger, IAnjutaDebuggerCallback callback, g
g_return_if_fail (IS_DEBUGGER (debugger));
buff = g_strdup_printf ("info sharedlib");
- debugger_queue_command (debugger, buff, DEBUGGER_COMMAND_NO_ERROR, (DebuggerParserFunc)debugger_info_finish, callback, user_data); g_free (buff);
+ debugger_queue_command (debugger, buff, DEBUGGER_COMMAND_NO_ERROR, (DebuggerParserFunc)debugger_info_finish, (IAnjutaDebuggerCallback)callback, user_data); g_free (buff);
}
void
-debugger_info_args (Debugger *debugger, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_info_args (Debugger *debugger, IAnjutaDebuggerGListCallback callback, gpointer user_data)
{
DEBUG_PRINT ("%s", "In function: debugger_info_args()");
g_return_if_fail (IS_DEBUGGER (debugger));
- debugger_queue_command (debugger, "info args", DEBUGGER_COMMAND_NO_ERROR, (DebuggerParserFunc)debugger_info_finish, callback, user_data);
+ debugger_queue_command (debugger, "info args", DEBUGGER_COMMAND_NO_ERROR, (DebuggerParserFunc)debugger_info_finish, (IAnjutaDebuggerCallback)callback, user_data);
}
void
-debugger_info_target (Debugger *debugger, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_info_target (Debugger *debugger, IAnjutaDebuggerGListCallback callback, gpointer user_data)
{
DEBUG_PRINT ("%s", "In function: debugger_info_target()");
g_return_if_fail (IS_DEBUGGER (debugger));
- debugger_queue_command (debugger, "info target", DEBUGGER_COMMAND_NO_ERROR, (DebuggerParserFunc)debugger_info_finish, callback, user_data);
+ debugger_queue_command (debugger, "info target", DEBUGGER_COMMAND_NO_ERROR, (DebuggerParserFunc)debugger_info_finish, (IAnjutaDebuggerCallback)callback, user_data);
}
void
-debugger_info_program (Debugger *debugger, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_info_program (Debugger *debugger, IAnjutaDebuggerGListCallback callback, gpointer user_data)
{
DEBUG_PRINT ("%s", "In function: debugger_info_program()");
g_return_if_fail (IS_DEBUGGER (debugger));
- debugger_queue_command (debugger, "info program", DEBUGGER_COMMAND_NO_ERROR, (DebuggerParserFunc)debugger_info_finish, callback, user_data);
+ debugger_queue_command (debugger, "info program", DEBUGGER_COMMAND_NO_ERROR, (DebuggerParserFunc)debugger_info_finish, (IAnjutaDebuggerCallback)callback, user_data);
}
void
-debugger_info_udot (Debugger *debugger, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_info_udot (Debugger *debugger, IAnjutaDebuggerGListCallback callback, gpointer user_data)
{
DEBUG_PRINT ("%s", "In function: debugger_info_udot()");
g_return_if_fail (IS_DEBUGGER (debugger));
- debugger_queue_command (debugger, "info udot", DEBUGGER_COMMAND_NO_ERROR, (DebuggerParserFunc)debugger_info_finish, callback, user_data);
+ debugger_queue_command (debugger, "info udot", DEBUGGER_COMMAND_NO_ERROR, (DebuggerParserFunc)debugger_info_finish, (IAnjutaDebuggerCallback)callback, user_data);
}
void
-debugger_info_variables (Debugger *debugger, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_info_variables (Debugger *debugger, IAnjutaDebuggerGListCallback callback, gpointer user_data)
{
DEBUG_PRINT ("%s", "In function: debugger_info_variables()");
g_return_if_fail (IS_DEBUGGER (debugger));
- debugger_queue_command (debugger, "info variables", DEBUGGER_COMMAND_NO_ERROR, (DebuggerParserFunc)debugger_info_finish, callback, user_data);
+ debugger_queue_command (debugger, "info variables", DEBUGGER_COMMAND_NO_ERROR, (DebuggerParserFunc)debugger_info_finish, (IAnjutaDebuggerCallback)callback, user_data);
}
static void
@@ -3200,7 +3200,7 @@ debugger_read_memory_finish (Debugger *debugger, const GDBMIValue *mi_results, c
}
void
-debugger_inspect_memory (Debugger *debugger, gulong address, guint length, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_inspect_memory (Debugger *debugger, gulong address, guint length, IAnjutaDebuggerMemoryCallback callback, gpointer user_data)
{
gchar *buff;
@@ -3209,7 +3209,7 @@ debugger_inspect_memory (Debugger *debugger, gulong address, guint length, IAnju
g_return_if_fail (IS_DEBUGGER (debugger));
buff = g_strdup_printf ("-data-read-memory 0x%lx x 1 1 %d", address, length);
- debugger_queue_command (debugger, buff, 0, debugger_read_memory_finish, callback, user_data);
+ debugger_queue_command (debugger, buff, 0, debugger_read_memory_finish, (IAnjutaDebuggerCallback)callback, user_data);
g_free (buff);
}
@@ -3297,7 +3297,7 @@ debugger_disassemble_finish (Debugger *debugger, const GDBMIValue *mi_results, c
}
void
-debugger_disassemble (Debugger *debugger, gulong address, guint length, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_disassemble (Debugger *debugger, gulong address, guint length, IAnjutaDebuggerInstructionCallback callback, gpointer user_data)
{
gchar *buff;
gulong end;
@@ -3310,7 +3310,7 @@ debugger_disassemble (Debugger *debugger, gulong address, guint length, IAnjutaD
/* Handle overflow */
end = (address + length < address) ? G_MAXULONG : address + length;
buff = g_strdup_printf ("-data-disassemble -s 0x%lx -e 0x%lx -- 0", address, end);
- debugger_queue_command (debugger, buff, 0, debugger_disassemble_finish, callback, user_data);
+ debugger_queue_command (debugger, buff, 0, debugger_disassemble_finish, (IAnjutaDebuggerCallback)callback, user_data);
g_free (buff);
}
@@ -3474,14 +3474,14 @@ debugger_stack_finish (Debugger *debugger, const GDBMIValue *mi_results, const G
}
void
-debugger_list_frame (Debugger *debugger, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_list_frame (Debugger *debugger, IAnjutaDebuggerGListCallback callback, gpointer user_data)
{
DEBUG_PRINT ("%s", "In function: debugger_list_frame()");
g_return_if_fail (IS_DEBUGGER (debugger));
debugger_queue_command (debugger, "-stack-list-frames", DEBUGGER_COMMAND_NO_ERROR | DEBUGGER_COMMAND_KEEP_RESULT, NULL, NULL, NULL);
- debugger_queue_command (debugger, "-stack-list-arguments 1", DEBUGGER_COMMAND_NO_ERROR, debugger_stack_finish, callback, user_data);
+ debugger_queue_command (debugger, "-stack-list-arguments 1", DEBUGGER_COMMAND_NO_ERROR, debugger_stack_finish, (IAnjutaDebuggerCallback)callback, user_data);
}
static void
@@ -3514,13 +3514,13 @@ debugger_dump_stack_finish (Debugger *debugger, const GDBMIValue *mi_results, co
}
}
-void debugger_dump_stack_trace (Debugger *debugger, IAnjutaDebuggerCallback func, gpointer user_data)
+void debugger_dump_stack_trace (Debugger *debugger, IAnjutaDebuggerGListCallback func, gpointer user_data)
{
DEBUG_PRINT ("%s", "In function: debugger_dump_stack_frame()");
g_return_if_fail (IS_DEBUGGER (debugger));
- debugger_queue_command (debugger, "thread apply all backtrace", DEBUGGER_COMMAND_NO_ERROR, debugger_dump_stack_finish, func, user_data);
+ debugger_queue_command (debugger, "thread apply all backtrace", DEBUGGER_COMMAND_NO_ERROR, debugger_dump_stack_finish, (IAnjutaDebuggerCallback)func, user_data);
}
/* Thread functions
@@ -3608,13 +3608,13 @@ debugger_list_thread_finish (Debugger *debugger, const GDBMIValue *mi_results, c
}
void
-debugger_list_thread (Debugger *debugger, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_list_thread (Debugger *debugger, IAnjutaDebuggerGListCallback callback, gpointer user_data)
{
DEBUG_PRINT ("%s", "In function: debugger_list_thread()");
g_return_if_fail (IS_DEBUGGER (debugger));
- debugger_queue_command (debugger, "-thread-list-ids", DEBUGGER_COMMAND_NO_ERROR, debugger_list_thread_finish, callback, user_data);
+ debugger_queue_command (debugger, "-thread-list-ids", DEBUGGER_COMMAND_NO_ERROR, debugger_list_thread_finish, (IAnjutaDebuggerCallback)callback, user_data);
}
static void
@@ -3682,7 +3682,7 @@ debugger_info_thread_finish (Debugger *debugger, const GDBMIValue *mi_results, c
}
void
-debugger_info_thread (Debugger *debugger, gint thread, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_info_thread (Debugger *debugger, gint thread, IAnjutaDebuggerGListCallback callback, gpointer user_data)
{
gchar *buff;
guint orig_thread;
@@ -3695,7 +3695,7 @@ debugger_info_thread (Debugger *debugger, gint thread, IAnjutaDebuggerCallback c
buff = g_strdup_printf ("-thread-select %d", thread);
debugger_queue_command (debugger, buff, 0, (DebuggerParserFunc)debugger_info_set_thread_finish, NULL, NULL);
g_free (buff);
- debugger_queue_command (debugger, "-stack-list-frames 0 0", 0, (DebuggerParserFunc)debugger_info_thread_finish, callback, user_data);
+ debugger_queue_command (debugger, "-stack-list-frames 0 0", 0, (DebuggerParserFunc)debugger_info_thread_finish, (IAnjutaDebuggerCallback)callback, user_data);
buff = g_strdup_printf ("-thread-select %d", orig_thread);
debugger_queue_command (debugger, buff, 0, (DebuggerParserFunc)debugger_info_set_thread_finish, NULL, NULL);
@@ -3800,23 +3800,23 @@ debugger_register_value_finish (Debugger *debugger, const GDBMIValue *mi_results
}
void
-debugger_list_register (Debugger *debugger, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_list_register (Debugger *debugger, IAnjutaDebuggerGListCallback callback, gpointer user_data)
{
DEBUG_PRINT ("%s", "In function: debugger_list_register()");
g_return_if_fail (IS_DEBUGGER (debugger));
- debugger_queue_command (debugger, "-data-list-register-names", DEBUGGER_COMMAND_NO_ERROR, debugger_register_name_finish, callback, user_data);
+ debugger_queue_command (debugger, "-data-list-register-names", DEBUGGER_COMMAND_NO_ERROR, debugger_register_name_finish, (IAnjutaDebuggerCallback)callback, user_data);
}
void
-debugger_update_register (Debugger *debugger, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_update_register (Debugger *debugger, IAnjutaDebuggerGListCallback callback, gpointer user_data)
{
DEBUG_PRINT ("%s", "In function: debugger_update_register()");
g_return_if_fail (IS_DEBUGGER (debugger));
- debugger_queue_command (debugger, "-data-list-register-values r", DEBUGGER_COMMAND_NO_ERROR, (DebuggerParserFunc)debugger_register_value_finish, callback, user_data);
+ debugger_queue_command (debugger, "-data-list-register-values r", DEBUGGER_COMMAND_NO_ERROR, (DebuggerParserFunc)debugger_register_value_finish, (IAnjutaDebuggerCallback)callback, user_data);
}
void
@@ -3902,7 +3902,7 @@ gdb_var_evaluate_expression (Debugger *debugger,
}
void
-debugger_evaluate_variable (Debugger *debugger, const gchar* name, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_evaluate_variable (Debugger *debugger, const gchar* name, IAnjutaDebuggerGCharCallback callback, gpointer user_data)
{
gchar *buff;
@@ -3911,7 +3911,7 @@ debugger_evaluate_variable (Debugger *debugger, const gchar* name, IAnjutaDebugg
g_return_if_fail (IS_DEBUGGER (debugger));
buff = g_strdup_printf ("-var-evaluate-expression %s", name);
- debugger_queue_command (debugger, buff, 0, gdb_var_evaluate_expression, callback, user_data);
+ debugger_queue_command (debugger, buff, 0, gdb_var_evaluate_expression, (IAnjutaDebuggerCallback)callback, user_data);
g_free (buff);
}
@@ -4008,7 +4008,7 @@ gdb_var_list_children (Debugger *debugger,
g_list_free (list);
}
-void debugger_list_variable_children (Debugger *debugger, const gchar* name, guint from, IAnjutaDebuggerCallback callback, gpointer user_data)
+void debugger_list_variable_children (Debugger *debugger, const gchar* name, guint from, IAnjutaDebuggerGListCallback callback, gpointer user_data)
{
gchar *buff;
@@ -4017,7 +4017,7 @@ void debugger_list_variable_children (Debugger *debugger, const gchar* name, gui
g_return_if_fail (IS_DEBUGGER (debugger));
buff = g_strdup_printf ("-var-list-children --all-values %s %d %d", name, from, from + MAX_CHILDREN);
- debugger_queue_command (debugger, buff, 0, gdb_var_list_children, callback, user_data);
+ debugger_queue_command (debugger, buff, 0, gdb_var_list_children, (IAnjutaDebuggerCallback)callback, user_data);
g_free (buff);
}
@@ -4056,7 +4056,7 @@ gdb_var_create (Debugger *debugger,
}
-void debugger_create_variable (Debugger *debugger, const gchar* name, IAnjutaDebuggerCallback callback, gpointer user_data)
+void debugger_create_variable (Debugger *debugger, const gchar* name, IAnjutaDebuggerVariableCallback callback, gpointer user_data)
{
gchar *buff;
@@ -4065,7 +4065,7 @@ void debugger_create_variable (Debugger *debugger, const gchar* name, IAnjutaDeb
g_return_if_fail (IS_DEBUGGER (debugger));
buff = g_strdup_printf ("-var-create - @ %s", name);
- debugger_queue_command (debugger, buff, 0, gdb_var_create, callback, user_data);
+ debugger_queue_command (debugger, buff, 0, gdb_var_create, (IAnjutaDebuggerCallback)callback, user_data);
g_free (buff);
}
@@ -4131,13 +4131,13 @@ gdb_var_update (Debugger *debugger,
g_list_free (list);
}
-void debugger_update_variable (Debugger *debugger, IAnjutaDebuggerCallback callback, gpointer user_data)
+void debugger_update_variable (Debugger *debugger, IAnjutaDebuggerGListCallback callback, gpointer user_data)
{
DEBUG_PRINT ("%s", "In function: update_variable()");
g_return_if_fail (IS_DEBUGGER (debugger));
- debugger_queue_command (debugger, "-var-update *", 0, gdb_var_update, callback, user_data);
+ debugger_queue_command (debugger, "-var-update *", 0, gdb_var_update, (IAnjutaDebuggerCallback)callback, user_data);
}
GType
diff --git a/plugins/gdb/debugger.h b/plugins/gdb/debugger.h
index daf893b..85f67b8 100644
--- a/plugins/gdb/debugger.h
+++ b/plugins/gdb/debugger.h
@@ -29,6 +29,10 @@
#include <libanjuta/interfaces/ianjuta-message-view.h>
#include <libanjuta/interfaces/ianjuta-debugger.h>
+#include <libanjuta/interfaces/ianjuta-debugger-breakpoint.h>
+#include <libanjuta/interfaces/ianjuta-debugger-memory.h>
+#include <libanjuta/interfaces/ianjuta-debugger-instruction.h>
+#include <libanjuta/interfaces/ianjuta-debugger-variable.h>
G_BEGIN_DECLS
@@ -143,60 +147,60 @@ void debugger_run_to_address (Debugger *debugger, gulong address);
void debugger_run_from_address (Debugger *debugger, gulong address);
/* Breakpoint */
-void debugger_add_breakpoint_at_line (Debugger *debugger, const gchar* file, guint line, IAnjutaDebuggerCallback callback, gpointer user_data);
-void debugger_add_breakpoint_at_function (Debugger *debugger, const gchar* file, const gchar* function, IAnjutaDebuggerCallback callback, gpointer user_data);
-void debugger_add_breakpoint_at_address (Debugger *debugger, gulong address, IAnjutaDebuggerCallback callback, gpointer user_data);
-void debugger_remove_breakpoint (Debugger *debugger, guint id, IAnjutaDebuggerCallback callback, gpointer user_data);
-void debugger_list_breakpoint (Debugger *debugger, IAnjutaDebuggerCallback callback, gpointer user_data);
-void debugger_enable_breakpoint (Debugger *debugger, guint id, gboolean enable, IAnjutaDebuggerCallback callback, gpointer user_data);
-void debugger_ignore_breakpoint (Debugger *debugger, guint id, guint ignore, IAnjutaDebuggerCallback callback, gpointer user_data);
-void debugger_condition_breakpoint (Debugger *debugger, guint id, const gchar* condition, IAnjutaDebuggerCallback callback, gpointer user_data);
+void debugger_add_breakpoint_at_line (Debugger *debugger, const gchar* file, guint line, IAnjutaDebuggerBreakpointCallback callback, gpointer user_data);
+void debugger_add_breakpoint_at_function (Debugger *debugger, const gchar* file, const gchar* function, IAnjutaDebuggerBreakpointCallback callback, gpointer user_data);
+void debugger_add_breakpoint_at_address (Debugger *debugger, gulong address, IAnjutaDebuggerBreakpointCallback callback, gpointer user_data);
+void debugger_remove_breakpoint (Debugger *debugger, guint id, IAnjutaDebuggerBreakpointCallback callback, gpointer user_data);
+void debugger_list_breakpoint (Debugger *debugger, IAnjutaDebuggerGListCallback callback, gpointer user_data);
+void debugger_enable_breakpoint (Debugger *debugger, guint id, gboolean enable, IAnjutaDebuggerBreakpointCallback callback, gpointer user_data);
+void debugger_ignore_breakpoint (Debugger *debugger, guint id, guint ignore, IAnjutaDebuggerBreakpointCallback callback, gpointer user_data);
+void debugger_condition_breakpoint (Debugger *debugger, guint id, const gchar* condition, IAnjutaDebuggerBreakpointCallback callback, gpointer user_data);
/* Variable */
-void debugger_print (Debugger *debugger, const gchar* variable, IAnjutaDebuggerCallback callback, gpointer user_data);
-void debugger_evaluate (Debugger *debugger, const gchar* name, IAnjutaDebuggerCallback callback, gpointer user_data);
+void debugger_print (Debugger *debugger, const gchar* variable, IAnjutaDebuggerGCharCallback callback, gpointer user_data);
+void debugger_evaluate (Debugger *debugger, const gchar* name, IAnjutaDebuggerGCharCallback callback, gpointer user_data);
/* Info */
-void debugger_list_local (Debugger *debugger, IAnjutaDebuggerCallback func, gpointer user_data);
-void debugger_list_argument (Debugger *debugger, IAnjutaDebuggerCallback func, gpointer user_data);
-void debugger_info_signal (Debugger *debugger, IAnjutaDebuggerCallback func, gpointer user_data);
-void debugger_info_frame (Debugger *debugger, guint frame, IAnjutaDebuggerCallback func, gpointer user_data);
-void debugger_info_sharedlib (Debugger *debugger, IAnjutaDebuggerCallback func, gpointer user_data);
-void debugger_info_args (Debugger *debugger, IAnjutaDebuggerCallback func, gpointer user_data);
-void debugger_info_target (Debugger *debugger, IAnjutaDebuggerCallback func, gpointer user_data);
-void debugger_info_program (Debugger *debugger, IAnjutaDebuggerCallback func, gpointer user_data);
-void debugger_info_udot (Debugger *debugger, IAnjutaDebuggerCallback func, gpointer user_data);
-void debugger_info_variables (Debugger *debugger, IAnjutaDebuggerCallback func, gpointer user_data);
-void debugger_inspect_memory (Debugger *debugger, gulong address, guint length, IAnjutaDebuggerCallback func, gpointer user_data);
-void debugger_disassemble (Debugger *debugger, gulong address, guint length, IAnjutaDebuggerCallback func, gpointer user_data);
+void debugger_list_local (Debugger *debugger, IAnjutaDebuggerGListCallback func, gpointer user_data);
+void debugger_list_argument (Debugger *debugger, IAnjutaDebuggerGListCallback func, gpointer user_data);
+void debugger_info_signal (Debugger *debugger, IAnjutaDebuggerGListCallback func, gpointer user_data);
+void debugger_info_frame (Debugger *debugger, guint frame, IAnjutaDebuggerGListCallback func, gpointer user_data);
+void debugger_info_sharedlib (Debugger *debugger, IAnjutaDebuggerGListCallback func, gpointer user_data);
+void debugger_info_args (Debugger *debugger, IAnjutaDebuggerGListCallback func, gpointer user_data);
+void debugger_info_target (Debugger *debugger, IAnjutaDebuggerGListCallback func, gpointer user_data);
+void debugger_info_program (Debugger *debugger, IAnjutaDebuggerGListCallback func, gpointer user_data);
+void debugger_info_udot (Debugger *debugger, IAnjutaDebuggerGListCallback func, gpointer user_data);
+void debugger_info_variables (Debugger *debugger, IAnjutaDebuggerGListCallback func, gpointer user_data);
+void debugger_inspect_memory (Debugger *debugger, gulong address, guint length, IAnjutaDebuggerMemoryCallback func, gpointer user_data);
+void debugger_disassemble (Debugger *debugger, gulong address, guint length, IAnjutaDebuggerInstructionCallback func, gpointer user_data);
/* Register */
-void debugger_list_register (Debugger *debugger, IAnjutaDebuggerCallback func, gpointer user_data);
-void debugger_update_register (Debugger *debugger, IAnjutaDebuggerCallback func, gpointer user_data);
+void debugger_list_register (Debugger *debugger, IAnjutaDebuggerGListCallback func, gpointer user_data);
+void debugger_update_register (Debugger *debugger, IAnjutaDebuggerGListCallback func, gpointer user_data);
void debugger_write_register (Debugger *debugger, const gchar *name, const gchar *value);
/* Stack */
-void debugger_list_argument (Debugger *debugger, IAnjutaDebuggerCallback func, gpointer user_data);
-void debugger_list_frame (Debugger *debugger, IAnjutaDebuggerCallback func, gpointer user_data);
+void debugger_list_argument (Debugger *debugger, IAnjutaDebuggerGListCallback func, gpointer user_data);
+void debugger_list_frame (Debugger *debugger, IAnjutaDebuggerGListCallback func, gpointer user_data);
void debugger_set_frame (Debugger *debugger, gsize frame);
-void debugger_dump_stack_trace (Debugger *debugger, IAnjutaDebuggerCallback func, gpointer user_data);
+void debugger_dump_stack_trace (Debugger *debugger, IAnjutaDebuggerGListCallback func, gpointer user_data);
/* Thread */
-void debugger_list_thread (Debugger *debugger, IAnjutaDebuggerCallback func, gpointer user_data);
+void debugger_list_thread (Debugger *debugger, IAnjutaDebuggerGListCallback func, gpointer user_data);
void debugger_set_thread (Debugger *debugger, gint thread);
-void debugger_info_thread (Debugger *debugger, gint thread, IAnjutaDebuggerCallback func, gpointer user_data);
+void debugger_info_thread (Debugger *debugger, gint thread, IAnjutaDebuggerGListCallback func, gpointer user_data);
/* Log */
void debugger_set_log (Debugger *debugger, IAnjutaMessageView *view);
/* Variable object */
void debugger_delete_variable (Debugger *debugger, const gchar *name);
-void debugger_evaluate_variable (Debugger *debugger, const gchar *name, IAnjutaDebuggerCallback callback, gpointer user_data);
+void debugger_evaluate_variable (Debugger *debugger, const gchar *name, IAnjutaDebuggerGCharCallback callback, gpointer user_data);
void debugger_assign_variable (Debugger *debugger, const gchar *name, const gchar *value);
-void debugger_list_variable_children (Debugger *debugger, const gchar* name, guint from, IAnjutaDebuggerCallback callback, gpointer user_data);
-void debugger_create_variable (Debugger *debugger, const gchar *name, IAnjutaDebuggerCallback callback, gpointer user_data);
-void debugger_update_variable (Debugger *debugger, IAnjutaDebuggerCallback callback, gpointer user_data);
+void debugger_list_variable_children (Debugger *debugger, const gchar* name, guint from, IAnjutaDebuggerGListCallback callback, gpointer user_data);
+void debugger_create_variable (Debugger *debugger, const gchar *name, IAnjutaDebuggerVariableCallback callback, gpointer user_data);
+void debugger_update_variable (Debugger *debugger, IAnjutaDebuggerGListCallback callback, gpointer user_data);
#if 0
diff --git a/plugins/gdb/plugin.c b/plugins/gdb/plugin.c
index 290498c..583d03d 100644
--- a/plugins/gdb/plugin.c
+++ b/plugins/gdb/plugin.c
@@ -604,7 +604,7 @@ idebugger_interrupt (IAnjutaDebugger *plugin, GError **err)
}
static gboolean
-idebugger_inspect (IAnjutaDebugger *plugin, const gchar *name, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
+idebugger_inspect (IAnjutaDebugger *plugin, const gchar *name, IAnjutaDebuggerGCharCallback callback, gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -614,7 +614,7 @@ idebugger_inspect (IAnjutaDebugger *plugin, const gchar *name, IAnjutaDebuggerCa
}
static gboolean
-idebugger_evaluate (IAnjutaDebugger *plugin, const gchar *name, const gchar *value, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
+idebugger_evaluate (IAnjutaDebugger *plugin, const gchar *name, const gchar *value, IAnjutaDebuggerGCharCallback callback, gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
gchar* buf;
@@ -637,7 +637,7 @@ idebugger_send_command (IAnjutaDebugger *plugin, const gchar* command, GError **
}
static gboolean
-idebugger_print (IAnjutaDebugger *plugin, const gchar* variable, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
+idebugger_print (IAnjutaDebugger *plugin, const gchar* variable, IAnjutaDebuggerGCharCallback callback, gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -647,7 +647,7 @@ idebugger_print (IAnjutaDebugger *plugin, const gchar* variable, IAnjutaDebugger
}
static gboolean
-idebugger_list_local (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_list_local (IAnjutaDebugger *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -657,7 +657,7 @@ idebugger_list_local (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback
}
static gboolean
-idebugger_list_argument (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_list_argument (IAnjutaDebugger *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -667,7 +667,7 @@ idebugger_list_argument (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callba
}
static gboolean
-idebugger_info_signal (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_info_signal (IAnjutaDebugger *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -677,7 +677,7 @@ idebugger_info_signal (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback
}
static gboolean
-idebugger_info_sharedlib (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_info_sharedlib (IAnjutaDebugger *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -700,7 +700,7 @@ idebugger_handle_signal (IAnjutaDebugger *plugin, const gchar* name, gboolean st
}
static gboolean
-idebugger_info_frame (IAnjutaDebugger *plugin, guint frame, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_info_frame (IAnjutaDebugger *plugin, guint frame, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -710,7 +710,7 @@ idebugger_info_frame (IAnjutaDebugger *plugin, guint frame, IAnjutaDebuggerCallb
}
static gboolean
-idebugger_info_args (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_info_args (IAnjutaDebugger *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -720,7 +720,7 @@ idebugger_info_args (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback ,
}
static gboolean
-idebugger_info_target (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_info_target (IAnjutaDebugger *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -730,7 +730,7 @@ idebugger_info_target (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback
}
static gboolean
-idebugger_info_program (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_info_program (IAnjutaDebugger *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -740,7 +740,7 @@ idebugger_info_program (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callbac
}
static gboolean
-idebugger_info_udot (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_info_udot (IAnjutaDebugger *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -750,7 +750,7 @@ idebugger_info_udot (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback ,
}
static gboolean
-idebugger_info_variables (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_info_variables (IAnjutaDebugger *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -770,7 +770,7 @@ idebugger_set_frame (IAnjutaDebugger *plugin, guint frame, GError **err)
}
static gboolean
-idebugger_list_frame (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_list_frame (IAnjutaDebugger *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -790,7 +790,7 @@ idebugger_set_thread (IAnjutaDebugger *plugin, gint thread, GError **err)
}
static gboolean
-idebugger_list_thread (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_list_thread (IAnjutaDebugger *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -800,7 +800,7 @@ idebugger_list_thread (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback
}
static gboolean
-idebugger_info_thread (IAnjutaDebugger *plugin, gint thread, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_info_thread (IAnjutaDebugger *plugin, gint thread, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -810,16 +810,6 @@ idebugger_info_thread (IAnjutaDebugger *plugin, gint thread, IAnjutaDebuggerCall
}
static gboolean
-idebugger_list_register (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
-{
- //GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
-
- //debugger_list_register (this->debugger, callback, user_data);
-
- return TRUE;
-}
-
-static gboolean
idebugger_run_from (IAnjutaDebugger *plugin, const gchar *file, gint line, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -830,7 +820,7 @@ idebugger_run_from (IAnjutaDebugger *plugin, const gchar *file, gint line, GErro
}
static gboolean
-idebugger_dump_stack_trace (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_dump_stack_trace (IAnjutaDebugger *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -910,7 +900,6 @@ idebugger_iface_init (IAnjutaDebuggerIface *iface)
iface->list_thread = idebugger_list_thread;
iface->set_thread = idebugger_set_thread;
iface->info_thread = idebugger_info_thread;
- iface->list_register = idebugger_list_register;
iface->dump_stack_trace = idebugger_dump_stack_trace;
iface->send_command = idebugger_send_command;
@@ -937,7 +926,7 @@ idebugger_breakpoint_implement (IAnjutaDebuggerBreakpoint *plugin, GError **err)
}
static gboolean
-idebugger_breakpoint_add_at_line (IAnjutaDebuggerBreakpoint *plugin, const gchar* file, guint line, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
+idebugger_breakpoint_add_at_line (IAnjutaDebuggerBreakpoint *plugin, const gchar* file, guint line, IAnjutaDebuggerBreakpointCallback callback, gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -947,7 +936,7 @@ idebugger_breakpoint_add_at_line (IAnjutaDebuggerBreakpoint *plugin, const gchar
}
static gboolean
-idebugger_breakpoint_add_at_function (IAnjutaDebuggerBreakpoint *plugin, const gchar* file, const gchar* function, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
+idebugger_breakpoint_add_at_function (IAnjutaDebuggerBreakpoint *plugin, const gchar* file, const gchar* function, IAnjutaDebuggerBreakpointCallback callback, gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -957,7 +946,7 @@ idebugger_breakpoint_add_at_function (IAnjutaDebuggerBreakpoint *plugin, const g
}
static gboolean
-idebugger_breakpoint_add_at_address (IAnjutaDebuggerBreakpoint *plugin, gulong address, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
+idebugger_breakpoint_add_at_address (IAnjutaDebuggerBreakpoint *plugin, gulong address, IAnjutaDebuggerBreakpointCallback callback, gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -967,7 +956,7 @@ idebugger_breakpoint_add_at_address (IAnjutaDebuggerBreakpoint *plugin, gulong a
}
static gboolean
-idebugger_breakpoint_enable (IAnjutaDebuggerBreakpoint *plugin, guint id, gboolean enable, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
+idebugger_breakpoint_enable (IAnjutaDebuggerBreakpoint *plugin, guint id, gboolean enable, IAnjutaDebuggerBreakpointCallback callback, gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -977,7 +966,7 @@ idebugger_breakpoint_enable (IAnjutaDebuggerBreakpoint *plugin, guint id, gboole
}
static gboolean
-idebugger_breakpoint_ignore (IAnjutaDebuggerBreakpoint *plugin, guint id, guint ignore, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
+idebugger_breakpoint_ignore (IAnjutaDebuggerBreakpoint *plugin, guint id, guint ignore, IAnjutaDebuggerBreakpointCallback callback, gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -987,7 +976,7 @@ idebugger_breakpoint_ignore (IAnjutaDebuggerBreakpoint *plugin, guint id, guint
}
static gboolean
-idebugger_breakpoint_condition (IAnjutaDebuggerBreakpoint *plugin, guint id, const gchar *condition, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
+idebugger_breakpoint_condition (IAnjutaDebuggerBreakpoint *plugin, guint id, const gchar *condition, IAnjutaDebuggerBreakpointCallback callback, gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -997,7 +986,7 @@ idebugger_breakpoint_condition (IAnjutaDebuggerBreakpoint *plugin, guint id, con
}
static gboolean
-idebugger_breakpoint_remove (IAnjutaDebuggerBreakpoint *plugin, guint id, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
+idebugger_breakpoint_remove (IAnjutaDebuggerBreakpoint *plugin, guint id, IAnjutaDebuggerBreakpointCallback callback, gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -1007,7 +996,7 @@ idebugger_breakpoint_remove (IAnjutaDebuggerBreakpoint *plugin, guint id, IAnjut
}
static gboolean
-idebugger_breakpoint_list (IAnjutaDebuggerBreakpoint *plugin, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
+idebugger_breakpoint_list (IAnjutaDebuggerBreakpoint *plugin, IAnjutaDebuggerGListCallback callback, gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -1034,7 +1023,7 @@ idebugger_breakpoint_iface_init (IAnjutaDebuggerBreakpointIface *iface)
*---------------------------------------------------------------------------*/
static gboolean
-idebugger_register_list (IAnjutaDebuggerRegister *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_register_list (IAnjutaDebuggerRegister *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -1044,7 +1033,7 @@ idebugger_register_list (IAnjutaDebuggerRegister *plugin, IAnjutaDebuggerCallbac
}
static gboolean
-idebugger_register_update (IAnjutaDebuggerRegister *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_register_update (IAnjutaDebuggerRegister *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -1075,7 +1064,7 @@ idebugger_register_iface_init (IAnjutaDebuggerRegisterIface *iface)
*---------------------------------------------------------------------------*/
static gboolean
-idebugger_memory_inspect (IAnjutaDebuggerMemory *plugin, gulong address, guint length, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_memory_inspect (IAnjutaDebuggerMemory *plugin, gulong address, guint length, IAnjutaDebuggerMemoryCallback callback , gpointer user_data, GError **err)
{
GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
@@ -1094,7 +1083,7 @@ idebugger_memory_iface_init (IAnjutaDebuggerMemoryIface *iface)
*---------------------------------------------------------------------------*/
static gboolean
-idebugger_instruction_disassemble (IAnjutaDebuggerInstruction *plugin, gulong address, guint length, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_instruction_disassemble (IAnjutaDebuggerInstruction *plugin, gulong address, guint length, IAnjutaDebuggerInstructionCallback callback , gpointer user_data, GError **err)
{
GdbPlugin *this = (GdbPlugin *)plugin;
@@ -1167,7 +1156,7 @@ idebugger_variable_destroy (IAnjutaDebuggerVariable *plugin, const gchar *name,
}
static gboolean
-idebugger_variable_evaluate (IAnjutaDebuggerVariable *plugin, const gchar *name, IAnjutaDebuggerCallback callback , gpointer user_data, GError **error)
+idebugger_variable_evaluate (IAnjutaDebuggerVariable *plugin, const gchar *name, IAnjutaDebuggerGCharCallback callback , gpointer user_data, GError **error)
{
GdbPlugin *gdb = ANJUTA_PLUGIN_GDB (plugin);
@@ -1187,7 +1176,7 @@ idebugger_variable_assign (IAnjutaDebuggerVariable *plugin, const gchar *name, c
}
static gboolean
-idebugger_variable_list_children (IAnjutaDebuggerVariable *plugin, const gchar *name, guint from, IAnjutaDebuggerCallback callback , gpointer user_data, GError **error)
+idebugger_variable_list_children (IAnjutaDebuggerVariable *plugin, const gchar *name, guint from, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **error)
{
GdbPlugin *gdb = ANJUTA_PLUGIN_GDB (plugin);
@@ -1197,7 +1186,7 @@ idebugger_variable_list_children (IAnjutaDebuggerVariable *plugin, const gchar *
}
static gboolean
-idebugger_variable_create (IAnjutaDebuggerVariable *plugin, const gchar *name, IAnjutaDebuggerCallback callback , gpointer user_data, GError **error)
+idebugger_variable_create (IAnjutaDebuggerVariable *plugin, const gchar *name, IAnjutaDebuggerVariableCallback callback , gpointer user_data, GError **error)
{
GdbPlugin *gdb = ANJUTA_PLUGIN_GDB (plugin);
@@ -1207,7 +1196,7 @@ idebugger_variable_create (IAnjutaDebuggerVariable *plugin, const gchar *name, I
}
static gboolean
-idebugger_variable_update (IAnjutaDebuggerVariable *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **error)
+idebugger_variable_update (IAnjutaDebuggerVariable *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **error)
{
GdbPlugin *gdb = ANJUTA_PLUGIN_GDB (plugin);
diff --git a/plugins/js-debugger/debugger-js.c b/plugins/js-debugger/debugger-js.c
index 79297d5..802999b 100644
--- a/plugins/js-debugger/debugger-js.c
+++ b/plugins/js-debugger/debugger-js.c
@@ -669,7 +669,7 @@ debugger_js_add_breakpoint (DebuggerJs *object, const gchar* file, guint line)
}
void
-debugger_js_breakpoint_list (DebuggerJs *object, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_js_breakpoint_list (DebuggerJs *object, IAnjutaDebuggerGListCallback callback, gpointer user_data)
{
DebuggerJsPrivate *priv = DEBUGGER_JS_PRIVATE(object);
@@ -678,7 +678,7 @@ debugger_js_breakpoint_list (DebuggerJs *object, IAnjutaDebuggerCallback callbac
task_added (object);
struct Task *task = g_new (struct Task, 1);
task->user_data = user_data;
- task->callback = callback;
+ task->callback = (IAnjutaDebuggerCallback)callback;
task->line_required = 0;
task->task_type = BREAKPOINT_LIST;
@@ -703,7 +703,7 @@ debugger_js_signal (DebuggerJs *object, IAnjutaDebuggerCallback callback, gpoint
}
void
-debugger_js_variable_list_children (DebuggerJs *object, IAnjutaDebuggerCallback callback, const gchar *name, gpointer user_data)
+debugger_js_variable_list_children (DebuggerJs *object, IAnjutaDebuggerGListCallback callback, const gchar *name, gpointer user_data)
{
DebuggerJsPrivate *priv = DEBUGGER_JS_PRIVATE(object);
@@ -712,7 +712,7 @@ debugger_js_variable_list_children (DebuggerJs *object, IAnjutaDebuggerCallback
task_added (object);
struct Task *task = g_new (struct Task, 1);
task->user_data = user_data;
- task->callback = callback;
+ task->callback = (IAnjutaDebuggerCallback)callback;
task->line_required = 1;
task->task_type = VARIABLE_LIST_CHILDREN;
task->this_data.VareableListChildren.name = g_strdup (name);
@@ -724,7 +724,7 @@ debugger_js_variable_list_children (DebuggerJs *object, IAnjutaDebuggerCallback
}
void
-debugger_js_list_local (DebuggerJs *object, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_js_list_local (DebuggerJs *object, IAnjutaDebuggerGListCallback callback, gpointer user_data)
{
DebuggerJsPrivate *priv = DEBUGGER_JS_PRIVATE(object);
@@ -733,7 +733,7 @@ debugger_js_list_local (DebuggerJs *object, IAnjutaDebuggerCallback callback, gp
task_added (object);
struct Task *task = g_new (struct Task, 1);
task->user_data = user_data;
- task->callback = callback;
+ task->callback = (IAnjutaDebuggerCallback)callback;
task->line_required = 1;
task->task_type = LIST_LOCAL;
@@ -743,7 +743,7 @@ debugger_js_list_local (DebuggerJs *object, IAnjutaDebuggerCallback callback, gp
}
void
-debugger_js_list_thread (DebuggerJs *object, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_js_list_thread (DebuggerJs *object, IAnjutaDebuggerGListCallback callback, gpointer user_data)
{
DebuggerJsPrivate *priv = DEBUGGER_JS_PRIVATE(object);
@@ -752,7 +752,7 @@ debugger_js_list_thread (DebuggerJs *object, IAnjutaDebuggerCallback callback, g
task_added (object);
struct Task *task = g_new (struct Task, 1);
task->user_data = user_data;
- task->callback = callback;
+ task->callback = (IAnjutaDebuggerCallback)callback;
task->line_required = 0;
task->task_type = LIST_THREAD;
@@ -760,7 +760,7 @@ debugger_js_list_thread (DebuggerJs *object, IAnjutaDebuggerCallback callback, g
}
void
-debugger_js_list_frame (DebuggerJs *object, IAnjutaDebuggerCallback callback, gpointer user_data)
+debugger_js_list_frame (DebuggerJs *object, IAnjutaDebuggerGListCallback callback, gpointer user_data)
{
DebuggerJsPrivate *priv = DEBUGGER_JS_PRIVATE(object);
@@ -769,7 +769,7 @@ debugger_js_list_frame (DebuggerJs *object, IAnjutaDebuggerCallback callback, gp
task_added (object);
struct Task *task = g_new (struct Task, 1);
task->user_data = user_data;
- task->callback = callback;
+ task->callback = (IAnjutaDebuggerCallback)callback;
task->line_required = 1;
task->task_type = LIST_FRAME;
@@ -779,7 +779,7 @@ debugger_js_list_frame (DebuggerJs *object, IAnjutaDebuggerCallback callback, gp
}
void
-debugger_js_info_thread (DebuggerJs *object, IAnjutaDebuggerCallback callback, gint thread, gpointer user_data)
+debugger_js_info_thread (DebuggerJs *object, IAnjutaDebuggerGListCallback callback, gint thread, gpointer user_data)
{
DebuggerJsPrivate *priv = DEBUGGER_JS_PRIVATE(object);
@@ -788,7 +788,7 @@ debugger_js_info_thread (DebuggerJs *object, IAnjutaDebuggerCallback callback, g
task_added (object);
struct Task *task = g_new (struct Task, 1);
task->user_data = user_data;
- task->callback = callback;
+ task->callback = (IAnjutaDebuggerCallback)callback;
task->line_required = 0;
task->task_type = INFO_THREAD;
@@ -796,7 +796,7 @@ debugger_js_info_thread (DebuggerJs *object, IAnjutaDebuggerCallback callback, g
}
void
-debugger_js_variable_create (DebuggerJs *object, IAnjutaDebuggerCallback callback, const gchar *name, gpointer user_data)
+debugger_js_variable_create (DebuggerJs *object, IAnjutaDebuggerVariableCallback callback, const gchar *name, gpointer user_data)
{
DebuggerJsPrivate *priv = DEBUGGER_JS_PRIVATE(object);
@@ -807,7 +807,7 @@ debugger_js_variable_create (DebuggerJs *object, IAnjutaDebuggerCallback callbac
task_added (object);
struct Task *task = g_new (struct Task, 1);
task->user_data = user_data;
- task->callback = callback;
+ task->callback = (IAnjutaDebuggerCallback)callback;
task->line_required = 1;
task->name = g_strdup (name);
task->task_type = VARIABLE_CREATE;
diff --git a/plugins/js-debugger/debugger-js.h b/plugins/js-debugger/debugger-js.h
index 1f2231b..d64892d 100644
--- a/plugins/js-debugger/debugger-js.h
+++ b/plugins/js-debugger/debugger-js.h
@@ -59,14 +59,14 @@ void debugger_js_stepover (DebuggerJs *object);
void debugger_js_stepout (DebuggerJs *object);
void debugger_js_stop (DebuggerJs *object);
void debugger_js_add_breakpoint (DebuggerJs *object, const gchar* file, guint line);
-void debugger_js_breakpoint_list (DebuggerJs *object, IAnjutaDebuggerCallback callback, gpointer user_data);
-void debugger_js_variable_list_children (DebuggerJs *object, IAnjutaDebuggerCallback callback, const gchar *name, gpointer user_data);
+void debugger_js_breakpoint_list (DebuggerJs *object, IAnjutaDebuggerGListCallback callback, gpointer user_data);
+void debugger_js_variable_list_children (DebuggerJs *object, IAnjutaDebuggerGListCallback callback, const gchar *name, gpointer user_data);
void debugger_js_signal (DebuggerJs *object, IAnjutaDebuggerCallback callback, gpointer user_data);
-void debugger_js_list_local (DebuggerJs *object, IAnjutaDebuggerCallback callback, gpointer user_data);
-void debugger_js_list_thread (DebuggerJs *object, IAnjutaDebuggerCallback callback, gpointer user_data);
-void debugger_js_list_frame (DebuggerJs *object, IAnjutaDebuggerCallback callback, gpointer user_data);
-void debugger_js_info_thread (DebuggerJs *object, IAnjutaDebuggerCallback callback, gint thread, gpointer user_data);
-void debugger_js_variable_create (DebuggerJs *object, IAnjutaDebuggerCallback callback, const gchar *name, gpointer user_data);
+void debugger_js_list_local (DebuggerJs *object, IAnjutaDebuggerGListCallback callback, gpointer user_data);
+void debugger_js_list_thread (DebuggerJs *object, IAnjutaDebuggerGListCallback callback, gpointer user_data);
+void debugger_js_list_frame (DebuggerJs *object, IAnjutaDebuggerGListCallback callback, gpointer user_data);
+void debugger_js_info_thread (DebuggerJs *object, IAnjutaDebuggerGListCallback callback, gint thread, gpointer user_data);
+void debugger_js_variable_create (DebuggerJs *object, IAnjutaDebuggerVariableCallback callback, const gchar *name, gpointer user_data);
G_END_DECLS
diff --git a/plugins/js-debugger/plugin.c b/plugins/js-debugger/plugin.c
index e7604fe..22e28b9 100644
--- a/plugins/js-debugger/plugin.c
+++ b/plugins/js-debugger/plugin.c
@@ -301,7 +301,7 @@ idebugger_interrupt (IAnjutaDebugger *plugin, GError **err)
}
static gboolean
-idebugger_inspect (IAnjutaDebugger *plugin, const gchar *name, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
+idebugger_inspect (IAnjutaDebugger *plugin, const gchar *name, IAnjutaDebuggerGCharCallback callback, gpointer user_data, GError **err)
{
DEBUG_PRINT ("%s", "inspect: Not Implemented");
@@ -309,7 +309,7 @@ idebugger_inspect (IAnjutaDebugger *plugin, const gchar *name, IAnjutaDebuggerCa
}
static gboolean
-idebugger_evaluate (IAnjutaDebugger *plugin, const gchar *name, const gchar *value, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
+idebugger_evaluate (IAnjutaDebugger *plugin, const gchar *name, const gchar *value, IAnjutaDebuggerGCharCallback callback, gpointer user_data, GError **err)
{
DEBUG_PRINT ("%s", "evaluate : Not Implemented");
@@ -325,7 +325,7 @@ idebugger_send_command (IAnjutaDebugger *plugin, const gchar* command, GError **
}
static gboolean
-idebugger_print (IAnjutaDebugger *plugin, const gchar* variable, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
+idebugger_print (IAnjutaDebugger *plugin, const gchar* variable, IAnjutaDebuggerGCharCallback callback, gpointer user_data, GError **err)
{
DEBUG_PRINT ("%s", "print: Not Implemented");
@@ -333,7 +333,7 @@ idebugger_print (IAnjutaDebugger *plugin, const gchar* variable, IAnjutaDebugger
}
static gboolean
-idebugger_list_local (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_list_local (IAnjutaDebugger *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
DEBUG_PRINT ("%s", "list_local: Implemented");
JSDbg *self = ANJUTA_PLUGIN_JSDBG (plugin);
@@ -342,7 +342,7 @@ idebugger_list_local (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback
}
static gboolean
-idebugger_list_argument (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_list_argument (IAnjutaDebugger *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
DEBUG_PRINT ("%s", "list_argument: Not Implemented");
@@ -350,7 +350,7 @@ idebugger_list_argument (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callba
}
static gboolean
-idebugger_info_signal (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_info_signal (IAnjutaDebugger *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
DEBUG_PRINT ("%s", "info_signal: Not Implemented");
@@ -358,7 +358,7 @@ idebugger_info_signal (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback
}
static gboolean
-idebugger_info_sharedlib (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_info_sharedlib (IAnjutaDebugger *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
DEBUG_PRINT ("%s", "info_sharedlib: Not Implemented");
@@ -374,7 +374,7 @@ idebugger_handle_signal (IAnjutaDebugger *plugin, const gchar* name, gboolean st
}
static gboolean
-idebugger_info_frame (IAnjutaDebugger *plugin, guint frame, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_info_frame (IAnjutaDebugger *plugin, guint frame, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
DEBUG_PRINT ("%s", "info_frame: Not Implemented");
@@ -382,7 +382,7 @@ idebugger_info_frame (IAnjutaDebugger *plugin, guint frame, IAnjutaDebuggerCallb
}
static gboolean
-idebugger_info_args (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_info_args (IAnjutaDebugger *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
DEBUG_PRINT ("%s", "info_args: Not Implemented");
@@ -390,7 +390,7 @@ idebugger_info_args (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback ,
}
static gboolean
-idebugger_info_target (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_info_target (IAnjutaDebugger *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
DEBUG_PRINT ("%s", "info_target: Not Implemented");
@@ -398,7 +398,7 @@ idebugger_info_target (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback
}
static gboolean
-idebugger_info_program (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_info_program (IAnjutaDebugger *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
DEBUG_PRINT ("%s", "info_program: Not Implemented");
@@ -406,7 +406,7 @@ idebugger_info_program (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callbac
}
static gboolean
-idebugger_info_udot (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_info_udot (IAnjutaDebugger *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
DEBUG_PRINT ("%s", "info_udot: Not Implemented");
@@ -414,7 +414,7 @@ idebugger_info_udot (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback ,
}
static gboolean
-idebugger_info_variables (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_info_variables (IAnjutaDebugger *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
DEBUG_PRINT ("%s", "info_variables: Not Implemented");
@@ -430,7 +430,7 @@ idebugger_set_frame (IAnjutaDebugger *plugin, guint frame, GError **err)
}
static gboolean
-idebugger_list_frame (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_list_frame (IAnjutaDebugger *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
DEBUG_PRINT ("%s", "list_frame: Implemented");
JSDbg *self = ANJUTA_PLUGIN_JSDBG (plugin);
@@ -447,7 +447,7 @@ idebugger_set_thread (IAnjutaDebugger *plugin, gint thread, GError **err)
}
static gboolean
-idebugger_list_thread (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_list_thread (IAnjutaDebugger *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
DEBUG_PRINT ("%s", "list_thread: Implemented(Fake)");
JSDbg *self = ANJUTA_PLUGIN_JSDBG (plugin);
@@ -456,7 +456,7 @@ idebugger_list_thread (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback
}
static gboolean
-idebugger_info_thread (IAnjutaDebugger *plugin, gint thread, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_info_thread (IAnjutaDebugger *plugin, gint thread, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
DEBUG_PRINT ("%s", "info_thread: Implemented(Fake)");
JSDbg *self = ANJUTA_PLUGIN_JSDBG (plugin);
@@ -465,14 +465,6 @@ idebugger_info_thread (IAnjutaDebugger *plugin, gint thread, IAnjutaDebuggerCall
}
static gboolean
-idebugger_list_register (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
-{
- DEBUG_PRINT ("%s", "list_register: Not Implemented");
-
- return FALSE;
-}
-
-static gboolean
idebugger_run_from (IAnjutaDebugger *plugin, const gchar *file, gint line, GError **err)
{
DEBUG_PRINT ("%s", "run_from: Not Implemented");
@@ -481,7 +473,7 @@ idebugger_run_from (IAnjutaDebugger *plugin, const gchar *file, gint line, GErro
}
static gboolean
-idebugger_dump_stack_trace (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
+idebugger_dump_stack_trace (IAnjutaDebugger *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **err)
{
DEBUG_PRINT ("%s", "dump_stack_trace: Not Implemented");
@@ -551,7 +543,6 @@ idebugger_iface_init (IAnjutaDebuggerIface *iface)
iface->list_thread = idebugger_list_thread;
iface->set_thread = idebugger_set_thread;
iface->info_thread = idebugger_info_thread;
- iface->list_register = idebugger_list_register;
iface->dump_stack_trace = idebugger_dump_stack_trace;
iface->send_command = idebugger_send_command;
@@ -575,7 +566,7 @@ idebugger_breakpoint_implement (IAnjutaDebuggerBreakpoint *plugin, GError **err)
}
static gboolean
-idebugger_breakpoint_add_at_line (IAnjutaDebuggerBreakpoint *plugin, const gchar* file, guint line, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
+idebugger_breakpoint_add_at_line (IAnjutaDebuggerBreakpoint *plugin, const gchar* file, guint line, IAnjutaDebuggerBreakpointCallback callback, gpointer user_data, GError **err)
{
DEBUG_PRINT ("%s", "breakpoint_add_at_line: Implemented");
JSDbg *self = ANJUTA_PLUGIN_JSDBG (plugin);
@@ -584,7 +575,7 @@ idebugger_breakpoint_add_at_line (IAnjutaDebuggerBreakpoint *plugin, const gchar
}
static gboolean
-idebugger_breakpoint_enable (IAnjutaDebuggerBreakpoint *plugin, guint id, gboolean enable, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
+idebugger_breakpoint_enable (IAnjutaDebuggerBreakpoint *plugin, guint id, gboolean enable, IAnjutaDebuggerBreakpointCallback callback, gpointer user_data, GError **err)
{
DEBUG_PRINT ("%s", "breakpoint_enable: Not Implemented");
@@ -592,7 +583,7 @@ idebugger_breakpoint_enable (IAnjutaDebuggerBreakpoint *plugin, guint id, gboole
}
static gboolean
-idebugger_breakpoint_ignore (IAnjutaDebuggerBreakpoint *plugin, guint id, guint ignore, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
+idebugger_breakpoint_ignore (IAnjutaDebuggerBreakpoint *plugin, guint id, guint ignore, IAnjutaDebuggerBreakpointCallback callback, gpointer user_data, GError **err)
{
DEBUG_PRINT ("%s", "breakpoint_ignore: Not Implemented");
@@ -600,7 +591,7 @@ idebugger_breakpoint_ignore (IAnjutaDebuggerBreakpoint *plugin, guint id, guint
}
static gboolean
-idebugger_breakpoint_condition (IAnjutaDebuggerBreakpoint *plugin, guint id, const gchar *condition, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
+idebugger_breakpoint_condition (IAnjutaDebuggerBreakpoint *plugin, guint id, const gchar *condition, IAnjutaDebuggerBreakpointCallback callback, gpointer user_data, GError **err)
{
DEBUG_PRINT ("%s", "breakpoint_condition: Not Implemented");
@@ -608,7 +599,7 @@ idebugger_breakpoint_condition (IAnjutaDebuggerBreakpoint *plugin, guint id, con
}
static gboolean
-idebugger_breakpoint_remove (IAnjutaDebuggerBreakpoint *plugin, guint id, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
+idebugger_breakpoint_remove (IAnjutaDebuggerBreakpoint *plugin, guint id, IAnjutaDebuggerBreakpointCallback callback, gpointer user_data, GError **err)
{
DEBUG_PRINT ("%s", "breakpoint_remove: Not Implemented");
@@ -616,7 +607,7 @@ idebugger_breakpoint_remove (IAnjutaDebuggerBreakpoint *plugin, guint id, IAnjut
}
static gboolean
-idebugger_breakpoint_list (IAnjutaDebuggerBreakpoint *plugin, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
+idebugger_breakpoint_list (IAnjutaDebuggerBreakpoint *plugin, IAnjutaDebuggerGListCallback callback, gpointer user_data, GError **err)
{
DEBUG_PRINT ("%s", "breakpoint_list: Implemented");
JSDbg *self = ANJUTA_PLUGIN_JSDBG (plugin);
@@ -649,7 +640,7 @@ idebugger_variable_destroy (IAnjutaDebuggerVariable *plugin, const gchar *name,
}
static gboolean
-idebugger_variable_evaluate (IAnjutaDebuggerVariable *plugin, const gchar *name, IAnjutaDebuggerCallback callback , gpointer user_data, GError **error)
+idebugger_variable_evaluate (IAnjutaDebuggerVariable *plugin, const gchar *name, IAnjutaDebuggerGCharCallback callback , gpointer user_data, GError **error)
{
puts (name);
DEBUG_PRINT ("%s", "variable_evaluate: Not Implemented");
@@ -665,7 +656,7 @@ idebugger_variable_assign (IAnjutaDebuggerVariable *plugin, const gchar *name, c
}
static gboolean
-idebugger_variable_list_children (IAnjutaDebuggerVariable *plugin, const gchar *name, guint from, IAnjutaDebuggerCallback callback , gpointer user_data, GError **error)
+idebugger_variable_list_children (IAnjutaDebuggerVariable *plugin, const gchar *name, guint from, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **error)
{
puts (name);
DEBUG_PRINT ("%s", "variable_list_children: Implemented");
@@ -676,7 +667,7 @@ idebugger_variable_list_children (IAnjutaDebuggerVariable *plugin, const gchar *
}
static gboolean
-idebugger_variable_create (IAnjutaDebuggerVariable *plugin, const gchar *name, IAnjutaDebuggerCallback callback , gpointer user_data, GError **error)
+idebugger_variable_create (IAnjutaDebuggerVariable *plugin, const gchar *name, IAnjutaDebuggerVariableCallback callback , gpointer user_data, GError **error)
{
puts (name);
DEBUG_PRINT ("%s", "idebugger_variable_create: Implemented");
@@ -686,7 +677,7 @@ idebugger_variable_create (IAnjutaDebuggerVariable *plugin, const gchar *name, I
}
static gboolean
-idebugger_variable_update (IAnjutaDebuggerVariable *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **error)
+idebugger_variable_update (IAnjutaDebuggerVariable *plugin, IAnjutaDebuggerGListCallback callback , gpointer user_data, GError **error)
{
DEBUG_PRINT ("%s", "idebugger_variable_update: Not Implemented");
return FALSE;
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
