![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Pret CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / pret|
Return to Pret CVS log | Up to [Research Unix] / researchv10no / cmd / pret |
1.1 root 1: # To unbundle, sh this file
2: echo makefile 1>&2
3: sed 's/.//' >makefile <<'//GO.SYSIN DD makefile'
4: -CC = cc
5: -YFLAGS = -dDv
6: -CFLAGS = -g
7: -OBJS = pret.o pret1.o pret2.o pret3.o pret4.o pret6.o pret7.o pret8.o pret9.o pret0.o pretlex.o
8: -
9: -# FILES:
10: -# pret.y - yacc parser
11: -# pret.h - constants and macros
12: -# pret.d - internal representation of the tables
13: -# pret0.c - reduction of the state machines
14: -# pret1.c - qsets
15: -# pret2.c - operations on rows and columns
16: -# pret3.c - procedures
17: -# pret4.c - processes
18: -# pret6.c - queues and messages
19: -# pret7.c - memory allocation
20: -# pret8.c - variables
21: -# pret9.c - parameters
22: -# pret.expr.c - expressions
23: -# pretlex.c lexical analyzer
24: -
25: -pret: $(OBJS) pret.h pret.d
26: - $(CC) $(CFLAGS) $(OBJS) -lln -o pret
27: -
28: -pret.o: pret.y pret.expr.c
29: -
30: -pretlex.o: pretlex.l x.tab.h
31: - lex pretlex.l
32: - $(CC) $(CFLAGS) -c lex.yy.c
33: - rm lex.yy.c
34: - mv lex.yy.o pretlex.o
35: -
36: -x.tab.h: y.tab.h
37: - -cmp -s x.tab.h y.tab.h || cp y.tab.h x.tab.h
38: -
39: -clean:
40: - rm -f *.o [xy].tab.[ch] y.output pret.out pret.err pret.tmp core a.out
41: -
42: -install:
43: - cp pret /usr/bin
44: //GO.SYSIN DD makefile
45: echo pret.d 1>&2
46: sed 's/.//' >pret.d <<'//GO.SYSIN DD pret.d'
47: - /*
48: - ** 3-dimensional table:
49: - ** one row per state
50: - ** one column per event
51: - ** one `pilar' per possible response
52: - */
53: -
54: - struct ENTRY {
55: - int nrpils; /* size of pilar stack */
56: - struct PILAR *pilar;
57: - struct ENTRY *nextrow;
58: - struct ENTRY *nextcol;
59: - };
60: - struct PILAR {
61: - int transf; /* row transition function */
62: - int code; /* output message or bltin index */
63: - struct PILAR *nxtp; /* last pilar points to NULL */
64: - };
65: -
66: - struct COL {
67: - int coltype; /* msg, spont, tau, default, task, condition */
68: - int ccode;
69: - };
70: -
71: - struct ROW {
72: - char name[256]; /* can be composite name */
73: - char reached; /* is row reachable ? */
74: - char refcount; /* label reference index */
75: - char labeled; /* start of do-loop or label */
76: - int mapping; /* indicates transit rows */
77: - int maptwo; /* renumbers reduced table */
78: - };
79: //GO.SYSIN DD pret.d
80: echo pret.expr.c 1>&2
81: sed 's/.//' >pret.expr.c <<'//GO.SYSIN DD pret.expr.c'
82: -#define DEBUG 0
83: -
84: -#define setv 1
85: -#define addeq 2
86: -#define subeq 3
87: -#define muleq 4
88: -#define diveq 5
89: -#define modeq 6
90: -#define plus 7
91: -#define minus 8
92: -#define times 9
93: -#define div 10
94: -#define mod 11
95: -#define power 12
96: -#define uminus 13
97: -#define gt 14
98: -#define lt 15
99: -#define ge 16
100: -#define le 17
101: -#define eq 18
102: -#define ne 19
103: -#define land 20
104: -#define lor 21
105: -#define lnot 22
106: -#define princ 23
107: -#define prdec 24
108: -#define poinc 25
109: -#define podec 26
110: -
111: -#define OP 0
112: -#define NM 1
113: -
114: -#define unary(c) (c == uminus || c == lnot || c >= princ)
115: -#define binary(c) !unary(c)
116: -
117: -struct REVPOL {
118: - char toktyp;
119: - short tokval;
120: -} *parsed;
121: -
122: -int prs = 0;
123: -extern int verbose;
124: -char * Emalloc();
125: -
126: -pushnm(tok)
127: -{ if (prs >= EXPRMAX)
128: - whoops("expression too long");
129: - parsed[prs].toktyp = NM;
130: - parsed[prs++].tokval = tok;
131: -}
132: -
133: -pushop(tok)
134: -{ if (prs >= EXPRMAX)
135: - whoops("expression too long");
136: - parsed[prs].toktyp = OP;
137: - parsed[prs++].tokval = tok;
138: -}
139: -
140: -struct Node *
141: -newnode(ntyp, nval, left, right)
142: - struct Node *left, *right;
143: -{
144: - struct Node *try;
145: -
146: - try = (struct Node *) Emalloc(sizeof(struct Node));
147: - try->ntyp = ntyp;
148: - try->nval = nval;
149: - try->left = left;
150: - try->right = right;
151: - return try;
152: -}
153: -
154: -makeexpr(n)
155: -{ pushexpr(n);
156: - return -(2 + addrevpol());
157: -}
158: -
159: -pushexpr(n)
160: - struct Node *n;
161: -{
162: - if (n == NULL) return;
163: - switch (n->ntyp) {
164: - case NM: pushnm(n->nval); break;
165: - case OP: pushexpr(n->left); pushexpr(n->right); pushop(n->nval); break;
166: - default: whoops("unknown node type");
167: - }
168: -}
169: -
170: -struct {
171: - short n;
172: - struct REVPOL *p;
173: -} revpols[MANY];
174: -
175: -int npols = 0;
176: -
177: -numexps(fd)
178: - FILE *fd;
179: -{ int i, j;
180: - struct REVPOL *p;
181: -
182: - fprintf(fd, "EXPR %d\n", npols);
183: - for (i = 0; i < npols; i++)
184: - { fprintf(fd, "%d: ", revpols[i].n);
185: - p = revpols[i].p;
186: - for (j = (revpols[i].n)-1; j >= 0; j--)
187: - fprintf(fd, "%d/%d ", p[j].toktyp, p[j].tokval);
188: - putc('\n', fd);
189: -} }
190: -
191: -findsame(a)
192: -{ struct REVPOL *p, *q;
193: - int k = revpols[a].n;
194: - int i, j;
195: -
196: - q = revpols[a].p;
197: - for (i = 0; i < npols; i++)
198: - { if (revpols[i].n != revpols[a].n)
199: - continue;
200: - p = revpols[i].p;
201: - for (j = 0; j < k; j++)
202: - if (p[j].toktyp != q[j].toktyp
203: - || p[j].tokval != q[j].tokval)
204: - break;
205: - if (j == k)
206: - break;
207: - }
208: - return i;
209: -}
210: -
211: -addrevpol()
212: -{ int i;
213: - int retval;
214: -
215: - if (npols >= MANY)
216: - whoops("too many expressions");
217: -
218: - revpols[npols].n = prs;
219: - revpols[npols].p = parsed;
220: -
221: - if ((retval = findsame(npols)) == npols)
222: - npols++;
223: -
224: -#if 0
225: - printf("exp(%d): ", prs);
226: - for (i = prs-1; i >= 0; i--)
227: - { if (parsed[i].toktyp == NM)
228: - { printf("%d ", parsed[i].tokval);
229: - continue;
230: - }
231: - switch(parsed[i].tokval) {
232: - case setv: printf("= "); break;
233: - case addeq: printf("+= "); break;
234: - case subeq: printf("-= "); break;
235: - case muleq: printf("*= "); break;
236: - case diveq: printf("/= "); break;
237: - case modeq: printf("%= "); break;
238: - case plus: printf("+ "); break;
239: - case minus: printf("- "); break;
240: - case times: printf("* "); break;
241: - case div: printf("/ "); break;
242: - case mod: printf("% "); break;
243: - case power: printf("^ "); break;
244: - case uminus: printf(".- "); break;
245: - case gt: printf("> "); break;
246: - case lt: printf("< "); break;
247: - case ge: printf(">= "); break;
248: - case le: printf("<= "); break;
249: - case eq: printf("== "); break;
250: - case ne: printf("!= "); break;
251: - case land: printf("&& "); break;
252: - case lor: printf("|| "); break;
253: - case lnot: printf("! "); break;
254: - case princ: printf("++. "); break;
255: - case prdec: printf("--. "); break;
256: - case poinc: printf(".++ "); break;
257: - case podec: printf(".-- "); break;
258: - default: fprintf(stderr, "%d", parsed[i].tokval);
259: - whoops("unknown operator");
260: - }
261: - }
262: - putchar('\n');
263: -#endif
264: - parsed = (struct REVPOL *) Emalloc(EXPRMAX * sizeof(struct REVPOL));
265: - prs = 0;
266: -
267: - return retval;
268: -}
269: //GO.SYSIN DD pret.expr.c
270: echo pret.h 1>&2
271: sed 's/.//' >pret.h <<'//GO.SYSIN DD pret.h'
272: -#define NORM 0 /* normal message */
273: -#define INITM 1 /* initial message */
274: -
275: -#define SND 2
276: -#define RCV 4
277: -#define SAR 6
278: -#define RFR 1
279: -#define DCL 2
280: -#define RAD 3
281: -#define ADR 4
282: -#define DAR 6
283: -
284: -#define MAXNAME 32 /* max available composite namelength */
285: -#define MAXPROC 16 /* max number of processes */
286: -#define MANY 512 /* max nr of distinct rows or names */
287: -#define MAXDEPTH 32 /* max nesting depth of if's and do's */
288: -#define EXPRMAX 64
289: -#define NOSTATE -1 /* default state */
290: -
291: -#define SOME 1 /* not none */
292: -#define NONE -1 /* default signal */
293: -#define NEW -1
294: -#define OLD 0
295: -#define LAB 1
296: -
297: -#define ISM 0 /* message variable */
298: -#define ISQ 1 /* queue-set variable */
299: -#define ISV 2 /* protocol variable */
300: -#define ISQN 3 /* queuename variable */
301: -
302: - /* types of transitions: */
303: -#define INP 10 /* recv specific message */
304: -#define DFL 11 /* default input from q */
305: -#define TMO 12 /* transition on timeout */
306: -#define OUTP 13 /* append message to a q */
307: -#define SPN 14 /* builtin call or transit state */
308: -#define CND 15 /* conditional */
309: -#define FCT 16 /* function call */
310: -
311: - /* `builtins:' */
312: -#define INCR 16 /* increment */
313: -#define DECR 17 /* decrement */
314: -#define SUBT 18 /* subtract */
315: -#define ADDT 19 /* add */
316: -#define SETV 32 /* set: = */
317: -#define ISEQ 256 /* compare: == */
318: -#define NTEQ 257 /* != */
319: -#define GREQ 258 /* >= */
320: -#define SMEQ 259 /* <= */
321: -#define GRNQ 260 /* > */
322: -#define SMNQ 261 /* < */
323: -
324: -#define SPNT(u) (u == TMO || u == OUTP)
325: -
326: -struct QTABLE {
327: - char name[MAXNAME];
328: - short status;
329: - short limit;
330: - short owner;
331: - int multiple;
332: - unsigned char magic;
333: -};
334: -
335: -#define BASEVAL MAXPROC /* base value for coding messages */
336: -#define NQUEUES 2*MAXPROC /* maximum number of queues */
337: -
338: -struct PROCTABLE {
339: - char name[MAXNAME];
340: - int nrstates;
341: - int unreach;
342: - int replic;
343: -};
344: //GO.SYSIN DD pret.h
345: echo pret.y 1>&2
346: sed 's/.//' >pret.y <<'//GO.SYSIN DD pret.y'
347: -%{
348: -#include <stdio.h>
349: -#include "pret.h"
350: -#include "pret.d"
351: -
352: -#define YYDEBUG 1
353: -
354: -struct Node {
355: - int ntyp; /* OP ~ nval&left&right, NM ~ val */
356: - int nval;
357: - struct Node *left, *right;
358: -};
359: -
360: -extern struct Node *newnode();
361: -
362: -struct PARS {
363: - int home;
364: - int dest;
365: - int bpnt;
366: -} ties[MAXDEPTH];
367: -
368: -FILE *tb; /* temp file to store tables */
369: -
370: -char procname[MAXNAME], refname[MAXNAME], qsetname[MAXNAME];
371: -char str[256], filename[256];
372: -char strings[MANY][MAXNAME];
373: -extern char yytext[];
374: -extern struct QTABLE qtable[NQUEUES];
375: -extern int varwidths;
376: -int nnames = 0;
377: -int linenumber = 1;
378: -int linecode = 0; /* include source code references */
379: -int nest = 0; /* nesting level of comments (lex) */
380: -int anyerror = 0;
381: -
382: -int pid = NONE; /* process number */
383: -int qid = NONE; /* queue number */
384: -int rid = NONE; /* template number when defined */
385: -int sid = NONE; /* qset number */
386: -int nid = NONE; /* template number when refered */
387: -int cid = NONE; /* index in call table */
388: -int qind, qisz; /* queue's initial string size */
389: -int parnum; /* counts actual parameters */
390: -int assertion = -1; /* id of assertion table, if any */
391: -int inertion = -1; /* id of error table, if any */
392: -int vartype, inside;
393: -int n, m, from, xx, zz;
394: -int soo = 0; /* start of optionlist */
395: -int curstate = 0;
396: -int curdepth = 0;
397: -int lastloop = -1;
398: -
399: -int verbose = 0;
400: -int nopurge = 0;
401: -
402: -checknames()
403: -{
404: - checkrefs();
405: - checkglobvars();
406: - checkqs();
407: -}
408: -
409: -putglobals(fd)
410: - FILE *fd;
411: -{
412: - numrefs(fd);
413: - numprocs(fd);
414: - numsorts(fd);
415: - numinits(fd);
416: - numglobvars(fd);
417: -}
418: -
419: -puttables(fd1)
420: - FILE *fd1;
421: -{ FILE *fd2;
422: - char buffer[MANY];
423: - int howmuch;
424: -
425: - if ((fd2 = fopen("pret.tmp", "r")) == NULL)
426: - whoops("cannot find pret.tmp");
427: -
428: - while ((howmuch = fread(buffer, sizeof(*buffer), MANY, fd2)) > 0)
429: - fwrite(buffer, sizeof(*buffer), howmuch, fd1);
430: -
431: - fclose(fd2);
432: - unlink("pret.tmp");
433: -}
434: -
435: -makebin()
436: -{ FILE *fd;
437: -
438: - if ((fd = fopen((anyerror)?"pret.err":"pret.out", "w")) == NULL)
439: - whoops("cannot create output file");
440: -
441: - putglobals(fd);
442: - puttables(fd);
443: - numexps(fd);
444: - fclose(fd);
445: - if (anyerror)
446: - fprintf(stderr, "output written to `pret.err'\n");
447: -}
448: -
449: -transfer(cl, tg)
450: -{ int i = curstate;
451: - curstate = enterowname(NEW, "", DAR);
452: - setrans(i, cl, curstate, tg);
453: -}
454: -
455: -#include "pret.expr.c"
456: -
457: -%}
458: -%union{
459: - int resu;
460: - struct Node *node;
461: -}
462: -
463: -%type <resu> PREIO INDEX QINDEX IMPORT ASGN ASGN
464: -%type <node> expr VARNAME
465: -%token <resu> NAME VALUE ARNAME QSNAME
466: -
467: -%start PROT_SPEC
468: -%token ASSERT ERROR
469: -%token PROCESS PBEGIN END IF FI DO OD
470: -%token timeout skip BREAK DEFAULT GOTO
471: -%token FLAG ARROW SEMICOLON COLON
472: -%token QUEUES QSET PVAR MESG
473: -%right '=' ADDEQ SUBEQ MULEQ DIVEQ MODEQ
474: -%left OR
475: -%left AND
476: -%left GT GE LT LE EQ NE
477: -%left '+' '-'
478: -%left '*' '/' '%'
479: -%left UNARYMINUS NOT INC DEC
480: -%right '^'
481: -
482: -%%
483: -
484: -PROT_SPEC : ONEMODULE
485: - | PROT_SPEC ONEMODULE
486: - ;
487: -
488: -ONEMODULE : PROC_SPEC
489: - | TASK_SPEC
490: - | ONEDECL
491: - | REQUIREMENT
492: - ;
493: -
494: -PROC_SPEC : PROCESS NAME QINDEX
495: - { strcpy(procname, strings[$2]);
496: - pid = newprocname(strings[$2], $3);
497: - }
498: - PBEGIN ANYDECLS
499: - { extern int extras;
500: - int ival;
501: - curstate = enterowname(NEW, "", DAR);
502: - newcalltable();
503: - ival = 3*MANY+pid+extras;
504: - addvarname("_PROCID", (DCL|RFR), ival, NONE, 0);
505: - }
506: - SEQUENCE END
507: - { wrapup(NONE, pid, tb, nopurge, verbose);
508: - pid = NONE;
509: - strcpy(procname, "_");
510: - }
511: - ;
512: -
513: -ANYDECLS : /* empty */
514: - | DECLS
515: - ;
516: -DECLS : ONEDECL
517: - | DECLS ONEDECL
518: - ;
519: -
520: -ONEDECL : QDECLS
521: - | VARDECLS
522: - ;
523: -/*
524: - * QUEUES
525: - * ======
526: - */
527: -
528: -QDECLS : QUEUES QDECL SEPARATOR
529: - ;
530: -QDECL : ONEQ
531: - | QNAMELIST
532: - ;
533: -
534: -ONEQ : NAME QINDEX '='
535: - { if ($2 == NONE || (qisz=$2) <= 0)
536: - yyerror("illegal queue size, %s", strings[$1]);
537: - qid = newqname(strings[$1], DCL, qisz, NONE);
538: - }
539: - PBEGIN MNAMELIST END
540: - ;
541: -
542: -/*
543: - * VARIABLES and QUEUESETS
544: - * =======================
545: - */
546: -
547: -VARDECLS : PVAR VNAMELIST SEPARATOR
548: - | QSET QSETDECL SEPARATOR
549: - ;
550: -
551: -QINDEX : /* empty */ { $$ = NONE; }
552: - | '[' VALUE ']' { $$ = $2; }
553: - ;
554: -
555: -QSETDECL : NAME PBEGIN NAME QINDEX COLON
556: - { xx = newqname(strings[$3], RFR, NONE, $4);
557: - sid = newqset(strings[$1], strings[$3], DCL, $4);
558: - }
559: - SNAMELIST END
560: - { closeqset(sid);
561: - }
562: - ;
563: -/*
564: - * PROCEDURES
565: - * ==========
566: - */
567: -
568: -TASK_SPEC : NAME
569: - { rid = newreftask(strings[$1], DCL);
570: - curstate = enterowname(NEW, "", DAR);
571: - strcpy(refname, strings[$1]);
572: - newcalltable();
573: - vartype = ISV;
574: - inside = 1;
575: - }
576: - '(' ANYPARAMS ')'
577: - { inside = 0;
578: - }
579: - ANYPARTYPES
580: - { reorder(); /* renumber formal parameters */
581: - }
582: - PBEGIN
583: - ANYDECLS
584: - SEQUENCE
585: - END
586: - { wrapup(rid, NONE, tb, nopurge, verbose);
587: - strcpy(refname, "_");
588: - rid = NONE;
589: - }
590: - ;
591: -
592: -ANYPARAMS : /* empty */
593: - | PNAMELIST
594: - | error
595: - { yyerror("bad namelist", "");
596: - }
597: -
598: - ;
599: -
600: -ANYPARTYPES : /* empty */
601: - | PARTYPES
602: - | error
603: - { yyerror("bad parameterlist", "");
604: - }
605: - ;
606: -
607: -PARTYPES : ONEPARTYPE SEMICOLON
608: - | PARTYPES ONEPARTYPE SEMICOLON
609: - ;
610: -ONEPARTYPE : PVAR
611: - { vartype = ISV;
612: - }
613: - PNAMELIST
614: - | QSET NAME PBEGIN NAME COLON
615: - { strcpy(qsetname, strings[$2]);
616: - sid = newqset(strings[$2], strings[$4], DCL, NONE);
617: - qid = addFpar(rid, strings[$2], sid, ISQ, inside);
618: - vartype = ISM;
619: - }
620: - PNAMELIST END
621: - { qid = NONE;
622: - closeqset(sid);
623: - }
624: - ;
625: -/*
626: - * REQUIREMENTS
627: - * ============
628: - */
629: -REQUIREMENT : ASSERT
630: - PBEGIN
631: - { rid = newreftask(" assert", DCL);
632: - assertion = rid;
633: - curstate = enterowname(NEW, "", DAR);
634: - strcpy(refname, " assert");
635: - newcalltable();
636: - }
637: - _SEQUENCE
638: - END
639: - { wrapup(rid, NONE, tb, nopurge, verbose);
640: - strcpy(refname, "_");
641: - rid = NONE;
642: - lastloop = -1;
643: - }
644: - | ERROR
645: - PBEGIN
646: - { rid = newreftask(" error", DCL);
647: - inertion = rid;
648: - curstate = enterowname(NEW, "", DAR);
649: - strcpy(refname, " error");
650: - newcalltable();
651: - }
652: - _SEQUENCE
653: - END
654: - { wrapup(rid, NONE, tb, nopurge, verbose);
655: - strcpy(refname, "_");
656: - rid = NONE;
657: - lastloop = -1;
658: - }
659: - ;
660: -_SEQUENCE : _STMNT
661: - | _SEQUENCE SEPARATOR _STMNT
662: - ;
663: -
664: -_STMNT : skip { lastloop = -1; }
665: - | _SELECT { lastloop = -1; }
666: - | _CYCLE
667: - | SEND { lastloop = -1; }
668: - | GUARD { lastloop = -1; }
669: - | STRUCTGOTO { lastloop = -1; }
670: - | error
671: - { yyerror("illegal assertion statement, %s", yytext);
672: - }
673: - ;
674: -_SELECT : IF
675: - { if (++curdepth == MAXDEPTH)
676: - whoops("nesting too deep");
677: -
678: - ties[curdepth].home = curstate;
679: - ties[curdepth].dest = enterowname(NEW, "", DAR);
680: - ties[curdepth].bpnt =
681: - (curdepth > 1) ? ties[curdepth-1].bpnt : -1;
682: - }
683: - _OPTIONLIST FI
684: - { setrowname(ties[curdepth].dest);
685: - curstate = ties[curdepth--].dest;
686: - }
687: - ;
688: -
689: -_CYCLE : DO
690: - { if (curdepth++ == MAXDEPTH)
691: - whoops("nesting too deep");
692: -
693: - labelrow(curstate);
694: - ties[curdepth].home = curstate;
695: - ties[curdepth].dest = curstate;
696: - ties[curdepth].bpnt = enterowname(NEW, "", DAR);
697: - }
698: - _OPTIONLIST OD
699: - { lastloop = ties[curdepth].home;
700: - setrowname(ties[curdepth].bpnt);
701: - curstate = ties[curdepth--].bpnt;
702: - }
703: - ;
704: -_OPTIONLIST : _ONEOPTION
705: - | _ONEOPTION _OPTIONLIST
706: - ;
707: -
708: -_ONEOPTION : FLAG _SEQUENCE
709: - { getrowname(str, ties[curdepth].dest);
710: - from = curstate;
711: - curstate = enterowname(OLD, str, DAR);
712: - setrans(from, 0, curstate, NONE);
713: - curstate = ties[curdepth].home;
714: - }
715: - ;
716: -/*
717: - * NAMELISTS
718: - * =========
719: - */
720: -
721: -ANAMELIST : ANAME
722: - | ANAMELIST ',' ANAME
723: - ;
724: -MNAMELIST : MNAME
725: - | MNAMELIST ',' MNAME
726: - ;
727: -PNAMELIST : PNAME
728: - | PNAMELIST ',' PNAME
729: - ;
730: -QNAMELIST : QNAME
731: - | QNAMELIST ',' QNAME
732: - ;
733: -SNAMELIST : SNAME
734: - | SNAMELIST ',' SNAME
735: - ;
736: -VNAMELIST : VNAME
737: - | VNAMELIST ',' VNAME
738: - ;
739: -/*
740: - * NAMES
741: - * =====
742: - */
743: -
744: -ANAME : QSNAME { addApars(strings[$1], nid, parnum++, NONE); }
745: - | expr { addAspecial(makeexpr($1), nid, parnum++); }
746: - ;
747: -MNAME : NAME
748: - { qtable[qid].status |= ADR;
749: - addmsg(strings[$1], qid, SND, INITM, NONE);
750: - if (--qisz < 0)
751: - yyerror("queue overfilled, %s", strings[$1]);
752: - }
753: - ;
754: -PNAME : NAME
755: - { if (vartype == ISM)
756: - addsetname(strings[$1], sid, 1);
757: - else
758: - addFpar(rid, strings[$1], qid, vartype, inside);
759: - }
760: - ;
761: -QNAME : NAME '[' VALUE ']'
762: - { if ((qisz = $3) <= 0)
763: - yyerror("illegal queue size, %s", strings[$1]);
764: - newqname(strings[$1], DCL, $3, NONE);
765: - }
766: - | NAME '[' VALUE ']' '[' VALUE ']'
767: - { if ((qisz = $6) <= 0)
768: - yyerror("illegal queue size, %s", strings[$1]);
769: - newqname(strings[$1], DCL, qisz, $3);
770: - }
771: - ;
772: -SNAME : NAME { addsetname(strings[$1], sid, 0); }
773: - ;
774: -VNAME : NAME QINDEX
775: - { addvarname(strings[$1], DCL, NONE, $2, 0);
776: - }
777: - | NAME QINDEX '=' expr
778: - { addvarname(strings[$1], DCL, makeexpr($4), $2, 0);
779: - }
780: - | NAME QINDEX COLON VALUE
781: - { addvarname(strings[$1], DCL, NONE, $2, $4);
782: - }
783: - ;
784: -/*
785: - * CODE
786: - * ====
787: - */
788: -
789: -SEQUENCE : STMNT
790: - { soo = 0;
791: - }
792: - | SEQUENCE SEPARATOR STMNT
793: - { soo = 0;
794: - }
795: - ;
796: -
797: -STMNT : skip
798: - { if (soo) /* only if used as a guard */
799: - transfer(0, NONE);
800: - }
801: - | SELECT
802: - | CYCLE
803: - | SEND
804: - | GUARD
805: - | JUMP
806: - | LABEL STMNT
807: - | TEMPLATE
808: - | BUILTIN
809: - | CONDITIONAL
810: - | END
811: - { yyerror("expecting a statement", "");
812: - whoops("exit");
813: - }
814: - ;
815: -
816: -SELECT : IF
817: - { if (++curdepth == MAXDEPTH)
818: - whoops("nesting too deep");
819: -
820: - ties[curdepth].home = curstate;
821: - ties[curdepth].dest = enterowname(NEW, "", DAR);
822: - ties[curdepth].bpnt =
823: - (curdepth>1) ? ties[curdepth-1].bpnt : -1;
824: - }
825: - OPTIONLIST FI
826: - { setrowname(ties[curdepth].dest);
827: - curstate = ties[curdepth--].dest;
828: - }
829: - ;
830: -
831: -CYCLE : DO
832: - { if (curdepth++ == MAXDEPTH)
833: - whoops("nesting too deep");
834: -
835: - labelrow(curstate);
836: - ties[curdepth].home = curstate;
837: - ties[curdepth].dest = curstate;
838: - ties[curdepth].bpnt = enterowname(NEW, "", DAR);
839: - }
840: - OPTIONLIST OD
841: - { setrowname(ties[curdepth].bpnt);
842: - curstate = ties[curdepth--].bpnt;
843: - }
844: - ;
845: -
846: -OPTIONLIST : ONEOPTION
847: - | ONEOPTION OPTIONLIST
848: - ;
849: -
850: -ONEOPTION : FLAG
851: - { soo = 1; /* start of an option string */
852: - }
853: - SEQUENCE
854: - { getrowname(str, ties[curdepth].dest);
855: - from = curstate;
856: - curstate = enterowname(OLD, str, DAR);
857: - setrans(from, 0, curstate, NONE);
858: - curstate = ties[curdepth].home;
859: - }
860: - ;
861: -
862: -INDEX : /* empty */ { $$ = NONE; }
863: - | '[' expr ']' { $$ = makeexpr($2); }
864: - ;
865: -
866: -PREIO : NAME INDEX
867: - { strcpy(str, strings[$1]); /* swivel away name */
868: - $$ = $2;
869: - }
870: - ;
871: -
872: -SEND : PREIO NOT NAME EXPORT
873: - { xx = newqname(str, ADR, NONE, $1);
874: - zz = addmsg(strings[$3], xx, SND, NORM, $1);
875: - n = entercolname(zz, OUTP);
876: - transfer(n, m);
877: - }
878: - ;
879: -
880: -EXPORT : /* empty */ { m = NONE; }
881: - | '(' expr ')' { m = makeexpr($2); }
882: - ;
883: -
884: -GUARD : PREIO '?' timeout
885: - { int x;
886: - xx = newqname(str, RFR, NONE, $1);
887: - x = addmsg(" tau", xx, SAR, NORM, $1);
888: - /*
889: - ** the leading space is to avoid
890: - ** clashes with a user name `tau',
891: - ** e.g. in a formal parameter list
892: - */
893: - n = entercolname(x, TMO);
894: - transfer(n, NONE);
895: - }
896: - | PREIO '?' NAME IMPORT
897: - { xx = newqname(str, RFR, NONE, $1);
898: - zz = addmsg(strings[$3], xx, RCV, NORM, $1);
899: - n = entercolname(zz, INP);
900: - transfer(n, $4);
901: - }
902: - | PREIO '?' DEFAULT IMPORT
903: - { xx = newqname(str, RFR, NONE, $1);
904: - zz = addmsg(" any", xx, SAR, NORM, $1);
905: - n = entercolname(zz, DFL);
906: - transfer(n, $4);
907: - }
908: - ;
909: -
910: -IMPORT : /* empty */
911: - { $$ = NONE;
912: - }
913: - | '(' ARNAME INDEX ')'
914: - { $$ = addvarname(strings[$2], RFR, NONE, $3, 0);
915: - }
916: - | '(' NAME ')'
917: - { $$ = addvarname(strings[$2], RFR, NONE, NONE, 0);
918: - }
919: - | '(' VALUE ')'
920: - { yyerror("importing into constant", "");
921: - }
922: - ;
923: -
924: -SEPARATOR : ARROW
925: - | SEMICOLON
926: - | error
927: - { yyerror("expecting a stmnt separator", "");
928: - }
929: - ;
930: -
931: -JUMP : GOTO NAME
932: - { from = curstate;
933: - curstate = enterowname(LAB, strings[$2], ADR);
934: - setrans(from, 0, curstate, NONE);
935: - curstate = enterowname(NEW, "", DAR);
936: - }
937: - | STRUCTGOTO
938: - ;
939: -
940: -STRUCTGOTO : BREAK
941: - { int i;
942: - from = curstate;
943: - i = ties[curdepth].bpnt;
944: -
945: - if (curdepth == 0 || i == -1)
946: - whoops("illegal break statement");
947: -
948: - getrowname(str, i);
949: - curstate = enterowname(OLD, str, DAR);
950: - setrans(from, 0, curstate, NONE);
951: - curstate = enterowname(NEW, "", DAR);
952: - }
953: - ;
954: -
955: -TEMPLATE : NAME
956: - { nid = newreftask(strings[$1], RFR);
957: - parnum = 0; qid = sid = NONE;
958: - cid = newcall(nid);
959: - }
960: - '(' ANYACTUALS ')'
961: - { int x;
962: - parrefs(parnum, nid);
963: - x = entercolname(cid, FCT);
964: - transfer(x, NONE);
965: - }
966: - ;
967: -
968: -ANYACTUALS : /* empty */
969: - | ANAMELIST
970: - ;
971: -
972: -CONDITIONAL : '(' expr ')'
973: - { transfer(entercolname(makeexpr($2), CND), NONE);
974: - }
975: - ;
976: -
977: -VARNAME : ARNAME INDEX
978: - { m = addvarname(strings[$1], RFR, NONE, $2, 0);
979: - $$ = newnode(NM, m, NULL, NULL);
980: - }
981: - | NAME
982: - { m = addvarname(strings[$1], RFR, NONE, NONE, 0);
983: - $$ = newnode(NM, m, NULL, NULL);
984: - }
985: - ;
986: -
987: -BUILTIN : VARNAME ASGN expr
988: - { m = makeexpr(newnode(OP, $2, $1, $3));
989: - transfer(0, m);
990: - }
991: - | VARNAME INC
992: - { m = makeexpr(newnode(OP, poinc, $1, NULL));
993: - transfer(0, m);
994: - }
995: - | VARNAME DEC
996: - { m = makeexpr(newnode(OP, podec, $1, NULL));
997: - transfer(0, m);
998: - }
999: - ;
1000: -
1001: -ASGN : '=' { $$ = setv; }
1002: - | ADDEQ { $$ = addeq; }
1003: - | SUBEQ { $$ = subeq; }
1004: - | MULEQ { $$ = muleq; }
1005: - | DIVEQ { $$ = diveq; }
1006: - | MODEQ { $$ = modeq; }
1007: - ;
1008: -
1009: -expr : expr '+' expr { $$ = newnode(OP, plus, $1, $3); }
1010: - | expr '-' expr { $$ = newnode(OP, minus, $1, $3); }
1011: - | expr '*' expr { $$ = newnode(OP, times, $1, $3); }
1012: - | expr '/' expr { $$ = newnode(OP, div, $1, $3); }
1013: - | expr '%' expr { $$ = newnode(OP, mod, $1, $3); }
1014: - | expr '^' expr { $$ = newnode(OP, power, $1, $3); }
1015: - | expr GT expr { $$ = newnode(OP, gt, $1, $3); }
1016: - | expr GE expr { $$ = newnode(OP, ge, $1, $3); }
1017: - | expr LT expr { $$ = newnode(OP, lt, $1, $3); }
1018: - | expr LE expr { $$ = newnode(OP, le, $1, $3); }
1019: - | expr EQ expr { $$ = newnode(OP, eq, $1, $3); }
1020: - | expr NE expr { $$ = newnode(OP, ne, $1, $3); }
1021: - | expr AND expr { $$ = newnode(OP, land, $1, $3); }
1022: - | expr OR expr { $$ = newnode(OP, lor, $1, $3); }
1023: - | '-' expr %prec UNARYMINUS
1024: - { $$ = newnode(OP, uminus, $2, NULL); }
1025: - | NOT expr
1026: - { $$ = newnode(OP, lnot, $2, NULL); }
1027: - | VALUE
1028: - { $$ = newnode(NM, $1+3*MANY, NULL, NULL); }
1029: - | ARNAME INDEX
1030: - { m = addvarname(strings[$1], RFR, NONE, $2, 0);
1031: - $$ = newnode(NM, m, NULL, NULL);
1032: - }
1033: - | NAME
1034: - { m = addvarname(strings[$1], RFR, NONE, NONE, 0);
1035: - $$ = newnode(NM, m, NULL, NULL);
1036: - }
1037: - | '(' expr ')' { $$ = $2; }
1038: - ;
1039: -
1040: -LABEL : NAME COLON
1041: - { from = curstate;
1042: - curstate = enterowname(LAB, strings[$1], DCL);
1043: - labelrow(curstate);
1044: - setrans(from, 0, curstate, NONE);
1045: - }
1046: - ;
1047: -%%
1048: -
1049: -extern FILE *yyin;
1050: -
1051: -main(argc, argv)
1052: - char **argv;
1053: -{
1054: - int base = 1, i = 1;
1055: - char c, buff[256];
1056: - char outfile[32];
1057: -
1058: - if (argc > base && argv[1][0] == '-')
1059: - { while ((c = argv[1][i++]) != '\0')
1060: - switch (c) {
1061: - case 's': varwidths = 1; break;
1062: - case 'v': verbose = 1; break;
1063: - case 'n': nopurge = 1; break;
1064: - case 'l': linecode = 1; break;
1065: - default : fprintf(stderr, "usage: pret [-vsnl] file\n");
1066: - fprintf(stderr, "\tv - verbose\n");
1067: - fprintf(stderr, "\ts - supertrace format\n");
1068: - fprintf(stderr, "\tn - no minimization\n");
1069: - fprintf(stderr, "\tl - enables linecode\n");
1070: - exit(1);
1071: - }
1072: - base++;
1073: - }
1074: - if (argc <= base)
1075: - { fprintf(stderr, "usage: pret [-vnl] file\n");
1076: - exit(1);
1077: -
1078: - }
1079: - if ((tb = fopen("pret.tmp", "w")) == NULL)
1080: - whoops("cannot create pret.tmp\n");
1081: -
1082: - strcpy(procname, "_");
1083: - strcpy(refname, "_");
1084: - unlink("pret.out");
1085: - unlink("pret.err");
1086: -
1087: - if (argc > base)
1088: - { strcpy(filename, argv[base]);
1089: -
1090: - mktemp(strcpy(outfile, "/tmp/trans.XXXXXX"));
1091: - sprintf(buff, "/lib/cpp %s > %s", filename, outfile);
1092: -
1093: - if (system(buff))
1094: - { unlink(outfile);
1095: - exit(1);
1096: - } else
1097: - if ((yyin = fopen(outfile, "r")) == NULL)
1098: - { printf("cannot open %s\n", outfile);
1099: - whoops("aborting");
1100: - }
1101: - unlink(outfile);
1102: - }
1103: - parsed = (struct REVPOL *)
1104: - Emalloc(EXPRMAX * sizeof(struct REVPOL));
1105: - prs = 0;
1106: -
1107: - yyparse();
1108: - prepsorts();
1109: - checknames();
1110: - fclose(tb);
1111: - chatter();
1112: - makebin();
1113: - exit(0);
1114: -}
1115: -
1116: -newstring(str)
1117: - char *str;
1118: -{ register int i;
1119: -
1120: - for (i = 0; i < nnames; i++)
1121: - if (strcmp(str, strings[i]) == 0)
1122: - return i;
1123: - if (++nnames >= MANY)
1124: - yyerror("symbol table overflow, %s", str);
1125: - strncpy(strings[i], str, MAXNAME-1);
1126: - return i;
1127: -}
1128: //GO.SYSIN DD pret.y
1129: echo pret0.c 1>&2
1130: sed 's/.//' >pret0.c <<'//GO.SYSIN DD pret0.c'
1131: -#include <stdio.h>
1132: -#include "pret.h"
1133: -#include "pret.d"
1134: -
1135: -#define DEBUG6 0
1136: -#define DEBUG7 0
1137: -
1138: -extern struct COL column[MANY];
1139: -extern struct ROW row[MANY];
1140: -extern int nrrows, nrcols, redrows;
1141: -
1142: -struct ENTRY * find();
1143: -char * Emalloc();
1144: -
1145: -char **triangle;
1146: -short **successor;
1147: -short *tmpsucc;
1148: -int *unmap; /* reverses maptwo values to original row numbers */
1149: -
1150: -MAP(x)
1151: -{ int y = row[x].maptwo; /* gives a value between 0 and redrows */
1152: -
1153: - unmap[y] = x;
1154: - return y;
1155: -}
1156: -
1157: -minimize()
1158: -{ int i, j;
1159: - int n = redrows;
1160: -
1161: - unmap = (int *)
1162: - Emalloc( n * sizeof (int) );
1163: - triangle = (char **)
1164: - Emalloc( n * sizeof (char *) );
1165: - /*
1166: - ** allocate a triangle of states
1167: - ** triangle[i][j] == 1
1168: - ** will indicate that the states i and j are
1169: - ** in the same equivalence class
1170: - ** initially, claim all pairs to be equivalent
1171: - */
1172: -
1173: - for (i = 1; i < n; i++)
1174: - { triangle[i] = (char *)
1175: - Emalloc(i * sizeof (char));
1176: - for (j = 0; j < i; j++)
1177: - triangle[i][j] = 1;
1178: - }
1179: - tmpsucc = (short *)
1180: - Emalloc( n * sizeof (short));
1181: - successor = (short **)
1182: - Emalloc( n * sizeof (short *) );
1183: -
1184: - for (i = 0; i < n; i++)
1185: - { successor[i] = (short *)
1186: - Emalloc(n * sizeof (short));
1187: - for (j = 0; j < n; j++)
1188: - successor[i][j] = 0;
1189: - }
1190: - partition();
1191: -
1192: -#if DEBUG6
1193: - putriangle();
1194: -#endif
1195: - squash();
1196: -
1197: - for (i = 1; i < n; i++)
1198: - free(triangle[i]);
1199: - free(triangle);
1200: - free(unmap);
1201: -}
1202: -
1203: -/*
1204: -newgeneration()
1205: -{ register int i,j;
1206: -
1207: - for (j = 0; j < n; i++)
1208: - tmpsucc[j] = 0;
1209: - for (i = 0; i < n; i++)
1210: - { for (j = 0; j < n; j++)
1211: - addkids(successor[i][j]);
1212: - for (j = 0; j < n; j++)
1213: - { successor[i][j] = tmpsucc[j];
1214: - tmpsucc[i] = 0;
1215: - }
1216: - }
1217: -}
1218: -
1219: -addkids(whosekids)
1220: -{ register int h,k,x,y;
1221: - struct ENTRY *one = find(i, 0);
1222: - struct ENTRY *two = find(j, 0);
1223: - struct PILAR *a;
1224: -
1225: -
1226: - for (k = 0; k < nrcols; k++)
1227: - { for (h = 0; h < one->nrpils; h++)
1228: - { a = one->pilar;
1229: -
1230: - tmpsucc[target(a->transf)] = 1;
1231: -
1232: - a = a->nxtp;
1233: - }
1234: - one = one->nextcol;
1235: - two = two->nextcol;
1236: - }
1237: -}
1238: -*/
1239: -
1240: -partition()
1241: -{ register int i, j, K;
1242: - int anychange = 1;
1243: -
1244: - /*
1245: - ** recursively scan through the
1246: - ** triangle to find non-equivalent pairs
1247: - ** until pi(1) -> pi(k) == pi(k-1)
1248: - */
1249: -
1250: - for (K = 1; anychange == 1; K++)
1251: - { anychange = 0;
1252: -#if DEBUG7
1253: - printf("%d Equivalence:\n", K);
1254: -#endif DEBUG7
1255: - for (i = nrrows-1; i > 0; i--)
1256: - { if (row[i].mapping != NOSTATE)
1257: - continue;
1258: -
1259: - for (j = 0; j < i; j++)
1260: - { if (row[j].mapping != NOSTATE
1261: - || triangle[MAP(i)][MAP(j)] == 0)
1262: - continue;
1263: -
1264: - if ( !equiv(K, i, j) )
1265: - { triangle[MAP(i)][MAP(j)] = 0;
1266: - anychange = 1;
1267: - }
1268: -#if DEBUG7
1269: - else
1270: - { printf("\tstates: %2d,", MAP(i));
1271: - printf("%2d\n", MAP(j));
1272: - }
1273: -#endif DEBUG7
1274: -} } } }
1275: -
1276: -#if DEBUG6
1277: -putriangle()
1278: -{ int i, j;
1279: - int n = redrows;
1280: - int cn = 0;
1281: - char * class = (char *) Emalloc (n * sizeof (char) );
1282: -
1283: - for (i = 0; i < n; i++)
1284: - class[i] = 0;
1285: -
1286: - for (i = 1; i < n; i++)
1287: - for (j = 0; j < i; j++)
1288: - if ( triangle[i][j] )
1289: - { if (class[i] == 0 && class[j] == 0)
1290: - class[i] = class[j] = ++cn;
1291: - else if (class[i] != 0)
1292: - class[j] = class[i];
1293: - else if (class[j] != 0)
1294: - class[i] = class[j];
1295: - else
1296: - whoops("cannot happen, classes");
1297: - }
1298: -
1299: - for (i = 1; i <= cn; i++)
1300: - { printf("class %2d: ", i);
1301: - for (j = 0; j < n; j++)
1302: - if (class[j] == i)
1303: - printf("%d,", j);
1304: - printf("\n\n");
1305: - }
1306: -
1307: - free(class);
1308: -}
1309: -#endif
1310: -
1311: -squash()
1312: -{ int i, j;
1313: - int n = redrows;
1314: - for (i = 1; i < n; i++)
1315: - for (j = 0; j < i; j++)
1316: - if ( triangle[i][j] )
1317: - { row[unmap[i]].mapping = unmap[j];
1318: - row[unmap[j]].labeled |= row[unmap[i]].labeled;
1319: - }
1320: -}
1321: -
1322: -outequiv(A, B)
1323: - struct ENTRY *A, *B;
1324: -{ struct PILAR *at = A->pilar;
1325: - struct PILAR *it = B->pilar;
1326: -
1327: - /*
1328: - ** don't look at the at->transf's,
1329: - ** equal columns implicitly give
1330: - ** equal inputs or outputs, so
1331: - ** just compare the cargo codes
1332: - */
1333: -
1334: - while (it != NULL && at != NULL)
1335: - { if (at->code != it->code)
1336: - break;
1337: -
1338: - at = at->nxtp;
1339: - it = it->nxtp;
1340: - }
1341: -
1342: - return (it == NULL && at == NULL);
1343: -}
1344: -
1345: -equiv(K, i, j)
1346: -{ int h, k, x, y, z;
1347: - struct ENTRY *one = find(i, 0);
1348: - struct ENTRY *two = find(j, 0);
1349: - struct PILAR *a, *b;
1350: -
1351: - if (one->nrpils != two->nrpils)
1352: - return 0;
1353: -
1354: - if (K == 1)
1355: - { for (k = 0; k < nrcols; k++)
1356: - { if ( !outequiv(one, two) )
1357: - return 0;
1358: -
1359: - one = one->nextcol;
1360: - two = two->nextcol;
1361: - }
1362: - } else
1363: - for (k = 0; k < nrcols; k++)
1364: - { a = one->pilar;
1365: - b = two->pilar;
1366: - for (h = 0; h < one->nrpils; h++)
1367: - {
1368: - x = target(a->transf);
1369: - y = target(b->transf);
1370: - x = MAP(x); y = MAP(y);
1371: - if (y > x) { z=x; x=y; y=z; }
1372: - if (x != y && triangle[x][y] == 0)
1373: - return 0;
1374: -
1375: - a = a->nxtp;
1376: - b = b->nxtp;
1377: - }
1378: - one = one->nextcol;
1379: - two = two->nextcol;
1380: - }
1381: -
1382: - return 1;
1383: -}
1384: //GO.SYSIN DD pret0.c
1385: echo pret1.c 1>&2
1386: sed 's/.//' >pret1.c <<'//GO.SYSIN DD pret1.c'
1387: -#include <stdio.h>
1388: -#include "pret.h"
1389: -
1390: -#define LOOK 0
1391: -#define ADD 1
1392: -
1393: -struct QSET_EL {
1394: - char name[MAXNAME]; /* message name */
1395: - char status; /* usage of this message */
1396: - int id; /* number assigned to msg */
1397: - struct QSET_EL *nxtel;
1398: -};
1399: -
1400: -struct QSETS {
1401: - int nrelmnts;
1402: - int status; /* usage of the qset itself */
1403: - int qstatus; /* usage of the setowner (a queue) */
1404: - char setname[MAXNAME]; /* symbolic name */
1405: - char setowner[MAXNAME]; /* queue */
1406: - int qind; /* NONE if simple q, #expr if array */
1407: - struct QSET_EL *elmnts;
1408: - struct QSETS *nxtset;
1409: - int closed;
1410: -};
1411: -
1412: -struct QSETS *frstset;
1413: -int nrsets = 0;
1414: -
1415: -extern struct QTABLE qtable[NQUEUES];
1416: -extern char procname[MAXNAME];
1417: -extern char refname[MAXNAME];
1418: -extern pid, rid;
1419: -char *Emalloc();
1420: -
1421: -isqset(str)
1422: - char *str;
1423: -{ struct QSETS *q = frstset;
1424: - char buf1[MAXNAME], buf2[MAXNAME];
1425: - int i;
1426: -
1427: - buf1[0] = '\0';
1428: - if (pid != NONE)
1429: - strncpy(buf1, procname, 8);
1430: - else if (rid != NONE)
1431: - strncpy(buf1, refname, 8);
1432: - strcat(buf1, ":");
1433: -
1434: - strcpy(buf2, "global:");
1435: - strcat(buf1, str);
1436: - strcat(buf2, str);
1437: -
1438: - for (i = 0; i < nrsets; i++, q = q->nxtset)
1439: - { if (strcmp(buf1, q->setname) == 0
1440: - || strcmp(buf2, q->setname) == 0)
1441: - return 1;
1442: - }
1443: - return 0;
1444: -}
1445: -
1446: -struct QSETS *
1447: -findset(which)
1448: -{ struct QSETS *hook = frstset;
1449: - int i;
1450: -
1451: - if (which >= nrsets || which < 0)
1452: - whoops("cannot happen - findset");
1453: -
1454: - for (i = 0; i < which; i++)
1455: - hook = hook->nxtset;
1456: -
1457: - return hook;
1458: -}
1459: -
1460: -inqset(which, what, usage, qind)
1461: - char *what;
1462: -{
1463: - struct QSETS *hook = findset(which);
1464: - struct QSET_EL *hookl = hook->elmnts;
1465: - int i;
1466: -
1467: - for (i = 0; i < hook->nrelmnts; i++)
1468: - { if (strcmp(what, hookl->name) == 0)
1469: - { hookl->status |= usage;
1470: - if (hookl->id == -1)
1471: - whoops("unnumbered parameter");
1472: - if (qind != hook->qind)
1473: - yyerror("queue indexing error, qset, %s", what);
1474: - return hookl->id;
1475: - }
1476: - hookl = hookl->nxtel;
1477: - }
1478: -
1479: - return -1;
1480: -}
1481: -
1482: -renumqset(which, N)
1483: -{ struct QSETS * hook = findset(which);
1484: - struct QSET_EL * hookl = hook->elmnts;
1485: - int i, j;
1486: -
1487: - qsetowner(which, 0);
1488: - for (i = 0, j = N; i < hook->nrelmnts; i++)
1489: - { hookl->id = j++;
1490: - hookl = hookl->nxtel;
1491: - }
1492: - return j;
1493: -}
1494: -
1495: -matchset(a, b)
1496: -{ struct QSETS * one = findset(a);
1497: - struct QSETS * two = findset(b);
1498: - struct QSET_EL * onel;
1499: - struct QSET_EL * twol;
1500: - int i;
1501: -
1502: - if (one->nrelmnts != two->nrelmnts)
1503: - { yyerror("qset does not match formal parameter, %s", one->setname);
1504: - return;
1505: - }
1506: - onel = one->elmnts;
1507: - twol = two->elmnts;
1508: -
1509: - for (i = 0; i < one->nrelmnts; i++)
1510: - { onel->status |= twol->status;
1511: - onel = onel->nxtel;
1512: - twol = twol->nxtel;
1513: - }
1514: - return two->qstatus;
1515: -}
1516: -
1517: -matchowner(a, str, how, qind)
1518: - char *str;
1519: -{ struct QSETS * hook = findset(a);
1520: -
1521: - if (strcmp(hook->setowner, str) == 0)
1522: - { hook->qstatus |= how;
1523: - if (qind != hook->qind)
1524: - yyerror("queue indexing error (qset ref), %s", str);
1525: - return 1;
1526: - }
1527: - return 0;
1528: -}
1529: -
1530: -struct QSET_EL *
1531: -mkelmnt(str, how)
1532: - char *str;
1533: -{ struct QSET_EL *try = (struct QSET_EL *)
1534: - Emalloc( sizeof( struct QSET_EL ) );
1535: -
1536: - strcpy(try->name, str);
1537: - try->nxtel = NULL;
1538: - try->status = how;
1539: - try->id = -1;
1540: -
1541: - return try;
1542: -}
1543: -
1544: -struct QSETS *
1545: -mkset(str1, str2, how, qind)
1546: - char *str1, *str2;
1547: -{ struct QSET_EL *hook;
1548: - struct QSETS *try = (struct QSETS *)
1549: - Emalloc( sizeof( struct QSETS ) );
1550: -
1551: - if (how == RFR)
1552: - yyerror("undeclared qset, %s", str1);
1553: -
1554: - try->status = how;
1555: - try->qstatus = 0;
1556: - try->nxtset = NULL;
1557: - strcpy(try->setname, str1);
1558: - strcpy(try->setowner, str2);
1559: - try->closed = 0;
1560: - try->qind = qind;
1561: -
1562: - try->nrelmnts = 0;
1563: - try->elmnts = mkelmnt(" tau", SAR);
1564: - try->nrelmnts++;
1565: -
1566: - hook = try->elmnts;
1567: - hook->nxtel = mkelmnt(" any", SND);
1568: - try->nrelmnts++;
1569: -
1570: - nrsets++;
1571: - return try;
1572: -}
1573: -
1574: -qsetowner(which, how)
1575: -{ struct QSETS *hook = findset(which);
1576: - return newqname(hook->setowner, how, NONE, hook->qind);
1577: -}
1578: -
1579: -inset(str, str2, mask, how, qind)
1580: - char *str, *str2;
1581: -{ struct QSETS *hook = frstset;
1582: - struct QSETS *last = frstset;
1583: - int i;
1584: - for (i = 0; i < nrsets && hook != NULL; i++)
1585: - { if (strcmp(hook->setname, str) == 0)
1586: - { if (mask == DCL)
1587: - yyerror("qset redeclared, %s", str);
1588: - hook->status |= mask;
1589: - break;
1590: - }
1591: - last = hook;
1592: - hook = hook->nxtset;
1593: - }
1594: - if (how == ADD && i == nrsets)
1595: - last->nxtset = mkset(str, str2, mask, qind);
1596: -
1597: - return i;
1598: -}
1599: -
1600: -newqset(str1, str2, mask, qind)
1601: - char *str1, *str2;
1602: -{
1603: - int i = nrsets;
1604: - char str[MAXNAME];
1605: -
1606: - if (pid != NONE)
1607: - strncpy(str, procname, 8);
1608: - else if (rid != NONE)
1609: - strncpy(str, refname, 8);
1610: - else
1611: - strcpy(str, "global");
1612: - strcat(str, ":");
1613: - strcat(str, str1);
1614: -
1615: - if (mask == RFR && (pid != NONE || rid != NONE))
1616: - { if (inset(str, str2, mask, LOOK, qind) == nrsets)
1617: - { strcpy(str, "global");
1618: - strcat(str, ":");
1619: - strcat(str, str1);
1620: - } }
1621: -
1622: - if (nrsets == 0)
1623: - frstset = mkset(str, str2, mask, qind);
1624: - else
1625: - i = inset(str, str2, mask, ADD, qind);
1626: -
1627: - return i;
1628: -}
1629: -
1630: -closeqset(which)
1631: -{ struct QSETS *where = findset(which);
1632: - where->closed = 1;
1633: -}
1634: -
1635: -isclosed(which)
1636: -{ struct QSETS *where = findset(which);
1637: - return where->closed;
1638: -}
1639: -
1640: -addsetname(str, which, susp)
1641: - char *str;
1642: -{ struct QSETS *where = findset(which);
1643: - struct QSET_EL *hook = where->elmnts;
1644: - int i, j;
1645: -
1646: - j = newqname(where->setowner, 0, NONE, where->qind);
1647: - i = where->nrelmnts;
1648: -
1649: - if (i == 0)
1650: - where->elmnts = mkelmnt(str, 0);
1651: - else
1652: - { for (i = 1; i < where->nrelmnts; i++)
1653: - hook = hook->nxtel;
1654: -
1655: - hook->nxtel = mkelmnt(str, 0);
1656: - }
1657: -
1658: - /* if setowner is a formal parameter name
1659: - * the returned value `j' refers to the qset
1660: - * in which it was defined + an offset `MANY'
1661: - * if so, we must check that the message added
1662: - * here was also defined in the original set
1663: - */
1664: -
1665: - if (susp && j >= MANY && isclosed(j - MANY)) /* current set is open */
1666: - addmsg(str, j, 0, NORM, where->qind); /* check validity msg */
1667: -
1668: - where->nrelmnts++;
1669: -
1670: - return i;
1671: -}
1672: -
1673: -callist(which, hit)
1674: -{ int i, j;
1675: - struct QSETS * hook = findset(which);
1676: - struct QSET_EL * kooh = hook->elmnts;
1677: -
1678: - for (i = 0; i < hook->nrelmnts; i++)
1679: - { j = addmsg(kooh->name, hit, kooh->status, NORM, hook->qind);
1680: - callentry(ISM, j);
1681: - kooh = kooh->nxtel;
1682: - }
1683: -}
1684: //GO.SYSIN DD pret1.c
1685: echo pret2.c 1>&2
1686: sed 's/.//' >pret2.c <<'//GO.SYSIN DD pret2.c'
1687: -#include <stdio.h>
1688: -#include "pret.h"
1689: -#include "pret.d"
1690: -
1691: - struct COL column[MANY];
1692: - struct ROW row[MANY];
1693: -
1694: - struct ENTRY *rowtail;
1695: - struct ENTRY *coltail;
1696: - struct ENTRY *base; /* base of transition table */
1697: -
1698: - struct ENTRY *newentry();
1699: - struct PILAR *newunit();
1700: -
1701: - int nrrows = 0; /* raw nr of rows (incremented by addrow() */
1702: - int nrcols = 0; /* number of columns per table */
1703: - int redrows = 0; /* reduced nr of rows (set by remap() */
1704: - int extras = 0; /* counts replicated processes */
1705: -
1706: -extern char procname[MAXNAME], refname[MAXNAME];
1707: -extern int anyerror, pid, rid, curstate, lastloop;
1708: -
1709: -struct ENTRY *
1710: -find(R, C)
1711: -{ register int i;
1712: - register int r = R;
1713: - register int c = C;
1714: - register struct ENTRY *here = base;
1715: -
1716: - if (r >= nrrows || c >= nrcols || r < 0 || c < 0)
1717: - whoops ("bad table index");
1718: - for (i = 0; i < r; i++)
1719: - here = here->nextrow;
1720: - for (i = 0; i < c; i++)
1721: - here = here->nextcol;
1722: - return here;
1723: -}
1724: -
1725: -getrowname(where, which)
1726: - char *where;
1727: -{ strcpy(where, row[which].name);
1728: -}
1729: -
1730: -setrowname(which)
1731: -{ char stro[256];
1732: - extern linenumber;
1733: - extern char filename[];
1734: -
1735: - sprintf(stro, "%d/%d:%s", linenumber, nrrows, filename);
1736: - strcpy(row[which].name, stro);
1737: -}
1738: -
1739: -deadlabels()
1740: -{ register int i;
1741: - for (i = 0; i < nrrows; i++)
1742: - switch(row[i].refcount)
1743: - { case ADR: printf("%s: undeclared label\n", row[i].name);
1744: - anyerror++;
1745: - break;
1746: - case DCL: printf("%s: unused label\n", row[i].name);
1747: - break;
1748: - case ADR+DCL:
1749: - break;
1750: - default: whoops("cannot happen - label");
1751: - }
1752: -}
1753: -
1754: -remap()
1755: -{ register int i, j;
1756: -
1757: - for (i = j = 0; i < nrrows; i++)
1758: - if (row[i].mapping == NOSTATE)
1759: - row[i].maptwo = j++;
1760: - redrows = j;
1761: -}
1762: -
1763: -purgerows(how)
1764: -{ int i; extern int linecode, assertion, inertion;
1765: -
1766: - for (i = 0; i < nrrows; i++)
1767: - { row[i].mapping = NOSTATE;
1768: - row[i].maptwo = i;
1769: - }
1770: - redrows = nrrows;
1771: -/* -> bug if (!linecode) */
1772: - if (!linecode || rid==assertion || rid==inertion)
1773: - transitrows(); /* remove dummy transitions */
1774: - remap();
1775: -
1776: - if (!linecode && !how)
1777: - { minimize();
1778: - remap();
1779: - }
1780: -}
1781: -
1782: -target(y)
1783: -{ int i = 0;
1784: - int x = y;
1785: - while (row[x].mapping != NOSTATE)
1786: - { x = row[x].mapping;
1787: - if (i++ > nrrows)
1788: - { printf("%s: ", (pid == NONE) ? procname : refname);
1789: - whoops("contains unconditional, infinite loop");
1790: - }
1791: - }
1792: - return x;
1793: -}
1794: -
1795: -enterowname(how, stri, bang)
1796: - char *stri, bang;
1797: -{ register int i;
1798: - char stro[256];
1799: - extern int linenumber;
1800: - extern char filename[];
1801: -
1802: - switch(how) {
1803: - case LAB: sprintf(stro, "%s: %s", stri, filename);
1804: - for (i = 0; i < nrrows; i++)
1805: - if (strcmp(stro, row[i].name) == 0)
1806: - break;
1807: -
1808: - if (i < nrrows)
1809: - { if (bang == DCL && (row[i].refcount & DCL))
1810: - { fprintf(stderr, "%d/%d %s %s\n",
1811: - i, nrrows, stro, row[i].name);
1812: - yyerror("label redeclared, %s", stro);
1813: - }else
1814: - row[i].refcount |= bang;
1815: - break;
1816: - } else
1817: - { addrow();
1818: - row[i].refcount = bang;
1819: - row[i].labeled = 0;
1820: - strcpy(row[i].name, stro);
1821: - }
1822: - break;
1823: - case NEW: i = nrrows;
1824: - sprintf(stro, "%d/%d:%s", linenumber, i, filename);
1825: - addrow();
1826: - row[i].refcount = bang;
1827: - row[i].labeled = 0;
1828: - strcpy(row[i].name, stro);
1829: - break;
1830: - case OLD: for (i = 0; i < nrrows; i++)
1831: - if (strcmp(stri, row[i].name) == 0)
1832: - break;
1833: - if (i == nrrows)
1834: - whoops("cannot happen - rows");
1835: - break;
1836: - }
1837: - return i;
1838: -}
1839: -
1840: -labelrow(n)
1841: -{
1842: - if (n < 0 || n >= nrrows)
1843: - whoops("cannot happen - labelrow");
1844: - row[n].labeled = 1;
1845: -
1846: -}
1847: -
1848: -deadrows(p, r)
1849: -{ register int i, j, k;
1850: - struct ENTRY *it;
1851: - struct PILAR *at;
1852: - char fld[128];
1853: - extern int nrprocs;
1854: -
1855: - for (i = 0; i < nrrows; i++)
1856: - row[i].reached = 0;
1857: -
1858: - for (i = 0; i < nrrows; i++)
1859: - { if (row[i].mapping != NOSTATE)
1860: - continue;
1861: - it = find(i, 0);
1862: - for (j = 0; j < nrcols; j++, it = it->nextcol)
1863: - { at = it->pilar;
1864: - do
1865: - { if (at->transf != NOSTATE)
1866: - { k = target(at->transf);
1867: - if (k != i)
1868: - row[k].reached = 1;
1869: - }
1870: - at = at->nxtp;
1871: - } while (at != NULL);
1872: - } }
1873: -
1874: - fld[0] = '\0';
1875: - for (i = k = 0; i < nrrows; i++)
1876: - { if (row[i].mapping != NOSTATE)
1877: - continue;
1878: - if (row[i].reached == 0 && row[i].maptwo != 0)
1879: - { j = strlen(fld); k++;
1880: - sprintf(&fld[j], "%d, ", row[i].maptwo);
1881: - } }
1882: -
1883: - if (p == NONE)
1884: - refsize(r, redrows, k);
1885: - else
1886: - procsize(p, redrows, k);
1887: -}
1888: -
1889: -deadends(tb)
1890: - FILE *tb;
1891: -{ register int i, j, x;
1892: - struct ENTRY *it;
1893: - struct PILAR *at;
1894: - char field[256];
1895: - int nrdeads = 0;
1896: -
1897: - if (nrrows == 0)
1898: - return;
1899: -
1900: - field[0] = '\0';
1901: - for (i = 0; i < nrrows; i++)
1902: - { if (row[i].mapping != NOSTATE)
1903: - continue;
1904: - it = find(i, 0);
1905: - for (j = 0; j < nrcols; j++, it = it->nextcol)
1906: - { for (at = it->pilar; at != NULL; at = at->nxtp)
1907: - if (at->transf != NOSTATE)
1908: - break;
1909: - if (at != NULL)
1910: - break;
1911: - }
1912: - if (j == nrcols)
1913: - { x = strlen(field);
1914: - sprintf(&field[x], "%d,", row[i].maptwo);
1915: - nrdeads++;
1916: - } }
1917: - if ((i = lastloop) >= 0)
1918: - { if (i >= nrrows || row[i].mapping != NOSTATE)
1919: - whoops("cannot happen - deadends");
1920: - x = strlen(field);
1921: - sprintf(&field[x], "%d,", row[i].maptwo);
1922: - nrdeads++;
1923: - }
1924: - fprintf(tb, "ENDSTATES %d: %s\n", nrdeads, field);
1925: -}
1926: -
1927: -transitrows()
1928: -{ register int i, j;
1929: - struct ENTRY *here, *there;
1930: - /* maintain row 0 as initial state */
1931: - here = base->nextrow;
1932: - for (i = 1; i < nrrows; i++, here = here->nextrow)
1933: - { if (here->nrpils != 1 || here->pilar->code != NONE)
1934: - continue;
1935: -
1936: - there = here->nextcol;
1937: - for (j = 1; j < nrcols; j++, there = there->nextcol)
1938: - if (there->nrpils != 0)
1939: - break;
1940: - if (j == nrcols)
1941: - { row[i].mapping = here->pilar->transf;
1942: - row[here->pilar->transf].labeled |= row[i].labeled;
1943: - } }
1944: -}
1945: -
1946: -entercolname(val, what)
1947: -{ register int i;
1948: -
1949: - for (i = 0; i < nrcols; i++)
1950: - if (column[i].ccode == val && column[i].coltype == what)
1951: - break;
1952: - if (i == nrcols)
1953: - { addcol();
1954: - column[i].ccode = val;
1955: - column[i].coltype = what;
1956: - }
1957: - return i;
1958: -}
1959: -
1960: -addrow()
1961: -{ register i = nrcols;
1962: - struct ENTRY *lastcol, *thiscol;
1963: - char uni[32];
1964: -
1965: - if (nrcols == 0)
1966: - { rowtail = coltail = base = newentry();
1967: - sprintf(uni, "%4d", curstate);
1968: - column[0].ccode = -1;
1969: - column[0].coltype = SPN;
1970: - strcpy(row[0].name, uni);
1971: - nrrows = nrcols = 1;
1972: - } else
1973: - { if (nrrows == MANY)
1974: - whoops("too many rows");
1975: - lastcol = rowtail;
1976: - rowtail = thiscol = lastcol->nextrow = newentry();
1977: - for (--i; i > 0; i--)
1978: - { thiscol = thiscol->nextcol = newentry();
1979: - lastcol = lastcol->nextcol;
1980: - lastcol->nextrow = thiscol;
1981: - }
1982: - nrrows++;
1983: - }
1984: -}
1985: -
1986: -addcol()
1987: -{ register int i = nrrows;
1988: - struct ENTRY *lstrow, *thisrow;
1989: -
1990: - if (nrcols == 0)
1991: - whoops("cannot happen - columns");
1992: - else
1993: - { lstrow = coltail;
1994: - coltail = thisrow = lstrow->nextcol = newentry();
1995: - if (nrcols++ == MANY)
1996: - whoops("too many columns");
1997: - for (--i; i > 0; i--)
1998: - { thisrow = thisrow->nextrow = newentry();
1999: - lstrow = lstrow->nextrow;
2000: - lstrow->nextcol = thisrow;
2001: - } }
2002: -}
2003: -
2004: -setrans(r, c, tr, to)
2005: -{ struct ENTRY *ft;
2006: - struct PILAR *pt;
2007: - int i;
2008: - ft = find(r, c);
2009: - pt = ft->pilar;
2010: - for (i = ft->nrpils++; i > 0; i--)
2011: - pt = pt->nxtp;
2012: -
2013: - pt->code = to;
2014: - pt->transf = tr;
2015: -
2016: - pt->nxtp = newunit();
2017: -}
2018: -
2019: -badstates(tb)
2020: - FILE *tb;
2021: -{ struct ENTRY *this, *that;
2022: - struct PILAR *at;
2023: - int i, k, x, nrbads = 0, nrlabs = 0;
2024: - char field[512], labfield[512];
2025: -
2026: - if (nrrows == 0)
2027: - return;
2028: -
2029: - labfield[0] = field[0] = '\0';
2030: - for (i = 0, this = base; this != NULL; this = this->nextrow, i++)
2031: - { if (row[i].mapping != NOSTATE)
2032: - continue;
2033: -
2034: - if (row[i].labeled)
2035: - { sprintf(&labfield[strlen(labfield)], "%d,", row[i].maptwo);
2036: - nrlabs++;
2037: - }
2038: - that = find(i, 0);
2039: - for (k = 0; k < nrcols; k++, that = that->nextcol)
2040: - { if (!SPNT(column[k].coltype))
2041: - continue;
2042: -
2043: - for (at = that->pilar, x = 0; at != NULL; at = at->nxtp)
2044: - { if (at->transf == NOSTATE)
2045: - continue;
2046: - x++; break;
2047: - }
2048: - if (x > 0)
2049: - { sprintf(&field[strlen(field)],"%d,",row[i].maptwo);
2050: - nrbads++;
2051: - break;
2052: - } }
2053: - }
2054: - fprintf(tb, "BADSTATES %d: %s\n", nrbads, field);
2055: - fprintf(tb, "LABSTATES %d: %s\n", nrlabs, labfield);
2056: -}
2057: -
2058: -dumpforw(tb)
2059: - FILE *tb;
2060: -{ struct ENTRY *this, *that;
2061: - struct PILAR *at;
2062: - char field[256];
2063: - int i, j, k, x, y; extern int linecode;
2064: -
2065: - if (pid == NONE)
2066: - fprintf(tb, "%s %d:", "REF", rid);
2067: - else
2068: - fprintf(tb, "%s %d:", "PROC", pid+extras);
2069: -
2070: - fprintf(tb, "%d/%d:", redrows, nrcols);
2071: - for (i = 0; i < nrcols; i++)
2072: - fprintf(tb, "%d(%d),", column[i].ccode, column[i].coltype);
2073: - putc('\n', tb);
2074: -
2075: - for (i = 0, this = base; this != NULL; this = this->nextrow, i++)
2076: - { if (row[i].mapping != NOSTATE)
2077: - continue;
2078: -
2079: - that = find(i, 0);
2080: - for (k = 0; k < nrcols; k++, that = that->nextcol)
2081: - { y = 0; field[0] = '\0';
2082: - for (at = that->pilar; at != NULL; at = at->nxtp)
2083: - { if (at->transf == NOSTATE)
2084: - continue;
2085: -
2086: - j = row[ target(at->transf) ].maptwo;
2087: -
2088: - if ((x = strlen(field)) > 200)
2089: - whoops("string overflow");
2090: -
2091: - sprintf(&field[x], "[%d,%d]", j, at->code);
2092: - y++;
2093: - }
2094: -
2095: - if (y > 0)
2096: - { fprintf(tb, "%d/%d ", row[i].maptwo, k);
2097: - fprintf(tb, "(%d) %s\n", y, field);
2098: - } } }
2099: - fprintf(tb, "0/0 (0)\n");
2100: -
2101: - if (linecode)
2102: - { fprintf(tb, "rownames:\n");
2103: - for (i = 0; i < redrows; i++)
2104: - fprintf(tb, "%s\n", row[i].name);
2105: - }
2106: -}
2107: -
2108: -wrapup(r, p, tb, np, vb)
2109: - FILE *tb;
2110: -{
2111: - int i;
2112: - extern struct PROCTABLE proctable[MAXPROC];
2113: -
2114: - purgerows(np);
2115: - dumpforw(tb);
2116: - deadends(tb);
2117: - badstates(tb);
2118: - putcalls(tb);
2119: - numlocvars(tb);
2120: -
2121: - if (r == NONE)
2122: - for (i = 1; i < proctable[p].replic; i++)
2123: - { extras++;
2124: - twiddle("_PROCID");
2125: - dumpforw(tb);
2126: - deadends(tb);
2127: - badstates(tb);
2128: - putcalls(tb);
2129: - numlocvars(tb);
2130: - }
2131: -
2132: - if (vb)
2133: - { deadrows(p, r);
2134: - deadlabels();
2135: - }
2136: -
2137: - release();
2138: - scrapcalltable();
2139: -}
2140: //GO.SYSIN DD pret2.c
2141: echo pret3.c 1>&2
2142: sed 's/.//' >pret3.c <<'//GO.SYSIN DD pret3.c'
2143: -#include <stdio.h>
2144: -#include "pret.h"
2145: -
2146: - struct FORMALS {
2147: - char name[MAXNAME];
2148: - int typefs; /* qset or pvar (default) */
2149: - int tag; /* id */
2150: - char used; /* reference count */
2151: - char reset; /* default type overwritten */
2152: - struct FORMALS *nxtpar;
2153: - };
2154: -
2155: - struct {
2156: - char name[MAXNAME];
2157: - int status;
2158: - int nrparams;
2159: - int nrstates;
2160: - int unreach;
2161: - struct FORMALS *params; /* formal parameters */
2162: - } reftable[MAXPROC];
2163: -
2164: - int nrrefs = 0;
2165: -
2166: - extern int anyerror, pid, rid, assertion, inertion;
2167: - extern char qsetname[MAXNAME];
2168: -
2169: -refsize(n, m, k)
2170: -{ reftable[n].nrstates = m;
2171: - reftable[n].unreach = k;
2172: -}
2173: -
2174: -reorder()
2175: -{ int i, j, N, M;
2176: - struct FORMALS * hook;
2177: -
2178: - if (rid == NONE)
2179: - return;
2180: - /*
2181: - * make sure that formal msg parameters
2182: - * are numbered in the order in which they
2183: - * will be pushed onto the call stack in trace.c
2184: - */
2185: -
2186: - j = reftable[rid].nrparams;
2187: - hook = reftable[rid].params;
2188: -
2189: - for (i = N = M = 0; i < j; i++)
2190: - { if (hook->typefs == ISQ || hook->typefs == ISQN)
2191: - N = renumqset(hook->tag, N);
2192: - else
2193: - hook->tag = M++;
2194: -
2195: - hook = hook->nxtpar;
2196: - }
2197: -}
2198: -
2199: -newreftask(str, mask)
2200: - char *str;
2201: -{ register int i;
2202: -
2203: - for (i = 0; i < nrrefs; i++)
2204: - if (strcmp(str, reftable[i].name) == 0)
2205: - break;
2206: - if (i == nrrefs)
2207: - { if (nrrefs >= MAXPROC)
2208: - whoops("too many procedures");
2209: - if (mask == RFR)
2210: - yyerror("undeclared procedure, %s", str);
2211: -
2212: - reftable[i].status = 0;
2213: - reftable[i].nrparams = 0;
2214: - reftable[i].nrstates = 0;
2215: - reftable[i].unreach = 0;
2216: - strcpy(reftable[nrrefs++].name, str);
2217: - } else
2218: - { if (mask == DCL && (reftable[i].status & DCL))
2219: - yyerror("procedure redeclared, %s", str);
2220: - if (mask == RFR && rid == i)
2221: - yyerror("recursive procedure, %s", str);
2222: - }
2223: - reftable[i].status |= mask;
2224: -
2225: - return i;
2226: -}
2227: -
2228: -struct FORMALS *
2229: -newparunit(str, nn, tp, ins)
2230: - char *str;
2231: -{ struct FORMALS * try = (struct FORMALS *)
2232: - Emalloc ( sizeof(struct FORMALS) );
2233: -
2234: - try->used = 0;
2235: - try->reset = 0;
2236: -
2237: - strcpy(try->name, str);
2238: -
2239: - try->typefs = tp;
2240: - try->nxtpar = NULL;
2241: -
2242: - try->tag = nn;
2243: - if (!ins)
2244: - yyerror("unspecified parameter, %s", str);
2245: -
2246: - return try;
2247: -}
2248: -
2249: -addFpar(to, stri, n, vt, ins)
2250: - char *stri;
2251: -{ struct FORMALS *hook;
2252: - int N = reftable[to].nrparams;
2253: - int i = N;
2254: -
2255: - if (N == 0)
2256: - { reftable[to].params = newparunit(stri, n, vt, ins);
2257: - reftable[to].nrparams++;
2258: - } else
2259: - { hook = reftable[to].params;
2260: - for (i = 0; i < N; i++, hook = hook->nxtpar)
2261: - { if (strcmp(hook->name, stri) == 0)
2262: - { if (ins || hook->reset == 1)
2263: - yyerror("name clash, %s", stri);
2264: -
2265: - hook->tag = n;
2266: - hook->typefs = vt;
2267: - hook->reset = 1;
2268: - break;
2269: - }
2270: - if (hook->nxtpar == NULL)
2271: - { hook->nxtpar = newparunit(stri, n, vt, ins);
2272: - reftable[to].nrparams++;
2273: - i++;
2274: - break;
2275: - } } }
2276: -
2277: - return i;
2278: -}
2279: -
2280: -Fparname(str, which, vt, hit, how, qind)
2281: - char *str;
2282: -{ int i, j, k;
2283: - struct FORMALS * hook = reftable[which].params;
2284: -
2285: - for (i = 0, j = reftable[which].nrparams; i < j; i++)
2286: - { if (strcmp(str, hook->name) == 0 && hook->typefs == vt)
2287: - break;
2288: - if (hook->typefs == ISQ || hook->typefs == ISQN)
2289: - { switch (vt) {
2290: - case ISM:
2291: - if (hook->tag == hit
2292: - && (k = inqset(hook->tag, str, how, qind)) != -1)
2293: - return k;
2294: - break;
2295: - case ISQ:
2296: - if (matchowner(hook->tag, str, how, qind))
2297: - return hook->tag; /* id of qset */
2298: - break;
2299: - } }
2300: - hook = hook->nxtpar;
2301: - }
2302: - if (i == j || (vt == ISM && hook->tag != hit))
2303: - return -1;
2304: -
2305: - hook->used |= how;
2306: -
2307: - if (vt == ISV)
2308: - return hook->tag;
2309: -
2310: - return i;
2311: -}
2312: -
2313: -checkrefs()
2314: -{ int i;
2315: - if (nrrefs == 0)
2316: - return;
2317: - for (i = 0; i < nrrefs; i++)
2318: - if (reftable[i].status == DCL)
2319: - { if (strcmp(reftable[i].name, " assert") != 0
2320: - && strcmp(reftable[i].name, " error") != 0)
2321: - printf("%s: unused procedure\n", reftable[i].name);
2322: - } else if (reftable[i].status == RFR)
2323: - printf("%s: undeclared procedure\n", reftable[i].name);
2324: -}
2325: -
2326: -numrefs(fd)
2327: - FILE *fd;
2328: -{ extern int linecode;
2329: - fprintf(fd, "%d linecode\n", linecode);
2330: - fprintf(fd, "%d procedures ", nrrefs);
2331: - fprintf(fd, "(assert %d/%d)\n", assertion, inertion);
2332: -}
2333: -
2334: -parrefs(n, m)
2335: -{ int i;
2336: - if ((i = reftable[m].nrparams - n) == 0)
2337: - return;
2338: - if (i > 0)
2339: - yyerror("missing parameters, %s", reftable[m].name);
2340: - else
2341: - yyerror("too many parameters, %s", reftable[m].name);
2342: -}
2343: -
2344: -isdigit(c) { return (c >= '0' && c <= '9'); }
2345: -
2346: -addAspecial(val, which, pn)
2347: -{ struct FORMALS * hook = reftable[which].params;
2348: - int i;
2349: -
2350: - if (pn >= reftable[which].nrparams || pn < 0)
2351: - return;
2352: -
2353: - for (i = 0; i < pn; i++)
2354: - if ((hook = hook->nxtpar) == NULL)
2355: - whoops("cannot happen - addAspecial");
2356: -
2357: - switch (hook->typefs)
2358: - { case ISQN:
2359: - case ISQ: yyerror("mismatched parameter, %s", "queue or qset");
2360: - break;
2361: - case ISV: callentry(ISV, val);
2362: - break;
2363: - default : whoops("cannot happen - addAspecial");
2364: - }
2365: -}
2366: -
2367: -addApars(what, which, pn, index)
2368: - char *what;
2369: -{ struct FORMALS * hook = reftable[which].params;
2370: - int val, hit, x;
2371: -
2372: - if (pn >= reftable[which].nrparams || pn < 0)
2373: - return;
2374: -
2375: - for (x = 0; x < pn; x++)
2376: - if ((hook = hook->nxtpar) == NULL)
2377: - whoops("cannot happen - formals");
2378: -
2379: - switch (hook->typefs)
2380: - { case ISQN:
2381: - val = newqset(what, what, 0, index);
2382: - x = matchset(val, hook->tag);
2383: - hit = qsetowner(val, x); /* find queue-id */
2384: - callentry(ISQ, hit); /* enter queue-id */
2385: - callist(val, hit); /* enter messages */
2386: - break;
2387: - case ISQ: val = newqset(what, "", RFR, index);
2388: - x = matchset(val, hook->tag);
2389: - hit = qsetowner(val, x); /* find queue-id */
2390: - callentry(ISQ, hit); /* enter queue-id */
2391: - callist(val, hit); /* enter messages */
2392: - break;
2393: - case ISV: val = addvarname(what, RFR, NONE, index, 0);
2394: - callentry(ISV, val);
2395: - break;
2396: - default : whoops("cannot happen - addApars");
2397: - }
2398: -}
2399: -
2400: -listrefs()
2401: -{ int i, k;
2402: -
2403: - for (i = 0; i < nrrefs; i++)
2404: - { printf("\t%2d\t%s, ", i+1, reftable[i].name);
2405: - for (k = strlen(reftable[i].name)+1; k < 10; k++)
2406: - putchar(' ');
2407: - k = reftable[i].nrstates;
2408: - printf("%d state%s", k, (k!=1)?"s":"");
2409: - if ((k = reftable[i].unreach) > 0)
2410: - printf(" (%d unreachable state%s)", k, (k>1)?"s":"");
2411: - putchar('\n');
2412: - }
2413: -}
2414: //GO.SYSIN DD pret3.c
2415: echo pret4.c 1>&2
2416: sed 's/.//' >pret4.c <<'//GO.SYSIN DD pret4.c'
2417: -#include <stdio.h>
2418: -#include "pret.h"
2419: -
2420: -struct PROCTABLE proctable[MAXPROC]; /* index to process names */
2421: -
2422: -int nrprocs = 0;
2423: -
2424: -procsize(n, m, k)
2425: -{ proctable[n].nrstates = m;
2426: - proctable[n].unreach = k;
2427: -}
2428: -
2429: -newprocname(str, repl)
2430: - char *str;
2431: -{ register int i;
2432: -
2433: - for (i = 0; i < nrprocs; i++)
2434: - if (strcmp(str, proctable[i].name) == 0)
2435: - break;
2436: -
2437: - if (i == nrprocs)
2438: - { if (nrprocs >= MAXPROC)
2439: - whoops("too many processes");
2440: - proctable[i].nrstates = 0;
2441: - proctable[i].unreach = 0;
2442: - proctable[i].replic = repl;
2443: - strcpy(proctable[nrprocs++].name, str);
2444: - } else
2445: - yyerror("process redeclared, %s", str);
2446: -
2447: - return i;
2448: -}
2449: -
2450: -numprocs(fd)
2451: - FILE *fd;
2452: -{
2453: - extern int extras;
2454: - fprintf(fd, "%d processes\n", nrprocs+extras);
2455: -}
2456: -
2457: -chatter()
2458: -{ int i;
2459: - extern int verbose, nrqs, nrmesgs, nrrefs, assertion, inertion, extras;
2460: -
2461: - if (verbose)
2462: - { i = ((assertion != -1) + (inertion != -1));
2463: - printf("\nOverview:\n========\n");
2464: - printf("%d queue%s:\n", nrqs, (nrqs==1)?"":"s");
2465: - listqs();
2466: - printf("%d process%s:\n",
2467: - nrprocs+extras, (nrprocs+extras==1)?"":"es");
2468: - listprs();
2469: - printf("%d procedure%s:\n", nrrefs, (nrrefs==1)?"":"s");
2470: - listrefs();
2471: - printf("%d assertion%s\n", i, (i==1)?"":"s");
2472: - }
2473: -}
2474: -
2475: -listprs()
2476: -{ int i, k;
2477: -
2478: - for (i = 0; i < nrprocs; i++)
2479: - { printf("\t%2d", i+1);
2480: - if (proctable[i].replic != NONE)
2481: - printf("x%d", proctable[i].replic);
2482: - printf("\t%s, ", proctable[i].name);
2483: - for (k = strlen(proctable[i].name)+1; k < 10; k++)
2484: - putchar(' ');
2485: - k = proctable[i].nrstates;
2486: - printf("%d state%s", k, (k!=1)?"s":"");
2487: - if ((k = proctable[i].unreach) > 0)
2488: - printf(" (%d unreachable state%s)", k, (k>1)?"s":"");
2489: - putchar('\n');
2490: - }
2491: -}
2492: //GO.SYSIN DD pret4.c
2493: echo pret6.c 1>&2
2494: sed 's/.//' >pret6.c <<'//GO.SYSIN DD pret6.c'
2495: -#include <stdio.h>
2496: -#include "pret.h"
2497: -
2498: -struct {
2499: - char name[MAXNAME];
2500: - char mbox;
2501: - char status;
2502: - int qind; /* index!=NONE if q addressed is array */
2503: - int equa; /* basename match */
2504: - int code;
2505: -} mesgtable[MANY];
2506: -
2507: -struct QTABLE qtable[NQUEUES];
2508: -
2509: -int msize[NQUEUES]; /* mailbox sizes per queue */
2510: -
2511: -int msgval = BASEVAL;
2512: -int nrmesgs = 0;
2513: -int nrqs = 0;
2514: -
2515: -int initable[MANY];
2516: -int nrinits = 0; /* number initial messages */
2517: -
2518: -extern anyerror, pid, rid;
2519: -
2520: -newqname(str, mask, lim, qind)
2521: - char *str;
2522: -{
2523: - register int i;
2524: -
2525: - if (rid != NONE)
2526: - { if ((i = Fparname(str, rid, ISQ, NONE, mask, qind)) != -1)
2527: - return (MANY + i); /* id of qset + offset */
2528: - }
2529: - for (i = 0; i < nrqs; i++)
2530: - if (strcmp(str, qtable[i].name) == 0)
2531: - break;
2532: - if (i == nrqs)
2533: - { if (nrqs >= NQUEUES)
2534: - whoops("too many queues");
2535: -
2536: - qtable[i].owner = (mask == DCL || mask == RFR) ? pid : NONE;
2537: - qtable[i].limit = (lim == NONE) ? 2 : lim;
2538: - qtable[i].status = mask;
2539: - qtable[i].magic = 0;
2540: - qtable[i].multiple = qind;
2541: - strcpy(qtable[nrqs++].name, str);
2542: - } else
2543: - { if (mask == DCL)
2544: - { if (qtable[i].status & DCL)
2545: - yyerror("queue redeclared, %s", str);
2546: -
2547: - if (qtable[i].owner == NONE)
2548: - qtable[i].owner = pid;
2549: - else if (qtable[i].owner != pid && pid != NONE)
2550: - warning("queue read by 2 processes", str);
2551: - qtable[i].limit = lim;
2552: - qtable[i].multiple = qind;
2553: - } else if (mask & RFR)
2554: - { if (qtable[i].owner == NONE)
2555: - qtable[i].owner = pid;
2556: -
2557: - else if (qtable[i].owner != pid)
2558: - warning("queue read by 2 processes", str);
2559: - }
2560: - if ((mask & RFR) || (mask & ADR))
2561: - { if (qind != qtable[i].multiple
2562: - && (qind == NONE || qtable[i].multiple == NONE))
2563: - yyerror("queue indexing error, mesg name, %s", str);
2564: - }
2565: - qtable[i].status |= mask;
2566: - }
2567: - return i;
2568: -}
2569: -
2570: -addmsg(what, hit, mask, tpp, qind)
2571: - char *what; char mask;
2572: -{ register int i, j;
2573: - char str[MAXNAME];
2574: -
2575: - if (rid != NONE)
2576: - { if ((i = Fparname(what, rid, ISM, hit - MANY, mask, qind)) != -1)
2577: - return (MANY + i);
2578: - if (hit >= MANY)
2579: - { yyerror("undeclared message, %s", what);
2580: - return -1;
2581: - } }
2582: -
2583: - strcpy(str, qtable[hit].name);
2584: - strcat(str, ":"); strcat(str, what);
2585: -
2586: - for (j = 0; j < nrmesgs; j++)
2587: - { if (strcmp(str, mesgtable[j].name) == 0)
2588: - break;
2589: - }
2590: - for (i = j; i < nrmesgs; i++)
2591: - if (strcmp(str, mesgtable[i].name) == 0
2592: - && mesgtable[i].qind == qind)
2593: - break;
2594: - if (i == nrmesgs)
2595: - { if (nrmesgs >= MANY)
2596: - whoops("too many messages");
2597: - if (qtable[hit].multiple != qind
2598: - && (qind == NONE || qtable[hit].multiple == NONE))
2599: - yyerror("Queue indexing error, qname, %s", str);
2600: -
2601: - mesgtable[i].mbox = hit;
2602: - mesgtable[i].qind = qind;
2603: - mesgtable[i].status = mask;
2604: - strcpy(mesgtable[nrmesgs++].name, str);
2605: - mesgtable[i].code = msgval++;
2606: - mesgtable[i].equa = mesgtable[j].code;
2607: - } else
2608: - mesgtable[i].status |= mask;
2609: -
2610: - if (tpp == INITM)
2611: - initable[nrinits++] = mesgtable[i].code;
2612: -
2613: - if (strcmp(what, " any") == 0 && mask == SAR)
2614: - qtable[hit].magic = 1;
2615: -
2616: - return mesgtable[i].code;
2617: -}
2618: -
2619: -isoqs()
2620: -{ int i;
2621: - for (i = 0; i < nrqs; i++)
2622: - { if (!(qtable[i].status & DCL))
2623: - printf("warning: queue `%s' undeclared\n", qtable[i].name);
2624: - if (qtable[i].owner == NONE)
2625: - printf("warning: queue `%s' unknown owner\n", qtable[i].name);
2626: - switch (qtable[i].status) {
2627: - case 0: /* used to check name existence in qsets */
2628: - case DCL: printf("%s: isolated queue\n", qtable[i].name);
2629: - break;
2630: - case DCL+RFR: printf("%s: queue not addressed\n", qtable[i].name);
2631: - break;
2632: - case DCL+ADR: printf("%s: queue is never read\n", qtable[i].name);
2633: - default: break;
2634: - }
2635: - }
2636: -}
2637: -
2638: -silentcheck()
2639: -{ int i, j, k, p;
2640: - for (i = 0; i < nrqs; i++)
2641: - { if (msize[i] == 0)
2642: - continue;
2643: - k = strlen(qtable[i].name) + 1;
2644: - for (j = 0; j < nrmesgs; j++)
2645: - if (mesgtable[j].mbox == i && (p = mesgtable[j].status) != SAR)
2646: - { switch (p) {
2647: - case RCV: if (qtable[i].multiple) break;
2648: - printf("queue %s: ", qtable[i].name);
2649: - printf("mesg '%s' ", &mesgtable[j].name[k]);
2650: - printf("is received but not sent\n");
2651: - anyerror++;
2652: - break;
2653: - case SND: if (qtable[i].magic != 0
2654: - || qtable[i].multiple
2655: - || strcmp(&mesgtable[j].name[k], " any") == 0)
2656: - break;
2657: - printf("queue %s: ", qtable[i].name);
2658: - printf("mesg '%s' ", &mesgtable[j].name[k]);
2659: - printf("is sent but not received\n");
2660: - anyerror++;
2661: - break;
2662: - case 0: printf("queue %s: ", qtable[i].name);
2663: - printf("mesg '%s' ", &mesgtable[j].name[k]);
2664: - printf("is never used\n");
2665: - break;
2666: - }
2667: - } }
2668: -}
2669: -
2670: -checkqs()
2671: -{ isoqs();
2672: - silentcheck();
2673: -}
2674: -
2675: -numsorts(fd)
2676: - FILE *fd;
2677: -{ int i, j;
2678: -
2679: - for (i = j = 0; i < nrqs; i++)
2680: - { if (qtable[i].multiple == NONE)
2681: - j++;
2682: - else
2683: - j += qtable[i].multiple;
2684: - }
2685: - fprintf(fd, "%d queues:\n", j);
2686: - numesgs(fd);
2687: - for (i = 0; i < nrqs; i++)
2688: - { fprintf(fd, "%s\t%d/",
2689: - qtable[i].name, qtable[i].owner);
2690: - fprintf(fd, "%d/%d/%d: ",
2691: - qtable[i].limit, msize[i], qtable[i].multiple);
2692: - for (j = 0; j < nrmesgs; j++)
2693: - if (mesgtable[j].mbox == i)
2694: - fprintf(fd, "%d[%d,%d],", mesgtable[j].code,
2695: - mesgtable[j].qind,
2696: - mesgtable[j].equa);
2697: - putc('\n', fd);
2698: -} }
2699: -
2700: -numinits(fd)
2701: - FILE *fd;
2702: -{ int i;
2703: - fprintf(fd, "%d inits:\n", nrinits);
2704: - for (i = 0; i < nrinits; i++)
2705: - fprintf(fd, "%d,", initable[i]);
2706: - if (nrinits > 0)
2707: - putc('\n', fd);
2708: -}
2709: -
2710: -numesgs(fd)
2711: - FILE *fd;
2712: -{ int i, j;
2713: - char c;
2714: -
2715: - fprintf(fd, "%d messages, base %d:\n", nrmesgs, BASEVAL);
2716: - for (i = 0; i < nrmesgs; i++)
2717: - { for (j = 0; (c = mesgtable[i].name[j]) != '\0'; j++)
2718: - if (c == ':')
2719: - { j++;
2720: - break;
2721: - }
2722: - if (c == '\0')
2723: - j = 0;
2724: -
2725: - fprintf(fd, "%s ", &mesgtable[i].name[j]);
2726: - }
2727: - if (nrmesgs > 0)
2728: - putc('\n', fd);
2729: -}
2730: -
2731: -prepsorts()
2732: -{ int i, j;
2733: - for (i = 0; i < nrqs; i++)
2734: - { msize[i] = 0;
2735: - for (j = 0; j < nrmesgs; j++)
2736: - if (mesgtable[j].mbox == i)
2737: - msize[i]++;
2738: - }
2739: -}
2740: -
2741: -listqs()
2742: -{ int i, j, k, l, a;
2743: -
2744: - for (i = 0; i < nrqs; i++)
2745: - {
2746: - if (qtable[i].status & DCL == 0) /* formal q-parameter */
2747: - continue;
2748: -
2749: - printf("\t%2d\t%s", i+1, qtable[i].name);
2750: - k = strlen(qtable[i].name) + 1;
2751: - if (qtable[i].multiple != NONE)
2752: - { printf("[%d], ", qtable[i].multiple);
2753: - a = (qtable[i].multiple>9)?4:3;
2754: - } else
2755: - { printf(", ");
2756: - a = 0;
2757: - }
2758: - for (j = 10; j > k+a; j--) putchar(' ');
2759: - printf("sort: ");
2760: -
2761: - for (j = l = 0; j < nrmesgs; j++)
2762: - if (mesgtable[j].mbox == i &&
2763: - strcmp(&mesgtable[j].name[k], " tau") != 0 &&
2764: - strcmp(&mesgtable[j].name[k], " any") != 0)
2765: - { if (l++ > 0)
2766: - printf(", ");
2767: - printf("%s", &mesgtable[j].name[k]);
2768: - if ((a = mesgtable[j].qind) != NONE)
2769: - { if (a < -1)
2770: - printf("/*%d", -(a+2));
2771: - else
2772: - printf("/%d", a);
2773: - } }
2774: - printf("\n");
2775: - }
2776: -}
2777: //GO.SYSIN DD pret6.c
2778: echo pret7.c 1>&2
2779: sed 's/.//' >pret7.c <<'//GO.SYSIN DD pret7.c'
2780: -#include <stdio.h>
2781: -#include "pret.h"
2782: -#include "pret.d"
2783: -
2784: -extern FILE *tb;
2785: -extern int anyerror, linenumber;
2786: -extern int nrrows, nrcols, curstate, curdepth;
2787: -extern int nrvars, realnrvars;
2788: -extern struct ENTRY *base;
2789: -extern char filename[256];
2790: -
2791: -char *
2792: -Emalloc(N)
2793: - unsigned N;
2794: -{ char *try, *malloc();
2795: - if ((try = malloc(N)) == NULL)
2796: - whoops("out of memory");
2797: - return try;
2798: -}
2799: -
2800: -whoops(s)
2801: - char *s;
2802: -{ yyerror(s, "aborting");
2803: - fclose(tb);
2804: - unlink("pret.tmp");
2805: - exit(1);
2806: -}
2807: -
2808: -yyerror(s1, s2)
2809: - char *s1, *s2;
2810: -{
2811: - char buf[512];
2812: - sprintf(buf, s1, s2);
2813: -
2814: - printf("\"%s\", line %2d: %s\n", filename, linenumber, buf);
2815: - fflush(stdout);
2816: - anyerror++;
2817: -}
2818: -
2819: -warning(s1, s2)
2820: - char *s1, *s2;
2821: -{
2822: - printf("\"%s\", line %2d, warning: %s", filename, linenumber, s1);
2823: - if (strlen(s2) > 0 && strcmp(s1, "syntax error") != 0)
2824: - printf(" (%s)\n", s2);
2825: - else
2826: - printf("\n");
2827: -}
2828: -
2829: -release()
2830: -{ register struct ENTRY *this, *temp1, *temp2;
2831: - register struct PILAR *that, *temp3;
2832: -
2833: - this = base;
2834: - while (this != NULL)
2835: - { temp1 = this->nextrow;
2836: - do
2837: - { temp2 = this->nextcol;
2838: - that = this->pilar;
2839: - do
2840: - { temp3 = that->nxtp;
2841: - free(that);
2842: - that = temp3;
2843: - } while (that != NULL);
2844: - free(this);
2845: - this = temp2;
2846: - } while (this != NULL);
2847: - this = temp1;
2848: - }
2849: - nrrows = nrcols = curstate = curdepth = 0;
2850: - nrvars = realnrvars = 0;
2851: -}
2852: -
2853: -struct PILAR *
2854: -newunit()
2855: -{ struct PILAR *try;
2856: -
2857: - try = (struct PILAR *) Emalloc(sizeof(struct PILAR));
2858: -
2859: - try->transf = NOSTATE;
2860: - try->code = NONE;
2861: - try->nxtp = NULL;
2862: -
2863: - return try;
2864: -}
2865: -
2866: -struct ENTRY *
2867: -newentry()
2868: -{ struct ENTRY *try;
2869: -
2870: - try = (struct ENTRY *) Emalloc(sizeof(struct ENTRY));
2871: -
2872: - try->pilar = newunit();
2873: - try->nrpils = 0;
2874: - try->nextrow = try->nextcol = NULL;
2875: - return try;
2876: -}
2877: //GO.SYSIN DD pret7.c
2878: echo pret8.c 1>&2
2879: sed 's/.//' >pret8.c <<'//GO.SYSIN DD pret8.c'
2880: -#include <stdio.h>
2881: -#include "pret.h"
2882: -
2883: -struct {
2884: - char name[MAXNAME];
2885: - int status;
2886: - int initval;
2887: - int index; /* set if used as array */
2888: - int width; /* in bits: for supertrace */
2889: -} vartbl[MANY];
2890: -
2891: -struct {
2892: - int m; /* index of basename in vartbl */
2893: - int n; /* reference to the index */
2894: -} ivartbl[MANY];
2895: -int realnrvars=0;
2896: -
2897: -struct {
2898: - int m; /* index of basename in globvartbl */
2899: - int n; /* reference to the index */
2900: -} igvartbl[MANY];
2901: -int realgvars=0;
2902: -
2903: -struct {
2904: - char name[MAXNAME];
2905: - int status;
2906: - int initval;
2907: - int index;
2908: - int width;
2909: -} globvartbl[MANY];
2910: -
2911: -int nrvars = 0;
2912: -int nrglobvars = 0;
2913: -int varwidths = 0;
2914: -
2915: -extern char procname[MAXNAME];
2916: -extern char refname[MAXNAME];
2917: -extern int anyerror, pid, rid;
2918: -
2919: -reallocal(m, n)
2920: -{ int i;
2921: - for (i = 0; i < realnrvars; i++)
2922: - if (ivartbl[i].m == m && ivartbl[i].n == n)
2923: - return i;
2924: - if ((i = realnrvars++) >= MANY)
2925: - whoops("reallocal overflow");
2926: - ivartbl[i].n = n;
2927: - ivartbl[i].m = m;
2928: - return i;
2929: -}
2930: -
2931: -realglobal(m, n)
2932: -{ int i;
2933: - for (i = 0; i < realgvars; i++)
2934: - if (igvartbl[i].m == m && igvartbl[i].n == n)
2935: - return i;
2936: - if ((i = realgvars++) >= MANY)
2937: - whoops("realglobal overflow");
2938: - igvartbl[i].n = n;
2939: - igvartbl[i].m = m;
2940: - return i;
2941: -}
2942: -
2943: -twiddle(suff)
2944: - char *suff;
2945: -{ int i; extern int extras;
2946: -
2947: - for (i = 0; i < nrvars; i++)
2948: - if (strcmp(vartbl[i].name, suff) == 0)
2949: - { vartbl[i].initval++;
2950: - return;
2951: - }
2952: - whoops("cannot happen, twiddle");
2953: -}
2954: -
2955: -isarrayvar(suff)
2956: - char *suff;
2957: -{ int i;
2958: -
2959: - for (i = 0; i < nrvars; i++)
2960: - if (strcmp(vartbl[i].name, suff) == 0
2961: - && vartbl[i].index != NONE)
2962: - return 1;
2963: - for (i = 0; i < nrglobvars; i++)
2964: - if (strcmp(globvartbl[i].name, suff) == 0
2965: - && globvartbl[i].index != NONE)
2966: - return 1;
2967: - return 0;
2968: -}
2969: -
2970: -looklocal(suff, how, index)
2971: - char *suff;
2972: -{ int i;
2973: -
2974: - for (i = 0; i < nrvars; i++)
2975: - if (strcmp(vartbl[i].name, suff) == 0)
2976: - { vartbl[i].status |= how;
2977: - break;
2978: - }
2979: -
2980: - if (i != nrvars && how == DCL)
2981: - yyerror("local variable redeclared, %s", suff);
2982: -
2983: - if (i != nrvars && how == RFR && index != vartbl[i].index
2984: - && (index == NONE || vartbl[i].index == NONE))
2985: - yyerror("local variable array indexing error, %s", suff);
2986: - return i;
2987: -}
2988: -
2989: -lookglobal(suff, how, index)
2990: - char *suff;
2991: -{ int i;
2992: -
2993: - for (i = 0; i < nrglobvars; i++)
2994: - if (strcmp(globvartbl[i].name, suff) == 0)
2995: - { globvartbl[i].status |= how;
2996: - break;
2997: - }
2998: -
2999: - if (pid == NONE && rid == NONE && i != nrglobvars && how == DCL)
3000: - yyerror("global variable redeclared, %s", suff);
3001: -
3002: - if (i != nrglobvars && how == RFR && index != globvartbl[i].index
3003: - && (index == NONE || globvartbl[i].index == NONE))
3004: - yyerror("global variable array indexing error, %s", suff);
3005: - return i;
3006: -}
3007: -
3008: -putlocal(what, ival, how, index, width)
3009: - char *what;
3010: -{ int i;
3011: -
3012: - if ((i = nrvars++) >= MANY)
3013: - whoops("too many variables");
3014: -
3015: - strcpy(vartbl[i].name, what);
3016: - vartbl[i].initval = ival;
3017: - vartbl[i].status = how;
3018: - vartbl[i].index = index;
3019: - vartbl[i].width = width;
3020: - if (index != NONE && ival != NONE)
3021: - { fprintf(stderr,"error: no automatic initialization");
3022: - fprintf(stderr, " of array `%s'\n",what);
3023: - anyerror++;
3024: - }
3025: - if (width != 0) varwidths=1;
3026: - return (MANY + i);
3027: -}
3028: -
3029: -putglobal(what, ival, how, index, width)
3030: - char *what;
3031: -{ int i;
3032: -
3033: - if ((i = nrglobvars++) >= MANY)
3034: - whoops("too many variables");
3035: - strcpy(globvartbl[i].name, what);
3036: - globvartbl[i].initval = ival;
3037: - globvartbl[i].status = how;
3038: - globvartbl[i].index = index;
3039: - globvartbl[i].width = width;
3040: - if (index != NONE && ival != NONE)
3041: - { fprintf(stderr,"error: no automatic initialization");
3042: - fprintf(stderr, " of array `%s'\n",what);
3043: - anyerror++;
3044: - }
3045: - if (width != 0) varwidths=1;
3046: -
3047: - return i;
3048: -}
3049: -/*
3050: - * arrays are merely patched in for now
3051: - */
3052: -addvarname(what, how, ival, index, width)
3053: - char *what;
3054: -{
3055: - int i, islocal = (rid != NONE || pid != NONE);
3056: -
3057: - if (rid != NONE && (i = Fparname(what, rid, ISV, NONE, how, index)) != -1)
3058: - return (2*MANY + i);
3059: - /* formal parameter may not be an array reference */
3060: -
3061: - if (islocal && (i = looklocal(what, how, index)) < nrvars)
3062: - return (MANY + reallocal(i, index));
3063: - if ((i = lookglobal(what, how, index)) < nrglobvars)
3064: - return realglobal(i, index);
3065: -
3066: - if (how == RFR)
3067: - yyerror("undeclared variable, %s", what);
3068: - if (islocal)
3069: - return putlocal(what, ival, how, index, width);
3070: -
3071: - return putglobal(what, ival, how, index, width);
3072: -}
3073: -
3074: -checklocvars()
3075: -{ int i;
3076: -
3077: - for (i = 0; i < nrvars; i++)
3078: - if (vartbl[i].status == DCL)
3079: - { printf("%s: ", (pid != NONE)?procname:refname);
3080: - printf("pvar %s is never used\n", vartbl[i].name);
3081: - }
3082: -}
3083: -
3084: -checkglobvars()
3085: -{ int i;
3086: -
3087: - for (i = 0; i < nrglobvars; i++)
3088: - if (globvartbl[i].status == DCL)
3089: - { printf("global: ");
3090: - printf("pvar %s is never used\n", globvartbl[i].name);
3091: - }
3092: -}
3093: -
3094: -numglobvars(fd)
3095: - FILE *fd;
3096: -{ int i;
3097: -
3098: - fprintf(fd, "%d g-variables: ", nrglobvars);
3099: - for (i = 0; i < nrglobvars; i++)
3100: - fprintf(fd, "%d/%d,", globvartbl[i].initval, globvartbl[i].index);
3101: - putc('\n', fd);
3102: - if (varwidths)
3103: - { fprintf(fd, "%d g-widths: ", nrglobvars);
3104: - for (i = 0; i < nrglobvars; i++)
3105: - fprintf(fd, "%d,", globvartbl[i].width);
3106: - putc('\n', fd);
3107: - }
3108: - fprintf(fd, "%d g-uses: ", realgvars);
3109: - for (i = 0; i < realgvars; i++)
3110: - fprintf(fd, "%d/%d,", igvartbl[i].m, igvartbl[i].n);
3111: - putc('\n', fd);
3112: -}
3113: -
3114: -numlocvars(fd)
3115: - FILE *fd;
3116: -{ int i;
3117: -
3118: - fprintf(fd, "%d l-variables: ", nrvars);
3119: - for (i = 0; i < nrvars; i++)
3120: - fprintf(fd, "%d/%d,", vartbl[i].initval, vartbl[i].index);
3121: - putc('\n', fd);
3122: - if (varwidths)
3123: - { fprintf(fd, "%d l-widths: ", nrvars);
3124: - for (i = 0; i < nrvars; i++)
3125: - fprintf(fd, "%d,", vartbl[i].width);
3126: - putc('\n', fd);
3127: - }
3128: -
3129: - fprintf(fd, "%d l-uses: ", realnrvars);
3130: - for (i = 0; i < realnrvars; i++)
3131: - fprintf(fd, "%d/%d,", ivartbl[i].m, ivartbl[i].n);
3132: - putc('\n', fd);
3133: -}
3134: //GO.SYSIN DD pret8.c
3135: echo pret9.c 1>&2
3136: sed 's/.//' >pret9.c <<'//GO.SYSIN DD pret9.c'
3137: -#include <stdio.h>
3138: -#include "pret.h"
3139: -
3140: -#define MAXACTUALS (MANY)
3141: -
3142: - struct ACTUALS {
3143: - int typefs[MAXACTUALS]; /* queue mesg or pvar */
3144: - int index [MAXACTUALS]; /* qid, if mesg */
3145: - struct ACTUALS *nxtcall;
3146: - int nractuals;
3147: - int whattask; /* id of task called */
3148: - };
3149: -
3150: - struct ACTUALS *calls; /* procedure call data */
3151: - int nrcalls; /* nr of procedure calls */
3152: -
3153: - extern pid, rid, linenumber;
3154: -
3155: -newcalltable()
3156: -{ nrcalls = 0;
3157: - calls = NULL;
3158: -}
3159: -
3160: -scrapcalltable()
3161: -{ struct ACTUALS *tmp;
3162: - struct ACTUALS *hook = calls;
3163: - int i;
3164: -
3165: - for (i = 0; i < nrcalls; i++)
3166: - { tmp = hook;
3167: - hook = hook->nxtcall;
3168: - free(tmp);
3169: - }
3170: -}
3171: -
3172: -newcall(ofwhat)
3173: -{ int i, j;
3174: - struct ACTUALS *new, *old;
3175: -
3176: - new = ( struct ACTUALS *)
3177: - Emalloc( sizeof(struct ACTUALS) );
3178: - new->nractuals = 0;
3179: - new->whattask = ofwhat;
3180: -
3181: - if ((j = nrcalls++) == 0)
3182: - calls = new;
3183: - else
3184: - { old = calls;
3185: - for (i = 1; i < j; i++)
3186: - old = old->nxtcall;
3187: - old->nxtcall = new;
3188: - }
3189: - return nrcalls-1;
3190: -}
3191: -
3192: -putcalls(tb)
3193: - FILE *tb;
3194: -{ struct ACTUALS *hook;
3195: - int j, k, a, b;
3196: - int maxm = 0;
3197: - int maxv = 0;
3198: -
3199: - fprintf(tb, "FCT_CALLS %d\n", nrcalls);
3200: - for (j = 0, hook = calls; j < nrcalls; j++)
3201: - {
3202: - for (k = a = b = 0; k < hook->nractuals; k++)
3203: - { if (hook->typefs[k] == ISM)
3204: - a++;
3205: - else if (hook->typefs[k] == ISV)
3206: - b++;
3207: - }
3208: - if (a > maxm) maxm = a;
3209: - if (b > maxv) maxv = b;
3210: -
3211: - fprintf(tb, "%d-%d/%d:", hook->whattask, a, b);
3212: - for (k = 0; k < hook->nractuals; k++)
3213: - { if (hook->typefs[k] != ISQ)
3214: - fprintf(tb, " %d/%d", hook->typefs[k], hook->index[k]);
3215: - }
3216: - putc('\n', tb);
3217: - hook = hook->nxtcall;
3218: - }
3219: - fprintf(tb, "PARS %d/%d\n", maxm, maxv);
3220: -}
3221: -
3222: -callentry(x, val)
3223: -{ int i;
3224: - struct ACTUALS *hook = calls;
3225: -
3226: - for (i = 1; i < nrcalls; i++)
3227: - hook = hook->nxtcall;
3228: -
3229: - if ((i = hook->nractuals++) >= MAXACTUALS)
3230: - whoops("too many parameters");
3231: - hook->typefs[i] = x;
3232: - hook->index[i] = val;
3233: -}
3234: //GO.SYSIN DD pret9.c
3235: echo pretlex.l 1>&2
3236: sed 's/.//' >pretlex.l <<'//GO.SYSIN DD pretlex.l'
3237: -%{
3238: -#include "stdio.h"
3239: -#include "pret.h"
3240: -#include "y.tab.h"
3241: -
3242: -extern linenumber, nest;
3243: -extern char filename[256];
3244: -
3245: -putback(c)
3246: -{ unput(c);
3247: -}
3248: -
3249: -%}
3250: -%%
3251: -\n { linenumber++; }
3252: -\/\* { char c1, c2; /* comment string */
3253: -
3254: - for(nest++, c2 = ' ';;){
3255: - c1 = c2;
3256: - c2 = input();
3257: - if (c1 == '/' && c2 == '*')
3258: - nest++;
3259: - else if (c1 == '*' && c2 == '/')
3260: - nest--;
3261: - if (nest <= 0)
3262: - break;
3263: - if (c2 == '\n')
3264: - linenumber++;
3265: - else if (c2 == 0)
3266: - whoops("unexpected eof (in comment)");
3267: - }
3268: - }
3269: -[ \t] { ; }
3270: -^#[ ]+[0-9]+[ ]+\"[^\"]+\"\n {
3271: - sscanf(&yytext[1], "%d \"%s\"\n", &linenumber, filename);
3272: - filename[strlen(filename)-1] = 0; /* strip the last " */
3273: - }
3274: -queue { return(QUEUES); }
3275: -qset { return(QSET); }
3276: -pvar { return(PVAR); }
3277: -proc { return(PROCESS); }
3278: -if { return(IF); }
3279: -fi { return(FI); }
3280: -do { return(DO); }
3281: -od { return(OD); }
3282: -skip { return(skip); }
3283: -goto { return(GOTO); }
3284: -break { return(BREAK); }
3285: -any { return(DEFAULT); }
3286: -default { return(DEFAULT); }
3287: -assert { return(ASSERT); }
3288: -error { return(ERROR); }
3289: -timeout { return(timeout); }
3290: -\{ { return(PBEGIN); }
3291: -\} { return(END); }
3292: -[0-9]+ { yylval.resu = atoi(yytext); return(VALUE); }
3293: -[a-zA-Z][_a-zA-Z0-9]* {
3294: - yylval.resu = newstring(yytext);
3295: - if (isarrayvar(yytext)) return(ARNAME);
3296: - if (isqset(yytext)) return(QSNAME);
3297: - return(NAME);
3298: - }
3299: -_PROCID { yylval.resu = newstring("_PROCID"); return(NAME); }
3300: -"::" { return(FLAG); }
3301: -"->" { return(ARROW); }
3302: -";" { return(SEMICOLON); }
3303: -":" { return(COLON); }
3304: -\+\+ { return(INC); }
3305: -\-\- { return(DEC); }
3306: -\+\= { return(ADDEQ); }
3307: -\-\= { return(SUBEQ); }
3308: -\*\= { return(MULEQ); }
3309: -\/\= { return(DIVEQ); }
3310: -\%\= { return(MODEQ); }
3311: -\|\| { return(OR); }
3312: -\&\& { return(AND); }
3313: -\>\= { return(GE); }
3314: -\<\= { return(LE); }
3315: -\!\= { return(NE); }
3316: -\> { return(GT); }
3317: -\< { return(LT); }
3318: -\! { return(NOT); }
3319: -== { return(EQ); }
3320: -. { return(yytext[0]); }
3321: //GO.SYSIN DD pretlex.l
3322: echo x.tab.h 1>&2
3323: sed 's/.//' >x.tab.h <<'//GO.SYSIN DD x.tab.h'
3324: -
3325: -typedef union {
3326: - int resu;
3327: - struct Node *node;
3328: -} YYSTYPE;
3329: -extern YYSTYPE yylval;
3330: -# define NAME 257
3331: -# define VALUE 258
3332: -# define ARNAME 259
3333: -# define QSNAME 260
3334: -# define ASSERT 261
3335: -# define ERROR 262
3336: -# define PROCESS 263
3337: -# define PBEGIN 264
3338: -# define END 265
3339: -# define IF 266
3340: -# define FI 267
3341: -# define DO 268
3342: -# define OD 269
3343: -# define timeout 270
3344: -# define skip 271
3345: -# define BREAK 272
3346: -# define DEFAULT 273
3347: -# define GOTO 274
3348: -# define FLAG 275
3349: -# define ARROW 276
3350: -# define SEMICOLON 277
3351: -# define COLON 278
3352: -# define QUEUES 279
3353: -# define QSET 280
3354: -# define PVAR 281
3355: -# define MESG 282
3356: -# define ADDEQ 283
3357: -# define SUBEQ 284
3358: -# define MULEQ 285
3359: -# define DIVEQ 286
3360: -# define MODEQ 287
3361: -# define OR 288
3362: -# define AND 289
3363: -# define GT 290
3364: -# define GE 291
3365: -# define LT 292
3366: -# define LE 293
3367: -# define EQ 294
3368: -# define NE 295
3369: -# define UNARYMINUS 296
3370: -# define NOT 297
3371: -# define INC 298
3372: -# define DEC 299
3373: //GO.SYSIN DD x.tab.h
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.