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