plugins/debug-manager/memory.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3     memory.c
   4     Copyright (C) 2006 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 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 #ifdef HAVE_CONFIG_H
  22 #include "config.h"
  23 #endif
  24
  25 #include <sys/stat.h>
  26 #include <unistd.h>
  27 #include <string.h>
  28
  29 #include <gnome.h>
  30
  31 /*#define DEBUG*/
  32 #include <libanjuta/anjuta-debug.h>
  33
  34 #include "memory.h"
  35
  36 #include "data_view.h"
  37 #include "plugin.h"
  38 #include "queue.h"
  39
  40 /* Constants
  41  *---------------------------------------------------------------------------*/
  42
  43 /* Types
  44  *---------------------------------------------------------------------------*/
  45
  46 struct _DmaMemory
  47 {
  48         DmaDebuggerQueue *debugger;
  49         AnjutaPlugin *plugin;
  50         GtkWidget *window;
  51         DmaDataBuffer *buffer;
  52         GtkWidget *menu;
  53 };
  54
  55 /* Private functions
  56  *---------------------------------------------------------------------------*/
  57
  58 static void
  59 on_memory_block_read (const IAnjutaDebuggerMemoryBlock *block, DmaMemory *mem, GError *err)
  60 {
  61         const gchar* tag;
  62
  63         if (block == NULL)
  64         {
  65                 /* Command has been cancelled */
  66                 return;
  67         }
  68
  69         guint length = block->length;
  70         gchar *data = block->data;
  71         gulong address = block->address;
  72
  73         tag = data + length;
  74         while (length != 0)
  75         {
  76                 const gchar* start;
  77
  78                 /* Skip undefined data */
  79                 for (start = tag; *tag == 0; tag++)
  80                 {
  81                         length--;
  82                         if (length == 0) return;
  83                 }
  84                 data += tag - start;
  85                 address += tag - start;
  86
  87                 /* Compute length of defined data */
  88                 for (start = tag; (length != 0) && (*tag != 0); tag++)
  89                 {
  90                         length--;
  91                 }
  92
  93                 dma_data_buffer_set_data (mem->buffer, address, tag - start, data);
  94                 data += tag - start;
  95                 address += tag - start;
  96         }
  97 }
  98
  99 static void
 100 read_memory_block (gulong address, gulong length, gpointer user_data)
 101 {
 102         DmaMemory *mem = (DmaMemory *)user_data;
 103
 104         if (mem->debugger != NULL)
 105         {
 106                 dma_queue_inspect_memory (
 107                                 mem->debugger,
 108                                 address,
 109                                 (guint)length,
 110                                 (IAnjutaDebuggerCallback)on_memory_block_read,
 111                                 mem);
 112         }
 113 }
 114
 115 static void
 116 dma_memory_update (DmaMemory *mem)
 117 {
 118         dma_data_buffer_invalidate(mem->buffer);
 119         dma_data_view_refresh(DMA_DATA_VIEW (mem->window));
 120 }
 121
 122 static void
 123 on_program_stopped (DmaMemory *mem)
 124 {
 125         dma_memory_update (mem);
 126 }
 127
 128 static void
 129 destroy_memory_gui (DmaMemory *mem)
 130 {
 131         /* Destroy menu */
 132         if (mem->menu != NULL)
 133         {
 134                 gtk_widget_destroy (mem->menu);
 135         }
 136
 137         if (mem->window != NULL)
 138         {
 139                 gtk_widget_destroy (mem->window);
 140                 mem->window = NULL;
 141                 dma_data_buffer_remove_all_page (mem->buffer);
 142         }
 143
 144         /* Remove buffer */
 145         if (mem->buffer != NULL)
 146         {
 147                 g_object_unref (mem->buffer);
 148                 mem->buffer = NULL;
 149         }
 150 }
 151
 152 static void
 153 on_debugger_stopped (DmaMemory *mem)
 154 {
 155
 156         g_signal_handlers_disconnect_by_func (mem->plugin, G_CALLBACK (on_debugger_stopped), mem);
 157         g_signal_handlers_disconnect_by_func (mem->plugin, G_CALLBACK (on_program_stopped), mem);
 158
 159         destroy_memory_gui (mem);
 160 }
 161
 162 static gboolean
 163 create_memory_gui (DmaMemory *mem)
 164 {
 165         GtkWidget *dataview;
 166
 167         g_return_val_if_fail (mem->buffer == NULL, FALSE);
 168         g_return_val_if_fail (mem->window == NULL, FALSE);
 169
 170         mem->buffer = dma_data_buffer_new (0x0000, 0xFFFFFFFFU, read_memory_block, NULL, mem);
 171         if (mem->buffer == NULL) return FALSE;
 172
 173         dataview = dma_data_view_new_with_buffer (mem->buffer);
 174         mem->window = dataview;
 175
 176         anjuta_shell_add_widget (mem->plugin->shell,
 177                                                          mem->window,
 178                              "AnjutaDebuggerMemory", _("Memory"),
 179                              NULL, ANJUTA_SHELL_PLACEMENT_CENTER,
 180                                                          NULL);
 181
 182         return TRUE;
 183 }
 184
 185 static void
 186 on_debugger_started (DmaMemory *mem)
 187 {
 188         /* Keep graphical interface if already existing, could happens after
 189          * unloading a program in the debugger */
 190         if (mem->window) return;
 191
 192         if (!dma_debugger_queue_is_supported (mem->debugger, HAS_MEMORY)) return;
 193
 194         if (!create_memory_gui (mem)) return;
 195
 196         /* Connect signals */
 197         g_signal_connect_swapped (mem->plugin, "debugger-stopped", G_CALLBACK (on_debugger_stopped), mem);
 198         g_signal_connect_swapped (mem->plugin, "program-stopped", G_CALLBACK (on_program_stopped), mem);
 199 }
 200
 201 /* Constructor & Destructor
 202  *---------------------------------------------------------------------------*/
 203
 204 DmaMemory*
 205 dma_memory_new(DebugManagerPlugin *plugin)
 206 {
 207         DmaMemory* mem;
 208
 209         mem = g_new0 (DmaMemory, 1);
 210
 211         mem->debugger = dma_debug_manager_get_queue (plugin);
 212         mem->plugin = ANJUTA_PLUGIN (plugin);
 213
 214         g_signal_connect_swapped (mem->plugin, "debugger-started", G_CALLBACK (on_debugger_started), mem);
 215
 216         return mem;
 217 }
 218
 219 void
 220 dma_memory_free(DmaMemory* mem)
 221 {
 222         g_return_if_fail (mem != NULL);
 223
 224         g_signal_handlers_disconnect_matched (mem->plugin, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, mem);
 225
 226         destroy_memory_gui (mem);
 227
 228         g_free(mem);
 229 }
 230
 231