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