![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to check.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / dbx|
Return to check.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / 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[] = "@(#)check.c 5.2 (Berkeley) 1/10/86";
9: #endif not lint
10:
11: static char rcsid[] = "$Header: check.c,v 1.5 84/12/26 10:38:35 linton Exp $";
12:
13: /*
14: * Check a tree for semantic correctness.
15: */
16:
17: #include "defs.h"
18: #include "tree.h"
19: #include "operators.h"
20: #include "events.h"
21: #include "symbols.h"
22: #include "scanner.h"
23: #include "source.h"
24: #include "object.h"
25: #include "mappings.h"
26: #include "process.h"
27: #include <signal.h>
28:
29: #ifndef public
30: #endif
31:
32: /*
33: * Check that the nodes in a tree have the correct arguments
34: * in order to be evaluated. Basically the error checking here
35: * frees the evaluation routines from worrying about anything
36: * except dynamic errors, e.g. subscript out of range.
37: */
38:
39: public check(p)
40: register Node p;
41: {
42: Node p1, p2;
43: Address addr;
44: Symbol f;
45:
46: checkref(p);
47: switch (p->op) {
48: case O_ASSIGN:
49: p1 = p->value.arg[0];
50: p2 = p->value.arg[1];
51: if (varIsSet("$unsafeassign")) {
52: if (size(p1->nodetype) != size(p2->nodetype)) {
53: error("incompatible sizes");
54: }
55: } else if (not compatible(p1->nodetype, p2->nodetype)) {
56: error("incompatible types");
57: }
58: break;
59:
60: case O_CATCH:
61: case O_IGNORE:
62: if (p->value.lcon < 0 or p->value.lcon > NSIG) {
63: error("invalid signal number");
64: }
65: break;
66:
67: case O_CONT:
68: if (p->value.lcon != DEFSIG and (
69: p->value.lcon < 0 or p->value.lcon > NSIG)
70: ) {
71: error("invalid signal number");
72: }
73: break;
74:
75: case O_DUMP:
76: if (p->value.arg[0] != nil) {
77: if (p->value.arg[0]->op == O_SYM) {
78: f = p->value.arg[0]->value.sym;
79: if (not isblock(f)) {
80: error("\"%s\" is not a block", symname(f));
81: }
82: } else {
83: beginerrmsg();
84: fprintf(stderr, "expected a symbol, found \"");
85: prtree(stderr, p->value.arg[0]);
86: fprintf(stderr, "\"");
87: enderrmsg();
88: }
89: }
90: break;
91:
92: case O_LIST:
93: if (p->value.arg[0]->op == O_SYM) {
94: f = p->value.arg[0]->value.sym;
95: if (not isblock(f) or ismodule(f)) {
96: error("\"%s\" is not a procedure or function", symname(f));
97: }
98: addr = firstline(f);
99: if (addr == NOADDR) {
100: error("\"%s\" is empty", symname(f));
101: }
102: }
103: break;
104:
105: case O_TRACE:
106: case O_TRACEI:
107: chktrace(p);
108: break;
109:
110: case O_STOP:
111: case O_STOPI:
112: chkstop(p);
113: break;
114:
115: case O_CALLPROC:
116: case O_CALL:
117: if (not isroutine(p->value.arg[0]->nodetype)) {
118: beginerrmsg();
119: fprintf(stderr, "\"");
120: prtree(stderr, p->value.arg[0]);
121: fprintf(stderr, "\" not call-able");
122: enderrmsg();
123: }
124: break;
125:
126: case O_WHEREIS:
127: if (p->value.arg[0]->op == O_SYM and
128: p->value.arg[0]->value.sym == nil) {
129: error("symbol not defined");
130: }
131: break;
132:
133: default:
134: break;
135: }
136: }
137:
138: /*
139: * Check arguments to a trace command.
140: */
141:
142: private chktrace(p)
143: Node p;
144: {
145: Node exp, place, cond;
146:
147: exp = p->value.arg[0];
148: place = p->value.arg[1];
149: cond = p->value.arg[2];
150: if (exp == nil) {
151: chkblock(place);
152: } else if (exp->op == O_LCON or exp->op == O_QLINE) {
153: if (place != nil) {
154: error("unexpected \"at\" or \"in\"");
155: }
156: if (p->op == O_TRACE) {
157: chkline(exp);
158: } else {
159: chkaddr(exp);
160: }
161: } else if (place != nil and (place->op == O_QLINE or place->op == O_LCON)) {
162: if (p->op == O_TRACE) {
163: chkline(place);
164: } else {
165: chkaddr(place);
166: }
167: } else {
168: if (exp->op != O_RVAL and exp->op != O_SYM and exp->op != O_CALL) {
169: error("can't trace expressions");
170: }
171: chkblock(place);
172: }
173: }
174:
175: /*
176: * Check arguments to a stop command.
177: */
178:
179: private chkstop(p)
180: Node p;
181: {
182: Node exp, place, cond;
183:
184: exp = p->value.arg[0];
185: place = p->value.arg[1];
186: cond = p->value.arg[2];
187: if (exp != nil) {
188: if (exp->op != O_RVAL and exp->op != O_SYM and exp->op != O_LCON) {
189: beginerrmsg();
190: fprintf(stderr, "expected variable, found ");
191: prtree(stderr, exp);
192: enderrmsg();
193: }
194: chkblock(place);
195: } else if (place != nil) {
196: if (place->op == O_SYM) {
197: chkblock(place);
198: } else {
199: if (p->op == O_STOP) {
200: chkline(place);
201: } else {
202: chkaddr(place);
203: }
204: }
205: }
206: }
207:
208: /*
209: * Check to see that the given node specifies some subprogram.
210: * Nil is ok since that means the entire program.
211: */
212:
213: private chkblock(b)
214: Node b;
215: {
216: Symbol p, outer;
217:
218: if (b != nil) {
219: if (b->op != O_SYM) {
220: beginerrmsg();
221: fprintf(stderr, "expected subprogram, found ");
222: prtree(stderr, b);
223: enderrmsg();
224: } else if (ismodule(b->value.sym)) {
225: outer = b->value.sym;
226: while (outer != nil) {
227: find(p, outer->name) where p->block == outer endfind(p);
228: if (p == nil) {
229: outer = nil;
230: error("\"%s\" is not a subprogram", symname(b->value.sym));
231: } else if (ismodule(p)) {
232: outer = p;
233: } else {
234: outer = nil;
235: b->value.sym = p;
236: }
237: }
238: } else if (
239: b->value.sym->class == VAR and
240: b->value.sym->name == b->value.sym->block->name and
241: b->value.sym->block->class == FUNC
242: ) {
243: b->value.sym = b->value.sym->block;
244: } else if (not isblock(b->value.sym)) {
245: error("\"%s\" is not a subprogram", symname(b->value.sym));
246: }
247: }
248: }
249:
250: /*
251: * Check to make sure a node corresponds to a source line.
252: */
253:
254: private chkline(p)
255: Node p;
256: {
257: if (p == nil) {
258: error("missing line");
259: } else if (p->op != O_QLINE and p->op != O_LCON) {
260: error("expected source line number, found \"%t\"", p);
261: }
262: }
263:
264: /*
265: * Check to make sure a node corresponds to an address.
266: */
267:
268: private chkaddr(p)
269: Node p;
270: {
271: if (p == nil) {
272: error("missing address");
273: } else if (p->op != O_LCON and p->op != O_QLINE) {
274: beginerrmsg();
275: fprintf(stderr, "expected address, found \"");
276: prtree(stderr, p);
277: fprintf(stderr, "\"");
278: enderrmsg();
279: }
280: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.