?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Updated Spanish translation
[anjuta-git-plugin.git] / plugins / debug-manager / debugger.c
blobeeb12d7c29031c6c25c1e9f8d2fbdcc66b92e480
1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
2 /*
3 debugger.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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 /*
22 * Keep all debugger command in a FIFO queue
23 *
24 *---------------------------------------------------------------------------*/
25
26 #include <config.h>
27
28 /*#define DEBUG*/
29
30 #include "debugger.h"
31
32 #include <libanjuta/anjuta-debug.h>
33 #include <libanjuta/interfaces/ianjuta-message-manager.h>
34 #include <libanjuta/interfaces/ianjuta-variable-debugger.h>
35
36 /* Contants defintion
37 *---------------------------------------------------------------------------*/
38
39 #define ICON_FILE "anjuta-debug-manager.plugin.png"
40
41 /* Private type
42 *---------------------------------------------------------------------------*/
43
44 enum
45 {
46 COMMAND_MASK = 0xff,
47 NEED_DEBUGGER_STOPPED = 1 << 8,
48 NEED_DEBUGGER_STARTED = 1 << 9,
49 NEED_PROGRAM_LOADED = 1 << 10,
50 NEED_PROGRAM_STOPPED = 1 << 11,
51 NEED_PROGRAM_RUNNING = 1 << 12,
52
53 STOP_DEBUGGER = 1 << 18,
54 START_DEBUGGER = 1 << 19,
55 LOAD_PROGRAM = 1 << 20,
56 STOP_PROGRAM = 1 << 21,
57 RUN_PROGRAM = 1 << 22,
58
59 CHANGE_STATE = 31 << 18,
60
61 CANCEL_IF_PROGRAM_RUNNING = 1 << 13,
62 CANCEL_ALL_COMMAND = 1 << 15,
63 };
64
65 typedef enum
66 {
67 EMPTY_COMMAND ,
68 CALLBACK_COMMAND,
69 INITIALIZE_COMMAND, /* Debugger stopped */
70 LOAD_COMMAND, /* Debugger started */
71 ATTACH_COMMAND,
72 QUIT_COMMAND, /* Debugger started - Program stopped */
73 ABORT_COMMAND,
74 USER_COMMAND,
75 INSPECT_MEMORY_COMMAND,
76 DISASSEMBLE_COMMAND,
77 LIST_REGISTER_COMMAND,
78 UNLOAD_COMMAND, /* Program loaded */
79 START_COMMAND,
80 RESTART_COMMAND, /* Program loaded - Program stopped */
81 BREAK_LINE_COMMAND,
82 BREAK_FUNCTION_COMMAND,
83 BREAK_ADDRESS_COMMAND,
84 ENABLE_BREAK_COMMAND,
85 IGNORE_BREAK_COMMAND, /* 0x10 */
86 CONDITION_BREAK_COMMAND,
87 REMOVE_BREAK_COMMAND,
88 INFO_SHAREDLIB_COMMAND,
89 INFO_TARGET_COMMAND,
90 INFO_PROGRAM_COMMAND,
91 INFO_UDOT_COMMAND,
92 STEP_IN_COMMAND, /* Program stopped */
93 STEP_OVER_COMMAND,
94 STEP_OUT_COMMAND,
95 RUN_COMMAND,
96 RUN_TO_COMMAND,
97 EXIT_COMMAND,
98 HANDLE_SIGNAL_COMMAND,
99 LIST_LOCAL_COMMAND,
100 LIST_ARG_COMMAND,
101 LIST_THREAD_COMMAND,
102 SET_THREAD_COMMAND,
103 INFO_THREAD_COMMAND,
104 INFO_SIGNAL_COMMAND, /* 0x20 */
105 INFO_FRAME_COMMAND,
106 INFO_ARGS_COMMAND,
107 INFO_VARIABLES_COMMAND,
108 SET_FRAME_COMMAND,
109 LIST_FRAME_COMMAND,
110 UPDATE_REGISTER_COMMAND,
111 WRITE_REGISTER_COMMAND,
112 EVALUATE_COMMAND,
113 INSPECT_COMMAND,
114 PRINT_COMMAND,
115 CREATE_VARIABLE,
116 EVALUATE_VARIABLE,
117 LIST_VARIABLE_CHILDREN,
118 DELETE_VARIABLE,
119 ASSIGN_VARIABLE, /* 0x30 */
120 UPDATE_VARIABLE,
121 INTERRUPT_COMMAND /* Program running */
122 } DmaDebuggerCommandType;
123
124 typedef enum
125 {
126 DMA_CALLBACK_COMMAND =
127 CALLBACK_COMMAND |
128 NEED_DEBUGGER_STOPPED | NEED_DEBUGGER_STARTED | NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED | NEED_PROGRAM_RUNNING,
129 DMA_INITIALIZE_COMMAND =
130 INITIALIZE_COMMAND | START_DEBUGGER |
131 NEED_DEBUGGER_STOPPED,
132 DMA_LOAD_COMMAND =
133 LOAD_COMMAND | LOAD_PROGRAM |
134 NEED_DEBUGGER_STOPPED | NEED_DEBUGGER_STARTED,
135 DMA_ATTACH_COMMAND =
136 ATTACH_COMMAND | RUN_PROGRAM |
137 NEED_DEBUGGER_STOPPED | NEED_DEBUGGER_STARTED,
138 DMA_QUIT_COMMAND =
139 QUIT_COMMAND | CANCEL_ALL_COMMAND | STOP_DEBUGGER |
140 NEED_DEBUGGER_STARTED | NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
141 DMA_ABORT_COMMAND =
142 ABORT_COMMAND | CANCEL_ALL_COMMAND | STOP_DEBUGGER |
143 NEED_DEBUGGER_STARTED | NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED | NEED_PROGRAM_RUNNING,
144 DMA_USER_COMMAND =
145 USER_COMMAND |
146 NEED_DEBUGGER_STARTED | NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
147 DMA_INSPECT_MEMORY_COMMAND =
148 INSPECT_MEMORY_COMMAND |
149 NEED_DEBUGGER_STARTED | NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
150 DMA_DISASSEMBLE_COMMAND =
151 DISASSEMBLE_COMMAND |
152 NEED_DEBUGGER_STARTED | NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
153 DMA_LIST_REGISTER_COMMAND =
154 LIST_REGISTER_COMMAND |
155 NEED_DEBUGGER_STARTED | NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
156 DMA_UNLOAD_COMMAND =
157 UNLOAD_COMMAND | START_DEBUGGER |
158 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
159 DMA_START_COMMAND =
160 START_COMMAND | RUN_PROGRAM |
161 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
162 DMA_RESTART_COMMAND =
163 RESTART_COMMAND | RUN_PROGRAM |
164 NEED_PROGRAM_STOPPED,
165 DMA_BREAK_LINE_COMMAND =
166 BREAK_LINE_COMMAND |
167 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
168 DMA_BREAK_FUNCTION_COMMAND =
169 BREAK_FUNCTION_COMMAND |
170 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
171 DMA_BREAK_ADDRESS_COMMAND =
172 BREAK_ADDRESS_COMMAND |
173 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
174 DMA_ENABLE_BREAK_COMMAND =
175 ENABLE_BREAK_COMMAND |
176 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
177 DMA_IGNORE_BREAK_COMMAND =
178 IGNORE_BREAK_COMMAND |
179 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
180 DMA_CONDITION_BREAK_COMMAND =
181 CONDITION_BREAK_COMMAND |
182 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
183 DMA_REMOVE_BREAK_COMMAND =
184 REMOVE_BREAK_COMMAND |
185 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
186 DMA_INFO_SHAREDLIB_COMMAND =
187 INFO_SHAREDLIB_COMMAND |
188 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
189 DMA_INFO_TARGET_COMMAND =
190 INFO_TARGET_COMMAND |
191 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
192 DMA_INFO_PROGRAM_COMMAND =
193 INFO_PROGRAM_COMMAND |
194 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
195 DMA_INFO_UDOT_COMMAND =
196 INFO_UDOT_COMMAND |
197 NEED_PROGRAM_LOADED | NEED_PROGRAM_STOPPED,
198 DMA_STEP_IN_COMMAND =
199 STEP_IN_COMMAND | RUN_PROGRAM |
200 NEED_PROGRAM_STOPPED,
201 DMA_STEP_OVER_COMMAND =
202 STEP_OVER_COMMAND | RUN_PROGRAM |
203 NEED_PROGRAM_STOPPED,
204 DMA_STEP_OUT_COMMAND =
205 STEP_OUT_COMMAND | RUN_PROGRAM |
206 NEED_PROGRAM_STOPPED,
207 DMA_RUN_COMMAND =
208 RUN_COMMAND | RUN_PROGRAM |
209 NEED_PROGRAM_STOPPED,
210 DMA_RUN_TO_COMMAND =
211 RUN_TO_COMMAND | RUN_PROGRAM |
212 NEED_PROGRAM_STOPPED,
213 DMA_EXIT_COMMAND =
214 EXIT_COMMAND | LOAD_PROGRAM |
215 NEED_PROGRAM_STOPPED,
216 DMA_HANDLE_SIGNAL_COMMAND =
217 HANDLE_SIGNAL_COMMAND |
218 NEED_PROGRAM_STOPPED,
219 DMA_LIST_LOCAL_COMMAND =
220 LIST_LOCAL_COMMAND |
221 NEED_PROGRAM_STOPPED,
222 DMA_LIST_ARG_COMMAND =
223 LIST_ARG_COMMAND |
224 NEED_PROGRAM_STOPPED,
225 DMA_LIST_THREAD_COMMAND =
226 LIST_THREAD_COMMAND |
227 NEED_PROGRAM_STOPPED,
228 DMA_SET_THREAD_COMMAND =
229 SET_THREAD_COMMAND |
230 NEED_PROGRAM_STOPPED,
231 DMA_INFO_THREAD_COMMAND =
232 INFO_THREAD_COMMAND |
233 NEED_PROGRAM_STOPPED,
234 DMA_INFO_SIGNAL_COMMAND =
235 INFO_SIGNAL_COMMAND |
236 NEED_PROGRAM_STOPPED,
237 DMA_INFO_FRAME_COMMAND =
238 INFO_FRAME_COMMAND |
239 NEED_PROGRAM_STOPPED,
240 DMA_INFO_ARGS_COMMAND =
241 INFO_ARGS_COMMAND |
242 NEED_PROGRAM_STOPPED,
243 DMA_INFO_VARIABLES_COMMAND =
244 INFO_VARIABLES_COMMAND |
245 NEED_PROGRAM_STOPPED,
246 DMA_SET_FRAME_COMMAND =
247 SET_FRAME_COMMAND |
248 NEED_PROGRAM_STOPPED,
249 DMA_LIST_FRAME_COMMAND =
250 LIST_FRAME_COMMAND |
251 NEED_PROGRAM_STOPPED,
252 DMA_UPDATE_REGISTER_COMMAND =
253 UPDATE_REGISTER_COMMAND |
254 NEED_PROGRAM_STOPPED,
255 DMA_WRITE_REGISTER_COMMAND =
256 WRITE_REGISTER_COMMAND |
257 NEED_PROGRAM_STOPPED,
258 DMA_EVALUATE_COMMAND =
259 EVALUATE_COMMAND |
260 NEED_PROGRAM_STOPPED,
261 DMA_INSPECT_COMMAND =
262 INSPECT_COMMAND |
263 NEED_PROGRAM_STOPPED,
264 DMA_PRINT_COMMAND =
265 PRINT_COMMAND |
266 NEED_PROGRAM_STOPPED,
267 DMA_CREATE_VARIABLE_COMMAND =
268 CREATE_VARIABLE |
269 NEED_PROGRAM_STOPPED,
270 DMA_EVALUATE_VARIABLE_COMMAND =
271 EVALUATE_VARIABLE | CANCEL_IF_PROGRAM_RUNNING |
272 NEED_PROGRAM_STOPPED,
273 DMA_LIST_VARIABLE_CHILDREN_COMMAND =
274 LIST_VARIABLE_CHILDREN |
275 NEED_PROGRAM_STOPPED,
276 DMA_DELETE_VARIABLE_COMMAND =
277 DELETE_VARIABLE |
278 NEED_PROGRAM_STOPPED,
279 DMA_ASSIGN_VARIABLE_COMMAND =
280 ASSIGN_VARIABLE |
281 NEED_PROGRAM_STOPPED,
282 DMA_UPDATE_VARIABLE_COMMAND =
283 UPDATE_VARIABLE | CANCEL_IF_PROGRAM_RUNNING |
284 NEED_PROGRAM_STOPPED,
285 DMA_INTERRUPT_COMMAND =
286 INTERRUPT_COMMAND | STOP_PROGRAM |
287 NEED_PROGRAM_RUNNING,
288 } DmaDebuggerCommand;
289
290
291
292
293 enum
294 {
295 DEBUGGER_STOPPED_OR_GREATER = EMPTY_COMMAND,
296 DEBUGGER_STOPPED_OR_LESSER = INITIALIZE_COMMAND,
297 DEBUGGER_STARTED_OR_GREATER = LOAD_COMMAND,
298 DEBUGGER_STARTED_OR_LESSER = ATTACH_COMMAND,
299 PROGRAM_LOADED_OR_GREATER = UNLOAD_COMMAND,
300 PROGRAM_LOADED_OR_LESSER = ATTACH_COMMAND,
301 PROGRAM_STOPPED_OR_GREATER = QUIT_COMMAND,
302 PROGRAM_STOPPED_OR_LESSER = ATTACH_COMMAND,
303 PROGRAM_RUNNING_OR_GREATER = INTERRUPT_COMMAND,
304 PROGRAM_RUNNING_OR_LESSER = INTERRUPT_COMMAND
305 };
306
307 typedef struct _DmaQueueCommand
308 {
309 DmaDebuggerCommandType type;
310 IAnjutaDebuggerCallback callback;
311 gpointer user_data;
312 union {
313 struct {
314 gchar *file;
315 gchar *type;
316 GList *dirs;
317 gboolean terminal;
318 } load;
319 struct {
320 gchar *args;
321 } start;
322 struct {
323 pid_t pid;
324 GList *dirs;
325 } attach;
326 struct {
327 gchar *file;
328 guint line;
329 guint address;
330 gchar *function;
331 } pos;
332 struct {
333 guint id;
334 guint ignore;
335 gchar *condition;
336 gboolean enable;
337 } brk;
338 struct {
339 guint id;
340 gchar *name;
341 gchar *value;
342 } watch;
343 struct {
344 gchar *cmd;
345 } user;
346 struct {
347 gchar *var;
348 } print;
349 struct {
350 guint id;
351 } info;
352 struct {
353 gchar *name;
354 gboolean stop;
355 gboolean print;
356 gboolean ignore;
357 } signal;
358 struct {
359 guint frame;
360 } frame;
361 struct {
362 guint address;
363 guint length;
364 } mem;
365 struct {
366 gchar *name;
367 gchar *value;
368 } var;
369 } data;
370 struct _DmaQueueCommand *next;
371 } DmaQueueCommand;
372
373 struct _DmaDebuggerQueue {
374 GObject parent;
375
376 AnjutaPlugin* plugin;
377 IAnjutaDebugger* debugger;
378 IAnjutaCpuDebugger* cpu_debugger;
379
380 /* Command queue */
381 DmaQueueCommand *head;
382 DmaQueueCommand *tail;
383 DmaDebuggerCommandType last;
384 gboolean queue_command;
385
386 IAnjutaDebuggerStatus debugger_status;
387 IAnjutaDebuggerStatus queue_status;
388 IAnjutaDebuggerStatus status;
389 gboolean ready;
390 gboolean stop_on_sharedlib;
391
392 /* View for debugger messages */
393 IAnjutaMessageView* log;
394
395 /* User output callback */
396 IAnjutaDebuggerOutputCallback output_callback;
397 gpointer output_data;
398 };
399
400 struct _DmaDebuggerQueueClass {
401 GObjectClass parent;
402 };
403
404 /*
405 * Functions declaration
406 *---------------------------------------------------------------------------*/
407
408 gboolean
409 dma_queue_check_status (DmaDebuggerQueue *self, DmaDebuggerCommandType type, GError **err);
410
411 void
412 dma_queue_update_debugger_status (DmaDebuggerQueue *self, IAnjutaDebuggerStatus state, gint status);
413
414 /* Call backs
415 *---------------------------------------------------------------------------*/
416
417 static void
418 on_debugger_output (IAnjutaDebuggerOutputType type, const gchar *message, gpointer user_data)
419 {
420 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (user_data);
421
422 /* Call user call back if exist */
423 if (self->output_callback != NULL)
424 {
425 self->output_callback (type, message, self->output_data);
426 }
427 else
428 {
429 /* Default handling of debugger message */
430
431 switch (type)
432 {
433 case IANJUTA_DEBUGGER_OUTPUT:
434 dma_debugger_message (self, message);
435 break;
436 case IANJUTA_DEBUGGER_INFO_OUTPUT:
437 dma_debugger_info (self, message);
438 break;
439 case IANJUTA_DEBUGGER_WARNING_OUTPUT:
440 dma_debugger_warning (self, message);
441 break;
442 case IANJUTA_DEBUGGER_ERROR_OUTPUT:
443 dma_debugger_error (self, message);
444 break;
445 }
446 }
447 }
448
449 /* Queue function
450 *---------------------------------------------------------------------------*/
451
452 static void
453 dma_debugger_command_free (DmaQueueCommand *cmd)
454 {
455 switch (cmd->type & COMMAND_MASK)
456 {
457 case EMPTY_COMMAND:
458 case CALLBACK_COMMAND:
459 case INITIALIZE_COMMAND:
460 case UNLOAD_COMMAND:
461 case QUIT_COMMAND:
462 case ABORT_COMMAND:
463 case RUN_COMMAND:
464 case STEP_IN_COMMAND:
465 case STEP_OVER_COMMAND:
466 case STEP_OUT_COMMAND:
467 case RESTART_COMMAND:
468 case EXIT_COMMAND:
469 case INTERRUPT_COMMAND:
470 case ENABLE_BREAK_COMMAND:
471 case IGNORE_BREAK_COMMAND:
472 case REMOVE_BREAK_COMMAND:
473 break;
474 case LIST_LOCAL_COMMAND:
475 case LIST_ARG_COMMAND:
476 case INFO_THREAD_COMMAND:
477 case LIST_THREAD_COMMAND:
478 case SET_THREAD_COMMAND:
479 case INFO_SIGNAL_COMMAND:
480 case INFO_SHAREDLIB_COMMAND:
481 case INFO_FRAME_COMMAND:
482 case INFO_ARGS_COMMAND:
483 case INFO_TARGET_COMMAND:
484 case INFO_PROGRAM_COMMAND:
485 case INFO_UDOT_COMMAND:
486 case INFO_VARIABLES_COMMAND:
487 case LIST_REGISTER_COMMAND:
488 case UPDATE_REGISTER_COMMAND:
489 break;
490 case SET_FRAME_COMMAND:
491 case LIST_FRAME_COMMAND:
492 case INSPECT_MEMORY_COMMAND:
493 case DISASSEMBLE_COMMAND:
494 break;
495 case INSPECT_COMMAND:
496 case EVALUATE_COMMAND:
497 case WRITE_REGISTER_COMMAND:
498 if (cmd->data.watch.name != NULL) g_free (cmd->data.watch.name);
499 if (cmd->data.watch.value != NULL) g_free (cmd->data.watch.value);
500 break;
501 case START_COMMAND:
502 if (cmd->data.start.args) g_free (cmd->data.start.args);
503 break;
504 case LOAD_COMMAND:
505 if (cmd->data.load.file) g_free (cmd->data.load.file);
506 if (cmd->data.load.type) g_free (cmd->data.load.type);
507 g_list_foreach (cmd->data.load.dirs, (GFunc)g_free, NULL);
508 g_list_free (cmd->data.load.dirs);
509 break;
510 case ATTACH_COMMAND:
511 g_list_foreach (cmd->data.attach.dirs, (GFunc)g_free, NULL);
512 g_list_free (cmd->data.attach.dirs);
513 break;
514 case RUN_TO_COMMAND:
515 case BREAK_LINE_COMMAND:
516 case BREAK_FUNCTION_COMMAND:
517 case BREAK_ADDRESS_COMMAND:
518 if (cmd->data.pos.file) g_free (cmd->data.pos.file);
519 if (cmd->data.pos.function) g_free (cmd->data.pos.function);
520 break;
521 case CONDITION_BREAK_COMMAND:
522 if (cmd->data.brk.condition) g_free (cmd->data.brk.condition);
523 break;
524 case USER_COMMAND:
525 if (cmd->data.user.cmd) g_free (cmd->data.user.cmd);
526 break;
527 case PRINT_COMMAND:
528 if (cmd->data.print.var) g_free (cmd->data.print.var);
529 break;
530 case HANDLE_SIGNAL_COMMAND:
531 if (cmd->data.signal.name) g_free (cmd->data.signal.name);
532 break;
533 case DELETE_VARIABLE:
534 case ASSIGN_VARIABLE:
535 case CREATE_VARIABLE:
536 case EVALUATE_VARIABLE:
537 case LIST_VARIABLE_CHILDREN:
538 case UPDATE_VARIABLE:
539 if (cmd->data.var.name) g_free (cmd->data.var.name);
540 break;
541 }
542 }
543
544 static void
545 dma_debugger_command_cancel (DmaQueueCommand *cmd)
546 {
547 GError *err = g_error_new_literal (IANJUTA_DEBUGGER_ERROR , IANJUTA_DEBUGGER_CANCEL, "Command cancel");
548
549 if (cmd->callback != NULL)
550 {
551 cmd->callback (NULL, cmd->user_data, err);
552 }
553 g_warning ("Cancel command %x\n", cmd->type);
554
555 g_error_free (err);
556 dma_debugger_command_free (cmd);
557 }
558
559 static void
560 dma_queue_cancel (DmaDebuggerQueue *self, guint flag)
561 {
562 DmaQueueCommand* cmd;
563 DmaQueueCommand* prev = self->head;
564
565 /* Cancel all commands after head */
566 for (cmd = prev->next; cmd != NULL;)
567 {
568 if (cmd->type & flag)
569 {
570 DmaQueueCommand* tmp = cmd;
571
572 cmd = cmd->next;
573 dma_debugger_command_cancel (tmp);
574 prev->next = cmd;
575 }
576 else
577 {
578 prev = cmd;
579 cmd = cmd->next;
580 }
581 }
582
583 self->tail = prev;
584 }
585
586 /* Cancel all commands those cannot handle this unexpected state
587 * Return TRUE if the state of the queue need to be changed too
588 */
589
590 static gboolean
591 dma_queue_cancel_unexpected (DmaDebuggerQueue *self, guint state)
592 {
593 DmaQueueCommand* cmd;
594 DmaQueueCommand* prev;
595
596 /* Check if queue is empty */
597 if (self->head)
598 {
599 if (self->ready == FALSE)
600 {
601 /* Current command is still in queue, keep it */
602 prev = self->head;
603 cmd = prev->next;
604
605 if (prev->type & CHANGE_STATE)
606 {
607 return FALSE;
608 }
609 }
610 else
611 {
612 /* First command hasn't been send yet, can be cancelled */
613 prev = NULL;
614 cmd = self->head;
615 }
616
617 for (; cmd != NULL;)
618 {
619 if (!(cmd->type & state))
620 {
621 /* Command is not allowed in this state, cancel it */
622 DmaQueueCommand* tmp = cmd;
623
624 cmd = cmd->next;
625 dma_debugger_command_cancel (tmp);
626 if (prev == NULL)
627 {
628 self->head = cmd;
629 }
630 else
631 {
632 prev->next = cmd;
633 }
634 }
635 else if (cmd->type & CHANGE_STATE)
636 {
637 /* A command setting the state is kept,
638 debugger state is known again afterward, queue state is kept too */
639
640 return FALSE;
641 }
642 else
643 {
644 /* Command is allowed even in this unexpected state, keep it */
645 prev = cmd;
646 cmd = cmd->next;
647 }
648 }
649 /* Update end of queue if necessary, queue state need to be changed */
650 self->tail = prev;
651 }
652
653
654 return TRUE;
655 }
656
657 static void
658 dma_debugger_queue_remove (DmaDebuggerQueue *self)
659 {
660 DmaQueueCommand* cmd;
661
662 if (self->head != NULL)
663 {
664 cmd = self->head->next;
665 dma_debugger_command_free (self->head);
666 g_free (self->head);
667 self->head = cmd;
668 if (cmd == NULL)
669 {
670 self->tail = NULL;
671 /* Queue is empty so has the same status than debugger */
672 self->queue_status = self->debugger_status;
673 }
674 }
675 }
676
677 static void
678 dma_debugger_end_command (DmaDebuggerQueue *self)
679 {
680 if (self->ready == FALSE)
681 {
682 dma_debugger_queue_remove (self);
683 self->ready = TRUE;
684 }
685 }
686
687 #if 0
688 /* Avoid passing a NULL argument to ianjuter_debugger_initialize */
689 static void
690 null_function(void)
691 {
692 return;
693 }
694 #endif
695
696 gboolean
697 dma_queue_check_status (DmaDebuggerQueue *self, DmaDebuggerCommandType type, GError **err)
698 {
699 for (;;)
700 {
701 switch (self->queue_command ? self->queue_status : self->debugger_status)
702 {
703 case IANJUTA_DEBUGGER_BUSY:
704 /* Only the debugger can be busy */
705 g_return_val_if_reached (FALSE);
706 case IANJUTA_DEBUGGER_STOPPED:
707 if (type & NEED_DEBUGGER_STOPPED)
708 {
709 /* State is right */
710 return TRUE;
711 }
712 else if (type & STOP_DEBUGGER)
713 {
714 /* Already stopped */
715 g_warning ("Cancel command %x, already stop\n", type);
716 return FALSE;
717 }
718 else
719 {
720 /* Other command need a program loaded, cannot be done automatically */
721 g_warning ("Cancel command %x, debugger stopped\n", type);
722 return FALSE;
723 }
724 case IANJUTA_DEBUGGER_STARTED:
725 if (type & NEED_DEBUGGER_STARTED)
726 {
727 /* State is right */
728 return TRUE;
729 }
730 else if (type & START_DEBUGGER)
731 {
732 /* Already started */
733 g_warning ("Cancel command %x, already started\n", type);
734 return FALSE;
735 }
736 else
737 {
738 /* Other command need a program loaded, cannot be done automatically */
739 g_warning ("Cancel command %x, debugger started\n", type);
740 return FALSE;
741 }
742 case IANJUTA_DEBUGGER_PROGRAM_LOADED:
743 if (type & NEED_PROGRAM_LOADED)
744 {
745 /* State is right */
746 return TRUE;
747 }
748 else
749 {
750 /* Other command need a program running, cannot be done automatically */
751 g_warning ("Cancel command %x, program loaded\n", type);
752 return FALSE;
753 }
754 case IANJUTA_DEBUGGER_PROGRAM_STOPPED:
755 if (type & NEED_PROGRAM_STOPPED)
756 {
757 /* State is right */
758 return TRUE;
759 }
760 else
761 {
762 /* Other command need a program running, cannot be done automatically */
763 g_warning ("Cancel command %x, program stopped\n", type);
764 return FALSE;
765 }
766 case IANJUTA_DEBUGGER_PROGRAM_RUNNING:
767 if (type & NEED_PROGRAM_RUNNING)
768 {
769 /* State is right */
770 return TRUE;
771 }
772 else
773 {
774 /* Other command need a program stopped, cannot be done automatically */
775 g_warning ("Cancel command %x, program running\n", type);
776 return TRUE;
777 }
778 }
779 }
780 }
781
782
783 static void
784 dma_queue_update_queue_status (DmaDebuggerQueue *self, DmaDebuggerCommandType type)
785 {
786 if (type & STOP_DEBUGGER)
787 {
788 self->queue_status = IANJUTA_DEBUGGER_STOPPED;
789 }
790 else if (type & START_DEBUGGER)
791 {
792 self->queue_status = IANJUTA_DEBUGGER_STARTED;
793 }
794 else if (type & LOAD_PROGRAM)
795 {
796 self->queue_status = IANJUTA_DEBUGGER_PROGRAM_LOADED;
797 }
798 else if (type & STOP_PROGRAM)
799 {
800 self->queue_status = IANJUTA_DEBUGGER_PROGRAM_STOPPED;
801 }
802 else if (type & RUN_PROGRAM)
803 {
804 self->queue_status = IANJUTA_DEBUGGER_PROGRAM_RUNNING;
805 dma_queue_cancel (self, CANCEL_IF_PROGRAM_RUNNING);
806 }
807 }
808
809 static void
810 dma_queue_emit_debugger_ready (DmaDebuggerQueue *queue)
811 {
812 IAnjutaDebuggerStatus stat;
813 static gboolean busy = FALSE;
814
815 if ((queue->head == NULL) && (queue->ready))
816 {
817 stat = queue->queue_status;
818 busy = FALSE;
819 }
820 else if (busy)
821 {
822 /* Busy signal already emitted, do nothing */
823 return;
824 }
825 else
826 {
827 stat = IANJUTA_DEBUGGER_BUSY;
828 busy = TRUE;
829 }
830
831 g_signal_emit_by_name (queue, "debugger-ready", stat);
832 }
833
834 void
835 dma_queue_update_debugger_status (DmaDebuggerQueue *self, IAnjutaDebuggerStatus state, gint status)
836 {
837 const char* signal = NULL;
838
839 self->queue_command = FALSE;
840 switch (state)
841 {
842 case IANJUTA_DEBUGGER_BUSY:
843 /* Debugger is busy, nothing to do */
844 self->queue_command = TRUE;
845 return;
846 case IANJUTA_DEBUGGER_STOPPED:
847 if (self->debugger_status != IANJUTA_DEBUGGER_STOPPED)
848 {
849 if (!(self->last & STOP_DEBUGGER))
850 {
851 if (dma_queue_cancel_unexpected (self, NEED_DEBUGGER_STOPPED))
852 {
853 self->queue_status = IANJUTA_DEBUGGER_STOPPED;
854 }
855 }
856 self->debugger_status = IANJUTA_DEBUGGER_STOPPED;
857 signal = "debugger-stopped";
858 }
859 break;
860 case IANJUTA_DEBUGGER_STARTED:
861 if (self->debugger_status != IANJUTA_DEBUGGER_STARTED)
862 {
863 if (!(self->last & START_DEBUGGER))
864 {
865 if (dma_queue_cancel_unexpected (self, NEED_DEBUGGER_STARTED))
866 {
867 self->queue_status = IANJUTA_DEBUGGER_STARTED;
868 }
869 }
870 self->debugger_status = IANJUTA_DEBUGGER_STARTED;
871 signal = "debugger-started";
872 }
873 break;
874 case IANJUTA_DEBUGGER_PROGRAM_LOADED:
875 if (self->debugger_status != IANJUTA_DEBUGGER_PROGRAM_LOADED)
876 {
877 if (!(self->last & LOAD_PROGRAM))
878 {
879 if (dma_queue_cancel_unexpected (self, NEED_PROGRAM_LOADED))
880 {
881 self->queue_status = IANJUTA_DEBUGGER_PROGRAM_LOADED;
882 }
883 }
884 if (self->debugger_status == IANJUTA_DEBUGGER_STOPPED)
885 {
886 dma_debugger_end_command (self);
887 self->debugger_status = IANJUTA_DEBUGGER_STARTED;
888 g_signal_emit_by_name (self, "debugger-started");
889 }
890 self->debugger_status = IANJUTA_DEBUGGER_PROGRAM_LOADED;
891 self->stop_on_sharedlib = FALSE;
892 signal = "program-loaded";
893 }
894 break;
895 case IANJUTA_DEBUGGER_PROGRAM_STOPPED:
896 if (self->debugger_status != IANJUTA_DEBUGGER_PROGRAM_STOPPED)
897 {
898 if (!(self->last & STOP_PROGRAM))
899 {
900 if (dma_queue_cancel_unexpected (self, NEED_PROGRAM_STOPPED))
901 {
902 self->queue_status = IANJUTA_DEBUGGER_PROGRAM_STOPPED;
903 }
904 }
905 self->debugger_status = IANJUTA_DEBUGGER_PROGRAM_STOPPED;
906 if (!self->stop_on_sharedlib)
907 {
908 signal = "program-stopped";
909 }
910 }
911 break;
912 case IANJUTA_DEBUGGER_PROGRAM_RUNNING:
913 if (self->debugger_status != IANJUTA_DEBUGGER_PROGRAM_RUNNING)
914 {
915 if (!(self->last & RUN_PROGRAM))
916 {
917 if (dma_queue_cancel_unexpected (self, NEED_PROGRAM_RUNNING))
918 {
919 self->queue_status = IANJUTA_DEBUGGER_PROGRAM_RUNNING;
920 }
921 }
922 self->debugger_status = IANJUTA_DEBUGGER_PROGRAM_RUNNING;
923 self->stop_on_sharedlib = FALSE;
924 signal = "program-running";
925 }
926 break;
927 }
928
929 /* Remove current command */
930 dma_debugger_end_command (self);
931
932 /* Emit signal */
933 if (signal != NULL)
934 {
935 g_signal_emit_by_name (self, signal, status);
936 }
937 self->queue_command = TRUE;
938 }
939
940 static void
941 dma_debugger_queue_clear (DmaDebuggerQueue *self)
942 {
943 DmaQueueCommand* cmd;
944
945 for (cmd = self->head; cmd != NULL; )
946 {
947 cmd = cmd->next;
948 dma_debugger_command_free (self->head);
949 g_free (self->head);
950 self->head = cmd;
951 }
952 self->head = NULL;
953 self->tail = NULL;
954 self->queue_command = TRUE;
955
956 /* Queue is empty so has the same status than debugger */
957 self->queue_status = self->debugger_status;
958 }
959
960 static DmaQueueCommand*
961 dma_debugger_queue_append (DmaDebuggerQueue *self, DmaDebuggerCommandType type, GError **err)
962 {
963 DmaQueueCommand* cmd = NULL;
964
965
966 if (dma_queue_check_status(self, type, err))
967 {
968 cmd = g_new0 (DmaQueueCommand, 1);
969 cmd->type = type;
970
971 if (self->queue_command)
972 {
973 // Append command at the end (in the queue)
974
975 if (self->head == NULL)
976 {
977 /* queue is empty */
978 self->head = cmd;
979 }
980 else
981 {
982 self->tail->next = cmd;
983 }
984 self->tail = cmd;
985
986 dma_queue_update_queue_status (self, type);
987 }
988 else
989 {
990 // Prepend command at the beginning
991 if (self->ready)
992 {
993 cmd->next = self->head;
994 self->head = cmd;
995 if (self->tail == NULL)
996 {
997 self->tail = cmd;
998 }
999 }
1000 else
1001 {
1002 cmd->next = self->head->next;
1003 self->head->next = cmd;
1004 if (self->tail == self->head)
1005 {
1006 self->tail = cmd;
1007 }
1008 }
1009 }
1010 }
1011
1012 return cmd;
1013 }
1014
1015 #if 0
1016 static DmaQueueCommand*
1017 dma_debugger_queue_prepend (DmaDebuggerQueue *self)
1018 {
1019 DmaQueueCommand* cmd;
1020
1021 cmd = g_new0 (DmaQueueCommand, 1);
1022 cmd->type = EMPTY_COMMAND;
1023 cmd->next = self->head;
1024 self->head = cmd;
1025
1026 if (self->head == NULL)
1027 {
1028 /* queue is empty */
1029 self->tail = cmd;
1030 }
1031
1032 return cmd;
1033 }
1034 #endif
1035
1036 static void
1037 dma_debugger_queue_execute (DmaDebuggerQueue *self)
1038 {
1039 IAnjutaDebuggerRegister reg;
1040 GError *err = NULL;
1041 gboolean ret;
1042
1043 /* Check if debugger is connected to a debugger backend */
1044 if (self->debugger == NULL) return;
1045
1046 /* Check if there debugger is busy */
1047 if (!self->ready)
1048 {
1049 IAnjutaDebuggerStatus status;
1050 /* Recheck status in case of desynchronization */
1051 status = ianjuta_debugger_get_status (self->debugger, NULL);
1052 dma_queue_update_debugger_status (self, status, 0);
1053 }
1054
1055 /* Check if there is something to execute */
1056 while ((self->head != NULL) && (self->ready))
1057 {
1058 DmaQueueCommand *cmd;
1059
1060 cmd = self->head;
1061
1062 DEBUG_PRINT("debugger cmd %x status %d\n", cmd->type, self->debugger_status);
1063
1064 /* Start command */
1065 self->ready = FALSE;
1066 self->last = cmd->type;
1067 switch (cmd->type & COMMAND_MASK)
1068 {
1069 case EMPTY_COMMAND:
1070 break;
1071 case CALLBACK_COMMAND:
1072 ianjuta_debugger_callback (self->debugger, cmd->callback, cmd->user_data, &err);
1073 break;
1074 case INITIALIZE_COMMAND:
1075 //dma_debugger_create_view (self);
1076 self->output_callback = (IAnjutaDebuggerOutputCallback)cmd->callback;
1077 self->output_data = cmd->user_data;
1078 ianjuta_debugger_initialize (self->debugger, on_debugger_output, self, &err);
1079 break;
1080 case LOAD_COMMAND:
1081 ianjuta_debugger_load (self->debugger, cmd->data.load.file, cmd->data.load.type, cmd->data.load.dirs, cmd->data.load.terminal, &err);
1082 break;
1083 case ATTACH_COMMAND:
1084 ianjuta_debugger_attach (self->debugger, cmd->data.attach.pid, cmd->data.load.dirs, &err);
1085 break;
1086 case UNLOAD_COMMAND:
1087 ianjuta_debugger_unload (self->debugger, &err);
1088 break;
1089 case QUIT_COMMAND:
1090 ret = ianjuta_debugger_quit (self->debugger, &err);
1091 break;
1092 case ABORT_COMMAND:
1093 ianjuta_debugger_abort (self->debugger, &err);
1094 break;
1095 case START_COMMAND:
1096 ianjuta_debugger_start (self->debugger, cmd->data.start.args, &err);
1097 break;
1098 case RUN_COMMAND:
1099 ianjuta_debugger_run (self->debugger, &err);
1100 break;
1101 case RUN_TO_COMMAND:
1102 ianjuta_debugger_run_to (self->debugger, cmd->data.pos.file, cmd->data.pos.line, &err);
1103 break;
1104 case STEP_IN_COMMAND:
1105 ianjuta_debugger_step_in (self->debugger, &err);
1106 break;
1107 case STEP_OVER_COMMAND:
1108 ianjuta_debugger_step_over (self->debugger, &err);
1109 break;
1110 case STEP_OUT_COMMAND:
1111 ianjuta_debugger_step_out (self->debugger, &err);
1112 break;
1113 case RESTART_COMMAND:
1114 //ianjuta_debugger_restart (self->debugger, &err);
1115 break;
1116 case EXIT_COMMAND:
1117 ianjuta_debugger_exit (self->debugger, &err);
1118 break;
1119 case INTERRUPT_COMMAND:
1120 ianjuta_debugger_interrupt (self->debugger, &err);
1121 break;
1122 case ENABLE_BREAK_COMMAND:
1123 ianjuta_debugger_enable_breakpoint (self->debugger, cmd->data.brk.id, cmd->data.brk.enable == IANJUTA_DEBUGGER_YES ? TRUE : FALSE, cmd->callback, cmd->user_data, &err);
1124 break;
1125 case IGNORE_BREAK_COMMAND:
1126 ianjuta_debugger_ignore_breakpoint (self->debugger, cmd->data.brk.id, cmd->data.brk.ignore, cmd->callback, cmd->user_data, &err);
1127 break;
1128 case REMOVE_BREAK_COMMAND:
1129 ianjuta_debugger_clear_breakpoint (self->debugger, cmd->data.brk.id, cmd->callback, cmd->user_data, &err);
1130 break;
1131 case INSPECT_COMMAND:
1132 ianjuta_debugger_inspect (self->debugger, cmd->data.watch.name, cmd->callback, cmd->user_data, &err);
1133 break;
1134 case EVALUATE_COMMAND:
1135 ianjuta_debugger_evaluate (self->debugger, cmd->data.watch.name, cmd->data.watch.value, cmd->callback, cmd->user_data, &err);
1136 break;
1137 case LIST_LOCAL_COMMAND:
1138 ianjuta_debugger_list_local (self->debugger, cmd->callback, cmd->user_data, &err);
1139 break;
1140 case LIST_ARG_COMMAND:
1141 ianjuta_debugger_list_argument (self->debugger, cmd->callback, cmd->user_data, &err);
1142 break;
1143 case LIST_THREAD_COMMAND:
1144 ianjuta_debugger_list_thread (self->debugger, cmd->callback, cmd->user_data, &err);
1145 break;
1146 case SET_THREAD_COMMAND:
1147 ianjuta_debugger_set_thread (self->debugger, cmd->data.frame.frame, &err);
1148 break;
1149 case INFO_THREAD_COMMAND:
1150 ianjuta_debugger_info_thread (self->debugger, cmd->data.info.id, cmd->callback, cmd->user_data, &err);
1151 break;
1152 case INFO_SIGNAL_COMMAND:
1153 ianjuta_debugger_info_signal (self->debugger, cmd->callback, cmd->user_data, &err);
1154 break;
1155 case INFO_SHAREDLIB_COMMAND:
1156 ianjuta_debugger_info_sharedlib (self->debugger, cmd->callback, cmd->user_data, &err);
1157 break;
1158 case INFO_FRAME_COMMAND:
1159 ianjuta_debugger_info_frame (self->debugger, 0, cmd->callback, cmd->user_data, &err);
1160 break;
1161 case INFO_ARGS_COMMAND:
1162 ianjuta_debugger_info_args (self->debugger, cmd->callback, cmd->user_data, &err);
1163 break;
1164 case INFO_TARGET_COMMAND:
1165 ianjuta_debugger_info_target (self->debugger, cmd->callback, cmd->user_data, &err);
1166 break;
1167 case INFO_PROGRAM_COMMAND:
1168 ianjuta_debugger_info_program (self->debugger, cmd->callback, cmd->user_data, &err);
1169 break;
1170 case INFO_UDOT_COMMAND:
1171 ianjuta_debugger_info_udot (self->debugger, cmd->callback, cmd->user_data, &err);
1172 break;
1173 case INFO_VARIABLES_COMMAND:
1174 ianjuta_debugger_info_variables (self->debugger, cmd->callback, cmd->user_data, &err);
1175 break;
1176 case SET_FRAME_COMMAND:
1177 ianjuta_debugger_set_frame (self->debugger, cmd->data.frame.frame, &err);
1178 break;
1179 case LIST_FRAME_COMMAND:
1180 ianjuta_debugger_list_frame (self->debugger, cmd->callback, cmd->user_data, &err);
1181 break;
1182 case LIST_REGISTER_COMMAND:
1183 ianjuta_cpu_debugger_list_register (self->cpu_debugger, cmd->callback, cmd->user_data, &err);
1184 break;
1185 case UPDATE_REGISTER_COMMAND:
1186 ianjuta_cpu_debugger_update_register (self->cpu_debugger, cmd->callback, cmd->user_data, &err);
1187 break;
1188 case WRITE_REGISTER_COMMAND:
1189 reg.num = cmd->data.watch.id;
1190 reg.name = cmd->data.watch.name;
1191 reg.value = cmd->data.watch.value;
1192 ianjuta_cpu_debugger_write_register (self->cpu_debugger, &reg, &err);
1193 break;
1194 case INSPECT_MEMORY_COMMAND:
1195 ianjuta_cpu_debugger_inspect_memory (self->cpu_debugger, cmd->data.mem.address, cmd->data.mem.length, cmd->callback, cmd->user_data, &err);
1196 break;
1197 case DISASSEMBLE_COMMAND:
1198 ianjuta_cpu_debugger_disassemble (self->cpu_debugger, cmd->data.mem.address, cmd->data.mem.length, cmd->callback, cmd->user_data, &err);
1199 break;
1200 case BREAK_LINE_COMMAND:
1201 ianjuta_debugger_set_breakpoint_at_line (self->debugger, cmd->data.pos.file, cmd->data.pos.line, cmd->callback, cmd->user_data, &err);
1202 break;
1203 case BREAK_FUNCTION_COMMAND:
1204 ianjuta_debugger_set_breakpoint_at_function (self->debugger, cmd->data.pos.file, cmd->data.pos.function, cmd->callback, cmd->user_data, &err);
1205 break;
1206 case BREAK_ADDRESS_COMMAND:
1207 ianjuta_debugger_set_breakpoint_at_address (self->debugger, cmd->data.pos.address, cmd->callback, cmd->user_data, &err);
1208 break;
1209 case CONDITION_BREAK_COMMAND:
1210 ianjuta_debugger_condition_breakpoint (self->debugger, cmd->data.brk.id, cmd->data.brk.condition, cmd->callback, cmd->user_data, &err);
1211 break;
1212 case USER_COMMAND:
1213 ianjuta_debugger_send_command (self->debugger, cmd->data.user.cmd, &err);
1214 break;
1215 case PRINT_COMMAND:
1216 ianjuta_debugger_print (self->debugger, cmd->data.print.var, cmd->callback, cmd->user_data, &err);
1217 break;
1218 case HANDLE_SIGNAL_COMMAND:
1219 ianjuta_debugger_handle_signal (self->debugger, cmd->data.signal.name, cmd->data.signal.stop, cmd->data.signal.print, cmd->data.signal.ignore, &err);
1220 break;
1221 case DELETE_VARIABLE:
1222 ianjuta_variable_debugger_delete_var (IANJUTA_VARIABLE_DEBUGGER (self->debugger), cmd->data.var.name, NULL);
1223 break;
1224 case ASSIGN_VARIABLE:
1225 ianjuta_variable_debugger_assign (IANJUTA_VARIABLE_DEBUGGER (self->debugger), cmd->data.var.name, cmd->data.var.value, &err);
1226 break;
1227 case EVALUATE_VARIABLE:
1228 ianjuta_variable_debugger_evaluate (IANJUTA_VARIABLE_DEBUGGER (self->debugger), cmd->data.var.name, cmd->callback, cmd->user_data, &err);
1229 break;
1230 case LIST_VARIABLE_CHILDREN:
1231 ianjuta_variable_debugger_list_children (IANJUTA_VARIABLE_DEBUGGER (self->debugger), cmd->data.var.name, cmd->callback, cmd->user_data, &err);
1232 break;
1233 case CREATE_VARIABLE:
1234 ianjuta_variable_debugger_create (IANJUTA_VARIABLE_DEBUGGER (self->debugger), cmd->data.var.name, cmd->callback, cmd->user_data, &err);
1235 break;
1236 case UPDATE_VARIABLE:
1237 ianjuta_variable_debugger_update (IANJUTA_VARIABLE_DEBUGGER (self->debugger), cmd->callback, cmd->user_data, &err);
1238 break;
1239 }
1240
1241 if (err != NULL)
1242 {
1243 /* Something fail */
1244 gboolean cancel_state = cmd->type & CHANGE_STATE;
1245
1246 /* Cancel command */
1247 self->head = cmd->next;
1248 dma_debugger_command_cancel (cmd);
1249 self->ready = TRUE;
1250
1251 /* If a command changing a state has been cancelled,
1252 * cancel invalidate commands too */
1253 if (cancel_state)
1254 {
1255 /* State change doesn't happen cancel all commands
1256 those cannot handle this */
1257 if (dma_queue_cancel_unexpected (self, self->debugger_status))
1258 {
1259 self->queue_status = self->debugger_status;
1260 }
1261 }
1262
1263 g_error_free (err);
1264 }
1265 }
1266 dma_queue_emit_debugger_ready (self);
1267 }
1268
1269 /* Public message functions
1270 *---------------------------------------------------------------------------*/
1271
1272 void
1273 dma_debugger_message (DmaDebuggerQueue *self, const gchar* message)
1274 {
1275 // dma_debugger_print_message (self, IANJUTA_MESSAGE_VIEW_TYPE_NORMAL, message);
1276 }
1277
1278 void
1279 dma_debugger_info (DmaDebuggerQueue *self, const gchar* message)
1280 {
1281 // dma_debugger_print_message (self, IANJUTA_MESSAGE_VIEW_TYPE_INFO, message);
1282 }
1283
1284 void dma_debugger_warning (DmaDebuggerQueue *self, const gchar* message)
1285 {
1286 // dma_debugger_print_message (self, IANJUTA_MESSAGE_VIEW_TYPE_WARNING, message);
1287 }
1288
1289 void dma_debugger_error (DmaDebuggerQueue *self, const gchar* message)
1290 {
1291 // dma_debugger_print_message (self, IANJUTA_MESSAGE_VIEW_TYPE_ERROR, message);
1292 }
1293
1294 /* IAnjutaDebugger callback
1295 *---------------------------------------------------------------------------*/
1296
1297 static void
1298 on_dma_debugger_ready (DmaDebuggerQueue *self, IAnjutaDebuggerStatus status)
1299 {
1300 DEBUG_PRINT ("From debugger: receive debugger ready");
1301 dma_queue_update_debugger_status (self, status, 0);
1302 if (self->ready) dma_debugger_queue_execute (self);
1303 }
1304
1305 static void
1306 on_dma_debugger_started (DmaDebuggerQueue *self)
1307 {
1308 /* Nothing do to */
1309 DEBUG_PRINT ("From debugger: receive debugger started");
1310 dma_queue_update_debugger_status (self, IANJUTA_DEBUGGER_STARTED, 0);
1311 if (self->ready) dma_debugger_queue_execute (self);
1312 }
1313
1314 static void
1315 on_dma_debugger_stopped (DmaDebuggerQueue *self, gint status)
1316 {
1317 DEBUG_PRINT ("From debugger: receive debugger stopped");
1318 dma_queue_update_debugger_status (self, IANJUTA_DEBUGGER_STOPPED, status);
1319 if (self->ready) dma_debugger_queue_execute (self);
1320 }
1321
1322 static void
1323 on_dma_program_loaded (DmaDebuggerQueue *self)
1324 {
1325 DEBUG_PRINT ("From debugger: receive program loaded");
1326 dma_queue_update_debugger_status (self, IANJUTA_DEBUGGER_PROGRAM_LOADED, 0);
1327 if (self->ready) dma_debugger_queue_execute (self);
1328 }
1329
1330 static void
1331 on_dma_program_running (DmaDebuggerQueue *self)
1332 {
1333 DEBUG_PRINT ("From debugger: debugger_program_running");
1334 dma_queue_update_debugger_status (self, IANJUTA_DEBUGGER_PROGRAM_RUNNING, 0);
1335 }
1336
1337 static void
1338 on_dma_program_stopped (DmaDebuggerQueue *self, guint thread)
1339 {
1340 DEBUG_PRINT ("From debugger: receive program stopped");
1341 dma_queue_update_debugger_status (self, IANJUTA_DEBUGGER_PROGRAM_STOPPED, thread);
1342 if (self->ready) dma_debugger_queue_execute (self);
1343 }
1344
1345 static void
1346 on_dma_program_exited (DmaDebuggerQueue *self)
1347 {
1348 DEBUG_PRINT ("From debugger: receive program exited");
1349 dma_queue_update_debugger_status (self, IANJUTA_DEBUGGER_PROGRAM_LOADED, 0);
1350 if (self->ready) dma_debugger_queue_execute (self);
1351 }
1352
1353 static void
1354 on_dma_location_changed (DmaDebuggerQueue *self, const gchar* src_path, guint line, guint address)
1355 {
1356 DEBUG_PRINT ("From debugger: location changed");
1357 g_signal_emit_by_name (self, "location-changed", src_path, line, address);
1358 }
1359
1360 static void
1361 on_dma_frame_changed (DmaDebuggerQueue *self, guint frame, guint thread)
1362 {
1363 DEBUG_PRINT ("From debugger: frame changed");
1364 g_signal_emit_by_name (self, "frame-changed", frame, thread);
1365 }
1366
1367 static void
1368 on_dma_signal_received (DmaDebuggerQueue *self, const gchar* name, const gchar* description)
1369 {
1370 DEBUG_PRINT ("From debugger: signal received");
1371 g_signal_emit_by_name (self, "signal-received", name, description);
1372 }
1373
1374 static void
1375 on_dma_sharedlib_event (DmaDebuggerQueue *self)
1376 {
1377 DEBUG_PRINT ("From debugger: shared lib event");
1378 self->stop_on_sharedlib = TRUE;
1379 dma_queue_update_debugger_status (self, IANJUTA_DEBUGGER_PROGRAM_STOPPED, 0);
1380 g_signal_emit_by_name (self, "sharedlib-event");
1381 ianjuta_debugger_run (IANJUTA_DEBUGGER (self), NULL);
1382 }
1383
1384 /* Connect/Disconnect function
1385 *---------------------------------------------------------------------------*/
1386
1387 static gboolean
1388 dma_debugger_activate_plugin (DmaDebuggerQueue* self, const gchar *mime_type)
1389 {
1390 AnjutaPluginManager *plugin_manager;
1391 AnjutaPluginDescription *plugin;
1392 GList *descs = NULL;
1393 gchar *value;
1394 gchar **interface_list;
1395 gchar **interface;
1396
1397 /* Get list of debugger plugins */
1398 plugin_manager = anjuta_shell_get_plugin_manager (ANJUTA_PLUGIN(self->plugin)->shell, NULL);
1399 descs = anjuta_plugin_manager_query (plugin_manager,
1400 "Anjuta Plugin","Interfaces", "IAnjutaDebugger",
1401 "File Loader", "SupportedMimeTypes", mime_type,
1402 NULL);
1403
1404 if (descs == NULL)
1405 {
1406 /* No plugin found */
1407 anjuta_util_dialog_error (GTK_WINDOW (ANJUTA_PLUGIN (self->plugin)->shell),
1408 _("Unable to find one debugger plugin acception %s mime type"), mime_type);
1409
1410 return FALSE;
1411 }
1412 else if (g_list_length (descs) == 1)
1413 {
1414 /* Only one plugin found, use it */
1415 plugin = (AnjutaPluginDescription *)descs->data;
1416 }
1417 else
1418 {
1419 /* Ask the user to select one plugin */
1420 plugin = anjuta_plugin_manager_select (plugin_manager,
1421 _("Select a plugin"),
1422 _("Please select a plugin to activate"),
1423 descs);
1424 }
1425
1426 if (plugin == NULL)
1427 {
1428 /* No plugin selected */
1429
1430 return FALSE;
1431 }
1432
1433 /* Get debugger location */
1434 value = NULL;
1435 anjuta_plugin_description_get_string (plugin, "Anjuta Plugin", "Location", &value);
1436 g_return_val_if_fail (value != NULL, FALSE);
1437
1438 /* Get debugger interface */
1439 self->debugger = (IAnjutaDebugger *)anjuta_plugin_manager_get_plugin_by_id (plugin_manager, value);
1440 g_free (value);
1441
1442 /* Get cpu debugger interface if available */
1443 if (IANJUTA_IS_CPU_DEBUGGER (self->debugger))
1444 {
1445 self->cpu_debugger = IANJUTA_CPU_DEBUGGER (self->debugger);
1446 }
1447
1448 return TRUE;
1449 }
1450
1451 static void
1452 dma_debugger_disconnect (DmaDebuggerQueue *self)
1453 {
1454 /* Disconnect signal */
1455 if (self->debugger)
1456 {
1457 g_signal_handlers_disconnect_by_func (self->debugger, G_CALLBACK (on_dma_debugger_ready), self);
1458 g_signal_handlers_disconnect_by_func (self->debugger, G_CALLBACK (on_dma_debugger_started), self);
1459 g_signal_handlers_disconnect_by_func (self->debugger, G_CALLBACK (on_dma_debugger_stopped), self);
1460 g_signal_handlers_disconnect_by_func (self->debugger, G_CALLBACK (on_dma_program_loaded), self);
1461 g_signal_handlers_disconnect_by_func (self->debugger, G_CALLBACK (on_dma_program_running), self);
1462 g_signal_handlers_disconnect_by_func (self->debugger, G_CALLBACK (on_dma_program_stopped), self);
1463 g_signal_handlers_disconnect_by_func (self->debugger, G_CALLBACK (on_dma_program_exited), self);
1464 g_signal_handlers_disconnect_by_func (self->debugger, G_CALLBACK (on_dma_location_changed), self);
1465 g_signal_handlers_disconnect_by_func (self->debugger, G_CALLBACK (on_dma_sharedlib_event), self);
1466 self->debugger = NULL;
1467 }
1468 }
1469
1470 static gboolean
1471 dma_debugger_connect (DmaDebuggerQueue *self, const gchar *mime_type)
1472 {
1473 dma_debugger_disconnect (self);
1474
1475 /* Look for a debugger supporting mime_type */
1476 if (!dma_debugger_activate_plugin (self, mime_type))
1477 {
1478
1479
1480 return FALSE;
1481 }
1482
1483 if (self->debugger)
1484 {
1485 /* Connect signal */
1486 g_signal_connect_swapped (self->debugger, "debugger-ready", G_CALLBACK (on_dma_debugger_ready), self);
1487 g_signal_connect_swapped (self->debugger, "debugger-started", G_CALLBACK (on_dma_debugger_started), self);
1488 g_signal_connect_swapped (self->debugger, "debugger-stopped", G_CALLBACK (on_dma_debugger_stopped), self);
1489 g_signal_connect_swapped (self->debugger, "program-loaded", G_CALLBACK (on_dma_program_loaded), self);
1490 g_signal_connect_swapped (self->debugger, "program-running", G_CALLBACK (on_dma_program_running), self);
1491 g_signal_connect_swapped (self->debugger, "program-stopped", G_CALLBACK (on_dma_program_stopped), self);
1492 g_signal_connect_swapped (self->debugger, "program-exited", G_CALLBACK (on_dma_program_exited), self);
1493 g_signal_connect_swapped (self->debugger, "location-changed", G_CALLBACK (on_dma_location_changed), self);
1494 g_signal_connect_swapped (self->debugger, "signal-received", G_CALLBACK (on_dma_signal_received), self);
1495 g_signal_connect_swapped (self->debugger, "frame-changed", G_CALLBACK (on_dma_frame_changed), self);
1496 g_signal_connect_swapped (self->debugger, "sharedlib-event", G_CALLBACK (on_dma_sharedlib_event), self);
1497
1498 if (self->log == NULL)
1499 {
1500 ianjuta_debugger_disable_log (self->debugger, NULL);
1501 }
1502 else
1503 {
1504 ianjuta_debugger_enable_log (self->debugger, self->log, NULL);
1505 }
1506 }
1507
1508 return self->debugger != NULL;
1509 }
1510
1511 /* Implementation of IAnjutaDebugger interface
1512 *---------------------------------------------------------------------------*/
1513
1514 static IAnjutaDebuggerStatus
1515 idebugger_get_status (IAnjutaDebugger *iface, GError **err)
1516 {
1517 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1518
1519 return self->queue_status;
1520 }
1521
1522 static gboolean
1523 idebugger_initialize (IAnjutaDebugger *iface, IAnjutaDebuggerOutputCallback callback, gpointer user_data, GError **err)
1524 {
1525 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1526 DmaQueueCommand *cmd;
1527
1528 cmd = dma_debugger_queue_append (self, DMA_INITIALIZE_COMMAND, err);
1529 if (cmd == NULL) return FALSE;
1530
1531 cmd->callback = (IAnjutaDebuggerCallback)callback;
1532 cmd->user_data = user_data;
1533 dma_debugger_queue_execute (self);
1534
1535 return TRUE;
1536 }
1537
1538 static gboolean
1539 idebugger_load (IAnjutaDebugger *iface, const gchar *file, const gchar* mime_type,
1540 const GList *search_dirs, gboolean terminal, GError **err)
1541 {
1542 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1543 DmaQueueCommand *cmd;
1544 const GList *node;
1545
1546 if (!dma_debugger_connect (self, mime_type)) return FALSE;
1547
1548 cmd = dma_debugger_queue_append (self, DMA_LOAD_COMMAND, err);
1549 if (cmd == NULL) return FALSE;
1550
1551 cmd->data.load.file = g_strdup (file);
1552 cmd->data.load.type = g_strdup (mime_type);
1553 cmd->data.load.dirs = NULL;
1554 cmd->data.load.terminal = terminal;
1555 for (node = search_dirs; node != NULL; node = g_list_next (node))
1556 {
1557 cmd->data.load.dirs = g_list_prepend (cmd->data.load.dirs, g_strdup (node->data));
1558 }
1559 cmd->data.load.dirs = g_list_reverse (cmd->data.load.dirs);
1560
1561 dma_debugger_queue_execute (self);
1562
1563 return TRUE;
1564 }
1565
1566 static gboolean
1567 idebugger_attach (IAnjutaDebugger *iface, pid_t pid, const GList *search_dirs, GError **err)
1568 {
1569 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1570 DmaQueueCommand *cmd;
1571 const GList *node;
1572
1573 if (!dma_debugger_connect (self, NULL)) return FALSE;
1574
1575 cmd = dma_debugger_queue_append (self, DMA_ATTACH_COMMAND, err);
1576 if (cmd == NULL) return FALSE;
1577
1578 cmd->data.attach.pid = pid;
1579 cmd->data.attach.dirs = NULL;
1580 for (node = search_dirs; node != NULL; node = g_list_next (node))
1581 {
1582 cmd->data.attach.dirs = g_list_prepend (cmd->data.attach.dirs, g_strdup (node->data));
1583 }
1584 cmd->data.attach.dirs = g_list_reverse (cmd->data.attach.dirs);
1585
1586 dma_debugger_queue_execute (self);
1587
1588 return TRUE;
1589 }
1590
1591 static gboolean
1592 idebugger_start (IAnjutaDebugger *iface, const gchar *args, GError **err)
1593 {
1594 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1595 DmaQueueCommand *cmd;
1596
1597 cmd = dma_debugger_queue_append (self, DMA_START_COMMAND, err);
1598 if (cmd == NULL) return FALSE;
1599
1600 cmd->data.start.args = args == NULL ? NULL : g_strdup (args);
1601 dma_debugger_queue_execute (self);
1602
1603 return TRUE;
1604 }
1605
1606 static gboolean
1607 idebugger_unload (IAnjutaDebugger *iface, GError **err)
1608 {
1609 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1610 DmaQueueCommand *cmd;
1611
1612 cmd = dma_debugger_queue_append (self, DMA_UNLOAD_COMMAND, err);
1613 if (cmd == NULL) return FALSE;
1614
1615 dma_debugger_queue_execute (self);
1616
1617 return TRUE;
1618 }
1619
1620 static gboolean
1621 idebugger_quit (IAnjutaDebugger *iface, GError **err)
1622 {
1623 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1624 DmaQueueCommand *cmd;
1625
1626 cmd = dma_debugger_queue_append (self, DMA_QUIT_COMMAND, err);
1627 if (cmd == NULL) return FALSE;
1628
1629 dma_debugger_queue_execute (self);
1630
1631 return TRUE;
1632 }
1633
1634 static gboolean
1635 idebugger_abort (IAnjutaDebugger *iface, GError **err)
1636 {
1637 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1638 DmaQueueCommand *cmd;
1639
1640 cmd = dma_debugger_queue_append (self, DMA_ABORT_COMMAND, err);
1641 if (cmd == NULL) return FALSE;
1642
1643 dma_debugger_queue_execute (self);
1644
1645 return TRUE;
1646 }
1647
1648 static gboolean
1649 idebugger_run (IAnjutaDebugger *iface, GError **err)
1650 {
1651 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1652 DmaQueueCommand *cmd;
1653
1654 cmd = dma_debugger_queue_append (self, DMA_RUN_COMMAND, err);
1655 if (cmd == NULL) return FALSE;
1656
1657 dma_debugger_queue_execute (self);
1658
1659 return TRUE;
1660 }
1661
1662 static gboolean
1663 idebugger_step_in (IAnjutaDebugger *iface, GError **err)
1664 {
1665 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1666 DmaQueueCommand *cmd;
1667
1668 cmd = dma_debugger_queue_append (self, DMA_STEP_IN_COMMAND, err);
1669 if (cmd == NULL) return FALSE;
1670
1671 dma_debugger_queue_execute (self);
1672
1673 return TRUE;
1674 }
1675
1676 static gboolean
1677 idebugger_step_over (IAnjutaDebugger *iface, GError **err)
1678 {
1679 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1680 DmaQueueCommand *cmd;
1681
1682 cmd = dma_debugger_queue_append (self, DMA_STEP_OVER_COMMAND, err);
1683 if (cmd == NULL) return FALSE;
1684
1685 dma_debugger_queue_execute (self);
1686
1687 return TRUE;
1688 }
1689
1690 static gboolean
1691 idebugger_run_to (IAnjutaDebugger *iface, const gchar *file,
1692 gint line, GError **err)
1693 {
1694 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1695 DmaQueueCommand *cmd;
1696
1697 cmd = dma_debugger_queue_append (self, DMA_RUN_TO_COMMAND, err);
1698 if (cmd == NULL) return FALSE;
1699
1700 cmd->data.pos.file = g_strdup (file);
1701 cmd->data.pos.line = line;
1702 dma_debugger_queue_execute (self);
1703
1704 return TRUE;
1705 }
1706
1707 static gboolean
1708 idebugger_step_out (IAnjutaDebugger *iface, GError **err)
1709 {
1710 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1711 DmaQueueCommand *cmd;
1712
1713 cmd = dma_debugger_queue_append (self, DMA_STEP_OUT_COMMAND, err);
1714 if (cmd == NULL) return FALSE;
1715
1716 dma_debugger_queue_execute (self);
1717
1718 return TRUE;
1719 }
1720
1721 static gboolean
1722 idebugger_exit (IAnjutaDebugger *iface, GError **err)
1723 {
1724 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1725 DmaQueueCommand *cmd;
1726
1727 cmd = dma_debugger_queue_append (self, DMA_EXIT_COMMAND, err);
1728 if (cmd == NULL) return FALSE;
1729
1730 dma_debugger_queue_execute (self);
1731
1732 return TRUE;
1733 }
1734
1735 static gboolean
1736 idebugger_interrupt (IAnjutaDebugger *iface, GError **err)
1737 {
1738 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1739 DmaQueueCommand *cmd;
1740
1741 cmd = dma_debugger_queue_append (self, DMA_INTERRUPT_COMMAND, err);
1742 if (cmd == NULL) return FALSE;
1743
1744 dma_debugger_queue_execute (self);
1745
1746 return TRUE;
1747 }
1748
1749 static gboolean
1750 idebugger_add_breakpoint_at_line (IAnjutaDebugger *iface, const gchar* file, guint line, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
1751 {
1752 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1753 DmaQueueCommand *cmd;
1754
1755 cmd = dma_debugger_queue_append (self, DMA_BREAK_LINE_COMMAND, err);
1756 if (cmd == NULL) return FALSE;
1757
1758 cmd->data.pos.file = g_strdup (file);
1759 cmd->data.pos.line = line;
1760 cmd->callback = callback;
1761 cmd->user_data = user_data;
1762 dma_debugger_queue_execute (self);
1763
1764 return TRUE;
1765 }
1766
1767 static gboolean
1768 idebugger_add_breakpoint_at_function (IAnjutaDebugger *iface, const gchar* file, const gchar* function, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
1769 {
1770 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1771 DmaQueueCommand *cmd;
1772
1773 cmd = dma_debugger_queue_append (self, DMA_BREAK_FUNCTION_COMMAND, err);
1774 if (cmd == NULL) return FALSE;
1775
1776 cmd->data.pos.file = g_strdup (file);
1777 cmd->data.pos.function = g_strdup (function);
1778 cmd->callback = callback;
1779 cmd->user_data = user_data;
1780 dma_debugger_queue_execute (self);
1781
1782 return TRUE;
1783 }
1784
1785 static gboolean
1786 idebugger_add_breakpoint_at_address (IAnjutaDebugger *iface, guint address, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
1787 {
1788 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1789 DmaQueueCommand *cmd;
1790
1791 cmd = dma_debugger_queue_append (self, DMA_BREAK_ADDRESS_COMMAND, err);
1792 if (cmd == NULL) return FALSE;
1793
1794 cmd->data.pos.address = address;
1795 cmd->callback = callback;
1796 cmd->user_data = user_data;
1797 dma_debugger_queue_execute (self);
1798
1799 return TRUE;
1800 }
1801
1802 static gboolean
1803 idebugger_enable_breakpoint (IAnjutaDebugger *iface, guint id, gboolean enable, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
1804 {
1805 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1806 DmaQueueCommand *cmd;
1807
1808 cmd = dma_debugger_queue_append (self, DMA_ENABLE_BREAK_COMMAND, err);
1809 if (cmd == NULL) return FALSE;
1810
1811 cmd->data.brk.id = id;
1812 cmd->data.brk.enable = enable;
1813 cmd->callback = callback;
1814 cmd->user_data = user_data;
1815 dma_debugger_queue_execute (self);
1816
1817 return TRUE;
1818 }
1819
1820 static gboolean
1821 idebugger_ignore_breakpoint (IAnjutaDebugger *iface, guint id, guint ignore, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
1822 {
1823 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1824 DmaQueueCommand *cmd;
1825
1826 cmd = dma_debugger_queue_append (self, DMA_IGNORE_BREAK_COMMAND, err);
1827 if (cmd == NULL) return FALSE;
1828
1829 cmd->data.brk.id = id;
1830 cmd->data.brk.ignore = ignore;
1831 cmd->callback = callback;
1832 cmd->user_data = user_data;
1833 dma_debugger_queue_execute (self);
1834
1835 return TRUE;
1836 }
1837
1838 static gboolean
1839 idebugger_condition_breakpoint (IAnjutaDebugger *iface, guint id, const gchar *condition, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
1840 {
1841 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1842 DmaQueueCommand *cmd;
1843
1844 cmd = dma_debugger_queue_append (self, DMA_CONDITION_BREAK_COMMAND, err);
1845 if (cmd == NULL) return FALSE;
1846
1847 cmd->data.brk.id = id;
1848 cmd->data.brk.condition = g_strdup (condition);
1849 cmd->callback = callback;
1850 cmd->user_data = user_data;
1851 dma_debugger_queue_execute (self);
1852
1853 return TRUE;
1854 }
1855
1856 static gboolean
1857 idebugger_remove_breakpoint (IAnjutaDebugger *iface, guint id, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
1858 {
1859 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1860 DmaQueueCommand *cmd;
1861
1862 cmd = dma_debugger_queue_append (self, DMA_REMOVE_BREAK_COMMAND, err);
1863 if (cmd == NULL) return FALSE;
1864
1865 cmd->data.brk.id = id;
1866 cmd->callback = callback;
1867 cmd->user_data = user_data;
1868 dma_debugger_queue_execute (self);
1869
1870 return TRUE;
1871 }
1872
1873 static gboolean
1874 idebugger_inspect (IAnjutaDebugger *iface, const gchar *expression, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
1875 {
1876 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1877 DmaQueueCommand *cmd;
1878
1879 cmd = dma_debugger_queue_append (self, DMA_INSPECT_COMMAND, err);
1880 if (cmd == NULL) return FALSE;
1881
1882 cmd->data.watch.name = g_strdup (expression);
1883 cmd->callback = callback;
1884 cmd->user_data = user_data;
1885 dma_debugger_queue_execute (self);
1886
1887 return TRUE;
1888 }
1889
1890 static gboolean
1891 idebugger_evaluate (IAnjutaDebugger *iface, const gchar *name, const gchar* value, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
1892 {
1893 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1894 DmaQueueCommand *cmd;
1895
1896 cmd = dma_debugger_queue_append (self, DMA_EVALUATE_COMMAND, err);
1897 if (cmd == NULL) return FALSE;
1898
1899 cmd->data.watch.name = g_strdup (name);
1900 cmd->data.watch.value = g_strdup (value);
1901 cmd->callback = callback;
1902 cmd->user_data = user_data;
1903 dma_debugger_queue_execute (self);
1904
1905 return TRUE;
1906 }
1907
1908 static gboolean
1909 idebugger_send_command (IAnjutaDebugger *iface, const gchar* command, GError **err)
1910 {
1911 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1912 DmaQueueCommand *cmd;
1913
1914 cmd = dma_debugger_queue_append (self, DMA_USER_COMMAND, err);
1915 if (cmd == NULL) return FALSE;
1916
1917 cmd->data.user.cmd = g_strdup (command);
1918 dma_debugger_queue_execute (self);
1919
1920 return TRUE;
1921 }
1922
1923 static gboolean
1924 idebugger_print (IAnjutaDebugger *iface, const gchar* variable, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
1925 {
1926 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1927 DmaQueueCommand *cmd;
1928
1929 cmd = dma_debugger_queue_append (self, DMA_PRINT_COMMAND, err);
1930 if (cmd == NULL) return FALSE;
1931
1932 cmd->data.print.var = g_strdup (variable);
1933 cmd->callback = callback;
1934 cmd->user_data = user_data;
1935 dma_debugger_queue_execute (self);
1936
1937 return TRUE;
1938 }
1939
1940 static gboolean
1941 idebugger_list_local (IAnjutaDebugger *iface, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
1942 {
1943 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1944 DmaQueueCommand *cmd;
1945
1946 cmd = dma_debugger_queue_append (self, DMA_LIST_LOCAL_COMMAND, err);
1947 if (cmd == NULL) return FALSE;
1948
1949 cmd->callback = callback;
1950 cmd->user_data = user_data;
1951 dma_debugger_queue_execute (self);
1952
1953 return TRUE;
1954 }
1955
1956 static gboolean
1957 idebugger_list_argument (IAnjutaDebugger *iface, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
1958 {
1959 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1960 DmaQueueCommand *cmd;
1961
1962 cmd = dma_debugger_queue_append (self, DMA_LIST_ARG_COMMAND, err);
1963 if (cmd == NULL) return FALSE;
1964
1965 cmd->callback = callback;
1966 cmd->user_data = user_data;
1967 dma_debugger_queue_execute (self);
1968
1969 return TRUE;
1970 }
1971
1972 static gboolean
1973 idebugger_list_thread (IAnjutaDebugger *iface, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
1974 {
1975 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1976 DmaQueueCommand *cmd;
1977
1978 cmd = dma_debugger_queue_append (self, DMA_LIST_THREAD_COMMAND, err);
1979 if (cmd == NULL) return FALSE;
1980
1981 cmd->callback = callback;
1982 cmd->user_data = user_data;
1983 dma_debugger_queue_execute (self);
1984
1985 return TRUE;
1986 }
1987
1988 static gboolean
1989 idebugger_set_thread (IAnjutaDebugger *iface, guint thread, GError **err)
1990 {
1991 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
1992 DmaQueueCommand *cmd;
1993
1994 cmd = dma_debugger_queue_append (self, DMA_SET_THREAD_COMMAND, err);
1995 if (cmd == NULL) return FALSE;
1996
1997 cmd->data.frame.frame = thread;
1998 dma_debugger_queue_execute (self);
1999
2000 return TRUE;
2001 }
2002
2003 static gboolean
2004 idebugger_info_thread (IAnjutaDebugger *iface, guint thread, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
2005 {
2006 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
2007 DmaQueueCommand *cmd;
2008
2009 cmd = dma_debugger_queue_append (self, DMA_INFO_THREAD_COMMAND, err);
2010 if (cmd == NULL) return FALSE;
2011
2012 cmd->callback = callback;
2013 cmd->user_data = user_data;
2014 cmd->data.info.id = thread;
2015 dma_debugger_queue_execute (self);
2016
2017 return TRUE;
2018 }
2019
2020 static gboolean
2021 idebugger_info_signal (IAnjutaDebugger *iface, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
2022 {
2023 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
2024 DmaQueueCommand *cmd;
2025
2026 cmd = dma_debugger_queue_append (self, DMA_INFO_SIGNAL_COMMAND, err);
2027 if (cmd == NULL) return FALSE;
2028
2029 cmd->callback = callback;
2030 cmd->user_data = user_data;
2031 dma_debugger_queue_execute (self);
2032
2033 return TRUE;
2034 }
2035
2036 static gboolean
2037 idebugger_info_sharedlib (IAnjutaDebugger *iface, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
2038 {
2039 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
2040 DmaQueueCommand *cmd;
2041
2042 cmd = dma_debugger_queue_append (self, DMA_INFO_SHAREDLIB_COMMAND, err);
2043 if (cmd == NULL) return FALSE;
2044
2045 cmd->callback = callback;
2046 cmd->user_data = user_data;
2047 dma_debugger_queue_execute (self);
2048
2049 return TRUE;
2050 }
2051
2052 static gboolean
2053 idebugger_handle_signal (IAnjutaDebugger *iface, const gchar* name, gboolean stop, gboolean print, gboolean ignore, GError **err)
2054 {
2055 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
2056 DmaQueueCommand *cmd;
2057
2058 cmd = dma_debugger_queue_append (self, DMA_HANDLE_SIGNAL_COMMAND, err);
2059 if (cmd == NULL) return FALSE;
2060
2061 cmd->data.signal.name = g_strdup (name);
2062 cmd->data.signal.stop = stop;
2063 cmd->data.signal.print = print;
2064 cmd->data.signal.ignore = ignore;
2065 dma_debugger_queue_execute (self);
2066
2067 return TRUE;
2068 }
2069
2070 static gboolean
2071 idebugger_info_frame (IAnjutaDebugger *iface, guint frame, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
2072 {
2073 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
2074 DmaQueueCommand *cmd;
2075
2076 cmd = dma_debugger_queue_append (self, DMA_INFO_FRAME_COMMAND, err);
2077 if (cmd == NULL) return FALSE;
2078
2079 cmd->data.frame.frame = frame;
2080 cmd->callback = callback;
2081 cmd->user_data = user_data;
2082 dma_debugger_queue_execute (self);
2083
2084 return TRUE;
2085 }
2086
2087 static gboolean
2088 idebugger_info_args (IAnjutaDebugger *iface, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
2089 {
2090 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
2091 DmaQueueCommand *cmd;
2092
2093 cmd = dma_debugger_queue_append (self, DMA_INFO_ARGS_COMMAND, err);
2094 if (cmd == NULL) return FALSE;
2095
2096 cmd->callback = callback;
2097 cmd->user_data = user_data;
2098 dma_debugger_queue_execute (self);
2099
2100 return TRUE;
2101 }
2102
2103 static gboolean
2104 idebugger_info_target (IAnjutaDebugger *iface, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
2105 {
2106 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
2107 DmaQueueCommand *cmd;
2108
2109 cmd = dma_debugger_queue_append (self, DMA_INFO_TARGET_COMMAND, err);
2110 if (cmd == NULL) return FALSE;
2111
2112 cmd->callback = callback;
2113 cmd->user_data = user_data;
2114 dma_debugger_queue_execute (self);
2115
2116 return TRUE;
2117 }
2118
2119 static gboolean
2120 idebugger_info_program (IAnjutaDebugger *iface, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
2121 {
2122 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
2123 DmaQueueCommand *cmd;
2124
2125 cmd = dma_debugger_queue_append (self, DMA_INFO_PROGRAM_COMMAND, err);
2126 if (cmd == NULL) return FALSE;
2127
2128 cmd->callback = callback;
2129 cmd->user_data = user_data;
2130 dma_debugger_queue_execute (self);
2131
2132 return TRUE;
2133 }
2134
2135 static gboolean
2136 idebugger_info_udot (IAnjutaDebugger *iface, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
2137 {
2138 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
2139 DmaQueueCommand *cmd;
2140
2141 cmd = dma_debugger_queue_append (self, DMA_INFO_UDOT_COMMAND, err);
2142 if (cmd == NULL) return FALSE;
2143
2144 cmd->callback = callback;
2145 cmd->user_data = user_data;
2146 dma_debugger_queue_execute (self);
2147
2148 return TRUE;
2149 }
2150
2151 static gboolean
2152 idebugger_info_variables (IAnjutaDebugger *iface, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
2153 {
2154 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
2155 DmaQueueCommand *cmd;
2156
2157 cmd = dma_debugger_queue_append (self, DMA_INFO_VARIABLES_COMMAND, err);
2158 if (cmd == NULL) return FALSE;
2159
2160 cmd->callback = callback;
2161 cmd->user_data = user_data;
2162 dma_debugger_queue_execute (self);
2163
2164 return TRUE;
2165 }
2166
2167 static gboolean
2168 idebugger_set_frame (IAnjutaDebugger *iface, guint frame, GError **err)
2169 {
2170 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
2171 DmaQueueCommand *cmd;
2172
2173 cmd = dma_debugger_queue_append (self, DMA_SET_FRAME_COMMAND, err);
2174 if (cmd == NULL) return FALSE;
2175
2176 cmd->data.frame.frame = frame;
2177 dma_debugger_queue_execute (self);
2178
2179 return TRUE;
2180 }
2181
2182 static gboolean
2183 idebugger_list_frame (IAnjutaDebugger *iface, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
2184 {
2185 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
2186 DmaQueueCommand *cmd;
2187
2188 cmd = dma_debugger_queue_append (self, DMA_LIST_FRAME_COMMAND, err);
2189 if (cmd == NULL) return FALSE;
2190
2191 cmd->callback = callback;
2192 cmd->user_data = user_data;
2193 dma_debugger_queue_execute (self);
2194
2195 return TRUE;
2196 }
2197
2198 static gboolean
2199 idebugger_list_register (IAnjutaDebugger *iface, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
2200 {
2201 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
2202 DmaQueueCommand *cmd;
2203
2204 cmd = dma_debugger_queue_append (self, DMA_LIST_REGISTER_COMMAND, err);
2205 if (cmd == NULL) return FALSE;
2206
2207 cmd->callback = callback;
2208 cmd->user_data = user_data;
2209 dma_debugger_queue_execute (self);
2210
2211 return TRUE;
2212 }
2213
2214 static gboolean
2215 idebugger_callback (IAnjutaDebugger *iface, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
2216 {
2217 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
2218 DmaQueueCommand *cmd;
2219
2220 cmd = dma_debugger_queue_append (self, DMA_CALLBACK_COMMAND, err);
2221 if (cmd == NULL) return FALSE;
2222
2223 cmd->callback = callback;
2224 cmd->user_data = user_data;
2225 dma_debugger_queue_execute (self);
2226
2227 return TRUE;
2228 }
2229
2230 static void
2231 idebugger_enable_log (IAnjutaDebugger *iface, IAnjutaMessageView *log, GError **err)
2232 {
2233 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
2234
2235 self->log = log;
2236 if (self->debugger != NULL)
2237 {
2238 ianjuta_debugger_enable_log (self->debugger, self->log, err);
2239 }
2240 }
2241
2242 static void
2243 idebugger_disable_log (IAnjutaDebugger *iface, GError **err)
2244 {
2245 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
2246
2247 self->log = NULL;
2248 if (self->debugger != NULL)
2249 {
2250 ianjuta_debugger_disable_log (self->debugger, err);
2251 }
2252 }
2253
2254 static void
2255 idebugger_iface_init (IAnjutaDebuggerIface *iface)
2256 {
2257 iface->get_status = idebugger_get_status;
2258 iface->initialize = idebugger_initialize;
2259 iface->attach = idebugger_attach;
2260 iface->load = idebugger_load;
2261 iface->start = idebugger_start;
2262 iface->unload = idebugger_unload;
2263 iface->quit = idebugger_quit;
2264 iface->abort = idebugger_abort;
2265 iface->run = idebugger_run;
2266 iface->step_in = idebugger_step_in;
2267 iface->step_over = idebugger_step_over;
2268 iface->step_out = idebugger_step_out;
2269 iface->run_to = idebugger_run_to;
2270 // iface->restart = idebugger_restart;
2271 iface->exit = idebugger_exit;
2272 iface->interrupt = idebugger_interrupt;
2273 iface->set_breakpoint_at_line = idebugger_add_breakpoint_at_line;
2274 iface->clear_breakpoint = idebugger_remove_breakpoint;
2275 iface->set_breakpoint_at_address = idebugger_add_breakpoint_at_address;
2276 iface->set_breakpoint_at_function = idebugger_add_breakpoint_at_function;
2277 iface->enable_breakpoint = idebugger_enable_breakpoint;
2278 iface->ignore_breakpoint = idebugger_ignore_breakpoint;
2279 iface->condition_breakpoint = idebugger_condition_breakpoint;
2280
2281 iface->inspect = idebugger_inspect;
2282 iface->evaluate = idebugger_evaluate;
2283
2284 iface->print = idebugger_print;
2285 iface->list_local = idebugger_list_local;
2286 iface->list_argument = idebugger_list_argument;
2287 iface->info_frame = idebugger_info_frame;
2288 iface->info_signal = idebugger_info_signal;
2289 iface->info_sharedlib = idebugger_info_sharedlib;
2290 iface->info_args = idebugger_info_args;
2291 iface->info_target = idebugger_info_target;
2292 iface->info_program = idebugger_info_program;
2293 iface->info_udot = idebugger_info_udot;
2294 iface->info_variables = idebugger_info_variables;
2295 iface->handle_signal = idebugger_handle_signal;
2296 iface->list_frame = idebugger_list_frame;
2297 iface->set_frame = idebugger_set_frame;
2298 iface->list_thread = idebugger_list_thread;
2299 iface->set_thread = idebugger_set_thread;
2300 iface->info_thread = idebugger_info_thread;
2301 iface->list_register = idebugger_list_register;
2302 iface->callback = idebugger_callback;
2303
2304 iface->enable_log = idebugger_enable_log;
2305 iface->disable_log = idebugger_disable_log;
2306
2307 iface->send_command = idebugger_send_command;
2308
2309 }
2310
2311 /* Implementation of IAnjutaCpuDebugger interface
2312 *---------------------------------------------------------------------------*/
2313
2314 static gboolean
2315 icpu_debugger_list_register (IAnjutaCpuDebugger *iface, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
2316 {
2317 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
2318 DmaQueueCommand *cmd;
2319
2320 cmd = dma_debugger_queue_append (self, DMA_LIST_REGISTER_COMMAND, err);
2321 if (cmd == NULL) return FALSE;
2322
2323 cmd->callback = callback;
2324 cmd->user_data = user_data;
2325 dma_debugger_queue_execute (self);
2326
2327 return TRUE;
2328 }
2329
2330
2331 static gboolean
2332 icpu_debugger_update_register (IAnjutaCpuDebugger *iface, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
2333 {
2334 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
2335 DmaQueueCommand *cmd;
2336
2337 cmd = dma_debugger_queue_append (self, DMA_UPDATE_REGISTER_COMMAND, err);
2338 if (cmd == NULL) return FALSE;
2339
2340 cmd->callback = callback;
2341 cmd->user_data = user_data;
2342 dma_debugger_queue_execute (self);
2343
2344 return TRUE;
2345 }
2346
2347 static gboolean
2348 icpu_debugger_write_register (IAnjutaCpuDebugger *iface, IAnjutaDebuggerRegister *value, GError **err)
2349 {
2350 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
2351 DmaQueueCommand *cmd;
2352
2353 cmd = dma_debugger_queue_append (self, DMA_WRITE_REGISTER_COMMAND, err);
2354 if (cmd == NULL) return FALSE;
2355
2356 cmd->data.watch.id = value->num;
2357 cmd->data.watch.name = value->name != NULL ? g_strdup (value->name) : NULL;
2358 cmd->data.watch.value = value->value != NULL ? g_strdup (value->value) : NULL;
2359 dma_debugger_queue_execute (self);
2360
2361 return TRUE;
2362 }
2363
2364 static gboolean
2365 icpu_debugger_inspect_memory (IAnjutaCpuDebugger *iface, guint address, guint length, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
2366 {
2367 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
2368 DmaQueueCommand *cmd;
2369
2370 cmd = dma_debugger_queue_append (self, DMA_INSPECT_MEMORY_COMMAND, err);
2371 if (cmd == NULL) return FALSE;
2372
2373 cmd->data.mem.address = address;
2374 cmd->data.mem.length = length;
2375 cmd->callback = callback;
2376 cmd->user_data = user_data;
2377 dma_debugger_queue_execute (self);
2378
2379 return TRUE;
2380 }
2381
2382 static gboolean
2383 icpu_debugger_disassemble (IAnjutaCpuDebugger *iface, guint address, guint length, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
2384 {
2385 DmaDebuggerQueue *self = (DmaDebuggerQueue *)iface;
2386 DmaQueueCommand *cmd;
2387
2388 cmd = dma_debugger_queue_append (self, DMA_DISASSEMBLE_COMMAND, err);
2389 if (cmd == NULL) return FALSE;
2390
2391 cmd->data.mem.address = address;
2392 cmd->data.mem.length = length;
2393 cmd->callback = callback;
2394 cmd->user_data = user_data;
2395 dma_debugger_queue_execute (self);
2396
2397 return TRUE;
2398 }
2399
2400 static void
2401 icpu_debugger_iface_init (IAnjutaCpuDebuggerIface *iface)
2402 {
2403 iface->list_register = icpu_debugger_list_register;
2404 iface->update_register = icpu_debugger_update_register;
2405 iface->write_register = icpu_debugger_write_register;
2406 iface->inspect_memory = icpu_debugger_inspect_memory;
2407 iface->disassemble = icpu_debugger_disassemble;
2408 }
2409
2410 /* Implementation of IAnjutaVariableDebugger interface
2411 *---------------------------------------------------------------------------*/
2412
2413 static gboolean
2414 ivariable_debugger_delete (IAnjutaVariableDebugger *iface, const gchar *name, GError **err)
2415 {
2416 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
2417 DmaQueueCommand *cmd;
2418
2419 cmd = dma_debugger_queue_append (self, DMA_DELETE_VARIABLE_COMMAND, err);
2420 if (cmd == NULL) return FALSE;
2421
2422 cmd->data.var.name = g_strdup(name);
2423 dma_debugger_queue_execute (self);
2424
2425 return TRUE;
2426 }
2427
2428 static gboolean
2429 ivariable_debugger_evaluate (IAnjutaVariableDebugger *iface, const gchar *name, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
2430 {
2431 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
2432 DmaQueueCommand *cmd;
2433
2434 cmd = dma_debugger_queue_append (self, DMA_EVALUATE_VARIABLE_COMMAND, err);
2435 if (cmd == NULL) return FALSE;
2436
2437 cmd->data.var.name = g_strdup(name);
2438 cmd->callback = callback;
2439 cmd->user_data = user_data;
2440 dma_debugger_queue_execute (self);
2441
2442 return TRUE;
2443 }
2444
2445 static gboolean
2446 ivariable_debugger_assign (IAnjutaVariableDebugger *iface, const gchar *name, const gchar *value, GError **err)
2447 {
2448 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
2449 DmaQueueCommand *cmd;
2450
2451 cmd = dma_debugger_queue_append (self, DMA_ASSIGN_VARIABLE_COMMAND, err);
2452 if (cmd == NULL) return FALSE;
2453
2454 cmd->data.var.name = g_strdup(name);
2455 cmd->data.var.value = g_strdup(value);
2456 dma_debugger_queue_execute (self);
2457
2458 return TRUE;
2459 }
2460
2461 static gboolean
2462 ivariable_debugger_list_children (IAnjutaVariableDebugger *iface, const gchar *name, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
2463 {
2464 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
2465 DmaQueueCommand *cmd;
2466
2467 cmd = dma_debugger_queue_append (self, DMA_LIST_VARIABLE_CHILDREN_COMMAND, err);
2468 if (cmd == NULL) return FALSE;
2469
2470 cmd->data.var.name = g_strdup(name);
2471 cmd->callback = callback;
2472 cmd->user_data = user_data;
2473 dma_debugger_queue_execute (self);
2474
2475 return TRUE;
2476 }
2477
2478 static gboolean
2479 ivariable_debugger_create (IAnjutaVariableDebugger *iface, const gchar *name, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
2480 {
2481 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
2482 DmaQueueCommand *cmd;
2483
2484 cmd = dma_debugger_queue_append (self, DMA_CREATE_VARIABLE_COMMAND, err);
2485 if (cmd == NULL) return FALSE;
2486
2487 cmd->data.var.name = g_strdup(name);
2488 cmd->callback = callback;
2489 cmd->user_data = user_data;
2490 dma_debugger_queue_execute (self);
2491
2492 return TRUE;
2493 }
2494
2495 static gboolean
2496 ivariable_debugger_update (IAnjutaVariableDebugger *iface, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
2497 {
2498 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (iface);
2499 DmaQueueCommand *cmd;
2500
2501 cmd = dma_debugger_queue_append (self, DMA_UPDATE_VARIABLE_COMMAND, err);
2502 if (cmd == NULL) return FALSE;
2503
2504 cmd->callback = callback;
2505 cmd->user_data = user_data;
2506 dma_debugger_queue_execute (self);
2507
2508 return TRUE;
2509 }
2510
2511 static void
2512 ivariable_debugger_iface_init (IAnjutaVariableDebuggerIface *iface)
2513 {
2514 iface->delete_var = ivariable_debugger_delete;
2515 iface->evaluate = ivariable_debugger_evaluate;
2516 iface->assign = ivariable_debugger_assign;
2517 iface->list_children = ivariable_debugger_list_children;
2518 iface->create = ivariable_debugger_create;
2519 iface->update = ivariable_debugger_update;
2520 }
2521
2522 /* GObject functions
2523 *---------------------------------------------------------------------------*/
2524
2525 /* Used in dispose and finalize */
2526 static gpointer parent_class;
2527
2528 /* dispose is the first destruction step. It is used to unref object created
2529 * with instance_init in order to break reference counting cycles. This
2530 * function could be called several times. All function should still work
2531 * after this call. It has to called its parents.*/
2532
2533 static void
2534 dma_debugger_queue_dispose (GObject *obj)
2535 {
2536 DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (obj);
2537
2538 dma_debugger_queue_clear (self);
2539
2540 GNOME_CALL_PARENT (G_OBJECT_CLASS, dispose, (obj));
2541 }
2542
2543 /* finalize is the last destruction step. It must free all memory allocated
2544 * with instance_init. It is called only one time just before releasing all
2545 * memory */
2546
2547 static void
2548 dma_debugger_queue_finalize (GObject *obj)
2549 {
2550 /*DmaDebuggerQueue *self = DMA_DEBUGGER_QUEUE (obj);*/
2551
2552 GNOME_CALL_PARENT (G_OBJECT_CLASS, finalize, (obj));
2553 }
2554
2555 /* instance_init is the constructor. All functions should work after this
2556 * call. */
2557
2558 static void
2559 dma_debugger_queue_instance_init (DmaDebuggerQueue *self)
2560 {
2561 self->plugin = NULL;
2562 self->debugger = NULL;
2563 self->cpu_debugger = NULL;
2564 self->head = NULL;
2565 self->queue_command = TRUE;
2566 self->ready = TRUE;
2567 self->debugger_status = IANJUTA_DEBUGGER_STOPPED;
2568 self->queue_status = IANJUTA_DEBUGGER_STOPPED;
2569 self->status = IANJUTA_DEBUGGER_STOPPED;
2570 self->log = NULL;
2571 self->output_callback = NULL;
2572 }
2573
2574 /* class_init intialize the class itself not the instance */
2575
2576 static void
2577 dma_debugger_queue_class_init (DmaDebuggerQueueClass * klass)
2578 {
2579 GObjectClass *object_class;
2580
2581 g_return_if_fail (klass != NULL);
2582 object_class = G_OBJECT_CLASS (klass);
2583
2584 parent_class = g_type_class_peek_parent (klass);
2585
2586 object_class->dispose = dma_debugger_queue_dispose;
2587 object_class->finalize = dma_debugger_queue_finalize;
2588 }
2589
2590 GType
2591 dma_debugger_queue_get_type (void)
2592 {
2593 static GType type = 0;
2594
2595 if (!type)
2596 {
2597 static const GTypeInfo type_info =
2598 {
2599 sizeof (DmaDebuggerQueueClass),
2600 (GBaseInitFunc) NULL,
2601 (GBaseFinalizeFunc) NULL,
2602 (GClassInitFunc) dma_debugger_queue_class_init,
2603 (GClassFinalizeFunc) NULL,
2604 NULL, /* class_data */
2605 sizeof (DmaDebuggerQueue),
2606 0, /* n_preallocs */
2607 (GInstanceInitFunc) dma_debugger_queue_instance_init,
2608 NULL /* value_table */
2609 };
2610 static const GInterfaceInfo iface_debugger_info = {
2611 (GInterfaceInitFunc) idebugger_iface_init,
2612 NULL, /* interface_finalize */
2613 NULL /* interface_data */
2614 };
2615 static const GInterfaceInfo iface_cpu_debugger_info = {
2616 (GInterfaceInitFunc) icpu_debugger_iface_init,
2617 NULL, /* interface_finalize */
2618 NULL /* interface_data */
2619 };
2620 static const GInterfaceInfo iface_variable_debugger_info = {
2621 (GInterfaceInitFunc) ivariable_debugger_iface_init,
2622 NULL, /* interface_finalize */
2623 NULL /* interface_data */
2624 };
2625
2626 type = g_type_register_static (G_TYPE_OBJECT,
2627 "DmaDebuggerQueue", &type_info, 0);
2628
2629 g_type_add_interface_static (type, IANJUTA_TYPE_DEBUGGER,
2630 &iface_debugger_info);
2631 g_type_add_interface_static (type, IANJUTA_TYPE_CPU_DEBUGGER,
2632 &iface_cpu_debugger_info);
2633 g_type_add_interface_static (type, IANJUTA_TYPE_VARIABLE_DEBUGGER,
2634 &iface_variable_debugger_info);
2635 }
2636
2637 return type;
2638 }
2639
2640 /* Creation and Destruction
2641 *---------------------------------------------------------------------------*/
2642
2643 DmaDebuggerQueue*
2644 dma_debugger_queue_new (AnjutaPlugin *plugin)
2645 {
2646 DmaDebuggerQueue *self;
2647
2648 self = g_object_new (DMA_DEBUGGER_QUEUE_TYPE, NULL);
2649
2650 self->plugin = plugin;
2651
2652 return self;
2653 }
2654
2655 void
2656 dma_debugger_queue_free (DmaDebuggerQueue *self)
2657 {
2658 dma_debugger_disconnect (self);
2659 g_object_unref (self);
2660 }
Anjuta IDE Git Plugin Development Tree