static void
genbin_arraydatar(Symbol* vsym,
Bytebuffer* memory,
nciter_t iter,
Iterodom* iterodom,
int index)
{
int i;
int rank = iterodom->rank;
int lastdim = (index == (rank - 1)); /* last dimension*/
int firstdim = (index == 0);
int declsize = odom->dims[index].declsize;
int isunlimited = (declsize == 0);
Symbol* basetype = vsym->typ.basetype;
Datalist* fillsrc = vsym->var.special._Fillvalue;
Constant* con;
ASSERT(index >= 0 && index < rank);
odom->dims[index].index = 0; /* reset*/
if(isunlimited) {
Constant* con;
if(!firstdim) {
if(!issublist(src)) {
semerror(srcline(src),"Unlimited data must be enclosed in {..}");
return;
}
srcpush(src); /* enter the unlimited data */
}
while((con=srcpeek(src))!=NULL) {
if(lastdim) {
genbin_data(basetype,src,fillsrc,memory);
} else {
genbin_arraydatar(vsym,src,odom,index+1,
checkpoint,memory);
}
odom->dims[index].index++;
if(docheckpoint) {
closure->putvar(closure,odom,memory);
}
}
odom->dims[index].datasize = odom->dims[index].index;
if(!firstdim) srcpop(src);
} else { /* !isunlimited*/
for(i=0;i<declsize;i++) {
con = srcpeek(src);
if(lastdim) {
genbin_data(basetype,src,fillsrc,memory);
} else { /* ! lastdim*/
(void)genbin_arraydatar(vsym,src,odom,
index+1,checkpoint,memory);
}
odom->dims[index].index++;
if(docheckpoint) {
closure->putvar(closure,odom,memory);
}
}
}
}
/* return 1 if the next element in the datasrc is nc_type*/
int
istype(Datasrc* datasrc , nc_type nctype)
{
NCConstant* ci = srcpeek(datasrc);
if(ci != NULL && ci->nctype == nctype) return 1;
return 0;
}
NCConstant*
srcpeek(Datasrc* ds)
{
if(ds == NULL) return NULL;
if(ds->index < ds->length)
return &ds->data[ds->index];
if(ds->spliced)
return srcpeek(ds->prev);
return NULL;
}
static void
genbin_data(Symbol* tsym, Datasrc* datasrc, Datalist* fillsrc,
Bytebuffer* memory)
{
int usecmpd;
Constant* con = srcpeek(datasrc);
if(con == NULL || con->nctype == NC_FILLVALUE) {
srcnext(datasrc);
genbin_fillvalue(tsym,fillsrc,datasrc,memory);
return;
}
switch (tsym->subclass) {
case NC_ENUM:
case NC_OPAQUE:
case NC_PRIM:
if(issublist(datasrc)) {
semerror(srcline(datasrc),"Expected primitive found {..}");
}
genbin_primdata(tsym,datasrc,fillsrc,memory);
break;
case NC_COMPOUND:
genbin_compound(tsym,datasrc,fillsrc,memory);
break;
case NC_VLEN: {
Constant* cp;
nc_vlen_t ptr;
if(!issublist(datasrc)) {
semerror(srcline(datasrc),"Vlen data must be enclosed in {..}");
}
cp = srcnext(datasrc);
/* generate the nc_vlen_t instance*/
ptr.p = vlendata[cp->value.compoundv->vlen.uid].data;
ptr.len = vlendata[cp->value.compoundv->vlen.uid].count;
bbAppendn(memory,(char*)&ptr,sizeof(ptr));
} break;
case NC_FIELD:
/* enclose in braces if and only if field is an array */
usecmpd = (issublist(datasrc) && tsym->typ.dimset.ndims > 0);
if(usecmpd) srcpush(datasrc);
if(tsym->typ.dimset.ndims > 0) {
genbin_fieldarray(tsym->typ.basetype,datasrc,&tsym->typ.dimset,0,memory);
} else {
genbin_data(tsym->typ.basetype,datasrc,NULL,memory);
}
if(usecmpd) srcpop(datasrc);
break;
default: PANIC1("genbin_data: unexpected subclass %d",tsym->subclass);
}
}
void
gen_charfield(Datasrc* src, Odometer* odom, int index, Bytebuffer* fieldbuf)
{
int i;
int lastdim = (index == (odom->rank - 1));
size_t declsize = odom->declsize[index];
Constant* con;
ASSERT(declsize != 0);
if(lastdim) {
for(i=0;i<declsize;) {
con = srcnext(src);
if(con == NULL) break;
if(!isstringable(con->nctype)) {
semerror(srcline(src),
"Encountered non-string constant in compound field");
return;
}
i += collectstring(con,declsize,fieldbuf);
}
if(i < declsize) i=fillstring(declsize,i,fieldbuf);
} else { /* ! lastdim*/
int exploded = 0;
size_t slicesize;
/* Compute subslice size */
slicesize = 1;
for(i=index+1;i<odom->rank;i++)
slicesize *= MAX(odom->declsize[i],odom->unlimitedsize[i]);
con = srcpeek(src);
if(con != NULL && !isstringable(con->nctype)) {
semerror(srcline(src),
"Encountered non-string constant in compound field");
return;
}
if(con != NULL && con->value.stringv.len > slicesize) {
/* Constant is larger than just our slice */
/* Explode the constant into subchunks */
exploded = stringexplode(src,slicesize);
}
for(i=0;i<declsize;i++) {
gen_charfield(src,odom,index+1,fieldbuf);
}
if(exploded) srcpop(src);
}
}
/* return 1 if the next element in the datasrc is a fill value*/
int
isfillvalue(Datasrc* datasrc)
{
return srcpeek(datasrc) == NULL || istype(datasrc,NC_FILLVALUE);
}
void
gen_chararray(Symbol* vsym,
Bytebuffer* databuf,
Datasrc* src,
Odometer* odom,
int index)
{
/* Assume that all dimensions from index+1 to rank-1 are !unlimited */
int i;
int rank = odom->rank;
int lastdim = (index == (rank - 1)); /* last dimension*/
int firstdim = (index == 0);
int isunlimited = (odom->declsize[index] == NC_UNLIMITED);
int exploded = 0;
Constant* con;
if(lastdim) {
gen_chararraysuffix(vsym,databuf,src,odom,index);
return;
}
ASSERT(index >= 0 && index < rank);
odom->index[index] = odom->start[index]; /* reset */
if(isunlimited) {
size_t slicesize;
Constant* con;
if(!firstdim) {
if(!issublist(src)) {
semerror(srcline(src),"Unlimited data must be enclosed in {..}");
return;
}
srcpush(src); /* enter the unlimited data */
}
con=srcpeek(src);
/* Break up the constant if it is too large */
slicesize = odomsubarray(odom,index+1);
if(con != NULL && con->value.stringv.len > slicesize) {
/* Constant is larger than just our slice */
/* Explode the constant into subchunks */
exploded = stringexplode(src,slicesize);
}
while((con=srcpeek(src))!=NULL) {
gen_chararray(vsym,databuf,src,odom,index+1);
odom->index[index]++;
}
odom->unlimitedsize[index] = odom->index[index];
if(exploded) srcpop(src);
if(!firstdim) srcpop(src);
} else { /* !isunlimited*/
size_t slicesize;
con = srcpeek(src);
ASSERT(!lastdim);
/* Break up the constant if it is too large */
slicesize = odomsubarray(odom,index+1);
if(con != NULL && con->value.stringv.len > slicesize) {
/* Constant is larger than just our slice */
/* Explode the constant into subchunks */
exploded = stringexplode(src,slicesize);
}
for(i=0;i<odom->declsize[index];i++) {
gen_chararray(vsym,databuf,src,odom,index+1);
}
if(exploded) srcpop(src);
}
}
static void
gen_chararraysuffix(Symbol* vsym,
Bytebuffer* databuf,
Datasrc* src,
Odometer* odom,
int index)
{
int i;
int rank = odom->rank;
int lastdim = (index == (rank - 1)); /* last dimension*/
int firstdim = (index == 0);
size_t declsize = odom->declsize[index];
int isunlimited = (declsize==NC_UNLIMITED);
Constant* con;
ASSERT(index >= 0 && index < rank);
odom->index[index] = odom->start[index]; /* reset*/
con = srcpeek(src);
if(!isunlimited) {
if(con != NULL && !isstringable(con->nctype)) {
semerror(srcline(src),
"Encountered non-string constant in char data: %s",
vsym->name);
return;
}
if(lastdim) {
/* To mimic ncgen original, it appears we have to hack.
I think firstdim==lastdim may work.
*/
for(i=0;i<declsize;) {
int slen;
con = srcnext(src);
if(con == NULL) break;
slen = collectstring(con,declsize,databuf);
if(!firstdim && slen < declsize) slen=fillstring(declsize,slen,databuf);
i += slen;
}
if(firstdim && i < declsize) i = fillstring(declsize,i,databuf);
odom->index[index] = i;
} else { /* ! lastdim*/
int exploded = 0;
size_t slicesize = odometertotal(odom,index+1);
if(con != NULL && con->nctype == NC_STRING
&& con->value.stringv.len > slicesize) {
/* Constant is larger than just our slice */
/* Explode the constant into subchunks */
exploded = stringexplode(src,slicesize);
}
for(i=0;i<odom->declsize[index];i++) {
gen_chararraysuffix(vsym,databuf,src,odom,index+1);
odom->index[index]++;
}
if(exploded) srcpop(src);
}
} else { /* unlimited => lastdim*/
Constant* con;
if(!firstdim) {
if(!issublist(src)) {
semerror(srcline(src),"Unlimited data must be enclosed in {..}");
return;
}
srcpush(src); /* enter the unlimited data */
}
/* Basically, collect all the strings until we run out */
i = 0;
while((con=srcnext(src))!=NULL) {
i += collectstring(con,0,databuf);
}
odom->index[index] = i;
odom->unlimitedsize[index] = odom->index[index];
if(!firstdim) srcpop(src);
}
}
