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