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