/* Result is pool'd*/
char*
prefixtostring(List* prefix, char* separator)
{
int slen=0;
int plen;
int i;
char* result;
if(prefix == NULL) return pooldup("");
plen = prefixlen(prefix);
if(plen == 0) { /* root prefix*/
slen=0;
/* slen += strlen(separator);*/
slen++; /* for null terminator*/
result = poolalloc(slen);
result[0] = '\0';
/*strcat(result,separator);*/
} else {
for(i=0;i<plen;i++) {
Symbol* sym = (Symbol*)listget(prefix,i);
slen += (strlen(separator)+strlen(sym->name));
}
slen++; /* for null terminator*/
result = poolalloc(slen);
result[0] = '\0';
for(i=0;i<plen;i++) {
Symbol* sym = (Symbol*)listget(prefix,i);
strcat(result,separator);
strcat(result,sym->name); /* append "/<prefix[i]>"*/
}
}
return result;
}
char*
pooldup(char* s)
{
char* sdup = poolalloc(strlen(s)+1);
strcpy(sdup,s);
return sdup;
}
char*
pooldup(const char* s)
{
char* sdup = poolalloc(strlen(s)+1);
strncpy(sdup,s,(strlen(s)+1));
return sdup;
}
char*
ncclassname(nc_class ncc)
{
char* s;
if(ncc >= NC_NAT && ncc <= NC_COMPOUND)
return nctypename((nc_type)ncc);
if(ncc == NC_FILLVALUE) return "NC_FILL";
if(ncc >= NC_GRP && ncc <= NC_PRIM)
return ncclassnames[ncc - NC_GRP];
s = poolalloc(128);
sprintf(s,"NC_<%d>",ncc);
return s;
}
char*
nctypename(nc_type nctype)
{
char* s;
if(nctype >= NC_NAT && nctype <= NC_COMPOUND)
return nctypenames[nctype];
if(nctype >= NC_GRP && nctype <= NC_PRIM)
return nctypenamesextend[(nctype - NC_GRP)];
if(nctype == NC_FILLVALUE) return "NC_FILL";
s = poolalloc(128);
sprintf(s,"NC_<%d>",nctype);
return s;
}
char*
escapify(char* s0, int quote, size_t len)
{
int i;
char* result;
result = poolalloc(1+4*len); /* overkill to support maximal expansion*/
result[0] = '\0';
for(i=0;i<len;i++) {
char tmp[8];
escapifychar((unsigned int)s0[i],tmp,quote);
strcat(result,tmp);
}
return result;
}
char*
poolcat(const char* s1, const char* s2)
{
int len1, len2;
char* cat;
if(s1 == NULL && s2 == NULL) return NULL;
len1 = (s1?strlen(s1):0);
len2 = (s2?strlen(s2):0);
cat = poolalloc(len1+len2+1);
cat[0] = '\0';
if(s1 != NULL) strcat(cat,s1);
if(s2 != NULL) strcat(cat,s2);
return cat;
}
Memimage*
allocmemimage(Rectangle r, ulong chan)
{
int d;
uchar *p;
ulong l, nw;
Memdata *md;
Memimage *i;
if((d = chantodepth(chan)) == 0) {
werrstr("bad channel descriptor %.8lux", chan);
return nil;
}
l = wordsperline(r, d);
nw = l*Dy(r);
md = malloc(sizeof(Memdata));
if(md == nil)
return nil;
md->ref = 1;
md->base = poolalloc(imagmem, sizeof(Memdata*)+(1+nw)*sizeof(ulong));
if(md->base == nil){
free(md);
return nil;
}
p = (uchar*)md->base;
*(Memdata**)p = md;
p += sizeof(Memdata*);
*(ulong*)p = getcallerpc(&r);
p += sizeof(ulong);
/* if this changes, memimagemove must change too */
md->bdata = p;
md->allocd = 1;
i = allocmemimaged(r, chan, md);
if(i == nil){
poolfree(imagmem, md->base);
free(md);
return nil;
}
md->imref = i;
return i;
}
static int
j_constant(Generator* generator, Symbol* sym, NCConstant* con, Bytebuffer* buf,...)
{
Bytebuffer* codetmp = bbNew();
char* special = NULL;
switch (con->nctype) {
case NC_CHAR:
if(con->value.charv == '\'')
bbprintf(codetmp,"'\\''");
else
bbprintf(codetmp,"'%c'",con->value.charv);
break;
case NC_BYTE:
bbprintf(codetmp,"%hhd",con->value.int8v);
break;
case NC_SHORT:
bbprintf(codetmp,"%hd",con->value.int16v);
break;
case NC_INT:
bbprintf(codetmp,"%d",con->value.int32v);
break;
case NC_FLOAT:
/* Special case for nan */
if(isnan(con->value.floatv))
bbprintf(codetmp,"Float.NaN");
else
bbprintf(codetmp,"%f",con->value.floatv);
break;
case NC_DOUBLE:
/* Special case for nan */
if(isnan(con->value.doublev))
bbprintf(codetmp,"Double.NaN");
else
bbprintf(codetmp,"%lf",con->value.doublev);
break;
case NC_UBYTE:
bbprintf(codetmp,"%hhu",con->value.uint8v);
break;
case NC_USHORT:
bbprintf(codetmp,"%hu",con->value.uint16v);
break;
case NC_UINT:
bbprintf(codetmp,"%uU",con->value.uint32v);
break;
case NC_INT64:
bbprintf(codetmp,"%lldLL",con->value.int64v);
break;
case NC_UINT64:
bbprintf(codetmp,"%lluLLU",con->value.uint64v);
break;
case NC_STRING: { /* handle separately */
char* escaped = escapify(con->value.stringv.stringv,
'"',con->value.stringv.len);
special = poolalloc(1+2+strlen(escaped));
strcpy(special,"\"");
strcat(special,escaped);
strcat(special,"\"");
} break;
default: PANIC1("ncstype: bad type code: %d",con->nctype);
}
if(special == NULL)
bbCatbuf(buf,codetmp);
else
bbCat(buf,special);
bbFree(codetmp);
return 1;
}
// This customized version carves holes defined by the regions.
// It'll remove any element which doesn't receive any region.
int custom_carveholes(struct mesh *m, struct behavior *b, const int *outside, const int *inside)
{
struct otri neighbortri;
struct otri triangleloop;
struct osub subsegloop;
triangle **temptri;
triangle ptr; /* Temporary variable used by sym(). */
double area;
double attribute;
double triangle_attribute;
int sane_mesh;
poolinit(& m->viri, sizeof( triangle * ), VIRUSPERBLOCK, VIRUSPERBLOCK, 0);
/* Assigns every triangle a regional attribute of -1 */
traversalinit(& m->triangles);
triangleloop.orient = 0;
triangleloop.tri = triangletraverse(m);
while ( triangleloop.tri != ( triangle * ) NULL ) {
setelemattribute(triangleloop, m->eextras, -1.0);
triangleloop.tri = triangletraverse(m);
}
sane_mesh = 1;
/* Loop over all segments */
traversalinit(& m->subsegs);
subsegloop.ss = subsegtraverse(m);
subsegloop.ssorient = 0;
while ( subsegloop.ss != ( subseg * ) NULL ) {
if ( subsegloop.ss != m->dummysub ) {
/* First neighbor. */
ssymself(subsegloop);
stpivot(subsegloop, neighbortri);
if ( neighbortri.tri != m->dummytri ) {
area = 0.0; /// @todo Possible set this as the minimum as well.
attribute = outside [ mark(subsegloop) - 1 ];
triangle_attribute = elemattribute(neighbortri, m->eextras);
/* The region no number yet. */
if ( triangle_attribute < 0 && attribute >= 0 ) {
infect(neighbortri);
temptri = ( triangle ** ) poolalloc(& m->viri);
* temptri = neighbortri.tri;
/* Apply one region's attribute and/or area constraint. */
regionplague(m, b, attribute, area);
/* The virus pool should be empty now. */
} else if ( attribute >= 0 && triangle_attribute >= 0 && attribute != triangle_attribute ) {
/* Check for problems. */
vertex v1, v2, v3;
org(neighbortri, v1);
dest(neighbortri, v2);
apex(neighbortri, v3);
fprintf(stdout, "Error: inconsistent region information (new %d, old %d from %d) (outside) at (%e, %e)\n",
( int ) attribute, ( int ) triangle_attribute, ( int ) mark(subsegloop), ( v1 [ 0 ] + v2 [ 0 ] + v3 [ 0 ] ) / 3, ( v1 [ 1 ] + v2 [ 1 ] + v3 [ 1 ] ) / 3);
sane_mesh = 0;
}
}
/* Second neighbor (same procedure). */
ssymself(subsegloop);
stpivot(subsegloop, neighbortri);
if ( neighbortri.tri != m->dummytri ) {
area = 0.0;
attribute = inside [ mark(subsegloop) - 1 ];
triangle_attribute = elemattribute(neighbortri, m->eextras);
if ( triangle_attribute < 0 && attribute >= 0 ) {
infect(neighbortri);
temptri = ( triangle ** ) poolalloc(& m->viri);
* temptri = neighbortri.tri;
regionplague(m, b, attribute, area);
} else if ( attribute >= 0 && triangle_attribute >= 0 && attribute != triangle_attribute ) {
vertex v1, v2, v3;
org(neighbortri, v1);
dest(neighbortri, v2);
apex(neighbortri, v3);
fprintf(stdout, "Error: inconsistent region information (new %d, old %d from %d) (inside) at (%e, %e)\n",
( int ) attribute, ( int ) triangle_attribute, ( int ) mark(subsegloop), ( v1 [ 0 ] + v2 [ 0 ] + v3 [ 0 ] ) / 3, ( v1 [ 1 ] + v2 [ 1 ] + v3 [ 1 ] ) / 3);
sane_mesh = 0;
}
}
subsegloop.ss = subsegtraverse(m);
}
}
/* Remove all triangles with marker 0.0 */
traversalinit(& m->triangles);
triangleloop.tri = triangletraverse(m);
int triangle_number = 0;
while ( triangleloop.tri != ( triangle * ) NULL ) {
if ( triangleloop.tri != m->dummytri ) {
triangle_number++;
attribute = elemattribute(triangleloop, m->eextras);
if ( attribute == -1.0 ) {
fprintf(stderr, "Broken mesh at triangle %d\n", triangle_number);
sane_mesh = 0;
} else if ( attribute == 0.0 ) {
infect(triangleloop);
temptri = ( triangle ** ) poolalloc(& m->viri);
* temptri = triangleloop.tri;
}
}
triangleloop.tri = triangletraverse(m);
}
/* Remove the marked elements */
plague(m, b);
if ( b->regionattrib && !b->refine ) {
/* Note the fact that each triangle has an additional attribute. */
m->eextras++;
}
/* Free up memory. */
pooldeinit(& m->viri);
return sane_mesh;
}
static int
c_constant(Generator* generator, NCConstant* con, Bytebuffer* buf,...)
{
Bytebuffer* codetmp = bbNew();
char* special = NULL;
switch (con->nctype) {
case NC_CHAR:
if(con->value.charv == '\'')
bbprintf(codetmp,"'\\''");
else
bbprintf(codetmp,"'%s'",cescapifychar(con->value.charv,'\''));
break;
case NC_BYTE:
bbprintf(codetmp,"%hhd",con->value.int8v);
break;
case NC_SHORT:
bbprintf(codetmp,"%hd",con->value.int16v);
break;
case NC_INT:
bbprintf(codetmp,"%d",con->value.int32v);
break;
case NC_FLOAT:
/* Special case for nanf */
if(isnan(con->value.floatv))
bbprintf(codetmp,"nanf");
else
bbprintf(codetmp,"%f",con->value.floatv);
break;
case NC_DOUBLE:
/* Special case for nan */
if(isnan(con->value.doublev))
bbprintf(codetmp,"nan");
else
bbprintf(codetmp,"%lf",con->value.doublev);
break;
case NC_UBYTE:
bbprintf(codetmp,"%hhu",con->value.uint8v);
break;
case NC_USHORT:
bbprintf(codetmp,"%hu",con->value.uint16v);
break;
case NC_UINT:
bbprintf(codetmp,"%uU",con->value.uint32v);
break;
case NC_INT64:
bbprintf(codetmp,"%lldLL",con->value.int64v);
break;
case NC_UINT64:
bbprintf(codetmp,"%lluLLU",con->value.uint64v);
break;
case NC_ECONST:
bbprintf(codetmp,"%s",cname(con->value.enumv));
break;
case NC_NIL:
case NC_STRING: { /* handle separately */
if(con->value.stringv.len == 0 && con->value.stringv.stringv == NULL) {
bbprintf(codetmp,"NULL");
} else {
char* escaped = escapify(con->value.stringv.stringv,
'"',con->value.stringv.len);
special = poolalloc(1+2+strlen(escaped));
strcpy(special,"\"");
strcat(special,escaped);
strcat(special,"\"");
}
} break;
case NC_OPAQUE: {
char* p;
int bslen;
bslen=(4*con->value.opaquev.len);
special = poolalloc(bslen+2+1);
strcpy(special,"\"");
p = con->value.opaquev.stringv;
while(*p) {
strcat(special,"\\x");
strncat(special,p,2);
p += 2;
}
strcat(special,"\"");
} break;
default: PANIC1("ncstype: bad type code: %d",con->nctype);
}
if(special == NULL)
bbCatbuf(buf,codetmp);
else
bbCat(buf,special);
bbFree(codetmp);
return 1;
}
/* Result is a pool string or a constant => do not free*/
char*
cdata_const(Constant* ci)
{
Bytebuffer* codetmp = bbNew();
char* result;
switch (ci->nctype) {
case NC_CHAR:
{
char tmp[64];
tmp[0] = '\0';
escapifychar(ci->value.charv,tmp,'\'');
bbCat(codetmp,"'");
bbCat(codetmp,tmp);
bbCat(codetmp,"'");
}
break;
case NC_BYTE:
bbprintf(codetmp,"%hhd",ci->value.int8v);
break;
case NC_SHORT:
bbprintf(codetmp,"%hd",ci->value.int16v);
break;
case NC_INT:
bbprintf(codetmp,"%d",ci->value.int32v);
break;
case NC_FLOAT:
bbprintf(codetmp,"%f",ci->value.floatv);
break;
case NC_DOUBLE:
bbprintf(codetmp,"%lf",ci->value.doublev);
break;
case NC_UBYTE:
bbprintf(codetmp,"%hhu",ci->value.uint8v);
break;
case NC_USHORT:
bbprintf(codetmp,"%hu",ci->value.uint16v);
break;
case NC_UINT:
bbprintf(codetmp,"%uU",ci->value.uint32v);
break;
case NC_INT64:
bbprintf(codetmp,"%lldLL",ci->value.int64v);
break;
case NC_UINT64:
bbprintf(codetmp,"%lluLLU",ci->value.uint64v);
break;
case NC_ECONST:
bbprintf(codetmp,"%s",cname(ci->value.enumv));
break;
case NC_STRING:
{ /* handle separately */
char* escaped = escapify(ci->value.stringv.stringv,
'"',ci->value.stringv.len);
result = poolalloc(1+2+strlen(escaped));
strcpy(result,"\"");
strcat(result,escaped);
strcat(result,"\"");
goto done;
}
break;
case NC_OPAQUE: {
char* p;
int bslen;
bslen=(4*ci->value.opaquev.len);
result = poolalloc(bslen+2+1);
strcpy(result,"\"");
p = ci->value.opaquev.stringv;
while(*p) {
strcat(result,"\\x");
strncat(result,p,2);
p += 2;
}
strcat(result,"\"");
goto done;
} break;
default: PANIC1("ncstype: bad type code: %d",ci->nctype);
}
result = pooldup(bbContents(codetmp)); /*except for NC_STRING and NC_OPAQUE*/
bbFree(codetmp);
done:
return result;
}
static void
genbin_primdata(Symbol* basetype, Datasrc* src, Datalist* fillsrc,
Bytebuffer* memory)
{
Constant* prim;
Constant target;
prim = srcnext(src);
if(prim == NULL || prim->nctype == NC_FILLVALUE) {
genbin_fillvalue(basetype,fillsrc,src,memory);
return;
}
target.nctype = basetype->typ.typecode;
if(prim == NULL) {
#ifdef GENFILL
/* generate a fill value*/
nc_getfill(&target);
/* fall thru*/
#else
return;
#endif
}
ASSERT(prim->nctype != NC_COMPOUND);
if(target.nctype != NC_ECONST) {
convert1(prim,&target);
alignbuffer(&target,memory);
}
switch (target.nctype) {
case NC_ECONST:
if(basetype->subclass != NC_ENUM) {
semerror(prim->lineno,"Conversion to enum not supported (yet)");
} else {
Datalist* econ = builddatalist(1);
srcpushlist(src,econ);
dlappend(econ,&prim->value.enumv->typ.econst);
genbin_primdata(prim->value.enumv->typ.basetype,src,
fillsrc,memory);
srcpop(src);
}
break;
case NC_OPAQUE: {
unsigned char* bytes;
size_t len;
setprimlength(&target,basetype->typ.size*2);
bytes=makebytestring(target.value.opaquev.stringv,&len);
bbAppendn(memory,(void*)bytes,len);
} break;
case NC_CHAR:
bbAppendn(memory,&target.value.charv,sizeof(target.value.charv));
break;
case NC_BYTE:
bbAppendn(memory,(void*)&target.value.int8v,sizeof(target.value.int8v));
break;
case NC_SHORT:
bbAppendn(memory,(void*)&target.value.int16v,sizeof(target.value.int16v));
break;
case NC_INT:
bbAppendn(memory,(void*)&target.value.int32v,sizeof(target.value.int32v));
break;
case NC_FLOAT:
bbAppendn(memory,(void*)&target.value.floatv,sizeof(target.value.floatv));
break;
case NC_DOUBLE:
bbAppendn(memory,(void*)&target.value.doublev,sizeof(target.value.doublev));
break;
case NC_UBYTE:
bbAppendn(memory,(void*)&target.value.uint8v,sizeof(target.value.uint8v));
break;
case NC_USHORT:
bbAppendn(memory,(void*)&target.value.uint16v,sizeof(target.value.uint16v));
break;
case NC_UINT:
bbAppendn(memory,(void*)&target.value.uint32v,sizeof(target.value.uint32v));
break;
case NC_INT64: {
union SI64 { char ch[8]; long long i64;} si64;
si64.i64 = target.value.int64v;
bbAppendn(memory,(void*)si64.ch,sizeof(si64.ch));
} break;
case NC_UINT64: {
union SU64 { char ch[8]; unsigned long long i64;} su64;
su64.i64 = target.value.uint64v;
bbAppendn(memory,(void*)su64.ch,sizeof(su64.ch));
} break;
case NC_STRING: {
if(usingclassic) {
bbAppendn(memory,target.value.stringv.stringv,target.value.stringv.len);
} else if(target.nctype == NC_CHAR) {
bbAppendn(memory,target.value.stringv.stringv,target.value.stringv.len);
} else {
char* ptr;
int len = (size_t)target.value.stringv.len;
ptr = poolalloc(len+1); /* CAREFUL: this has short lifetime*/
memcpy(ptr,target.value.stringv.stringv,len);
ptr[len] = '\0';
bbAppendn(memory,(void*)&ptr,sizeof(ptr));
}
} break;
default: PANIC1("genbin_primdata: unexpected type: %d",target.nctype);
}
}
