/* Utility to transfer a string to a buffer with escaping */
static void
escapify(NCbytes* buffer, const char* s)
{
const char* p;
for(p=s;*p;p++) {
if(strchr(ESCAPECHARS,*p) != NULL)
ncbytesappend(buffer,'\\');
ncbytesappend(buffer,*p);
}
}
/* For debugging */
int
ncbytesnull(NCbytes* bb)
{
ncbytesappend(bb,'\0');
bb->length--;
return 1;
}
/**
* @internal Build _NCProperties attribute value.
*
* Convert a NCPROPINFO instance to a single string.
*
* @param info Properties info.
* @param propdatap Pointer that gets properties string.
*
* @return ::NC_NOERR No error.
* @return ::NC_EINVAL failed.
* @author Dennis Heimbigner
*/
int
NC4_buildpropinfo(struct NCPROPINFO* info, char** propdatap)
{
int stat = NC_NOERR;
int i;
NCbytes* buffer = NULL;
char sversion[64];
LOG((3, "%s", __func__));
if(info == NULL || info->version == 0 || propdatap == NULL)
{stat = NC_EINVAL; goto done;}
*propdatap = NULL;
buffer = ncbytesnew();
if(!buffer) {stat = NC_ENOMEM; goto done;}
/* start with version */
ncbytescat(buffer,NCPVERSION);
ncbytesappend(buffer,'=');
snprintf(sversion,sizeof(sversion),"%d",info->version);
ncbytescat(buffer,sversion);
for(i=0;i<nclistlength(info->properties);i+=2) {
char* value, *name;
name = nclistget(info->properties,i);
if(name == NULL) continue;
value = nclistget(info->properties,i+1);
ncbytesappend(buffer,NCPROPSSEP2); /* terminate last entry */
escapify(buffer,name);
ncbytesappend(buffer,'=');
escapify(buffer,value);
}
/* Force null termination */
ncbytesnull(buffer);
*propdatap = ncbytesextract(buffer);
done:
if(buffer != NULL) ncbytesfree(buffer);
return stat;
}
/* Pad a buffer */
int
dapalignbuffer(NCbytes* buf, int alignment)
{
int pad;
unsigned long len;
if(buf == NULL) return 0;
len = ncbyteslength(buf);
pad = nccpadding(len,alignment);
#ifdef TEST
for(;pad > 0;pad--)
ncbytesappend(buf,0x3a); /* 0x3a was chosen at random */
#else
ncbytessetlength(buf,len+pad);
#endif
return 1;
}
void
dcetobuffer(DCEnode* node, NCbytes* buf)
{
int i;
char tmp[1024];
if(buf == NULL) return;
if(node == NULL) {ncbytesappend(buf,'?'); return;}
switch (node->sort) {
case CES_SLICE: {
DCEslice* slice = (DCEslice*)node;
size_t last = (slice->first+slice->length)-1;
if(last > slice->declsize && slice->declsize > 0)
last = slice->declsize - 1;
if(slice->count == 1) {
snprintf(tmp,sizeof(tmp),"[%lu]",
(unsigned long)slice->first);
} else if(slice->stride == 1) {
snprintf(tmp,sizeof(tmp),"[%lu:%lu]",
(unsigned long)slice->first,
(unsigned long)last);
} else {
snprintf(tmp,sizeof(tmp),"[%lu:%lu:%lu]",
(unsigned long)slice->first,
(unsigned long)slice->stride,
(unsigned long)last);
}
ncbytescat(buf,tmp);
} break;
case CES_SEGMENT: {
DCEsegment* segment = (DCEsegment*)node;
int rank = segment->rank;
char* name = (segment->name?segment->name:"<unknown>");
ncbytescat(buf,nulldup(name));
if(!dceiswholesegment(segment)) {
for(i=0;i<rank;i++) {
DCEslice* slice = segment->slices+i;
dcetobuffer((DCEnode*)slice,buf);
}
}
} break;
case CES_VAR: {
DCEvar* var = (DCEvar*)node;
dcelisttobuffer(var->segments,buf,".");
} break;
case CES_FCN: {
DCEfcn* fcn = (DCEfcn*)node;
ncbytescat(buf,fcn->name);
ncbytescat(buf,"(");
dcelisttobuffer(fcn->args,buf,",");
ncbytescat(buf,")");
} break;
case CES_CONST: {
DCEconstant* value = (DCEconstant*)node;
switch (value->discrim) {
case CES_STR:
ncbytescat(buf,value->text);
break;
case CES_INT:
snprintf(tmp,sizeof(tmp),"%lld",value->intvalue);
ncbytescat(buf,tmp);
break;
case CES_FLOAT:
snprintf(tmp,sizeof(tmp),"%g",value->floatvalue);
ncbytescat(buf,tmp);
break;
default: assert(0);
}
} break;
case CES_VALUE: {
DCEvalue* value = (DCEvalue*)node;
switch (value->discrim) {
case CES_CONST:
dcetobuffer((DCEnode*)value->constant,buf);
break;
case CES_VAR:
dcetobuffer((DCEnode*)value->var,buf);
break;
case CES_FCN:
dcetobuffer((DCEnode*)value->fcn,buf);
break;
default: assert(0);
}
} break;
case CES_PROJECT: {
DCEprojection* target = (DCEprojection*)node;
switch (target->discrim) {
case CES_VAR:
dcetobuffer((DCEnode*)target->var,buf);
break;
case CES_FCN: dcetobuffer((DCEnode*)target->fcn,buf); break;
default: assert(0);
}
} break;
case CES_SELECT: {
DCEselection* sel = (DCEselection*)node;
dcetobuffer((DCEnode*)sel->lhs,buf);
if(sel->operator == CES_NIL) break;
ncbytescat(buf,opstrings[(int)sel->operator]);
if(nclistlength(sel->rhs) > 1)
ncbytescat(buf,"{");
dcelisttobuffer(sel->rhs,buf,",");
if(nclistlength(sel->rhs) > 1)
ncbytescat(buf,"}");
} break;
case CES_CONSTRAINT: {
DCEconstraint* con = (DCEconstraint*)node;
if(con->projections != NULL && nclistlength(con->projections) > 0) {
dcelisttobuffer(con->projections,buf,",");
}
if(con->selections != NULL && nclistlength(con->selections) > 0) {
ncbytescat(buf,"&"); /* because & is really a prefix */
dcelisttobuffer(con->selections,buf,"&");
}
} break;
case CES_NIL: {
ncbytescat(buf,"<nil>");
} break;
default:
assert(0);
}
}
static void
ceaddyytext(DCElexstate* lex, int c)
{
ncbytesappend(lex->yytext,(char)c);
}
static void
dapaddyytext(DAPlexstate* lex, int c)
{
ncbytesappend(lex->yytext,c);
}
