4.3BSD - /usr/src/ucb/dbx/eval.c

   1: /*
   2:  * Copyright (c) 1983 Regents of the University of California.
   3:  * All rights reserved.  The Berkeley software License Agreement
   4:  * specifies the terms and conditions for redistribution.
   5:  */
   6: 
   7: #ifndef lint
   8: static char sccsid[] = "@(#)eval.c	5.3 (Berkeley) 6/21/85";
   9: #endif not lint
  10: 
  11: static char rcsid[] = "$Header: eval.c,v 1.5 84/12/26 10:39:08 linton Exp $";
  12: 
  13: /*
  14:  * Tree evaluation.
  15:  */
  16: 
  17: #include "defs.h"
  18: #include "tree.h"
  19: #include "operators.h"
  20: #include "debug.h"
  21: #include "eval.h"
  22: #include "events.h"
  23: #include "symbols.h"
  24: #include "scanner.h"
  25: #include "source.h"
  26: #include "object.h"
  27: #include "mappings.h"
  28: #include "process.h"
  29: #include "runtime.h"
  30: #include "machine.h"
  31: #include <signal.h>
  32: 
  33: #ifndef public
  34: 
  35: #include "machine.h"
  36: 
  37: #define STACKSIZE 20000
  38: 
  39: typedef Char Stack;
  40: 
  41: #define push(type, value) { \
  42:     ((type *) (sp += sizeof(type)))[-1] = (value); \
  43: }
  44: 
  45: #define pop(type) ( \
  46:     (*((type *) (sp -= sizeof(type)))) \
  47: )
  48: 
  49: #define popn(n, dest) { \
  50:     sp -= n; \
  51:     bcopy(sp, dest, n); \
  52: }
  53: 
  54: #define alignstack() { \
  55:     sp = (Stack *) (( ((int) sp) + sizeof(int) - 1)&~(sizeof(int) - 1)); \
  56: }
  57: 
  58: #endif
  59: 
  60: public Stack stack[STACKSIZE];
  61: public Stack *sp = &stack[0];
  62: public Boolean useInstLoc = false;
  63: 
  64: #define chksp() \
  65: { \
  66:     if (sp < &stack[0]) { \
  67:     panic("stack underflow"); \
  68:     } \
  69: }
  70: 
  71: #define poparg(n, r, fr) { \
  72:     eval(p->value.arg[n]); \
  73:     if (isreal(p->op)) { \
  74:     if (size(p->value.arg[n]->nodetype) == sizeof(float)) { \
  75:         fr = pop(float); \
  76:     } else { \
  77:         fr = pop(double); \
  78:     } \
  79:     } else if (isint(p->op)) { \
  80:     r = popsmall(p->value.arg[n]->nodetype); \
  81:     } \
  82: }
  83: 
  84: #define Boolrep char    /* underlying representation type for booleans */
  85: 
  86: /*
  87:  * Command-level evaluation.
  88:  */
  89: 
  90: public Node topnode;
  91: 
  92: public topeval (p)
  93: Node p;
  94: {
  95:     if (traceeval) {
  96:     fprintf(stderr, "topeval(");
  97:     prtree(stderr, p);
  98:     fprintf(stderr, ")\n");
  99:     fflush(stderr);
 100:     }
 101:     topnode = p;
 102:     eval(p);
 103: }
 104: 
 105: /*
 106:  * Evaluate a parse tree leaving the value on the top of the stack.
 107:  */
 108: 
 109: public eval(p)
 110: register Node p;
 111: {
 112:     long r0, r1;
 113:     double fr0, fr1;
 114:     Address addr;
 115:     long i, n;
 116:     int len;
 117:     Symbol s;
 118:     Node n1, n2;
 119:     boolean b;
 120:     File file;
 121:     String str;
 122: 
 123:     checkref(p);
 124:     if (traceeval) {
 125:     fprintf(stderr, "begin eval %s\n", opname(p->op));
 126:     }
 127:     switch (degree(p->op)) {
 128:     case BINARY:
 129:         poparg(1, r1, fr1);
 130:         poparg(0, r0, fr0);
 131:         break;
 132: 
 133:     case UNARY:
 134:         poparg(0, r0, fr0);
 135:         break;
 136: 
 137:     default:
 138:         /* do nothing */;
 139:     }
 140:     switch (p->op) {
 141:     case O_SYM:
 142:         s = p->value.sym;
 143:         if (s == retaddrsym) {
 144:         push(long, return_addr());
 145:         } else if (isvariable(s)) {
 146:         if (s != program and not isactive(container(s))) {
 147:             error("\"%s\" is not active", symname(s));
 148:         }
 149:         if (isvarparam(s) and not isopenarray(s)) {
 150:             rpush(address(s, nil), sizeof(Address));
 151:         } else {
 152:             push(Address, address(s, nil));
 153:         }
 154:         } else if (isblock(s)) {
 155:         push(Symbol, s);
 156:         } else if (isconst(s)) {
 157:         eval(constval(s));
 158:         } else {
 159:         error("can't evaluate a %s", classname(s));
 160:         }
 161:         break;
 162: 
 163:     case O_LCON:
 164:     case O_CCON:
 165:         r0 = p->value.lcon;
 166:         pushsmall(p->nodetype, r0);
 167:         break;
 168: 
 169:     case O_FCON:
 170:         push(double, p->value.fcon);
 171:         break;
 172: 
 173:     case O_SCON:
 174:         len = size(p->nodetype);
 175:         mov(p->value.scon, sp, len);
 176:         sp += len;
 177:         break;
 178: 
 179:     case O_INDEX:
 180:         s = p->value.arg[0]->nodetype;
 181:         p->value.arg[0]->nodetype = t_addr;
 182:         eval(p->value.arg[0]);
 183:         p->value.arg[0]->nodetype = s;
 184:         n = pop(Address);
 185:         eval(p->value.arg[1]);
 186:         evalindex(s, n, popsmall(p->value.arg[1]->nodetype));
 187:         break;
 188: 
 189:     case O_DOT:
 190:         s = p->value.arg[1]->value.sym;
 191:         eval(p->value.arg[0]);
 192:         n = pop(long);
 193:         push(long, n + (s->symvalue.field.offset div 8));
 194:         break;
 195: 
 196:     /*
 197: 	 * Get the value of the expression addressed by the top of the stack.
 198: 	 * Push the result back on the stack.
 199: 	 */
 200: 
 201:     case O_INDIR:
 202:     case O_RVAL:
 203:         addr = pop(long);
 204:         if (addr == 0) {
 205:         error("reference through nil pointer");
 206:         }
 207:         len = size(p->nodetype);
 208:         rpush(addr, len);
 209:         break;
 210: 
 211:     /*
 212: 	 * Move the stack pointer so that the top of the stack has
 213: 	 * something corresponding to the size of the current node type.
 214: 	 * If this new type is bigger than the subtree (len > 0),
 215: 	 * then the stack is padded with nulls.  If it's smaller,
 216: 	 * the stack is just dropped by the appropriate amount.
 217: 	 */
 218:     case O_TYPERENAME:
 219:         len = size(p->nodetype) - size(p->value.arg[0]->nodetype);
 220:         if (len > 0) {
 221:         for (n = 0; n < len; n++) {
 222:             *sp++ = '\0';
 223:         }
 224:         } else if (len < 0) {
 225:         sp += len;
 226:         }
 227:         break;
 228: 
 229:     case O_COMMA:
 230:         eval(p->value.arg[0]);
 231:         if (p->value.arg[1] != nil) {
 232:         eval(p->value.arg[1]);
 233:         }
 234:         break;
 235: 
 236:     case O_ITOF:
 237:         push(double, (double) r0);
 238:         break;
 239: 
 240:     case O_ADD:
 241:         push(long, r0+r1);
 242:         break;
 243: 
 244:     case O_ADDF:
 245:         push(double, fr0+fr1);
 246:         break;
 247: 
 248:     case O_SUB:
 249:         push(long, r0-r1);
 250:         break;
 251: 
 252:     case O_SUBF:
 253:         push(double, fr0-fr1);
 254:         break;
 255: 
 256:     case O_NEG:
 257:         push(long, -r0);
 258:         break;
 259: 
 260:     case O_NEGF:
 261:         push(double, -fr0);
 262:         break;
 263: 
 264:     case O_MUL:
 265:         push(long, r0*r1);
 266:         break;
 267: 
 268:     case O_MULF:
 269:         push(double, fr0*fr1);
 270:         break;
 271: 
 272:     case O_DIVF:
 273:         if (fr1 == 0) {
 274:         error("error: division by 0");
 275:         }
 276:         push(double, fr0 / fr1);
 277:         break;
 278: 
 279:     case O_DIV:
 280:         if (r1 == 0) {
 281:         error("error: div by 0");
 282:         }
 283:         push(long, r0 div r1);
 284:         break;
 285: 
 286:     case O_MOD:
 287:         if (r1 == 0) {
 288:         error("error: mod by 0");
 289:         }
 290:         push(long, r0 mod r1);
 291:         break;
 292: 
 293:     case O_LT:
 294:         push(Boolrep, r0 < r1);
 295:         break;
 296: 
 297:     case O_LTF:
 298:         push(Boolrep, fr0 < fr1);
 299:         break;
 300: 
 301:     case O_LE:
 302:         push(Boolrep, r0 <= r1);
 303:         break;
 304: 
 305:     case O_LEF:
 306:         push(Boolrep, fr0 <= fr1);
 307:         break;
 308: 
 309:     case O_GT:
 310:         push(Boolrep, r0 > r1);
 311:         break;
 312: 
 313:     case O_GTF:
 314:         push(Boolrep, fr0 > fr1);
 315:         break;
 316: 
 317:     case O_EQ:
 318:         push(Boolrep, r0 == r1);
 319:         break;
 320: 
 321:     case O_EQF:
 322:         push(Boolrep, fr0 == fr1);
 323:         break;
 324: 
 325:     case O_NE:
 326:         push(Boolrep, r0 != r1);
 327:         break;
 328: 
 329:     case O_NEF:
 330:         push(Boolrep, fr0 != fr1);
 331:         break;
 332: 
 333:     case O_AND:
 334:         push(Boolrep, r0 and r1);
 335:         break;
 336: 
 337:     case O_OR:
 338:         push(Boolrep, r0 or r1);
 339:         break;
 340: 
 341:     case O_ASSIGN:
 342:         assign(p->value.arg[0], p->value.arg[1]);
 343:         break;
 344: 
 345:     case O_CHFILE:
 346:         if (p->value.scon == nil) {
 347:         printf("%s\n", cursource);
 348:         } else {
 349:         file = opensource(p->value.scon);
 350:         if (file == nil) {
 351:             error("can't read \"%s\"", p->value.scon);
 352:         } else {
 353:             fclose(file);
 354:             setsource(p->value.scon);
 355:         }
 356:         }
 357:         break;
 358: 
 359:     case O_CONT:
 360:         cont(p->value.lcon);
 361:         printnews();
 362:         break;
 363: 
 364:     case O_LIST:
 365:         list(p);
 366:         break;
 367: 
 368:     case O_FUNC:
 369:         func(p->value.arg[0]);
 370:         break;
 371: 
 372:     case O_EXAMINE:
 373:         eval(p->value.examine.beginaddr);
 374:         r0 = pop(long);
 375:         if (p->value.examine.endaddr == nil) {
 376:         n = p->value.examine.count;
 377:         if (n == 0) {
 378:             printvalue(r0, p->value.examine.mode);
 379:         } else if (streq(p->value.examine.mode, "i")) {
 380:             printninst(n, (Address) r0);
 381:         } else {
 382:             printndata(n, (Address) r0, p->value.examine.mode);
 383:         }
 384:         } else {
 385:         eval(p->value.examine.endaddr);
 386:         r1 = pop(long);
 387:         if (streq(p->value.examine.mode, "i")) {
 388:             printinst((Address)r0, (Address)r1);
 389:         } else {
 390:             printdata((Address)r0, (Address)r1, p->value.examine.mode);
 391:         }
 392:         }
 393:         break;
 394: 
 395:     case O_PRINT:
 396:         for (n1 = p->value.arg[0]; n1 != nil; n1 = n1->value.arg[1]) {
 397:         eval(n1->value.arg[0]);
 398:         printval(n1->value.arg[0]->nodetype);
 399:         putchar(' ');
 400:         }
 401:         putchar('\n');
 402:         break;
 403: 
 404:     case O_PSYM:
 405:         if (p->value.arg[0]->op == O_SYM) {
 406:         psym(p->value.arg[0]->value.sym);
 407:         } else {
 408:         psym(p->value.arg[0]->nodetype);
 409:         }
 410:         break;
 411: 
 412:     case O_QLINE:
 413:         eval(p->value.arg[1]);
 414:         break;
 415: 
 416:     case O_STEP:
 417:         b = inst_tracing;
 418:         inst_tracing = (Boolean) (not p->value.step.source);
 419:         if (p->value.step.skipcalls) {
 420:         next();
 421:         } else {
 422:         stepc();
 423:         }
 424:         inst_tracing = b;
 425:         useInstLoc = (Boolean) (not p->value.step.source);
 426:         printnews();
 427:         break;
 428: 
 429:     case O_WHATIS:
 430:         if (p->value.arg[0]->op == O_SYM) {
 431:         printdecl(p->value.arg[0]->value.sym);
 432:         } else {
 433:         printdecl(p->value.arg[0]->nodetype);
 434:         }
 435:         break;
 436: 
 437:     case O_WHERE:
 438:         wherecmd();
 439:         break;
 440: 
 441:     case O_WHEREIS:
 442:         if (p->value.arg[0]->op == O_SYM) {
 443:         printwhereis(stdout, p->value.arg[0]->value.sym);
 444:         } else {
 445:         printwhereis(stdout, p->value.arg[0]->nodetype);
 446:         }
 447:         break;
 448: 
 449:     case O_WHICH:
 450:         if (p->value.arg[0]->op == O_SYM) {
 451:         printwhich(stdout, p->value.arg[0]->value.sym);
 452:         } else {
 453:         printwhich(stdout, p->value.arg[0]->nodetype);
 454:         }
 455:         putchar('\n');
 456:         break;
 457: 
 458:     case O_ALIAS:
 459:         n1 = p->value.arg[0];
 460:         n2 = p->value.arg[1];
 461:         if (n2 == nil) {
 462:         if (n1 == nil) {
 463:             alias(nil, nil, nil);
 464:         } else {
 465:             alias(n1->value.name, nil, nil);
 466:         }
 467:         } else if (n2->op == O_NAME) {
 468:         str = ident(n2->value.name);
 469:         alias(n1->value.name, nil, strdup(str));
 470:         } else {
 471:         if (n1->op == O_COMMA) {
 472:             alias(
 473:             n1->value.arg[0]->value.name,
 474:             (List) n1->value.arg[1],
 475:             n2->value.scon
 476:             );
 477:         } else {
 478:             alias(n1->value.name, nil, n2->value.scon);
 479:         }
 480:         }
 481:         break;
 482: 
 483:     case O_UNALIAS:
 484:         unalias(p->value.arg[0]->value.name);
 485:         break;
 486: 
 487:     case O_CALLPROC:
 488:         callproc(p, false);
 489:         break;
 490: 
 491:     case O_CALL:
 492:         callproc(p, true);
 493:         break;
 494: 
 495:     case O_CATCH:
 496:         if (p->value.lcon == 0) {
 497:         printsigscaught(process);
 498:         } else {
 499:         psigtrace(process, p->value.lcon, true);
 500:         }
 501:         break;
 502: 
 503:     case O_EDIT:
 504:         edit(p->value.scon);
 505:         break;
 506: 
 507:         case O_DEBUG:
 508:             debug(p);
 509:         break;
 510: 
 511:     case O_DOWN:
 512:         checkref(p->value.arg[0]);
 513:         assert(p->value.arg[0]->op == O_LCON);
 514:         down(p->value.arg[0]->value.lcon);
 515:         break;
 516: 
 517:     case O_DUMP:
 518:         if (p->value.arg[0] == nil) {
 519:         dumpall();
 520:         } else {
 521:         s = p->value.arg[0]->value.sym;
 522:         if (s == curfunc) {
 523:             dump(nil);
 524:         } else {
 525:             dump(s);
 526:         }
 527:         }
 528:         break;
 529: 
 530:     case O_GRIPE:
 531:         gripe();
 532:         break;
 533: 
 534:     case O_HELP:
 535:         help();
 536:         break;
 537: 
 538:     case O_IGNORE:
 539:         if (p->value.lcon == 0) {
 540:         printsigsignored(process);
 541:         } else {
 542:         psigtrace(process, p->value.lcon, false);
 543:         }
 544:         break;
 545: 
 546:     case O_RETURN:
 547:         if (p->value.arg[0] == nil) {
 548:         rtnfunc(nil);
 549:         } else {
 550:         assert(p->value.arg[0]->op == O_SYM);
 551:         rtnfunc(p->value.arg[0]->value.sym);
 552:         }
 553:         break;
 554: 
 555:     case O_RUN:
 556:         run();
 557:         break;
 558: 
 559:     case O_SET:
 560:         set(p->value.arg[0], p->value.arg[1]);
 561:         break;
 562: 
 563:     case O_SEARCH:
 564:         search(p->value.arg[0]->value.lcon, p->value.arg[1]->value.scon);
 565:         break;
 566: 
 567:     case O_SOURCE:
 568:         setinput(p->value.scon);
 569:         break;
 570: 
 571:     case O_STATUS:
 572:         status();
 573:         break;
 574: 
 575:     case O_TRACE:
 576:     case O_TRACEI:
 577:         trace(p);
 578:         break;
 579: 
 580:     case O_STOP:
 581:     case O_STOPI:
 582:         stop(p);
 583:         break;
 584: 
 585:     case O_UNSET:
 586:         undefvar(p->value.arg[0]->value.name);
 587:         break;
 588: 
 589:     case O_UP:
 590:         checkref(p->value.arg[0]);
 591:         assert(p->value.arg[0]->op == O_LCON);
 592:         up(p->value.arg[0]->value.lcon);
 593:         break;
 594: 
 595:     case O_ADDEVENT:
 596:         addevent(p->value.event.cond, p->value.event.actions);
 597:         break;
 598: 
 599:     case O_DELETE:
 600:         n1 = p->value.arg[0];
 601:         while (n1->op == O_COMMA) {
 602:         n2 = n1->value.arg[0];
 603:         assert(n2->op == O_LCON);
 604:         if (not delevent((unsigned int) n2->value.lcon)) {
 605:             error("unknown event %ld", n2->value.lcon);
 606:         }
 607:         n1 = n1->value.arg[1];
 608:         }
 609:         assert(n1->op == O_LCON);
 610:         if (not delevent((unsigned int) n1->value.lcon)) {
 611:         error("unknown event %ld", n1->value.lcon);
 612:         }
 613:         break;
 614: 
 615:     case O_ENDX:
 616:         endprogram();
 617:         break;
 618: 
 619:     case O_IF:
 620:         if (cond(p->value.event.cond)) {
 621:         evalcmdlist(p->value.event.actions);
 622:         }
 623:         break;
 624: 
 625:     case O_ONCE:
 626:         event_once(p->value.event.cond, p->value.event.actions);
 627:         break;
 628: 
 629:     case O_PRINTCALL:
 630:         printcall(p->value.sym, whatblock(return_addr()));
 631:         break;
 632: 
 633:     case O_PRINTIFCHANGED:
 634:         printifchanged(p->value.arg[0]);
 635:         break;
 636: 
 637:     case O_PRINTRTN:
 638:         printrtn(p->value.sym);
 639:         break;
 640: 
 641:     case O_PRINTSRCPOS:
 642:         getsrcpos();
 643:         if (p->value.arg[0] == nil) {
 644:         printsrcpos();
 645:         putchar('\n');
 646:         printlines(curline, curline);
 647:         } else if (p->value.arg[0]->op == O_QLINE) {
 648:         if (p->value.arg[0]->value.arg[1]->value.lcon == 0) {
 649:             printf("tracei: ");
 650:             printinst(pc, pc);
 651:         } else {
 652:             if (canReadSource()) {
 653:             printf("trace:  ");
 654:             printlines(curline, curline);
 655:             }
 656:         }
 657:         } else {
 658:         printsrcpos();
 659:         printf(": ");
 660:         eval(p->value.arg[0]);
 661:         prtree(stdout, p->value.arg[0]);
 662:         printf(" = ");
 663:         printval(p->value.arg[0]->nodetype);
 664:         putchar('\n');
 665:         }
 666:         break;
 667: 
 668:     case O_PROCRTN:
 669:         procreturn(p->value.sym);
 670:         break;
 671: 
 672:     case O_STOPIFCHANGED:
 673:         stopifchanged(p->value.arg[0]);
 674:         break;
 675: 
 676:     case O_STOPX:
 677:         isstopped = true;
 678:         break;
 679: 
 680:     case O_TRACEON:
 681:         traceon(p->value.trace.inst, p->value.trace.event,
 682:         p->value.trace.actions);
 683:         break;
 684: 
 685:     case O_TRACEOFF:
 686:         traceoff(p->value.lcon);
 687:         break;
 688: 
 689:     default:
 690:         panic("eval: bad op %d", p->op);
 691:     }
 692:     if (traceeval) {
 693:     fprintf(stderr, "end eval %s\n", opname(p->op));
 694:     }
 695: }
 696: 
 697: /*
 698:  * Evaluate a list of commands.
 699:  */
 700: 
 701: public evalcmdlist(cl)
 702: Cmdlist cl;
 703: {
 704:     Command c;
 705: 
 706:     foreach (Command, c, cl)
 707:     evalcmd(c);
 708:     endfor
 709: }
 710: 
 711: /*
 712:  * Push "len" bytes onto the expression stack from address "addr"
 713:  * in the process.  If there isn't room on the stack, print an error message.
 714:  */
 715: 
 716: public rpush(addr, len)
 717: Address addr;
 718: int len;
 719: {
 720:     if (not canpush(len)) {
 721:     error("expression too large to evaluate");
 722:     } else {
 723:     chksp();
 724:     dread(sp, addr, len);
 725:     sp += len;
 726:     }
 727: }
 728: 
 729: /*
 730:  * Check if the stack has n bytes available.
 731:  */
 732: 
 733: public Boolean canpush(n)
 734: Integer n;
 735: {
 736:     return (Boolean) (sp + n < &stack[STACKSIZE]);
 737: }
 738: 
 739: /*
 740:  * Push a small scalar of the given type onto the stack.
 741:  */
 742: 
 743: public pushsmall(t, v)
 744: Symbol t;
 745: long v;
 746: {
 747:     register Integer s;
 748: 
 749:     s = size(t);
 750:     switch (s) {
 751:     case sizeof(char):
 752:         push(char, v);
 753:         break;
 754: 
 755:     case sizeof(short):
 756:         push(short, v);
 757:         break;
 758: 
 759:     case sizeof(long):
 760:         push(long, v);
 761:         break;
 762: 
 763:     default:
 764:         panic("bad size %d in popsmall", s);
 765:     }
 766: }
 767: 
 768: /*
 769:  * Pop an item of the given type which is assumed to be no larger
 770:  * than a long and return it expanded into a long.
 771:  */
 772: 
 773: public long popsmall(t)
 774: Symbol t;
 775: {
 776:     register integer n;
 777:     long r;
 778: 
 779:     n = size(t);
 780:     if (n == sizeof(char)) {
 781:     if (t->class == RANGE and t->symvalue.rangev.lower >= 0) {
 782:         r = (long) pop(unsigned char);
 783:     } else {
 784:         r = (long) pop(char);
 785:     }
 786:     } else if (n == sizeof(short)) {
 787:     if (t->class == RANGE and t->symvalue.rangev.lower >= 0) {
 788:         r = (long) pop(unsigned short);
 789:     } else {
 790:         r = (long) pop(short);
 791:     }
 792:     } else if (n == sizeof(long)) {
 793:     r = pop(long);
 794:     } else {
 795:     error("[internal error: size %d in popsmall]", n);
 796:     }
 797:     return r;
 798: }
 799: 
 800: /*
 801:  * Evaluate a conditional expression.
 802:  */
 803: 
 804: public Boolean cond(p)
 805: Node p;
 806: {
 807:     register Boolean b;
 808: 
 809:     if (p == nil) {
 810:     b = true;
 811:     } else {
 812:     eval(p);
 813:     b = (Boolean) pop(Boolrep);
 814:     }
 815:     return b;
 816: }
 817: 
 818: /*
 819:  * Return the address corresponding to a given tree.
 820:  */
 821: 
 822: public Address lval(p)
 823: Node p;
 824: {
 825:     if (p->op == O_RVAL) {
 826:     eval(p->value.arg[0]);
 827:     } else {
 828:     eval(p);
 829:     }
 830:     return (Address) (pop(long));
 831: }
 832: 
 833: /*
 834:  * Process a trace command, translating into the appropriate events
 835:  * and associated actions.
 836:  */
 837: 
 838: public trace(p)
 839: Node p;
 840: {
 841:     Node exp, place, cond;
 842:     Node left;
 843: 
 844:     exp = p->value.arg[0];
 845:     place = p->value.arg[1];
 846:     cond = p->value.arg[2];
 847:     if (exp == nil) {
 848:     traceall(p->op, place, cond);
 849:     } else if (exp->op == O_QLINE or exp->op == O_LCON) {
 850:     traceinst(p->op, exp, cond);
 851:     } else if (place != nil and place->op == O_QLINE) {
 852:     traceat(p->op, exp, place, cond);
 853:     } else {
 854:     left = exp;
 855:     if (left->op == O_RVAL or left->op == O_CALL) {
 856:         left = left->value.arg[0];
 857:     }
 858:     if (left->op == O_SYM and isblock(left->value.sym)) {
 859:         traceproc(p->op, left->value.sym, place, cond);
 860:     } else {
 861:         tracedata(p->op, exp, place, cond);
 862:     }
 863:     }
 864: }
 865: 
 866: /*
 867:  * Set a breakpoint that will turn on tracing.
 868:  */
 869: 
 870: private traceall(op, place, cond)
 871: Operator op;
 872: Node place;
 873: Node cond;
 874: {
 875:     Symbol s;
 876:     Node event;
 877:     Command action;
 878: 
 879:     if (place == nil) {
 880:     s = program;
 881:     } else {
 882:     s = place->value.sym;
 883:     }
 884:     event = build(O_EQ, build(O_SYM, procsym), build(O_SYM, s));
 885:     action = build(O_PRINTSRCPOS,
 886:     build(O_QLINE, nil, build(O_LCON, (op == O_TRACE) ? 1 : 0)));
 887:     if (cond != nil) {
 888:     action = build(O_IF, cond, buildcmdlist(action));
 889:     }
 890:     action = build(O_TRACEON, (op == O_TRACEI), buildcmdlist(action));
 891:     action->value.trace.event = addevent(event, buildcmdlist(action));
 892:     if (isstdin()) {
 893:     printevent(action->value.trace.event);
 894:     }
 895: }
 896: 
 897: /*
 898:  * Set up the appropriate breakpoint for tracing an instruction.
 899:  */
 900: 
 901: private traceinst(op, exp, cond)
 902: Operator op;
 903: Node exp;
 904: Node cond;
 905: {
 906:     Node event, wh;
 907:     Command action;
 908:     Event e;
 909: 
 910:     if (exp->op == O_LCON) {
 911:     wh = build(O_QLINE, build(O_SCON, strdup(cursource)), exp);
 912:     } else {
 913:     wh = exp;
 914:     }
 915:     if (op == O_TRACEI) {
 916:     event = build(O_EQ, build(O_SYM, pcsym), wh);
 917:     } else {
 918:     event = build(O_EQ, build(O_SYM, linesym), wh);
 919:     }
 920:     action = build(O_PRINTSRCPOS, wh);
 921:     if (cond) {
 922:     action = build(O_IF, cond, buildcmdlist(action));
 923:     }
 924:     e = addevent(event, buildcmdlist(action));
 925:     if (isstdin()) {
 926:     printevent(e);
 927:     }
 928: }
 929: 
 930: /*
 931:  * Set a breakpoint to print an expression at a given line or address.
 932:  */
 933: 
 934: private traceat(op, exp, place, cond)
 935: Operator op;
 936: Node exp;
 937: Node place;
 938: Node cond;
 939: {
 940:     Node event;
 941:     Command action;
 942:     Event e;
 943: 
 944:     if (op == O_TRACEI) {
 945:     event = build(O_EQ, build(O_SYM, pcsym), place);
 946:     } else {
 947:     event = build(O_EQ, build(O_SYM, linesym), place);
 948:     }
 949:     action = build(O_PRINTSRCPOS, exp);
 950:     if (cond != nil) {
 951:     action = build(O_IF, cond, buildcmdlist(action));
 952:     }
 953:     e = addevent(event, buildcmdlist(action));
 954:     if (isstdin()) {
 955:     printevent(e);
 956:     }
 957: }
 958: 
 959: /*
 960:  * Construct event for tracing a procedure.
 961:  *
 962:  * What we want here is
 963:  *
 964:  * 	when $proc = p do
 965:  *	    if <condition> then
 966:  *	        printcall;
 967:  *	        once $pc = $retaddr do
 968:  *	            printrtn;
 969:  *	        end;
 970:  *	    end if;
 971:  *	end;
 972:  *
 973:  * Note that "once" is like "when" except that the event
 974:  * deletes itself as part of its associated action.
 975:  */
 976: 
 977: private traceproc(op, p, place, cond)
 978: Operator op;
 979: Symbol p;
 980: Node place;
 981: Node cond;
 982: {
 983:     Node event;
 984:     Command action;
 985:     Cmdlist actionlist;
 986:     Event e;
 987: 
 988:     action = build(O_PRINTCALL, p);
 989:     actionlist = list_alloc();
 990:     cmdlist_append(action, actionlist);
 991:     event = build(O_EQ, build(O_SYM, pcsym), build(O_SYM, retaddrsym));
 992:     action = build(O_ONCE, event, buildcmdlist(build(O_PRINTRTN, p)));
 993:     cmdlist_append(action, actionlist);
 994:     if (cond != nil) {
 995:     actionlist = buildcmdlist(build(O_IF, cond, actionlist));
 996:     }
 997:     event = build(O_EQ, build(O_SYM, procsym), build(O_SYM, p));
 998:     e = addevent(event, actionlist);
 999:     if (isstdin()) {
1000:     printevent(e);
1001:     }
1002: }
1003: 
1004: /*
1005:  * Set up breakpoint for tracing data.
1006:  */
1007: 
1008: private tracedata(op, exp, place, cond)
1009: Operator op;
1010: Node exp;
1011: Node place;
1012: Node cond;
1013: {
1014:     Symbol p;
1015:     Node event;
1016:     Command action;
1017: 
1018:     p = (place == nil) ? tcontainer(exp) : place->value.sym;
1019:     if (p == nil) {
1020:     p = program;
1021:     }
1022:     action = build(O_PRINTIFCHANGED, exp);
1023:     if (cond != nil) {
1024:     action = build(O_IF, cond, buildcmdlist(action));
1025:     }
1026:     action = build(O_TRACEON, (op == O_TRACEI), buildcmdlist(action));
1027:     event = build(O_EQ, build(O_SYM, procsym), build(O_SYM, p));
1028:     action->value.trace.event = addevent(event, buildcmdlist(action));
1029:     if (isstdin()) {
1030:     printevent(action->value.trace.event);
1031:     }
1032: }
1033: 
1034: /*
1035:  * Setting and unsetting of stops.
1036:  */
1037: 
1038: public stop(p)
1039: Node p;
1040: {
1041:     Node exp, place, cond, t;
1042:     Symbol s;
1043:     Command action;
1044:     Event e;
1045: 
1046:     exp = p->value.arg[0];
1047:     place = p->value.arg[1];
1048:     cond = p->value.arg[2];
1049:     if (exp != nil) {
1050:     stopvar(p->op, exp, place, cond);
1051:     } else {
1052:     action = build(O_STOPX);
1053:     if (cond != nil) {
1054:         action = build(O_IF, cond, buildcmdlist(action));
1055:     }
1056:     if (place == nil or place->op == O_SYM) {
1057:         if (place == nil) {
1058:         s = program;
1059:         } else {
1060:         s = place->value.sym;
1061:         }
1062:         t = build(O_EQ, build(O_SYM, procsym), build(O_SYM, s));
1063:         if (cond != nil) {
1064:         action = build(O_TRACEON, (p->op == O_STOPI),
1065:             buildcmdlist(action));
1066:         e = addevent(t, buildcmdlist(action));
1067:         action->value.trace.event = e;
1068:         } else {
1069:         e = addevent(t, buildcmdlist(action));
1070:         }
1071:         if (isstdin()) {
1072:         printevent(e);
1073:         }
1074:     } else {
1075:         stopinst(p->op, place, cond, action);
1076:     }
1077:     }
1078: }
1079: 
1080: private stopinst(op, place, cond, action)
1081: Operator op;
1082: Node place;
1083: Node cond;
1084: Command action;
1085: {
1086:     Node event;
1087:     Event e;
1088: 
1089:     if (op == O_STOP) {
1090:     event = build(O_EQ, build(O_SYM, linesym), place);
1091:     } else {
1092:     event = build(O_EQ, build(O_SYM, pcsym), place);
1093:     }
1094:     e = addevent(event, buildcmdlist(action));
1095:     if (isstdin()) {
1096:     printevent(e);
1097:     }
1098: }
1099: 
1100: /*
1101:  * Implement stopping on assignment to a variable by adding it to
1102:  * the variable list.
1103:  */
1104: 
1105: private stopvar(op, exp, place, cond)
1106: Operator op;
1107: Node exp;
1108: Node place;
1109: Node cond;
1110: {
1111:     Symbol p;
1112:     Node event;
1113:     Command action;
1114: 
1115:     if (place == nil) {
1116:     if (exp->op == O_LCON) {
1117:         p = program;
1118:     } else {
1119:         p = tcontainer(exp);
1120:         if (p == nil) {
1121:         p = program;
1122:         }
1123:     }
1124:     } else {
1125:     p = place->value.sym;
1126:     }
1127:     action = build(O_STOPIFCHANGED, exp);
1128:     if (cond != nil) {
1129:     action = build(O_IF, cond, buildcmdlist(action));
1130:     }
1131:     action = build(O_TRACEON, (op == O_STOPI), buildcmdlist(action));
1132:     event = build(O_EQ, build(O_SYM, procsym), build(O_SYM, p));
1133:     action->value.trace.event = addevent(event, buildcmdlist(action));
1134:     if (isstdin()) {
1135:     printevent(action->value.trace.event);
1136:     }
1137: }
1138: 
1139: /*
1140:  * Assign the value of an expression to a variable (or term).
1141:  */
1142: 
1143: public assign(var, exp)
1144: Node var;
1145: Node exp;
1146: {
1147:     Address addr;
1148:     integer varsize, expsize;
1149:     char cvalue;
1150:     short svalue;
1151:     long lvalue;
1152:     float fvalue;
1153: 
1154:     if (var->op == O_SYM and regnum(var->value.sym) != -1) {
1155:     eval(exp);
1156:     setreg(regnum(var->value.sym), pop(Address));
1157:     } else {
1158:     addr = lval(var);
1159:     varsize = size(var->nodetype);
1160:     expsize = size(exp->nodetype);
1161:     eval(exp);
1162:     if (varsize == sizeof(float) and expsize == sizeof(double)) {
1163:         fvalue = (float) pop(double);
1164:         dwrite(&fvalue, addr, sizeof(fvalue));
1165:     } else {
1166:         if (varsize < sizeof(long)) {
1167:         lvalue = 0;
1168:         popn(expsize, &lvalue);
1169:         if (varsize == sizeof(char)) {
1170:             cvalue = lvalue;
1171:             dwrite(&cvalue, addr, sizeof(cvalue));
1172:         } else if (varsize == sizeof(short)) {
1173:             svalue = lvalue;
1174:             dwrite(&svalue, addr, sizeof(svalue));
1175:         } else {
1176:             error("[internal error: bad size %d in assign]", varsize);
1177:         }
1178:         } else {
1179:         if (expsize <= varsize) {
1180:             sp -= expsize;
1181:             dwrite(sp, addr, expsize);
1182:         } else {
1183:             sp -= expsize;
1184:             dwrite(sp, addr, varsize);
1185:         }
1186:         }
1187:     }
1188:     }
1189: }
1190: 
1191: /*
1192:  * Set a debugger variable.
1193:  */
1194: 
1195: private set (var, exp)
1196: Node var, exp;
1197: {
1198:     Symbol t;
1199: 
1200:     if (var == nil) {
1201:     defvar(nil, nil);
1202:     } else if (exp == nil) {
1203:     defvar(var->value.name, nil);
1204:     } else if (var->value.name == identname("$frame", true)) {
1205:     t = exp->nodetype;
1206:     if (not compatible(t, t_int) and not compatible(t, t_addr)) {
1207:         error("$frame must be an address");
1208:     }
1209:     eval(exp);
1210:     getnewregs(pop(Address));
1211:     } else {
1212:     defvar(var->value.name, unrval(exp));
1213:     }
1214: }
1215: 
1216: /*
1217:  * Execute a list command.
1218:  */
1219: 
1220: private list (p)
1221: Node p;
1222: {
1223:     Symbol f;
1224:     Address addr;
1225:     Lineno line, l1, l2;
1226: 
1227:     if (p->value.arg[0]->op == O_SYM) {
1228:     f = p->value.arg[0]->value.sym;
1229:     addr = firstline(f);
1230:     if (addr == NOADDR) {
1231:         error("no source lines for \"%s\"", symname(f));
1232:     }
1233:     setsource(srcfilename(addr));
1234:     line = srcline(addr);
1235:     getsrcwindow(line, &l1, &l2);
1236:     } else {
1237:     eval(p->value.arg[0]);
1238:     l1 = (Lineno) (pop(long));
1239:     eval(p->value.arg[1]);
1240:     l2 = (Lineno) (pop(long));
1241:     }
1242:     printlines(l1, l2);
1243: }
1244: 
1245: /*
1246:  * Execute a func command.
1247:  */
1248: 
1249: private func (p)
1250: Node p;
1251: {
1252:     Symbol s, f;
1253:     Address addr;
1254: 
1255:     if (p == nil) {
1256:     printname(stdout, curfunc);
1257:     putchar('\n');
1258:     } else {
1259:     s = p->value.sym;
1260:     if (isroutine(s)) {
1261:         setcurfunc(s);
1262:     } else {
1263:         find(f, s->name) where isroutine(f) endfind(f);
1264:         if (f == nil) {
1265:         error("%s is not a procedure or function", symname(s));
1266:         }
1267:         setcurfunc(f);
1268:     }
1269:     addr = codeloc(curfunc);
1270:     if (addr != NOADDR) {
1271:         setsource(srcfilename(addr));
1272:         cursrcline = srcline(addr);
1273:     }
1274:     }
1275: }
1276: 
1277: /*
1278:  * Send a message to the current support person.
1279:  */
1280: 
1281: #ifdef MAINTAINER
1282: static char maintainer[] = MAINTAINER;
1283: #else
1284: static char maintainer[] = "";
1285: #endif
1286: 
1287: public gripe()
1288: {
1289:     typedef Operation();
1290:     Operation *old;
1291:     int pid, status;
1292:     extern int versionNumber;
1293:     char subject[100];
1294: 
1295:     if (maintainer[0] == '\0') {
1296:     puts("Gripes not supported at this site.  Sorry.");
1297:     return;
1298:     }
1299:     puts("Type control-D to end your message.  Be sure to include");
1300:     puts("your name and the name of the file you are debugging.");
1301:     putchar('\n');
1302:     old = signal(SIGINT, SIG_DFL);
1303:     sprintf(subject, "dbx (version 3.%d) gripe", versionNumber);
1304:     pid = back("Mail", stdin, stdout, "-s", subject, maintainer, nil);
1305:     signal(SIGINT, SIG_IGN);
1306:     pwait(pid, &status);
1307:     signal(SIGINT, old);
1308:     if (status == 0) {
1309:     puts("Thank you.");
1310:     } else {
1311:     puts("\nMail not sent.");
1312:     }
1313: }
1314: 
1315: /*
1316:  * Give the user some help.
1317:  */
1318: 
1319: public help()
1320: {
1321:     puts("run                    - begin execution of the program");
1322:     puts("print <exp>            - print the value of the expression");
1323:     puts("where                  - print currently active procedures");
1324:     puts("stop at <line>         - suspend execution at the line");
1325:     puts("stop in <proc>         - suspend execution when <proc> is called");
1326:     puts("cont                   - continue execution");
1327:     puts("step                   - single step one line");
1328:     puts("next                   - step to next line (skip over calls)");
1329:     puts("trace <line#>          - trace execution of the line");
1330:     puts("trace <proc>           - trace calls to the procedure");
1331:     puts("trace <var>            - trace changes to the variable");
1332:     puts("trace <exp> at <line#> - print <exp> when <line> is reached");
1333:     puts("status                 - print trace/stop's in effect");
1334:     puts("delete <number>        - remove trace or stop of given number");
1335:     puts("call <proc>            - call a procedure in program");
1336:     puts("whatis <name>          - print the declaration of the name");
1337:     puts("list <line>, <line>    - list source lines");
1338:     puts("gripe                  - send mail to the person in charge of dbx");
1339:     puts("quit                   - exit dbx");
1340: }
1341: 
1342: /*
1343:  * Divert output to the given file name.
1344:  * Cannot redirect to an existing file.
1345:  */
1346: 
1347: private int so_fd;
1348: private Boolean notstdout;
1349: 
1350: public setout(filename)
1351: String filename;
1352: {
1353:     File f;
1354: 
1355:     f = fopen(filename, "r");
1356:     if (f != nil) {
1357:     fclose(f);
1358:     error("%s: file already exists", filename);
1359:     } else {
1360:     so_fd = dup(1);
1361:     close(1);
1362:     if (creat(filename, 0666) == nil) {
1363:         unsetout();
1364:         error("can't create %s", filename);
1365:     }
1366:     notstdout = true;
1367:     }
1368: }
1369: 
1370: /*
1371:  * Revert output to standard output.
1372:  */
1373: 
1374: public unsetout()
1375: {
1376:     fflush(stdout);
1377:     close(1);
1378:     if (dup(so_fd) != 1) {
1379:     panic("standard out dup failed");
1380:     }
1381:     close(so_fd);
1382:     notstdout = false;
1383: }
1384: 
1385: /*
1386:  * Determine is standard output is currently being redirected
1387:  * to a file (as far as we know).
1388:  */
1389: 
1390: public Boolean isredirected()
1391: {
1392:     return notstdout;
1393: }

Defined functions

Defined variables

Defined typedef's

Defined macros