plugins/gdb/plugin.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3     plugin.c
   4     Copyright (C) 2005 Sebastien 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 as 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  * Implement the IAnjutaDebugger interface.
  23  */
  24
  25 #include <config.h>
  26
  27 #define DEBUG
  28
  29 #include "plugin.h"
  30
  31 #include "debugger.h"
  32
  33 #include <libanjuta/interfaces/ianjuta-debugger.h>
  34 #include <libanjuta/interfaces/ianjuta-breakpoint-debugger.h>
  35 #include <libanjuta/interfaces/ianjuta-cpu-debugger.h>
  36 #include <libanjuta/interfaces/ianjuta-variable-debugger.h>
  37 #include <libanjuta/anjuta-debug.h>
  38 #include <libanjuta/anjuta-plugin.h>
  39
  40 /* Plugin type
  41  *---------------------------------------------------------------------------*/
  42
  43 struct _GdbPlugin
  44 {
  45         AnjutaPlugin parent;
  46
  47         /* Debugger */
  48         Debugger *debugger;
  49
  50         /* Output callback data */
  51         IAnjutaDebuggerOutputCallback output_callback;
  52         gpointer output_user_data;
  53
  54         /* Log message window */
  55         IAnjutaMessageView *view;
  56 };
  57
  58 struct _GdbPluginClass
  59 {
  60         AnjutaPluginClass parent_class;
  61 };
  62
  63 /* Private functions
  64  *---------------------------------------------------------------------------*/
  65
  66 static void
  67 gdb_plugin_initialize (GdbPlugin *this)
  68 {
  69         if (this->debugger == NULL)
  70         {
  71                 GtkWindow *parent;
  72
  73                 parent = GTK_WINDOW (ANJUTA_PLUGIN (this)->shell);
  74                 this->debugger = debugger_new (parent, G_OBJECT (this));
  75                 debugger_set_output_callback (this->debugger, this->output_callback, this->output_user_data);
  76                 if (this->view) debugger_set_log (this->debugger, this->view);
  77         }
  78 }
  79
  80 /* AnjutaPlugin functions
  81  *---------------------------------------------------------------------------*/
  82
  83 static gboolean
  84 gdb_plugin_activate_plugin (AnjutaPlugin* plugin)
  85 {
  86         /* GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin); */
  87
  88         DEBUG_PRINT ("GDB: Activating Gdb plugin...");
  89
  90         return TRUE;
  91 }
  92
  93 static gboolean
  94 gdb_plugin_deactivate_plugin (AnjutaPlugin* plugin)
  95 {
  96         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
  97
  98         DEBUG_PRINT ("GDB: Deactivating Gdb plugin...");
  99
 100         if (this->debugger != NULL)
 101         {
 102                 debugger_free (this->debugger);
 103                 this->debugger = NULL;
 104         }
 105
 106         return TRUE;
 107 }
 108
 109 /* GObject functions
 110  *---------------------------------------------------------------------------*/
 111
 112 /* Used in dispose and finalize */
 113 static gpointer parent_class;
 114
 115 /* instance_init is the constructor. All functions should work after this
 116  * call. */
 117
 118 static void
 119 gdb_plugin_instance_init (GObject* obj)
 120 {
 121         GdbPlugin *this = ANJUTA_PLUGIN_GDB (obj);
 122
 123         this->debugger = NULL;
 124         this->output_callback = NULL;
 125 }
 126
 127 /* dispose is the first destruction step. It is used to unref object created
 128  * with instance_init in order to break reference counting cycles. This
 129  * function could be called several times. All function should still work
 130  * after this call. It has to called its parents.*/
 131
 132 static void
 133 gdb_plugin_dispose (GObject* obj)
 134 {
 135         GdbPlugin *this = ANJUTA_PLUGIN_GDB (obj);
 136
 137         if (this->debugger != NULL)
 138         {
 139                 debugger_free (this->debugger);
 140                 this->debugger = NULL;
 141         }
 142         GNOME_CALL_PARENT (G_OBJECT_CLASS, dispose, (G_OBJECT (obj)));
 143 }
 144
 145 /* finalize is the last destruction step. It must free all memory allocated
 146  * with instance_init. It is called only one time just before releasing all
 147  * memory */
 148
 149 static void
 150 gdb_plugin_finalize (GObject* obj)
 151 {
 152         GNOME_CALL_PARENT (G_OBJECT_CLASS, finalize, (G_OBJECT (obj)));
 153 }
 154
 155 /* class_init intialize the class itself not the instance */
 156
 157 static void
 158 gdb_plugin_class_init (GObjectClass* klass)
 159 {
 160         AnjutaPluginClass *plugin_class = ANJUTA_PLUGIN_CLASS (klass);
 161
 162         parent_class = g_type_class_peek_parent (klass);
 163
 164         plugin_class->activate = gdb_plugin_activate_plugin;
 165         plugin_class->deactivate = gdb_plugin_deactivate_plugin;
 166         klass->dispose = gdb_plugin_dispose;
 167         klass->finalize = gdb_plugin_finalize;
 168 }
 169
 170 /* Implementation of IAnjutaDebugger interface
 171  *---------------------------------------------------------------------------*/
 172
 173 static IAnjutaDebuggerStatus
 174 idebugger_get_status (IAnjutaDebugger *plugin, GError **err)
 175 {
 176         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 177
 178         if (this->debugger == NULL)
 179         {
 180                 return IANJUTA_DEBUGGER_STOPPED;
 181         }
 182         else
 183         {
 184                 return debugger_get_status (this->debugger);
 185         }
 186 }
 187
 188
 189 static gboolean
 190 idebugger_initialize (IAnjutaDebugger *plugin, IAnjutaDebuggerOutputCallback callback, gpointer user_data, GError **err)
 191 {
 192         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 193
 194         this->output_callback = callback;
 195         this->output_user_data = user_data;
 196         g_signal_emit_by_name (G_OBJECT (plugin), "debugger-ready", IANJUTA_DEBUGGER_STOPPED);
 197
 198         return TRUE;
 199 }
 200
 201 static gboolean
 202 idebugger_load (IAnjutaDebugger *plugin, const gchar *file, const gchar* mime_type,
 203                                 const GList *search_dirs, gboolean terminal, GError **err)
 204 {
 205         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 206         gboolean is_libtool = FALSE;
 207
 208         /* Check allowed mime type */
 209         if (strcmp (mime_type, "application/x-executable") == 0)
 210         {
 211         }
 212         else if (strcmp (mime_type, "application/x-shellscript") == 0)
 213         {
 214                 /* FIXME: We should really do more checks to confirm that
 215                  * this target is indeed libtool target
 216                  */
 217                 is_libtool = TRUE;
 218         }
 219         else if (strcmp (mime_type, "application/x-core") == 0)
 220         {
 221         }
 222         else
 223         {
 224                 //return IANJUTA_DEBUGGER_NOT_IMPLEMENTED;
 225                 return TRUE;
 226         }
 227
 228         // a NULL filename could be used to check supported mime type
 229         if (file == NULL) return TRUE;
 230
 231         // Start debugger
 232         gdb_plugin_initialize (this);
 233
 234         return debugger_start (this->debugger, search_dirs, file, is_libtool, terminal);
 235 }
 236
 237 static gboolean
 238 idebugger_unload (IAnjutaDebugger *plugin, GError **err)
 239 {
 240         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 241
 242         debugger_stop (this->debugger);
 243
 244         return TRUE;
 245 }
 246
 247 static gboolean
 248 idebugger_attach (IAnjutaDebugger *plugin, pid_t pid, const GList *search_dirs, GError **err)
 249 {
 250         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 251
 252         // Start debugger
 253         gdb_plugin_initialize (this);
 254         debugger_start (this->debugger, search_dirs, NULL, FALSE, FALSE);
 255         debugger_attach_process (this->debugger, pid);
 256
 257         return TRUE;
 258 }
 259
 260 static gboolean
 261 idebugger_start (IAnjutaDebugger *plugin, const gchar *argument, GError **err)
 262 {
 263         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 264
 265         debugger_start_program (this->debugger, argument);
 266
 267         return TRUE;
 268 }
 269
 270 static gboolean
 271 idebugger_quit (IAnjutaDebugger *plugin, GError **err)
 272 {
 273         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 274
 275         if (!debugger_stop (this->debugger))
 276         {
 277                 DEBUG_PRINT ("set error");
 278                 g_set_error (err, IANJUTA_DEBUGGER_ERROR, IANJUTA_DEBUGGER_CANCEL, "Command cancelled by user");
 279
 280                 return FALSE;
 281         }
 282         else
 283         {
 284                 return TRUE;
 285         }
 286 }
 287
 288 static gboolean
 289 idebugger_abort (IAnjutaDebugger *plugin, GError **err)
 290 {
 291         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 292
 293         DEBUG_PRINT ("idebugger abort\n");
 294         if (!debugger_abort (this->debugger))
 295         {
 296                 g_set_error (err, IANJUTA_DEBUGGER_ERROR, IANJUTA_DEBUGGER_CANCEL, "Command cancelled by user");
 297
 298                 return FALSE;
 299         }
 300         else
 301         {
 302                 return TRUE;
 303         }
 304 }
 305
 306 static gboolean
 307 idebugger_run (IAnjutaDebugger *plugin, GError **err)
 308 {
 309         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 310
 311         debugger_run (this->debugger);
 312
 313         return TRUE;
 314 }
 315
 316 static gboolean
 317 idebugger_step_in (IAnjutaDebugger *plugin, GError **err)
 318 {
 319         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 320
 321         debugger_step_in (this->debugger);
 322
 323         return TRUE;
 324 }
 325
 326 static gboolean
 327 idebugger_step_over (IAnjutaDebugger *plugin, GError **err)
 328 {
 329         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 330
 331         debugger_step_over (this->debugger);
 332
 333         return TRUE;
 334 }
 335
 336 static gboolean
 337 idebugger_run_to (IAnjutaDebugger *plugin, const gchar *file,
 338                                                    gint line, GError **err)
 339 {
 340         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 341
 342         debugger_run_to_position (this->debugger, file, line);
 343
 344         return TRUE;
 345 }
 346
 347 static gboolean
 348 idebugger_step_out (IAnjutaDebugger *plugin, GError **err)
 349 {
 350         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 351
 352         debugger_step_out (this->debugger);
 353
 354         return TRUE;
 355 }
 356
 357 static gboolean
 358 idebugger_exit (IAnjutaDebugger *plugin, GError **err)
 359 {
 360         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 361
 362         debugger_stop_program (this->debugger);
 363
 364         return TRUE;
 365 }
 366
 367 static gboolean
 368 idebugger_interrupt (IAnjutaDebugger *plugin, GError **err)
 369 {
 370         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 371
 372         debugger_interrupt (this->debugger);
 373
 374         return TRUE;
 375 }
 376
 377 static gboolean
 378 idebugger_inspect (IAnjutaDebugger *plugin, const gchar *name, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
 379 {
 380         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 381
 382         debugger_evaluate (this->debugger, name, callback, user_data);
 383
 384         return TRUE;
 385 }
 386
 387 static gboolean
 388 idebugger_evaluate (IAnjutaDebugger *plugin, const gchar *name, const gchar *value, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
 389 {
 390         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 391         gchar* buf;
 392
 393         buf = g_strconcat ("\"", name, " = ", value, "\"", NULL);
 394         debugger_evaluate (this->debugger, buf, callback, user_data);
 395         g_free (buf);
 396
 397         return TRUE;
 398 }
 399
 400 static gboolean
 401 idebugger_send_command (IAnjutaDebugger *plugin, const gchar* command, GError **err)
 402 {
 403         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 404
 405         debugger_command (this->debugger, command, FALSE, NULL, NULL);
 406
 407         return TRUE;
 408 }
 409
 410 static gboolean
 411 idebugger_print (IAnjutaDebugger *plugin, const gchar* variable, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
 412 {
 413         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 414
 415         debugger_print (this->debugger, variable, callback, user_data);
 416
 417         return TRUE;
 418 }
 419
 420 static gboolean
 421 idebugger_list_local (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
 422 {
 423         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 424
 425         debugger_list_local (this->debugger, callback, user_data);
 426
 427         return TRUE;
 428 }
 429
 430 static gboolean
 431 idebugger_list_argument (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
 432 {
 433         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 434
 435         debugger_list_argument (this->debugger, callback, user_data);
 436
 437         return TRUE;
 438 }
 439
 440 static gboolean
 441 idebugger_info_signal (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
 442 {
 443         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 444
 445         debugger_info_signal (this->debugger, callback, user_data);
 446
 447         return TRUE;
 448 }
 449
 450 static gboolean
 451 idebugger_info_sharedlib (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
 452 {
 453         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 454
 455         debugger_info_sharedlib (this->debugger, callback, user_data);
 456
 457         return TRUE;
 458 }
 459
 460 static gboolean
 461 idebugger_handle_signal (IAnjutaDebugger *plugin, const gchar* name, gboolean stop, gboolean print, gboolean ignore, GError **err)
 462 {
 463         gchar* cmd;
 464         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 465
 466         cmd = g_strdup_printf("handle %s %sstop %sprint %spass", name, stop ? "" : "no", print ? "" : "no", ignore ? "" : "no");
 467         debugger_command (this->debugger, cmd, FALSE, NULL, NULL);
 468         g_free (cmd);
 469
 470         return TRUE;
 471 }
 472
 473 static gboolean
 474 idebugger_info_frame (IAnjutaDebugger *plugin, guint frame, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
 475 {
 476         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 477
 478         debugger_info_frame (this->debugger, frame, callback, user_data);
 479
 480         return TRUE;
 481 }
 482
 483 static gboolean
 484 idebugger_info_args (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
 485 {
 486         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 487
 488         debugger_info_args (this->debugger, callback, user_data);
 489
 490         return TRUE;
 491 }
 492
 493 static gboolean
 494 idebugger_info_target (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
 495 {
 496         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 497
 498         debugger_info_target (this->debugger, callback, user_data);
 499
 500         return TRUE;
 501 }
 502
 503 static gboolean
 504 idebugger_info_program (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
 505 {
 506         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 507
 508         debugger_info_program (this->debugger, callback, user_data);
 509
 510         return TRUE;
 511 }
 512
 513 static gboolean
 514 idebugger_info_udot (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
 515 {
 516         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 517
 518         debugger_info_udot (this->debugger, callback, user_data);
 519
 520         return TRUE;
 521 }
 522
 523 static gboolean
 524 idebugger_info_variables (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
 525 {
 526         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 527
 528         debugger_info_variables (this->debugger, callback, user_data);
 529
 530         return TRUE;
 531 }
 532
 533 static gboolean
 534 idebugger_set_frame (IAnjutaDebugger *plugin, guint frame, GError **err)
 535 {
 536         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 537
 538         debugger_set_frame (this->debugger, frame);
 539
 540         return TRUE;
 541 }
 542
 543 static gboolean
 544 idebugger_list_frame (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
 545 {
 546         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 547
 548         debugger_list_frame (this->debugger, callback, user_data);
 549
 550         return TRUE;
 551 }
 552
 553 static gboolean
 554 idebugger_set_thread (IAnjutaDebugger *plugin, gint thread, GError **err)
 555 {
 556         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 557
 558         debugger_set_thread (this->debugger, thread);
 559
 560         return TRUE;
 561 }
 562
 563 static gboolean
 564 idebugger_list_thread (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
 565 {
 566         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 567
 568         debugger_list_thread (this->debugger, callback, user_data);
 569
 570         return TRUE;
 571 }
 572
 573 static gboolean
 574 idebugger_info_thread (IAnjutaDebugger *plugin, gint thread, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
 575 {
 576         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 577
 578         debugger_info_thread (this->debugger, thread, callback, user_data);
 579
 580         return TRUE;
 581 }
 582
 583 static gboolean
 584 idebugger_list_register (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
 585 {
 586         //GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 587
 588         //debugger_list_register (this->debugger, callback, user_data);
 589
 590         return TRUE;
 591 }
 592
 593 static gboolean
 594 idebugger_callback (IAnjutaDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
 595 {
 596
 597         callback (NULL, user_data, NULL);
 598
 599         return TRUE;
 600 }
 601
 602 static void
 603 idebugger_enable_log (IAnjutaDebugger *plugin, IAnjutaMessageView *log, GError **err)
 604 {
 605         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 606
 607         this->view = log;
 608         if (this->debugger)
 609                 debugger_set_log (this->debugger, log);
 610 }
 611
 612 static void
 613 idebugger_disable_log (IAnjutaDebugger *plugin, GError **err)
 614 {
 615         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 616
 617         this->view = NULL;
 618         if (this->debugger)
 619                 debugger_set_log (this->debugger, NULL);
 620 }
 621
 622 static void
 623 idebugger_iface_init (IAnjutaDebuggerIface *iface)
 624 {
 625         iface->get_status = idebugger_get_status;
 626         iface->initialize = idebugger_initialize;
 627         iface->attach = idebugger_attach;
 628         iface->load = idebugger_load;
 629         iface->start = idebugger_start;
 630         iface->unload = idebugger_unload;
 631         iface->quit = idebugger_quit;
 632         iface->abort = idebugger_abort;
 633         iface->run = idebugger_run;
 634         iface->step_in = idebugger_step_in;
 635         iface->step_over = idebugger_step_over;
 636         iface->step_out = idebugger_step_out;
 637         iface->run_to = idebugger_run_to;
 638         iface->exit = idebugger_exit;
 639         iface->interrupt = idebugger_interrupt;
 640
 641         iface->inspect = idebugger_inspect;
 642         iface->evaluate = idebugger_evaluate;
 643
 644         iface->print = idebugger_print;
 645         iface->list_local = idebugger_list_local;
 646         iface->list_argument = idebugger_list_argument;
 647         iface->info_frame = idebugger_info_frame;
 648         iface->info_signal = idebugger_info_signal;
 649         iface->info_sharedlib = idebugger_info_sharedlib;
 650         iface->info_args = idebugger_info_args;
 651         iface->info_target = idebugger_info_target;
 652         iface->info_program = idebugger_info_program;
 653         iface->info_udot = idebugger_info_udot;
 654         iface->info_variables = idebugger_info_variables;
 655         iface->handle_signal = idebugger_handle_signal;
 656         iface->list_frame = idebugger_list_frame;
 657         iface->set_frame = idebugger_set_frame;
 658         iface->list_thread = idebugger_list_thread;
 659         iface->set_thread = idebugger_set_thread;
 660         iface->info_thread = idebugger_info_thread;
 661         iface->list_register = idebugger_list_register;
 662
 663         iface->send_command = idebugger_send_command;
 664
 665         iface->callback = idebugger_callback;
 666
 667         iface->enable_log = idebugger_enable_log;
 668         iface->disable_log = idebugger_disable_log;
 669 }
 670
 671
 672 /* Implementation of IAnjutaBreakpointDebugger interface
 673  *---------------------------------------------------------------------------*/
 674
 675 static gboolean
 676 ibreakpoint_debugger_add_breakpoint_at_line (IAnjutaBreakpointDebugger *plugin, const gchar* file, guint line, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
 677 {
 678         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 679
 680         /* NULL breakpoint is used to detect available feature */
 681         if (file == NULL) return TRUE;
 682
 683         debugger_add_breakpoint_at_line (this->debugger, file, line, callback, user_data);
 684
 685         return TRUE;
 686 }
 687
 688 static gboolean
 689 ibreakpoint_debugger_add_breakpoint_at_function (IAnjutaBreakpointDebugger *plugin, const gchar* file, const gchar* function, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
 690 {
 691         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 692
 693         /* NULL breakpoint is used to detect available feature */
 694         if (function == NULL) return TRUE;
 695
 696         debugger_add_breakpoint_at_function (this->debugger, *file == '\0' ? NULL : file, function, callback, user_data);
 697
 698         return TRUE;
 699 }
 700
 701 static gboolean
 702 ibreakpoint_debugger_add_breakpoint_at_address (IAnjutaBreakpointDebugger *plugin, guint address, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
 703 {
 704         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 705
 706         /* NULL breakpoint is used to detect available feature */
 707         if (address == 0) return TRUE;
 708
 709         debugger_add_breakpoint_at_address (this->debugger, address, callback, user_data);
 710
 711         return TRUE;
 712 }
 713
 714 static gboolean
 715 ibreakpoint_debugger_enable_breakpoint (IAnjutaBreakpointDebugger *plugin, guint id, gboolean enable, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
 716 {
 717         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 718
 719         /* NULL breakpoint is used to detect available feature */
 720         if (id == 0) return TRUE;
 721
 722         debugger_enable_breakpoint (this->debugger, id, enable, callback, user_data);
 723
 724         return TRUE;
 725 }
 726
 727 static gboolean
 728 ibreakpoint_debugger_ignore_breakpoint (IAnjutaBreakpointDebugger *plugin, guint id, guint ignore, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
 729 {
 730         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 731
 732         /* NULL breakpoint is used to detect available feature */
 733         if (id == 0) return TRUE;
 734
 735         debugger_ignore_breakpoint (this->debugger, id, ignore, callback, user_data);
 736
 737         return TRUE;
 738 }
 739
 740 static gboolean
 741 ibreakpoint_debugger_condition_breakpoint (IAnjutaBreakpointDebugger *plugin, guint id, const gchar *condition, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
 742 {
 743         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 744
 745         /* NULL breakpoint is used to detect available feature */
 746         if (id == 0) return TRUE;
 747
 748         debugger_condition_breakpoint (this->debugger, id, condition, callback, user_data);
 749
 750         return TRUE;
 751 }
 752
 753 static gboolean
 754 ibreakpoint_debugger_remove_breakpoint (IAnjutaBreakpointDebugger *plugin, guint id, IAnjutaDebuggerCallback callback, gpointer user_data, GError **err)
 755 {
 756         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 757
 758         /* NULL breakpoint is used to detect available feature */
 759         if (id == 0) return TRUE;
 760
 761         debugger_remove_breakpoint (this->debugger, id, callback, user_data);
 762
 763         return TRUE;
 764 }
 765
 766 static void
 767 ibreakpoint_debugger_iface_init (IAnjutaBreakpointDebuggerIface *iface)
 768 {
 769         iface->set_breakpoint_at_line = ibreakpoint_debugger_add_breakpoint_at_line;
 770         iface->clear_breakpoint = ibreakpoint_debugger_remove_breakpoint;
 771         iface->set_breakpoint_at_address = ibreakpoint_debugger_add_breakpoint_at_address;
 772         iface->set_breakpoint_at_function = ibreakpoint_debugger_add_breakpoint_at_function;
 773         iface->enable_breakpoint = ibreakpoint_debugger_enable_breakpoint;
 774         iface->ignore_breakpoint = ibreakpoint_debugger_ignore_breakpoint;
 775         iface->condition_breakpoint = ibreakpoint_debugger_condition_breakpoint;
 776 }
 777
 778 /* Implementation of IAnjutaCpuDebugger interface
 779  *---------------------------------------------------------------------------*/
 780
 781 static gboolean
 782 icpu_debugger_list_register (IAnjutaCpuDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
 783 {
 784         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 785
 786         debugger_list_register (this->debugger, callback, user_data);
 787
 788         return TRUE;
 789 }
 790
 791 static gboolean
 792 icpu_debugger_update_register (IAnjutaCpuDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
 793 {
 794         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 795
 796         debugger_update_register (this->debugger, callback, user_data);
 797
 798         return TRUE;
 799 }
 800
 801 static gboolean
 802 icpu_debugger_write_register (IAnjutaCpuDebugger *plugin, IAnjutaDebuggerRegister *value, GError **err)
 803 {
 804         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 805
 806         debugger_write_register (this->debugger, value->name, value->value);
 807
 808         return TRUE;
 809 }
 810
 811 static gboolean
 812 icpu_debugger_inspect_memory (IAnjutaCpuDebugger *plugin, guint address, guint length, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
 813 {
 814         GdbPlugin *this = ANJUTA_PLUGIN_GDB (plugin);
 815
 816         debugger_inspect_memory (this->debugger, address, length, callback, user_data);
 817
 818         return TRUE;
 819 }
 820
 821 static gboolean
 822 icpu_debugger_disassemble (IAnjutaCpuDebugger *plugin, guint address, guint length, IAnjutaDebuggerCallback callback , gpointer user_data, GError **err)
 823 {
 824         GdbPlugin *this = (GdbPlugin *)plugin;
 825
 826         debugger_disassemble (this->debugger, address, length, callback, user_data);
 827
 828         return TRUE;
 829 }
 830
 831 static void
 832 icpu_debugger_iface_init (IAnjutaCpuDebuggerIface *iface)
 833 {
 834         iface->list_register = icpu_debugger_list_register;
 835         iface->update_register = icpu_debugger_update_register;
 836         iface->write_register = icpu_debugger_write_register;
 837         iface->inspect_memory = icpu_debugger_inspect_memory;
 838         iface->disassemble = icpu_debugger_disassemble;
 839 }
 840
 841 /* Implementation of IAnjutaVariableDebugger interface
 842  *---------------------------------------------------------------------------*/
 843
 844 static gboolean
 845 ivariable_debugger_delete (IAnjutaVariableDebugger *plugin, const gchar *name, GError **error)
 846 {
 847         GdbPlugin *gdb = ANJUTA_PLUGIN_GDB (plugin);
 848
 849         debugger_delete_variable (gdb->debugger, name);
 850
 851         return TRUE;
 852 }
 853
 854 static gboolean
 855 ivariable_debugger_evaluate (IAnjutaVariableDebugger *plugin, const gchar *name, IAnjutaDebuggerCallback callback , gpointer user_data, GError **error)
 856 {
 857         GdbPlugin *gdb = ANJUTA_PLUGIN_GDB (plugin);
 858
 859         debugger_evaluate_variable (gdb->debugger, name, callback, user_data);
 860
 861         return TRUE;
 862 }
 863
 864 static gboolean
 865 ivariable_debugger_assign (IAnjutaVariableDebugger *plugin, const gchar *name, const gchar *value, GError **error)
 866 {
 867         GdbPlugin *gdb = ANJUTA_PLUGIN_GDB (plugin);
 868
 869         debugger_assign_variable (gdb->debugger, name, value);
 870
 871         return TRUE;
 872 }
 873
 874 static gboolean
 875 ivariable_debugger_list_children (IAnjutaVariableDebugger *plugin, const gchar *name, IAnjutaDebuggerCallback callback , gpointer user_data, GError **error)
 876 {
 877         GdbPlugin *gdb = ANJUTA_PLUGIN_GDB (plugin);
 878
 879         debugger_list_variable_children (gdb->debugger, name, callback, user_data);
 880
 881         return TRUE;
 882 }
 883
 884 static gboolean
 885 ivariable_debugger_create (IAnjutaVariableDebugger *plugin, const gchar *name, IAnjutaDebuggerCallback callback , gpointer user_data, GError **error)
 886 {
 887         GdbPlugin *gdb = ANJUTA_PLUGIN_GDB (plugin);
 888
 889         debugger_create_variable (gdb->debugger, name, callback, user_data);
 890
 891         return TRUE;
 892 }
 893
 894 static gboolean
 895 ivariable_debugger_update (IAnjutaVariableDebugger *plugin, IAnjutaDebuggerCallback callback , gpointer user_data, GError **error)
 896 {
 897         GdbPlugin *gdb = ANJUTA_PLUGIN_GDB (plugin);
 898
 899         debugger_update_variable (gdb->debugger, callback, user_data);
 900
 901         return TRUE;
 902 }
 903
 904 static void
 905 ivariable_debugger_iface_init (IAnjutaVariableDebuggerIface *iface)
 906 {
 907         iface->delete_var = ivariable_debugger_delete;
 908         iface->evaluate = ivariable_debugger_evaluate;
 909         iface->assign = ivariable_debugger_assign;
 910         iface->list_children = ivariable_debugger_list_children;
 911         iface->create = ivariable_debugger_create;
 912         iface->update = ivariable_debugger_update;
 913 }
 914
 915 ANJUTA_PLUGIN_BEGIN (GdbPlugin, gdb_plugin);
 916 ANJUTA_PLUGIN_ADD_INTERFACE(idebugger, IANJUTA_TYPE_DEBUGGER);
 917 ANJUTA_PLUGIN_ADD_INTERFACE(ibreakpoint_debugger, IANJUTA_TYPE_BREAKPOINT_DEBUGGER);
 918 ANJUTA_PLUGIN_ADD_INTERFACE(icpu_debugger, IANJUTA_TYPE_CPU_DEBUGGER);
 919 ANJUTA_PLUGIN_ADD_INTERFACE(ivariable_debugger, IANJUTA_TYPE_VARIABLE_DEBUGGER);
 920 ANJUTA_PLUGIN_END;
 921
 922 ANJUTA_SIMPLE_PLUGIN (GdbPlugin, gdb_plugin);