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