![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to b2ana.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / B / src / bint|
Return to b2ana.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / B / src / bint |
1.1 root 1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
2:
3: /* $Header: b2ana.c,v 1.4 85/08/22 16:54:05 timo Exp $ */
4:
5: /* Prepare for code generation -- find out which tags are targets */
6:
7: #include "b.h"
8: #include "b1obj.h"
9: #include "b2nod.h"
10: #include "b2gen.h" /* Must be after b2nod.h */
11: #include "b3err.h"
12: #include "b3env.h"
13: #include "b3sou.h" /* For get_pname */
14:
15:
16: Visible int nextvarnumber; /* Counts local targets (including formals) */
17:
18: Visible value formals, locals, globals, mysteries, refinements;
19:
20:
21: Visible value *setup(t) parsetree t; {
22: typenode n= Nodetype(t);
23: bool in_prmnv= !Unit(n);
24: nextvarnumber= 0;
25: formals= mk_elt();
26: mysteries= mk_elt();
27: if (in_prmnv) {
28: globals= copy(prmnv->tab);
29: locals= Vnil;
30: refinements= mk_elt();
31: return Command(n) ? &globals : Pnil;
32: } else {
33: globals= mk_elt();
34: locals= mk_elt();
35: refinements=
36: copy(*Branch(t, n == HOW_TO ? HOW_R_NAMES : FPR_R_NAMES));
37: unit_context(t);
38: return &locals;
39: }
40: }
41:
42: Hidden Procedure unit_context(t) parsetree t; {
43: cntxt= In_unit;
44: release(uname); uname= get_pname(t);
45: }
46:
47: Visible Procedure cleanup() {
48: release(formals);
49: release(locals);
50: release(globals);
51: release(mysteries);
52: release(refinements);
53: }
54:
55: /* ******************************************************************** */
56:
57: /* Analyze parse tree, finding the targets and formal parameters.
58: Formal parameters of HOW'TO's are of course found in the unit heading.
59: Formal parameters of YIELDs and TESTs are treated as local targets.
60: Global targets are also easily found: they are mentioned in a SHARE command.
61: Local targets appear on their own or in collateral forms after PUT IN,
62: DRAW or CHOOSE, or as bound tags after FOR, SOME, EACH or NO.
63: Note that DELETE x, REMOVE e FROM x, or PUT e IN x[k] (etc.) don't
64: introduce local targets, because in all these cases x must have been
65: initialized first. This speeds up our task of finding targets,
66: since we don't have to visit all nodes: only nodes that may contain
67: commands or tests, and the positions mentioned here, need be visited.
68: (And of course unit headings).
69: We don't have to look for refinements since these are already known
70: from the unit heading.
71: */
72:
73: Hidden Procedure a_tag(name, targs) value name; value *targs; {
74: value *aa; int varnumber;
75: if (locals != Vnil && envassoc(locals, name)) return;
76: if (envassoc(globals, name)) return;
77: if (envassoc(formals, name)) return;
78: if (envassoc(refinements, name)) {
79: if (targs != &mysteries)
80: fixerr(MESS(4600, "a refinement may not be used as a target"));
81: return;
82: }
83: if (aa= envassoc(mysteries, name)) {
84: if (targs == &mysteries) return;
85: varnumber= SmallIntVal(*aa);
86: e_delete(&mysteries, name);
87: }
88: else if (targs != &globals) varnumber= nextvarnumber++;
89: else varnumber= 0;
90: e_replace(MkSmallInt(varnumber), targs, name);
91: }
92:
93: Hidden Procedure a_fpr_formals(t) parsetree t; {
94: typenode n= Nodetype(t);
95: switch (n) {
96: case TAG:
97: break;
98: case MONF: case MONPRD:
99: analyze(*Branch(t, MON_RIGHT), &locals);
100: break;
101: case DYAF: case DYAPRD:
102: analyze(*Branch(t, DYA_LEFT), &locals);
103: analyze(*Branch(t, DYA_RIGHT), &locals);
104: break;
105: default: syserr(MESS(4601, "a_fpr_formals"));
106: }
107: }
108:
109: Visible Procedure analyze(t, targs) parsetree t; value *targs; {
110: typenode nt; string s; char c; int n, k, len; value v;
111: if (!Is_node(t) || !still_ok) return;
112: nt= Nodetype(t);
113: if (nt < 0 || nt >= NTYPES) syserr(MESS(4602, "analyze bad tree"));
114: s= gentab[nt];
115: if (s == NULL) return;
116: n= First_fieldnr;
117: while ((c= *s++) != '\0' && still_ok) {
118: switch (c) {
119: case '0':
120: case '1':
121: case '2':
122: case '3':
123: case '4':
124: case '5':
125: case '6':
126: case '7':
127: case '8':
128: case '9':
129: n= (c - '0') + First_fieldnr;
130: break;
131: case 'c':
132: v= *Branch(t, n);
133: if (v != Vnil) {
134: len= Nfields(v);
135: for (k= 0; k < len; ++k)
136: analyze(*Field(v, k), targs);
137: }
138: ++n;
139: break;
140: case '#':
141: curlino= *Branch(t, n);
142: /* Fall through */
143: case 'l':
144: case 'v':
145: ++n;
146: break;
147: case 'm':
148: analyze(*Branch(t, n), &mysteries);
149: ++n;
150: break;
151: case 'g':
152: analyze(*Branch(t, n), &globals);
153: ++n;
154: break;
155: case '!':
156: analyze(*Branch(t, n),
157: locals != Vnil ? &locals : &globals);
158: ++n;
159: break;
160: case 'x':
161: curline= *Branch(t, n);
162: /* Fall through */
163: case 'a':
164: case 'u':
165: analyze(*Branch(t, n), targs);
166: ++n;
167: break;
168: case 't':
169: analyze(*Branch(t, n), Pnil);
170: ++n;
171: break;
172: case 'f':
173: a_fpr_formals(*Branch(t, n));
174: ++n;
175: break;
176: case 'h':
177: v= *Branch(t, n);
178: if (v != Vnil && Is_text(v))
179: a_tag(v, &formals);
180: else
181: analyze(v, &formals);
182: ++n;
183: break;
184: case '=':
185: *Branch(t, n)= MkSmallInt(nextvarnumber);
186: ++n;
187: break;
188: case 'T':
189: if (targs != Pnil)
190: a_tag((value)*Branch(t, TAG_NAME), targs);
191: break;
192: }
193: }
194: }
195:
196: /* ******************************************************************** */
197:
198: /* Table describing the actions of the fixer for each node type */
199:
200:
201: /*
202: LIST OF CODES AND THEIR MEANING
203:
204: char fix n? analyze
205:
206: 0-9 n= c-'0'
207:
208: # set curlino ++n set curlino
209: = ++n set to nextvarnum
210: ! locate ++n analyze; force targs= &local
211: a locate ++n analyze
212: c collateral ++n analyze collateral
213: f fpr_formals ++n a_fpr_formals
214: g ++n global
215: h ++n how'to formal
216: l locate ++n
217: m actual param ++n mystery
218: t test ++n analyze; set targs= 0
219: u unit ++n analyze
220: v evaluate ++n
221: x execute ++n analyze
222:
223: ? special code for UNPARSED
224: C special code for comparison
225: D special code for DYAF
226: E special code for DYAPRD
227: G jumpto(l1)
228: H here(&l1)
229: I if (*Branch(t, n) != NilTree) jump2here(t)
230: J jump2here(t)
231: K hold(&st)
232: L let_go(&st)
233: M special code for MONF
234: N special code for MONPRD
235: R if (!reachable()) error("command cannot be reached")
236: S jumpto(Stop)
237: T special code for TAG
238: U special code for user-defined-command
239: V visit(t)
240: W visit2(t, seterr(1))
241: X visit(t) or lvisit(t) depending on flag
242: Y special code for YIELD/TEST
243: Z special code for refinement
244:
245: */
246:
247:
248: Visible string gentab[]= {
249:
250: /* HOW_TO */ "1h3xSu6=",
251: /* YIELD */ "2fV4xYu7=",
252: /* TEST */ "2fV4xYu7=",
253: /* REFINEMENT */ "H2xZSu",
254:
255: /* Commands */
256:
257: /* SUITE */ "#RVx3x",
258: /* PUT */ "vaV",
259: /* INSERT */ "vlV",
260: /* REMOVE */ "vlV",
261: /* CHOOSE */ "avV",
262: /* DRAW */ "aV",
263: /* SET_RANDOM */ "vV",
264: /* DELETE */ "lV",
265: /* CHECK */ "tV",
266: /* SHARE */ "g",
267:
268: /* WRITE */ "1vV",
269: /* READ */ "avV",
270: /* READ_RAW */ "aV",
271:
272: /* IF */ "tV2xJ",
273: /* WHILE */ "HtV2xGJ",
274: /* FOR */ "avHV3xGJ",
275:
276: /* SELECT */ "1x",
277: /* TEST_SUITE */ "#tW3xKIxL",
278: /* ELSE */ "#2x",
279:
280: /* QUIT */ "VS",
281: /* RETURN */ "vVS",
282: /* REPORT */ "tVS",
283: /* SUCCEED */ "VS",
284: /* FAIL */ "VS",
285:
286: /* USER_COMMAND */ "1mUV",
287: /* EXTENDED_COMMAND */ "1cV",
288:
289: /* Expressions, targets, tests */
290:
291: /* TAG */ "T",
292: /* COMPOUND */ "a",
293:
294: /* Expressions, targets */
295:
296: /* COLLATERAL */ "cX",
297: /* SELECTION */ "lvX",
298: /* BEHEAD */ "lvX",
299: /* CURTAIL */ "lvX",
300:
301: /* Expressions, tests */
302:
303: /* UNPARSED */ "?",
304:
305: /* Expressions */
306:
307: /* MONF */ "M1vV",
308: /* DYAF */ "Dv2vV",
309: /* NUMBER */ "V",
310: /* TEXT_DIS */ "1v",
311: /* TEXT_LIT */ "1vV",
312: /* TEXT_CONV */ "vvV",
313: /* ELT_DIS */ "V",
314: /* LIST_DIS */ "cV",
315: /* RANGE_DIS */ "vvV",
316: /* TAB_DIS */ "cV",
317:
318: /* Tests */
319:
320: /* AND */ "tVtJ",
321: /* OR */ "tVtJ",
322: /* NOT */ "tV",
323: /* SOME_IN */ "!vHVtGJ",
324: /* EACH_IN */ "!vHVtGJ",
325: /* NO_IN */ "!vHVtGJ",
326: /* SOME_PARSING */ "!vHVtGJ",
327: /* EACH_PARSING */ "!vHVtGJ",
328: /* NO_PARSING */ "!vHVtGJ",
329: /* MONPRD */ "N1vV",
330: /* DYAPRD */ "Ev2vV",
331: /* LESS_THAN */ "vvVC",
332: /* AT_MOST */ "vvVC",
333: /* GREATER_THAN */ "vvVC",
334: /* AT_LEAST */ "vvVC",
335: /* EQUAL */ "vvVC",
336: /* UNEQUAL */ "vvVC",
337: /* Nonode */ "",
338:
339: /* TAGformal */ "T",
340: /* TAGlocal */ "T",
341: /* TAGglobal */ "T",
342: /* TAGmystery */ "T",
343: /* TAGrefinement */ "T",
344: /* TAGzerfun */ "T",
345: /* TAGzerprd */ "T",
346:
347: /* ACTUAL */ "1mm",
348: /* FORMAL */ "1hh",
349: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.