void mem_rd_block(uint32_t a, uint8_t *d, uint16_t len)
{
int i;
for(i = 0; i < len; i++)
d[i] = mem_rd_byte(a+i);
}
// return value as string
static char* rd_mem_as_str(IO_DEF *t)
{
switch(t->size)
{
case 1: return g_strdup_printf("%02x", mem_rd_byte(t->addr)); break;
case 2: return g_strdup_printf("%04x", mem_rd_word(t->addr)); break;
case 4: return g_strdup_printf("%08x", mem_rd_long(t->addr)); break;
default: return g_strdup("???"); break;
}
return g_strdup("");
}
static int rd_bit(IO_DEF *s, int bit_num)
{
switch(s->size)
{
case 1: return mem_rd_byte(s->addr) & (1 << bit_num);
break;
case 2: return mem_rd_word(s->addr) & (1 << bit_num);
break;
case 4: return mem_rd_long(s->addr) & (1 << bit_num);
break;
}
return -1;
}
void mem_rd_block(uint32_t a, uint8_t *d, uint16_t len)
{
/*
int q = len / 4;
int r = len % 4;
int i, j;
for(i = 0; i < q; i++)
d[4*i] = mem_rd_long(a + 4*i);
for(j = 0; j < r; j++)
d[4*i+j] = mem_rd_byte(a + 4*i + j);
*/
int i;
for(i = 0; i < len; i++)
d[i] = mem_rd_byte(a+i);
}
// called when a check button has been toggled
static void renderer_toggled(GtkCellRendererToggle *cell,
gchar *path_string, gpointer user_data)
{
GtkWidget *tree = user_data;
GtkTreeView *view = GTK_TREE_VIEW(tree);
GtkTreeModel *model = gtk_tree_view_get_model(view);
GtkTreeStore *store = GTK_TREE_STORE(model);
GtkTreePath *path;
GtkTreeIter parent, iter;
IO_DEF *s;
gboolean state, result;
gchar* bit_str;
gint bit_num;
gchar* str;
path = gtk_tree_path_new_from_string(path_string);
if (!gtk_tree_model_get_iter(model, &iter, path))
return;
if (!gtk_tree_model_get_iter(model, &iter, path))
return;
gtk_tree_model_get(model, &iter,
COL_BTNACT, &state,
COL_S, &s,
COL_ADDR, &bit_str,
-1);
// change button state
state = !state;
sscanf(bit_str, "%i", &bit_num);
// change value in memory
switch(s->size)
{
case 1:
if(state)
mem_wr_byte(s->addr, (uint8_t)(mem_rd_byte(s->addr) | (1 << bit_num)));
else
mem_wr_byte(s->addr, (uint8_t)(mem_rd_byte(s->addr) & ~(1 << bit_num)));
break;
case 2:
if(state)
mem_wr_word(s->addr, (uint16_t)(mem_rd_word(s->addr) | (1 << bit_num)));
else
mem_wr_word(s->addr, (uint16_t)(mem_rd_word(s->addr) & ~(1 << bit_num)));
break;
case 4:
if(state)
mem_wr_long(s->addr, mem_rd_long(s->addr) | (1 << bit_num));
else
mem_wr_long(s->addr, mem_rd_long(s->addr) & ~(1 << bit_num));
break;
}
// and change displayed value (parent node)
gtk_tree_store_set(store, &iter, COL_BTNACT, state, -1);
g_free(bit_str);
result = gtk_tree_model_iter_parent(model, &parent, &iter);
if(result)
{
str = rd_mem_as_str(s);
gtk_tree_store_set(store, &parent, COL_VALUE, str, -1);
g_free(str);
}
}
static void renderer_edited(GtkCellRendererText * cell,
const gchar * path_string,
const gchar * new_text, gpointer user_data)
{
GtkWidget *list = user_data;
GtkTreeView *view = GTK_TREE_VIEW(list);
GtkTreeModel *model = gtk_tree_view_get_model(view);
GtkListStore *store = GTK_LIST_STORE(model);
GtkTreeViewColumn *column;
GtkTreeIter iter;
GtkTreePath *path;
gint col;
gchar *str_addr;
gchar *str_data = (char *)new_text;
int addr, data, i;
gchar *ascii, *utf;
gsize bw;
// get column
gtk_tree_view_get_cursor(view, &path, &column);
if(!path || !column)
return;
// get iterator
if (!gtk_tree_model_get_iter(model, &iter, path))
return;
// get address
col = column2index(list, column);
gtk_tree_model_get(model, &iter, COL_ADDR, &str_addr, COL_ASCII, &ascii, -1);
// check for new value
if((strlen(str_data) % 2) != 0)
{
gtk_tree_path_free(path);
return;
}
for(i = 0; i < (int)strlen(str_data); i++)
if(!isxdigit(str_data[i]))
{
gtk_tree_path_free(path);
return;
}
// set new value(s) and update memory
for(i = 0; (i < (int)strlen(str_data)/2) && ((col+i) <= COL_F); i++)
{
char digits[3];
int offset = col - COL_0 + i;
strncpy(digits, &new_text[2*i], 2);
digits[2] = '\0';
sscanf(str_addr, "%x", &addr);
sscanf(digits, "%x", &data);
mem_wr_byte(addr + offset, (uint8_t)data);
// don't rely on typed value
data = mem_rd_byte(addr + offset);
sprintf(digits, "%02x", data);
ascii[offset] = (isprint(data) && !iscntrl(data) ? data : '.');
gtk_list_store_set(store, &iter, col+i, digits, -1);
dbgstack_refresh_window(); // refresh stack, too
}
// and ascii area, too
utf = g_locale_to_utf8(ascii, -1, NULL, &bw, NULL);
gtk_list_store_set(store, &iter, COL_ASCII, utf, -1);
g_free(str_addr);
gtk_tree_path_free(path);
}
static void refresh_page(int page, int offset)
{
GtkNotebook *nb = GTK_NOTEBOOK(notebook);
GtkWidget *tab;
GtkWidget *label;
G_CONST_RETURN gchar *text;
uint32_t addr, len = DUMP_SIZE;
GList *l, *elt;
GtkWidget *list;
GtkTreeView *view;
GtkTreeModel *model;
GtkListStore *store;
gchar *str;
gint i;
// retrieve addr by tab name
tab = gtk_notebook_get_nth_page(nb, page);
label = gtk_notebook_get_tab_label(nb, tab);
text = gtk_label_get_text(GTK_LABEL(label));
// get list pointer (we have 1 child)
l = gtk_container_get_children(GTK_CONTAINER(nb));
elt = g_list_nth(l, page);
list = GTK_WIDGET(elt->data);
view = GTK_TREE_VIEW(list);
model = gtk_tree_view_get_model(view);
store = GTK_LIST_STORE(model);
// get new address
sscanf(text, "%x", &addr);
len = DUMP_SIZE;
addr += offset;
addr &= 0xffffff;
// refresh only if mem changed (speed-up)
#ifndef FORCE_REFRESH
if(!offset)
{
static uint8_t old_array[DUMP_SIZE] = { 0 };
gint diff = 0;
// can't use memcmp due to banking
for(i = 0; i < DUMP_SIZE; i++)
{
uint8_t old = old_array[i];
uint8_t mem = mem_rd_byte(addr + i);
if(old != mem)
{
old = mem;
diff = !0;
}
}
if(!diff) return;
}
#endif
// refresh tab
str = g_strdup_printf("%06x", addr);
gtk_label_set_text(GTK_LABEL(label), str);
g_free(str);
// and list
clist_refresh(store, addr, len <= DUMP_SIZE ? len : DUMP_SIZE);
// set column
for(i = COL_0; i <= COL_F; i++)
{
GtkTreeViewColumn *col;
col = gtk_tree_view_get_column(view, i);
str = g_strdup_printf("%X", (addr + i - 1) & 0xf);
gtk_tree_view_column_set_title(col, str);
g_free(str);
}
}
static void clist_populate(GtkListStore *store, uint32_t start, int length)
{
GtkTreeIter iter;
int i;
gchar *str;
char ascii[17];
uint32_t a;
GdkColor gray, black, red, white;
gboolean success;
GdkColor *color = &black;
//static uint8_t old[DUMP_SIZE] = { 0 };
//static uint8_t *old_ptr;
gdk_color_parse("DarkGray", &gray);
gdk_colormap_alloc_colors(gdk_colormap_get_system(), &gray, 1,
FALSE, FALSE, &success);
gdk_color_parse("Black", &black);
gdk_colormap_alloc_colors(gdk_colormap_get_system(), &black, 1,
FALSE, FALSE, &success);
gdk_color_parse("Red", &red);
gdk_colormap_alloc_colors(gdk_colormap_get_system(), &red, 1,
FALSE, FALSE, &success);
gdk_color_parse("White", &white);
gdk_colormap_alloc_colors(gdk_colormap_get_system(), &white, 1,
FALSE, FALSE, &success);
//old_ptr = old;
for(a = start; a < start+length; a += 0x10)
{
uint32_t addr = a & 0xffffff;
uint8_t mem;
char *utf;
gsize bw;
gtk_list_store_append(store, &iter);
str = g_strdup_printf("%06x", addr);
gtk_list_store_set(store, &iter,
COL_ADDR, str,
COL_GRAY, &gray,
-1);
g_free(str);
if(options3.dbg_font_type)
gtk_list_store_set(store, &iter, COL_FONT, options3.dbg_font_name, -1);
else
gtk_list_store_set(store, &iter, COL_FONT, "courier", -1);
for(i = COL_0; i <= COL_F; i++)
{
if(addr + (i-COL_0) != 0x60000f)
mem = mem_rd_byte(addr + (i-COL_0));
else
mem = 0xff;
str = g_strdup_printf("%02x", mem);
ascii[i-COL_0] = (isprint(mem) && !iscntrl(mem) ? mem : '.');
/*
if(*old_ptr != *mem_ptr)
{
*old_ptr++ = *mem_ptr;
color = &red;
printf("$");
}
else
{
old_ptr++;
color = &black;
printf(".");
}
*/
gtk_list_store_set(store, &iter,
i, str,
COL_EDITABLE, TRUE,
COL_COLOR, color,
i + CLIST_NVCOLS - COL_0, &white,
-1);
g_free(str);
}
ascii[16] = '\0';
utf = g_locale_to_utf8(ascii, -1, NULL, &bw, NULL);
gtk_list_store_set(store, &iter, COL_ASCII, utf, -1);
}
}
static gint search_engine(char *str, int ascii, int casse, uint32_t *address, int *length)
{
uint8_t *data;
uint16_t len;
gchar *tmp;
gint i;
uint32_t addr;
data = (uint8_t *) g_strdup((gchar *) str);
len = strlen((char *) data);
// ASCII mode ?
if(!ascii)
{
char *p, *q;
// compact string
p = str;
q = tmp = g_strdup(str);
while(*p)
{
if(*p != ' ')
*q++ = *p++;
else
p++;
}
*q = '\0';
// and converts
len = strlen(tmp) / 2;
for(i = 0; i < len; i++)
{
char digits[3];
unsigned int temp;
strncpy(digits, &tmp[2*i], 2);
digits[2] = '\0';
sscanf(digits, "%02x", &temp);
data[i] = temp;
}
g_free(tmp);
}
// search (we don't use memcmp because mem space may be not contiguous)
i = 0;
for(addr = *address; addr <= 0xffffff; addr++)
{
if(mem_rd_byte(addr) == data[i])
i++;
else
i = 0;
if(i == len)
break;
}
if(i == len)
{
*address = addr - len + 1;
*length = len;
return !0;
}
return 0;
}
