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