![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to 1.recog.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / usr.bin / struct|
Return to 1.recog.c CVS log | Up to [CSRG BSD Unix] / 43BSD / usr.bin / struct |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)1.recog.c 4.1 (Berkeley) 2/11/83";
3: #endif not lint
4:
5: #include <stdio.h>
6: #include "1.incl.h"
7: #include "def.h"
8:
9:
10: recognize(type, ifflag) /* if ifflag = 1, statement is if()type; otherwise is type */
11: int type, ifflag; /* do whatever is needed for this statement */
12: {
13: int *arctype, i, sp;
14: VERT num, num1, nest, loophead;
15: extern long label();
16: long *arclab;
17: if (nlabs > 3) sp = nlabs; else sp = 3;
18: arctype = challoc(sizeof(*arctype) * sp); arclab = challoc(sizeof(*arclab) * sp);
19: for( i=0; i < endbuf; i++) {if (buffer[i] == '~') buffer[i] = ' ';}
20: loophead = nest = innerdo(label(0));
21: if (DEFINED(nest))
22: {
23: /* this statement is last line of do loop */
24: nest = ARC(nest,0); /* nest is ITERVX of the innermost do ending here */
25: }
26:
27:
28: if (ifflag)
29: {
30: if (type == ungo)
31: {
32: arctype[0] = -2;
33: arclab[0] = label(1);
34: }
35: else
36: arctype[0] = 0;
37:
38: arctype[1] = (nest >= 0) ? nest : -2;
39: arclab[1] = implicit;
40: num1 = makenode(IFVX,TRUE,TRUE,label(0),2,arctype,arclab);
41: PRED(num1) = pred;
42: }
43:
44: arctype[0] = (nest >= 0) ? nest : -2;
45: arclab[0] = implicit;
46:
47: switch(type)
48: {
49: case ungo:
50: if (!ifflag)
51: {
52: connect(label(1),implicit);
53: if (label(0) != implicit) connect(label(1),label(0));
54: }
55: break;
56: case RETVX:
57: case STOPVX:
58: if (type == RETVX)
59: {
60: if (retvert == UNDEFINED)
61: retvert = makenode(type,FALSE,FALSE,implicit,0,arctype,arclab);
62: num = retvert;
63: }
64: else
65: {
66: if (stopvert == UNDEFINED)
67: stopvert = makenode(type,FALSE,FALSE,implicit,0,arctype,arclab);
68: num = stopvert;
69: }
70: if (!ifflag)
71: {
72: fixvalue(implicit,num);
73: clear(implicit);
74: if (label(0) != implicit) fixvalue(label(0),num);
75: }
76: break;
77:
78:
79: case contst:
80: contin(label(0),loophead);
81: break;
82:
83: case FMTVX:
84: num = makenode(FMTVX,FALSE,TRUE,implicit,0,arctype,arclab);
85: BEGCODE(num) = comchar + 1 - rtnbeg;
86: ONDISK(num) = endline - endcom;
87: if (label(0) != implicit)
88: fixvalue(label(0),num);
89: FMTLST = append(num,FMTLST);
90: break;
91: case STLNVX:
92: if (DEFINED(stflag) && !ifflag && (label(0) == implicit))
93: {
94: ++CODELINES(stflag);
95: ONDISK(stflag) += endline - begline + 1;
96: }
97: else
98: {
99: num = makenode(STLNVX,!ifflag,!ifflag,label(0),1,arctype,arclab);
100: if (!ifflag)
101: {
102: stflag = num;
103: BEGCODE(num) = comchar + 1 - rtnbeg;
104: ONDISK(num) = endline - endcom;
105: CODELINES(num) = 1;
106: }
107: else
108: {
109: BEGCODE(num) = stcode;
110: ONDISK(num) = FALSE;
111: CODELINES(num) = 1;
112: }
113: }
114: break;
115:
116: case DOVX:
117: if (arctype[0] != -2)
118: {
119: error("illegal do range, ","","");
120: fprintf(stderr," between lines %d and %d\n",begline, endline);
121: exit(1);
122: }
123: arctype[1] = UNDEFINED;
124: num1 = makenode(DOVX,TRUE,TRUE,label(0),2,arctype,arclab);
125: if (++doptr >= maxdo)
126: {
127: faterr("in parsing:\n","do loops nested deeper than allowed","");
128: }
129: dostack[doptr] = label(1);
130: doloc[doptr] = num1; /* stack link to node after loop */
131: INC(num1) = inc;
132: num = makenode(ITERVX,TRUE,FALSE,implicit,1,arctype,arclab);
133: ARC(num1,0) = num;
134: FATH(num) = UNDEFINED; /* number of DOVX can change so leave UNDEFINED until later */
135: break;
136: case arithif:
137: if (label(1) == label(2) || label(1) == 0L)
138: makeif(1,label(0),concat(pred," > 0"),label(3),label(2));
139: else if (label(1) == label(3) || label(3) == 0L)
140: makeif(1,label(0),concat(pred," == 0"),label(2),label(1));
141: else if (label(2) == label(3) || label(2) == 0L)
142: makeif(1,label(0),concat(pred," < 0"),label(1),label(3));
143: else
144: {
145: makeif(1,label(0),concat(pred," < 0"),label(1),implicit);
146: makeif(1,implicit,concat(pred," == 0"),label(2),label(3));
147: }
148: break;
149:
150: case IOVX:
151: if (endlab)
152: {
153: arctype[1] = -2;
154: arclab[1] = endlab->labelt;
155: }
156: else
157: arctype[1] = UNDEFINED;
158: if (errlab)
159: {
160: arctype[2] = -2;
161: arclab[2] = errlab->labelt;
162: }
163: else
164: arctype[2] = UNDEFINED;
165: num = makenode(IOVX,!ifflag,!ifflag,label(0),3,arctype,arclab);
166: PRERW(num) = prerw;
167: POSTRW(num) = postrw;
168: if (reflab)
169: addref(reflab->labelt, &FMTREF(num));
170: else
171: FMTREF(num) = UNDEFINED;
172: break;
173:
174: case COMPVX:
175: if (intcase)
176: {
177: num = compcase(ifflag);
178: break;
179: }
180: case ASGOVX:
181: for (i = 0; i < nlabs - 1; i++)
182: {
183: arctype[i] = -2;
184: arclab[i] = label(nlabs-i-1);
185: }
186: num = makenode(type,!ifflag,!ifflag,label(0),nlabs - 1, arctype, arclab);
187: EXP(num) = exp;
188: break;
189: case ASVX:
190: num = makenode(ASVX,!ifflag,!ifflag,label(0),1,arctype,arclab);
191: EXP(num) = exp;
192: addref(label(1),&LABREF(num));
193: break;
194: case entry:
195: num = makenode(STLNVX,FALSE,TRUE,label(0),1,arctype,arclab);
196: BEGCODE(num) = comchar + 1 - rtnbeg;
197: ONDISK(num) = endline - endcom;
198: CODELINES(num) = 1;
199: ENTLST = append(num,ENTLST);
200: break;
201: }
202: if (ifflag && type != ungo)
203: {
204: ARC(num1,0) = num;
205: }
206: if (DEFINED(loophead)) nesteddo(label(0), loophead);
207: if (ifflag || DEFINED(loophead) || type != STLNVX) stflag = UNDEFINED;
208:
209:
210: chfree(arctype,sizeof(*arctype) * sp); chfree(arclab,sizeof(*arclab) * sp);
211: if (debug)
212: {
213: fprintf(debfd,"line %d: ", begline);
214: if (ifflag) fprintf(debfd,"if() ");
215: switch(type)
216: {case RETVX: fprintf(debfd,"return"); break;
217: case STOPVX: fprintf(debfd,"stop"); break;
218: case contst: fprintf(debfd,"continue"); break;
219: case ungo: fprintf(debfd,"uncond. goto"); break;
220: case COMPVX: fprintf(debfd,"comp. goto"); break;
221: case ASGOVX: fprintf(debfd,"ass. goto, labs"); break;
222: case ASVX: fprintf(debfd,"label assignment"); break;
223: case STLNVX: fprintf(debfd,"simple statement"); break;
224: case arithif: fprintf(debfd,"arith if"); break;
225: case DOVX: fprintf(debfd,"do "); break;
226: case FMTVX: fprintf(debfd,"format st"); break;
227: case IOVX: fprintf(debfd,"IOVX statement "); break;
228: case entry: fprintf(debfd,"entry statement "); break;
229: }
230: fprintf(debfd,"\n%s\n", buffer);
231: }
232: }
233:
234:
235:
236: makeif(first,labe,test,arc1,arc2) /* construct IFVX with arcs to labels arc1,arc2 */
237: int first;
238: long labe, arc1,arc2;
239: char *test;
240: {
241: int num, arctype[2];
242: long arclab[2];
243: arctype[0] = arctype[1] = -2;
244: arclab[0] = arc1;
245: arclab[1] = arc2;
246: num = makenode(IFVX,first,first,labe,2,arctype,arclab);
247: PRED(num) = test;
248: return(num);
249: }
250:
251:
252: innerdo(labe) /* return number of DOVX associated with labe, or UNDEFINED */
253: long labe;
254: {
255: if (DEFINED(doptr))
256: {if (dostack[doptr] == labe)
257: return(doloc[doptr--]);
258: }
259: return(UNDEFINED);
260: }
261:
262:
263:
264:
265: contin(labe,nest) /* handle continue statements */
266: long labe;
267: int nest;
268: {
269: VERT y;
270:
271: if (!DEFINED(nest))
272: { /* not nested */
273: if (labe != implicit) connect(implicit,labe); /* labe pts to next node */
274: }
275: else
276: { /* nested */
277: y = ARC(nest,0);
278: fixvalue(labe,y); /* labe pts to ITERVX */
279: fixvalue(implicit, y); /* implicit links pt to ITERVX */
280: clear(implicit);
281: }
282: }
283:
284:
285:
286:
287: nesteddo(labe,v)
288: /* if multiple do's end on same label, add arc from inner DOVX
289: to enclosing DOVX;
290: add implicit link out of outermost DOVX with this label */
291: long labe;
292: int v;
293: {
294:
295: while (DEFINED(doptr) && dostack[doptr] == labe)
296: {
297: ARC(v,1) = ARC(doloc[doptr],0); /*set inner DOVX to point to outer ITERVX */
298: v = doloc[doptr--];
299: }
300: addref(implicit, &ARC(v,1));
301: }
302:
303:
304:
305: compcase(ifflag) /* turn computed goto into case statement */
306: LOGICAL ifflag;
307: {
308: int *arctype, i, num, d, arct;
309: extern long label();
310: long *arclab;
311: char *str;
312: arctype = challoc(sizeof(*arctype) * nlabs);
313: arclab = challoc (sizeof(*arclab) * nlabs);
314:
315: d = distinct(linelabs->nxtlab,arctype,arclab,nlabs-1);
316: /* puts distinct labels in arclab, count of each in arctype */
317: arct = -2;
318: for (i = 0; i < d; ++i)
319: arctype[i] = makenode(ICASVX,FALSE,FALSE,implicit,1,&arct,&arclab[i]);
320: num = makenode(SWCHVX,!ifflag,!ifflag,label(0),d,arctype,arclab);
321: EXP(num) = exp;
322:
323: str = challoc(6*(nlabs-1)); /* 5 digits + , or \0 per label */
324: for (i = 0; i < d; ++i) /* construct list of values for each label */
325: EXP(arctype[i]) = stralloc(str,accum(str,linelabs->nxtlab,arclab[i]));
326: chfree(str,6*(nlabs-1));
327: chfree(arctype,sizeof(*arctype) * nlabs); chfree(arclab,sizeof(*arclab) * nlabs);
328: return(num);
329: }
330:
331:
332: accum(str,vlist,f) /* build string of indices in compnode corr. to label f */
333: char *str; long f; struct lablist *vlist;
334: {
335: int s,j; struct lablist *p;
336:
337: s = 0;
338: j = 1;
339: for (p = vlist; p ; p = p->nxtlab) /* search for occurrences of f */
340: {
341: if (p->labelt ==f)
342: {
343: if (s)
344: {
345: str[s] = ',';
346: ++s;
347: }
348: sprintf(&str[s],"%d",j);
349: while (str[s] != '\0') ++s;
350: }
351: ++j;
352: }
353: return(s+1);
354: }
355:
356:
357: distinct(vlist,count,dlist,size) /* make dlist into list of distinct labels in vlist */
358: struct lablist *vlist; long dlist[]; /*count[] gets count of each label; d distinct labels */
359: int count[],size;
360: {int d,i;
361: d = 0;
362: for(i = 0; i < size; i++) count[i] = 0;
363:
364: for (;vlist && vlist->labelt != 0L; vlist = vlist ->nxtlab)
365: {
366: for (i = 0; ;i++)
367: {
368: if (i == d) dlist[d++] = vlist->labelt;
369: if (dlist[i] == vlist->labelt)
370: {
371: ++count[i]; break;
372: }
373: }
374: }
375: return(d);
376: }
377:
378:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.