List*
prefixdup(List* prefix)
{
List* dupseq;
int i;
if(prefix == NULL) return listnew();
dupseq = listnew();
listsetalloc(dupseq,listlength(prefix));
for(i=0;i<listlength(prefix);i++) listpush(dupseq,listget(prefix,i));
return dupseq;
}
int
ropa_init (unsigned num_cb, unsigned num_cli, unsigned num_cc,
unsigned hashsz_cb, unsigned hashsz_cli, unsigned hashsz_cc)
{
ht_callbacks = hashtabnew (hashsz_cb, callbacks_cmp, callbacks_hash);
if (ht_callbacks == NULL)
errx (1, "ropa_init: failed to create hashtable for callbacks");
ht_clients_ip = hashtabnew (hashsz_cli, clients_cmp_ip, clients_hash_ip);
if (ht_clients_ip == NULL)
errx (1, "ropa_init: failed to create hashtable for clients_ip");
ht_clients_uuid = hashtabnew (hashsz_cli, clients_cmp_uuid,
clients_hash_uuid);
if (ht_clients_uuid == NULL)
errx (1, "ropa_init: failed to create hashtable for clients_uuid");
ht_ccpairs = hashtabnew (hashsz_cc, ccpairs_cmp,
ccpairs_hash);
if (ht_ccpairs == NULL)
errx (1, "ropa_init: failed to create hashtable for ccpairs");
lru_clients = listnew ();
if (lru_clients == NULL)
errx (1, "ropa_init: failed to create lru for clients");
lru_ccpair = listnew ();
if (lru_ccpair == NULL)
errx (1, "ropa_init: failed to create list for ccpairs");
lru_callback = listnew ();
if (lru_callback == NULL)
errx (1, "ropa_init: failed to create list for callback");
heap_ccpairs = heap_new (num_cc, ccpair_cmp_time);
if (heap_ccpairs == NULL)
errx (1, "ropa_init: failed to create heap for ccpairs");
create_clients(num_cli);
create_callbacks(num_cb);
create_ccpairs(num_cc);
uuid_init_simple (&server_uuid, 0x82ED305E);
if (LWP_CreateProcess (heapcleaner, ROPA_STACKSIZE, 1,
NULL, "heap-invalidator", &cleaner_pid))
errx (1, "ropa_init: LWP_CreateProcess failed");
debuglevel = mlog_log_get_level_num(); /* XXX */
return 0;
}
/*
Locate enums whose name is a prefix of ident
and contains the suffix as an enum const
and capture that enum constant.
*/
static List*
findecmatches(char* ident)
{
List* matches = listnew();
int i;
for(i=0;i<listlength(typdefs);i++) {
int len;
Symbol* ec;
Symbol* en = (Symbol*)listget(typdefs,i);
if(en->subclass != NC_ENUM)
continue;
/* First, assume that the ident is the econst name only */
ec = checkeconst(en,ident);
if(ec != NULL)
listpush(matches,ec);
/* Second, do the prefix check */
len = strlen(en->name);
if(strncmp(ident,en->name,len) == 0) {
Symbol *ec;
/* Find the matching ec constant, if any */
if(*(ident+len) != '.') continue;
ec = checkeconst(en,ident+len+1); /* +1 for the dot */
if(ec != NULL)
listpush(matches,ec);
}
}
if(listlength(matches) == 0) {
listfree(matches);
matches = NULL;
}
return matches;
}
static void
create_clients (unsigned n)
{
struct ropa_client *c;
unsigned long i;
c = calloc (n, sizeof (*c));
if (c == NULL)
err (1, "create_clients: calloc");
for (i = 0 ; i < n; i++) {
#ifdef DIAGNOSTIC
c[i].magic = DIAGNOSTIC_CLIENT;
{
int j;
for (j = 0; j < sizeof(c->addr)/sizeof(c->addr[0]); j++)
c[i].addr[j].magic = DIAGNOSTIC_ADDR;
}
#endif
c[i].port = 0;
c[i].lastseen = 0;
c[i].callbacks = listnew();
if (c[i].callbacks == NULL)
err (1, "create_clients: listnew");
c[i].ref = 0;
c[i].state = ROPAC_FREE;
c[i].li = listaddtail (lru_clients, &c[i]);
}
num_clients += n;
}
void
mnode_init (unsigned num)
{
struct mnode *nodes = calloc (sizeof(struct mnode), num);
int i;
mnode_numfree = mnode_nodes = num;
if (nodes == NULL)
errx (1, "mnode_init: calloc failed");
mnode_lru = listnew();
if (mnode_lru == NULL)
errx (1, "mnode_init: listnew returned NULL");
for (i = 0; i < num ;i++) {
nodes[i].li = listaddhead (mnode_lru, &nodes[i]);
assert(nodes[i].li);
}
mnode_htab = hashtabnew (num * 2, /* XXX */
mnode_cmp,
mnode_hash);
if (mnode_htab == NULL)
errx (1, "mnode_init: hashtabnew returned NULL");
}
static void
processenums(void)
{
unsigned long i,j;
#if 0 /* Unused? */
List* enumids = listnew();
#endif
for(i=0;i<listlength(typdefs);i++) {
Symbol* sym = (Symbol*)listget(typdefs,i);
ASSERT(sym->objectclass == NC_TYPE);
if(sym->subclass != NC_ENUM) continue;
for(j=0;j<listlength(sym->subnodes);j++) {
Symbol* esym = (Symbol*)listget(sym->subnodes,j);
ASSERT(esym->subclass == NC_ECONST);
#if 0 /* Unused? */
listpush(enumids,(void*)esym);
#endif
}
}
/* Convert enum values to match enum type*/
for(i=0;i<listlength(typdefs);i++) {
Symbol* tsym = (Symbol*)listget(typdefs,i);
ASSERT(tsym->objectclass == NC_TYPE);
if(tsym->subclass != NC_ENUM) continue;
for(j=0;j<listlength(tsym->subnodes);j++) {
Symbol* esym = (Symbol*)listget(tsym->subnodes,j);
NCConstant* newec = nullconst();
ASSERT(esym->subclass == NC_ECONST);
newec->nctype = esym->typ.typecode;
convert1(esym->typ.econst,newec);
reclaimconstant(esym->typ.econst);
esym->typ.econst = newec;
}
}
}
static void
processattributes(void)
{
int i,j;
/* process global attributes*/
for(i=0;i<listlength(gattdefs);i++) {
Symbol* asym = (Symbol*)listget(gattdefs,i);
/* If the attribute has a zero length, then default it */
if(asym->data == NULL || asym->data->length == 0) {
asym->data = builddatalist(1);
emptystringconst(asym->lineno,&asym->data->data[asym->data->length]);
/* force type to be NC_CHAR */
asym->typ.basetype = primsymbols[NC_CHAR];
}
if(asym->typ.basetype == NULL) inferattributetype(asym);
/* fill in the typecode*/
asym->typ.typecode = asym->typ.basetype->typ.typecode;
}
/* process per variable attributes*/
for(i=0;i<listlength(attdefs);i++) {
Symbol* asym = (Symbol*)listget(attdefs,i);
/* If the attribute has a zero length, then default it */
if(asym->data == NULL || asym->data->length == 0) {
asym->data = builddatalist(1);
emptystringconst(asym->lineno,&asym->data->data[asym->data->length]);
/* force type to be NC_CHAR */
asym->typ.basetype = primsymbols[NC_CHAR];
}
/* If no basetype is specified, then try to infer it;
the exception if _Fillvalue, whose type is that of the
containing variable.
*/
if(strcmp(asym->name,specialname(_FILLVALUE_FLAG)) == 0) {
/* This is _Fillvalue */
asym->typ.basetype = asym->att.var->typ.basetype; /* its basetype is same as its var*/
/* put the datalist into the specials structure */
if(asym->data == NULL) {
/* Generate a default fill value */
asym->data = getfiller(asym->typ.basetype);
}
asym->att.var->var.special._Fillvalue = asym->data;
} else if(asym->typ.basetype == NULL) {
inferattributetype(asym);
}
/* fill in the typecode*/
asym->typ.typecode = asym->typ.basetype->typ.typecode;
}
/* collect per-variable attributes per variable*/
for(i=0;i<listlength(vardefs);i++) {
Symbol* vsym = (Symbol*)listget(vardefs,i);
List* list = listnew();
for(j=0;j<listlength(attdefs);j++) {
Symbol* asym = (Symbol*)listget(attdefs,j);
ASSERT(asym->att.var != NULL);
if(asym->att.var != vsym) continue;
listpush(list,(void*)asym);
}
vsym->var.attributes = list;
}
}
List*
listclone(List* l)
{
List* clone = listnew();
*clone = *l;
clone->content = listdup(l);
return clone;
}
void
chunkspecinit(void)
{
/* initialization */
if(varchunkspecs == NULL)
varchunkspecs = listnew();
memset(&dimchunkspecs,0,sizeof(dimchunkspecs));
}
static listnode* findMaxima(const imImage* hough_points, int *line_count, const imImage* hough)
{
int x, y, xsize, ysize, rhomax, offset, rho_delta = 0;
listnode* maxima = NULL, *cur_node = NULL;
point pt;
imbyte *map = (imbyte*)hough_points->data[0];
int *hough_map = NULL;
xsize = hough_points->width; /* X = theta */
ysize = hough_points->height; /* Y = rho */
rhomax = ysize/2;
if (hough)
{
hough_map = (int*)hough->data[0];
rho_delta = (int)(rhomax*tan(THETA_DELTA1));
}
for (y=0; y < ysize; y++)
{
for (x=0; x < xsize; x++)
{
offset = y*xsize + x;
if (map[offset])
{
pt.theta = x;
pt.rho = y-rhomax;
if (!maxima)
{
cur_node = maxima = listnew(&pt);
(*line_count)++;
}
else
{
if (hough_map)
{
listnode* old_node = cur_node;
pt.count = hough_map[offset];
cur_node = listadd_filtered(maxima, cur_node, &pt, rho_delta);
if (cur_node != old_node)
(*line_count)++;
}
else
{
cur_node = listadd(cur_node, &pt);
(*line_count)++;
}
}
}
}
}
return maxima;
}
int
vld_init (void)
{
struct dp_part *dp;
int ret, partnum, i;
db_lru = listnew();
if (db_lru == NULL)
errx (1, "vld_init: db_lru == NULL");
for (i = 0; i < 100 /* XXX */ ; i++)
listaddhead (db_lru, NULL);
vol_list = listnew();
if (vol_list == NULL)
errx (1, "vld_init: vol_list == NULL");
volume_htab = hashtabnew(volume_htab_sz, volume_cmp, volume_hash);
if (volume_htab == NULL)
errx (1, "vld_init: volume_htab == NULL");
for (partnum = 0; partnum < 'z'-'a'; partnum++) {
ret = dp_create (partnum , &dp);
if (ret) {
warnx ("vld_init: dp_create(%d) returned %d", partnum, ret);
continue;
}
ret = dp_findvol (dp, register_vols_cb, dp);
if (ret)
warnx ("vld_init: dp_findvol returned: %d", ret);
dp_free (dp);
}
return 0;
}
void
conn_init (unsigned nentries)
{
arla_warnx (ADEBCONN, "initconncache");
connhtab = hashtabnew (CONNCACHESIZE, conncmp, connhash);
if (connhtab == NULL)
arla_errx (1, ADEBERROR, "conn_init: hashtabnew failed");
connfreelist = listnew ();
if (connfreelist == NULL)
arla_errx (1, ADEBERROR, "conn_init: listnew failed");
connprobelist = listnew ();
if (connprobelist == NULL)
arla_errx (1, ADEBERROR, "conn_init: listnew failed");
nconnections = 0;
if (LWP_CreateProcess (pinger, PINGER_STACKSIZE, 1,
NULL, "pinger", &pinger_pid))
arla_errx (1, ADEBERROR,
"conn: cannot create pinger thread");
create_new_connections (nentries);
}
static t_lex *addlist(t_lex *list, char *str)
{
t_lex *tmp;
tmp = listnew(str);
if (!list)
return (tmp);
else
{
tmp->prev = list->prev;
list->prev->next = tmp;
tmp->next = list;
list->prev = tmp;
}
return (list);
}
static listnode* listadd_filtered(listnode* list, listnode* cur_node, point *pt, int rho_delta)
{
int ret;
listnode* lt = list;
while (lt)
{
ret = ptNear(<->pt, pt, rho_delta);
if (ret)
{
if (ret == 2)
lt->pt = *pt; /* replace the line */
return cur_node;
}
lt = lt->next;
}
cur_node->next = listnew(pt);
return cur_node->next;
}
static void
processenums(void)
{
int i,j;
List* enumids = listnew();
for(i=0;i<listlength(typdefs);i++) {
Symbol* sym = (Symbol*)listget(typdefs,i);
ASSERT(sym->objectclass == NC_TYPE);
if(sym->subclass != NC_ENUM) continue;
for(j=0;j<listlength(sym->subnodes);j++) {
Symbol* esym = (Symbol*)listget(sym->subnodes,j);
ASSERT(esym->subclass == NC_ECONST);
listpush(enumids,(void*)esym);
}
}
/* Now walk set of enum ids to look for duplicates with same prefix*/
for(i=0;i<listlength(enumids);i++) {
Symbol* sym1 = (Symbol*)listget(enumids,i);
for(j=i+1;j<listlength(enumids);j++) {
Symbol* sym2 = (Symbol*)listget(enumids,j);
if(strcmp(sym1->name,sym2->name) != 0) continue;
if(!prefixeq(sym1->prefix,sym2->prefix)) continue;
semerror(sym1->lineno,"Duplicate enumeration ids in same scope: %s",
fullname(sym1));
}
}
/* Convert enum values to match enum type*/
for(i=0;i<listlength(typdefs);i++) {
Symbol* tsym = (Symbol*)listget(typdefs,i);
ASSERT(tsym->objectclass == NC_TYPE);
if(tsym->subclass != NC_ENUM) continue;
for(j=0;j<listlength(tsym->subnodes);j++) {
Symbol* esym = (Symbol*)listget(tsym->subnodes,j);
Constant newec;
ASSERT(esym->subclass == NC_ECONST);
newec.nctype = esym->typ.typecode;
convert1(&esym->typ.econst,&newec);
esym->typ.econst = newec;
}
}
}
static void
create_callbacks (unsigned n)
{
struct ropa_cb *c;
int i;
c = malloc (n * sizeof (*c));
if (c == NULL)
err (1, "create_callbacks: malloc");
memset (c, 0, n * sizeof (*c));
for (i = 0; i < n ; i++) {
#ifdef DIAGNOSTIC
c[i].magic = DIAGNOSTIC_CALLBACK;
#endif
c[i].ccpairs = listnew();
if (c[i].ccpairs == NULL)
err (1, "create_callbacks: listnew");
c[i].li = listaddtail (lru_callback, &c[i]);
}
num_callbacks += n;
}
static List*
ecsearchgrp(Symbol* grp, List* candidates)
{
List* matches = listnew();
int i,j;
/* do the intersection of grp subnodes and candidates */
for(i=0;i<listlength(grp->subnodes);i++) {
Symbol* sub= (Symbol*)listget(grp->subnodes,i);
if(sub->subclass != NC_ENUM)
continue;
for(j=0;j<listlength(candidates);j++) {
Symbol* ec = (Symbol*)listget(candidates,j);
if(ec->container == sub)
listpush(matches,ec);
}
}
if(listlength(matches) == 0) {
listfree(matches);
matches = NULL;
}
return matches;
}
static listnode* listadd(listnode* node, point *pt)
{
node->next = listnew(pt);
return node->next;
}
static void
processattributes(void)
{
int i,j;
/* process global attributes*/
for(i=0;i<listlength(gattdefs);i++) {
Symbol* asym = (Symbol*)listget(gattdefs,i);
if(asym->typ.basetype == NULL) inferattributetype(asym);
/* fill in the typecode*/
asym->typ.typecode = asym->typ.basetype->typ.typecode;
if(asym->data != NULL && asym->data->length == 0) {
NCConstant* empty = NULL;
/* If the attribute has a zero length, then default it;
note that it must be of type NC_CHAR */
if(asym->typ.typecode != NC_CHAR)
semerror(asym->lineno,"Empty datalist can only be assigned to attributes of type char",fullname(asym));
empty = emptystringconst(asym->lineno);
dlappend(asym->data,empty);
}
validateNIL(asym);
}
/* process per variable attributes*/
for(i=0;i<listlength(attdefs);i++) {
Symbol* asym = (Symbol*)listget(attdefs,i);
/* If no basetype is specified, then try to infer it;
the exception is _Fillvalue, whose type is that of the
containing variable.
*/
if(strcmp(asym->name,specialname(_FILLVALUE_FLAG)) == 0) {
/* This is _Fillvalue */
asym->typ.basetype = asym->att.var->typ.basetype; /* its basetype is same as its var*/
/* put the datalist into the specials structure */
if(asym->data == NULL) {
/* Generate a default fill value */
asym->data = getfiller(asym->typ.basetype);
}
if(asym->att.var->var.special->_Fillvalue != NULL)
reclaimdatalist(asym->att.var->var.special->_Fillvalue);
asym->att.var->var.special->_Fillvalue = clonedatalist(asym->data);
} else if(asym->typ.basetype == NULL) {
inferattributetype(asym);
}
/* fill in the typecode*/
asym->typ.typecode = asym->typ.basetype->typ.typecode;
if(asym->data->length == 0) {
NCConstant* empty = NULL;
/* If the attribute has a zero length, and is char type, then default it */
if(asym->typ.typecode != NC_CHAR)
semerror(asym->lineno,"Empty datalist can only be assigned to attributes of type char",fullname(asym));
empty = emptystringconst(asym->lineno);
dlappend(asym->data,empty);
}
validateNIL(asym);
}
/* collect per-variable attributes per variable*/
for(i=0;i<listlength(vardefs);i++) {
Symbol* vsym = (Symbol*)listget(vardefs,i);
List* list = listnew();
for(j=0;j<listlength(attdefs);j++) {
Symbol* asym = (Symbol*)listget(attdefs,j);
if(asym->att.var == NULL)
continue; /* ignore globals for now */
if(asym->att.var != vsym) continue;
listpush(list,(void*)asym);
}
vsym->var.attributes = list;
}
}
/* 3. mark types that use vlen*/
static void
processtypes(void)
{
unsigned long i,j;
int keep,added;
List* sorted = listnew(); /* hold re-ordered type set*/
/* Prime the walk by capturing the set*/
/* of types that are dependent on primitive types*/
/* e.g. uint vlen(*) or primitive types*/
for(i=0;i<listlength(typdefs);i++) {
Symbol* sym = (Symbol*)listget(typdefs,i);
keep=0;
switch (sym->subclass) {
case NC_PRIM: /*ignore pre-defined primitive types*/
sym->touched=1;
break;
case NC_OPAQUE:
case NC_ENUM:
keep=1;
break;
case NC_VLEN: /* keep if its basetype is primitive*/
if(sym->typ.basetype->subclass == NC_PRIM) keep=1;
break;
case NC_COMPOUND: /* keep if all fields are primitive*/
keep=1; /*assume all fields are primitive*/
for(j=0;j<listlength(sym->subnodes);j++) {
Symbol* field = (Symbol*)listget(sym->subnodes,j);
ASSERT(field->subclass == NC_FIELD);
if(field->typ.basetype->subclass != NC_PRIM) {keep=0;break;}
}
break;
default: break;/* ignore*/
}
if(keep) {
sym->touched = 1;
listpush(sorted,(void*)sym);
}
}
/* 2. repeated walk to collect level i types*/
do {
added=0;
for(i=0;i<listlength(typdefs);i++) {
Symbol* sym = (Symbol*)listget(typdefs,i);
if(sym->touched) continue; /* ignore already processed types*/
keep=0; /* assume not addable yet.*/
switch (sym->subclass) {
case NC_PRIM:
case NC_OPAQUE:
case NC_ENUM:
PANIC("type re-touched"); /* should never happen*/
break;
case NC_VLEN: /* keep if its basetype is already processed*/
if(sym->typ.basetype->touched) keep=1;
break;
case NC_COMPOUND: /* keep if all fields are processed*/
keep=1; /*assume all fields are touched*/
for(j=0;j<listlength(sym->subnodes);j++) {
Symbol* field = (Symbol*)listget(sym->subnodes,j);
ASSERT(field->subclass == NC_FIELD);
if(!field->typ.basetype->touched) {keep=1;break;}
}
break;
default: break;
}
if(keep) {
listpush(sorted,(void*)sym);
sym->touched = 1;
added++;
}
}
} while(added > 0);
/* Any untouched type => circular dependency*/
for(i=0;i<listlength(typdefs);i++) {
Symbol* tsym = (Symbol*)listget(typdefs,i);
if(tsym->touched) continue;
semerror(tsym->lineno,"Circular type dependency for type: %s",fullname(tsym));
}
listfree(typdefs);
typdefs = sorted;
/* fill in type typecodes*/
for(i=0;i<listlength(typdefs);i++) {
Symbol* sym = (Symbol*)listget(typdefs,i);
if(sym->typ.basetype != NULL && sym->typ.typecode == NC_NAT)
sym->typ.typecode = sym->typ.basetype->typ.typecode;
}
/* Identify types containing vlens */
for(i=0;i<listlength(typdefs);i++) {
Symbol* tsym = (Symbol*)listget(typdefs,i);
tagvlentypes(tsym);
}
}
