![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pret3.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / pret|
Return to pret3.c CVS log | Up to [Research Unix] / researchv10dc / cmd / pret |
1.1 root 1: #include <stdio.h>
2: #include "pret.h"
3:
4: struct FORMALS {
5: char name[MAXNAME];
6: int typefs; /* qset or pvar (default) */
7: int tag; /* id */
8: char used; /* reference count */
9: char reset; /* default type overwritten */
10: struct FORMALS *nxtpar;
11: };
12:
13: struct {
14: char name[MAXNAME];
15: int status;
16: int nrparams;
17: int nrstates;
18: int unreach;
19: struct FORMALS *params; /* formal parameters */
20: } reftable[MAXPROC];
21:
22: int nrrefs = 0;
23:
24: extern int anyerror, pid, rid, assertion, inertion;
25: extern char qsetname[MAXNAME];
26:
27: refsize(n, m, k)
28: { reftable[n].nrstates = m;
29: reftable[n].unreach = k;
30: }
31:
32: reorder()
33: { int i, j, N, M;
34: struct FORMALS * hook;
35:
36: if (rid == NONE)
37: return;
38: /*
39: * make sure that formal msg parameters
40: * are numbered in the order in which they
41: * will be pushed onto the call stack in trace.c
42: */
43:
44: j = reftable[rid].nrparams;
45: hook = reftable[rid].params;
46:
47: for (i = N = M = 0; i < j; i++)
48: { if (hook->typefs == ISQ || hook->typefs == ISQN)
49: N = renumqset(hook->tag, N);
50: else
51: hook->tag = M++;
52:
53: hook = hook->nxtpar;
54: }
55: }
56:
57: newreftask(str, mask)
58: char *str;
59: { register int i;
60:
61: for (i = 0; i < nrrefs; i++)
62: if (strcmp(str, reftable[i].name) == 0)
63: break;
64: if (i == nrrefs)
65: { if (nrrefs >= MAXPROC)
66: whoops("too many procedures");
67: if (mask == RFR)
68: yyerror("undeclared procedure, %s", str);
69:
70: reftable[i].status = 0;
71: reftable[i].nrparams = 0;
72: reftable[i].nrstates = 0;
73: reftable[i].unreach = 0;
74: strcpy(reftable[nrrefs++].name, str);
75: } else
76: { if (mask == DCL && (reftable[i].status & DCL))
77: yyerror("procedure redeclared, %s", str);
78: if (mask == RFR && rid == i)
79: yyerror("recursive procedure, %s", str);
80: }
81: reftable[i].status |= mask;
82:
83: return i;
84: }
85:
86: struct FORMALS *
87: newparunit(str, nn, tp, ins)
88: char *str;
89: { struct FORMALS * try = (struct FORMALS *)
90: Emalloc ( sizeof(struct FORMALS) );
91:
92: try->used = 0;
93: try->reset = 0;
94:
95: strcpy(try->name, str);
96:
97: try->typefs = tp;
98: try->nxtpar = NULL;
99:
100: try->tag = nn;
101: if (!ins)
102: yyerror("unspecified parameter, %s", str);
103:
104: return try;
105: }
106:
107: addFpar(to, stri, n, vt, ins)
108: char *stri;
109: { struct FORMALS *hook;
110: int N = reftable[to].nrparams;
111: int i = N;
112:
113: if (N == 0)
114: { reftable[to].params = newparunit(stri, n, vt, ins);
115: reftable[to].nrparams++;
116: } else
117: { hook = reftable[to].params;
118: for (i = 0; i < N; i++, hook = hook->nxtpar)
119: { if (strcmp(hook->name, stri) == 0)
120: { if (ins || hook->reset == 1)
121: yyerror("name clash, %s", stri);
122:
123: hook->tag = n;
124: hook->typefs = vt;
125: hook->reset = 1;
126: break;
127: }
128: if (hook->nxtpar == NULL)
129: { hook->nxtpar = newparunit(stri, n, vt, ins);
130: reftable[to].nrparams++;
131: i++;
132: break;
133: } } }
134:
135: return i;
136: }
137:
138: Fparname(str, which, vt, hit, how, qind)
139: char *str;
140: { int i, j, k;
141: struct FORMALS * hook = reftable[which].params;
142:
143: for (i = 0, j = reftable[which].nrparams; i < j; i++)
144: { if (strcmp(str, hook->name) == 0 && hook->typefs == vt)
145: break;
146: if (hook->typefs == ISQ || hook->typefs == ISQN)
147: { switch (vt) {
148: case ISM:
149: if (hook->tag == hit
150: && (k = inqset(hook->tag, str, how, qind)) != -1)
151: return k;
152: break;
153: case ISQ:
154: if (matchowner(hook->tag, str, how, qind))
155: return hook->tag; /* id of qset */
156: break;
157: } }
158: hook = hook->nxtpar;
159: }
160: if (i == j || (vt == ISM && hook->tag != hit))
161: return -1;
162:
163: hook->used |= how;
164:
165: if (vt == ISV)
166: return hook->tag;
167:
168: return i;
169: }
170:
171: checkrefs()
172: { int i;
173: if (nrrefs == 0)
174: return;
175: for (i = 0; i < nrrefs; i++)
176: if (reftable[i].status == DCL)
177: { if (strcmp(reftable[i].name, " assert") != 0
178: && strcmp(reftable[i].name, " error") != 0)
179: printf("%s: unused procedure\n", reftable[i].name);
180: } else if (reftable[i].status == RFR)
181: printf("%s: undeclared procedure\n", reftable[i].name);
182: }
183:
184: numrefs(fd)
185: FILE *fd;
186: { extern int linecode;
187: fprintf(fd, "%d linecode\n", linecode);
188: fprintf(fd, "%d procedures ", nrrefs);
189: fprintf(fd, "(assert %d/%d)\n", assertion, inertion);
190: }
191:
192: parrefs(n, m)
193: { int i;
194: if ((i = reftable[m].nrparams - n) == 0)
195: return;
196: if (i > 0)
197: yyerror("missing parameters, %s", reftable[m].name);
198: else
199: yyerror("too many parameters, %s", reftable[m].name);
200: }
201:
202: isdigit(c) { return (c >= '0' && c <= '9'); }
203:
204: addAspecial(val, which, pn)
205: { struct FORMALS * hook = reftable[which].params;
206: int i;
207:
208: if (pn >= reftable[which].nrparams || pn < 0)
209: return;
210:
211: for (i = 0; i < pn; i++)
212: if ((hook = hook->nxtpar) == NULL)
213: whoops("cannot happen - addAspecial");
214:
215: switch (hook->typefs)
216: { case ISQN:
217: case ISQ: yyerror("mismatched parameter, %s", "queue or qset");
218: break;
219: case ISV: callentry(ISV, val);
220: break;
221: default : whoops("cannot happen - addAspecial");
222: }
223: }
224:
225: addApars(what, which, pn, index)
226: char *what;
227: { struct FORMALS * hook = reftable[which].params;
228: int val, hit, x;
229:
230: if (pn >= reftable[which].nrparams || pn < 0)
231: return;
232:
233: for (x = 0; x < pn; x++)
234: if ((hook = hook->nxtpar) == NULL)
235: whoops("cannot happen - formals");
236:
237: switch (hook->typefs)
238: { case ISQN:
239: val = newqset(what, what, 0, index);
240: x = matchset(val, hook->tag);
241: hit = qsetowner(val, x); /* find queue-id */
242: callentry(ISQ, hit); /* enter queue-id */
243: callist(val, hit); /* enter messages */
244: break;
245: case ISQ: val = newqset(what, "", RFR, index);
246: x = matchset(val, hook->tag);
247: hit = qsetowner(val, x); /* find queue-id */
248: callentry(ISQ, hit); /* enter queue-id */
249: callist(val, hit); /* enter messages */
250: break;
251: case ISV: val = addvarname(what, RFR, NONE, index, 0);
252: callentry(ISV, val);
253: break;
254: default : whoops("cannot happen - addApars");
255: }
256: }
257:
258: listrefs()
259: { int i, k;
260:
261: for (i = 0; i < nrrefs; i++)
262: { printf("\t%2d\t%s, ", i+1, reftable[i].name);
263: for (k = strlen(reftable[i].name)+1; k < 10; k++)
264: putchar(' ');
265: k = reftable[i].nrstates;
266: printf("%d state%s", k, (k!=1)?"s":"");
267: if ((k = reftable[i].unreach) > 0)
268: printf(" (%d unreachable state%s)", k, (k>1)?"s":"");
269: putchar('\n');
270: }
271: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.