Return to trace1.c CVS log

Up to [Research Unix] / researchv8dc / cmd / trace

Annotation of researchv8dc/cmd/trace/trace1.c, revision 1.1

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.