![[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 [Research Unix] / researchv10no / cmd / struct|
Return to 1.recog.c CVS log | Up to [Research Unix] / researchv10no / 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: if((unsigned)(BEGCODE(num))!=comchar+1-rtnbeg)
83: faterr("program too long","","");
84: ONDISK(num) = endline - endcom;
85: if (label(0) != implicit)
86: fixvalue(label(0),num);
87: FMTLST = append(num,FMTLST);
88: break;
89: case STLNVX:
90: if (DEFINED(stflag) && !ifflag && (label(0) == implicit))
91: {
92: ++CODELINES(stflag);
93: ONDISK(stflag) += endline - begline + 1;
94: }
95: else
96: {
97: num = makenode(STLNVX,!ifflag,!ifflag,label(0),1,arctype,arclab);
98: if (!ifflag)
99: {
100: stflag = num;
101: BEGCODE(num) = comchar + 1 - rtnbeg;
102: if((unsigned)(BEGCODE(num))!=comchar+1-rtnbeg)
103: faterr("program too long","","");
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: if((unsigned)(BEGCODE(num))!=comchar+1-rtnbeg)
198: faterr("program too long","","");
199: ONDISK(num) = endline - endcom;
200: CODELINES(num) = 1;
201: ENTLST = append(num,ENTLST);
202: break;
203: }
204: if (ifflag && type != ungo)
205: {
206: ARC(num1,0) = num;
207: }
208: if (DEFINED(loophead)) nesteddo(label(0), loophead);
209: if (ifflag || DEFINED(loophead) || type != STLNVX) stflag = UNDEFINED;
210:
211:
212: chfree(arctype,sizeof(*arctype) * sp); chfree(arclab,sizeof(*arclab) * sp);
213: if (debug)
214: {
215: fprintf(debfd,"line %d: ", begline);
216: if (ifflag) fprintf(debfd,"if() ");
217: switch(type)
218: {case RETVX: fprintf(debfd,"return"); break;
219: case STOPVX: fprintf(debfd,"stop"); break;
220: case contst: fprintf(debfd,"continue"); break;
221: case ungo: fprintf(debfd,"uncond. goto"); break;
222: case COMPVX: fprintf(debfd,"comp. goto"); break;
223: case ASGOVX: fprintf(debfd,"ass. goto, labs"); break;
224: case ASVX: fprintf(debfd,"label assignment"); break;
225: case STLNVX: fprintf(debfd,"simple statement"); break;
226: case arithif: fprintf(debfd,"arith if"); break;
227: case DOVX: fprintf(debfd,"do "); break;
228: case FMTVX: fprintf(debfd,"format st"); break;
229: case IOVX: fprintf(debfd,"IOVX statement "); break;
230: case entry: fprintf(debfd,"entry statement "); break;
231: }
232: fprintf(debfd,"\n%s\n", buffer);
233: }
234: }
235:
236:
237:
238: makeif(first,labe,test,arc1,arc2) /* construct IFVX with arcs to labels arc1,arc2 */
239: int first;
240: long labe, arc1,arc2;
241: char *test;
242: {
243: int num, arctype[2];
244: long arclab[2];
245: arctype[0] = arctype[1] = -2;
246: arclab[0] = arc1;
247: arclab[1] = arc2;
248: num = makenode(IFVX,first,first,labe,2,arctype,arclab);
249: PRED(num) = test;
250: return(num);
251: }
252:
253:
254: innerdo(labe) /* return number of DOVX associated with labe, or UNDEFINED */
255: long labe;
256: {
257: if (DEFINED(doptr))
258: {if (dostack[doptr] == labe)
259: return(doloc[doptr--]);
260: }
261: return(UNDEFINED);
262: }
263:
264:
265:
266:
267: contin(labe,nest) /* handle continue statements */
268: long labe;
269: int nest;
270: {
271: VERT y;
272:
273: if (!DEFINED(nest))
274: { /* not nested */
275: if (labe != implicit) connect(implicit,labe); /* labe pts to next node */
276: }
277: else
278: { /* nested */
279: y = ARC(nest,0);
280: fixvalue(labe,y); /* labe pts to ITERVX */
281: fixvalue(implicit, y); /* implicit links pt to ITERVX */
282: clear(implicit);
283: }
284: }
285:
286:
287:
288:
289: nesteddo(labe,v)
290: /* if multiple do's end on same label, add arc from inner DOVX
291: to enclosing DOVX;
292: add implicit link out of outermost DOVX with this label */
293: long labe;
294: int v;
295: {
296:
297: while (DEFINED(doptr) && dostack[doptr] == labe)
298: {
299: ARC(v,1) = ARC(doloc[doptr],0); /*set inner DOVX to point to outer ITERVX */
300: v = doloc[doptr--];
301: }
302: addref(implicit, &ARC(v,1));
303: }
304:
305:
306:
307: compcase(ifflag) /* turn computed goto into case statement */
308: LOGICAL ifflag;
309: {
310: int *arctype, i, num, d, arct;
311: extern long label();
312: long *arclab;
313: char *str;
314: arctype = challoc(sizeof(*arctype) * nlabs);
315: arclab = challoc (sizeof(*arclab) * nlabs);
316:
317: d = distinct(linelabs->nxtlab,arctype,arclab,nlabs-1);
318: /* puts distinct labels in arclab, count of each in arctype */
319: arct = -2;
320: for (i = 0; i < d; ++i)
321: arctype[i] = makenode(ICASVX,FALSE,FALSE,implicit,1,&arct,&arclab[i]);
322: num = makenode(SWCHVX,!ifflag,!ifflag,label(0),d,arctype,arclab);
323: EXP(num) = exp;
324:
325: str = challoc(6*nlabs); /* 5 digits + , or \0 per label */
326: for (i = 0; i < d; ++i) /* construct list of values for each label */
327: EXP(arctype[i]) = stralloc(str,accum(str,linelabs->nxtlab,arclab[i]));
328: chfree(str,6*nlabs);
329: chfree(arctype,sizeof(*arctype) * nlabs); chfree(arclab,sizeof(*arclab) * nlabs);
330: return(num);
331: }
332:
333:
334: accum(str,vlist,f) /* build string of indices in compnode corr. to label f */
335: char *str; long f; struct lablist *vlist;
336: {
337: int s,j; struct lablist *p;
338:
339: s = 0;
340: j = 1;
341: for (p = vlist; p ; p = p->nxtlab) /* search for occurrences of f */
342: {
343: if (p->labelt ==f)
344: {
345: if (s)
346: {
347: str[s] = ',';
348: ++s;
349: }
350: sprintf(&str[s],"%d",j);
351: while (str[s] != '\0') ++s;
352: }
353: ++j;
354: }
355: return(s+1);
356: }
357:
358:
359: distinct(vlist,count,dlist,size) /* make dlist into list of distinct labels in vlist */
360: struct lablist *vlist; long dlist[]; /*count[] gets count of each label; d distinct labels */
361: int count[],size;
362: {int d,i;
363: d = 0;
364: for(i = 0; i <= size; i++) count[i] = 0;
365:
366: for (;vlist && vlist->labelt != 0L; vlist = vlist ->nxtlab)
367: {
368: for (i = 0; ;i++)
369: {
370: if (i == d) dlist[d++] = vlist->labelt;
371: if (dlist[i] == vlist->labelt)
372: {
373: ++count[i]; break;
374: }
375: }
376: }
377: return(d);
378: }
379:
380:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.