← Back to branch summary

~ubuntu-branches/ubuntu/breezy/tiemu/breezy

« back to all changes in this revision

Viewing changes to src/gui/gtk/debug_cb.c

  • Committer: Bazaar Package Importer
  • Author(s): Julien BLACHE
  • Date: 2005-06-02 16:50:15 UTC
  • mfrom: (1.2.1 upstream) (2.1.1 sarge)
  • Revision ID: james.westby@ubuntu.com-20050602165015-59ab24414tl2wzol
Tags: 1.99+svn1460-1
* New snapshot.
* debian/control:
  + Updated build-depends.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gui/gtk/debug_cb.c
1
 
#ifdef HAVE_CONFIG_H
2
 
#  include <config.h>
3
 
#endif
4
 
 
5
 
#include <stdlib.h>
6
 
#include <gtk/gtk.h>
7
 
#include <ctype.h>
8
 
 
9
 
#include "debug_cb.h"
10
 
#include "debug_dbox.h"
11
 
#include "support.h"
12
 
 
13
 
#include "interface.h"
14
 
#include "platform.h"
15
 
#include "struct.h"
16
 
#include "ticalc.h"
17
 
#include "paths.h"
18
 
#include "support.h"
19
 
#include "gxpm.h"
20
 
#include "pgmentbkpt_dbox.h"
21
 
#include "pgmentbkpt_cb.h"
22
 
#include "trap_dbox.h"
23
 
#include "trap_cb.h"
24
 
#include "dbgopt_dbox.h"
25
 
#include "dbgopt_cb.h"
26
 
#include "msg_cb.h"
27
 
#include "dbkpt_dbox.h"
28
 
#include "dbkpt_cb.h"
29
 
#include "bkpt_cause.h"
30
 
#include "main.h"
31
 
 
32
 
#include "sysdeps.h"
33
 
 
34
 
#define DEBUG_LINES 20
35
 
 
36
 
/* Used widget */
37
 
static GtkWidget *debugger_dbox = NULL;
38
 
static GtkWidget *code_clist;
39
 
static GtkWidget *mem_clist;
40
 
static GtkWidget *stack_clist;
41
 
static GtkWidget *reg_text;
42
 
static GtkWidget *statusbar; // statusbar
43
 
 
44
 
gint refresh_register_dbox();
45
 
gint refresh_code_dbox();
46
 
gint refresh_stack_dbox();
47
 
gint refresh_memory_dbox();
48
 
 
49
 
gint display_debugger_dbox(void)
50
 
{
51
 
  GtkWidget *dbox;
52
 
  gpointer user_data;
53
 
  
54
 
  if(debugger_dbox == NULL)
55
 
    {
56
 
      dbox = create_debugger_dbox();
57
 
      
58
 
      user_data = gtk_object_get_data(GTK_OBJECT(dbox), "debugger_dbox");
59
 
      debugger_dbox = GTK_WIDGET(user_data);
60
 
      
61
 
      user_data = gtk_object_get_data(GTK_OBJECT(dbox), "text5");
62
 
      reg_text = GTK_WIDGET(user_data);
63
 
      
64
 
      user_data = gtk_object_get_data(GTK_OBJECT(dbox), "clist1");
65
 
      code_clist = GTK_WIDGET(user_data);
66
 
      
67
 
      user_data = gtk_object_get_data(GTK_OBJECT(dbox), "clist2");
68
 
      mem_clist = GTK_WIDGET(user_data);
69
 
      
70
 
      user_data = gtk_object_get_data(GTK_OBJECT(dbox), "clist3");
71
 
      stack_clist = GTK_WIDGET(user_data);
72
 
      
73
 
      user_data = gtk_object_get_data(GTK_OBJECT(dbox), "statusbar1");
74
 
      statusbar = GTK_WIDGET(user_data);
75
 
      
76
 
      gtk_widget_show_all(dbox);
77
 
      display_bkpt_cause();
78
 
    }
79
 
  else
80
 
    {
81
 
    }
82
 
  refresh_stack_dbox();
83
 
  refresh_memory_dbox();
84
 
  refresh_code_dbox();
85
 
  refresh_register_dbox();
86
 
      
87
 
  return 0;
88
 
}
89
 
 
90
 
 
91
 
/* Local persistant variables */
92
 
 GtkWidget *data_bkpt_dbox = NULL;
93
 
 gint data_bkpt_selected_row = -1;
94
 
 gint bkpt_encountered = 0;
95
 
 gint data_addr = 0x000000;
96
 
 gint selected_row = -1;
97
 
 
98
 
/* Some linked-list for breakpoints */
99
 
GList *bkpt_address_list = NULL;
100
 
GList *bkpt_access_list = NULL;
101
 
GList *bkpt_vector_list = NULL;
102
 
GList *bkpt_trap_list = NULL;
103
 
 
104
 
 
105
 
/*****************/
106
 
/* Debugger dbox */
107
 
/*****************/
108
 
 
109
 
static int put_in_sb(gchar *s)
110
 
{
111
 
  gint id;
112
 
 
113
 
  id = gtk_statusbar_get_context_id(GTK_STATUSBAR(statusbar), s);
114
 
  gtk_statusbar_push(GTK_STATUSBAR(statusbar), id, s);
115
 
 
116
 
  return id;
117
 
}
118
 
 
119
 
 
120
 
/*
121
 
  Called when the Debuger dbox is displayed
122
 
*/
123
 
void
124
 
on_debugger_dbox_show                  (GtkWidget       *widget,
125
 
                                        gpointer         user_data)
126
 
{
127
 
}
128
 
 
129
 
 
130
 
/*
131
 
  Called when the Debugger Dbox is destroyed 
132
 
*/
133
 
void
134
 
on_debugger_dbox_destroy               (GtkObject       *object,
135
 
                                        gpointer         user_data)
136
 
{
137
 
  gint i;
138
 
  CODE_BKPT *s;
139
 
 
140
 
  // The debugger dbox is not active any longer
141
 
  code_clist = NULL;
142
 
  debugger_dbox = NULL;
143
 
 
144
 
  // Restore breakpoints
145
 
  // Bkpts are removed when the debugger is launched so
146
 
  // that we can 'single step'
147
 
  for(i=0; i<g_list_length(bkpt_address_list); i++)
148
 
    {
149
 
      s = (CODE_BKPT *)g_list_nth_data(bkpt_address_list, i);
150
 
      
151
 
      ti68k_setBreakpointAddress(s->address);
152
 
    }
153
 
  
154
 
  // Emulation core in free running
155
 
  unhalt();
156
 
}
157
 
 
158
 
 
159
 
/*
160
 
  Initialize the 'Registers' box
161
 
*/
162
 
gint refresh_register_dbox()
163
 
{
164
 
  GtkWidget *text = reg_text;
165
 
  GdkColormap *cmap;
166
 
  GdkColor colour;
167
 
  GdkFont *fixed_font;
168
 
  gint i;
169
 
  gchar buffer[MAXCHARS];
170
 
  static gint prev_Dx[8] = {0, 0, 0, 0, 0, 0, 0, 0};
171
 
  static gint prev_Ax[8] = {0, 0, 0, 0, 0, 0, 0, 0};
172
 
  static gint prev_SP = 0;
173
 
  static gint prev_SR = 0;
174
 
  static gint prev_PC = 0;
175
 
 
176
 
  if(text != NULL)
177
 
    gtk_editable_delete_text((GtkEditable *)text, 0, -1);
178
 
 
179
 
  cmap = gdk_colormap_get_system();
180
 
  colour.red = 0xffff;
181
 
  colour.green = 0;
182
 
  colour.blue = 0;
183
 
  if (!gdk_color_alloc(cmap, &colour)) 
184
 
    {
185
 
      g_error("couldn't allocate colour");
186
 
    }
187
 
 
188
 
  //fixed_font = gdk_font_load ("-misc-fixed-medium-r-*-*-*-100-*-*-*-*-*-*");
189
 
  fixed_font = gdk_font_load("-adobe-helvetica-bold-r-normal--12-120-75-75-p-70-iso8859-1");
190
 
 
191
 
  gtk_widget_realize (text);
192
 
  gtk_text_freeze (GTK_TEXT (text));
193
 
  
194
 
  /* Display the Dx & Ax registers */
195
 
  for(i=0; i<8; i++)
196
 
    {
197
 
      sprintf(buffer, "D%i=%08X", i, ti68k_getDataRegister(i));
198
 
      if(prev_Dx[i] == ti68k_getDataRegister(i))
199
 
        gtk_text_insert(GTK_TEXT(text), fixed_font, &text->style->black, 
200
 
                        NULL, buffer, -1);
201
 
      else
202
 
        gtk_text_insert(GTK_TEXT(text), fixed_font, &colour, 
203
 
                        NULL, buffer, -1);
204
 
      
205
 
      sprintf(buffer, "  ");
206
 
      gtk_text_insert(GTK_TEXT(text), fixed_font, &text->style->black, 
207
 
                      NULL, buffer, -1);
208
 
      
209
 
      sprintf(buffer, "A%i=%08X\n", i, ti68k_getAddressRegister(i));
210
 
      if(prev_Ax[i] == ti68k_getAddressRegister(i))
211
 
        gtk_text_insert(GTK_TEXT(text), fixed_font, &text->style->black, 
212
 
                        NULL, buffer, -1);
213
 
      else
214
 
        gtk_text_insert(GTK_TEXT(text), fixed_font, &colour, 
215
 
                        NULL, buffer, -1);
216
 
    }
217
 
 
218
 
  gtk_text_insert(GTK_TEXT(text), fixed_font, &text->style->black, 
219
 
                  NULL, "\n", -1);
220
 
  
221
 
  /* Display the SP register */
222
 
  sprintf(buffer, "SP=%06X\n", ti68k_getSpRegister());
223
 
  if(prev_SP == ti68k_getSpRegister())
224
 
    gtk_text_insert(GTK_TEXT(text), fixed_font, &text->style->black, 
225
 
                    NULL, buffer, -1);
226
 
  else
227
 
    gtk_text_insert(GTK_TEXT(text), fixed_font, &colour, NULL, buffer, -1);
228
 
 
229
 
  /* Display the SR register */
230
 
  sprintf(buffer, "SR=%04X      ", ti68k_getSrRegister());
231
 
  if(prev_SR == ti68k_getSrRegister())
232
 
    gtk_text_insert(GTK_TEXT(text), fixed_font, &text->style->black, 
233
 
                    NULL, buffer, -1);
234
 
  else
235
 
    gtk_text_insert(GTK_TEXT(text), fixed_font, &colour, NULL, buffer, -1);
236
 
 
237
 
  /* Display the PC register */
238
 
  sprintf(buffer, "PC=%06X  \n", ti68k_getPcRegister());
239
 
  if(prev_PC == ti68k_getPcRegister())
240
 
    gtk_text_insert(GTK_TEXT(text), fixed_font, &text->style->black, 
241
 
                    NULL, buffer, -1);
242
 
  else
243
 
    gtk_text_insert(GTK_TEXT(text), fixed_font, &colour, NULL, buffer, -1);
244
 
 
245
 
  /* Display the status flag register */
246
 
  /*
247
 
  sprintf(buffer, "T=%i  S=%i  M=%i  I=%i  \n", 0, 0, 0, 0);
248
 
  gtk_text_insert(GTK_TEXT(text), fixed_font, &text->style->black, 
249
 
                  NULL, buffer, -1);
250
 
 
251
 
  sprintf(buffer, "X=%i  N=%i  Z=%i  V=%i  C=%i\n", 0, 0, 0, 0, 0);
252
 
  gtk_text_insert(GTK_TEXT(text), fixed_font, &text->style->black, 
253
 
                  NULL, buffer, -1);
254
 
  */
255
 
  gtk_text_insert(GTK_TEXT(text), fixed_font, &text->style->black,
256
 
                  NULL, ti68k_getFlagRegister(), -1);
257
 
  reg_text = text;
258
 
 
259
 
  gtk_text_thaw (GTK_TEXT (text));
260
 
 
261
 
  /* Store old values for colour display */
262
 
  for(i=0; i<8; i++)
263
 
    {
264
 
      prev_Dx[i] = ti68k_getDataRegister(i);
265
 
      prev_Ax[i] = ti68k_getAddressRegister(i);
266
 
    }
267
 
  prev_SR = ti68k_getSrRegister();
268
 
  prev_SP = ti68k_getSpRegister();
269
 
  prev_PC = ti68k_getPcRegister();
270
 
 
271
 
  return 0;
272
 
}
273
 
 
274
 
/*
275
 
  Initialize the 'code/disasm' box
276
 
*/
277
 
 
278
 
/* Utility function */
279
 
gint refresh_breakpoints(GtkWidget *widget)
280
 
{
281
 
  GtkWidget *clist = code_clist;
282
 
  GdkPixmap *pixmap_run;
283
 
  GdkBitmap *mask_run;
284
 
  GdkPixmap *pixmap_bkpt;
285
 
  GdkBitmap *mask_bkpt;
286
 
  GdkPixmap *pixmap_void;
287
 
  GdkBitmap *mask_void;
288
 
  gint i, j;
289
 
  CODE_BKPT *s1;
290
 
  gint addr1, addr2, addr;
291
 
  gint res;
292
 
 
293
 
  /* Load pixmaps */
294
 
  open_xpm("run.xpm", widget, &pixmap_run, &mask_run);
295
 
  open_xpm("bkpt.xpm", widget, &pixmap_bkpt, &mask_bkpt);
296
 
  open_xpm("void.xpm", widget, &pixmap_void, &mask_void);
297
 
 
298
 
  /* Erase pixmaps entries */
299
 
  for(j=0; j<DEBUG_LINES; j++)
300
 
    {
301
 
      gtk_clist_set_pixmap((GtkCList *)clist, j, 0, 
302
 
                           pixmap_void, mask_void);
303
 
    }
304
 
 
305
 
  /* Fill the clist */
306
 
  gtk_clist_freeze((GtkCList *)clist);
307
 
  //printf("list length: %i, %p\n", g_list_length(bkpt_address_list), bkpt_address_list);
308
 
  for(i=0; i<g_list_length(bkpt_address_list); i++)
309
 
    {
310
 
      s1 = (CODE_BKPT *)g_list_nth_data(bkpt_address_list, i);
311
 
      addr1 = s1->address;
312
 
      //printf("Breakpoint to localize at 0x%06x\n", addr1);
313
 
 
314
 
      for(j=0; j<DEBUG_LINES; j++)
315
 
        {
316
 
          addr2 = GPOINTER_TO_INT(gtk_clist_get_row_data((GtkCList *)clist, 
317
 
                                                         j));
318
 
          //printf("Address localized: 0x%06x\n", addr2);
319
 
 
320
 
          if(addr1 == addr2)
321
 
            {
322
 
              //printf("Bkpt localized: 0x%06x at clist line %i\n", addr2, j);
323
 
              gtk_clist_set_pixmap((GtkCList *)clist, j, 0, 
324
 
                                   pixmap_bkpt, mask_bkpt);
325
 
            }
326
 
          else
327
 
            {
328
 
            }
329
 
          //fprintf(stderr, "<%06X %06X>\n", addr2, getPcRegister());
330
 
        }
331
 
    }
332
 
 
333
 
  /* Update the run arrow */
334
 
  addr = ti68k_getPcRegister();
335
 
  //fprintf(stdout, "PC in refresh: %06X\n", ti68k_getPcRegister());
336
 
  res = gtk_clist_find_row_from_data((GtkCList *)clist, GINT_TO_POINTER(addr));
337
 
  //fprintf(stdout, "row in refresh: %i\n", res);
338
 
  if(res != -1)
339
 
    { // row found
340
 
      gtk_clist_set_pixmap((GtkCList *)clist, res, 0, pixmap_run, mask_run);
341
 
    }
342
 
  printf("\n");
343
 
 
344
 
  gdk_pixmap_unref(pixmap_run);
345
 
  gdk_pixmap_unref(pixmap_bkpt);
346
 
  gdk_pixmap_unref(pixmap_void);
347
 
 
348
 
  gtk_clist_thaw((GtkCList *)clist);  
349
 
  return 0;
350
 
}
351
 
 
352
 
gint refresh_code_dbox()
353
 
{
354
 
  GtkWidget *clist = code_clist;
355
 
  gchar *row_text[3];
356
 
  gint i, k;
357
 
  gint addr = ti68k_getPcRegister();
358
 
  gint offset;
359
 
  gchar buffer[MAXCHARS];
360
 
  GtkStyle *style;
361
 
  GdkFont *fixed_font;
362
 
  gint cw;
363
 
  gint row;
364
 
 
365
 
  /* Check if necessary to refresh the clist box */
366
 
  if(clist != NULL)
367
 
    {
368
 
      //fprintf(stderr, "PC: %06X\n", getPcRegister());
369
 
      row = gtk_clist_find_row_from_data((GtkCList *)clist, 
370
 
                                         GINT_TO_POINTER(ti68k_getPcRegister()));
371
 
      //fprintf(stdout, "row: %i\n", row);
372
 
      if(row != -1)
373
 
        { // row not found: address is outside, reload disasm
374
 
          refresh_breakpoints(debugger_dbox);
375
 
          return -1;
376
 
        }
377
 
    }
378
 
 
379
 
  /* Load a font */
380
 
  //fixed_font = gdk_font_load ("-misc-fixed-medium-r-*-*-*-100-*-*-*-*-*-*");
381
 
  fixed_font = gdk_font_load("-adobe-helvetica-bold-r-normal--12-120-75-75-p-70-iso8859-1");
382
 
 
383
 
  style = gtk_style_new();
384
 
  style->font = fixed_font;
385
 
  cw = gdk_char_width(fixed_font, 'A');
386
 
 
387
 
  gtk_clist_set_column_width((GtkCList *)clist, 0, 1*cw);
388
 
  gtk_clist_set_column_width((GtkCList *)clist, 1, 10*cw);
389
 
  gtk_clist_set_column_width((GtkCList *)clist, 2, 24*cw);
390
 
 
391
 
  /* Fill the clist */
392
 
  gtk_clist_freeze((GtkCList *)clist);
393
 
  for(i=0; i<options.code_lines; i++)
394
 
    gtk_clist_remove((GtkCList *)clist, 0);
395
 
  for(i=0; i<3; i++) row_text[i] = NULL;
396
 
  for(i=0; i<options.code_lines; i++)
397
 
    {
398
 
      offset = ti68k_disasm(addr, buffer);
399
 
      row_text[1] = g_strdup(buffer);
400
 
      row_text[1][9] = '\0';
401
 
      row_text[2] = g_strdup(buffer+10);
402
 
 
403
 
      gtk_clist_append((GtkCList *)clist, row_text);
404
 
      gtk_clist_set_row_data((GtkCList *)clist, i, 
405
 
                             GINT_TO_POINTER(addr)); // add addr to clist data
406
 
      //fprintf(stderr, "%i: %06X\n", i, addr);
407
 
      gtk_clist_set_row_style((GtkCList *)clist, i, style);
408
 
 
409
 
      addr += offset;
410
 
 
411
 
      for(k=0; k<3; k++)
412
 
        {
413
 
          g_free(row_text[k]);
414
 
        } 
415
 
    }
416
 
 
417
 
  /* Refresh breakpoints */
418
 
  //printf("clist pointer: %p\n", clist);
419
 
  refresh_breakpoints(debugger_dbox);
420
 
 
421
 
  gtk_clist_thaw((GtkCList *)clist);
422
 
  return 0;
423
 
}
424
 
 
425
 
/*
426
 
  Initialize the 'memory' box
427
 
*/
428
 
gint refresh_memory_dbox()
429
 
{
430
 
  GtkWidget *clist = mem_clist;
431
 
  GtkStyle *style;
432
 
  GdkColormap *cmap;
433
 
  GdkColor colour;
434
 
  GdkFont *fixed_font;
435
 
  gchar *row_text[3];
436
 
  gint i, j, k;
437
 
  UBYTE *ti_ram = (UBYTE *)ti68k_getRamPtr();
438
 
  gint cw;
439
 
  gint addr = data_addr;
440
 
 
441
 
  /* Load the colormap */
442
 
  cmap = gdk_colormap_get_system();
443
 
  colour.red = 0xffff;
444
 
  colour.green = 0;
445
 
  colour.blue = 0;
446
 
  if (!gdk_color_alloc(cmap, &colour)) 
447
 
    {
448
 
      g_error("couldn't allocate colour");
449
 
    }
450
 
  
451
 
  /* Load a font */
452
 
  //fixed_font = gdk_font_load ("-misc-fixed-medium-r-*-*-*-100-*-*-*-*-*-*");
453
 
  fixed_font = gdk_font_load("-adobe-helvetica-bold-r-normal--12-120-75-75-p-70-iso8859-1");
454
 
  style = gtk_style_new();
455
 
  style->font = fixed_font;
456
 
  //style->text[GTK_STATE_NORMAL] = colour;
457
 
  cw = gdk_char_width(fixed_font, 'A');
458
 
 
459
 
  gtk_clist_set_column_width((GtkCList *)clist, 0, 7*cw);
460
 
  gtk_clist_set_column_width((GtkCList *)clist, 1, 25*cw);
461
 
  gtk_clist_set_column_width((GtkCList *)clist, 2, 9*cw);
462
 
 
463
 
  /* Fill the clist */
464
 
  gtk_clist_freeze((GtkCList *)clist);  
465
 
  for(i=0; i<options.mem_lines; i++)
466
 
    gtk_clist_remove((GtkCList *)clist, 0);
467
 
  for(j=0; j<3; j++) 
468
 
    row_text[j] = NULL;
469
 
  for(j=0; j<options.mem_lines; j++, addr+=8)
470
 
    {
471
 
      row_text[0] = g_strdup_printf("%06X", addr);
472
 
      row_text[1] = g_strdup_printf("%02X %02X %02X %02X %02X %02X %02X %02X ",
473
 
                                    ti_ram[addr+0], ti_ram[addr+1],
474
 
                                    ti_ram[addr+2], ti_ram[addr+3],
475
 
                                    ti_ram[addr+4], ti_ram[addr+5],
476
 
                                    ti_ram[addr+6], ti_ram[addr+7]);
477
 
      
478
 
      row_text[2] = g_strdup_printf("%c%c%c%c%c%c%c%c", 
479
 
                                    isprint(ti_ram[addr+0]) ? ti_ram[addr+0] : '.',
480
 
                                    isprint(ti_ram[addr+1]) ? ti_ram[addr+1] : '.',
481
 
                                    isprint(ti_ram[addr+2]) ? ti_ram[addr+2] : '.',
482
 
                                    isprint(ti_ram[addr+3]) ? ti_ram[addr+3] : '.',
483
 
                                    isprint(ti_ram[addr+4]) ? ti_ram[addr+4] : '.',
484
 
                                    isprint(ti_ram[addr+5]) ? ti_ram[addr+5] : '.',
485
 
                                    isprint(ti_ram[addr+6]) ? ti_ram[addr+6] : '.',
486
 
                                    isprint(ti_ram[addr+7]) ? ti_ram[addr+7] : '.');
487
 
 
488
 
      gtk_clist_append((GtkCList *)clist, row_text);
489
 
      gtk_clist_set_row_style((GtkCList *)clist, j, style);
490
 
 
491
 
      for(k=0; k<3; k++)
492
 
        {
493
 
          //fprintf(stderr, "<%i %p %s>\n", k, row_text[k], row_text[k]); // bug here !!!
494
 
          g_free(row_text[k]);
495
 
        }
496
 
    }
497
 
  
498
 
  gtk_clist_thaw((GtkCList *)clist);
499
 
  return 0;
500
 
}
501
 
 
502
 
/*
503
 
  Initialize the 'stack' box
504
 
*/
505
 
gint refresh_stack_dbox()
506
 
{
507
 
  GtkWidget *clist = stack_clist;
508
 
  GtkStyle *style;
509
 
  GdkFont *fixed_font;
510
 
  gchar *row_text[2];
511
 
  gint i, k;
512
 
  gint sp = ti68k_getSpRegister();
513
 
  UWORD *ti_ram = (UWORD *)ti68k_getRamPtr();
514
 
  gint addr;
515
 
  gint cw;
516
 
 
517
 
  /* Load a font */
518
 
  //fixed_font = gdk_font_load ("-misc-fixed-medium-r-*-*-*-100-*-*-*-*-*-*");
519
 
  fixed_font = gdk_font_load("-adobe-helvetica-bold-r-normal--12-120-75-75-p-70-iso8859-1");
520
 
  style = gtk_style_new();
521
 
  style->font = fixed_font;
522
 
  cw = gdk_char_width(fixed_font, 'A');
523
 
 
524
 
  gtk_clist_set_column_width((GtkCList *)clist, 0, 8*cw);
525
 
  gtk_clist_set_column_width((GtkCList *)clist, 1, 10*cw);
526
 
 
527
 
  /* Fill the clist */
528
 
  gtk_clist_freeze((GtkCList *)clist);
529
 
  for(i=0; i<options.stack_lines; i++)
530
 
    gtk_clist_remove((GtkCList *)clist, 0);
531
 
  for(i=0; i<2; i++) 
532
 
    row_text[i] = NULL;
533
 
  for(i=0, addr = sp; i<10; i++, addr += 2)
534
 
    {
535
 
      row_text[0] = g_strdup_printf("%06X:", addr);
536
 
      row_text[1] = g_strdup_printf("%04X", ti_ram[addr]);
537
 
      
538
 
      gtk_clist_append((GtkCList *)clist, row_text);
539
 
      gtk_clist_set_row_style((GtkCList *)clist, i, style);
540
 
    
541
 
      for(k=0; k<2; k++)
542
 
        {
543
 
          g_free(row_text[k]);
544
 
        }
545
 
    }
546
 
      
547
 
  gtk_clist_thaw((GtkCList *)clist);
548
 
  return 0;
549
 
}
550
 
 
551
 
 
552
 
/********************************/
553
 
/* Debugger dbox menu callbacks */
554
 
/********************************/
555
 
 
556
 
/*
557
 
  Debug|Run (F5)
558
 
*/
559
 
void
560
 
on_run1_activate                       (GtkMenuItem     *menuitem,
561
 
                                        gpointer         user_data)
562
 
{
563
 
  put_in_sb(_("Running..."));
564
 
 
565
 
  // Run the emulation core
566
 
  unhalt();
567
 
}
568
 
 
569
 
 
570
 
/*
571
 
  Debug|Step (F7)
572
 
*/
573
 
 
574
 
void
575
 
on_step1_activate                      (GtkMenuItem     *menuitem,
576
 
                                        gpointer         user_data)
577
 
{
578
 
  gint addr;
579
 
 
580
 
  put_in_sb(_("One step (F7)"));
581
 
  DISPLAY("Step (F7)\n");
582
 
 
583
 
  // Set up an internal trap (DBTRACE) which will launch/refresh the
584
 
  // debugger when encountered
585
 
  addr = ti68k_getPcRegister();
586
 
  DISPLAY("addr=$%06x\n", addr);
587
 
  ti68k_doSingleStep(); // set trap
588
 
  unhalt();    // emulator in free running
589
 
}
590
 
 
591
 
 
592
 
void
593
 
on_step_over1_activate                 (GtkMenuItem     *menuitem,
594
 
                                        gpointer         user_data)
595
 
{
596
 
  //gint addr;
597
 
  
598
 
  put_in_sb(_("Step over."));
599
 
  fprintf(stderr, "Step over (F8): not yet implemented\n");
600
 
 
601
 
  /* Execute one instruction */
602
 
  //bkpt_encountered = !doInstructions(1, 0);
603
 
 
604
 
  /* Refresh the 'code' dbox by sending the 'show' signal */
605
 
  gtk_signal_emit_by_name((GtkObject *)debugger_dbox, "show");
606
 
  
607
 
  /* Refres_breakpoints */
608
 
  refresh_breakpoints(code_clist);
609
 
}
610
 
 
611
 
 
612
 
/*
613
 
  Run up to cursor (F4)
614
 
*/
615
 
void
616
 
on_run_to_cursor1_activate             (GtkMenuItem     *menuitem,
617
 
                                        gpointer         user_data)
618
 
{
619
 
  gint addr_to_go, next_addr;
620
 
  gint i;
621
 
  gchar buffer[64];
622
 
 
623
 
  put_in_sb(_("Ran up to cursor."));
624
 
  fprintf(stderr, "Run to cursor (F4)\n");
625
 
 
626
 
  /* Execute some instructions */
627
 
  if(selected_row != -1)
628
 
    {
629
 
      printf("PC: 0x%06x\n", ti68k_getPcRegister());
630
 
      addr_to_go = GPOINTER_TO_INT(gtk_clist_get_row_data((GtkCList *)code_clist, selected_row));
631
 
      printf("addr to go: 0x%06x\n", addr_to_go);
632
 
      for(i=1, next_addr = ti68k_getPcRegister(); next_addr < addr_to_go; i++)
633
 
        {
634
 
          next_addr += ti68k_disasm(next_addr, buffer);
635
 
          printf("-> buffer: <%s>\n", buffer);
636
 
          if(i > options.code_lines)
637
 
            break;
638
 
        }
639
 
      //bkpt_encountered = !doInstructions(i, 0);
640
 
    }
641
 
  else
642
 
    return; 
643
 
  
644
 
  /* Refresh the 'code' dbox by sending the 'show' signal */
645
 
  gtk_signal_emit_by_name((GtkObject *)debugger_dbox, "show");
646
 
  
647
 
  /* Refres_breakpoints */
648
 
  refresh_breakpoints(code_clist);
649
 
}
650
 
 
651
 
 
652
 
/*
653
 
  Debug|Break (F11)
654
 
*/
655
 
void
656
 
on_break1_activate                     (GtkMenuItem     *menuitem,
657
 
                                        gpointer         user_data)
658
 
{
659
 
  gint i;
660
 
  gint addr;
661
 
  //GtkWidget *clist = code_clist;
662
 
  CODE_BKPT *s;
663
 
 
664
 
  put_in_sb(_("Break !"));
665
 
  halt();
666
 
  fprintf(stderr, "Break (F11)\n");
667
 
 
668
 
  /* Place a breakpoint */
669
 
  addr = ti68k_getPcRegister();
670
 
  //addr = getPcRegister() + disasm(getPcRegister(), buffer);
671
 
  i = ti68k_setBreakpointAddress(addr);
672
 
 
673
 
  s = (CODE_BKPT *)g_malloc(sizeof(CODE_BKPT));
674
 
  s->address = addr;
675
 
  s->id = i;
676
 
  bkpt_address_list = g_list_append(bkpt_address_list, s);
677
 
 
678
 
  /* Refresh the 'code' dbox by sending the 'show' signal */
679
 
  gtk_signal_emit_by_name((GtkObject *)debugger_dbox, "show");
680
 
  
681
 
  /* Refres_breakpoints */
682
 
  refresh_breakpoints(code_clist);
683
 
}
684
 
 
685
 
 
686
 
/* Quit the 'Debugger' window */
687
 
void
688
 
on_exit2_activate                      (GtkMenuItem     *menuitem,
689
 
                                        gpointer         user_data)
690
 
{
691
 
  gtk_widget_destroy(GTK_WIDGET(user_data));
692
 
}
693
 
 
694
 
 
695
 
void
696
 
on_set_breakpoint_at_selection1_activate
697
 
                                        (GtkMenuItem     *menuitem,
698
 
                                        gpointer         user_data)
699
 
{
700
 
  GtkWidget *clist = code_clist; //user_data;
701
 
  GdkPixmap *pixmap;
702
 
  GdkBitmap *mask;
703
 
  gint addr;
704
 
  gint i;
705
 
  CODE_BKPT *s, *s1;
706
 
 
707
 
  put_in_sb(_("Breakpoint added."));
708
 
  fprintf(stderr, "Breakpoints|Set bkpt at selection (F2)\n");
709
 
  //fprintf(stderr, "clist: %p\n", clist);
710
 
  /* Retrieve the selected line and its address */
711
 
  if(selected_row != -1)
712
 
    {
713
 
      addr = GPOINTER_TO_INT(gtk_clist_get_row_data((GtkCList *)clist, 
714
 
                                                    selected_row));
715
 
      /* Check whether we already have a breakpoint */      
716
 
      for(i=0; i<g_list_length(bkpt_address_list); i++)
717
 
        {
718
 
          s1 = (CODE_BKPT *)g_list_nth_data(bkpt_address_list, i);
719
 
          if(addr == s1->address)
720
 
            {
721
 
              /* If yes, then remove it (toggle bkpt) */
722
 
              ti68k_delBreakpointAddress(s1->id);
723
 
              bkpt_address_list = g_list_remove(bkpt_address_list, s1);
724
 
              g_free(s1);
725
 
              printf("Bkpt toggled\n");
726
 
              refresh_breakpoints(code_clist);
727
 
 
728
 
              return;
729
 
            }
730
 
        }
731
 
    }
732
 
  else
733
 
    {
734
 
      addr = ti68k_getPcRegister();
735
 
    }
736
 
    
737
 
  /* Place a breakpoint */
738
 
  fprintf(stdout, "Place a breakpoint at %06X\n", addr);
739
 
  i = ti68k_setBreakpointAddress(addr);
740
 
  
741
 
  s = (CODE_BKPT *)g_malloc(sizeof(CODE_BKPT));
742
 
  s->address = addr;
743
 
  s->id = i;
744
 
  bkpt_address_list = g_list_append(bkpt_address_list, s);
745
 
  
746
 
  open_xpm("bkpt.xpm", code_clist, &pixmap, &mask);
747
 
  gtk_clist_set_pixmap((GtkCList *)clist, selected_row, 0, pixmap, mask);
748
 
  gdk_pixmap_unref(pixmap);
749
 
}
750
 
 
751
 
 
752
 
void
753
 
on_set_breakpoint_on_program_entry1_activate
754
 
                                        (GtkMenuItem     *menuitem,
755
 
                                        gpointer         user_data)
756
 
{
757
 
  display_pgmentrybkpt_dbox ();
758
 
}
759
 
 
760
 
 
761
 
void
762
 
on_set_breakpoint_on_trap_exception1_activate
763
 
                                        (GtkMenuItem     *menuitem,
764
 
                                        gpointer         user_data)
765
 
{
766
 
  display_trap_dbox();
767
 
}
768
 
 
769
 
 
770
 
void
771
 
on_set_data_breakpoint1_activate       (GtkMenuItem     *menuitem,
772
 
                                        gpointer         user_data)
773
 
{
774
 
  //gtk_widget_show(create_add_data_bkpt_dbox());
775
 
  display_data_bkpts_dbox();
776
 
}
777
 
 
778
 
/* Local functions used below */
779
 
static void clear_all_bkpt_address(gpointer data, gpointer user_data)
780
 
{
781
 
  CODE_BKPT *s = (CODE_BKPT *)data;
782
 
  ti68k_delBreakpointAddress(s->id);
783
 
 
784
 
  g_free(s);
785
 
}
786
 
 
787
 
void
788
 
on_clear_all_breakpoints1_activate     (GtkMenuItem     *menuitem,
789
 
                                        gpointer         user_data)
790
 
{
791
 
  fprintf(stderr, "Breakpoints|Clear all bkpts\n");
792
 
  g_list_foreach(bkpt_address_list, clear_all_bkpt_address, NULL);
793
 
  g_list_free(bkpt_address_list);
794
 
  bkpt_address_list = NULL; // free ne met pas le ptr a null: bug !
795
 
 
796
 
  /* Refresh breakpoints */
797
 
  refresh_breakpoints(code_clist);
798
 
}
799
 
 
800
 
 
801
 
void
802
 
on_log1_activate                       (GtkMenuItem     *menuitem,
803
 
                                        gpointer         user_data)
804
 
{
805
 
  
806
 
}
807
 
 
808
 
 
809
 
void
810
 
on_view_log1_activate                  (GtkMenuItem     *menuitem,
811
 
                                        gpointer         user_data)
812
 
{
813
 
  msg_box2(_("Information"), 
814
 
           _("This function is not available yet."));
815
 
}
816
 
 
817
 
 
818
 
void
819
 
on_edit_logged_addresses1_activate     (GtkMenuItem     *menuitem,
820
 
                                        gpointer         user_data)
821
 
{
822
 
  msg_box2(_("Information"), 
823
 
          _("This function is not available yet."));
824
 
}
825
 
 
826
 
 
827
 
void
828
 
on_log_link_port_send1_activate        (GtkMenuItem     *menuitem,
829
 
                                        gpointer         user_data)
830
 
{
831
 
  // to do
832
 
}
833
 
 
834
 
 
835
 
void
836
 
on_log_link_port_receive1_activate     (GtkMenuItem     *menuitem,
837
 
                                        gpointer         user_data)
838
 
{
839
 
  // to do
840
 
}
841
 
 
842
 
 
843
 
void
844
 
on_clear_all1_activate                 (GtkMenuItem     *menuitem,
845
 
                                        gpointer         user_data)
846
 
{
847
 
  msg_box2(_("Information"), 
848
 
           _("This function is not available yet."));
849
 
}
850
 
 
851
 
 
852
 
void
853
 
on_enable_logging1_activate            (GtkMenuItem     *menuitem,
854
 
                                        gpointer         user_data)
855
 
{
856
 
  // to do
857
 
}
858
 
 
859
 
 
860
 
gboolean
861
 
on_clist1_button_press_event           (GtkWidget       *widget,
862
 
                                        GdkEventButton  *event,
863
 
                                        gpointer         user_data)
864
 
{
865
 
  gint row, column;
866
 
  GdkEventButton *bevent;
867
 
 
868
 
  if (!gtk_clist_get_selection_info (GTK_CLIST (widget), 
869
 
                                     event->x, event->y, 
870
 
                                     &row, &column)) 
871
 
    return FALSE;
872
 
 
873
 
  switch(event->type)
874
 
    {
875
 
    case GDK_BUTTON_PRESS:
876
 
      if(event->button==3)
877
 
        {
878
 
          bevent=(GdkEventButton *)(event);
879
 
          gtk_menu_popup(GTK_MENU(create_code_popup_menu()), 
880
 
                         NULL, NULL, NULL, NULL, 
881
 
                         bevent->button, bevent->time);
882
 
 
883
 
          return TRUE;
884
 
        }
885
 
      break;
886
 
    case GDK_2BUTTON_PRESS:
887
 
      break;
888
 
    default:
889
 
      break;        
890
 
    }
891
 
  
892
 
  return FALSE;
893
 
}
894
 
 
895
 
 
896
 
void
897
 
on_clist1_select_row                   (GtkCList        *clist,
898
 
                                        gint             row,
899
 
                                        gint             column,
900
 
                                        GdkEvent        *event,
901
 
                                        gpointer         user_data)
902
 
{
903
 
  selected_row = row;
904
 
}
905
 
 
906
 
 
907
 
void
908
 
on_clist1_unselect_row                 (GtkCList        *clist,
909
 
                                        gint             row,
910
 
                                        gint             column,
911
 
                                        GdkEvent        *event,
912
 
                                        gpointer         user_data)
913
 
{
914
 
  selected_row = -1;
915
 
}
916
 
 
917
 
 
918
 
gboolean
919
 
on_clist2_key_press_event              (GtkWidget       *widget,
920
 
                                        GdkEventKey     *event,
921
 
                                        gpointer         user_data)
922
 
{
923
 
  //gint row, column;
924
 
 
925
 
  printf("Key pressed\n");
926
 
  /*
927
 
  if (gtk_clist_get_selection_info (GTK_CLIST (widget), event->x, event->y, 
928
 
  &row, &column))
929
 
    {
930
 
      printf("at row %i, column %i\n", row, column);
931
 
    }
932
 
  */
933
 
  return FALSE;
934
 
}
935
 
 
936
 
 
937
 
gboolean
938
 
on_clist2_button_press_event           (GtkWidget       *widget,
939
 
                                        GdkEventButton  *event,
940
 
                                        gpointer         user_data)
941
 
{
942
 
  gint row, column;
943
 
  GdkEventButton *bevent;
944
 
 
945
 
  if (!gtk_clist_get_selection_info (GTK_CLIST (widget), 
946
 
                                     event->x, event->y, 
947
 
                                     &row, &column)) 
948
 
    return FALSE;
949
 
 
950
 
  switch(event->type)
951
 
    {
952
 
    case GDK_BUTTON_PRESS:
953
 
      if(event->button==3)
954
 
        {
955
 
          bevent=(GdkEventButton *)(event);
956
 
          gtk_menu_popup(GTK_MENU(create_memory_popup_menu()), 
957
 
                         NULL, NULL, NULL, NULL, 
958
 
                         bevent->button, bevent->time);
959
 
 
960
 
          return TRUE;
961
 
        }
962
 
      break;
963
 
    case GDK_2BUTTON_PRESS:
964
 
      break;
965
 
    default:
966
 
      break;        
967
 
    }
968
 
  
969
 
  return FALSE;
970
 
}
971
 
 
972
 
/*******************/
973
 
/* Code popup menu */
974
 
/*******************/
975
 
//begin
976
 
 
977
 
void
978
 
on_go_to_address1_activate             (GtkMenuItem     *menuitem,
979
 
                                        gpointer         user_data)
980
 
{
981
 
  gtk_widget_show_all(create_gotocode_dbox());
982
 
}
983
 
 
984
 
 
985
 
void
986
 
on_go_to_pc1_activate                  (GtkMenuItem     *menuitem,
987
 
                                        gpointer         user_data)
988
 
{
989
 
 
990
 
}
991
 
 
992
 
 
993
 
/* Right button menu in the code part of the Debugger Window */
994
 
void
995
 
on_set_breakpoint1_activate            (GtkMenuItem     *menuitem,
996
 
                                        gpointer         user_data)
997
 
{
998
 
  // Equivalent to the menu
999
 
  on_set_breakpoint_at_selection1_activate(menuitem, code_clist);
1000
 
}
1001
 
 
1002
 
 
1003
 
void
1004
 
on_set_pc_to_selection1_activate       (GtkMenuItem     *menuitem,
1005
 
                                        gpointer         user_data)
1006
 
{
1007
 
  gint addr;
1008
 
 
1009
 
  /* Retrieve the selected line and its address */
1010
 
  if(selected_row != -1)
1011
 
    {
1012
 
      addr = GPOINTER_TO_INT(gtk_clist_get_row_data((GtkCList *)code_clist, 
1013
 
                                                    selected_row));
1014
 
      ti68k_setPcRegister(addr);
1015
 
      gtk_signal_emit_by_name((GtkObject *)debugger_dbox, "show");
1016
 
    }
1017
 
}
1018
 
 
1019
 
 
1020
 
void
1021
 
on_force_refresh1_activate             (GtkMenuItem     *menuitem,
1022
 
                                        gpointer         user_data)
1023
 
{
1024
 
  /* Refresh the 'code' dbox by sending the 'show' signal */
1025
 
  gtk_signal_emit_by_name((GtkObject *)debugger_dbox, "show");
1026
 
  
1027
 
  /* Refres_breakpoints */
1028
 
  refresh_breakpoints(code_clist);
1029
 
}
1030
 
 
1031
 
/********************/
1032
 
/* Memoy popup menu */
1033
 
/********************/
1034
 
 
1035
 
void
1036
 
on_edit1_activate                      (GtkMenuItem     *menuitem,
1037
 
                                        gpointer         user_data)
1038
 
{
1039
 
  
1040
 
}
1041
 
 
1042
 
 
1043
 
void
1044
 
on_go_to1_activate                     (GtkMenuItem     *menuitem,
1045
 
                                        gpointer         user_data)
1046
 
{
1047
 
  gtk_widget_show_all(create_gotodata_dbox());
1048
 
}
1049
 
 
1050
 
 
1051
 
/********************************/
1052
 
/* 'Address to go' dialog boxes */
1053
 
/********************************/
1054
 
 
1055
 
static gint code_addr_to_go = 0x000000;
1056
 
static gint data_addr_to_go = 0x000000;
1057
 
 
1058
 
void
1059
 
on_entry10_changed                     (GtkEditable     *editable,
1060
 
                                        gpointer         user_data)
1061
 
{
1062
 
  gchar *s;
1063
 
 
1064
 
  s = gtk_editable_get_chars((GtkEditable *)(user_data), 0, -1);
1065
 
  if(sscanf(s, "0x%6x", &code_addr_to_go) < 1)
1066
 
    code_addr_to_go =  0x000000;
1067
 
 
1068
 
  g_free(s);
1069
 
}
1070
 
 
1071
 
 
1072
 
void
1073
 
on_button45_clicked                    (GtkButton       *button,
1074
 
                                        gpointer         user_data)
1075
 
{
1076
 
  ti68k_setPcRegister(code_addr_to_go);
1077
 
  gtk_signal_emit_by_name((GtkObject *)debugger_dbox, "show");  
1078
 
 
1079
 
  gtk_widget_destroy(GTK_WIDGET(user_data));
1080
 
}
1081
 
 
1082
 
/* 'Address mem to go' dialog box */
1083
 
 
1084
 
void
1085
 
on_entry11_changed                     (GtkEditable     *editable,
1086
 
                                        gpointer         user_data)
1087
 
{
1088
 
  gchar *s;
1089
 
 
1090
 
  s = gtk_editable_get_chars((GtkEditable *)(user_data), 0, -1);
1091
 
  if(sscanf(s, "0x%6x", &data_addr_to_go) < 1)
1092
 
    data_addr_to_go =  0x000000;
1093
 
 
1094
 
  g_free(s);
1095
 
}
1096
 
 
1097
 
 
1098
 
void
1099
 
on_button99_clicked                    (GtkButton       *button,
1100
 
                                        gpointer         user_data)
1101
 
{
1102
 
  data_addr = data_addr_to_go;
1103
 
  gtk_signal_emit_by_name((GtkObject *)debugger_dbox, "show");  
1104
 
 
1105
 
  gtk_widget_destroy(GTK_WIDGET(user_data));
1106
 
}
1107
 
 
1108
 
 
1109
 
void
1110
 
on_options1_activate                   (GtkMenuItem     *menuitem,
1111
 
                                        gpointer         user_data)
1112
 
{
1113
 
  display_dbgopt_dbox();
1114
 
}
1115
 
 
1116
 
/* Memory box events for test purposes */
1117
 
 
1118
 
void
1119
 
on_clist2_click_column                 (GtkCList        *clist,
1120
 
                                        gint             column,
1121
 
                                        gpointer         user_data)
1122
 
{
1123
 
 
1124
 
}
1125
 
 
1126
 
 
1127
 
void
1128
 
on_clist2_select_row                   (GtkCList        *clist,
1129
 
                                        gint             row,
1130
 
                                        gint             column,
1131
 
                                        GdkEvent        *event,
1132
 
                                        gpointer         user_data)
1133
 
{
1134
 
  //fprintf(stdout, "row: %i\n", row);
1135
 
}
1136
 
 
1137
 
 
1138
 
gboolean
1139
 
on_clist2_event                        (GtkWidget       *widget,
1140
 
                                        GdkEvent        *event,
1141
 
                                        gpointer         user_data)
1142
 
{
1143
 
  /*
1144
 
  GdkEventButton *bevent = (GdkEventButton *)event;
1145
 
  int x, y;
1146
 
  int row, column;
1147
 
 
1148
 
  if( (event->type >= 4) && (event->type <= 9))
1149
 
    {
1150
 
      x = bevent->x;
1151
 
      y = bevent->y;
1152
 
      gtk_clist_get_selection_info (GTK_CLIST(widget), x, y, &row, &column);
1153
 
      fprintf(stdout, "event %i, x=%i, y=%i, row=%i, column=%i\n",
1154
 
              event->type, x, y, row, column);
1155
 
    }
1156
 
  */
1157
 
  return FALSE;
1158
 
}
1159
 
 
1160
 
void
1161
 
on_gotocode_dbox_destroy               (GtkObject       *object,
1162
 
                                        gpointer         user_data)
1163
 
{
1164
 
  //unhalt();
1165
 
}
1166
 
 
1167
 
 
1168
 
void
1169
 
on_gotodata_dbox_destroy               (GtkObject       *object,
1170
 
                                        gpointer         user_data)
1171
 
{
1172
 
  //unhalt();
1173
 
}
1174
 
 
1175
 
/**/
1176