plugins/debug-manager/command.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3     command.c
   4     Copyright (C) 2007 Sébastien Granjoux
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  19 */
  20
  21 /*
  22  * Wrap each debugger commands in a command object put in a FIFO queue
  23  *---------------------------------------------------------------------------*/
  24
  25 #include <config.h>
  26
  27 #include "command.h"
  28
  29 #include "queue.h"
  30
  31 /*#define DEBUG*/
  32 #include <libanjuta/anjuta-debug.h>
  33 #include <libanjuta/interfaces/ianjuta-debugger-breakpoint.h>
  34 #include <libanjuta/interfaces/ianjuta-debugger-register.h>
  35 #include <libanjuta/interfaces/ianjuta-debugger-memory.h>
  36 #include <libanjuta/interfaces/ianjuta-debugger-instruction.h>
  37 #include <libanjuta/interfaces/ianjuta-debugger-variable.h>
  38
  39 #include <gio/gio.h>
  40
  41 #include <stdarg.h>
  42
  43 /* Contants defintion
  44  *---------------------------------------------------------------------------*/
  45
  46 /* Private type
  47  *---------------------------------------------------------------------------*/
  48
  49 typedef enum
  50 {
  51         EMPTY_COMMAND ,
  52         CALLBACK_COMMAND,
  53         LOAD_COMMAND,           /* Debugger started */
  54         ATTACH_COMMAND,
  55         QUIT_COMMAND,           /* Debugger started - Program stopped */
  56         ABORT_COMMAND,
  57         USER_COMMAND,
  58         INSPECT_MEMORY_COMMAND,
  59         DISASSEMBLE_COMMAND,
  60         LIST_REGISTER_COMMAND,
  61         SET_WORKING_DIRECTORY_COMMAND,
  62         SET_ENVIRONMENT_COMMAND,
  63         UNLOAD_COMMAND,         /* Program loaded */
  64         START_COMMAND,
  65         BREAK_LINE_COMMAND,               /* Program loaded - Program stopped */
  66         BREAK_FUNCTION_COMMAND,
  67         BREAK_ADDRESS_COMMAND,  /* 0x10 */
  68         ENABLE_BREAK_COMMAND,
  69         IGNORE_BREAK_COMMAND,
  70         CONDITION_BREAK_COMMAND,
  71         REMOVE_BREAK_COMMAND,
  72         LIST_BREAK_COMMAND,
  73         INFO_SHAREDLIB_COMMAND,
  74         INFO_TARGET_COMMAND,
  75         INFO_PROGRAM_COMMAND,
  76         INFO_UDOT_COMMAND,
  77         STEP_IN_COMMAND,   /* Program stopped */
  78         STEP_OVER_COMMAND,
  79         STEP_OUT_COMMAND,
  80         RUN_COMMAND,
  81         RUN_TO_COMMAND,
  82         STEPI_IN_COMMAND,
  83         STEPI_OVER_COMMAND,                     /* 0x20 */
  84         RUN_TO_ADDRESS_COMMAND,
  85         EXIT_COMMAND,
  86         HANDLE_SIGNAL_COMMAND,
  87         LIST_LOCAL_COMMAND,
  88         LIST_ARG_COMMAND,
  89         LIST_THREAD_COMMAND,
  90         SET_THREAD_COMMAND,
  91         INFO_THREAD_COMMAND,
  92         INFO_SIGNAL_COMMAND,
  93         INFO_FRAME_COMMAND,
  94         INFO_ARGS_COMMAND,
  95         INFO_VARIABLES_COMMAND,
  96         SET_FRAME_COMMAND,
  97         LIST_FRAME_COMMAND,
  98         UPDATE_REGISTER_COMMAND,
  99         WRITE_REGISTER_COMMAND,         /* 0x30 */
 100         EVALUATE_COMMAND,
 101         INSPECT_COMMAND,
 102         PRINT_COMMAND,
 103         CREATE_VARIABLE,
 104         EVALUATE_VARIABLE,
 105         LIST_VARIABLE_CHILDREN,
 106         DELETE_VARIABLE,
 107         ASSIGN_VARIABLE,
 108         UPDATE_VARIABLE,
 109         INTERRUPT_COMMAND /* Program running */
 110 } DmaDebuggerCommandType;
 111
 112 typedef enum
 113 {
 114         DMA_CALLBACK_COMMAND =
 115                 CALLBACK_COMMAND |
 116                 NEED_DEBUGGER_STOPPED | NEED_DEBUGGER_STARTED | NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED | NEED_PROGRAM_RUNNING,
 117         DMA_LOAD_COMMAND =
 118                 LOAD_COMMAND | LOAD_PROGRAM |
 119                 NEED_DEBUGGER_STOPPED | NEED_DEBUGGER_STARTED,
 120         DMA_ATTACH_COMMAND =
 121                 ATTACH_COMMAND | RUN_PROGRAM |
 122                 NEED_DEBUGGER_STOPPED | NEED_DEBUGGER_STARTED,
 123         DMA_QUIT_COMMAND =
 124                 QUIT_COMMAND | CANCEL_ALL_COMMAND | STOP_DEBUGGER |
 125             HIGH_PRIORITY | NEED_DEBUGGER_STARTED | NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
 126         DMA_ABORT_COMMAND =
 127                 ABORT_COMMAND | CANCEL_ALL_COMMAND | STOP_DEBUGGER |
 128             ASYNCHRONOUS | NEED_DEBUGGER_STARTED | NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED | NEED_PROGRAM_RUNNING,
 129         DMA_USER_COMMAND =
 130                 USER_COMMAND |
 131             NEED_DEBUGGER_STARTED | NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED  | NEED_PROGRAM_RUNNING,
 132         DMA_INSPECT_MEMORY_COMMAND =
 133                 INSPECT_MEMORY_COMMAND |
 134                 NEED_DEBUGGER_STARTED | NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED | NEED_PROGRAM_RUNNING,
 135         DMA_DISASSEMBLE_COMMAND =
 136                 DISASSEMBLE_COMMAND |
 137                 NEED_DEBUGGER_STARTED | NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED | NEED_PROGRAM_RUNNING,
 138         DMA_LIST_REGISTER_COMMAND =
 139                 LIST_REGISTER_COMMAND |
 140                 NEED_DEBUGGER_STARTED | NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED | NEED_PROGRAM_RUNNING,
 141         DMA_SET_WORKING_DIRECTORY_COMMAND =
 142                 SET_WORKING_DIRECTORY_COMMAND |
 143                 NEED_DEBUGGER_STARTED | NEED_PROGRAM_LOADED,
 144         DMA_SET_ENVIRONMENT_COMMAND =
 145                 SET_ENVIRONMENT_COMMAND |
 146                 NEED_DEBUGGER_STARTED | NEED_PROGRAM_LOADED,
 147         DMA_UNLOAD_COMMAND =
 148                 UNLOAD_COMMAND | START_DEBUGGER |
 149                 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
 150         DMA_START_COMMAND =
 151                 START_COMMAND | RUN_PROGRAM |
 152                 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
 153         DMA_BREAK_LINE_COMMAND =
 154                 BREAK_LINE_COMMAND |
 155                 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
 156         DMA_BREAK_FUNCTION_COMMAND =
 157                 BREAK_FUNCTION_COMMAND |
 158                 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
 159         DMA_BREAK_ADDRESS_COMMAND =
 160                 BREAK_ADDRESS_COMMAND |
 161                 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
 162         DMA_ENABLE_BREAK_COMMAND =
 163                 ENABLE_BREAK_COMMAND |
 164                 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
 165         DMA_IGNORE_BREAK_COMMAND =
 166                 IGNORE_BREAK_COMMAND |
 167                 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
 168         DMA_CONDITION_BREAK_COMMAND =
 169                 CONDITION_BREAK_COMMAND |
 170                 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
 171         DMA_REMOVE_BREAK_COMMAND =
 172                 REMOVE_BREAK_COMMAND |
 173                 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED | NEED_PROGRAM_RUNNING,
 174         DMA_LIST_BREAK_COMMAND =
 175                 LIST_BREAK_COMMAND |
 176                 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED | NEED_PROGRAM_RUNNING,
 177         DMA_INFO_SHAREDLIB_COMMAND =
 178                 INFO_SHAREDLIB_COMMAND |
 179                 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
 180         DMA_INFO_TARGET_COMMAND =
 181                 INFO_TARGET_COMMAND |
 182                 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
 183         DMA_INFO_PROGRAM_COMMAND =
 184                 INFO_PROGRAM_COMMAND |
 185                 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
 186         DMA_INFO_UDOT_COMMAND =
 187                 INFO_UDOT_COMMAND |
 188                 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
 189         DMA_STEP_IN_COMMAND =
 190                 STEP_IN_COMMAND | RUN_PROGRAM |
 191                 NEED_PROGRAM_STOPPED,
 192         DMA_STEP_OVER_COMMAND =
 193                 STEP_OVER_COMMAND | RUN_PROGRAM |
 194                 NEED_PROGRAM_STOPPED,
 195         DMA_STEP_OUT_COMMAND =
 196                 STEP_OUT_COMMAND | RUN_PROGRAM |
 197                 NEED_PROGRAM_STOPPED,
 198         DMA_RUN_COMMAND =
 199                 RUN_COMMAND | RUN_PROGRAM |
 200                 NEED_PROGRAM_STOPPED,
 201         DMA_RUN_TO_COMMAND =
 202                 RUN_TO_COMMAND | RUN_PROGRAM |
 203                 NEED_PROGRAM_STOPPED,
 204         DMA_STEPI_IN_COMMAND =
 205                 STEPI_IN_COMMAND | RUN_PROGRAM |
 206                 NEED_PROGRAM_STOPPED,
 207         DMA_STEPI_OVER_COMMAND =
 208                 STEPI_OVER_COMMAND | RUN_PROGRAM |
 209                 NEED_PROGRAM_STOPPED,
 210         DMA_RUN_TO_ADDRESS_COMMAND =
 211                 RUN_TO_ADDRESS_COMMAND | RUN_PROGRAM |
 212                 NEED_PROGRAM_STOPPED,
 213         DMA_EXIT_COMMAND =
 214                 EXIT_COMMAND | LOAD_PROGRAM |
 215                 NEED_PROGRAM_STOPPED,
 216         DMA_HANDLE_SIGNAL_COMMAND =
 217                 HANDLE_SIGNAL_COMMAND |
 218                 NEED_PROGRAM_STOPPED,
 219         DMA_LIST_LOCAL_COMMAND =
 220                 LIST_LOCAL_COMMAND |
 221                 NEED_PROGRAM_STOPPED | NEED_PROGRAM_RUNNING,
 222         DMA_LIST_ARG_COMMAND =
 223                 LIST_ARG_COMMAND |
 224                 NEED_PROGRAM_STOPPED | NEED_PROGRAM_RUNNING,
 225         DMA_LIST_THREAD_COMMAND =
 226                 LIST_THREAD_COMMAND |
 227                 NEED_PROGRAM_STOPPED | NEED_PROGRAM_RUNNING,
 228         DMA_SET_THREAD_COMMAND =
 229                 SET_THREAD_COMMAND |
 230                 NEED_PROGRAM_STOPPED,
 231         DMA_INFO_THREAD_COMMAND =
 232                 INFO_THREAD_COMMAND |
 233                 NEED_PROGRAM_STOPPED,
 234         DMA_INFO_SIGNAL_COMMAND =
 235                 INFO_SIGNAL_COMMAND |
 236                 NEED_PROGRAM_STOPPED,
 237         DMA_INFO_FRAME_COMMAND =
 238                 INFO_FRAME_COMMAND |
 239                 NEED_PROGRAM_STOPPED,
 240         DMA_INFO_ARGS_COMMAND =
 241                 INFO_ARGS_COMMAND |
 242                 NEED_PROGRAM_STOPPED,
 243         DMA_INFO_VARIABLES_COMMAND =
 244                 INFO_VARIABLES_COMMAND |
 245                 NEED_PROGRAM_STOPPED,
 246         DMA_SET_FRAME_COMMAND =
 247                 SET_FRAME_COMMAND |
 248                 NEED_PROGRAM_STOPPED,
 249         DMA_LIST_FRAME_COMMAND =
 250                 LIST_FRAME_COMMAND |
 251                 NEED_PROGRAM_STOPPED | NEED_PROGRAM_RUNNING,
 252         DMA_UPDATE_REGISTER_COMMAND =
 253                 UPDATE_REGISTER_COMMAND |
 254                 NEED_PROGRAM_STOPPED | NEED_PROGRAM_RUNNING,
 255         DMA_WRITE_REGISTER_COMMAND =
 256                 WRITE_REGISTER_COMMAND |
 257                 NEED_PROGRAM_STOPPED,
 258         DMA_EVALUATE_COMMAND =
 259                 EVALUATE_COMMAND |
 260                 NEED_PROGRAM_STOPPED,
 261         DMA_INSPECT_COMMAND =
 262                 INSPECT_COMMAND |
 263                 NEED_PROGRAM_STOPPED,
 264         DMA_PRINT_COMMAND =
 265                 PRINT_COMMAND |
 266                 NEED_PROGRAM_STOPPED,
 267         DMA_CREATE_VARIABLE_COMMAND =
 268            CREATE_VARIABLE |
 269                 NEED_PROGRAM_STOPPED | NEED_PROGRAM_RUNNING,
 270         DMA_EVALUATE_VARIABLE_COMMAND =
 271             EVALUATE_VARIABLE | CANCEL_IF_PROGRAM_RUNNING |
 272             NEED_PROGRAM_STOPPED,
 273         DMA_LIST_VARIABLE_CHILDREN_COMMAND =
 274             LIST_VARIABLE_CHILDREN |
 275                 NEED_PROGRAM_STOPPED,
 276         DMA_DELETE_VARIABLE_COMMAND =
 277                 DELETE_VARIABLE |
 278                 NEED_PROGRAM_STOPPED | NEED_PROGRAM_RUNNING,
 279         DMA_ASSIGN_VARIABLE_COMMAND =
 280                 ASSIGN_VARIABLE |
 281                 NEED_PROGRAM_STOPPED,
 282         DMA_UPDATE_VARIABLE_COMMAND =
 283             UPDATE_VARIABLE | CANCEL_IF_PROGRAM_RUNNING |
 284                 NEED_PROGRAM_STOPPED | NEED_PROGRAM_RUNNING,
 285         DMA_INTERRUPT_COMMAND =
 286                 INTERRUPT_COMMAND | STOP_PROGRAM |
 287                 ASYNCHRONOUS | NEED_PROGRAM_RUNNING,
 288 } DmaDebuggerCommand;
 289
 290 struct _DmaQueueCommand
 291 {
 292         DmaDebuggerCommandType type;
 293         IAnjutaDebuggerCallback callback;
 294         gpointer user_data;
 295         union {
 296                 struct {
 297                         gchar *file;
 298                         gchar *type;
 299                         GList *dirs;
 300                 } load;
 301                 struct {
 302                         gchar *args;
 303                         gboolean terminal;
 304                         gboolean stop;
 305                 } start;
 306                 struct {
 307                         pid_t pid;
 308                         GList *dirs;
 309                 } attach;
 310                 struct {
 311                         guint *id;
 312                         gchar *file;
 313                         guint line;
 314                         gulong address;
 315                         gchar *function;
 316                 } pos;
 317                 struct {
 318                         guint id;
 319                         guint ignore;
 320                         gchar *condition;
 321                         gboolean enable;
 322                 } brk;
 323                 struct {
 324                         guint id;
 325                         gchar *name;
 326                         gchar *value;
 327                 } watch;
 328                 struct {
 329                         gchar *cmd;
 330                 } user;
 331                 struct {
 332                         gchar *var;
 333                 } print;
 334                 struct {
 335                         guint id;
 336                 } info;
 337                 struct {
 338                         gchar *name;
 339                         gboolean stop;
 340                         gboolean print;
 341                         gboolean ignore;
 342                 } signal;
 343                 struct {
 344                         guint frame;
 345                 } frame;
 346                 struct {
 347                         gulong address;
 348                         guint length;
 349                 } mem;
 350                 struct {
 351                         gchar *name;
 352                         gchar *value;
 353                 } var;
 354                 gchar **env;
 355                 gchar *dir;
 356         } data;
 357         struct _DmaQueueCommand *next;
 358 };
 359
 360 /* Private function
 361  *---------------------------------------------------------------------------*/
 362
 363 static DmaQueueCommand*
 364 dma_command_new (DmaDebuggerCommand cmd_type,...)
 365 {
 366         DmaQueueCommand* cmd;
 367         DmaDebuggerCommandType type = cmd_type & COMMAND_MASK;
 368         IAnjutaDebuggerRegisterData* reg;
 369         va_list args;
 370         GList *list;
 371
 372         cmd = g_new0 (DmaQueueCommand, 1);
 373         cmd->type = cmd_type;
 374
 375         va_start (args, cmd_type);
 376         switch (type)
 377         {
 378         case EMPTY_COMMAND:
 379                 break;
 380         case CALLBACK_COMMAND:
 381                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 382                 cmd->user_data = va_arg (args, gpointer);
 383                 break;
 384         case LOAD_COMMAND:
 385                 cmd->data.load.file = g_strdup (va_arg (args, gchar *));
 386                 cmd->data.load.type = g_strdup (va_arg (args, gchar *));
 387                 cmd->data.load.dirs = NULL;
 388                 for (list = va_arg (args, GList *); list != NULL; list = g_list_next (list))
 389                 {
 390                         cmd->data.load.dirs = g_list_prepend (cmd->data.load.dirs, g_strdup (list->data));
 391                 }
 392                 cmd->data.load.dirs = g_list_reverse (cmd->data.load.dirs);
 393                 break;
 394         case ATTACH_COMMAND:
 395                 cmd->data.attach.pid = va_arg (args,pid_t);
 396                 cmd->data.load.dirs = NULL;
 397                 for (list = va_arg (args, GList *); list != NULL; list = g_list_next (list))
 398                 {
 399                         cmd->data.load.dirs = g_list_prepend (cmd->data.load.dirs, g_strdup (list->data));
 400                 }
 401                 cmd->data.load.dirs = g_list_reverse (cmd->data.load.dirs);
 402                 break;
 403         case UNLOAD_COMMAND:
 404                 break;
 405         case QUIT_COMMAND:
 406                 break;
 407         case ABORT_COMMAND:
 408                 break;
 409         case SET_WORKING_DIRECTORY_COMMAND:
 410                 cmd->data.dir = g_strdup (va_arg (args, gchar *));
 411                 break;
 412         case SET_ENVIRONMENT_COMMAND:
 413                 cmd->data.env = g_strdupv (va_arg (args, gchar **));
 414                 break;
 415         case START_COMMAND:
 416                 cmd->data.start.args = g_strdup (va_arg (args, gchar *));
 417                 cmd->data.start.terminal = va_arg (args, gboolean);
 418                 cmd->data.start.stop = va_arg (args, gboolean);
 419             break;
 420         case RUN_COMMAND:
 421                 break;
 422         case RUN_TO_COMMAND:
 423                 cmd->data.pos.file = g_strdup (va_arg (args, gchar *));
 424                 cmd->data.pos.line = va_arg (args, guint);
 425                 break;
 426         case STEP_IN_COMMAND:
 427                 break;
 428         case STEP_OVER_COMMAND:
 429                 break;
 430         case STEP_OUT_COMMAND:
 431                 break;
 432         case RUN_TO_ADDRESS_COMMAND:
 433                 cmd->data.pos.address = va_arg (args, guint);
 434                 break;
 435         case STEPI_IN_COMMAND:
 436                 break;
 437         case STEPI_OVER_COMMAND:
 438                 break;
 439         case EXIT_COMMAND:
 440                 break;
 441         case INTERRUPT_COMMAND:
 442                 break;
 443         case ENABLE_BREAK_COMMAND:
 444                 cmd->data.brk.id = va_arg (args, gint);
 445                 cmd->data.brk.enable = va_arg (args, gboolean);
 446                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 447                 cmd->user_data = va_arg (args, gpointer);
 448                 break;
 449         case IGNORE_BREAK_COMMAND:
 450                 cmd->data.brk.id = va_arg (args, gint);
 451                 cmd->data.brk.ignore = va_arg (args, guint);
 452                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 453                 cmd->user_data = va_arg (args, gpointer);
 454                 break;
 455         case REMOVE_BREAK_COMMAND:
 456                 cmd->data.brk.id = va_arg (args, gint);
 457                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 458                 cmd->user_data = va_arg (args, gpointer);
 459                 break;
 460         case BREAK_LINE_COMMAND:
 461                 cmd->data.pos.id = va_arg (args, guint *);
 462                 cmd->data.pos.file = g_strdup (va_arg (args, gchar *));
 463                 cmd->data.pos.line = va_arg (args, guint);
 464                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 465                 cmd->user_data = va_arg (args, gpointer);
 466                 break;
 467         case BREAK_FUNCTION_COMMAND:
 468                 cmd->data.pos.id = va_arg (args, guint *);
 469                 cmd->data.pos.file = g_strdup (va_arg (args, gchar *));
 470                 cmd->data.pos.function = g_strdup (va_arg (args, gchar *));
 471                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 472                 cmd->user_data = va_arg (args, gpointer);
 473                 break;
 474         case BREAK_ADDRESS_COMMAND:
 475                 cmd->data.pos.id = va_arg (args, guint *);
 476                 cmd->data.pos.address = va_arg (args, gulong);
 477                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 478                 cmd->user_data = va_arg (args, gpointer);
 479                 break;
 480         case CONDITION_BREAK_COMMAND:
 481                 cmd->data.brk.id = va_arg (args, gint);
 482                 cmd->data.brk.condition = g_strdup (va_arg (args, gchar *));
 483                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 484                 cmd->user_data = va_arg (args, gpointer);
 485                 break;
 486         case LIST_BREAK_COMMAND:
 487                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 488                 cmd->user_data = va_arg (args, gpointer);
 489                 break;
 490         case INSPECT_COMMAND:
 491                 cmd->data.watch.name = g_strdup (va_arg (args, gchar *));
 492                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 493                 cmd->user_data = va_arg (args, gpointer);
 494             break;
 495         case EVALUATE_COMMAND:
 496                 cmd->data.watch.name = g_strdup (va_arg (args, gchar *));
 497                 cmd->data.watch.value = g_strdup (va_arg (args, gchar *));
 498                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 499                 cmd->user_data = va_arg (args, gpointer);
 500             break;
 501         case LIST_LOCAL_COMMAND:
 502                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 503                 cmd->user_data = va_arg (args, gpointer);
 504                 break;
 505         case LIST_ARG_COMMAND:
 506                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 507                 cmd->user_data = va_arg (args, gpointer);
 508                 break;
 509         case LIST_THREAD_COMMAND:
 510                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 511                 cmd->user_data = va_arg (args, gpointer);
 512                 break;
 513         case SET_THREAD_COMMAND:
 514                 cmd->data.frame.frame = va_arg (args, guint);
 515                 break;
 516         case INFO_THREAD_COMMAND:
 517                 cmd->data.info.id = va_arg (args, guint);
 518                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 519                 cmd->user_data = va_arg (args, gpointer);
 520                 break;
 521         case INFO_SIGNAL_COMMAND:
 522                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 523                 cmd->user_data = va_arg (args, gpointer);
 524                 break;
 525         case INFO_SHAREDLIB_COMMAND:
 526                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 527                 cmd->user_data = va_arg (args, gpointer);
 528                 break;
 529         case INFO_FRAME_COMMAND:
 530                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 531                 cmd->user_data = va_arg (args, gpointer);
 532                 break;
 533         case INFO_ARGS_COMMAND:
 534                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 535                 cmd->user_data = va_arg (args, gpointer);
 536                 break;
 537         case INFO_TARGET_COMMAND:
 538                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 539                 cmd->user_data = va_arg (args, gpointer);
 540                 break;
 541         case INFO_PROGRAM_COMMAND:
 542                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 543                 cmd->user_data = va_arg (args, gpointer);
 544                 break;
 545         case INFO_UDOT_COMMAND:
 546                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 547                 cmd->user_data = va_arg (args, gpointer);
 548                 break;
 549         case INFO_VARIABLES_COMMAND:
 550                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 551                 cmd->user_data = va_arg (args, gpointer);
 552                 break;
 553         case SET_FRAME_COMMAND:
 554                 cmd->data.frame.frame = va_arg (args, guint);
 555                 break;
 556         case LIST_FRAME_COMMAND:
 557                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 558                 cmd->user_data = va_arg (args, gpointer);
 559                 break;
 560         case LIST_REGISTER_COMMAND:
 561                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 562                 cmd->user_data = va_arg (args, gpointer);
 563                 break;
 564         case UPDATE_REGISTER_COMMAND:
 565                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 566                 cmd->user_data = va_arg (args, gpointer);
 567                 break;
 568         case WRITE_REGISTER_COMMAND:
 569                 reg = va_arg (args, IAnjutaDebuggerRegisterData *);
 570                 cmd->data.watch.id = reg->num;
 571             cmd->data.watch.name = g_strdup (reg->name);
 572             cmd->data.watch.value = g_strdup (reg->value);
 573                 break;
 574         case INSPECT_MEMORY_COMMAND:
 575                 cmd->data.mem.address = va_arg (args, gulong);
 576             cmd->data.mem.length = va_arg (args, guint);
 577                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 578                 cmd->user_data = va_arg (args, gpointer);
 579                 break;
 580         case DISASSEMBLE_COMMAND:
 581                 cmd->data.mem.address = va_arg (args, gulong);
 582             cmd->data.mem.length = va_arg (args, guint);
 583                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 584                 cmd->user_data = va_arg (args, gpointer);
 585                 break;
 586         case USER_COMMAND:
 587                 cmd->data.user.cmd = g_strdup (va_arg (args, gchar *));
 588                 break;
 589         case PRINT_COMMAND:
 590                 cmd->data.print.var = g_strdup (va_arg (args, gchar *));
 591                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 592                 cmd->user_data = va_arg (args, gpointer);
 593                 break;
 594         case HANDLE_SIGNAL_COMMAND:
 595                 cmd->data.signal.name = g_strdup (va_arg (args, gchar *));
 596                 cmd->data.signal.stop = va_arg (args, gboolean);
 597                 cmd->data.signal.print = va_arg (args, gboolean);
 598                 cmd->data.signal.ignore = va_arg (args, gboolean);
 599                 break;
 600         case DELETE_VARIABLE:
 601                 cmd->data.var.name = g_strdup (va_arg (args, gchar *));
 602                 break;
 603         case ASSIGN_VARIABLE:
 604                 cmd->data.var.name = g_strdup (va_arg (args, gchar *));
 605                 cmd->data.var.value = g_strdup (va_arg (args, gchar *));
 606                 break;
 607         case EVALUATE_VARIABLE:
 608                 cmd->data.var.name = g_strdup (va_arg (args, gchar *));
 609                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 610                 cmd->user_data = va_arg (args, gpointer);
 611                 break;
 612         case LIST_VARIABLE_CHILDREN:
 613                 cmd->data.var.name = g_strdup (va_arg (args, gchar *));
 614                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 615                 cmd->user_data = va_arg (args, gpointer);
 616                 break;
 617         case CREATE_VARIABLE:
 618                 cmd->data.var.name = g_strdup (va_arg (args, gchar *));
 619                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 620                 cmd->user_data = va_arg (args, gpointer);
 621                 break;
 622         case UPDATE_VARIABLE:
 623                 cmd->callback = va_arg (args, IAnjutaDebuggerCallback);
 624                 cmd->user_data = va_arg (args, gpointer);
 625                 break;
 626         }
 627
 628         return cmd;
 629 }
 630
 631 /* Public function
 632  *---------------------------------------------------------------------------*/
 633
 634 gboolean
 635 dma_queue_load (DmaDebuggerQueue *self, const gchar *file, const gchar* mime_type, const GList *search_dirs)
 636 {
 637         if (!dma_debugger_queue_start (self, mime_type)) return FALSE;
 638
 639         return dma_debugger_queue_append (self, dma_command_new (DMA_LOAD_COMMAND, file, mime_type, search_dirs));
 640 }
 641
 642 gboolean
 643 dma_queue_attach (DmaDebuggerQueue *self, pid_t pid, const GList *search_dirs)
 644 {
 645         if (!dma_debugger_queue_start (self, NULL)) return FALSE;
 646
 647         return dma_debugger_queue_append (self, dma_command_new (DMA_ATTACH_COMMAND, pid, search_dirs));
 648 }
 649
 650 gboolean
 651 dma_queue_set_working_directory(DmaDebuggerQueue *self, const gchar *directory)
 652 {
 653         return dma_debugger_queue_append (self, dma_command_new (DMA_SET_WORKING_DIRECTORY_COMMAND, directory));
 654 }
 655
 656 gboolean
 657 dma_queue_set_environment(DmaDebuggerQueue *self, gchar **variables)
 658 {
 659         return dma_debugger_queue_append (self, dma_command_new (DMA_SET_ENVIRONMENT_COMMAND, variables));
 660 }
 661
 662 gboolean
 663 dma_queue_start (DmaDebuggerQueue *self, const gchar *args, gboolean terminal, gboolean stop)
 664 {
 665         return dma_debugger_queue_append (self, dma_command_new (DMA_START_COMMAND, args, terminal, stop));
 666 }
 667
 668 gboolean
 669 dma_queue_unload (DmaDebuggerQueue *self)
 670 {
 671         return dma_debugger_queue_append (self, dma_command_new (DMA_UNLOAD_COMMAND));
 672 }
 673
 674 gboolean
 675 dma_queue_quit (DmaDebuggerQueue *self)
 676 {
 677         return dma_debugger_queue_append (self, dma_command_new (DMA_QUIT_COMMAND));
 678 }
 679
 680 gboolean
 681 dma_queue_abort (DmaDebuggerQueue *self)
 682 {
 683         return dma_debugger_queue_append (self, dma_command_new (DMA_ABORT_COMMAND));
 684 }
 685
 686 gboolean
 687 dma_queue_run (DmaDebuggerQueue *self)
 688 {
 689         return dma_debugger_queue_append (self, dma_command_new (DMA_RUN_COMMAND));
 690 }
 691
 692 gboolean
 693 dma_queue_step_in (DmaDebuggerQueue *self)
 694 {
 695         return dma_debugger_queue_append (self, dma_command_new (DMA_STEP_IN_COMMAND));
 696 }
 697
 698 gboolean
 699 dma_queue_step_over (DmaDebuggerQueue *self)
 700 {
 701         return dma_debugger_queue_append (self, dma_command_new (DMA_STEP_OVER_COMMAND));
 702 }
 703
 704 gboolean
 705 dma_queue_run_to (DmaDebuggerQueue *self, const gchar *file, gint line)
 706 {
 707         return dma_debugger_queue_append (self, dma_command_new (DMA_RUN_TO_COMMAND, file, line));
 708 }
 709
 710 gboolean
 711 dma_queue_step_out (DmaDebuggerQueue *self)
 712 {
 713         return dma_debugger_queue_append (self, dma_command_new (DMA_STEP_OUT_COMMAND));
 714 }
 715
 716 gboolean
 717 dma_queue_stepi_in (DmaDebuggerQueue *self)
 718 {
 719         return dma_debugger_queue_append (self, dma_command_new (DMA_STEPI_IN_COMMAND));
 720 }
 721
 722 gboolean
 723 dma_queue_stepi_over (DmaDebuggerQueue *self)
 724 {
 725         return dma_debugger_queue_append (self, dma_command_new (DMA_STEPI_OVER_COMMAND));
 726 }
 727
 728 gboolean
 729 dma_queue_run_to_address (DmaDebuggerQueue *self, gulong address)
 730 {
 731         return dma_debugger_queue_append (self, dma_command_new (DMA_RUN_TO_ADDRESS_COMMAND, address));
 732 }
 733
 734 gboolean
 735 dma_queue_exit (DmaDebuggerQueue *self)
 736 {
 737         return dma_debugger_queue_append (self, dma_command_new (DMA_EXIT_COMMAND));
 738 }
 739
 740 gboolean
 741 dma_queue_interrupt (DmaDebuggerQueue *self)
 742 {
 743         return dma_debugger_queue_append (self, dma_command_new (DMA_INTERRUPT_COMMAND));
 744 }
 745
 746 gboolean
 747 dma_queue_inspect (DmaDebuggerQueue *self, const gchar *expression, IAnjutaDebuggerCallback callback, gpointer user_data)
 748 {
 749         return dma_debugger_queue_append (self, dma_command_new (DMA_INSPECT_COMMAND, expression, callback, user_data));
 750 }
 751
 752 gboolean
 753 dma_queue_evaluate (DmaDebuggerQueue *self, const gchar *name, const gchar* value, IAnjutaDebuggerCallback callback, gpointer user_data)
 754 {
 755         return dma_debugger_queue_append (self, dma_command_new (DMA_EVALUATE_COMMAND, name, value, callback, user_data));
 756 }
 757
 758 gboolean
 759 dma_queue_send_command (DmaDebuggerQueue *self, const gchar* command)
 760 {
 761         return dma_debugger_queue_append (self, dma_command_new (DMA_USER_COMMAND, command));
 762 }
 763
 764 gboolean
 765 dma_queue_print (DmaDebuggerQueue *self, const gchar* variable, IAnjutaDebuggerCallback callback, gpointer user_data)
 766 {
 767         return dma_debugger_queue_append (self, dma_command_new (DMA_PRINT_COMMAND, variable, callback, user_data));
 768 }
 769
 770 gboolean
 771 dma_queue_list_local (DmaDebuggerQueue *self, IAnjutaDebuggerCallback callback , gpointer user_data)
 772 {
 773         return dma_debugger_queue_append (self, dma_command_new (DMA_LIST_LOCAL_COMMAND, callback, user_data));
 774 }
 775
 776 gboolean
 777 dma_queue_list_argument (DmaDebuggerQueue *self, IAnjutaDebuggerCallback callback , gpointer user_data)
 778 {
 779         return dma_debugger_queue_append (self, dma_command_new (DMA_LIST_ARG_COMMAND, callback, user_data));
 780 }
 781
 782 gboolean
 783 dma_queue_list_thread (DmaDebuggerQueue *self, IAnjutaDebuggerCallback callback , gpointer user_data)
 784 {
 785         return dma_debugger_queue_append (self, dma_command_new (DMA_LIST_THREAD_COMMAND, callback, user_data));
 786 }
 787
 788 gboolean
 789 dma_queue_set_thread (DmaDebuggerQueue *self, gint thread)
 790 {
 791         return dma_debugger_queue_append (self, dma_command_new (DMA_SET_THREAD_COMMAND, thread));
 792 }
 793
 794 gboolean
 795 dma_queue_info_thread (DmaDebuggerQueue *self, gint thread, IAnjutaDebuggerCallback callback , gpointer user_data)
 796 {
 797         return dma_debugger_queue_append (self, dma_command_new (DMA_INFO_THREAD_COMMAND, thread, callback, user_data));
 798 }
 799
 800 gboolean
 801 dma_queue_info_signal (DmaDebuggerQueue *self, IAnjutaDebuggerCallback callback , gpointer user_data)
 802 {
 803         return dma_debugger_queue_append (self, dma_command_new (DMA_INFO_SIGNAL_COMMAND, callback, user_data));
 804 }
 805
 806 gboolean
 807 dma_queue_info_sharedlib (DmaDebuggerQueue *self, IAnjutaDebuggerCallback callback , gpointer user_data)
 808 {
 809         return dma_debugger_queue_append (self, dma_command_new (DMA_INFO_SHAREDLIB_COMMAND, callback, user_data));
 810 }
 811
 812 gboolean
 813 dma_queue_handle_signal (DmaDebuggerQueue *self, const gchar* name, gboolean stop, gboolean print, gboolean ignore)
 814 {
 815         return dma_debugger_queue_append (self, dma_command_new (DMA_HANDLE_SIGNAL_COMMAND, name, stop, print, ignore));
 816 }
 817
 818 gboolean
 819 dma_queue_info_frame (DmaDebuggerQueue *self, guint frame, IAnjutaDebuggerCallback callback , gpointer user_data)
 820 {
 821         return dma_debugger_queue_append (self, dma_command_new (DMA_INFO_FRAME_COMMAND, frame, callback, user_data));
 822 }
 823
 824 gboolean
 825 dma_queue_info_args (DmaDebuggerQueue *self, IAnjutaDebuggerCallback callback , gpointer user_data)
 826 {
 827         return dma_debugger_queue_append (self, dma_command_new (DMA_INFO_ARGS_COMMAND, callback, user_data));
 828 }
 829
 830 gboolean
 831 dma_queue_info_target (DmaDebuggerQueue *self, IAnjutaDebuggerCallback callback , gpointer user_data)
 832 {
 833         return dma_debugger_queue_append (self, dma_command_new (DMA_INFO_TARGET_COMMAND, callback, user_data));
 834 }
 835
 836 gboolean
 837 dma_queue_info_program (DmaDebuggerQueue *self, IAnjutaDebuggerCallback callback , gpointer user_data)
 838 {
 839         return dma_debugger_queue_append (self, dma_command_new (DMA_INFO_PROGRAM_COMMAND, callback, user_data));
 840 }
 841
 842 gboolean
 843 dma_queue_info_udot (DmaDebuggerQueue *self, IAnjutaDebuggerCallback callback , gpointer user_data)
 844 {
 845         return dma_debugger_queue_append (self, dma_command_new (DMA_INFO_UDOT_COMMAND, callback, user_data));
 846 }
 847
 848 gboolean
 849 dma_queue_info_variables (DmaDebuggerQueue *self, IAnjutaDebuggerCallback callback , gpointer user_data)
 850 {
 851         return dma_debugger_queue_append (self, dma_command_new (DMA_INFO_VARIABLES_COMMAND, callback, user_data));
 852 }
 853
 854 gboolean
 855 dma_queue_set_frame (DmaDebuggerQueue *self, guint frame)
 856 {
 857         return dma_debugger_queue_append (self, dma_command_new (DMA_SET_FRAME_COMMAND, frame));
 858 }
 859
 860 gboolean
 861 dma_queue_list_frame (DmaDebuggerQueue *self, IAnjutaDebuggerCallback callback , gpointer user_data)
 862 {
 863         return dma_debugger_queue_append (self, dma_command_new (DMA_LIST_FRAME_COMMAND, callback, user_data));
 864 }
 865
 866 gboolean
 867 dma_queue_callback (DmaDebuggerQueue *self, IAnjutaDebuggerCallback callback , gpointer user_data)
 868 {
 869         return dma_debugger_queue_append (self, dma_command_new (DMA_CALLBACK_COMMAND, callback, user_data));
 870 }
 871
 872 gboolean
 873 dma_queue_add_breakpoint_at_line (DmaDebuggerQueue *self, guint *id, const gchar* file, guint line, IAnjutaDebuggerCallback callback, gpointer user_data)
 874 {
 875         return dma_debugger_queue_append (self, dma_command_new (DMA_BREAK_LINE_COMMAND, id, file, line, callback, user_data));
 876 }
 877
 878 gboolean
 879 dma_queue_add_breakpoint_at_function (DmaDebuggerQueue *self, guint *id, const gchar* file, const gchar* function, IAnjutaDebuggerCallback callback, gpointer user_data)
 880 {
 881         return dma_debugger_queue_append (self, dma_command_new (DMA_BREAK_FUNCTION_COMMAND, id, file, function, callback, user_data));
 882 }
 883
 884 gboolean
 885 dma_queue_add_breakpoint_at_address (DmaDebuggerQueue *self, guint *id, gulong address, IAnjutaDebuggerCallback callback, gpointer user_data)
 886 {
 887         return dma_debugger_queue_append (self, dma_command_new (DMA_BREAK_ADDRESS_COMMAND, id, address, callback, user_data));
 888 }
 889
 890 gboolean
 891 dma_queue_enable_breakpoint (DmaDebuggerQueue *self, guint id, gboolean enable, IAnjutaDebuggerCallback callback, gpointer user_data)
 892 {
 893         return dma_debugger_queue_append (self, dma_command_new (DMA_ENABLE_BREAK_COMMAND, id, enable, callback, user_data));
 894 }
 895
 896 gboolean
 897 dma_queue_ignore_breakpoint (DmaDebuggerQueue *self, guint id, guint ignore, IAnjutaDebuggerCallback callback, gpointer user_data)
 898 {
 899         return dma_debugger_queue_append (self, dma_command_new (DMA_IGNORE_BREAK_COMMAND, id, ignore, callback, user_data));
 900 }
 901
 902 gboolean
 903 dma_queue_condition_breakpoint (DmaDebuggerQueue *self, guint id, const gchar *condition, IAnjutaDebuggerCallback callback, gpointer user_data)
 904 {
 905         return dma_debugger_queue_append (self, dma_command_new (DMA_CONDITION_BREAK_COMMAND, id, condition, callback, user_data));
 906 }
 907
 908 gboolean
 909 dma_queue_remove_breakpoint (DmaDebuggerQueue *self, guint id, IAnjutaDebuggerCallback callback, gpointer user_data)
 910 {
 911         return dma_debugger_queue_append (self, dma_command_new (DMA_REMOVE_BREAK_COMMAND, id, callback, user_data));
 912 }
 913
 914 gboolean
 915 dma_queue_list_breakpoint (DmaDebuggerQueue *self, IAnjutaDebuggerCallback callback, gpointer user_data)
 916 {
 917         return dma_debugger_queue_append (self, dma_command_new (DMA_LIST_BREAK_COMMAND, callback, user_data));
 918 }
 919
 920 gboolean
 921 dma_queue_list_register (DmaDebuggerQueue *self, IAnjutaDebuggerCallback callback , gpointer user_data)
 922 {
 923         return dma_debugger_queue_append (self, dma_command_new (DMA_LIST_REGISTER_COMMAND, callback, user_data));
 924 }
 925
 926 gboolean
 927 dma_queue_update_register (DmaDebuggerQueue *self, IAnjutaDebuggerCallback callback , gpointer user_data)
 928 {
 929         return dma_debugger_queue_append (self, dma_command_new (DMA_UPDATE_REGISTER_COMMAND, callback, user_data));
 930 }
 931
 932 gboolean
 933 dma_queue_write_register (DmaDebuggerQueue *self, IAnjutaDebuggerRegisterData *value)
 934 {
 935         return dma_debugger_queue_append (self, dma_command_new (DMA_WRITE_REGISTER_COMMAND, value));
 936 }
 937
 938 gboolean
 939 dma_queue_inspect_memory (DmaDebuggerQueue *self, gulong address, guint length, IAnjutaDebuggerCallback callback , gpointer user_data)
 940 {
 941         return dma_debugger_queue_append (self, dma_command_new (DMA_INSPECT_MEMORY_COMMAND, address, length, callback, user_data));
 942 }
 943
 944 gboolean
 945 dma_queue_disassemble (DmaDebuggerQueue *self, gulong address, guint length, IAnjutaDebuggerCallback callback , gpointer user_data)
 946 {
 947         return dma_debugger_queue_append (self, dma_command_new (DMA_DISASSEMBLE_COMMAND, address, length, callback, user_data));
 948 }
 949
 950 gboolean
 951 dma_queue_delete_variable (DmaDebuggerQueue *self, const gchar *name)
 952 {
 953         return dma_debugger_queue_append (self, dma_command_new (DMA_DELETE_VARIABLE_COMMAND, name));
 954 }
 955
 956 gboolean
 957 dma_queue_evaluate_variable (DmaDebuggerQueue *self, const gchar *name, IAnjutaDebuggerCallback callback, gpointer user_data)
 958 {
 959         return dma_debugger_queue_append (self, dma_command_new (DMA_EVALUATE_VARIABLE_COMMAND, name, callback, user_data));
 960 }
 961
 962 gboolean
 963 dma_queue_assign_variable (DmaDebuggerQueue *self, const gchar *name, const gchar *value)
 964 {
 965         return dma_debugger_queue_append (self, dma_command_new (DMA_ASSIGN_VARIABLE_COMMAND, name, value));
 966 }
 967
 968 gboolean
 969 dma_queue_list_children (DmaDebuggerQueue *self, const gchar *name, IAnjutaDebuggerCallback callback, gpointer user_data)
 970 {
 971         return dma_debugger_queue_append (self, dma_command_new (DMA_LIST_VARIABLE_CHILDREN_COMMAND, name, callback, user_data));
 972 }
 973
 974 gboolean
 975 dma_queue_create_variable (DmaDebuggerQueue *self, const gchar *name, IAnjutaDebuggerCallback callback, gpointer user_data)
 976 {
 977         return dma_debugger_queue_append (self, dma_command_new (DMA_CREATE_VARIABLE_COMMAND, name, callback, user_data));
 978 }
 979
 980 gboolean
 981 dma_queue_update_variable (DmaDebuggerQueue *self, IAnjutaDebuggerCallback callback, gpointer user_data)
 982 {
 983         return dma_debugger_queue_append (self, dma_command_new (DMA_UPDATE_VARIABLE_COMMAND, callback, user_data));
 984 }
 985
 986 void
 987 dma_command_free (DmaQueueCommand *cmd)
 988 {
 989         DmaDebuggerCommandType type = cmd->type & COMMAND_MASK;
 990
 991         switch (type)
 992         {
 993         case EMPTY_COMMAND:
 994         case CALLBACK_COMMAND:
 995         case UNLOAD_COMMAND:
 996         case QUIT_COMMAND:
 997         case ABORT_COMMAND:
 998         case RUN_COMMAND:
 999         case STEP_IN_COMMAND:
1000         case STEP_OVER_COMMAND:
1001         case STEP_OUT_COMMAND:
1002         case STEPI_IN_COMMAND:
1003         case STEPI_OVER_COMMAND:
1004         case RUN_TO_ADDRESS_COMMAND:
1005         case EXIT_COMMAND:
1006         case INTERRUPT_COMMAND:
1007         case ENABLE_BREAK_COMMAND:
1008         case IGNORE_BREAK_COMMAND:
1009         case REMOVE_BREAK_COMMAND:
1010         case LIST_BREAK_COMMAND:
1011             break;
1012         case LIST_LOCAL_COMMAND:
1013         case LIST_ARG_COMMAND:
1014         case INFO_THREAD_COMMAND:
1015         case LIST_THREAD_COMMAND:
1016         case SET_THREAD_COMMAND:
1017         case INFO_SIGNAL_COMMAND:
1018         case INFO_SHAREDLIB_COMMAND:
1019         case INFO_FRAME_COMMAND:
1020         case INFO_ARGS_COMMAND:
1021         case INFO_TARGET_COMMAND:
1022         case INFO_PROGRAM_COMMAND:
1023         case INFO_UDOT_COMMAND:
1024         case INFO_VARIABLES_COMMAND:
1025         case LIST_REGISTER_COMMAND:
1026         case UPDATE_REGISTER_COMMAND:
1027             break;
1028         case SET_FRAME_COMMAND:
1029         case LIST_FRAME_COMMAND:
1030         case INSPECT_MEMORY_COMMAND:
1031         case DISASSEMBLE_COMMAND:
1032                 break;
1033         case INSPECT_COMMAND:
1034         case EVALUATE_COMMAND:
1035         case WRITE_REGISTER_COMMAND:
1036                 if (cmd->data.watch.name != NULL) g_free (cmd->data.watch.name);
1037                 if (cmd->data.watch.value != NULL) g_free (cmd->data.watch.value);
1038                 break;
1039         case START_COMMAND:
1040                 if (cmd->data.start.args) g_free (cmd->data.start.args);
1041                 break;
1042         case LOAD_COMMAND:
1043                 if (cmd->data.load.file) g_free (cmd->data.load.file);
1044                 if (cmd->data.load.type) g_free (cmd->data.load.type);
1045         g_list_foreach (cmd->data.load.dirs, (GFunc)g_free, NULL);
1046         g_list_free (cmd->data.load.dirs);
1047                 break;
1048         case SET_WORKING_DIRECTORY_COMMAND:
1049                 if (cmd->data.dir) g_free (cmd->data.dir);
1050                 break;
1051         case SET_ENVIRONMENT_COMMAND:
1052                 g_strfreev (cmd->data.env);
1053                 break;
1054         case ATTACH_COMMAND:
1055         g_list_foreach (cmd->data.attach.dirs, (GFunc)g_free, NULL);
1056         g_list_free (cmd->data.attach.dirs);
1057                 break;
1058         case RUN_TO_COMMAND:
1059         case BREAK_LINE_COMMAND:
1060         case BREAK_FUNCTION_COMMAND:
1061         case BREAK_ADDRESS_COMMAND:
1062                 if (cmd->data.pos.file) g_free (cmd->data.pos.file);
1063                 if (cmd->data.pos.function) g_free (cmd->data.pos.function);
1064                 break;
1065         case CONDITION_BREAK_COMMAND:
1066                 if (cmd->data.brk.condition) g_free (cmd->data.brk.condition);
1067                 break;
1068         case USER_COMMAND:
1069                 if (cmd->data.user.cmd) g_free (cmd->data.user.cmd);
1070                 break;
1071         case PRINT_COMMAND:
1072                 if (cmd->data.print.var) g_free (cmd->data.print.var);
1073                 break;
1074         case HANDLE_SIGNAL_COMMAND:
1075                 if (cmd->data.signal.name) g_free (cmd->data.signal.name);
1076                 break;
1077         case DELETE_VARIABLE:
1078         case ASSIGN_VARIABLE:
1079         case CREATE_VARIABLE:
1080         case EVALUATE_VARIABLE:
1081         case LIST_VARIABLE_CHILDREN:
1082         case UPDATE_VARIABLE:
1083                 if (cmd->data.var.name) g_free (cmd->data.var.name);
1084                 break;
1085     }
1086
1087         g_free (cmd);
1088 }
1089
1090
1091 void
1092 dma_command_cancel (DmaQueueCommand *cmd)
1093 {
1094         GError *err = g_error_new_literal (IANJUTA_DEBUGGER_ERROR , IANJUTA_DEBUGGER_CANCEL, "Command cancel");
1095
1096         if (cmd->callback != NULL)
1097         {
1098                 cmd->callback (NULL, cmd->user_data, err);
1099         }
1100
1101         g_error_free (err);
1102
1103         g_warning ("Cancel command %x\n", cmd->type);
1104
1105         dma_command_free (cmd);
1106 }
1107
1108 /* It is possible that the queue contains several add breakpoint command
1109  * for the same one. Just before sending the command to the debugger check
1110  * that the breakpoint is still not set */
1111
1112 static gboolean
1113 dma_command_is_breakpoint_pending (DmaQueueCommand *cmd)
1114 {
1115         GError *err;
1116
1117         if (*cmd->data.pos.id == 0) return TRUE;                /* Breakpoint is not set, can add it */
1118
1119         err     = g_error_new (IANJUTA_DEBUGGER_ERROR , IANJUTA_DEBUGGER_ALREADY_DONE, "Breakpoint is already set with id %d", *cmd->data.pos.id);
1120
1121         if (cmd->callback != NULL)
1122         {
1123                 cmd->callback (NULL, cmd->user_data, err);
1124         }
1125         g_error_free (err);
1126
1127         return FALSE;
1128 }
1129
1130 gboolean
1131 dma_command_run (DmaQueueCommand *cmd, IAnjutaDebugger *debugger,
1132                                  DmaDebuggerQueue *queue, GError **err)
1133 {
1134         IAnjutaDebuggerRegisterData reg;
1135         gboolean ret = FALSE;
1136         DmaDebuggerCommandType type = cmd->type & COMMAND_MASK;
1137         IAnjutaDebuggerCallback callback = cmd->callback == NULL ? NULL : dma_debugger_queue_command_callback;
1138         GFile* file;
1139         switch (type)
1140         {
1141         case EMPTY_COMMAND:
1142                 ret = TRUE;
1143                 break;
1144         case CALLBACK_COMMAND:
1145                 ret = ianjuta_debugger_callback (debugger, callback, queue, err);
1146                 break;
1147         case LOAD_COMMAND:
1148                 ret = ianjuta_debugger_load (debugger, cmd->data.load.file, cmd->data.load.type, cmd->data.load.dirs, err);
1149                 break;
1150         case ATTACH_COMMAND:
1151                 ret = ianjuta_debugger_attach (debugger, cmd->data.attach.pid, cmd->data.load.dirs, err);
1152                 break;
1153         case SET_WORKING_DIRECTORY_COMMAND:
1154                 ret = ianjuta_debugger_set_working_directory (debugger, cmd->data.dir, err);
1155                 break;
1156         case SET_ENVIRONMENT_COMMAND:
1157                 ret = ianjuta_debugger_set_environment (debugger, cmd->data.env, err);
1158                 break;
1159         case UNLOAD_COMMAND:
1160             ret = ianjuta_debugger_unload (debugger, err);
1161             break;
1162         case QUIT_COMMAND:
1163                 ret = ianjuta_debugger_quit (debugger, err);
1164                 break;
1165         case ABORT_COMMAND:
1166                 ret = ianjuta_debugger_abort (debugger, err);
1167                 break;
1168         case START_COMMAND:
1169                 ret = ianjuta_debugger_start (debugger, cmd->data.start.args, cmd->data.start.terminal, cmd->data.start.stop, err);
1170             break;
1171         case RUN_COMMAND:
1172                 ret = ianjuta_debugger_run (debugger, err);
1173                 break;
1174         case RUN_TO_COMMAND:
1175                 file = g_file_new_for_uri (cmd->data.pos.file);
1176                 ret = ianjuta_debugger_run_to (debugger, file, cmd->data.pos.line, err);
1177                 g_object_unref (file);
1178                 break;
1179         case STEP_IN_COMMAND:
1180                 ret = ianjuta_debugger_step_in (debugger, err);
1181                 break;
1182         case STEP_OVER_COMMAND:
1183                 ret = ianjuta_debugger_step_over (debugger, err);
1184                 break;
1185         case STEP_OUT_COMMAND:
1186                 ret = ianjuta_debugger_step_out (debugger, err);
1187                 break;
1188         case RUN_TO_ADDRESS_COMMAND:
1189                 ret = ianjuta_debugger_instruction_run_to_address (IANJUTA_DEBUGGER_INSTRUCTION (debugger), cmd->data.pos.address, err);
1190                 break;
1191         case STEPI_IN_COMMAND:
1192                 ret = ianjuta_debugger_instruction_step_in (IANJUTA_DEBUGGER_INSTRUCTION (debugger), err);
1193                 break;
1194         case STEPI_OVER_COMMAND:
1195                 ret = ianjuta_debugger_instruction_step_over (IANJUTA_DEBUGGER_INSTRUCTION (debugger), err);
1196                 break;
1197         case EXIT_COMMAND:
1198                 ret = ianjuta_debugger_exit (debugger, err);
1199                 break;
1200         case INTERRUPT_COMMAND:
1201                 ret = ianjuta_debugger_interrupt (debugger, err);
1202                 break;
1203         case ENABLE_BREAK_COMMAND:
1204                 ret = ianjuta_debugger_breakpoint_enable (IANJUTA_DEBUGGER_BREAKPOINT (debugger), cmd->data.brk.id, cmd->data.brk.enable, callback, queue, err);
1205                 break;
1206         case IGNORE_BREAK_COMMAND:
1207                 ret = ianjuta_debugger_breakpoint_ignore (IANJUTA_DEBUGGER_BREAKPOINT (debugger), cmd->data.brk.id, cmd->data.brk.ignore, callback, queue, err);
1208                 break;
1209         case REMOVE_BREAK_COMMAND:
1210                 ret = ianjuta_debugger_breakpoint_clear (IANJUTA_DEBUGGER_BREAKPOINT (debugger), cmd->data.brk.id, callback, queue, err);
1211                 break;
1212         case BREAK_LINE_COMMAND:
1213                 if (dma_command_is_breakpoint_pending (cmd))
1214                 {
1215                         ret = ianjuta_debugger_breakpoint_set_at_line (IANJUTA_DEBUGGER_BREAKPOINT (debugger), cmd->data.pos.file, cmd->data.pos.line, callback, queue, err);
1216                 }
1217                 else
1218                 {
1219                         ret = FALSE;
1220                 }
1221                 break;
1222         case BREAK_FUNCTION_COMMAND:
1223                 if (dma_command_is_breakpoint_pending (cmd))
1224                 {
1225                         ret = ianjuta_debugger_breakpoint_set_at_function (IANJUTA_DEBUGGER_BREAKPOINT (debugger), cmd->data.pos.file, cmd->data.pos.function, callback, queue, err);
1226                 }
1227                 else
1228                 {
1229                         ret = FALSE;
1230                 }
1231                 break;
1232         case BREAK_ADDRESS_COMMAND:
1233                 if (dma_command_is_breakpoint_pending (cmd))
1234                 {
1235                         ret = ianjuta_debugger_breakpoint_set_at_address (IANJUTA_DEBUGGER_BREAKPOINT (debugger), cmd->data.pos.address, callback, queue, err);
1236                 }
1237                 else
1238                 {
1239                         ret = FALSE;
1240                 }
1241                 break;
1242         case CONDITION_BREAK_COMMAND:
1243                 ret = ianjuta_debugger_breakpoint_condition (IANJUTA_DEBUGGER_BREAKPOINT (debugger), cmd->data.brk.id, cmd->data.brk.condition, callback, queue, err);
1244                 break;
1245         case LIST_BREAK_COMMAND:
1246                 ret = ianjuta_debugger_breakpoint_list (IANJUTA_DEBUGGER_BREAKPOINT (debugger), callback, queue, err);
1247                 break;
1248         case INSPECT_COMMAND:
1249                 ret = ianjuta_debugger_inspect (debugger, cmd->data.watch.name, callback, queue, err);
1250             break;
1251         case EVALUATE_COMMAND:
1252                 ret = ianjuta_debugger_evaluate (debugger, cmd->data.watch.name, cmd->data.watch.value, callback, queue, err);
1253             break;
1254         case LIST_LOCAL_COMMAND:
1255                 ret = ianjuta_debugger_list_local (debugger, callback, queue, err);
1256                 break;
1257         case LIST_ARG_COMMAND:
1258                 ret = ianjuta_debugger_list_argument (debugger, callback, queue, err);
1259                 break;
1260         case LIST_THREAD_COMMAND:
1261                 ret = ianjuta_debugger_list_thread (debugger, callback, queue, err);
1262                 break;
1263         case SET_THREAD_COMMAND:
1264                 ret = ianjuta_debugger_set_thread (debugger, cmd->data.frame.frame, err);
1265                 break;
1266         case INFO_THREAD_COMMAND:
1267                 ret = ianjuta_debugger_info_thread (debugger, cmd->data.info.id, callback, queue, err);
1268                 break;
1269         case INFO_SIGNAL_COMMAND:
1270                 ret = ianjuta_debugger_info_signal (debugger, callback, queue, err);
1271                 break;
1272         case INFO_SHAREDLIB_COMMAND:
1273                 ret = ianjuta_debugger_info_sharedlib (debugger, callback, queue, err);
1274                 break;
1275         case INFO_FRAME_COMMAND:
1276                 ret = ianjuta_debugger_info_frame (debugger, 0, callback, queue, err);
1277                 break;
1278         case INFO_ARGS_COMMAND:
1279                 ret = ianjuta_debugger_info_args (debugger, callback, queue, err);
1280                 break;
1281         case INFO_TARGET_COMMAND:
1282                 ret = ianjuta_debugger_info_target (debugger, callback, queue, err);
1283                 break;
1284         case INFO_PROGRAM_COMMAND:
1285                 ret = ianjuta_debugger_info_program (debugger, callback, queue, err);
1286                 break;
1287         case INFO_UDOT_COMMAND:
1288                 ret = ianjuta_debugger_info_udot (debugger, callback, queue, err);
1289                 break;
1290         case INFO_VARIABLES_COMMAND:
1291                 ret = ianjuta_debugger_info_variables (debugger, callback, queue, err);
1292                 break;
1293         case SET_FRAME_COMMAND:
1294                 ret = ianjuta_debugger_set_frame (debugger, cmd->data.frame.frame, err);
1295                 break;
1296         case LIST_FRAME_COMMAND:
1297                 ret = ianjuta_debugger_list_frame (debugger, callback, queue, err);
1298                 break;
1299         case LIST_REGISTER_COMMAND:
1300                 ret = ianjuta_debugger_register_list (IANJUTA_DEBUGGER_REGISTER (debugger), callback, queue, err);
1301                 break;
1302         case UPDATE_REGISTER_COMMAND:
1303                 ret = ianjuta_debugger_register_update (IANJUTA_DEBUGGER_REGISTER (debugger), callback, queue, err);
1304                 break;
1305         case WRITE_REGISTER_COMMAND:
1306                 reg.num = cmd->data.watch.id;
1307             reg.name = cmd->data.watch.name;
1308             reg.value = cmd->data.watch.value;
1309                 ret = ianjuta_debugger_register_write (IANJUTA_DEBUGGER_REGISTER (debugger), &reg, err);
1310                 break;
1311         case INSPECT_MEMORY_COMMAND:
1312                 ret = ianjuta_debugger_memory_inspect (IANJUTA_DEBUGGER_MEMORY (debugger), cmd->data.mem.address, cmd->data.mem.length, callback, queue, err);
1313                 break;
1314         case DISASSEMBLE_COMMAND:
1315                 ret = ianjuta_debugger_instruction_disassemble (IANJUTA_DEBUGGER_INSTRUCTION (debugger), cmd->data.mem.address, cmd->data.mem.length, callback, queue, err);
1316                 break;
1317         case USER_COMMAND:
1318                 ret = ianjuta_debugger_send_command (debugger, cmd->data.user.cmd, err);
1319                 break;
1320         case PRINT_COMMAND:
1321                 ret = ianjuta_debugger_print (debugger, cmd->data.print.var, callback, queue, err);
1322                 break;
1323         case HANDLE_SIGNAL_COMMAND:
1324                 ret = ianjuta_debugger_handle_signal (debugger, cmd->data.signal.name, cmd->data.signal.stop, cmd->data.signal.print, cmd->data.signal.ignore, err);
1325                 break;
1326         case DELETE_VARIABLE:
1327                 ret = ianjuta_debugger_variable_destroy (IANJUTA_DEBUGGER_VARIABLE (debugger), cmd->data.var.name, NULL);
1328                 break;
1329         case ASSIGN_VARIABLE:
1330                 ret = ianjuta_debugger_variable_assign (IANJUTA_DEBUGGER_VARIABLE (debugger), cmd->data.var.name, cmd->data.var.value, err);
1331                 break;
1332         case EVALUATE_VARIABLE:
1333                 ret = ianjuta_debugger_variable_evaluate (IANJUTA_DEBUGGER_VARIABLE (debugger), cmd->data.var.name, callback, queue, err);
1334                 break;
1335         case LIST_VARIABLE_CHILDREN:
1336                 ret = ianjuta_debugger_variable_list_children (IANJUTA_DEBUGGER_VARIABLE (debugger), cmd->data.var.name, callback, queue, err);
1337                 break;
1338         case CREATE_VARIABLE:
1339                 ret = ianjuta_debugger_variable_create (IANJUTA_DEBUGGER_VARIABLE (debugger), cmd->data.var.name, callback, queue, err);
1340                 break;
1341         case UPDATE_VARIABLE:
1342                 ret = ianjuta_debugger_variable_update (IANJUTA_DEBUGGER_VARIABLE (debugger), callback, queue, err);
1343                 break;
1344         }
1345
1346         return ret;
1347 }
1348
1349 void
1350 dma_command_callback (DmaQueueCommand *cmd, const gpointer data, GError *err)
1351 {
1352         DmaDebuggerCommandType type = cmd->type & COMMAND_MASK;
1353
1354         switch (type)
1355         {
1356         case EMPTY_COMMAND:
1357         case LOAD_COMMAND:
1358         case ATTACH_COMMAND:
1359         case UNLOAD_COMMAND:
1360         case QUIT_COMMAND:
1361         case ABORT_COMMAND:
1362         case START_COMMAND:
1363         case SET_WORKING_DIRECTORY_COMMAND:
1364         case SET_ENVIRONMENT_COMMAND:
1365         case RUN_COMMAND:
1366         case RUN_TO_COMMAND:
1367         case STEP_IN_COMMAND:
1368         case STEP_OVER_COMMAND:
1369         case STEP_OUT_COMMAND:
1370         case RUN_TO_ADDRESS_COMMAND:
1371         case STEPI_IN_COMMAND:
1372         case STEPI_OVER_COMMAND:
1373         case EXIT_COMMAND:
1374         case INTERRUPT_COMMAND:
1375         case SET_THREAD_COMMAND:
1376         case SET_FRAME_COMMAND:
1377         case WRITE_REGISTER_COMMAND:
1378         case USER_COMMAND:
1379         case HANDLE_SIGNAL_COMMAND:
1380         case DELETE_VARIABLE:
1381         case ASSIGN_VARIABLE:
1382                 g_return_if_reached ();
1383                 break;
1384         case CALLBACK_COMMAND:
1385         case ENABLE_BREAK_COMMAND:
1386         case IGNORE_BREAK_COMMAND:
1387         case REMOVE_BREAK_COMMAND:
1388         case BREAK_LINE_COMMAND:
1389         case BREAK_FUNCTION_COMMAND:
1390         case BREAK_ADDRESS_COMMAND:
1391         case CONDITION_BREAK_COMMAND:
1392         case LIST_BREAK_COMMAND:
1393         case INSPECT_COMMAND:
1394         case EVALUATE_COMMAND:
1395         case LIST_LOCAL_COMMAND:
1396         case LIST_ARG_COMMAND:
1397         case LIST_THREAD_COMMAND:
1398         case INFO_THREAD_COMMAND:
1399         case INFO_SIGNAL_COMMAND:
1400         case INFO_SHAREDLIB_COMMAND:
1401         case INFO_FRAME_COMMAND:
1402         case INFO_ARGS_COMMAND:
1403         case INFO_TARGET_COMMAND:
1404         case INFO_PROGRAM_COMMAND:
1405         case INFO_UDOT_COMMAND:
1406         case INFO_VARIABLES_COMMAND:
1407         case LIST_FRAME_COMMAND:
1408         case LIST_REGISTER_COMMAND:
1409         case UPDATE_REGISTER_COMMAND:
1410         case INSPECT_MEMORY_COMMAND:
1411         case DISASSEMBLE_COMMAND:
1412         case PRINT_COMMAND:
1413         case EVALUATE_VARIABLE:
1414         case LIST_VARIABLE_CHILDREN:
1415         case CREATE_VARIABLE:
1416         case UPDATE_VARIABLE:
1417                 if (cmd->callback != NULL)
1418                 {
1419                         cmd->callback (data, cmd->user_data, err);
1420                 }
1421                 break;
1422         }
1423 }
1424
1425 gboolean
1426 dma_command_is_valid_in_state (DmaQueueCommand *cmd, IAnjutaDebuggerState state)
1427 {
1428         return cmd->type & 1 << (state + STATE_TO_NEED - 1);
1429 }
1430
1431 IAnjutaDebuggerState
1432 dma_command_is_going_to_state (DmaQueueCommand *cmd)
1433 {
1434         IAnjutaDebuggerState state;
1435
1436         switch (cmd->type & CHANGE_MASK)
1437         {
1438         case STOP_DEBUGGER:
1439                 state = IANJUTA_DEBUGGER_STOPPED;
1440                 break;
1441         case START_DEBUGGER:
1442                 state = IANJUTA_DEBUGGER_STARTED;
1443                 break;
1444         case LOAD_PROGRAM:
1445                 state = IANJUTA_DEBUGGER_PROGRAM_LOADED;
1446                 break;
1447         case STOP_PROGRAM:
1448                 state = IANJUTA_DEBUGGER_PROGRAM_STOPPED;
1449                 break;
1450         case RUN_PROGRAM:
1451                 state = IANJUTA_DEBUGGER_PROGRAM_RUNNING;
1452                 break;
1453         default:
1454                 state = IANJUTA_DEBUGGER_BUSY;
1455         }
1456
1457         return state;
1458 }
1459
1460 gboolean
1461 dma_command_has_flag (DmaQueueCommand *cmd, DmaCommandFlag flag)
1462 {
1463         return cmd->type & flag;
1464 }
1465
1466 int
1467 dma_command_get_type (DmaQueueCommand *cmd)
1468 {
1469         return (int)cmd->type;
1470 }