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); } }