interpreters/nitfol/debug.c

   1 /*  Nitfol - z-machine interpreter using Glk for output.
   2     Copyright (C) 1999  Evin Robertson
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  17
  18     The author can be reached at nitfol@deja.com
  19 */
  20 #include "nitfol.h"
  21
  22 #ifdef HEADER
  23
  24 #ifndef DEBUGGING
  25
  26 #define debug_object(o, t)
  27 #define debug_attrib(a, o)
  28
  29 #endif
  30
  31 typedef enum { CONT_GO, CONT_STEP, CONT_NEXT, CONT_FINISH, CONT_UNTIL, CONT_STEPI, CONT_NEXTI } Cont_type;
  32
  33
  34 #endif
  35
  36 BOOL enter_debugger = FALSE;
  37
  38 #ifdef DEBUGGING
  39
  40 BOOL exit_debugger = FALSE;
  41 infix_file *cur_file;
  42 int cur_line;
  43 int cur_break;
  44 int cur_stack_depth;
  45 int infix_selected_frame;
  46
  47 static Cont_type debug_cont = CONT_GO;
  48 static int step_count = 0;
  49
  50 typedef enum { bp_none, bp_break, bp_write_watch, bp_read_watch, bp_access_watch } bptype;
  51
  52 typedef enum { del, del_at_next_stop, disable, donttouch } bpdisp;
  53
  54 typedef struct breakpoint breakpoint;
  55
  56 struct breakpoint {
  57   breakpoint *next;
  58
  59   int number;
  60   BOOL enabled;
  61
  62   bptype type;
  63   bpdisp disposition;
  64
  65   offset PC;
  66   int break_frame;  /* If not -1, only break at this depth */
  67
  68   infix_file *file;
  69   int line;
  70
  71   unsigned hit_count;
  72   unsigned ignore_count; /* Don't break until 0 */
  73
  74   char *condition;
  75
  76   char *watch_expression;
  77   int watch_frame;  /* Frame at which to evaluate watch; -1 if no locals */
  78   z_typed watch_value;
  79 };
  80
  81
  82 static breakpoint *breaklist;
  83 static int breaknumber = 1;
  84
  85
  86 void set_step(Cont_type t, int count)
  87 {
  88   debug_cont = t;
  89   step_count = count;
  90   exit_debugger = TRUE;
  91
  92   do_check_watches = TRUE;
  93   if(debug_cont == CONT_GO && breaklist == NULL)
  94     do_check_watches = FALSE;
  95 }
  96
  97
  98 int infix_set_break(offset location)
  99 {
 100   breakpoint newbreak;
 101
 102   infix_location cur_location;
 103
 104   if(location == 0) {
 105     infix_print_string("No code at that location.\n");
 106     return 0;
 107   }
 108
 109   newbreak.number = breaknumber++;
 110   newbreak.enabled = TRUE;
 111   newbreak.type = bp_break;
 112   newbreak.disposition = donttouch;
 113   newbreak.PC = location;
 114   newbreak.break_frame = -1;
 115   newbreak.hit_count = 0;
 116   newbreak.ignore_count = 0;
 117   newbreak.condition = NULL;
 118
 119   LEadd(breaklist, newbreak);
 120
 121   infix_print_string("Breakpoint ");
 122   infix_print_number(newbreak.number);
 123   infix_print_string(" at ");
 124   infix_print_number(location);
 125
 126   if(infix_decode_PC(&cur_location, location)) {
 127     infix_print_string(": file ");
 128     infix_print_string(cur_location.file->filename);
 129     infix_print_string(", line ");
 130     infix_print_number(cur_location.line_num);
 131   }
 132   infix_print_string(".\n");
 133
 134   do_check_watches = TRUE;
 135   return newbreak.number;
 136 }
 137
 138 static breakpoint *find_breakpoint(int breaknum)
 139 {
 140   breakpoint *p;
 141   LEsearch(breaklist, p, p->number == breaknum);
 142
 143   if(p)
 144     return p;
 145
 146   infix_print_string("No breakpoint number ");
 147   infix_print_number(breaknum);
 148   infix_print_string(".\n");
 149   return NULL;
 150 }
 151
 152
 153 void infix_delete_breakpoint(int breaknum)
 154 {
 155   breakpoint *p, *t;
 156   LEsearchremove(breaklist, p, t, p->number == breaknum, n_free(p->condition));
 157 }
 158
 159 void infix_set_cond(int breaknum, const char *condition)
 160 {
 161   breakpoint *p = find_breakpoint(breaknum);
 162
 163   if(p) {
 164     if(p->condition) {
 165       n_free(p->condition);
 166     }
 167     p->condition = n_strdup(condition);
 168   }
 169 }
 170
 171 void infix_set_ignore(int breaknum, int count)
 172 {
 173   breakpoint *p = find_breakpoint(breaknum);
 174
 175   if(p)
 176     p->ignore_count = count;
 177 }
 178
 179 void infix_set_break_enabled(int breaknum, BOOL enabled)
 180 {
 181   breakpoint *p = find_breakpoint(breaknum);
 182
 183   if(p)
 184     p->enabled = enabled;
 185 }
 186
 187 static void infix_show_break(breakpoint *b)
 188 {
 189   infix_print_number(b->number);
 190   infix_print_char(' ');
 191   infix_print_string("breakpoint");
 192   infix_print_char(' ');
 193   infix_print_string("keep");
 194   infix_print_char(' ');
 195   if(b->enabled)
 196     infix_print_char('y');
 197   else
 198     infix_print_char('n');
 199   infix_print_offset(b->PC);
 200   infix_print_char(' ');
 201   infix_gprint_loc(0, b->PC);
 202   infix_print_char('\n');
 203 }
 204
 205 void infix_show_all_breakpoints(void)
 206 {
 207   breakpoint *p;
 208   if(!breaklist) {
 209     infix_print_string("No breakpoints or watchpoints.\n");
 210   } else {
 211     for(p = breaklist; p; p=p->next)
 212       infix_show_break(p);
 213   }
 214 }
 215
 216 void infix_show_breakpoint(int breaknum)
 217 {
 218   breakpoint *p = find_breakpoint(breaknum);
 219   if(p) {
 220     infix_show_break(p);
 221   } else {
 222     infix_print_string("No such breakpoint or watchpoint.\n");
 223   }
 224 }
 225
 226
 227 typedef struct auto_display auto_display;
 228
 229 struct auto_display {
 230   auto_display *next;
 231
 232   int number;
 233   BOOL enabled;
 234
 235   char *exp;
 236 };
 237
 238 static auto_display *displist;
 239 static int dispnumber = 1;
 240
 241 int infix_auto_display(const char *expression)
 242 {
 243   auto_display newdisp;
 244   newdisp.number = dispnumber++;
 245   newdisp.enabled = TRUE;
 246   newdisp.exp = n_strdup(expression);
 247
 248   LEadd(displist, newdisp);
 249
 250   return newdisp.number;
 251 }
 252
 253 void perform_displays(void)
 254 {
 255   auto_display *p;
 256   for(p = displist; p; p=p->next) {
 257     if(p->enabled) {
 258       infix_print_number(p->number);
 259       infix_print_string(": ");
 260       infix_print_string(p->exp);
 261       infix_print_string(" = ");
 262       infix_display(evaluate_expression(p->exp, infix_selected_frame));
 263     }
 264   }
 265 }
 266
 267
 268 static auto_display *find_auto_display(int displaynum)
 269 {
 270   auto_display *p;
 271   LEsearch(displist, p, p->number == displaynum);
 272
 273   if(p)
 274     return p;
 275
 276   infix_print_string("No auto-display number ");
 277   infix_print_number(displaynum);
 278   infix_print_string(".\n");
 279   return NULL;
 280 }
 281
 282
 283 void infix_auto_undisplay(int displaynum)
 284 {
 285   auto_display *p, *t;
 286   LEsearchremove(displist, p, t, p->number == displaynum, n_free(p->exp));
 287 }
 288
 289
 290 void infix_set_display_enabled(int displaynum, BOOL enabled)
 291 {
 292   auto_display *p = find_auto_display(displaynum);
 293
 294   if(p)
 295     p->enabled = enabled;
 296 }
 297
 298
 299 const char *debug_decode_number(unsigned number)
 300 {
 301   const char *name;
 302   z_typed val;
 303   val.v = number;
 304
 305   val.t = Z_OBJECT;
 306   name = infix_get_name(val);
 307
 308   if(!name) {
 309     val.t = Z_ROUTINE;
 310     name = infix_get_name(val);
 311   }
 312   if(!name) {
 313     val.t = Z_STRING;
 314     name = infix_get_name(val);
 315   }
 316   return name;
 317 }
 318
 319
 320 unsigned opcode_counters[OFFSET_END];
 321
 322
 323 void check_watches(void)
 324 {
 325   /* This function is called after every instruction, and infix_decode_PC is
 326      relatively expensive, so only get it when we need it */
 327   infix_location cur_location;
 328   BOOL found_location = FALSE;
 329
 330   BOOL is_breakpoint = FALSE;
 331   int depth;
 332   BOOL go_debug;
 333   breakpoint *p;
 334
 335
 336   switch(debug_cont) {
 337   case CONT_STEP:
 338     if(!infix_decode_PC(&cur_location, oldPC))
 339       break;
 340     found_location = TRUE;
 341     if(cur_file != cur_location.file || cur_line != cur_location.line_num)
 342       go_debug = TRUE;
 343     break;
 344
 345   case CONT_STEPI:
 346     go_debug = TRUE;
 347     break;
 348
 349   case CONT_NEXT:
 350     depth = stack_get_depth();
 351     if(depth < cur_stack_depth) {
 352       go_debug = TRUE;
 353     } else if(cur_stack_depth == depth) {
 354       if(!infix_decode_PC(&cur_location, oldPC))
 355         break;
 356       found_location = TRUE;
 357
 358       if(cur_file != cur_location.file || cur_line != cur_location.line_num)
 359         go_debug = TRUE;
 360     }
 361     break;
 362
 363   case CONT_NEXTI:
 364     depth = stack_get_depth();
 365     if(depth <= cur_stack_depth)
 366       go_debug = TRUE;
 367     break;
 368
 369   case CONT_FINISH:
 370     depth = stack_get_depth();
 371     if(depth < cur_stack_depth)
 372       go_debug = TRUE;
 373     break;
 374
 375   case CONT_UNTIL:
 376     depth = stack_get_depth();
 377     if(depth < cur_stack_depth) {
 378       go_debug = TRUE;
 379     } else if(cur_stack_depth == depth) {
 380       if(!infix_decode_PC(&cur_location, oldPC))
 381         break;
 382       found_location = TRUE;
 383
 384       if(cur_file != cur_location.file || cur_line > cur_location.line_num)
 385         go_debug = TRUE;
 386     }
 387     break;
 388
 389   case CONT_GO:
 390     go_debug = FALSE;
 391   }
 392
 393   if(go_debug && step_count && --step_count)
 394     go_debug = FALSE;
 395
 396   for(p = breaklist; p; p=p->next) {
 397     if(p->enabled) {
 398       BOOL break_hit = FALSE;
 399       switch(p->type) {
 400       case bp_none:
 401       case bp_read_watch:
 402         break;
 403
 404       case bp_break:
 405         break_hit = p->PC == oldPC;
 406         break;
 407
 408       case bp_write_watch:
 409       case bp_access_watch:
 410
 411         ;
 412       }
 413
 414       if(break_hit) {
 415         if(p->ignore_count) {
 416           p->ignore_count--;
 417         } else {
 418           z_typed foo;
 419           if(p->condition)
 420             foo = evaluate_expression(p->condition, infix_selected_frame);
 421           if(!p->condition || foo.v) {
 422             is_breakpoint = TRUE;
 423             go_debug = TRUE;
 424
 425             p->hit_count++;
 426
 427             infix_print_string("Breakpoint ");
 428             infix_print_number(p->number);
 429             infix_print_string(", ");
 430
 431             switch(p->disposition) {
 432             case del:
 433               infix_delete_breakpoint(p->number);
 434               break;
 435
 436             case disable:
 437               p->enabled = FALSE;
 438               break;
 439
 440             case del_at_next_stop:
 441             case donttouch:
 442               ;
 443             }
 444           }
 445         }
 446       }
 447     }
 448   }
 449
 450
 451   if(go_debug || enter_debugger) {
 452     depth = stack_get_depth();
 453
 454     enter_debugger = FALSE;
 455
 456     if(!found_location)
 457       found_location = infix_decode_PC(&cur_location, oldPC);
 458
 459     if(found_location) {
 460       cur_file = cur_location.file;
 461       cur_line = cur_location.line_num;
 462     } else {
 463       cur_file = NULL;
 464       cur_line = 0;
 465     }
 466
 467     if(is_breakpoint || cur_stack_depth != depth) {
 468       infix_gprint_loc(depth, 0);
 469     } else {
 470       infix_file_print_line(cur_file, cur_line);
 471     }
 472
 473     infix_selected_frame = cur_stack_depth = depth;
 474
 475     for(p = breaklist; p; p=p->next) {
 476       if(p->disposition == del_at_next_stop)
 477         infix_delete_breakpoint(p->number);
 478     }
 479
 480     debug_prompt();
 481   }
 482
 483   return;
 484 }
 485
 486
 487 void debug_prompt(void)
 488 {
 489   char buffer[513];
 490   exit_debugger = FALSE;
 491   perform_displays();
 492   while(!exit_debugger) {
 493     if(db_prompt)
 494       infix_print_string(db_prompt);
 495     else
 496       infix_print_string("(nitfol) ");
 497     infix_get_string(buffer, 512);
 498     process_debug_command(buffer);
 499   }
 500 }
 501
 502 void infix_select_frame(int num)
 503 {
 504   if(frame_is_valid(num))
 505     infix_selected_frame = num;
 506 }
 507
 508 void infix_show_frame(int frame)
 509 {
 510   infix_print_char('#');
 511   infix_print_number(frame);
 512   infix_print_string("  ");
 513   infix_gprint_loc(frame, 0);
 514 }
 515
 516 void infix_backtrace(int start, int length)
 517 {
 518   int n;
 519   for(n = start + length - 1; n >= start; n--) {
 520     infix_show_frame(n);
 521   }
 522 }
 523
 524
 525
 526 const char *watchnames[] = {
 527   "reading object",
 528   "move to object",
 529   "moving object"
 530 };
 531
 532
 533
 534
 535 void debug_object(zword objectnum, watchinfo type)
 536 {
 537   /*n_show_debug(E_OBJECT, watchnames[type], objectnum);*/
 538 }
 539
 540 void debug_attrib(zword attribnum, zword objectnum)
 541 {
 542   /*n_show_debug(E_OBJECT, "using attribute", attribnum);*/
 543 }
 544
 545
 546
 547 #endif
 548