Return to trace1.c CVS log

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

Annotation of researchv10no/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:  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.