## IAnjutaDebugger IAnjutaDebugger — Debugger interface |

## Stability Level

Unstable, unless otherwise indicated

## Synopsis

    #include <libanjuta/interfaces/ianjuta-debugger.h>

    #define             IANJUTA_TYPE_DEBUGGER_ERROR
    #define             IANJUTA_TYPE_DEBUGGER_OUTPUT_TYPE
    #define             IANJUTA_TYPE_DEBUGGER_STATE
    #define             IANJUTA_DEBUGGER_ERROR
                        IAnjutaDebugger;
                        IAnjutaDebuggerIface;
    enum                IAnjutaDebuggerError;
    enum                IAnjutaDebuggerOutputType;
    enum                IAnjutaDebuggerState;
                        IAnjutaDebuggerFrame;
    void                (*IAnjutaDebuggerCallback)          (const gpointer data,
                                                             gpointer user_data,
                                                             GError *err);
    void                (*IAnjutaDebuggerGListCallback)     (const GList *list,
                                                             gpointer user_data,
                                                             GError *err);
    void                (*IAnjutaDebuggerGCharCallback)     (const gchar *value,
                                                             gpointer user_data,
                                                             GError *err);
    void                (*IAnjutaDebuggerOutputCallback)    (IAnjutaDebuggerOutputType type,
                                                             const gchar *output,
                                                             gpointer user_data);
    GType               ianjuta_debugger_output_type_get_type
                                                            (void);
    GType               ianjuta_debugger_state_get_type     (void);
    GQuark              ianjuta_debugger_error_quark        (void);
    GType               ianjuta_debugger_get_type           (void);
    gboolean            ianjuta_debugger_abort              (IAnjutaDebugger *obj,
                                                             GError **err);
    gboolean            ianjuta_debugger_attach             (IAnjutaDebugger *obj,
                                                             pid_t pid,
                                                             const GList *source_search_directories,
                                                             GError **err);
    gboolean            ianjuta_debugger_callback           (IAnjutaDebugger *obj,
                                                             IAnjutaDebuggerCallback callback,
                                                             gpointer user_data,
                                                             GError **err);
    gboolean            ianjuta_debugger_connect            (IAnjutaDebugger *obj,
                                                             const gchar *server,
                                                             const gchar *args,
                                                             gboolean terminal,
                                                             gboolean stop,
                                                             GError **err);
    void                ianjuta_debugger_disable_log        (IAnjutaDebugger *obj,
                                                             GError **err);
    gboolean            ianjuta_debugger_dump_stack_trace   (IAnjutaDebugger *obj,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);
    void                ianjuta_debugger_enable_log         (IAnjutaDebugger *obj,
                                                             IAnjutaMessageView *log,
                                                             GError **err);
    gboolean            ianjuta_debugger_evaluate           (IAnjutaDebugger *obj,
                                                             const gchar *name,
                                                             const gchar *value,
                                                             IAnjutaDebuggerGCharCallback callback,
                                                             gpointer user_data,
                                                             GError **err);
    gboolean            ianjuta_debugger_exit               (IAnjutaDebugger *obj,
                                                             GError **err);
    IAnjutaDebuggerState  ianjuta_debugger_get_state        (IAnjutaDebugger *obj,
                                                             GError **err);
    gboolean            ianjuta_debugger_handle_signal      (IAnjutaDebugger *obj,
                                                             const gchar *name,
                                                             gboolean stop,
                                                             gboolean print,
                                                             gboolean ignore,
                                                             GError **err);
    gboolean            ianjuta_debugger_info_args          (IAnjutaDebugger *obj,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);
    gboolean            ianjuta_debugger_info_frame         (IAnjutaDebugger *obj,
                                                             guint frame,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);
    gboolean            ianjuta_debugger_info_program       (IAnjutaDebugger *obj,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);
    gboolean            ianjuta_debugger_info_sharedlib     (IAnjutaDebugger *obj,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);
    gboolean            ianjuta_debugger_info_signal        (IAnjutaDebugger *obj,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);
    gboolean            ianjuta_debugger_info_target        (IAnjutaDebugger *obj,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);
    gboolean            ianjuta_debugger_info_thread        (IAnjutaDebugger *obj,
                                                             gint thread,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);
    gboolean            ianjuta_debugger_info_udot          (IAnjutaDebugger *obj,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);
    gboolean            ianjuta_debugger_info_variables     (IAnjutaDebugger *obj,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);
    gboolean            ianjuta_debugger_inspect            (IAnjutaDebugger *obj,
                                                             const gchar *name,
                                                             IAnjutaDebuggerGCharCallback callback,
                                                             gpointer user_data,
                                                             GError **err);
    gboolean            ianjuta_debugger_interrupt          (IAnjutaDebugger *obj,
                                                             GError **err);
    gboolean            ianjuta_debugger_list_argument      (IAnjutaDebugger *obj,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);
    gboolean            ianjuta_debugger_list_frame         (IAnjutaDebugger *obj,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);
    gboolean            ianjuta_debugger_list_local         (IAnjutaDebugger *obj,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);
    gboolean            ianjuta_debugger_list_thread        (IAnjutaDebugger *obj,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);
    gboolean            ianjuta_debugger_load               (IAnjutaDebugger *obj,
                                                             const gchar *file,
                                                             const gchar *mime_type,
                                                             const GList *source_search_directories,
                                                             GError **err);
    gboolean            ianjuta_debugger_print              (IAnjutaDebugger *obj,
                                                             const gchar *variable,
                                                             IAnjutaDebuggerGCharCallback callback,
                                                             gpointer user_data,
                                                             GError **err);
    gboolean            ianjuta_debugger_quit               (IAnjutaDebugger *obj,
                                                             GError **err);
    gboolean            ianjuta_debugger_run                (IAnjutaDebugger *obj,
                                                             GError **err);
    gboolean            ianjuta_debugger_run_from           (IAnjutaDebugger *obj,
                                                             const gchar *file,
                                                             gint line,
                                                             GError **err);
    gboolean            ianjuta_debugger_run_to             (IAnjutaDebugger *obj,
                                                             const gchar *file,
                                                             gint line,
                                                             GError **err);
    gboolean            ianjuta_debugger_send_command       (IAnjutaDebugger *obj,
                                                             const gchar *command,
                                                             GError **err);
    gboolean            ianjuta_debugger_set_environment    (IAnjutaDebugger *obj,
                                                             gchar **env,
                                                             GError **err);
    gboolean            ianjuta_debugger_set_frame          (IAnjutaDebugger *obj,
                                                             guint frame,
                                                             GError **err);
    gboolean            ianjuta_debugger_set_thread         (IAnjutaDebugger *obj,
                                                             gint thread,
                                                             GError **err);
    gboolean            ianjuta_debugger_set_working_directory
                                                            (IAnjutaDebugger *obj,
                                                             const gchar *dir,
                                                             GError **err);
    gboolean            ianjuta_debugger_start              (IAnjutaDebugger *obj,
                                                             const gchar *args,
                                                             gboolean terminal,
                                                             gboolean stop,
                                                             GError **err);
    gboolean            ianjuta_debugger_step_in            (IAnjutaDebugger *obj,
                                                             GError **err);
    gboolean            ianjuta_debugger_step_out           (IAnjutaDebugger *obj,
                                                             GError **err);
    gboolean            ianjuta_debugger_step_over          (IAnjutaDebugger *obj,
                                                             GError **err);
    gboolean            ianjuta_debugger_unload             (IAnjutaDebugger *obj,
                                                             GError **err);

## Object Hierarchy

      GInterface
       +----IAnjutaDebugger

## Prerequisites

IAnjutaDebugger requires GObject.

## Known Derived Interfaces

IAnjutaDebugger is required by IAnjutaDebuggerBreakpoint, IAnjutaDebuggerInstruction, IAnjutaDebuggerMemory, IAnjutaDebuggerRegister and IAnjutaDebuggerVariable.

## Signals

      "debugger-ready"                                 : Run Last
      "debugger-started"                               : Run Last
      "debugger-stopped"                               : Run Last
      "frame-changed"                                  : Run Last
      "program-exited"                                 : Run Last
      "program-loaded"                                 : Run Last
      "program-moved"                                  : Run Last
      "program-running"                                : Run Last
      "program-stopped"                                : Run Last
      "sharedlib-event"                                : Run Last
      "signal-received"                                : Run Last

## Description

This interface is implemented by debugger backends, by example the gdb backend. It is used by the debug manager plugin which provides the graphical interface and a simple wrapper: IAnjutaDebugManager.

The debugger is in one on these 5 states and emit a signal to the debug manager when it changes. Here is figure showing all transitions and the signal emitted.

Figure 2.

## Details

### IANJUTA_TYPE_DEBUGGER_ERROR

    #define IANJUTA_TYPE_DEBUGGER_ERROR (ianjuta_debugger_error_get_type())

### IANJUTA_TYPE_DEBUGGER_OUTPUT_TYPE

    #define IANJUTA_TYPE_DEBUGGER_OUTPUT_TYPE (ianjuta_debugger_output_type_get_type())

### IANJUTA_TYPE_DEBUGGER_STATE

    #define IANJUTA_TYPE_DEBUGGER_STATE (ianjuta_debugger_state_get_type())

### IANJUTA_DEBUGGER_ERROR

    #define IANJUTA_DEBUGGER_ERROR ianjuta_debugger_error_quark()

### IAnjutaDebugger

    typedef struct _IAnjutaDebugger IAnjutaDebugger;

### IAnjutaDebuggerIface

    typedef struct {
    	GTypeInterface g_iface;

    	/* Signal */
    	void (*debugger_ready) (IAnjutaDebugger *obj, IAnjutaDebuggerState state);
    	/* Signal */
    	void (*debugger_started) (IAnjutaDebugger *obj);
    	/* Signal */
    	void (*debugger_stopped) (IAnjutaDebugger *obj, GError *err);
    	/* Signal */
    	void (*frame_changed) (IAnjutaDebugger *obj, guint frame,  gint thread);
    	/* Signal */
    	void (*program_exited) (IAnjutaDebugger *obj);
    	/* Signal */
    	void (*program_loaded) (IAnjutaDebugger *obj);
    	/* Signal */
    	void (*program_moved) (IAnjutaDebugger *obj, gint pid,  gint tid,  gulong address,  const gchar* file,  guint line);
    	/* Signal */
    	void (*program_running) (IAnjutaDebugger *obj);
    	/* Signal */
    	void (*program_stopped) (IAnjutaDebugger *obj);
    	/* Signal */
    	void (*sharedlib_event) (IAnjutaDebugger *obj);
    	/* Signal */
    	void (*signal_received) (IAnjutaDebugger *obj, const gchar* name,  const gchar* description);

    	gboolean (*abort) (IAnjutaDebugger *obj, GError **err);
    	gboolean (*attach) (IAnjutaDebugger *obj, pid_t pid, const GList* source_search_directories, GError **err);
    	gboolean (*callback) (IAnjutaDebugger *obj, IAnjutaDebuggerCallback callback,  gpointer user_data, GError **err);
    	gboolean (*connect) (IAnjutaDebugger *obj, const gchar *server,  const gchar *args,  gboolean terminal,  gboolean stop, GError **err);
    	void (*disable_log) (IAnjutaDebugger *obj, GError **err);
    	gboolean (*dump_stack_trace) (IAnjutaDebugger *obj, IAnjutaDebuggerGListCallback callback,  gpointer user_data, GError **err);
    	void (*enable_log) (IAnjutaDebugger *obj, IAnjutaMessageView *log, GError **err);
    	gboolean (*evaluate) (IAnjutaDebugger *obj, const gchar* name,  const gchar* value,  IAnjutaDebuggerGCharCallback callback,  gpointer user_data, GError **err);
    	gboolean (*exit) (IAnjutaDebugger *obj, GError **err);
    	IAnjutaDebuggerState (*get_state) (IAnjutaDebugger *obj, GError **err);
    	gboolean (*handle_signal) (IAnjutaDebugger *obj, const gchar *name,  gboolean stop,  gboolean print,  gboolean ignore, GError **err);
    	gboolean (*info_args) (IAnjutaDebugger *obj, IAnjutaDebuggerGListCallback callback,  gpointer user_data, GError **err);
    	gboolean (*info_frame) (IAnjutaDebugger *obj, guint frame,  IAnjutaDebuggerGListCallback callback,  gpointer user_data, GError **err);
    	gboolean (*info_program) (IAnjutaDebugger *obj, IAnjutaDebuggerGListCallback callback,  gpointer user_data, GError **err);
    	gboolean (*info_sharedlib) (IAnjutaDebugger *obj, IAnjutaDebuggerGListCallback callback,  gpointer user_data, GError **err);
    	gboolean (*info_signal) (IAnjutaDebugger *obj, IAnjutaDebuggerGListCallback callback,  gpointer user_data, GError **err);
    	gboolean (*info_target) (IAnjutaDebugger *obj, IAnjutaDebuggerGListCallback callback,  gpointer user_data, GError **err);
    	gboolean (*info_thread) (IAnjutaDebugger *obj, gint thread,  IAnjutaDebuggerGListCallback callback,  gpointer user_data, GError **err);
    	gboolean (*info_udot) (IAnjutaDebugger *obj, IAnjutaDebuggerGListCallback callback,  gpointer user_data, GError **err);
    	gboolean (*info_variables) (IAnjutaDebugger *obj, IAnjutaDebuggerGListCallback callback,  gpointer user_data, GError **err);
    	gboolean (*inspect) (IAnjutaDebugger *obj, const gchar* name,  IAnjutaDebuggerGCharCallback callback,  gpointer user_data, GError **err);
    	gboolean (*interrupt) (IAnjutaDebugger *obj, GError **err);
    	gboolean (*list_argument) (IAnjutaDebugger *obj, IAnjutaDebuggerGListCallback callback,  gpointer user_data, GError **err);
    	gboolean (*list_frame) (IAnjutaDebugger *obj, IAnjutaDebuggerGListCallback callback,  gpointer user_data, GError **err);
    	gboolean (*list_local) (IAnjutaDebugger *obj, IAnjutaDebuggerGListCallback callback,  gpointer user_data, GError **err);
    	gboolean (*list_thread) (IAnjutaDebugger *obj, IAnjutaDebuggerGListCallback callback,  gpointer user_data, GError **err);
    	gboolean (*load) (IAnjutaDebugger *obj, const gchar *file,  const gchar *mime_type, const GList* source_search_directories, GError **err);
    	gboolean (*print) (IAnjutaDebugger *obj, const gchar *variable,  IAnjutaDebuggerGCharCallback callback,  gpointer user_data, GError **err);
    	gboolean (*quit) (IAnjutaDebugger *obj, GError **err);
    	gboolean (*run) (IAnjutaDebugger *obj, GError **err);
    	gboolean (*run_from) (IAnjutaDebugger *obj, const gchar *file,  gint line, GError **err);
    	gboolean (*run_to) (IAnjutaDebugger *obj, const gchar* file,  gint line, GError **err);
    	gboolean (*send_command) (IAnjutaDebugger *obj, const gchar *command, GError **err);
    	gboolean (*set_environment) (IAnjutaDebugger *obj, gchar **env, GError **err);
    	gboolean (*set_frame) (IAnjutaDebugger *obj, guint frame, GError **err);
    	gboolean (*set_thread) (IAnjutaDebugger *obj, gint thread, GError **err);
    	gboolean (*set_working_directory) (IAnjutaDebugger *obj, const gchar *dir, GError **err);
    	gboolean (*start) (IAnjutaDebugger *obj, const gchar *args,  gboolean terminal,  gboolean stop, GError **err);
    	gboolean (*step_in) (IAnjutaDebugger *obj, GError **err);
    	gboolean (*step_out) (IAnjutaDebugger *obj, GError **err);
    	gboolean (*step_over) (IAnjutaDebugger *obj, GError **err);
    	gboolean (*unload) (IAnjutaDebugger *obj, GError **err);
    } IAnjutaDebuggerIface;

### enum IAnjutaDebuggerError

    typedef enum {
    	IANJUTA_DEBUGGER_OK              =  0,
    	IANJUTA_DEBUGGER_NOT_READY,
    	IANJUTA_DEBUGGER_NOT_RUNNING,
    	IANJUTA_DEBUGGER_NOT_STOPPED,
    	IANJUTA_DEBUGGER_NOT_LOADED,
    	IANJUTA_DEBUGGER_NOT_STARTED,
    	IANJUTA_DEBUGGER_NOT_CONNECTED,
    	IANJUTA_DEBUGGER_NOT_IMPLEMENTED,
    	IANJUTA_DEBUGGER_CANCEL,
    	IANJUTA_DEBUGGER_UNABLE_TO_CREATE_VARIABLE,
    	IANJUTA_DEBUGGER_UNABLE_TO_ACCESS_MEMORY,
    	IANJUTA_DEBUGGER_UNABLE_TO_OPEN_FILE,
    	IANJUTA_DEBUGGER_UNSUPPORTED_FILE_TYPE,
    	IANJUTA_DEBUGGER_UNSUPPORTED_VERSION,
    	IANJUTA_DEBUGGER_UNABLE_TO_FIND_DEBUGGER,
    	IANJUTA_DEBUGGER_ALREADY_DONE,
    	IANJUTA_DEBUGGER_PROGRAM_NOT_FOUND,
    	IANJUTA_DEBUGGER_UNABLE_TO_CONNECT,
    	IANJUTA_DEBUGGER_UNKNOWN_ERROR,
    	IANJUTA_DEBUGGER_OTHER_ERROR
    } IAnjutaDebuggerError;

This enumeration is used to defined the error returned by the debugger backend.

`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

### enum IAnjutaDebuggerOutputType

    typedef enum {
    	IANJUTA_DEBUGGER_OUTPUT,
    	IANJUTA_DEBUGGER_WARNING_OUTPUT,
    	IANJUTA_DEBUGGER_ERROR_OUTPUT,
    	IANJUTA_DEBUGGER_INFO_OUTPUT
    } IAnjutaDebuggerOutputType;

This enumeration is used to defined the kind of output in IAnjutaDebuggerOutputCallback

`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

### enum IAnjutaDebuggerState

    typedef enum {
    	IANJUTA_DEBUGGER_BUSY,
    	IANJUTA_DEBUGGER_STOPPED,
    	IANJUTA_DEBUGGER_STARTED,
    	IANJUTA_DEBUGGER_PROGRAM_LOADED,
    	IANJUTA_DEBUGGER_PROGRAM_STOPPED,
    	IANJUTA_DEBUGGER_PROGRAM_RUNNING
    } IAnjutaDebuggerState;

This enumeration is used to defined the different state of the debugger.

`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.

### IAnjutaDebuggerFrame

    typedef struct {
    	gint thread;
    	guint level;
    	gchar *args;
    	gchar *file;
    	guint line;
    	gchar *function;
    	gchar *library;
    	gulong address;
    } IAnjutaDebuggerFrame;

This structure keeps all information about a stack frame.

gint `thread`; | Thread identifier.
guint `level`; | Level of the frame, 0 is the topmost one.
gchar *`args`; | List of argument of the caller.
gchar *`file`; | Source file name where is the program counter.
guint `line`; | Line number in the file above.
gchar *`function`; | Function name where is the program counter.
gchar *`library`; | Library name where is the program counter.
gulong `address`; | Address of the program counter.

### IAnjutaDebuggerCallback ()

    void                (*IAnjutaDebuggerCallback)          (const gpointer data,
                                                             gpointer user_data,
                                                             GError *err);

This callback function is used only by ianjuta_debugger_callback with a NULL data.

`data` : | data
`user_data` : | user data passed to the function
`err` : |

### IAnjutaDebuggerGListCallback ()

    void                (*IAnjutaDebuggerGListCallback)     (const GList *list,
                                                             gpointer user_data,
                                                             GError *err);

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.

`list` : | list of data. [element-type any]
`user_data` : | user data passed to the function
`err` : |

### IAnjutaDebuggerGCharCallback ()

    void                (*IAnjutaDebuggerGCharCallback)     (const gchar *value,
                                                             gpointer user_data,
                                                             GError *err);

This callback function is used by several debugger functions. The data is a string

`value` : |
`user_data` : | user data
`err` : |

### IAnjutaDebuggerOutputCallback ()

    void                (*IAnjutaDebuggerOutputCallback)    (IAnjutaDebuggerOutputType type,
                                                             const gchar *output,
                                                             gpointer user_data);

This callback function is used only by ianjuta_debugger_callback with a NULL data.

`type` : |
`output` : |
`user_data` : | user data

### ianjuta_debugger_output_type_get_type ()

    GType               ianjuta_debugger_output_type_get_type
                                                            (void);

Returns : |

### ianjuta_debugger_state_get_type ()

    GType               ianjuta_debugger_state_get_type     (void);

Returns : |

### ianjuta_debugger_error_quark ()

    GQuark              ianjuta_debugger_error_quark        (void);

Returns : |

### ianjuta_debugger_get_type ()

    GType               ianjuta_debugger_get_type           (void);

Returns : |

### ianjuta_debugger_abort ()

    gboolean            ianjuta_debugger_abort              (IAnjutaDebugger *obj,
                                                             GError **err);

Quit the debugger as fast as possible.

`obj` : | Self
`err` : | Error propagation and reporting.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_attach ()

    gboolean            ianjuta_debugger_attach             (IAnjutaDebugger *obj,
                                                             pid_t pid,
                                                             const GList *source_search_directories,
                                                             GError **err);

Attach to an already running process.

`obj` : | Self
`pid` : | pid of the process to debug
`source_search_directories` : | List of directories to search for source files. [element-type utf8]
`err` : | Error propagation and reporting.
Returns : | TRUE if sucessful, other FALSE.

### ianjuta_debugger_callback ()

    gboolean            ianjuta_debugger_callback           (IAnjutaDebugger *obj,
                                                             IAnjutaDebuggerCallback callback,
                                                             gpointer user_data,
                                                             GError **err);

All commands are executed asynchronously and give back information with callbacks. It is difficult to know when a command is really executed. But as all commands are executed in order, you can use this command to get a call back when all previous commands have been executed.

`obj` : | Self
`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.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_connect ()

    gboolean            ianjuta_debugger_connect            (IAnjutaDebugger *obj,
                                                             const gchar *server,
                                                             const gchar *args,
                                                             gboolean terminal,
                                                             gboolean stop,
                                                             GError **err);

Connect to a remote debugger and run program

`obj` : | Self
`server` : | remote server
`args` : | command line argument of the program
`terminal` : | TRUE if the program need a terminal
`stop` : | TRUE if program is stopped at the beginning
`err` : | Error propagation and reporting
Returns : | TRUE if sucessfull, otherwise FALSE.

### ianjuta_debugger_disable_log ()

    void                ianjuta_debugger_disable_log        (IAnjutaDebugger *obj,
                                                             GError **err);

Disable debugger log.

`obj` : | Self
`err` : | Error propagation and reporting.

### ianjuta_debugger_dump_stack_trace ()

    gboolean            ianjuta_debugger_dump_stack_trace   (IAnjutaDebugger *obj,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);

Return a stack trace valid for a bug reports. This function is optional.

`obj` : | Self
`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.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_enable_log ()

    void                ianjuta_debugger_enable_log         (IAnjutaDebugger *obj,
                                                             IAnjutaMessageView *log,
                                                             GError **err);

Log all debuggers commands, mainly useful for debugging.

`obj` : | Self
`log` : | MessageView used by log
`err` : | Error propagation and reporting.

### ianjuta_debugger_evaluate ()

    gboolean            ianjuta_debugger_evaluate           (IAnjutaDebugger *obj,
                                                             const gchar *name,
                                                             const gchar *value,
                                                             IAnjutaDebuggerGCharCallback callback,
                                                             gpointer user_data,
                                                             GError **err);

Change the value of a variable in the current program.

`obj` : | Self
`name` : | variable name
`value` : | new variable value
`callback` : | Callback to call when the variable has been modified
`user_data` : | User data that is passed back to the callback
`err` : | Error propagation and reporting.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_exit ()

    gboolean            ianjuta_debugger_exit               (IAnjutaDebugger *obj,
                                                             GError **err);

Exit from the currently loaded program.

`obj` : | Self
`err` : | Error propagation and reporting.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_get_state ()

    IAnjutaDebuggerState  ianjuta_debugger_get_state        (IAnjutaDebugger *obj,
                                                             GError **err);

Get the current state of the debugger

`obj` : | Self
`err` : | Error propagation and reporting.
Returns : | The current debugger state.

### ianjuta_debugger_handle_signal ()

    gboolean            ianjuta_debugger_handle_signal      (IAnjutaDebugger *obj,
                                                             const gchar *name,
                                                             gboolean stop,
                                                             gboolean print,
                                                             gboolean ignore,
                                                             GError **err);

It defines how to handle signal received by the program.

`obj` : | Self
`name` : | signal name
`stop` : | TRUE if we need to stop signal
`print` : | TRUE if we display a message when the signal is emitted
`ignore` : | TRUE if we ignore the signal
`err` : | Error propagation and reporting.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_info_args ()

    gboolean            ianjuta_debugger_info_args          (IAnjutaDebugger *obj,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);

Get some informatin about a current functin arguments.

`obj` : | Self
`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.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_info_frame ()

    gboolean            ianjuta_debugger_info_frame         (IAnjutaDebugger *obj,
                                                             guint frame,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);

Get some information about the one stack frame.

`obj` : | Self
`frame` : | frame number, the top frame has the number 0
`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.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_info_program ()

    gboolean            ianjuta_debugger_info_program       (IAnjutaDebugger *obj,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);

Get some informatin about a current program.

`obj` : | Self
`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.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_info_sharedlib ()

    gboolean            ianjuta_debugger_info_sharedlib     (IAnjutaDebugger *obj,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);

Get information about shared libraries.

`obj` : | Self
`callback` : | Callback to call with list of arguments
`user_data` : | User data that is passed back to the callback
`err` : | Error propagation and reporting.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_info_signal ()

    gboolean            ianjuta_debugger_info_signal        (IAnjutaDebugger *obj,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);

Get some informatin about a signal

`obj` : | Self
`callback` : | Callback to call with list of arguments
`user_data` : | User data that is passed back to the callback
`err` : | Error propagation and reporting.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_info_target ()

    gboolean            ianjuta_debugger_info_target        (IAnjutaDebugger *obj,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);

Get back some information about the target

`obj` : | Self
`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.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_info_thread ()

    gboolean            ianjuta_debugger_info_thread        (IAnjutaDebugger *obj,
                                                             gint thread,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);

Get some information about current threads.

`obj` : | Self
`thread` : | thread number
`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.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_info_udot ()

    gboolean            ianjuta_debugger_info_udot          (IAnjutaDebugger *obj,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);

Get some informatin about OS structures.

`obj` : | Self
`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.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_info_variables ()

    gboolean            ianjuta_debugger_info_variables     (IAnjutaDebugger *obj,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);

Get some informatin about variables.

`obj` : | Self
`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.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_inspect ()

    gboolean            ianjuta_debugger_inspect            (IAnjutaDebugger *obj,
                                                             const gchar *name,
                                                             IAnjutaDebuggerGCharCallback callback,
                                                             gpointer user_data,
                                                             GError **err);

Get back the value of the named variable.

`obj` : | Self
`name` : | variable name
`callback` : | Callback to call with variable value
`user_data` : | User data that is passed back to the callback
`err` : | Error propagation and reporting.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_interrupt ()

    gboolean            ianjuta_debugger_interrupt          (IAnjutaDebugger *obj,
                                                             GError **err);

Interrupt the program currently running.

`obj` : | Self
`err` : | Error propagation and reporting.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_list_argument ()

    gboolean            ianjuta_debugger_list_argument      (IAnjutaDebugger *obj,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);

Get the list of arguments

`obj` : | Self
`callback` : | Callback to call with list of arguments
`user_data` : | User data that is passed back to the callback
`err` : | Error propagation and reporting.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_list_frame ()

    gboolean            ianjuta_debugger_list_frame         (IAnjutaDebugger *obj,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);

Get the list of frames.

`obj` : | Self
`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.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_list_local ()

    gboolean            ianjuta_debugger_list_local         (IAnjutaDebugger *obj,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);

Get the list of local variables

`obj` : | Self
`callback` : | Callback to call with list of local variable
`user_data` : | User data that is passed back to the callback
`err` : | Error propagation and reporting.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_list_thread ()

    gboolean            ianjuta_debugger_list_thread        (IAnjutaDebugger *obj,
                                                             IAnjutaDebuggerGListCallback callback,
                                                             gpointer user_data,
                                                             GError **err);

Get the list of threads.

`obj` : | Self
`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.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_load ()

    gboolean            ianjuta_debugger_load               (IAnjutaDebugger *obj,
                                                             const gchar *file,
                                                             const gchar *mime_type,
                                                             const GList *source_search_directories,
                                                             GError **err);

Load a program in the debugger.

`obj` : | Self
`file` : | filename
`mime_type` : | mime type of the file
`source_search_directories` : | List of directories to search for source files. [element-type utf8]
`err` : | Error propagation and reporting.
Returns : | TRUE if sucessful, other FALSE.

### ianjuta_debugger_print ()

    gboolean            ianjuta_debugger_print              (IAnjutaDebugger *obj,
                                                             const gchar *variable,
                                                             IAnjutaDebuggerGCharCallback callback,
                                                             gpointer user_data,
                                                             GError **err);

Display value of a variable, like inspect.

`obj` : | Self
`variable` : |
`callback` : | Callback to call with variable value
`user_data` : | User data that is passed back to the callback
`err` : | Error propagation and reporting.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_quit ()

    gboolean            ianjuta_debugger_quit               (IAnjutaDebugger *obj,
                                                             GError **err);

Quit the debugger, can wait until the debugger is ready.

`obj` : | Self
`err` : | Error propagation and reporting.
Returns : | TRUE if sucessful, other FALSE.

### ianjuta_debugger_run ()

    gboolean            ianjuta_debugger_run                (IAnjutaDebugger *obj,
                                                             GError **err);

Run the program currently loaded.

`obj` : | Self
`err` : | Error propagation and reporting.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_run_from ()

    gboolean            ianjuta_debugger_run_from           (IAnjutaDebugger *obj,
                                                             const gchar *file,
                                                             gint line,
                                                             GError **err);

Execute the program from a new position. This function is optional.

`obj` : | Self
`file` : | target file name
`line` : | target line in file
`err` : | Error propagation and reporting.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_run_to ()

    gboolean            ianjuta_debugger_run_to             (IAnjutaDebugger *obj,
                                                             const gchar *file,
                                                             gint line,
                                                             GError **err);

Execute the currently loaded program until it reachs the target line.

`obj` : | Self
`file` : | target file name
`line` : | target line in file
`err` : | Error propagation and reporting.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_send_command ()

    gboolean            ianjuta_debugger_send_command       (IAnjutaDebugger *obj,
                                                             const gchar *command,
                                                             GError **err);

Send a command directly to the debugger. Warning, changing the debugger states, by sending a run command by example, will probably gives some troubles in the debug manager.

`obj` : | Self
`command` : | command
`err` : | Error propagation and reporting.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_set_environment ()

    gboolean            ianjuta_debugger_set_environment    (IAnjutaDebugger *obj,
                                                             gchar **env,
                                                             GError **err);

Set environment variable

`obj` : | Self
`env` : | List environment variable
`err` : | Error propagation and reporting
Returns : | TRUE if sucessfull, other FALSE.

### ianjuta_debugger_set_frame ()

    gboolean            ianjuta_debugger_set_frame          (IAnjutaDebugger *obj,
                                                             guint frame,
                                                             GError **err);

Set the current frame.

`obj` : | Self
`frame` : | frame number
`err` : | Error propagation and reporting.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_set_thread ()

    gboolean            ianjuta_debugger_set_thread         (IAnjutaDebugger *obj,
                                                             gint thread,
                                                             GError **err);

Set the current thread.

`obj` : | Self
`thread` : | thread number
`err` : | Error propagation and reporting.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_set_working_directory ()

    gboolean            ianjuta_debugger_set_working_directory
                                                            (IAnjutaDebugger *obj,
                                                             const gchar *dir,
                                                             GError **err);

Set program working directory.

`obj` : | Self
`dir` : | working program directory
`err` : | Error propagation and reporting.
Returns : | TRUE if sucessful, other FALSE.

### ianjuta_debugger_start ()

    gboolean            ianjuta_debugger_start              (IAnjutaDebugger *obj,
                                                             const gchar *args,
                                                             gboolean terminal,
                                                             gboolean stop,
                                                             GError **err);

Start a loaded program under debugger control.

`obj` : | Self
`args` : | command line argument of the program
`terminal` : | TRUE if the program need a terminal
`stop` : | TRUE if program is stopped at the beginning
`err` : | Error propagation and reporting.
Returns : | TRUE if sucessful, other FALSE.

### ianjuta_debugger_step_in ()

    gboolean            ianjuta_debugger_step_in            (IAnjutaDebugger *obj,
                                                             GError **err);

Execute a single C instruction of the program currently loaded.

`obj` : | Self
`err` : | Error propagation and reporting.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_step_out ()

    gboolean            ianjuta_debugger_step_out           (IAnjutaDebugger *obj,
                                                             GError **err);

Execute the currently loaded program until it goes out of the current procedure.

`obj` : | Self
`err` : | Error propagation and reporting.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_step_over ()

    gboolean            ianjuta_debugger_step_over          (IAnjutaDebugger *obj,
                                                             GError **err);

Execute one C instruction, without entering in procedure, of the program currently loaded.

`obj` : | Self
`err` : | Error propagation and reporting.
Returns : | TRUE if sucessful, otherwise FALSE.

### ianjuta_debugger_unload ()

    gboolean            ianjuta_debugger_unload             (IAnjutaDebugger *obj,
                                                             GError **err);

Unload a program.

`obj` : | Self
`err` : | Error propagation and reporting.
Returns : | TRUE if sucessfull, otherwise FALSE.

## Signal Details

### The `"debugger-ready"` signal

    void                user_function                      (IAnjutaDebugger     *ianjutadebugger,
                                                            IAnjutaDebuggerState arg1,
                                                            gpointer             user_data)            : Run Last

`ianjutadebugger` : | the object which received the signal.
`arg1` : |
`user_data` : | user data set when the signal handler was connected.

### The `"debugger-started"` signal

    void                user_function                      (IAnjutaDebugger *ianjutadebugger,
                                                            gpointer         user_data)            : Run Last

`ianjutadebugger` : | the object which received the signal.
`user_data` : | user data set when the signal handler was connected.

### The `"debugger-stopped"` signal

    void                user_function                      (IAnjutaDebugger *ianjutadebugger,
                                                            GError          *arg1,
                                                            gpointer         user_data)            : Run Last

`ianjutadebugger` : | the object which received the signal.
`arg1` : |
`user_data` : | user data set when the signal handler was connected.

### The `"frame-changed"` signal

    void                user_function                      (IAnjutaDebugger *ianjutadebugger,
                                                            guint            arg1,
                                                            gint             arg2,
                                                            gpointer         user_data)            : Run Last

`ianjutadebugger` : | the object which received the signal.
`arg1` : |
`arg2` : |
`user_data` : | user data set when the signal handler was connected.

### The `"program-exited"` signal

    void                user_function                      (IAnjutaDebugger *ianjutadebugger,
                                                            gpointer         user_data)            : Run Last

`ianjutadebugger` : | the object which received the signal.
`user_data` : | user data set when the signal handler was connected.

### The `"program-loaded"` signal

    void                user_function                      (IAnjutaDebugger *ianjutadebugger,
                                                            gpointer         user_data)            : Run Last

`ianjutadebugger` : | the object which received the signal.
`user_data` : | user data set when the signal handler was connected.

### The `"program-moved"` signal

    void                user_function                      (IAnjutaDebugger *ianjutadebugger,
                                                            gint             arg1,
                                                            gint             arg2,
                                                            gulong           arg3,
                                                            gchar           *arg4,
                                                            guint            arg5,
                                                            gpointer         user_data)            : Run Last

`ianjutadebugger` : | the object which received the signal.
`arg1` : |
`arg2` : |
`arg3` : |
`arg4` : |
`arg5` : |
`user_data` : | user data set when the signal handler was connected.

### The `"program-running"` signal

    void                user_function                      (IAnjutaDebugger *ianjutadebugger,
                                                            gpointer         user_data)            : Run Last

`ianjutadebugger` : | the object which received the signal.
`user_data` : | user data set when the signal handler was connected.

### The `"program-stopped"` signal

    void                user_function                      (IAnjutaDebugger *ianjutadebugger,
                                                            gpointer         user_data)            : Run Last

`ianjutadebugger` : | the object which received the signal.
`user_data` : | user data set when the signal handler was connected.

### The `"sharedlib-event"` signal

    void                user_function                      (IAnjutaDebugger *ianjutadebugger,
                                                            gpointer         user_data)            : Run Last

`ianjutadebugger` : | the object which received the signal.
`user_data` : | user data set when the signal handler was connected.

### The `"signal-received"` signal

    void                user_function                      (IAnjutaDebugger *ianjutadebugger,
                                                            gchar           *arg1,
                                                            gchar           *arg2,
                                                            gpointer         user_data)            : Run Last

`ianjutadebugger` : | the object which received the signal.
`arg1` : |
`arg2` : |
`user_data` : | user data set when the signal handler was connected.

## See Also

IAnjutaDebugManager