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