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