plugins/debug-manager/queue.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3     queue.c
   4     Copyright (C) 2005 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  * Keep all debugger commands in a queue and send them one by one to the
  23  * debugger (implementing IAnjutaDebugger).
  24  *---------------------------------------------------------------------------*/
  25
  26 #include <config.h>
  27
  28 #include "queue.h"
  29
  30 /*#define DEBUG*/
  31 #include <libanjuta/anjuta-debug.h>
  32 #include <libanjuta/interfaces/ianjuta-message-manager.h>
  33 #include <libanjuta/interfaces/ianjuta-debugger-register.h>
  34 #include <libanjuta/interfaces/ianjuta-debugger-memory.h>
  35 #include <libanjuta/interfaces/ianjuta-debugger-instruction.h>
  36 #include <libanjuta/interfaces/ianjuta-debugger-breakpoint.h>
  37 #include <libanjuta/interfaces/ianjuta-debugger-variable.h>
  38
  39
  40 #include <stdarg.h>
  41
  42 /* Contants defintion
  43  *---------------------------------------------------------------------------*/
  44
  45 #define ICON_FILE "anjuta-debug-manager.plugin.png"
  46
  47 /* Private type
  48  *---------------------------------------------------------------------------*/
  49
  50 struct _DmaDebuggerQueue {
  51         GObject parent;
  52
  53         AnjutaPlugin* plugin;
  54         IAnjutaDebugger* debugger;
  55         guint support;
  56
  57         /* Command queue */
  58         GQueue *queue;
  59         DmaQueueCommand *last;
  60         gint prepend_command;
  61
  62         IAnjutaDebuggerState debugger_state;
  63         IAnjutaDebuggerState queue_state;
  64         gboolean stop_on_sharedlib;
  65
  66         /* View for debugger messages */
  67         IAnjutaMessageView* log;
  68
  69         gboolean busy;
  70 };
  71
  72 struct _DmaDebuggerQueueClass {
  73         GObjectClass parent;
  74  };
  75
  76 /* Call backs
  77  *---------------------------------------------------------------------------*/
  78
  79 /* Queue function
  80  *---------------------------------------------------------------------------*/
  81
  82 static void
  83 dma_queue_cancel (DmaDebuggerQueue *self, DmaCommandFlag flag)
  84 {
  85         GList* node = g_queue_peek_head_link(self->queue);
  86
  87         /* Cancel all commands in queue with the flag */
  88         while (node != NULL)
  89         {
  90                 GList* next = g_list_next (node);
  91                 DmaQueueCommand* cmd = (DmaQueueCommand *)node->data;
  92
  93                 if (dma_command_has_flag (cmd, flag))
  94                 {
  95                         dma_command_cancel (cmd);
  96                         g_queue_delete_link (self->queue, node);
  97                 }
  98                 node = next;
  99         }
 100 }
 101
 102 /* Cancel all commands those cannot handle this unexpected state
 103  * Return TRUE if the state of the queue need to be changed too
 104  */
 105
 106 static gboolean
 107 dma_queue_cancel_unexpected (DmaDebuggerQueue *self, IAnjutaDebuggerState state)
 108 {
 109         GList* node = g_queue_peek_head_link(self->queue);
 110
 111         /* IANJUTA_DEBUGGER_BUSY is used as a do nothing marker*/
 112         if (state == IANJUTA_DEBUGGER_BUSY) return FALSE;
 113
 114         /* Cancel all commands in queue with the flag */
 115         while (node != NULL)
 116         {
 117                 GList* next = g_list_next (node);
 118                 DmaQueueCommand* cmd = (DmaQueueCommand *)node->data;
 119
 120                 if (!dma_command_is_valid_in_state(cmd, state))
 121                 {
 122                         /* Command is not allowed in this state, cancel it */
 123                         dma_command_cancel (cmd);
 124                         g_queue_delete_link (self->queue, node);
 125                 }
 126                 else if (dma_command_is_going_to_state (cmd) != IANJUTA_DEBUGGER_BUSY)
 127                 {
 128                         /* A command setting the state is kept,
 129                         debugger state is known again afterward, queue state is kept too */
 130
 131                         return FALSE;
 132                 }
 133                 node = next;
 134         }
 135         /* End in this unexpected state */
 136         self->queue_state = state;
 137
 138         return TRUE;
 139 }
 140
 141 static void
 142 dma_debugger_queue_clear (DmaDebuggerQueue *self)
 143 {
 144         g_queue_foreach (self->queue, (GFunc)dma_command_free, NULL);
 145         /* Do not use g_queue_clear yet as it is defined only in GLib 2.14 */
 146         while (g_queue_pop_head(self->queue) != NULL);
 147         if (self->last != NULL)
 148         {
 149                 DEBUG_PRINT("clear command %x", dma_command_get_type (self->last));
 150                 dma_command_free (self->last);
 151                 self->last = NULL;
 152         }
 153
 154         /* Queue is empty so has the same state than debugger */
 155         self->queue_state = self->debugger_state;
 156
 157         self->prepend_command = 0;
 158 }
 159
 160 static void
 161 dma_queue_emit_debugger_state (DmaDebuggerQueue *self, IAnjutaDebuggerState state, GError* err)
 162 {
 163         enum
 164         {
 165                 NO_SIGNAL,
 166                 DEBUGGER_STOPPED_SIGNAL,
 167                 DEBUGGER_STARTED_SIGNAL,
 168                 PROGRAM_LOADED_SIGNAL,
 169                 PROGRAM_UNLOADED_SIGNAL,
 170                 PROGRAM_STARTED_SIGNAL,
 171                 PROGRAM_EXITED_SIGNAL,
 172                 PROGRAM_RUNNING_SIGNAL,
 173                 PROGRAM_STOPPED_SIGNAL
 174         } signal = NO_SIGNAL;
 175         gboolean emit_program_started = FALSE;
 176
 177         DEBUG_PRINT("update debugger state new %d old %d", state, self->debugger_state);
 178
 179         /* Add missing state if useful */
 180         switch (state)
 181         {
 182         case IANJUTA_DEBUGGER_STOPPED:
 183                 if ((self->debugger_state == IANJUTA_DEBUGGER_PROGRAM_RUNNING) ||
 184                         (self->debugger_state == IANJUTA_DEBUGGER_PROGRAM_STOPPED))
 185                 {
 186                         dma_queue_emit_debugger_state (self, IANJUTA_DEBUGGER_PROGRAM_LOADED, NULL);
 187                 }
 188                 else if (self->debugger_state == IANJUTA_DEBUGGER_PROGRAM_LOADED)
 189                 {
 190                         dma_queue_emit_debugger_state (self, IANJUTA_DEBUGGER_STARTED, NULL);
 191                 }
 192                 break;
 193         case IANJUTA_DEBUGGER_STARTED:
 194                 if ((self->debugger_state == IANJUTA_DEBUGGER_PROGRAM_RUNNING) ||
 195                         (self->debugger_state == IANJUTA_DEBUGGER_PROGRAM_STOPPED))
 196                 {
 197                         dma_queue_emit_debugger_state (self, IANJUTA_DEBUGGER_PROGRAM_LOADED, NULL);
 198                 }
 199                 break;
 200         case IANJUTA_DEBUGGER_PROGRAM_LOADED:
 201                 if (self->debugger_state == IANJUTA_DEBUGGER_STOPPED)
 202                 {
 203                         dma_queue_emit_debugger_state (self, IANJUTA_DEBUGGER_STARTED, NULL);
 204                 }
 205                 break;
 206         case IANJUTA_DEBUGGER_PROGRAM_STOPPED:
 207                 if (self->debugger_state == IANJUTA_DEBUGGER_STOPPED)
 208                 {
 209                         dma_queue_emit_debugger_state (self, IANJUTA_DEBUGGER_STARTED, NULL);
 210                 }
 211                 else if (self->debugger_state == IANJUTA_DEBUGGER_STARTED)
 212                 {
 213                         dma_queue_emit_debugger_state (self, IANJUTA_DEBUGGER_PROGRAM_LOADED, NULL);
 214                 }
 215                 break;
 216         case IANJUTA_DEBUGGER_PROGRAM_RUNNING:
 217                 if (self->debugger_state == IANJUTA_DEBUGGER_STOPPED)
 218                 {
 219                         dma_queue_emit_debugger_state (self, IANJUTA_DEBUGGER_STARTED, NULL);
 220                 }
 221                 else if (self->debugger_state == IANJUTA_DEBUGGER_STARTED)
 222                 {
 223                         dma_queue_emit_debugger_state (self, IANJUTA_DEBUGGER_PROGRAM_LOADED, NULL);
 224                 }
 225                 break;
 226         case IANJUTA_DEBUGGER_BUSY:
 227                 break;
 228         }
 229
 230         if (self->debugger_state != state)
 231         {
 232                 switch (state)
 233                 {
 234                 case IANJUTA_DEBUGGER_BUSY:
 235                         /* Debugger is busy, nothing to do */
 236                         return;
 237                 case IANJUTA_DEBUGGER_STOPPED:
 238                         self->stop_on_sharedlib = FALSE;
 239                         signal = DEBUGGER_STOPPED_SIGNAL;
 240                         self->debugger_state = state;
 241                         break;
 242                 case IANJUTA_DEBUGGER_STARTED:
 243                         self->stop_on_sharedlib = FALSE;
 244                         signal = self->debugger_state < IANJUTA_DEBUGGER_STARTED ? DEBUGGER_STARTED_SIGNAL : PROGRAM_UNLOADED_SIGNAL;
 245                         self->debugger_state = state;
 246                         break;
 247                 case IANJUTA_DEBUGGER_PROGRAM_LOADED:
 248                         self->stop_on_sharedlib = FALSE;
 249                         signal = self->debugger_state < IANJUTA_DEBUGGER_PROGRAM_LOADED ? PROGRAM_LOADED_SIGNAL : PROGRAM_EXITED_SIGNAL;
 250                         self->debugger_state = state;
 251                         break;
 252                 case IANJUTA_DEBUGGER_PROGRAM_STOPPED:
 253                         if (!self->stop_on_sharedlib)
 254                         {
 255                                 emit_program_started = self->debugger_state < IANJUTA_DEBUGGER_PROGRAM_STOPPED;
 256                                 signal = PROGRAM_STOPPED_SIGNAL;
 257                         }
 258                         else if (self->debugger_state < IANJUTA_DEBUGGER_PROGRAM_STOPPED)
 259                         {
 260                                 signal = PROGRAM_STARTED_SIGNAL;
 261                         }
 262                         self->debugger_state = state;
 263                         break;
 264                 case IANJUTA_DEBUGGER_PROGRAM_RUNNING:
 265                         emit_program_started = self->debugger_state < IANJUTA_DEBUGGER_PROGRAM_STOPPED;
 266                         self->stop_on_sharedlib = FALSE;
 267                         signal = PROGRAM_RUNNING_SIGNAL;
 268                         self->debugger_state = state;
 269                         break;
 270                 }
 271         }
 272
 273         self->prepend_command++;
 274         /* Emit signal */
 275         switch (signal)
 276         {
 277         case NO_SIGNAL:
 278                 /* Do nothing */
 279                 break;
 280         case DEBUGGER_STOPPED_SIGNAL:
 281                 DEBUG_PRINT("** emit debugger-stopped **");
 282                 g_signal_emit_by_name (self->plugin, "debugger-stopped", err);
 283                 break;
 284         case DEBUGGER_STARTED_SIGNAL:
 285                 DEBUG_PRINT("** emit debugger-started **");
 286                 g_signal_emit_by_name (self->plugin, "debugger-started");
 287                 break;
 288         case PROGRAM_LOADED_SIGNAL:
 289                 DEBUG_PRINT("** emit program-loaded **");
 290                 g_signal_emit_by_name (self->plugin, "program-loaded");
 291                 break;
 292         case PROGRAM_UNLOADED_SIGNAL:
 293                 DEBUG_PRINT("** emit program-unloaded **");
 294                 g_signal_emit_by_name (self->plugin, "program-unloaded");
 295                 break;
 296         case PROGRAM_STARTED_SIGNAL:
 297                 DEBUG_PRINT("** emit program-started **");
 298                 g_signal_emit_by_name (self->plugin, "program-started");
 299                 break;
 300         case PROGRAM_EXITED_SIGNAL:
 301                 DEBUG_PRINT("** emit program-exited **");
 302                 g_signal_emit_by_name (self->plugin, "program-exited");
 303                 break;
 304         case PROGRAM_STOPPED_SIGNAL:
 305                 DEBUG_PRINT("** emit program-exited **");
 306                 if (emit_program_started)
 307                 {
 308                         DEBUG_PRINT("** emit program-started **");
 309                         g_signal_emit_by_name (self->plugin, "program-started");
 310                 }
 311                 DEBUG_PRINT("** emit program-stopped **");
 312                 g_signal_emit_by_name (self->plugin, "program-stopped");
 313                 break;
 314         case PROGRAM_RUNNING_SIGNAL:
 315                 if (emit_program_started)
 316                 {
 317                         DEBUG_PRINT("** emit program-started **");
 318                         g_signal_emit_by_name (self->plugin, "program-started");
 319                 }
 320                 DEBUG_PRINT("** emit program-running **");
 321                 g_signal_emit_by_name (self->plugin, "program-running");
 322                 break;
 323         }
 324         self->prepend_command--;
 325 }
 326
 327 static void
 328 dma_queue_emit_debugger_ready (DmaDebuggerQueue *self)
 329 {
 330         gboolean busy;
 331
 332         if (g_queue_is_empty(self->queue) && (self->last == NULL))
 333         {
 334                 busy = FALSE;
 335         }
 336         else
 337         {
 338                 busy = TRUE;
 339         }
 340
 341         if (busy != self->busy)
 342         {
 343                 AnjutaStatus* status;
 344
 345                 status = anjuta_shell_get_status(ANJUTA_PLUGIN (self->plugin)->shell, NULL);
 346                 if (busy)
 347                 {
 348                         anjuta_status_busy_push (status);
 349                         self->busy = TRUE;
 350                 }
 351                 else
 352                 {
 353                         anjuta_status_busy_pop (status);
 354                         self->busy = FALSE;
 355                 }
 356         }
 357 }
 358
 359 static void dma_debugger_queue_execute (DmaDebuggerQueue *self);
 360
 361 /* Call when debugger has completed the current command */
 362
 363 static void
 364 dma_debugger_queue_complete (DmaDebuggerQueue *self, IAnjutaDebuggerState state)
 365 {
 366         DEBUG_PRINT("debugger_queue_complete %d", state);
 367
 368         if (state != IANJUTA_DEBUGGER_BUSY)
 369         {
 370                 if (self->last != NULL)
 371                 {
 372                         if (dma_command_is_going_to_state (self->last) != state)
 373                         {
 374                                 /* Command end in an unexpected state,
 375                                 * Remove invalid following command */
 376                                 dma_queue_cancel_unexpected (self, state);
 377                         }
 378
 379                         /* Remove current command */
 380                         DEBUG_PRINT("end command %x", dma_command_get_type (self->last));
 381                         dma_command_free (self->last);
 382                         self->last = NULL;
 383                 }
 384
 385
 386                 /* Emit new state if necessary */
 387                 dma_queue_emit_debugger_state (self, state, NULL);
 388
 389                 /* Send next command */
 390                 dma_debugger_queue_execute (self);
 391         }
 392 }
 393
 394 /* Call to send next command */
 395
 396 static void
 397 dma_debugger_queue_execute (DmaDebuggerQueue *self)
 398 {
 399         DEBUG_PRINT("debugger_queue_execute");
 400
 401         /* Check if debugger is connected to a debugger backend */
 402         g_return_if_fail (self->debugger != NULL);
 403
 404         /* Check if there debugger is busy */
 405         if (self->last != NULL)
 406         {
 407                 IAnjutaDebuggerState state;
 408                 /* Recheck state in case of desynchronization */
 409                 state = ianjuta_debugger_get_state (self->debugger, NULL);
 410                 dma_debugger_queue_complete (self, state);
 411         }
 412
 413         /* Check if there is something to execute */
 414         while (!g_queue_is_empty(self->queue) && (self->last == NULL))
 415         {
 416                 DmaQueueCommand *cmd;
 417                 GError *err = NULL;
 418                 gboolean ok;
 419
 420                 cmd = (DmaQueueCommand *)g_queue_pop_head(self->queue);
 421
 422                 /* Start command */
 423                 self->last = cmd;
 424                 DEBUG_PRINT("run command %x", dma_command_get_type (cmd));
 425                 ok = dma_command_run (cmd, self->debugger, self, &err);
 426
 427                 if (!ok || (err != NULL))
 428                 {
 429                         /* Something fail */
 430                         if (dma_command_is_going_to_state (self->last) != IANJUTA_DEBUGGER_BUSY)
 431                         {
 432                                 /* Command has been canceled in an unexpected state,
 433                                  * Remove invalid following command */
 434                                 dma_queue_cancel_unexpected (self, self->debugger_state);
 435                         }
 436
 437                         /* Remove current command */
 438                         DEBUG_PRINT("cancel command %x", dma_command_get_type (self->last));
 439                         dma_command_free (self->last);
 440                         self->last = NULL;
 441
 442                         /* Display error message to user */
 443                         if (err != NULL)
 444                         {
 445                                 if (err->message != NULL)
 446                                 {
 447                                         anjuta_util_dialog_error (GTK_WINDOW (ANJUTA_PLUGIN (self->plugin)->shell), err->message);
 448                                 }
 449
 450                                 g_error_free (err);
 451                         }
 452                 }
 453         }
 454
 455         dma_queue_emit_debugger_ready (self);
 456 }
 457
 458 static gboolean
 459 dma_queue_check_state (DmaDebuggerQueue *self, DmaQueueCommand* cmd)
 460 {
 461         gboolean recheck;
 462
 463         for (recheck = FALSE; recheck != TRUE; recheck = TRUE)
 464         {
 465                 IAnjutaDebuggerState state;
 466
 467                 if (self->prepend_command)
 468                 {
 469                         /* Prepend command use debugger state or current command state */
 470                         if (self->last != NULL)
 471                         {
 472                                 state = dma_command_is_going_to_state (self->last);
 473                                 if (state == IANJUTA_DEBUGGER_BUSY)
 474                                 {
 475                                         state = self->debugger_state;
 476                                 }
 477                         }
 478                         else
 479                         {
 480                                 state = self->debugger_state;
 481                         }
 482                 }
 483                 else
 484                 {
 485                         /* Append command use queue state */
 486                         state = self->queue_state;
 487                 }
 488
 489                 /* Only the debugger can be busy */
 490                 g_return_val_if_fail (state != IANJUTA_DEBUGGER_BUSY, FALSE);
 491
 492                 if (dma_command_is_valid_in_state (cmd, state))
 493         {
 494                         /* State is right */
 495                         return TRUE;
 496                 }
 497
 498                 g_warning ("Cancel command %x, debugger in state %d", dma_command_get_type (cmd), state);
 499
 500                 /* Check if synchronization is still ok */
 501                 state = ianjuta_debugger_get_state (self->debugger, NULL);
 502                 dma_debugger_queue_complete (self, state);
 503
 504                 /* Check again */
 505         }
 506
 507         return FALSE;
 508 }
 509
 510 static gboolean
 511 dma_debugger_activate_plugin (DmaDebuggerQueue* self, const gchar *mime_type)
 512 {
 513         AnjutaPluginManager *plugin_manager;
 514         AnjutaPluginDescription *plugin;
 515         GList *descs = NULL;
 516         gchar *value;
 517
 518         /* Get list of debugger plugins */
 519         plugin_manager = anjuta_shell_get_plugin_manager (ANJUTA_PLUGIN(self->plugin)->shell, NULL);
 520         if (mime_type == NULL)
 521         {
 522                 /* User has to select the right debugger */
 523                 descs = anjuta_plugin_manager_query (plugin_manager,
 524                                                 "Anjuta Plugin","Interfaces", "IAnjutaDebugger", NULL);
 525         }
 526         else
 527         {
 528                 /* Propose only debugger supporting correct mime type */
 529                 descs = anjuta_plugin_manager_query (plugin_manager,
 530                                                 "Anjuta Plugin","Interfaces", "IAnjutaDebugger",
 531                                                 "File Loader", "SupportedMimeTypes", mime_type,
 532                                                 NULL);
 533         }
 534
 535         if (descs == NULL)
 536         {
 537                 /* No plugin found */
 538                 anjuta_util_dialog_error (GTK_WINDOW (ANJUTA_PLUGIN (self->plugin)->shell),
 539                                 _("Unable to find one debugger plugin acception %s mime type"), mime_type);
 540
 541                 return FALSE;
 542         }
 543         else if (g_list_length (descs) == 1)
 544         {
 545                 /* Only one plugin found, use it */
 546                 plugin = (AnjutaPluginDescription *)descs->data;
 547         }
 548         else
 549         {
 550                 /* Ask the user to select one plugin */
 551                 plugin = anjuta_plugin_manager_select (plugin_manager,
 552                                                 _("Select a plugin"),
 553                                                 _("Please select a plugin to activate"),
 554                                                 descs);
 555         }
 556
 557         if (plugin != NULL)
 558         {
 559                 /* Get debugger location */
 560                 value = NULL;
 561                 anjuta_plugin_description_get_string (plugin, "Anjuta Plugin", "Location", &value);
 562                 g_return_val_if_fail (value != NULL, FALSE);
 563
 564                 /* Get debugger interface */
 565                 self->debugger = (IAnjutaDebugger *)anjuta_plugin_manager_get_plugin_by_id (plugin_manager, value);
 566
 567                 self->support = 0;
 568                 /* Check if register interface is available */
 569                 self->support |= IANJUTA_IS_DEBUGGER_REGISTER(self->debugger) ? HAS_REGISTER : 0;
 570                 /* Check if memory interface is available */
 571                 self->support |= IANJUTA_IS_DEBUGGER_MEMORY(self->debugger) ? HAS_MEMORY : 0;
 572                 /* Check if instruction interface is available */
 573                 self->support |= IANJUTA_IS_DEBUGGER_INSTRUCTION(self->debugger) ? HAS_INSTRUCTION : 0;
 574                 /* Check if breakpoint interface is available */
 575                 self->support |= IANJUTA_IS_DEBUGGER_BREAKPOINT(self->debugger) ? HAS_BREAKPOINT : 0;
 576                 if (IANJUTA_IS_DEBUGGER_BREAKPOINT (self->debugger))
 577                 {
 578                         self->support |= ianjuta_debugger_breakpoint_implement (IANJUTA_DEBUGGER_BREAKPOINT (self->debugger), NULL) * HAS_BREAKPOINT * 2;
 579                 }
 580                 /* Check if variable interface is available */
 581                 self->support |= IANJUTA_IS_DEBUGGER_VARIABLE(self->debugger) ? HAS_VARIABLE : 0;
 582
 583                 g_free (value);
 584
 585                 return TRUE;
 586         }
 587         else
 588         {
 589                 /* No plugin selected */
 590
 591                 return FALSE;
 592         }
 593 }
 594
 595 /* IAnjutaDebugger callback
 596  *---------------------------------------------------------------------------*/
 597
 598 static void
 599 on_dma_debugger_ready (DmaDebuggerQueue *self, IAnjutaDebuggerState state)
 600 {
 601         DEBUG_PRINT ("From debugger: receive debugger ready %d", state);
 602
 603         dma_debugger_queue_complete (self, state);
 604 }
 605
 606 static void
 607 on_dma_debugger_started (DmaDebuggerQueue *self)
 608 {
 609         DEBUG_PRINT ("From debugger: receive debugger started");
 610         dma_queue_emit_debugger_state (self, IANJUTA_DEBUGGER_STARTED, NULL);
 611 }
 612
 613 static void
 614 on_dma_debugger_stopped (DmaDebuggerQueue *self, GError *err)
 615 {
 616         IAnjutaDebuggerState state;
 617
 618         DEBUG_PRINT ("From debugger: receive debugger stopped with error %p", err);
 619         dma_queue_emit_debugger_state (self, IANJUTA_DEBUGGER_STOPPED, err);
 620
 621         /* Reread debugger state, could have changed while emitting signal */
 622         state = ianjuta_debugger_get_state (self->debugger, NULL);
 623         dma_debugger_queue_complete (self, state);
 624 }
 625
 626 static void
 627 on_dma_program_loaded (DmaDebuggerQueue *self)
 628 {
 629         DEBUG_PRINT ("From debugger: receive program loaded");
 630         dma_queue_emit_debugger_state (self, IANJUTA_DEBUGGER_PROGRAM_LOADED, NULL);
 631 }
 632
 633 static void
 634 on_dma_program_running (DmaDebuggerQueue *self)
 635 {
 636         DEBUG_PRINT ("From debugger: debugger_program_running");
 637         dma_queue_emit_debugger_state (self, IANJUTA_DEBUGGER_PROGRAM_RUNNING, NULL);
 638 }
 639
 640 static void
 641 on_dma_program_stopped (DmaDebuggerQueue *self)
 642 {
 643         DEBUG_PRINT ("From debugger: receive program stopped");
 644         dma_queue_emit_debugger_state (self, IANJUTA_DEBUGGER_PROGRAM_STOPPED, NULL);
 645 }
 646
 647 static void
 648 on_dma_program_exited (DmaDebuggerQueue *self)
 649 {
 650         DEBUG_PRINT ("From debugger: receive program exited");
 651         dma_queue_emit_debugger_state (self, IANJUTA_DEBUGGER_PROGRAM_LOADED, NULL);
 652 }
 653
 654 static void
 655 on_dma_program_moved (DmaDebuggerQueue *self, guint pid, gint tid, gulong address, const gchar* src_path, guint line)
 656 {
 657         DEBUG_PRINT ("From debugger: program moved");
 658         self->prepend_command++;
 659         g_signal_emit_by_name (self->plugin, "program-moved", pid, tid, address, src_path, line);
 660         self->prepend_command--;
 661 }
 662
 663 static void
 664 on_dma_frame_changed (DmaDebuggerQueue *self, guint frame, gint thread)
 665 {
 666         DEBUG_PRINT ("From debugger: frame changed");
 667         self->prepend_command++;
 668         g_signal_emit_by_name (self->plugin, "frame-changed", frame, thread);
 669         self->prepend_command--;
 670 }
 671
 672 static void
 673 on_dma_signal_received (DmaDebuggerQueue *self, const gchar* name, const gchar* description)
 674 {
 675         DEBUG_PRINT ("From debugger: signal received");
 676         self->prepend_command++;
 677         g_signal_emit_by_name (self->plugin, "signal-received", name, description);
 678         self->prepend_command--;
 679 }
 680
 681 static void
 682 on_dma_sharedlib_event (DmaDebuggerQueue *self)
 683 {
 684         DEBUG_PRINT ("From debugger: shared lib event");
 685         self->stop_on_sharedlib = TRUE;
 686         dma_debugger_queue_complete (self, IANJUTA_DEBUGGER_PROGRAM_STOPPED);
 687         self->prepend_command++;
 688         g_signal_emit_by_name (self->plugin, "sharedlib-event");
 689         self->prepend_command--;
 690         dma_queue_run (self);
 691 }
 692
 693 /* Public function
 694  *---------------------------------------------------------------------------*/
 695
 696 /* Command callback will add their commands at the beginning of the queue */
 697 void
 698 dma_debugger_queue_command_callback (const gpointer data, gpointer user_data, GError* err)
 699 {
 700         DmaDebuggerQueue *self = (DmaDebuggerQueue *)user_data;
 701
 702         g_return_if_fail (self->last != NULL);
 703
 704         self->prepend_command++;
 705         dma_command_callback (self->last, data, err);
 706         self->prepend_command--;
 707 }
 708
 709 gboolean
 710 dma_debugger_queue_append (DmaDebuggerQueue *self, DmaQueueCommand *cmd)
 711 {
 712         DEBUG_PRINT("append cmd %x prepend %d", dma_command_get_type (cmd), self->prepend_command);
 713         DEBUG_PRINT("current %x", self->last == NULL ? 0 : dma_command_get_type (self->last));
 714         DEBUG_PRINT("queue %x", self->queue->head == NULL ? 0 : dma_command_get_type (self->queue->head->data));
 715
 716         if ((self->debugger != NULL) && dma_queue_check_state(self, cmd))
 717         {
 718                 /* If command is asynchronous stop current command */
 719                 if (dma_command_has_flag (cmd, ASYNCHRONOUS))
 720                 {
 721                         IAnjutaDebuggerState state;
 722
 723                         state = dma_command_is_going_to_state (cmd);
 724                         if (state != IANJUTA_DEBUGGER_BUSY)
 725                         {
 726                                 /* Command is changing debugger state */
 727                                 dma_queue_cancel_unexpected (self, state);
 728                         }
 729
 730                         /* Append command at the beginning */
 731                         g_queue_push_head (self->queue, cmd);
 732
 733                         dma_debugger_queue_complete (self, self->debugger_state);
 734                 }
 735                 else if (self->prepend_command == 0)
 736                 {
 737                         /* Append command at the end (in the queue) */
 738                         IAnjutaDebuggerState state;
 739
 740                         g_queue_push_tail (self->queue, cmd);
 741
 742                         state = dma_command_is_going_to_state (cmd);
 743                         if (state != IANJUTA_DEBUGGER_BUSY)
 744                         {
 745                                 self->queue_state = state;
 746                         }
 747                 }
 748                 else
 749                 {
 750                         /* Prepend command at the beginning */
 751                         g_queue_push_head (self->queue, cmd);
 752                 }
 753
 754                 dma_debugger_queue_execute(self);
 755
 756                 return TRUE;
 757         }
 758         else
 759         {
 760                 dma_command_free (cmd);
 761
 762                 return FALSE;
 763         }
 764 }
 765
 766 void
 767 dma_debugger_queue_stop (DmaDebuggerQueue *self)
 768 {
 769         /* Disconnect signal */
 770         if (self->debugger)
 771         {
 772                 g_signal_handlers_disconnect_by_func (self->debugger, G_CALLBACK (on_dma_debugger_ready), self);
 773                 g_signal_handlers_disconnect_by_func (self->debugger, G_CALLBACK (on_dma_debugger_started), self);
 774                 g_signal_handlers_disconnect_by_func (self->debugger, G_CALLBACK (on_dma_debugger_stopped), self);
 775                 g_signal_handlers_disconnect_by_func (self->debugger, G_CALLBACK (on_dma_program_loaded), self);
 776                 g_signal_handlers_disconnect_by_func (self->debugger, G_CALLBACK (on_dma_program_running), self);
 777                 g_signal_handlers_disconnect_by_func (self->debugger, G_CALLBACK (on_dma_program_stopped), self);
 778                 g_signal_handlers_disconnect_by_func (self->debugger, G_CALLBACK (on_dma_program_exited), self);
 779                 g_signal_handlers_disconnect_by_func (self->debugger, G_CALLBACK (on_dma_program_moved), self);
 780                 g_signal_handlers_disconnect_by_func (self->debugger, G_CALLBACK (on_dma_signal_received), self);
 781                 g_signal_handlers_disconnect_by_func (self->debugger, G_CALLBACK (on_dma_frame_changed), self);
 782                 g_signal_handlers_disconnect_by_func (self->debugger, G_CALLBACK (on_dma_sharedlib_event), self);
 783                 self->debugger = NULL;
 784                 self->support = 0;
 785         }
 786 }
 787
 788 gboolean
 789 dma_debugger_queue_start (DmaDebuggerQueue *self, const gchar *mime_type)
 790 {
 791         dma_debugger_queue_stop (self);
 792
 793         /* Look for a debugger supporting mime_type */
 794         if (!dma_debugger_activate_plugin (self, mime_type))
 795         {
 796                 return FALSE;
 797         }
 798
 799         if (self->debugger)
 800         {
 801                 /* Connect signal */
 802                 g_signal_connect_swapped (self->debugger, "debugger-ready", G_CALLBACK (on_dma_debugger_ready), self);
 803                 g_signal_connect_swapped (self->debugger, "debugger-started", G_CALLBACK (on_dma_debugger_started), self);
 804                 g_signal_connect_swapped (self->debugger, "debugger-stopped", G_CALLBACK (on_dma_debugger_stopped), self);
 805                 g_signal_connect_swapped (self->debugger, "program-loaded", G_CALLBACK (on_dma_program_loaded), self);
 806                 g_signal_connect_swapped (self->debugger, "program-running", G_CALLBACK (on_dma_program_running), self);
 807                 g_signal_connect_swapped (self->debugger, "program-stopped", G_CALLBACK (on_dma_program_stopped), self);
 808                 g_signal_connect_swapped (self->debugger, "program-exited", G_CALLBACK (on_dma_program_exited), self);
 809                 g_signal_connect_swapped (self->debugger, "program-moved", G_CALLBACK (on_dma_program_moved), self);
 810                 g_signal_connect_swapped (self->debugger, "signal-received", G_CALLBACK (on_dma_signal_received), self);
 811                 g_signal_connect_swapped (self->debugger, "frame-changed", G_CALLBACK (on_dma_frame_changed), self);
 812                 g_signal_connect_swapped (self->debugger, "sharedlib-event", G_CALLBACK (on_dma_sharedlib_event), self);
 813
 814                 if (self->log == NULL)
 815                 {
 816                         dma_queue_disable_log (self);
 817                 }
 818                 else
 819                 {
 820                         dma_queue_enable_log (self, self->log);
 821                 }
 822         }
 823
 824         return self->debugger != NULL;
 825 }
 826
 827 void
 828 dma_queue_enable_log (DmaDebuggerQueue *self, IAnjutaMessageView *log)
 829 {
 830         self->log = log;
 831         if (self->debugger != NULL)
 832         {
 833                 ianjuta_debugger_enable_log (self->debugger, self->log, NULL);
 834         }
 835 }
 836
 837 void
 838 dma_queue_disable_log (DmaDebuggerQueue *self)
 839 {
 840         self->log = NULL;
 841         if (self->debugger != NULL)
 842         {
 843                 ianjuta_debugger_disable_log (self->debugger, NULL);
 844         }
 845 }
 846
 847 IAnjutaDebuggerState
 848 dma_debugger_queue_get_state (DmaDebuggerQueue *self)
 849 {
 850         return self->queue_state;
 851 }
 852
 853 gboolean
 854 dma_debugger_queue_is_supported (DmaDebuggerQueue *self, DmaDebuggerCapability capability)
 855 {
 856         return self->support & capability ? TRUE : FALSE;
 857 }
 858
 859 /* GObject functions
 860  *---------------------------------------------------------------------------*/
 861
 862 /* Used in dispose and finalize */
 863 static gpointer parent_class;
 864
 865 /* dispose is the first destruction step. It is used to unref object created
 866  * with instance_init in order to break reference counting cycles. This
 867  * function could be called several times. All function should still work
 868  * after this call. It has to called its parents.*/
 869
 870 static void
 871 dma_debugger_queue_dispose (GObject *obj)
 872 {
 873         DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (obj);
 874
 875         dma_debugger_queue_clear (self);
 876
 877         GNOME_CALL_PARENT (G_OBJECT_CLASS, dispose, (obj));
 878 }
 879
 880 /* finalize is the last destruction step. It must free all memory allocated
 881  * with instance_init. It is called only one time just before releasing all
 882  * memory */
 883
 884 static void
 885 dma_debugger_queue_finalize (GObject *obj)
 886 {
 887         /*DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (obj);*/
 888
 889         GNOME_CALL_PARENT (G_OBJECT_CLASS, finalize, (obj));
 890 }
 891
 892 /* instance_init is the constructor. All functions should work after this
 893  * call. */
 894
 895 static void
 896 dma_debugger_queue_instance_init (DmaDebuggerQueue *self)
 897 {
 898         self->plugin = NULL;
 899         self->debugger = NULL;
 900         self->support = 0;
 901         self->queue = g_queue_new ();
 902         self->last = NULL;
 903         self->busy = FALSE;
 904         self->prepend_command = 0;
 905         self->debugger_state = IANJUTA_DEBUGGER_STOPPED;
 906         self->queue_state = IANJUTA_DEBUGGER_STOPPED;
 907         self->log = NULL;
 908 }
 909
 910 /* class_init intialize the class itself not the instance */
 911
 912 static void
 913 dma_debugger_queue_class_init (DmaDebuggerQueueClass * klass)
 914 {
 915         GObjectClass *object_class;
 916
 917         g_return_if_fail (klass != NULL);
 918         object_class = G_OBJECT_CLASS (klass);
 919
 920         parent_class = g_type_class_peek_parent (klass);
 921
 922         object_class->dispose = dma_debugger_queue_dispose;
 923         object_class->finalize = dma_debugger_queue_finalize;
 924 }
 925
 926 GType
 927 dma_debugger_queue_get_type (void)
 928 {
 929         static GType type = 0;
 930
 931         if (!type)
 932         {
 933                 static const GTypeInfo type_info =
 934                 {
 935                         sizeof (DmaDebuggerQueueClass),
 936                         (GBaseInitFunc) NULL,
 937                         (GBaseFinalizeFunc) NULL,
 938                         (GClassInitFunc) dma_debugger_queue_class_init,
 939                         (GClassFinalizeFunc) NULL,
 940                         NULL,           /* class_data */
 941                         sizeof (DmaDebuggerQueue),
 942                         0,              /* n_preallocs */
 943                         (GInstanceInitFunc) dma_debugger_queue_instance_init,
 944                         NULL            /* value_table */
 945                 };
 946
 947                 type = g_type_register_static (G_TYPE_OBJECT,
 948                                             "DmaDebuggerQueue", &type_info, 0);
 949         }
 950
 951         return type;
 952 }
 953
 954 /* Creation and Destruction
 955  *---------------------------------------------------------------------------*/
 956
 957 DmaDebuggerQueue*
 958 dma_debugger_queue_new (AnjutaPlugin *plugin)
 959 {
 960         DmaDebuggerQueue *self;
 961
 962         self = g_object_new (DMA_DEBUGGER_QUEUE_TYPE, NULL);
 963         self->plugin = plugin;
 964
 965         return self;
 966 }
 967
 968 void
 969 dma_debugger_queue_free (DmaDebuggerQueue *self)
 970 {
 971         dma_debugger_queue_stop (self);
 972         g_object_unref (self);
 973 }