![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to trace4.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / cmd / trace|
Return to trace4.c CVS log | Up to [Research Unix] / researchv8dc / cmd / trace |
1.1 root 1: #include "stdio.h"
2: #include "trace.h"
3: #include "trace.d"
4:
5: extern char lockplus, prefix, ignvars, ignques;
6: extern char mask[MAXPROC];
7:
8: extern struct QUEUE *s_last;
9: extern int *processes, *globvars, *state;
10: extern int nrprocs, nrrefs, nrvars, level;
11: extern double zapper;
12: extern long loopsf, zapped;
13: extern struct PROCSTACK **procstack;
14: extern struct VARPARS *procpars;
15:
16: double iseen = 0;
17: double ireseen = 0;
18:
19: struct VISIT *lastvisit;
20: struct STATE *giveme(), *setstate();
21: char *Smalloc(), *emalloc();
22:
23: struct STATE *
24: inloop()
25: { struct STATE *tmp;
26: register struct VISIT *hook;
27: register int i, x; char aa;
28: int h = hashvalue();
29:
30: for (x = member(h); x > 0; x--)
31: { tmp = giveme(h, x);
32: hook = tmp->next;
33: if (samestate(tmp))
34: { for (i = tmp->nrvisits; i >= 1; i--, hook = hook->next)
35: {
36: if (hook->analyzed)
37: { if (ignques || Queuesmatch(hook))
38: { if (prefix)
39: output("prefix: ", 0);
40: return NULL;
41: }
42: } else
43: { if (Queuesmatch(hook))
44: { loopsf++;
45: aa = assertholds();
46: if (aa == 0 || lockplus)
47: putloop(hook->prop.h, aa);
48: return NULL;
49: }
50: } }
51: return setstate(tmp, h);
52: }
53: }
54: return setstate((struct STATE *) NULL, h);
55: }
56:
57: cmplvars(one, two)
58: struct LOCVARS *one;
59: struct VARPARS *two;
60: { int i;
61:
62: if (one->nrlvars != two->nrlvars)
63: whoops("cannot happen - cmplocal");
64:
65: for (i = 0; i < one->nrlvars; i++)
66: if (one->lvarvals[i] != two->lvarvals[i])
67: return 0;
68:
69: return 1;
70: }
71:
72: cmplocals(one, two)
73: struct VARPARS *one, *two;
74: { int i;
75:
76: if (one->nrlvars != two->nrlvars)
77: whoops("cannot happen - cmplocal");
78:
79: for (i = 0; i < one->nrlvars; i++)
80: if (one->lvarvals[i] != two->lvarvals[i])
81: return 0;
82:
83: return 1;
84: }
85:
86: cmparams(one, two)
87: struct VARPARS *one, *two;
88: { register int i;
89:
90: if (one->nrms != two->nrms || one->nrvs != two->nrvs)
91: whoops("cannot happen - cmparams");
92:
93: for (i = 0; i < one->nrms; i++)
94: if (one->ms[i] != two->ms[i])
95: return 0;
96: for (i = 0; i < one->nrvs; i++)
97: if (one->vs[i] != two->vs[i])
98: return 0;
99:
100: return 1;
101: }
102:
103: cmpstacks(older, newer)
104: struct PROCSTACK *older, *newer;
105: { struct PROCSTACK *tmp1 = older;
106: struct PROCSTACK *tmp2 = newer;
107:
108: while (tmp2 != NULL)
109: {
110: if (tmp1->uptable != tmp2->uptable
111: || tmp1->uptransf != tmp2->uptransf)
112: return 0;
113:
114: if (cmplocals(tmp1->varparsaved, tmp2->varparsaved) == 0
115: || cmparams (tmp1->varparsaved, tmp2->varparsaved) == 0)
116: return 0;
117:
118: tmp1 = tmp1->follow;
119: tmp2 = tmp2->follow;
120: }
121: return 1;
122: }
123:
124: samestate(at)
125: struct STATE *at;
126: { register int i;
127:
128: for (i = 0; i < nrprocs; i++)
129: { if (mask[i])
130: continue;
131:
132: if (at->trip[i].prev != (short) state[i]
133: || at->trip[i].pmap != (short) processes[i])
134: return 0;
135: if (ignvars == 0
136: && (cmplvars(at->l_vars[i], &(procpars[i])) == 0 ||
137: (nrrefs > 0 && cmpstacks(at->traceback[i], procstack[i]) == 0)
138: ))
139: return 0;
140: }
141:
142: if (!ignvars)
143: for (i = 0; i < nrvars; i++)
144: if (at->g_vars[i] != (short) globvars[i])
145: return 0;
146:
147: return 1;
148: }
149:
150: cpylvars(into, from)
151: struct LOCVARS *into;
152: struct VARPARS *from;
153: { register int i;
154:
155: into->nrlvars = from->nrlvars;
156: into->lvarvals = (short *)
157: Smalloc(from->nrlvars * sizeof(short));
158: for (i = 0; i < from->nrlvars; i++)
159: into->lvarvals[i] = from->lvarvals[i];
160: }
161:
162: cpylocals(into, from)
163: struct VARPARS *into, *from;
164: { register int i;
165:
166: into->nrlvars = from->nrlvars;
167: into->lvarvals = (short *)
168: Smalloc(from->nrlvars * sizeof(short));
169: for (i = 0; i < from->nrlvars; i++)
170: into->lvarvals[i] = from->lvarvals[i];
171: }
172:
173: cpyparams(into, from)
174: struct VARPARS *into, *from;
175: { int i;
176:
177: into->nrms = from->nrms;
178: into->ms = (short *)
179: Smalloc(from->nrms * sizeof(short));
180: for (i = 0; i < from->nrms; i++)
181: into->ms[i] = from->ms[i];
182:
183: into->nrvs = from->nrvs;
184: into->vs = (short *)
185: Smalloc(from->nrvs * sizeof(short));
186: for (i = 0; i < from->nrvs; i++)
187: into->vs[i] = from->vs[i];
188: }
189:
190: cpystacks(left, right)
191: struct PROCSTACK *left, *right;
192: { struct PROCSTACK *into = left;
193: struct PROCSTACK *from = right;
194:
195: while (from != NULL)
196: { into->varparsaved = (struct VARPARS *)
197: Smalloc(sizeof(struct VARPARS));
198:
199: cpylocals(into->varparsaved, from->varparsaved);
200: cpyparams(into->varparsaved, from->varparsaved);
201:
202: into->uptable = from->uptable;
203: into->uptransf = from->uptransf;
204:
205: if ((from = from->follow) != NULL)
206: { into->follow = (struct PROCSTACK *)
207: Smalloc(sizeof(struct PROCSTACK));
208: into = into->follow;
209: } }
210: }
211:
212: struct STATE *
213: newstate(pha)
214: int pha;
215: { struct STATE *hook;
216: int i;
217: struct VISIT *findastate();
218:
219: hook = (struct STATE *)
220: Smalloc(sizeof(struct STATE));
221: hook->trip = (struct TUPLE *)
222: Smalloc(nrprocs * sizeof(struct TUPLE));
223:
224: if (!ignvars)
225: { hook->l_vars = (struct LOCVARS **)
226: Smalloc(nrprocs * sizeof(struct LOCVARS *));
227:
228: hook->g_vars = (short *)
229: Smalloc(nrvars * sizeof(short));
230: for (i = 0; i < nrvars; i++)
231: hook->g_vars[i] = (short) globvars[i];
232:
233: if (nrrefs > 0)
234: hook->traceback = (struct PROCSTACK **)
235: Smalloc(nrprocs * sizeof(struct PROCSTACK *));
236: }
237:
238: for (i = 0; i < nrprocs; i++)
239: { hook->trip[i].prev = (short) state[i];
240: hook->trip[i].pmap = (short) processes[i];
241:
242: if (!ignvars)
243: { hook->l_vars[i] = (struct LOCVARS *)
244: Smalloc(sizeof(struct LOCVARS));
245:
246: cpylvars(hook->l_vars[i], &(procpars[i]));
247:
248: if (nrrefs > 0)
249: { if (procstack[i] != NULL)
250: { hook->traceback[i] = (struct PROCSTACK *)
251: Smalloc(sizeof(struct PROCSTACK));
252:
253: cpystacks(hook->traceback[i], procstack[i]);
254: } else
255: hook->traceback[i] = NULL;
256: } } }
257:
258: hook->hash = (short) pha;
259: hook->nrvisits = 1;
260: hook->next = findastate(hook);
261:
262: insert(pha, hook); /* make index in hash table */
263:
264: return hook;
265: }
266:
267: struct VISIT *
268: oldstate(where)
269: struct STATE *where;
270: { struct VISIT *tmp;
271: struct VISIT *findastate();
272: int i;
273:
274: if (where->nrvisits > 0)
275: { tmp = where->next;
276: for (i = where->nrvisits; i > 1; i--)
277: tmp = tmp->next;
278:
279: if (tmp == NULL)
280: whoops("cannot happen - oldstate");
281:
282: tmp->next = findastate(where);
283: where->nrvisits += 1;
284: ireseen += (double)1;
285:
286: return tmp->next;
287: } else
288: { where->next = findastate(where);
289: where->nrvisits = 1;
290: ireseen += (double)1;
291:
292: return where->next;
293: }
294: }
295:
296: struct STATE *
297: setstate(where, ha)
298: struct STATE *where;
299: { struct STATE *tmp;
300: struct VISIT *work;
301:
302: if (where == NULL)
303: { tmp = newstate(ha);
304: work = tmp->next;
305: } else
306: { tmp = where;
307: work = oldstate(where);
308: }
309:
310: work->prop.h = (struct STUFF *) emalloc( sizeof(struct STUFF) );
311: work->prop.h->s = s_last;
312: work->analyzed = 0;
313:
314: lastvisit = work;
315: relink(work);
316:
317: return tmp;
318: }
319:
320: struct VISIT *
321: pickstate(at)
322: struct STATE *at;
323: { struct VISIT *latter = NULL;
324: register struct VISIT *hook = at->next;
325: register int i;
326:
327: for (i = at->nrvisits; i >= 1; i--, hook = hook->next)
328: { if (hook->analyzed == 1)
329: {
330: if (latter == NULL)
331: at->next = hook->next;
332: else
333: latter->next = hook->next;
334:
335: efree(hook->prop.c);
336:
337: at->nrvisits -= 1;
338: zapped++;
339: return hook;
340: }
341: latter = hook;
342: }
343: return NULL;
344: }
345:
346: struct VISIT *
347: picknown(at, want)
348: struct STATE *at;
349: struct VISIT *want;
350: { struct VISIT *latter = NULL;
351: register struct VISIT *hook = at->next;
352: register int i, j = at->nrvisits;
353:
354: for (i = 0; i < j; i++, hook = hook->next)
355: { if (hook == want)
356: break;
357: latter = hook;
358: }
359: if (i == j)
360: whoops("cannot happen - picknown");
361:
362: if (latter == NULL)
363: at->next = hook->next;
364: else
365: latter->next = hook->next;
366:
367: efree(hook->prop.c);
368: at->nrvisits -= 1;
369: zapped++;
370:
371: return hook;
372: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.