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