![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to trace1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / trace|
Return to trace1.c CVS log | Up to [Research Unix] / researchv10no / cmd / trace |
1.1 root 1: #include <stdio.h>
2: #include <signal.h>
3: #include "trace.h"
4: #include "trace.d"
5:
6: #if 0
7: #define debug(s1, s2, s3, s4, s5) printf(s1, s2, s3, s4, s5)
8: #else
9: #define debug(s1, s2, s3, s4, s5)
10: #endif
11:
12: struct TBL *tbl;
13: struct LBT *lbt;
14: struct MBOX *mbox;
15: struct MNAME *fullname;
16:
17: struct REVPOL **expr;
18: struct PROCSTACK **procstack;
19:
20: struct VARPARS *procpars;
21: struct TBLPARS *tblpars;
22: struct LOCVARS *tblvars;
23: struct TBLPARS *tablpars;
24:
25: struct QUEUE **starter, **head, **tail;
26: struct QUEUE *s_first, *s_last;
27:
28: /*
29: * reftasks : mapping of logic reftask id to table number
30: * processes: mapping of logic process id to table number
31: * basics : initial process table
32: */
33:
34: int *state, *reftasks, *processes, *basics;
35: int *qsize, *globvars, *inits, *xob;
36:
37: /*
38: * the state-set of an assertion table is mapped
39: * onto the global variables (to simplify state checking)
40: * the first global that is an element from the state set
41: * is given by integer `abase'
42: */
43:
44: int abase = -1; /* base of assertion table state set */
45: int ebase = -1; /* base of error table state set */
46: int assertbl = -1; /* table used for assertion checking */
47: int errortbl = -1; /* table used for assertion checking */
48: int msgbase = -1, maxlevel = -1, maxreached = -1;
49:
50: int maxcol=0, nrtbl=0, nrqs=0, nrprocs=0, nrrefs=0;
51: int nrinit=0, nrvars=0, nexpr=0, nrmesgs=0, linecode=0;
52: int QMAX=2;
53:
54: char qoverride = 0;
55: char noshortcut = 0; /* disable timeout heuristics */
56: char prbyq = 2; /* controls output format */
57: char blast = 0; /* blast search mode */
58: char qandirty = 0; /* scatter search mode */
59: char lockplus = 0; /* report both buffer locks and loops */
60: char firstlock = 0; /* stop at first buffer lock found */
61: char maxxed = 0; /* bound on search depth */
62: char prefix = 0; /* print all prefixes too */
63: char timedd = 0; /* verbose mode */
64: char completed = 0; /* not interrupted */
65: char muststore = 0; /* must perform loop check and store state */
66: char sensible = 0; /* default mode: try a sensible partial search */
67:
68: double zapper = (double) 30000;
69: double tryswiff=0, noswiff=0, cannot=0;
70:
71: long zapped = 0, locksf = 0, loopsf = 0;
72: long normf = 0, callno = 0;
73:
74: int *effnrstates; /* effective nr of table states per process */
75: int aperiod = 120;
76:
77: char *topofmem, *sbrk(), *Smalloc();
78: char fname[64];
79:
80: FILE *mb;
81:
82: extern double iseen, ireseen, painful, kurshan;
83:
84: onalarm()
85: { float t;
86: struct { long u, p, cu, cp; } tim;
87:
88: times(&tim);
89: t = (float) (tim.u + tim.p)/ (float) 60.0;
90:
91: if (++callno%10 == 1)
92: { fprintf(stderr, " seconds depth states zapped");
93: fprintf(stderr, " prefix terms loops locks memory\n");
94: }
95: fprintf(stderr, "%8.2f %6d ", t, maxreached);
96: fprintf(stderr, "%6g %8ld %7g ", iseen+ireseen, zapped, kurshan);
97: fprintf(stderr, "%5ld %5ld ", normf, loopsf);
98: fprintf(stderr, "%5ld %8u\n", locksf, sbrk(0) - topofmem);
99: signal(SIGALRM, onalarm);
100: alarm(aperiod);
101: }
102:
103: postlude()
104: { struct { long u, p, cu, cp; } tim;
105: extern double COUNT;
106: float u, s;
107:
108: fflush(stdout);
109: if (!completed)
110: fprintf(stderr, "trace: interrupted\n");
111:
112: if (timedd)
113: { times(&tim);
114: u = (float) tim.u / (float) 60.0;
115: s = (float) tim.p / (float) 60.0;
116:
117: fprintf(stderr, "\ttime: %.2fs u + ", u);
118: fprintf(stderr, "%.2fs sys = %.2fs\n\n", s, u+s);
119: fprintf(stderr, "\t%g states cached, ", iseen+ireseen);
120: fprintf(stderr, "%ld states zapped\n", zapped);
121: fprintf(stderr, "\tsearch depth reached: %d; ", maxreached);
122: fprintf(stderr, "memory used: %u\n\t", sbrk(0) - topofmem );
123: fprintf(stderr, "%ld deadlocks, ", locksf);
124: fprintf(stderr, "%ld loops, ", loopsf);
125: fprintf(stderr, "%ld terminating executions, and ", normf);
126: fprintf(stderr, "%g prefixes\n", kurshan);
127: fprintf(stderr, "\t%g edges traversed", COUNT);
128: fprintf(stderr, ", %g states analyzed twice\n", painful);
129: if (cannot > 0)
130: fprintf(stderr, "\t%g cache replacements failed\n", cannot);
131: if (tryswiff > 0)
132: fprintf(stderr, "\ttryswiff %5g noswiff %g\n",tryswiff,noswiff);
133: }
134: exit(completed == 0);
135: }
136:
137: wisdom()
138: {
139: if (sensible)
140: { timedd = firstlock = qandirty = 1;
141: fprintf(stderr, "default search: ");
142: fprintf(stderr, "-vxjqm %d %d\n", QMAX, maxlevel);
143: } else
144: { fprintf(stderr, "%s search, ", (blast) ? "blast" :
145: (qandirty) ? "scatter" : "exhaustive");
146: fprintf(stderr, "depth bound %d\n", maxlevel);
147: }
148: }
149:
150: main(argc, argv)
151: char **argv;
152: {
153: char c;
154: int i=1, j, base=2;
155:
156: strcpy(fname, "pret.out");
157: if (argc > 1 && argv[1][0] == '-')
158: { base++;
159: while ((c = argv[1][i++]) != '\0')
160: switch (c) {
161: case 'a': prefix = 1; break;
162: case 'b': blast = qandirty = 1; break;
163: case 'c': if (argc >= base)
164: { sscanf(argv[base-1], "%d", &j);
165: base++;
166: } else
167: usage("missing argument for `c' flag");
168: firstlock = lockplus = timedd = 1;
169: switch (j) {
170: case 0: blast = qandirty = 1; break;
171: case 1: maxxed = 3; /* fall through */
172: case 2: qandirty = 1; break;
173: case 3: maxxed = 2; break; /* 1{ x effnr */
174: case 4: maxxed = 3; /* 2 x effnr */
175: case 5: break; /* 8 x effnr */
176: default: usage("unknown validation class");
177: }
178: break;
179: case 'f': prbyq = 1; break;
180: case 'F': prbyq = 0; break;
181: case 'j': firstlock = 1; break;
182: case 'k': if (argc >= base)
183: { sscanf(argv[base-1], "%d", &j);
184: zapper = (double) (j * 1000);
185: base++;
186: } else
187: usage("missing argument for `k' flag");
188: break;
189: case 'l': lockplus = 1; break;
190: case 'm': maxxed = 1;
191: if (argc >= base)
192: { sscanf(argv[base-1], "%d", &maxlevel);
193: base++;
194: } else
195: usage("missing argument for `m' flag");
196: break;
197: case 'n': noshortcut = 1; break;
198: case 'q': qoverride = 1;
199: if (argc >= base)
200: { sscanf(argv[base-1], "%d", &QMAX);
201: base++;
202: } else
203: usage("missing argument for `q' flag");
204: break;
205: case 'r': if (argc >= base)
206: { sscanf(argv[base-1], "%d", &j);
207: base++;
208: } else
209: usage("missing argument for `r' flag");
210: signal(SIGALRM, postlude);
211: aperiod = 0;
212: alarm(j*60);
213: break;
214: case 'R': if (argc >= base)
215: { sscanf(argv[base-1], "%d", &j);
216: base++;
217: } else
218: usage("missing argument for `R' flag");
219: aperiod = j*60;
220: break;
221: case 's': setup(); showtables(timedd); exit(0);
222: break;
223: case 'v': timedd = 1; break;
224: case 'x': qandirty = 1; break;
225: default : usage("unknown option");
226: }
227: } else
228: { sensible = qoverride = 1;
229: }
230:
231: if (argc >= base-1)
232: sscanf(argv[base-1], "%s", fname);
233: else
234: strcpy(fname, "pret.out");
235:
236: setup();
237: init();
238: topofmem = sbrk(0);
239:
240: if (maxxed != 1)
241: {
242: for (j = maxlevel = 0; j < nrprocs; j++)
243: maxlevel += effnrstates[processes[j]];
244:
245: switch (maxxed) {
246: case 3: maxlevel *= 2; break;
247: case 2: maxlevel = (3*maxlevel)/2; break;
248: case 0: if (sensible)
249: maxlevel *= 2;
250: else
251: maxlevel *= 8; /* avoid pathetic cases */
252: break;
253: default: whoops("cannot happen - main");
254: }
255: maxxed = 1;
256: }
257: if (aperiod > 0)
258: { signal(SIGALRM, onalarm);
259: alarm(aperiod);
260: } signal(SIGINT, postlude);
261:
262: wisdom();
263: muststore = 1; /* must always store initial state */
264: FSE(0);
265: completed = 1;
266: postlude();
267: }
268:
269: setup()
270: {
271: if ((mb = fopen(fname, "r")) == NULL)
272: { fprintf(stderr, "cannot find `%s'\n", fname);
273: exit(1);
274: }
275:
276: getglobals();
277: gettables();
278: getexprs();
279:
280: fclose(mb);
281: }
282:
283: getglobals()
284: { register int i, j;
285: int a, b, c, x, y, z;
286:
287: if (fscanf(mb, "%d linecode\n", &linecode) != 1)
288: badinput("linecode");
289: a = fscanf(mb, "%d procedures (assert %d/%d)\n", &x, &assertbl, &errortbl);
290: if (a != 3)
291: badinput("procedures");
292: if (fscanf(mb, "%d processes\n", &y) != 1)
293: badinput("processes");
294: if (fscanf(mb, "%d queues:\n", &z) != 1)
295: badinput("queues");
296:
297: debug("%d procs, %d functions, %d queues, assert %d\n", y, x, z, assertbl);
298:
299: nrtbl = x + y;
300: nrqs = z;
301: alloc1(x, y, z);
302:
303: getmesnames();
304:
305: for (i = 0; i < z; i++)
306: { if (fscanf(mb, "%s\t%d/%d/%d: ", mbox[i].qname, &b, &a, &c) != 4)
307: badinput("queue sorts");
308: alloc2(i, a, b);
309: for (j = 0; j < c; j++)
310: { fscanf(mb, "%d,", &b);
311: xob[b] = i;
312: }
313: }
314:
315: if (fscanf(mb, "%d inits:\n", &nrinit) != 1)
316: badinput("queue inits");
317:
318: alloc3(nrinit);
319: for (i = 0; i < nrinit; i++)
320: fscanf(mb, "%d,", &(inits[i]));
321:
322: if (fscanf(mb, "%d g-variables: ", &nrvars) != 1)
323: badinput("g-variables");
324:
325: alloc4(nrvars);
326:
327: for (i = 0; i < nrvars; i++)
328: if (fscanf(mb, "%d,", &a) != 1)
329: badinput("g-var-inits");
330: else
331: { if ((b = determine(a)) == 1 || b == 2)
332: badinput("g-var bad init");
333: else
334: globvars[i] = (short) a;
335: }
336: }
337:
338: getmesnames()
339: { register int i;
340: if (fscanf(mb, "%d messages, base %d:\n", &nrmesgs, &msgbase) != 2)
341: badinput("messages");
342:
343: alloc45(nrmesgs);
344:
345: for (i = 0; i < nrmesgs; i++)
346: if (fscanf(mb, "%s ", fullname[i].mname) != 1)
347: badinput("mesg");
348: }
349:
350: gettables()
351: { register int i, j;
352: int a, b, c, d;
353: char name[32];
354:
355: processes[0] = -1;
356: if (nrtbl >= 64)
357: badinput("too many process tables...");
358: for (i = 0; i < nrtbl; i++)
359: { if ((j = fscanf(mb, "%s %d:%d/%d:", name, &a, &b, &c)) != 4)
360: { printf("matched %d: %s %d\n", j, name, a);
361: badinput("table header");
362: }
363:
364: debug("table %d: %s (%d) ", i, name, a, 0);
365: debug("r/c: %d/%d\n", b, c, 0, 0);
366:
367: if (b >= 1024)
368: badinput("too many states");
369: if ((tbl[i].nrrows = b) == 0)
370: badinput("empty table");
371: tbl[i].nrcols = c;
372:
373: if (strcmp(name, "REF") == 0)
374: { reftasks[a] = i;
375: nrrefs++;
376: } else
377: { processes[a] = basics[a] = i;
378: nrprocs++;
379: effnrstates[i] = b;
380: }
381:
382: if (b > 0)
383: { alloc5(i);
384: for (j = 0; j < c; j++)
385: { if (fscanf(mb, "%d(%d),", &b, &d) != 2)
386: badinput("column header");
387:
388: debug("%d(%d),\n", b, d, 0, 0);
389:
390: tbl[i].coltyp[j] = d;
391: tbl[i].colmap[j] = b;
392: if (d != FCT && d != SPN && d != CND)
393: tbl[i].colorg[j] = whichq(b);
394: else
395: tbl[i].colorg[j] = -1;
396: }
397: getrows(i);
398: getspecials(i);
399: getcalls(i);
400: getparams(a, i);
401: getlocvars(a, i);
402: } } }
403:
404: getrows(nn)
405: { int a, b, c;
406: int n = nn;
407: char tmp[128];
408:
409: for (;;)
410: { if (fscanf(mb, "%d/%d (%d) ", &a, &b, &c) != 3)
411: badinput("row");
412:
413: if (a == 0 && b == 0 && c == 0)
414: break;
415:
416: debug("row %d, col %d, size %d:\n", a, b, c, 0);
417:
418: if (c == 0)
419: continue;
420:
421: tbl[n].deadrow[a] = 0;
422: getentries(n, a, b, c);
423: }
424: if (!linecode) return;
425:
426: if (fscanf(mb, "%s\n", tmp) != 1 || strcmp(tmp, "rownames:") != 0)
427: badinput("rownames");
428: for (a = 0; a < tbl[n].nrrows; a++)
429: { for (b = 0; (tbl[n].rowname[a][b] = getc(mb)) != '\n'; b++) ;
430: tbl[n].rowname[a][b] = '\0';
431: }
432: }
433:
434: getentries(nn, m, p, q)
435: { register int i;
436: int x, y, n = nn;
437:
438: tbl[n].ptr[m][p].nrpils = (short) q;
439:
440: alloc6(n, m, p, q);
441:
442: for (i = 0; i < q; i++)
443: { if (fscanf(mb, "[%d,%d] ", &x, &y) != 2)
444: badinput("table entry");
445: tbl[n].ptr[m][p].one[i].transf = (short) x;
446: tbl[n].ptr[m][p].one[i].valtrans = (short) y;
447:
448: debug("\t[%d,%d] \n", x, y, 0, 0);
449: }
450: }
451:
452: getspecials(in)
453: { register int i;
454: int n, m;
455: char stri[64];
456: if (fscanf(mb, "ENDSTATES %d: ", &n) != 1)
457: badinput("endstates");
458:
459: for (i = 0; i < n; i++)
460: { if (fscanf(mb, "%d,", &m) != 1 || m < 0 || m >= tbl[in].nrrows)
461: badinput("endstate");
462: tbl[in].endrow[m] = 1;
463: }
464: if ((m = fscanf(mb, "%s %d: ", stri, &n)) != 2 ||
465: strcmp(stri, "BADSTATES") != 0)
466: { printf("read %s %d\n", stri, n);
467: badinput("badstates");
468: }
469:
470: for (i = 0; i < n; i++)
471: { if (fscanf(mb, "%d,", &m) != 1 || m < 0 || m >= tbl[in].nrrows)
472: badinput("badstate");
473: tbl[in].badrow[m] = 1;
474: }
475:
476: if ((m = fscanf(mb, "%s %d: ", stri, &n)) != 2 ||
477: strcmp(stri, "LABSTATES") != 0)
478: { printf("read %s %d\n", stri, n);
479: badinput("labstates");
480: }
481:
482: for (i = 0; i < n; i++)
483: { if (fscanf(mb, "%d,", &m) != 1 || m < 0 || m >= tbl[in].nrrows)
484: badinput("labstate");
485: tbl[in].labrow[m] = 1;
486: }
487: debug("specials:\n", 0, 0, 0, 0);
488: for (i = 0; i < tbl[in].nrrows; i++)
489: { n = tbl[in].endrow[i];
490: m = tbl[in].badrow[i];
491: debug("\t%d: %d/%d/%d\n", i, n, m, tbl[in].labrow[i]);
492: }
493: }
494:
495: getparams(pr, tb)
496: { int n, m;
497: char stri[64];
498: if (fscanf(mb, "%s %d/%d", stri, &n, &m) != 3)
499: { printf("read %s %d/%d\n", stri, n, m);
500: badinput("parameters");
501: }
502:
503: tblpars[tb].nrms = (short) n; /* required sizes */
504: tblpars[tb].nrvs = (short) m;
505:
506: if (processes[pr] == tb)
507: alloc8(pr, 2*n, 2*m); /* avalaible sizes */
508: }
509:
510: getlocvars(p, tb)
511: { register int i;
512: int n, m;
513: if (fscanf(mb, "%d l-variables: ", &n) != 1)
514: badinput("l-variables");
515:
516: if (processes[p] != tb)
517: { tblvars[tb].nrlvars = (short) n; /* required size */
518: if (n > 0)
519: tblvars[tb].lvarvals = (short *)
520: Smalloc(n * sizeof(short));
521: for (i = 0; i < n; i++)
522: if (fscanf(mb, "%d,", &m) != 1)
523: badinput("l-vars");
524: else
525: tblvars[tb].lvarvals[i] = (short) m;
526: } else
527: { tablpars[p].nrlvars = (short) (2*n); /* available size */
528: procpars[p].nrlvars = (short) n; /* actually used */
529: if (n > 0)
530: procpars[p].lvarvals = (short *)
531: Emalloc((2*n) * sizeof(short));
532: for (i = 0; i < n; i++)
533: if (fscanf(mb, "%d,", &m) != 1)
534: badinput("lvar-inits");
535: else
536: procpars[p].lvarvals[i] = (short) m;
537: }
538: }
539:
540: getcalls(in)
541: { register int i, j;
542: int k, n, m, a, b, N;
543: char stri[64];
544: if (fscanf(mb, "%s %d", stri, &n) != 2) /* FCTS */
545: { printf("read %s %d\n", stri, n);
546: badinput("function calls");
547: }
548: alloc9(in, n);
549: for (i = 0, N = n; i < N; i++)
550: { if (fscanf(mb, "%d-%d/%d: ", &n, &m, &k) != 3)
551: badinput("fct call");
552:
553: alloc10(in, i, n, m, k);
554:
555: effnrstates[in] += tbl[reftasks[n]].nrrows;
556:
557: for (j = m+k, a = b = 0; j > 0; j--)
558: { if (fscanf(mb, "%d/%d", &n, &m) != 2)
559: badinput("fct call entry");
560: if (n == 0)
561: tbl[in].calls[i].ms[a++] = (short) m;
562: else
563: tbl[in].calls[i].vs[b++] = (short) m;
564: } }
565: }
566:
567: getexprs()
568: { int i, j, a, b, c;
569: char name[32];
570:
571: if (fscanf(mb, "%s %d\n", name, &nexpr) != 2)
572: badinput("nexpr");
573: if (strcmp(name, "EXPR") != 0)
574: badinput("expressions");
575:
576: expr = (struct REVPOL **)
577: Smalloc(nexpr * sizeof(struct REVPOL *));
578:
579: for (i = 0; i < nexpr; i++)
580: { fscanf(mb, "%d: ", &a);
581:
582: expr[i] = (struct REVPOL *)
583: Smalloc(a * sizeof(struct REVPOL));
584:
585: for (j = 0; j < a; j++)
586: { fscanf(mb, "%d/%d: %d\n", &b, &c);
587: expr[i][j].toktyp = b;
588: expr[i][j].tokval = c;
589: } }
590: }
591:
592: showtables(how)
593: { register int i, j;
594: int k, n, m, p;
595: char table[2*MAXPROC][64];
596:
597: for (i = 0; i < nrprocs; i++)
598: { j = processes[i];
599: sprintf(table[j], "process %d", i);
600: }
601: for (i = 0; i < nrrefs; i++)
602: { j = reftasks[i];
603: sprintf(table[j], "reftask %d", i);
604: }
605:
606: for (i = 0; i < nrtbl; i++)
607: {
608: printf("\n%s (table %d):\n", table[i], i);
609: if (how && linecode)
610: { for (j = 2+strlen(tbl[i].rowname[0]); j > 0; j--)
611: putchar(' ');
612: } else printf(" ");
613: putchar('\t');
614: for (k = 0; k < tbl[i].nrcols; k++)
615: { switch(tbl[i].coltyp[k]) {
616: case INP: printf("I:"); break;
617: case DFL: printf("D:"); break;
618: case TMO: printf("T:"); break;
619: case OUTP: printf("O:"); break;
620: case SPN: printf("S:"); break;
621: case CND: printf("C:"); break;
622: case FCT: printf("F:"); break;
623: }
624: if (tbl[i].colorg[k] != -1)
625: printf("%d/%d\t", tbl[i].colmap[k], tbl[i].colorg[k]);
626: else
627: printf("%d \t", tbl[i].colmap[k]);
628: }
629:
630: for (j = 0; j < tbl[i].nrrows; j++)
631: { if (!how || !linecode)
632: printf("\n%2d\t", j);
633: else
634: printf("\n%2d/%s\t", j, tbl[i].rowname[j]);
635: for (k = 0; k < tbl[i].nrcols; k++)
636: { if (how)
637: {
638: for (p = 0; p < tbl[i].ptr[j][k].nrpils; p++)
639: { n = (int) tbl[i].ptr[j][k].one[p].transf;
640: printf("%d,", n);
641: }
642: } else
643: {
644: if (tbl[i].ptr[j][k].nrpils > 0)
645: { n = (int) tbl[i].ptr[j][k].one[0].transf;
646: m = (int) tbl[i].ptr[j][k].one[0].valtrans;
647: printf("%d(%d)", n, m);
648: }
649: if (tbl[i].ptr[j][k].nrpils > 1)
650: putchar('+');
651: }
652: putchar('\t');
653: }
654: } }
655: putchar('\n');
656: }
657:
658: whichq(n)
659: { int i;
660: if (n < 0 || n >= MANY)
661: return -1;
662:
663: if ((i = xob[n]) == -1)
664: badinput("mbox sort incomplete");
665:
666: return i;
667: }
668:
669: init()
670: { register int i, m;
671: state = (int *)
672: Smalloc(nrprocs * sizeof(int));
673: qsize = (int *)
674: Smalloc(nrqs * sizeof(int));
675: head = (struct QUEUE **)
676: Smalloc(nrqs * sizeof(struct QUEUE *));
677: tail = (struct QUEUE **)
678: Smalloc(nrqs * sizeof(struct QUEUE *));
679: starter = (struct QUEUE **)
680: Smalloc(nrqs * sizeof(struct QUEUE *));
681:
682:
683: for (i = 0; i < nrqs; i++)
684: { starter[i] = (struct QUEUE *)
685: Smalloc(sizeof(struct QUEUE));
686: starter[i]->next = NULL;
687: qsize[i] = 0;
688: head[i] = tail[i] = starter[i];
689: }
690:
691: decode();
692: initable(); /* do not change the order of inits */
693: iniqtable();
694: inihash();
695:
696: for (i = 0; i < nrprocs; i++)
697: { state[i] = 0;
698: procstack[i] = NULL;
699:
700: lbt[i].mapcol = (int *)
701: Smalloc(maxcol * sizeof(int));
702: lbt[i].orgcol = (int *)
703: Smalloc(maxcol * sizeof(int));
704: fiddler(i);
705: }
706:
707: s_last = NULL;
708:
709: for (i = 0; i < nrinit; i++)
710: { m = inits[i];
711: if (send(m, whichq(m), NONE, NONE, 0) == 0)
712: badinput("qsize too small for initial string...");
713: }
714: if (assertbl != NONE)
715: { assertbl = reftasks[assertbl];
716:
717: abase = nrvars;
718: nrvars += tbl[assertbl].nrrows;
719:
720: if (abase > 0)
721: globvars = (int *)
722: Realloc(globvars, nrvars * sizeof(int));
723: else
724: globvars = (int *)
725: Smalloc(nrvars * sizeof(int));
726:
727: globvars[abase] = 1;
728: for (i = abase+1; i < nrvars; i++)
729: globvars[i] = 0;
730: }
731: if (errortbl != NONE)
732: { errortbl = reftasks[errortbl];
733:
734: ebase = nrvars;
735: nrvars += tbl[errortbl].nrrows;
736:
737: if (ebase > 0)
738: globvars = (int *)
739: Realloc(globvars, nrvars * sizeof(int));
740: else
741: globvars = (int *)
742: Smalloc(nrvars * sizeof(int));
743:
744: globvars[ebase] = 1;
745: for (i = ebase+1; i < nrvars; i++)
746: globvars[i] = 0;
747: }
748: }
749:
750: decode()
751: { register int i, j, m;
752:
753: for (i = 0; i < nrvars; i++)
754: { m = convert(globvars[i], NONE);
755: globvars[i] = (short) m;
756: }
757: for (i = 0; i < nrprocs; i++)
758: for (j = 0; j < procpars[i].nrlvars; j++)
759: { m = convert(procpars[i].lvarvals[j], i);
760: procpars[i].lvarvals[j] = (short) m;
761: }
762: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.