/* determine the initializer type corresponding to an expression */
static int
inittype(ASTNode *n)
{
if(n == nil) return SINONE;
switch(n->t) {
case ASTCINT:
case ASTCONST:
return SINONE;
case ASTDEFAULT:
return SIDEF;
case ASTSYMB:
if(n->sym == nil || n->sym->clock == nil)
return SIINVAL;
switch(n->sym->clock->t) {
case ASTASYNC:
return SIASYNC;
default:
return SISYNC;
}
case ASTOP:
return initjoin(inittype(n->n1), inittype(n->n2));
case ASTTERN:
return initjoin(initjoin(inittype(n->n1), inittype(n->n2)), inittype(n->n3));
default:
error(n, "exprtype: unknown %A", n->t);
return SIINVAL;
}
}
DL_EXPORT(void) initproperties()
{
PyObject *m, *d;
m = Py_InitModule("properties", (PyMethodDef*) module_methods);
d = PyModule_GetDict(m);
PyModule_AddConstants(d,&module_constants[0]);
inittype("Property", m, &tProperty, &property_constants[0]);
}
/* process all initial blocks */
static void
initial(SemDefs *glob)
{
Nodes *r, *s;
int t;
for(r = initbl; r != nil; r = r->next) {
for(s = r->n->nl; s != nil; s = s->next) {
t = inittype(s->n);
if(t == SIINVAL || t == SINONE)
error(s->n, "'%n' not a valid trigger", s->n);
}
initial1(r->n->n1, r->n->nl, glob);
}
}
/* process statement in initial block with triggers tr,
creating SemInit structures for all triggers. */
static void
initial1(ASTNode *n, Nodes *tr, SemDefs *glob)
{
Nodes *r;
SemVar *v;
SemInit *si, **p;
int t;
if(n == nil) return;
switch(n->t) {
case ASTASS:
assert(n->n1 != nil);
if(n->n1->t != ASTSYMB) {
error(n, "initial1: unknown lval %A", n->n1->t);
return;
}
assert(n->n1->sym != nil);
v = n->n1->sym->semc[0];
assert(v != nil);
if((v->flags & SVREG) == 0) {
warn(n, "'%s' initial assignment ignored", v->sym->name);
break;
}
for(r = tr; r != nil; r = r->next) {
t = inittype(r->n);
if(t == SIINVAL || t == SINONE) continue;
for(p = &v->init; *p != nil; p = &(*p)->vnext)
if(nodeeq((*p)->trigger, r->n, nodeeq)) {
error(n, "'%s' conflicting initial value", v->sym->name);
break;
}
if(*p != nil) continue;
si = emalloc(sizeof(SemInit));
si->trigger = onlyone(ssabuildbl(r->n, glob, 0));
si->type = t;
si->var = v;
si->val = n->n2;
*p = si;
}
break;
case ASTBLOCK:
for(r = n->nl; r != nil; r = r->next)
initial1(r->n, tr, glob);
break;
default:
error(n, "initial1: unknown %A", n->t);
}
}
