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