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