28e9566dc5
from Ori_B:
There were a small number of changes needed from the tarball
on spinroot.org:
- The mkfile needed to be updated
- Memory.h needed to not be included
- It needed to invoke /bin/cpp instead of gcc -E
- It depended on `yychar`, which our yacc doesn't
provide.
I'm still figuring out how to use spin, but it seems to do
the right thing when testing a few of the examples:
% cd $home/src/Spin/Examples/
% spin -a peterson.pml
% pcc pan.c -D_POSIX_SOURCE
% ./6.out
(Spin Version 6.4.7 -- 19 August 2017)
+ Partial Order Reduction
Full statespace search for:
never claim - (none specified)
assertion violations +
acceptance cycles - (not selected)
invalid end states +
State-vector 32 byte, depth reached 24, errors: 0
40 states, stored
27 states, matched
67 transitions (= stored+matched)
0 atomic steps
hash conflicts: 0 (resolved)
Stats on memory usage (in Megabytes):
0.002 equivalent memory usage for states (stored*(State-vector + overhead))
0.292 actual memory usage for states
128.000 memory used for hash table (-w24)
0.534 memory used for DFS stack (-m10000)
128.730 total actual memory usage
unreached in proctype user
/tmp/Spin/Examples/peterson.pml:20, state 10, "-end-"
(1 of 10 states)
pan: elapsed time 1.25 seconds
pan: rate 32 states/second
1585 lines
40 KiB
C
1585 lines
40 KiB
C
/***** spin: pangen1.c *****/
|
|
|
|
/*
|
|
* This file is part of the public release of Spin. It is subject to the
|
|
* terms in the LICENSE file that is included in this source directory.
|
|
* Tool documentation is available at http://spinroot.com
|
|
*/
|
|
|
|
#include "spin.h"
|
|
#include "y.tab.h"
|
|
#include "pangen1.h"
|
|
#include "pangen3.h"
|
|
#include "pangen6.h"
|
|
#include <assert.h>
|
|
#ifdef SOLARIS
|
|
#include <sys/int_limits.h>
|
|
#else
|
|
#include <stdint.h>
|
|
#endif
|
|
|
|
extern FILE *tc, *th, *tt;
|
|
extern Label *labtab;
|
|
extern Ordered *all_names;
|
|
extern ProcList *rdy;
|
|
extern Queue *qtab;
|
|
extern Symbol *Fname;
|
|
extern int lineno, verbose, Pid, separate, old_scope_rules, nclaims;
|
|
extern int nrRdy, nqs, mst, Mpars, claimnr, eventmapnr;
|
|
extern short has_sorted, has_random, has_provided, has_priority;
|
|
extern Queue *ltab[];
|
|
|
|
int Npars=0, u_sync=0, u_async=0, hastrack = 1;
|
|
short has_io = 0;
|
|
short has_state=0; /* code contains c_state */
|
|
|
|
static Symbol *LstSet=ZS;
|
|
static int acceptors=0, progressors=0, nBits=0;
|
|
static int Types[] = { UNSIGNED, BIT, BYTE, CHAN, MTYPE, SHORT, INT, STRUCT };
|
|
|
|
static int doglobal(char *, int);
|
|
static void dohidden(void);
|
|
static void do_init(FILE *, Symbol *);
|
|
static void end_labs(Symbol *, int);
|
|
static void put_ptype(char *, int, int, int, enum btypes);
|
|
static void tc_predef_np(void);
|
|
static void put_pinit(ProcList *);
|
|
static void multi_init(void);
|
|
void walk_struct(FILE *, int, char *, Symbol *, char *, char *, char *);
|
|
|
|
static void
|
|
reverse_names(ProcList *p)
|
|
{
|
|
if (!p) return;
|
|
reverse_names(p->nxt);
|
|
fprintf(tc, " \"%s\",\n", p->n->name);
|
|
}
|
|
static void
|
|
reverse_types(ProcList *p)
|
|
{
|
|
if (!p) return;
|
|
reverse_types(p->nxt);
|
|
fprintf(tc, " %d, /* %s */\n", p->b, p->n->name);
|
|
}
|
|
|
|
static int
|
|
blog(int n) /* for small log2 without rounding problems */
|
|
{ int m=1, r=2;
|
|
|
|
while (r < n) { m++; r *= 2; }
|
|
return 1+m;
|
|
}
|
|
|
|
void
|
|
genheader(void)
|
|
{ ProcList *p; int i;
|
|
|
|
if (separate == 2)
|
|
{ putunames(th);
|
|
goto here;
|
|
}
|
|
/* 5.2.3: gcc 3 no longer seems to compute sizeof at compile time */
|
|
fprintf(th, "#define WS %d /* word size in bytes */\n", (int) sizeof(void *));
|
|
fprintf(th, "#define SYNC %d\n", u_sync);
|
|
fprintf(th, "#define ASYNC %d\n\n", u_async);
|
|
fprintf(th, "#ifndef NCORE\n");
|
|
fprintf(th, " #ifdef DUAL_CORE\n");
|
|
fprintf(th, " #define NCORE 2\n");
|
|
fprintf(th, " #elif QUAD_CORE\n");
|
|
fprintf(th, " #define NCORE 4\n");
|
|
fprintf(th, " #else\n");
|
|
fprintf(th, " #define NCORE 1\n");
|
|
fprintf(th, " #endif\n");
|
|
fprintf(th, "#endif\n\n");
|
|
|
|
putunames(th);
|
|
|
|
fprintf(tc, "\nshort Air[] = { ");
|
|
for (p = rdy, i=0; p; p = p->nxt, i++)
|
|
fprintf(tc, "%s (short) Air%d", (p!=rdy)?",":"", i);
|
|
fprintf(tc, ", (short) Air%d", i); /* np_ */
|
|
if (nclaims > 1)
|
|
{ fprintf(tc, "\n#ifndef NOCLAIM\n");
|
|
fprintf(tc, " , (short) Air%d", i+1); /* Multi */
|
|
fprintf(tc, "\n#endif\n\t");
|
|
}
|
|
fprintf(tc, " };\n");
|
|
|
|
fprintf(tc, "char *procname[] = {\n");
|
|
reverse_names(rdy);
|
|
fprintf(tc, " \":np_:\",\n");
|
|
fprintf(tc, " 0\n");
|
|
fprintf(tc, "};\n\n");
|
|
|
|
fprintf(tc, "enum btypes { NONE=%d, N_CLAIM=%d,", NONE, N_CLAIM);
|
|
fprintf(tc, " I_PROC=%d, A_PROC=%d,", I_PROC, A_PROC);
|
|
fprintf(tc, " P_PROC=%d, E_TRACE=%d, N_TRACE=%d };\n\n",
|
|
P_PROC, E_TRACE, N_TRACE);
|
|
|
|
fprintf(tc, "int Btypes[] = {\n");
|
|
reverse_types(rdy);
|
|
fprintf(tc, " 0 /* :np_: */\n");
|
|
fprintf(tc, "};\n\n");
|
|
|
|
here:
|
|
for (p = rdy; p; p = p->nxt)
|
|
put_ptype(p->n->name, p->tn, mst, nrRdy+1, p->b);
|
|
/* +1 for np_ */
|
|
put_ptype("np_", nrRdy, mst, nrRdy+1, 0);
|
|
|
|
if (nclaims > 1)
|
|
{ /* this is the structure that goes into the state-vector
|
|
* instead of the actual never claims
|
|
* this assumes that the claims do not have any local variables
|
|
* this claim records the types and states of all subclaims in an array
|
|
* NB: not sure if we need the first 3 fields in this structure
|
|
* it's here for now to avoid breaking some possible dependence
|
|
* in the calculations above, we were already taking into account
|
|
* that there is one never-claim, which will now be this one
|
|
*/
|
|
|
|
i = blog(mst);
|
|
fprintf(th, "\n");
|
|
|
|
fprintf(th, "#ifndef NOCLAIM\n");
|
|
fprintf(th, " #undef VERI\n");
|
|
fprintf(th, " #define VERI %d\n", nrRdy+1);
|
|
fprintf(th, " #define Pclaim P%d\n\n", nrRdy+1);
|
|
fprintf(th, "typedef struct P%d {\n", nrRdy+1);
|
|
fprintf(th, " unsigned _pid : 8; /* always zero */\n");
|
|
fprintf(th, " unsigned _t : %d; /* active-claim type */\n",
|
|
blog(nrRdy+1));
|
|
fprintf(th, " unsigned _p : %d; /* active-claim state */\n",
|
|
i);
|
|
fprintf(th, " unsigned _n : %d; /* active-claim index */\n",
|
|
blog(nclaims));
|
|
if (i <= UINT8_MAX) /* in stdint.h = UCHAR_MAX from limits.h */
|
|
{ fprintf(th, " uchar c_cur[NCLAIMS]; /* claim-states */\n");
|
|
} else if (i <= UINT16_MAX) /* really USHRT_MAX from limits.h */
|
|
{ fprintf(th, " ushort c_cur[NCLAIMS]; /* claim-states */\n");
|
|
} else /* the most unlikely case */
|
|
{ fprintf(th, " uint c_cur[NCLAIMS]; /* claim-states */\n");
|
|
}
|
|
fprintf(th, "} P%d;\n", nrRdy+1);
|
|
|
|
fprintf(tc, "#ifndef NOCLAIM\n");
|
|
fprintf(tc, "uchar spin_c_typ[NCLAIMS]; /* claim-types */\n");
|
|
fprintf(tc, "#endif\n");
|
|
|
|
fprintf(th, " #define Air%d (0)\n\n", nrRdy+1);
|
|
fprintf(th, "#endif\n");
|
|
/*
|
|
* find special states as:
|
|
* stopstate [ claimnr ][ curstate ] == 1
|
|
* accpstate [ claimnr ][ curstate ]
|
|
* progstate [ claimnr ][ curstate ]
|
|
* reached [ claimnr ][ curstate ]
|
|
* visstate [ claimnr ][ curstate ]
|
|
* loopstate [ claimnr ][ curstate ]
|
|
* mapstate [ claimnr ][ curstate ]
|
|
*/
|
|
} else
|
|
{ fprintf(th, "#define Pclaim P0\n");
|
|
fprintf(th, "#ifndef NCLAIMS\n");
|
|
fprintf(th, " #define NCLAIMS 1\n");
|
|
fprintf(th, "#endif\n");
|
|
fprintf(tc, "uchar spin_c_typ[NCLAIMS]; /* claim-types */\n");
|
|
}
|
|
|
|
ntimes(th, 0, 1, Head0);
|
|
|
|
if (separate != 2)
|
|
{ extern void c_add_stack(FILE *);
|
|
extern void c_stack_size(FILE *);
|
|
|
|
ntimes(th, 0, 1, Header);
|
|
fprintf(th, "#define StackSize (");
|
|
c_stack_size(th);
|
|
fprintf(th, ")\n");
|
|
|
|
c_add_stack(th);
|
|
ntimes(th, 0, 1, Header0);
|
|
} else
|
|
{ fprintf(th, "extern char *emalloc(unsigned long);\n");
|
|
}
|
|
ntimes(th, 0, 1, Head1);
|
|
|
|
LstSet = ZS;
|
|
(void) doglobal("", PUTV);
|
|
|
|
hastrack = c_add_sv(th);
|
|
|
|
fprintf(th, "#ifdef TRIX\n");
|
|
fprintf(th, " /* room for 512 proc+chan ptrs, + safety margin */\n");
|
|
fprintf(th, " char *_ids_[MAXPROC+MAXQ+4];\n");
|
|
fprintf(th, "#else\n");
|
|
fprintf(th, " uchar sv[VECTORSZ];\n");
|
|
fprintf(th, "#endif\n");
|
|
|
|
fprintf(th, "} State");
|
|
#ifdef SOLARIS
|
|
fprintf(th,"\n#ifdef GCC\n");
|
|
fprintf(th, "\t__attribute__ ((aligned(8)))");
|
|
fprintf(th, "\n#endif\n\t");
|
|
#endif
|
|
fprintf(th, ";\n\n");
|
|
|
|
fprintf(th, "#ifdef TRIX\n");
|
|
fprintf(th, "typedef struct TRIX_v6 {\n");
|
|
fprintf(th, " uchar *body; /* aligned */\n");
|
|
fprintf(th, "#ifndef BFS\n");
|
|
fprintf(th, " short modified;\n");
|
|
fprintf(th, "#endif\n");
|
|
fprintf(th, " short psize;\n");
|
|
fprintf(th, " short parent_pid;\n");
|
|
fprintf(th, " struct TRIX_v6 *nxt;\n");
|
|
fprintf(th, "} TRIX_v6;\n");
|
|
fprintf(th, "#endif\n\n");
|
|
|
|
fprintf(th, "#define HAS_TRACK %d\n", hastrack);
|
|
if (0 && hastrack) /* not really a problem */
|
|
{ fprintf(th, "#ifdef BFS_PAR\n");
|
|
fprintf(th, " #error cannot use BFS_PAR on models with c_track stmnts\n");
|
|
fprintf(th, "#endif\n");
|
|
}
|
|
if (separate != 2)
|
|
dohidden();
|
|
}
|
|
|
|
void
|
|
genaddproc(void)
|
|
{ ProcList *p;
|
|
int i = 0;
|
|
|
|
if (separate == 2) goto shortcut;
|
|
|
|
ntimes(tc, nrRdy+1, nrRdy+2, R2); /* +1 for np_ -- was th */
|
|
|
|
fprintf(tc, "#ifdef TRIX\n");
|
|
fprintf(tc, "int what_p_size(int);\n");
|
|
fprintf(tc, "int what_q_size(int);\n\n");
|
|
|
|
/* the number of processes just changed by 1 (up or down) */
|
|
/* this means that the channel indices move up or down by one slot */
|
|
/* not all new channels may have a valid index yet, but we move */
|
|
/* all of them anyway, as if they existed */
|
|
ntimes(tc, 0, 1, R7a);
|
|
fprintf(tc, "#endif\n\n");
|
|
|
|
ntimes(tc, 0, 1, R7b);
|
|
|
|
fprintf(tc, "int\naddproc(int calling_pid, int priority, int n");
|
|
for (/* i = 0 */; i < Npars; i++)
|
|
fprintf(tc, ", int par%d", i);
|
|
|
|
ntimes(tc, 0, 1, Addp0);
|
|
ntimes(tc, 1, nrRdy+1, R5); /* +1 for np_ */
|
|
|
|
if (nclaims > 1)
|
|
{ fprintf(tc, "#ifndef NOCLAIM\n");
|
|
ntimes(tc, nrRdy+1, nrRdy+2, R5);
|
|
fprintf(tc, "#endif\n");
|
|
}
|
|
|
|
ntimes(tc, 0, 1, Addp1);
|
|
|
|
if (has_provided)
|
|
{ fprintf(tt, "\nint\nprovided(int II, unsigned char ot, ");
|
|
fprintf(tt, "int tt, Trans *t)\n");
|
|
fprintf(tt, "{\n\tswitch(ot) {\n");
|
|
}
|
|
shortcut:
|
|
if (nclaims > 1)
|
|
{ multi_init();
|
|
}
|
|
tc_predef_np();
|
|
for (p = rdy; p; p = p->nxt)
|
|
{ Pid = p->tn;
|
|
put_pinit(p);
|
|
}
|
|
if (separate == 2) return;
|
|
|
|
Pid = 0;
|
|
if (has_provided)
|
|
{ fprintf(tt, "\tdefault: return 1; /* e.g., a claim */\n");
|
|
fprintf(tt, "\t}\n\treturn 0;\n}\n");
|
|
}
|
|
|
|
ntimes(tc, i, i+1, R6);
|
|
if (separate == 0)
|
|
ntimes(tc, 1, nrRdy+1, R5); /* +1 for np_ */
|
|
else
|
|
ntimes(tc, 1, nrRdy, R5);
|
|
ntimes(tc, 0, 1, R8a);
|
|
}
|
|
|
|
void
|
|
do_locinits(FILE *fd)
|
|
{ ProcList *p;
|
|
|
|
/* the locinit functions may refer to pptr or qptr */
|
|
fprintf(fd, "#if VECTORSZ>32000\n");
|
|
fprintf(fd, " extern int \n");
|
|
fprintf(fd, "#else\n");
|
|
fprintf(fd, " extern short \n");
|
|
fprintf(fd, "#endif\n");
|
|
fprintf(fd, " *proc_offset, *q_offset;\n");
|
|
|
|
for (p = rdy; p; p = p->nxt)
|
|
{ c_add_locinit(fd, p->tn, p->n->name);
|
|
}
|
|
}
|
|
|
|
void
|
|
genother(void)
|
|
{ ProcList *p;
|
|
|
|
switch (separate) {
|
|
case 2:
|
|
if (nclaims > 0)
|
|
{ for (p = rdy; p; p = p->nxt)
|
|
{ if (p->b == N_CLAIM)
|
|
{ ntimes(tc, p->tn, p->tn+1, R0); /* claims only */
|
|
fprintf(tc, "#ifdef HAS_CODE\n");
|
|
ntimes(tc, p->tn, p->tn+1, R00);
|
|
fprintf(tc, "#endif\n");
|
|
} } }
|
|
break;
|
|
case 1:
|
|
ntimes(tc, 0, 1, Code0);
|
|
for (p = rdy; p; p = p->nxt)
|
|
{ if (p->b != N_CLAIM)
|
|
{ ntimes(tc, p->tn, p->tn+1, R0); /* all except claims */
|
|
fprintf(tc, "#ifdef HAS_CODE\n");
|
|
ntimes(tc, p->tn, p->tn+1, R00);
|
|
fprintf(tc, "#endif\n");
|
|
} }
|
|
break;
|
|
case 0:
|
|
ntimes(tc, 0, 1, Code0);
|
|
ntimes(tc, 0, nrRdy+1, R0); /* +1 for np_ */
|
|
fprintf(tc, "#ifdef HAS_CODE\n");
|
|
ntimes(tc, 0, nrRdy+1, R00); /* +1 for np_ */
|
|
fprintf(tc, "#endif\n");
|
|
break;
|
|
}
|
|
/* new place, make sure Maxbody is set to its final value here */
|
|
fprintf(tc, "\n");
|
|
|
|
if (separate != 2)
|
|
{ ntimes(tc, 1, u_sync+u_async+1, R3); /* nqs is still 0 */
|
|
fprintf(tc, "\tMaxbody = max(Maxbody, sizeof(State)-VECTORSZ);\n");
|
|
fprintf(tc, "\tif ((Maxbody %% WS) != 0)\n");
|
|
fprintf(tc, "\t Maxbody += WS - (Maxbody %% WS);\n\n");
|
|
}
|
|
|
|
for (p = rdy; p; p = p->nxt)
|
|
end_labs(p->n, p->tn);
|
|
|
|
switch (separate) {
|
|
case 2:
|
|
if (nclaims > 0)
|
|
{ for (p = rdy; p; p = p->nxt)
|
|
{ if (p->b == N_CLAIM)
|
|
{ ntimes(tc, p->tn, p->tn+1, R0a); /* claims only */
|
|
} } }
|
|
return;
|
|
case 1:
|
|
for (p = rdy; p; p = p->nxt)
|
|
{ if (p->b != N_CLAIM)
|
|
{ ntimes(tc, p->tn, p->tn+1, R0a); /* all except claims */
|
|
} }
|
|
fprintf(tc, " if (state_tables)\n");
|
|
fprintf(tc, " ini_claim(%d, 0);\n", claimnr); /* the default claim */
|
|
if (acceptors == 0)
|
|
{ acceptors = 1; /* assume at least 1 acceptstate */
|
|
}
|
|
break;
|
|
case 0:
|
|
ntimes(tc, 0, nrRdy, R0a); /* all */
|
|
break;
|
|
}
|
|
|
|
ntimes(th, acceptors, acceptors+1, Code1);
|
|
ntimes(th, progressors, progressors+1, Code3);
|
|
|
|
ntimes(tc, 0, 1, Code2a); /* dfs, bfs */
|
|
ntimes(tc, 0, 1, Code2e); /* multicore */
|
|
ntimes(tc, 0, 1, Code2c); /* multicore */
|
|
ntimes(tc, 0, 1, Code2d);
|
|
|
|
fprintf(tc, "void\ndo_reach(void)\n{\n");
|
|
ntimes(tc, 0, nrRdy, R4);
|
|
fprintf(tc, "}\n\n");
|
|
|
|
fprintf(tc, "void\niniglobals(int calling_pid)\n{\n");
|
|
if (doglobal("", INIV) > 0)
|
|
{ fprintf(tc, "#ifdef VAR_RANGES\n");
|
|
(void) doglobal("logval(\"", LOGV);
|
|
fprintf(tc, "#endif\n");
|
|
}
|
|
fprintf(tc, "}\n\n");
|
|
}
|
|
|
|
void
|
|
gensvmap(void)
|
|
{
|
|
ntimes(tc, 0, 1, SvMap);
|
|
}
|
|
|
|
static struct {
|
|
char *s, *t; int n, m, p;
|
|
} ln[] = {
|
|
{"end", "stopstate", 3, 0, 0},
|
|
{"progress", "progstate", 8, 0, 1},
|
|
{"accept", "accpstate", 6, 1, 0},
|
|
{0, 0, 0, 0, 0},
|
|
};
|
|
|
|
static void
|
|
end_labs(Symbol *s, int i)
|
|
{ int oln = lineno;
|
|
Symbol *ofn = Fname;
|
|
Label *l;
|
|
int j; char foo[128];
|
|
|
|
if ((pid_is_claim(i) && separate == 1)
|
|
|| (!pid_is_claim(i) && separate == 2))
|
|
return;
|
|
|
|
for (l = labtab; l; l = l->nxt)
|
|
for (j = 0; ln[j].n; j++)
|
|
{ if (strncmp(l->s->name, ln[j].s, ln[j].n) == 0
|
|
&& strcmp(l->c->name, s->name) == 0)
|
|
{ fprintf(tc, "\t%s[%d][%d] = 1;\n",
|
|
ln[j].t, i, l->e->seqno);
|
|
acceptors += ln[j].m;
|
|
progressors += ln[j].p;
|
|
if (l->e->status & D_ATOM)
|
|
{ sprintf(foo, "%s label inside d_step",
|
|
ln[j].s);
|
|
goto complain;
|
|
}
|
|
if (j > 0 && (l->e->status & ATOM))
|
|
{ sprintf(foo, "%s label inside atomic",
|
|
ln[j].s);
|
|
complain: lineno = l->e->n->ln;
|
|
Fname = l->e->n->fn;
|
|
printf("spin: %3d:%s, warning, %s - is invisible\n",
|
|
lineno, Fname?Fname->name:"-", foo);
|
|
} } }
|
|
/* visible states -- through remote refs: */
|
|
for (l = labtab; l; l = l->nxt)
|
|
if (l->visible
|
|
&& strcmp(l->s->context->name, s->name) == 0)
|
|
fprintf(tc, "\tvisstate[%d][%d] = 1;\n",
|
|
i, l->e->seqno);
|
|
|
|
lineno = oln;
|
|
Fname = ofn;
|
|
}
|
|
|
|
void
|
|
ntimes(FILE *fd, int n, int m, const char *c[])
|
|
{
|
|
int i, j;
|
|
for (j = 0; c[j]; j++)
|
|
for (i = n; i < m; i++)
|
|
{ fprintf(fd, c[j], i, i, i, i, i, i);
|
|
fprintf(fd, "\n");
|
|
}
|
|
}
|
|
|
|
void
|
|
prehint(Symbol *s)
|
|
{ Lextok *n;
|
|
|
|
printf("spin: warning, ");
|
|
if (!s) return;
|
|
|
|
n = (s->context != ZS)?s->context->ini:s->ini;
|
|
if (n)
|
|
printf("line %s:%d, ", n->fn->name, n->ln);
|
|
}
|
|
|
|
void
|
|
checktype(Symbol *sp, char *s)
|
|
{ char buf[128]; int i;
|
|
|
|
if (!s
|
|
|| (sp->type != BYTE
|
|
&& sp->type != SHORT
|
|
&& sp->type != INT))
|
|
return;
|
|
|
|
if (sp->hidden&16) /* formal parameter */
|
|
{ ProcList *p; Lextok *f, *t;
|
|
int posnr = 0;
|
|
for (p = rdy; p; p = p->nxt)
|
|
if (p->n->name
|
|
&& strcmp(s, p->n->name) == 0)
|
|
break;
|
|
if (p)
|
|
for (f = p->p; f; f = f->rgt) /* list of types */
|
|
for (t = f->lft; t; t = t->rgt, posnr++)
|
|
if (t->sym
|
|
&& strcmp(t->sym->name, sp->name) == 0)
|
|
{ checkrun(sp, posnr);
|
|
return;
|
|
}
|
|
|
|
} else if (!(sp->hidden&4))
|
|
{ if (!(verbose&32)) return;
|
|
sputtype(buf, sp->type);
|
|
i = (int) strlen(buf);
|
|
while (i > 0 && buf[--i] == ' ') buf[i] = '\0';
|
|
prehint(sp);
|
|
if (sp->context)
|
|
printf("proctype %s:", s);
|
|
else
|
|
printf("global");
|
|
printf(" '%s %s' could be declared 'bit %s'\n",
|
|
buf, sp->name, sp->name);
|
|
} else if (sp->type != BYTE && !(sp->hidden&8))
|
|
{ if (!(verbose&32)) return;
|
|
sputtype(buf, sp->type);
|
|
i = (int) strlen(buf);
|
|
while (buf[--i] == ' ') buf[i] = '\0';
|
|
prehint(sp);
|
|
if (sp->context)
|
|
printf("proctype %s:", s);
|
|
else
|
|
printf("global");
|
|
printf(" '%s %s' could be declared 'byte %s'\n",
|
|
buf, sp->name, sp->name);
|
|
}
|
|
}
|
|
|
|
static int
|
|
dolocal(FILE *ofd, char *pre, int dowhat, int p, char *s, enum btypes b)
|
|
{ int h, j, k=0; extern int nr_errs;
|
|
Ordered *walk;
|
|
Symbol *sp;
|
|
char buf[128], buf2[128], buf3[128];
|
|
|
|
if (dowhat == INIV)
|
|
{ /* initialize in order of declaration */
|
|
for (walk = all_names; walk; walk = walk->next)
|
|
{ sp = walk->entry;
|
|
if (sp->context
|
|
&& !sp->owner
|
|
&& strcmp(s, sp->context->name) == 0)
|
|
{ checktype(sp, s); /* fall through */
|
|
if (!(sp->hidden&16))
|
|
{ sprintf(buf, "((P%d *)pptr(h))->", p);
|
|
do_var(ofd, dowhat, buf, sp, "", " = ", ";\n");
|
|
}
|
|
k++;
|
|
} }
|
|
} else
|
|
{ for (j = 0; j < 8; j++)
|
|
for (h = 0; h <= 1; h++)
|
|
for (walk = all_names; walk; walk = walk->next)
|
|
{ sp = walk->entry;
|
|
if (sp->context
|
|
&& !sp->owner
|
|
&& sp->type == Types[j]
|
|
&& ((h == 0 && (sp->nel == 1 && sp->isarray == 0))
|
|
|| (h == 1 && (sp->nel > 1 || sp->isarray == 1)))
|
|
&& strcmp(s, sp->context->name) == 0)
|
|
{ switch (dowhat) {
|
|
case LOGV:
|
|
if (sp->type == CHAN
|
|
&& verbose == 0)
|
|
break;
|
|
sprintf(buf, "%s%s:", pre, s);
|
|
{ sprintf(buf2, "\", ((P%d *)pptr(h))->", p);
|
|
sprintf(buf3, ");\n");
|
|
}
|
|
do_var(ofd, dowhat, "", sp, buf, buf2, buf3);
|
|
break;
|
|
case PUTV:
|
|
sprintf(buf, "((P%d *)pptr(h))->", p);
|
|
do_var(ofd, dowhat, buf, sp, "", " = ", ";\n");
|
|
k++;
|
|
break;
|
|
}
|
|
if (b == N_CLAIM)
|
|
{ printf("error: %s defines local %s\n",
|
|
s, sp->name);
|
|
nr_errs++;
|
|
} } } }
|
|
|
|
return k;
|
|
}
|
|
|
|
void
|
|
c_chandump(FILE *fd)
|
|
{ Queue *q;
|
|
char buf[256];
|
|
int i;
|
|
|
|
if (!qtab)
|
|
{ fprintf(fd, "void\nc_chandump(int unused)\n");
|
|
fprintf(fd, "{\tunused++; /* avoid complaints */\n}\n");
|
|
return;
|
|
}
|
|
|
|
fprintf(fd, "void\nc_chandump(int from)\n");
|
|
fprintf(fd, "{ uchar *z; int slot;\n");
|
|
|
|
fprintf(fd, " from--;\n");
|
|
fprintf(fd, " if (from >= (int) now._nr_qs || from < 0)\n");
|
|
fprintf(fd, " { printf(\"pan: bad qid %%d\\n\", from+1);\n");
|
|
fprintf(fd, " return;\n");
|
|
fprintf(fd, " }\n");
|
|
fprintf(fd, " z = qptr(from);\n");
|
|
fprintf(fd, " switch (((Q0 *)z)->_t) {\n");
|
|
|
|
for (q = qtab; q; q = q->nxt)
|
|
{ fprintf(fd, " case %d:\n\t\t", q->qid);
|
|
sprintf(buf, "((Q%d *)z)->", q->qid);
|
|
|
|
fprintf(fd, "for (slot = 0; slot < %sQlen; slot++)\n\t\t", buf);
|
|
fprintf(fd, "{ printf(\" [\");\n\t\t");
|
|
for (i = 0; i < q->nflds; i++)
|
|
{ if (q->fld_width[i] == MTYPE)
|
|
{ fprintf(fd, "\tprintm(%scontents[slot].fld%d);\n\t\t",
|
|
buf, i);
|
|
} else
|
|
fprintf(fd, "\tprintf(\"%%d,\", %scontents[slot].fld%d);\n\t\t",
|
|
buf, i);
|
|
}
|
|
fprintf(fd, " printf(\"],\");\n\t\t");
|
|
fprintf(fd, "}\n\t\t");
|
|
fprintf(fd, "break;\n");
|
|
}
|
|
fprintf(fd, " }\n");
|
|
fprintf(fd, " printf(\"\\n\");\n}\n");
|
|
}
|
|
|
|
void
|
|
c_var(FILE *fd, char *pref, Symbol *sp)
|
|
{ char *ptr, buf[256];
|
|
int i;
|
|
|
|
if (!sp)
|
|
{ fatal("cannot happen - c_var", 0);
|
|
}
|
|
|
|
ptr = sp->name;
|
|
if (!old_scope_rules)
|
|
{ while (*ptr == '_' || isdigit((int)*ptr))
|
|
{ ptr++;
|
|
} }
|
|
|
|
switch (sp->type) {
|
|
case STRUCT:
|
|
/* c_struct(fd, pref, sp); */
|
|
fprintf(fd, "\t\tprintf(\"\t(struct %s)\\n\");\n",
|
|
sp->name);
|
|
sprintf(buf, "%s%s.", pref, sp->name);
|
|
c_struct(fd, buf, sp);
|
|
break;
|
|
case MTYPE:
|
|
case BIT: case BYTE:
|
|
case SHORT: case INT:
|
|
case UNSIGNED:
|
|
sputtype(buf, sp->type);
|
|
if (sp->nel == 1 && sp->isarray == 0)
|
|
{
|
|
if (sp->type == MTYPE && ismtype(sp->name))
|
|
{ fprintf(fd, "\tprintf(\"\t%s %s:\t%d\\n\");\n",
|
|
buf, ptr, ismtype(sp->name));
|
|
} else
|
|
{ fprintf(fd, "\tprintf(\"\t%s %s:\t%%d\\n\", %s%s);\n",
|
|
buf, ptr, pref, sp->name);
|
|
}
|
|
} else
|
|
{ fprintf(fd, "\t{\tint l_in;\n");
|
|
fprintf(fd, "\t\tfor (l_in = 0; l_in < %d; l_in++)\n", sp->nel);
|
|
fprintf(fd, "\t\t{\n");
|
|
fprintf(fd, "\t\t\tprintf(\"\t%s %s[%%d]:\t%%d\\n\", l_in, %s%s[l_in]);\n",
|
|
buf, ptr, pref, sp->name);
|
|
fprintf(fd, "\t\t}\n");
|
|
fprintf(fd, "\t}\n");
|
|
}
|
|
break;
|
|
case CHAN:
|
|
if (sp->nel == 1 && sp->isarray == 0)
|
|
{ fprintf(fd, "\tprintf(\"\tchan %s (=%%d):\tlen %%d:\\t\", ", ptr);
|
|
fprintf(fd, "%s%s, q_len(%s%s));\n",
|
|
pref, sp->name, pref, sp->name);
|
|
fprintf(fd, "\tc_chandump(%s%s);\n", pref, sp->name);
|
|
} else
|
|
for (i = 0; i < sp->nel; i++)
|
|
{ fprintf(fd, "\tprintf(\"\tchan %s[%d] (=%%d):\tlen %%d:\\t\", ",
|
|
ptr, i);
|
|
fprintf(fd, "%s%s[%d], q_len(%s%s[%d]));\n",
|
|
pref, sp->name, i, pref, sp->name, i);
|
|
fprintf(fd, "\tc_chandump(%s%s[%d]);\n",
|
|
pref, sp->name, i);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
int
|
|
c_splurge_any(ProcList *p)
|
|
{ Ordered *walk;
|
|
Symbol *sp;
|
|
|
|
if (p->b != N_CLAIM && p->b != E_TRACE && p->b != N_TRACE)
|
|
for (walk = all_names; walk; walk = walk->next)
|
|
{ sp = walk->entry;
|
|
if (!sp->context
|
|
|| sp->type == 0
|
|
|| strcmp(sp->context->name, p->n->name) != 0
|
|
|| sp->owner || (sp->hidden&1)
|
|
|| (sp->type == MTYPE && ismtype(sp->name)))
|
|
continue;
|
|
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
c_splurge(FILE *fd, ProcList *p)
|
|
{ Ordered *walk;
|
|
Symbol *sp;
|
|
char pref[64];
|
|
|
|
if (p->b != N_CLAIM && p->b != E_TRACE && p->b != N_TRACE)
|
|
for (walk = all_names; walk; walk = walk->next)
|
|
{ sp = walk->entry;
|
|
if (!sp->context
|
|
|| sp->type == 0
|
|
|| strcmp(sp->context->name, p->n->name) != 0
|
|
|| sp->owner || (sp->hidden&1)
|
|
|| (sp->type == MTYPE && ismtype(sp->name)))
|
|
continue;
|
|
|
|
sprintf(pref, "((P%d *)pptr(pid))->", p->tn);
|
|
c_var(fd, pref, sp);
|
|
}
|
|
}
|
|
|
|
void
|
|
c_wrapper(FILE *fd) /* allow pan.c to print out global sv entries */
|
|
{ Ordered *walk;
|
|
ProcList *p;
|
|
Symbol *sp;
|
|
Lextok *n;
|
|
extern Lextok *Mtype;
|
|
int j;
|
|
|
|
fprintf(fd, "void\nc_globals(void)\n{\t/* int i; */\n");
|
|
fprintf(fd, " printf(\"global vars:\\n\");\n");
|
|
for (walk = all_names; walk; walk = walk->next)
|
|
{ sp = walk->entry;
|
|
if (sp->context || sp->owner || (sp->hidden&1))
|
|
continue;
|
|
c_var(fd, "now.", sp);
|
|
}
|
|
fprintf(fd, "}\n");
|
|
|
|
fprintf(fd, "void\nc_locals(int pid, int tp)\n{\t/* int i; */\n");
|
|
fprintf(fd, " switch(tp) {\n");
|
|
for (p = rdy; p; p = p->nxt)
|
|
{ fprintf(fd, " case %d:\n", p->tn);
|
|
if (c_splurge_any(p))
|
|
{ fprintf(fd, " \tprintf(\"local vars proc %%d (%s):\\n\", pid);\n",
|
|
p->n->name);
|
|
c_splurge(fd, p);
|
|
} else
|
|
{ fprintf(fd, " \t/* none */\n");
|
|
}
|
|
fprintf(fd, " \tbreak;\n");
|
|
}
|
|
fprintf(fd, " }\n}\n");
|
|
|
|
fprintf(fd, "void\nprintm(int x)\n{\n");
|
|
fprintf(fd, " switch (x) {\n");
|
|
for (n = Mtype, j = 1; n && j; n = n->rgt, j++)
|
|
fprintf(fd, "\tcase %d: Printf(\"%s\"); break;\n",
|
|
j, n->lft->sym->name);
|
|
fprintf(fd, " default: Printf(\"%%d\", x);\n");
|
|
fprintf(fd, " }\n");
|
|
fprintf(fd, "}\n");
|
|
}
|
|
|
|
static int
|
|
doglobal(char *pre, int dowhat)
|
|
{ Ordered *walk;
|
|
Symbol *sp;
|
|
int j, cnt = 0;
|
|
|
|
for (j = 0; j < 8; j++)
|
|
for (walk = all_names; walk; walk = walk->next)
|
|
{ sp = walk->entry;
|
|
if (!sp->context
|
|
&& !sp->owner
|
|
&& sp->type == Types[j])
|
|
{ if (Types[j] != MTYPE || !ismtype(sp->name))
|
|
switch (dowhat) {
|
|
case LOGV:
|
|
if (sp->type == CHAN
|
|
&& verbose == 0)
|
|
break;
|
|
if (sp->hidden&1)
|
|
break;
|
|
do_var(tc, dowhat, "", sp,
|
|
pre, "\", now.", ");\n");
|
|
break;
|
|
case INIV:
|
|
checktype(sp, (char *) 0);
|
|
cnt++; /* fall through */
|
|
case PUTV:
|
|
do_var(tc, dowhat,
|
|
(sp->hidden&1)?"":"now.", sp,
|
|
"", " = ", ";\n");
|
|
break;
|
|
} } }
|
|
return cnt;
|
|
}
|
|
|
|
static void
|
|
dohidden(void)
|
|
{ Ordered *walk;
|
|
Symbol *sp;
|
|
int j;
|
|
|
|
for (j = 0; j < 8; j++)
|
|
for (walk = all_names; walk; walk = walk->next)
|
|
{ sp = walk->entry;
|
|
if ((sp->hidden&1)
|
|
&& sp->type == Types[j])
|
|
{ if (sp->context || sp->owner)
|
|
fatal("cannot hide non-globals (%s)", sp->name);
|
|
if (sp->type == CHAN)
|
|
fatal("cannot hide channels (%s)", sp->name);
|
|
fprintf(th, "/* hidden variable: */");
|
|
typ2c(sp);
|
|
} }
|
|
}
|
|
|
|
void
|
|
do_var(FILE *ofd, int dowhat, char *s, Symbol *sp,
|
|
char *pre, char *sep, char *ter)
|
|
{ int i;
|
|
char *ptr = sp?sp->name:"";
|
|
|
|
if (!sp)
|
|
{ fatal("cannot happen - do_var", 0);
|
|
}
|
|
|
|
switch(dowhat) {
|
|
case PUTV:
|
|
if (sp->hidden&1) break;
|
|
|
|
typ2c(sp);
|
|
break;
|
|
|
|
case LOGV:
|
|
if (!old_scope_rules)
|
|
{ while (*ptr == '_' || isdigit((int)*ptr))
|
|
{ ptr++;
|
|
} }
|
|
/* fall thru */
|
|
case INIV:
|
|
if (sp->type == STRUCT)
|
|
{ /* struct may contain a chan */
|
|
walk_struct(ofd, dowhat, s, sp, pre, sep, ter);
|
|
break;
|
|
}
|
|
if (!sp->ini && dowhat != LOGV) /* it defaults to 0 */
|
|
break;
|
|
if (sp->nel == 1 && sp->isarray == 0)
|
|
{ if (dowhat == LOGV)
|
|
{ fprintf(ofd, "\t\t%s%s%s%s",
|
|
pre, s, ptr, sep);
|
|
fprintf(ofd, "%s%s", s, sp->name);
|
|
} else
|
|
{ fprintf(ofd, "\t\t%s%s%s%s",
|
|
pre, s, sp->name, sep);
|
|
do_init(ofd, sp);
|
|
}
|
|
fprintf(ofd, "%s", ter);
|
|
} else
|
|
{ if (sp->ini && sp->ini->ntyp == CHAN)
|
|
{ for (i = 0; i < sp->nel; i++)
|
|
{ fprintf(ofd, "\t\t%s%s%s[%d]%s",
|
|
pre, s, sp->name, i, sep);
|
|
if (dowhat == LOGV)
|
|
fprintf(ofd, "%s%s[%d]",
|
|
s, sp->name, i);
|
|
else
|
|
do_init(ofd, sp);
|
|
fprintf(ofd, "%s", ter);
|
|
}
|
|
} else if (sp->ini)
|
|
{ if (dowhat != LOGV && sp->isarray && sp->ini->ntyp == ',')
|
|
{ Lextok *z, *y;
|
|
z = sp->ini;
|
|
for (i = 0; i < sp->nel; i++)
|
|
{ if (z && z->ntyp == ',')
|
|
{ y = z->lft;
|
|
z = z->rgt;
|
|
} else
|
|
{ y = z;
|
|
}
|
|
fprintf(ofd, "\t\t%s%s%s[%d]%s",
|
|
pre, s, sp->name, i, sep);
|
|
putstmnt(ofd, y, 0);
|
|
fprintf(ofd, "%s", ter);
|
|
}
|
|
} else
|
|
{ fprintf(ofd, "\t{\tint l_in;\n");
|
|
fprintf(ofd, "\t\tfor (l_in = 0; l_in < %d; l_in++)\n",
|
|
sp->nel);
|
|
fprintf(ofd, "\t\t{\n");
|
|
fprintf(ofd, "\t\t\t%s%s%s[l_in]%s",
|
|
pre, s, sp->name, sep);
|
|
if (dowhat == LOGV)
|
|
{ fprintf(ofd, "%s%s[l_in]", s, sp->name);
|
|
} else
|
|
{ putstmnt(ofd, sp->ini, 0);
|
|
}
|
|
fprintf(ofd, "%s", ter);
|
|
fprintf(ofd, "\t\t}\n");
|
|
fprintf(ofd, "\t}\n");
|
|
} } }
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
do_init(FILE *ofd, Symbol *sp)
|
|
{ int i;
|
|
|
|
if (sp->ini
|
|
&& sp->type == CHAN
|
|
&& ((i = qmake(sp)) > 0))
|
|
{ if (sp->ini->ntyp == CHAN)
|
|
{ fprintf(ofd, "addqueue(calling_pid, %d, %d)",
|
|
i, ltab[i-1]->nslots == 0);
|
|
} else
|
|
{ fprintf(ofd, "%d", i);
|
|
}
|
|
} else
|
|
{ putstmnt(ofd, sp->ini, 0);
|
|
}
|
|
}
|
|
|
|
static void
|
|
put_ptype(char *s, int i, int m0, int m1, enum btypes b)
|
|
{ int k;
|
|
|
|
if (b == I_PROC)
|
|
{ fprintf(th, "#define Pinit ((P%d *)this)\n", i);
|
|
} else if (b == P_PROC || b == A_PROC)
|
|
{ fprintf(th, "#define P%s ((P%d *)this)\n", s, i);
|
|
}
|
|
|
|
fprintf(th, "typedef struct P%d { /* %s */\n", i, s);
|
|
fprintf(th, " unsigned _pid : 8; /* 0..255 */\n");
|
|
fprintf(th, " unsigned _t : %d; /* proctype */\n", blog(m1));
|
|
fprintf(th, " unsigned _p : %d; /* state */\n", blog(m0));
|
|
fprintf(th, "#ifdef HAS_PRIORITY\n");
|
|
fprintf(th, " unsigned _priority : 8; /* 0..255 */\n");
|
|
fprintf(th, "#endif\n");
|
|
LstSet = ZS;
|
|
nBits = 8 + blog(m1) + blog(m0);
|
|
k = dolocal(tc, "", PUTV, i, s, b); /* includes pars */
|
|
c_add_loc(th, s);
|
|
|
|
fprintf(th, "} P%d;\n", i);
|
|
if ((!LstSet && k > 0) || has_state)
|
|
fprintf(th, "#define Air%d 0\n\n", i);
|
|
else if (LstSet || k == 0) /* 5.0, added condition */
|
|
{ fprintf(th, "#define Air%d (sizeof(P%d) - ", i, i);
|
|
if (k == 0)
|
|
{ fprintf(th, "%d", (nBits+7)/8);
|
|
goto done;
|
|
}
|
|
if ((LstSet->type != BIT && LstSet->type != UNSIGNED)
|
|
|| LstSet->nel != 1)
|
|
{ fprintf(th, "Offsetof(P%d, %s) - %d*sizeof(",
|
|
i, LstSet->name, LstSet->nel);
|
|
}
|
|
switch(LstSet->type) {
|
|
case UNSIGNED:
|
|
fprintf(th, "%d", (nBits+7)/8);
|
|
break;
|
|
case BIT:
|
|
if (LstSet->nel == 1)
|
|
{ fprintf(th, "%d", (nBits+7)/8);
|
|
break;
|
|
} /* else fall through */
|
|
case MTYPE: case BYTE: case CHAN:
|
|
fprintf(th, "uchar)"); break;
|
|
case SHORT:
|
|
fprintf(th, "short)"); break;
|
|
case INT:
|
|
fprintf(th, "int)"); break;
|
|
default:
|
|
fatal("cannot happen Air %s",
|
|
LstSet->name);
|
|
}
|
|
done: fprintf(th, ")\n\n");
|
|
}
|
|
}
|
|
|
|
static void
|
|
tc_predef_np(void)
|
|
{
|
|
fprintf(th, "#define _NP_ %d\n", nrRdy); /* 1+ highest proctype nr */
|
|
|
|
fprintf(th, "#define _nstates%d 3 /* np_ */\n", nrRdy);
|
|
fprintf(th, "#define _endstate%d 2 /* np_ */\n\n", nrRdy);
|
|
fprintf(th, "#define _start%d 0 /* np_ */\n", nrRdy);
|
|
|
|
fprintf(tc, "\tcase %d: /* np_ */\n", nrRdy);
|
|
if (separate == 1)
|
|
{ fprintf(tc, "\t\tini_claim(%d, h);\n", nrRdy);
|
|
} else
|
|
{ fprintf(tc, "\t\t((P%d *)pptr(h))->_t = %d;\n", nrRdy, nrRdy);
|
|
fprintf(tc, "\t\t((P%d *)pptr(h))->_p = 0;\n", nrRdy);
|
|
|
|
fprintf(tc, "#ifdef HAS_PRIORITY\n");
|
|
fprintf(tc, "\t\t((P%d *)pptr(h))->_priority = priority;\n", nrRdy);
|
|
fprintf(tc, "#endif\n");
|
|
|
|
fprintf(tc, "\t\treached%d[0] = 1;\n", nrRdy);
|
|
fprintf(tc, "\t\taccpstate[%d][1] = 1;\n", nrRdy);
|
|
}
|
|
fprintf(tc, "\t\tbreak;\n");
|
|
}
|
|
|
|
static void
|
|
multi_init(void)
|
|
{ ProcList *p;
|
|
Element *e;
|
|
int i = nrRdy+1;
|
|
int ini, j;
|
|
int nrc = nclaims;
|
|
|
|
fprintf(tc, "#ifndef NOCLAIM\n");
|
|
fprintf(tc, "\tcase %d: /* claim select */\n", i);
|
|
for (p = rdy, j = 0; p; p = p->nxt, j++)
|
|
{ if (p->b == N_CLAIM)
|
|
{ e = p->s->frst;
|
|
ini = huntele(e, e->status, -1)->seqno;
|
|
|
|
fprintf(tc, "\t\tspin_c_typ[%d] = %d; /* %s */\n",
|
|
j, p->tn, p->n->name);
|
|
fprintf(tc, "\t\t((P%d *)pptr(h))->c_cur[%d] = %d;\n",
|
|
i, j, ini);
|
|
fprintf(tc, "\t\treached%d[%d]=1;\n", p->tn, ini);
|
|
|
|
/* the default initial claim is first one in model */
|
|
if (--nrc == 0)
|
|
{ fprintf(tc, "\t\t((P%d *)pptr(h))->_t = %d;\n", i, p->tn);
|
|
fprintf(tc, "\t\t((P%d *)pptr(h))->_p = %d;\n", i, ini);
|
|
fprintf(tc, "\t\t((P%d *)pptr(h))->_n = %d; /* %s */\n",
|
|
i, j, p->n->name);
|
|
fprintf(tc, "\t\tsrc_claim = src_ln%d;\n", p->tn);
|
|
fprintf(tc, "#ifndef BFS\n");
|
|
fprintf(tc, "\t\tif (whichclaim == -1 && claimname == NULL)\n");
|
|
fprintf(tc, "\t\t\tprintf(\"0: Claim %s (%d), from state %d\\n\");\n",
|
|
p->n->name, p->tn, ini);
|
|
fprintf(tc, "#endif\n");
|
|
}
|
|
} }
|
|
fprintf(tc, "\t\tif (whichclaim != -1)\n");
|
|
fprintf(tc, "\t\t{ select_claim(whichclaim);\n");
|
|
fprintf(tc, "\t\t}\n");
|
|
fprintf(tc, "\t\tbreak;\n\n");
|
|
fprintf(tc, "#endif\n");
|
|
}
|
|
|
|
static void
|
|
put_pinit(ProcList *P)
|
|
{ Lextok *fp, *fpt, *t;
|
|
Element *e = P->s->frst;
|
|
Symbol *s = P->n;
|
|
Lextok *p = P->p;
|
|
int i = P->tn;
|
|
int ini, j, k;
|
|
|
|
if (pid_is_claim(i)
|
|
&& separate == 1)
|
|
{ fprintf(tc, "\tcase %d: /* %s */\n", i, s->name);
|
|
fprintf(tc, "\t\tini_claim(%d, h);\n", i);
|
|
fprintf(tc, "\t\tbreak;\n");
|
|
return;
|
|
}
|
|
if (!pid_is_claim(i)
|
|
&& separate == 2)
|
|
return;
|
|
|
|
ini = huntele(e, e->status, -1)->seqno;
|
|
fprintf(th, "#define _start%d %d\n", i, ini);
|
|
if (i == eventmapnr)
|
|
fprintf(th, "#define start_event %d\n", ini);
|
|
|
|
fprintf(tc, "\tcase %d: /* %s */\n", i, s->name);
|
|
|
|
fprintf(tc, "\t\t((P%d *)pptr(h))->_t = %d;\n", i, i);
|
|
fprintf(tc, "\t\t((P%d *)pptr(h))->_p = %d;\n", i, ini);
|
|
fprintf(tc, "#ifdef HAS_PRIORITY\n");
|
|
|
|
fprintf(tc, "\t\t((P%d *)pptr(h))->_priority = priority; /* was: %d */\n",
|
|
i, (P->priority<1)? 1 : P->priority);
|
|
|
|
fprintf(tc, "#endif\n");
|
|
fprintf(tc, "\t\treached%d[%d]=1;\n", i, ini);
|
|
if (P->b == N_CLAIM)
|
|
{ fprintf(tc, "\t\tsrc_claim = src_ln%d;\n", i);
|
|
}
|
|
|
|
if (has_provided)
|
|
{ fprintf(tt, "\tcase %d: /* %s */\n\t\t", i, s->name);
|
|
if (P->prov)
|
|
{ fprintf(tt, "if (");
|
|
putstmnt(tt, P->prov, 0);
|
|
fprintf(tt, ")\n\t\t\t");
|
|
}
|
|
fprintf(tt, "return 1;\n");
|
|
if (P->prov)
|
|
fprintf(tt, "\t\tbreak;\n");
|
|
}
|
|
|
|
fprintf(tc, "\t\t/* params: */\n");
|
|
for (fp = p, j=0; fp; fp = fp->rgt)
|
|
for (fpt = fp->lft; fpt; fpt = fpt->rgt, j++)
|
|
{ t = (fpt->ntyp == ',') ? fpt->lft : fpt;
|
|
if (t->sym->nel > 1 || t->sym->isarray)
|
|
{ lineno = t->ln;
|
|
Fname = t->fn;
|
|
fatal("array in parameter list, %s",
|
|
t->sym->name);
|
|
}
|
|
fprintf(tc, "\t\t((P%d *)pptr(h))->", i);
|
|
if (t->sym->type == STRUCT)
|
|
{ if (full_name(tc, t, t->sym, 1))
|
|
{ lineno = t->ln;
|
|
Fname = t->fn;
|
|
fatal("hidden array in parameter %s",
|
|
t->sym->name);
|
|
}
|
|
} else
|
|
fprintf(tc, "%s", t->sym->name);
|
|
fprintf(tc, " = par%d;\n", j);
|
|
}
|
|
fprintf(tc, "\t\t/* locals: */\n");
|
|
k = dolocal(tc, "", INIV, i, s->name, P->b);
|
|
if (k > 0)
|
|
{ fprintf(tc, "#ifdef VAR_RANGES\n");
|
|
(void) dolocal(tc, "logval(\"", LOGV, i, s->name, P->b);
|
|
fprintf(tc, "#endif\n");
|
|
}
|
|
|
|
fprintf(tc, "#ifdef HAS_CODE\n");
|
|
fprintf(tc, "\t\tlocinit%d(h);\n", i);
|
|
fprintf(tc, "#endif\n");
|
|
|
|
dumpclaims(tc, i, s->name);
|
|
fprintf(tc, "\t break;\n");
|
|
}
|
|
|
|
Element *
|
|
huntstart(Element *f)
|
|
{ Element *e = f;
|
|
Element *elast = (Element *) 0;
|
|
int cnt = 0;
|
|
|
|
while (elast != e && cnt++ < 200) /* new 4.0.8 */
|
|
{ elast = e;
|
|
if (e->n)
|
|
{ if (e->n->ntyp == '.' && e->nxt)
|
|
e = e->nxt;
|
|
else if (e->n->ntyp == UNLESS)
|
|
e = e->sub->this->frst;
|
|
} }
|
|
|
|
if (cnt >= 200 || !e)
|
|
{ lineno = (f && f->n)?f->n->ln:lineno;
|
|
fatal("confusing control. structure", (char *) 0);
|
|
}
|
|
return e;
|
|
}
|
|
|
|
Element *
|
|
huntele(Element *f, unsigned int o, int stopat)
|
|
{ Element *g, *e = f;
|
|
int cnt=0; /* a precaution against loops */
|
|
|
|
if (e)
|
|
for ( ; cnt < 500 && e->n; cnt++)
|
|
{
|
|
if (e->seqno == stopat)
|
|
break;
|
|
|
|
switch (e->n->ntyp) {
|
|
case GOTO:
|
|
g = get_lab(e->n,1);
|
|
if (e == g)
|
|
{ lineno = (f && f->n)?f->n->ln:lineno;
|
|
fatal("infinite goto loop", (char *) 0);
|
|
}
|
|
cross_dsteps(e->n, g->n);
|
|
break;
|
|
case '.':
|
|
case BREAK:
|
|
if (!e->nxt)
|
|
return e;
|
|
g = e->nxt;
|
|
break;
|
|
case UNLESS:
|
|
g = huntele(e->sub->this->frst, o, stopat);
|
|
if (!g)
|
|
{ fatal("unexpected error 1", (char *) 0);
|
|
}
|
|
break;
|
|
case D_STEP:
|
|
case ATOMIC:
|
|
case NON_ATOMIC:
|
|
default:
|
|
return e;
|
|
}
|
|
if ((o & ATOM) && !(g->status & ATOM))
|
|
return e;
|
|
e = g;
|
|
}
|
|
if (cnt >= 500 || !e)
|
|
{ lineno = (f && f->n)?f->n->ln:lineno;
|
|
fatal("confusing control structure", (char *) 0);
|
|
}
|
|
return e;
|
|
}
|
|
|
|
void
|
|
typ2c(Symbol *sp)
|
|
{ int wsbits = sizeof(long)*8; /* wordsize in bits */
|
|
switch (sp->type) {
|
|
case UNSIGNED:
|
|
if (sp->hidden&1)
|
|
fprintf(th, "\tuchar %s;", sp->name);
|
|
else
|
|
fprintf(th, "\tunsigned %s : %d",
|
|
sp->name, sp->nbits);
|
|
LstSet = sp;
|
|
if (nBits%wsbits > 0
|
|
&& wsbits - nBits%wsbits < sp->nbits)
|
|
{ /* must padd to a word-boundary */
|
|
nBits += wsbits - nBits%wsbits;
|
|
}
|
|
nBits += sp->nbits;
|
|
break;
|
|
case BIT:
|
|
if (sp->nel == 1 && sp->isarray == 0 && !(sp->hidden&1))
|
|
{ fprintf(th, "\tunsigned %s : 1", sp->name);
|
|
LstSet = sp;
|
|
nBits++;
|
|
break;
|
|
} /* else fall through */
|
|
if (!(sp->hidden&1) && (verbose&32))
|
|
printf("spin: warning: bit-array %s[%d] mapped to byte-array\n",
|
|
sp->name, sp->nel);
|
|
nBits += 8*sp->nel; /* mapped onto array of uchars */
|
|
case MTYPE:
|
|
case BYTE:
|
|
case CHAN: /* good for up to 255 channels */
|
|
fprintf(th, "\tuchar %s", sp->name);
|
|
LstSet = sp;
|
|
break;
|
|
case SHORT:
|
|
fprintf(th, "\tshort %s", sp->name);
|
|
LstSet = sp;
|
|
break;
|
|
case INT:
|
|
fprintf(th, "\tint %s", sp->name);
|
|
LstSet = sp;
|
|
break;
|
|
case STRUCT:
|
|
if (!sp->Snm)
|
|
fatal("undeclared structure element %s", sp->name);
|
|
fprintf(th, "\tstruct %s %s",
|
|
sp->Snm->name,
|
|
sp->name);
|
|
LstSet = ZS;
|
|
break;
|
|
case CODE_FRAG:
|
|
case PREDEF:
|
|
return;
|
|
default:
|
|
fatal("variable %s undeclared", sp->name);
|
|
}
|
|
|
|
if (sp->nel > 1 || sp->isarray)
|
|
fprintf(th, "[%d]", sp->nel);
|
|
fprintf(th, ";\n");
|
|
}
|
|
|
|
static void
|
|
ncases(FILE *fd, int p, int n, int m, const char *c[])
|
|
{ int i, j;
|
|
|
|
for (j = 0; c[j]; j++)
|
|
for (i = n; i < m; i++)
|
|
{ fprintf(fd, c[j], i, p, i);
|
|
fprintf(fd, "\n");
|
|
}
|
|
}
|
|
|
|
void
|
|
qlen_type(int qmax)
|
|
{
|
|
fprintf(th, "\t");
|
|
if (qmax < 256)
|
|
fprintf(th, "uchar");
|
|
else if (qmax < 65535)
|
|
fprintf(th, "ushort");
|
|
else
|
|
fprintf(th, "uint");
|
|
fprintf(th, " Qlen; /* q_size */\n");
|
|
}
|
|
|
|
void
|
|
genaddqueue(void)
|
|
{ char buf0[256];
|
|
int j, qmax = 0;
|
|
Queue *q;
|
|
|
|
ntimes(tc, 0, 1, Addq0);
|
|
|
|
if (has_io && !nqs)
|
|
fprintf(th, "#define NQS 1 /* nqs=%d, but has_io */\n", nqs);
|
|
else
|
|
fprintf(th, "#define NQS %d\n", nqs);
|
|
|
|
for (q = qtab; q; q = q->nxt)
|
|
if (q->nslots > qmax)
|
|
qmax = q->nslots;
|
|
|
|
for (q = qtab; q; q = q->nxt)
|
|
{ j = q->qid;
|
|
fprintf(tc, "\tcase %d: j = sizeof(Q%d);", j, j);
|
|
fprintf(tc, " q_flds[%d] = %d;", j, q->nflds);
|
|
fprintf(tc, " q_max[%d] = %d;", j, max(1,q->nslots));
|
|
fprintf(tc, " break;\n");
|
|
|
|
fprintf(th, "typedef struct Q%d {\n", j);
|
|
qlen_type(qmax); /* 4.2.2 */
|
|
fprintf(th, " uchar _t; /* q_type */\n");
|
|
fprintf(th, " struct {\n");
|
|
|
|
for (j = 0; j < q->nflds; j++)
|
|
{ switch (q->fld_width[j]) {
|
|
case BIT:
|
|
if (q->nflds != 1)
|
|
{ fprintf(th, "\t\tunsigned");
|
|
fprintf(th, " fld%d : 1;\n", j);
|
|
break;
|
|
} /* else fall through: smaller struct */
|
|
case MTYPE:
|
|
case CHAN:
|
|
case BYTE:
|
|
fprintf(th, "\t\tuchar fld%d;\n", j);
|
|
break;
|
|
case SHORT:
|
|
fprintf(th, "\t\tshort fld%d;\n", j);
|
|
break;
|
|
case INT:
|
|
fprintf(th, "\t\tint fld%d;\n", j);
|
|
break;
|
|
default:
|
|
fatal("bad channel spec", "");
|
|
}
|
|
}
|
|
fprintf(th, " } contents[%d];\n", max(1, q->nslots));
|
|
fprintf(th, "} Q%d;\n", q->qid);
|
|
}
|
|
|
|
fprintf(th, "typedef struct Q0 {\t/* generic q */\n");
|
|
qlen_type(qmax); /* 4.2.2 */
|
|
fprintf(th, " uchar _t;\n");
|
|
fprintf(th, "} Q0;\n");
|
|
|
|
ntimes(tc, 0, 1, Addq1);
|
|
|
|
fprintf(tc, "#ifdef TRIX\n");
|
|
fprintf(tc, "int\nwhat_p_size(int t)\n{\tint j;\n");
|
|
fprintf(tc, " switch (t) {\n");
|
|
ntimes(tc, 0, nrRdy+1, R5); /* +1 for np_ */
|
|
fprintf(tc, " default: Uerror(\"bad proctype\");\n");
|
|
fprintf(tc, " }\n return j;\n}\n\n");
|
|
|
|
fprintf(tc, "int\nwhat_q_size(int t)\n{\tint j;\n");
|
|
fprintf(tc, " switch (t) {\n");
|
|
for (j = 0; j < nqs+1; j++)
|
|
{ fprintf(tc, " case %d: j = sizeof(Q%d); break;\n", j, j);
|
|
}
|
|
fprintf(tc, " default: Uerror(\"bad qtype\");\n");
|
|
fprintf(tc, " }\n return j;\n}\n");
|
|
fprintf(tc, "#endif\n\n");
|
|
|
|
if (has_random)
|
|
{ fprintf(th, "int Q_has(int");
|
|
for (j = 0; j < Mpars; j++)
|
|
fprintf(th, ", int, int");
|
|
fprintf(th, ");\n");
|
|
|
|
fprintf(tc, "int\nQ_has(int into");
|
|
for (j = 0; j < Mpars; j++)
|
|
fprintf(tc, ", int want%d, int fld%d", j, j);
|
|
fprintf(tc, ")\n");
|
|
fprintf(tc, "{ int i;\n\n");
|
|
fprintf(tc, " if (!into--)\n");
|
|
fprintf(tc, " uerror(\"ref to unknown chan ");
|
|
fprintf(tc, "(recv-poll)\");\n\n");
|
|
fprintf(tc, " if (into >= now._nr_qs || into < 0)\n");
|
|
fprintf(tc, " Uerror(\"qrecv bad queue#\");\n\n");
|
|
fprintf(tc, " for (i = 0; i < ((Q0 *)qptr(into))->Qlen;");
|
|
fprintf(tc, " i++)\n");
|
|
fprintf(tc, " {\n");
|
|
for (j = 0; j < Mpars; j++)
|
|
{ fprintf(tc, " if (want%d && ", j);
|
|
fprintf(tc, "qrecv(into+1, i, %d, 0) != fld%d)\n",
|
|
j, j);
|
|
fprintf(tc, " continue;\n");
|
|
}
|
|
fprintf(tc, " return i+1;\n");
|
|
fprintf(tc, " }\n");
|
|
fprintf(tc, " return 0;\n");
|
|
fprintf(tc, "}\n");
|
|
}
|
|
|
|
fprintf(tc, "#if NQS>0\n");
|
|
fprintf(tc, "void\nqsend(int into, int sorted");
|
|
for (j = 0; j < Mpars; j++)
|
|
fprintf(tc, ", int fld%d", j);
|
|
fprintf(tc, ", int args_given)\n");
|
|
ntimes(tc, 0, 1, Addq11);
|
|
|
|
for (q = qtab; q; q = q->nxt)
|
|
{ sprintf(buf0, "((Q%d *)z)->", q->qid);
|
|
fprintf(tc, "\tcase %d:%s\n", q->qid,
|
|
(q->nslots)?"":" /* =rv= */");
|
|
if (q->nslots == 0) /* reset handshake point */
|
|
fprintf(tc, "\t\t(trpt+2)->o_m = 0;\n");
|
|
|
|
if (has_sorted)
|
|
{ fprintf(tc, "\t\tif (!sorted) goto append%d;\n", q->qid);
|
|
fprintf(tc, "\t\tfor (j = 0; j < %sQlen; j++)\n", buf0);
|
|
fprintf(tc, "\t\t{\t/* find insertion point */\n");
|
|
sprintf(buf0, "((Q%d *)z)->contents[j].fld", q->qid);
|
|
for (j = 0; j < q->nflds; j++)
|
|
{ fprintf(tc, "\t\t\tif (fld%d > %s%d) continue;\n",
|
|
j, buf0, j);
|
|
fprintf(tc, "\t\t\tif (fld%d < %s%d) ", j, buf0, j);
|
|
fprintf(tc, "goto found%d;\n\n", q->qid);
|
|
}
|
|
fprintf(tc, "\t\t}\n");
|
|
fprintf(tc, "\tfound%d:\n", q->qid);
|
|
sprintf(buf0, "((Q%d *)z)->", q->qid);
|
|
fprintf(tc, "\t\tfor (k = %sQlen - 1; k >= j; k--)\n", buf0);
|
|
fprintf(tc, "\t\t{\t/* shift up */\n");
|
|
for (j = 0; j < q->nflds; j++)
|
|
{ fprintf(tc, "\t\t\t%scontents[k+1].fld%d = ",
|
|
buf0, j);
|
|
fprintf(tc, "%scontents[k].fld%d;\n",
|
|
buf0, j);
|
|
}
|
|
fprintf(tc, "\t\t}\n");
|
|
fprintf(tc, "\tappend%d:\t/* insert in slot j */\n", q->qid);
|
|
}
|
|
|
|
fprintf(tc, "#ifdef HAS_SORTED\n");
|
|
fprintf(tc, "\t\t(trpt+1)->ipt = j;\n"); /* ipt was bup.oval */
|
|
fprintf(tc, "#endif\n");
|
|
fprintf(tc, "\t\t%sQlen = %sQlen + 1;\n", buf0, buf0);
|
|
sprintf(buf0, "((Q%d *)z)->contents[j].fld", q->qid);
|
|
for (j = 0; j < q->nflds; j++)
|
|
fprintf(tc, "\t\t%s%d = fld%d;\n", buf0, j, j);
|
|
fprintf(tc, "\t\tif (args_given != %d)\n", q->nflds);
|
|
fprintf(tc, "\t\t{ if (args_given > %d)\n", q->nflds);
|
|
fprintf(tc, "\t\t uerror(\"too many parameters in send stmnt\");\n");
|
|
fprintf(tc, "\t\t else\n");
|
|
fprintf(tc, "\t\t uerror(\"too few parameters in send stmnt\");\n");
|
|
fprintf(tc, "\t\t}\n");
|
|
fprintf(tc, "\t\tbreak;\n");
|
|
}
|
|
ntimes(tc, 0, 1, Addq2);
|
|
|
|
for (q = qtab; q; q = q->nxt)
|
|
fprintf(tc, "\tcase %d: return %d;\n", q->qid, (!q->nslots));
|
|
|
|
ntimes(tc, 0, 1, Addq3);
|
|
|
|
for (q = qtab; q; q = q->nxt)
|
|
fprintf(tc, "\tcase %d: return (q_sz(from) == %d);\n",
|
|
q->qid, max(1, q->nslots));
|
|
|
|
ntimes(tc, 0, 1, Addq4);
|
|
for (q = qtab; q; q = q->nxt)
|
|
{ sprintf(buf0, "((Q%d *)z)->", q->qid);
|
|
fprintf(tc, " case %d:%s\n\t\t",
|
|
q->qid, (q->nslots)?"":" /* =rv= */");
|
|
if (q->nflds == 1)
|
|
{ fprintf(tc, "if (fld == 0) r = %s", buf0);
|
|
fprintf(tc, "contents[slot].fld0;\n");
|
|
} else
|
|
{ fprintf(tc, "switch (fld) {\n");
|
|
ncases(tc, q->qid, 0, q->nflds, R12);
|
|
fprintf(tc, "\t\tdefault: Uerror");
|
|
fprintf(tc, "(\"too many fields in recv\");\n");
|
|
fprintf(tc, "\t\t}\n");
|
|
}
|
|
fprintf(tc, "\t\tif (done)\n");
|
|
if (q->nslots == 0)
|
|
{ fprintf(tc, "\t\t{ j = %sQlen - 1;\n", buf0);
|
|
fprintf(tc, "\t\t %sQlen = 0;\n", buf0);
|
|
sprintf(buf0, "\t\t\t((Q%d *)z)->contents", q->qid);
|
|
} else
|
|
{ fprintf(tc, "\t\t{ j = %sQlen;\n", buf0);
|
|
fprintf(tc, "\t\t %sQlen = --j;\n", buf0);
|
|
fprintf(tc, "\t\t for (k=slot; k<j; k++)\n");
|
|
fprintf(tc, "\t\t {\n");
|
|
sprintf(buf0, "\t\t\t((Q%d *)z)->contents", q->qid);
|
|
for (j = 0; j < q->nflds; j++)
|
|
{ fprintf(tc, "\t%s[k].fld%d = \n", buf0, j);
|
|
fprintf(tc, "\t\t%s[k+1].fld%d;\n", buf0, j);
|
|
}
|
|
fprintf(tc, "\t\t }\n");
|
|
}
|
|
|
|
for (j = 0; j < q->nflds; j++)
|
|
fprintf(tc, "%s[j].fld%d = 0;\n", buf0, j);
|
|
fprintf(tc, "\t\t\tif (fld+1 != %d)\n\t\t\t", q->nflds);
|
|
fprintf(tc, "\tuerror(\"missing pars in receive\");\n");
|
|
/* incompletely received msgs cannot be unrecv'ed */
|
|
fprintf(tc, "\t\t}\n");
|
|
fprintf(tc, "\t\tbreak;\n");
|
|
}
|
|
ntimes(tc, 0, 1, Addq5);
|
|
for (q = qtab; q; q = q->nxt)
|
|
fprintf(tc, " case %d: j = sizeof(Q%d); break;\n",
|
|
q->qid, q->qid);
|
|
ntimes(tc, 0, 1, R8b);
|
|
ntimes(th, 0, 1, Proto); /* function prototypes */
|
|
|
|
fprintf(th, "void qsend(int, int");
|
|
for (j = 0; j < Mpars; j++)
|
|
fprintf(th, ", int");
|
|
fprintf(th, ", int);\n\n");
|
|
|
|
fprintf(th, "#define Addproc(x,y) addproc(256, y, x");
|
|
/* 256 is param outside the range of valid pids */
|
|
for (j = 0; j < Npars; j++)
|
|
fprintf(th, ", 0");
|
|
fprintf(th, ")\n");
|
|
}
|