static void
collectsegmentnames3(NClist* segments, NClist* path)
{
int i;
ncbytesclear(path);
for(i=0;i<nclistlength(segments);i++) {
DCEsegment* segment = (DCEsegment*)nclistget(segments,i);
nclistpush(path,(ncelem)segment->name);
}
}
int
ncbytessetcontents(NCbytes* bb, char* contents, unsigned long alloc)
{
if(bb == NULL) return ncbytesfail();
ncbytesclear(bb);
if(!bb->nonextendible && bb->content != NULL) free(bb->content);
bb->content = contents;
bb->length = 0;
bb->alloc = alloc;
bb->nonextendible = 1;
return 1;
}
char*
dumpselection(NCselection* sel)
{
NCbytes* buf = ncbytesnew();
NCbytes* segbuf = ncbytesnew();
char* sstring;
NClist* segments = NULL;
int j;
if(sel == NULL) return nulldup("");
segments = sel->lhs->var->segments;
ncbytescat(buf,"&");
tostringncsegments(segments,segbuf);
ncbytescat(buf,ncbytescontents(segbuf));
ncbytescat(buf,opstrings[sel->operator]);
ncbytescat(buf,"{");
for(j=0;j<nclistlength(sel->rhs);j++) {
NCvalue* value = (NCvalue*)nclistget(sel->rhs,j);
NCconstant* con = value->constant;
char tmp[64];
if(j > 0) ncbytescat(buf,",");
switch (value->discrim) {
case NS_STR:
ncbytescat(buf,con->text);
break;
case NS_CONST:
switch (con->discrim) {
case NS_INT:
snprintf(tmp,sizeof(tmp),"%lld",con->intvalue);
ncbytescat(buf,tmp);
break;
case NS_FLOAT:
snprintf(tmp,sizeof(tmp),"%g",con->floatvalue);
ncbytescat(buf,tmp);
break;
default: PANIC1("unexpected discriminator %d",(int)con->discrim);
}
break;
case NS_VAR:
segments = value->var->segments;
ncbytesclear(segbuf);
tostringncsegments(segments,segbuf);
ncbytescat(buf,ncbytescontents(segbuf));
break;
default: PANIC1("unexpected discriminator %d",(int)value->discrim);
}
}
ncbytescat(buf,"}");
sstring = ncbytesdup(buf);
ncbytesfree(buf);
ncbytesfree(segbuf);
return sstring;
}
static void
atomicsToString(D4printer* out, union ATOMICS* value, nc_type type)
{
char tmp[256];
ncbytesclear(out->tmp);
switch (type) {
case NC_CHAR:
snprintf(tmp,sizeof(tmp),"'%c'",value->i8[0]);
break;
case NC_BYTE:
snprintf(tmp,sizeof(tmp),"%d",value->i8[0]);
break;
case NC_UBYTE:
snprintf(tmp,sizeof(tmp),"%u",value->u8[0]);
break;
case NC_SHORT:
snprintf(tmp,sizeof(tmp),"%d",value->i16[0]);
break;
case NC_USHORT:
snprintf(tmp,sizeof(tmp),"%u",value->u16[0]);
break;
case NC_INT:
snprintf(tmp,sizeof(tmp),"%d",value->i32[0]);
break;
case NC_UINT:
snprintf(tmp,sizeof(tmp),"%u",value->u32[0]);
break;
case NC_INT64:
snprintf(tmp,sizeof(tmp),"%lld",value->i64[0]);
break;
case NC_UINT64:
snprintf(tmp,sizeof(tmp),"%llu",value->u64[0]);
break;
case NC_FLOAT:
snprintf(tmp,sizeof(tmp),"%g",value->f32[0]);
break;
case NC_DOUBLE:
snprintf(tmp,sizeof(tmp),"%g",value->f64[0]);
break;
case NC_STRING:
ncbytescat(out->tmp,"\"");
ncbytescat(out->tmp,value->s[0]);
ncbytescat(out->tmp,"\"");
break;
default: abort();
}
if(type != NC_STRING) ncbytescat(out->tmp,tmp);
ncbytesnull(out->tmp);
}
int
dcelex(YYSTYPE* lvalp, DCEparsestate* state)
{
DCElexstate* lexstate = state->lexstate;
int token;
int c;
int len;
char* p=NULL;
token = 0;
ncbytesclear(lexstate->yytext);
ncbytesnull(lexstate->yytext);
p=lexstate->next;
while(token == 0 && (c=*p)) {
if(c <= ' ' || c >= '\177') {p++; continue;}
if(c == '"') {
int more = 1;
ceaddyytext(lexstate,c);
/* We have a SCAN_STRINGCONST */
while(more && (c=*(++p))) {
switch (c) {
case '"': p++; more=0; break;
case '\\':
c=*(++p);
switch (c) {
case 'r': c = '\r'; break;
case 'n': c = '\n'; break;
case 'f': c = '\f'; break;
case 't': c = '\t'; break;
case 'x': {
int d1,d2;
c = '?';
++p;
d1 = tohex(*p++);
if(d1 < 0) {
dceerror(state,"Illegal \\xDD in SCAN_STRING");
} else {
d2 = tohex(*p++);
if(d2 < 0) {
dceerror(state,"Illegal \\xDD in SCAN_STRING");
} else {
c=(((unsigned int)d1)<<4) | (unsigned int)d2;
}
}
} break;
default: break;
}
break;
default: break;
}
ceaddyytext(lexstate,c);
}
token=SCAN_STRINGCONST;
} else if(strchr(numchars1,c) != NULL) {
/* we might have a SCAN_NUMBERCONST */
int isnumber = 0;
char* yytext;
char* endpoint;
ceaddyytext(lexstate,c);
for(p++;(c=*p);p++) {
if(strchr(numcharsn,c) == NULL) break;
ceaddyytext(lexstate,c);
}
/* See if this is a number */
ncbytesnull(lexstate->yytext);
yytext = ncbytescontents(lexstate->yytext);
(void)strtoll(yytext,&endpoint,10);
if(*yytext != '\0' && *endpoint == '\0')
isnumber = 1;
else {
(void)strtod(yytext,&endpoint);
if(*yytext != '\0' && *endpoint == '\0')
isnumber = 1; /* maybe */
}
/* A number followed by an id char is assumed to just be
a funny id */
if(isnumber && (*p == '\0' || strchr(wordcharsn,*p) == NULL)) {
token = SCAN_NUMBERCONST;
} else {
/* Now, if the funny word has a "." in it,
we have to back up to that dot */
char* dotpoint = strchr(yytext,'.');
if(dotpoint != NULL) {
p = dotpoint;
*dotpoint = '\0';
}
token = SCAN_WORD;
}
} else if(strchr(wordchars1,c) != NULL) {
/* we have a SCAN_WORD */
ceaddyytext(lexstate,c);
for(p++;(c=*p);p++) {
if(strchr(wordcharsn,c) == NULL) break;
ceaddyytext(lexstate,c);
}
token=SCAN_WORD;
} else {
/* we have a single char token */
token = c;
ceaddyytext(lexstate,c);
p++;
}
}
lexstate->next = p;
len = ncbyteslength(lexstate->yytext);
if(len > MAX_TOKEN_LENGTH) len = MAX_TOKEN_LENGTH;
strncpy(lexstate->lasttokentext,ncbytescontents(lexstate->yytext),len);
lexstate->lasttokentext[len] = '\0';
lexstate->lasttoken = token;
if(dcedebug) dumptoken(lexstate);
/*Put return value onto Bison stack*/
if(ncbyteslength(lexstate->yytext) == 0)
*lvalp = NULL;
else {
*lvalp = ncbytesdup(lexstate->yytext);
nclistpush(lexstate->reclaim,(void*)*lvalp);
}
return token;
}
int
daplex(YYSTYPE* lvalp, DAPparsestate* state)
{
DAPlexstate* lexstate = state->lexstate;
int token;
int c;
unsigned int i;
char* p;
char* tmp;
YYSTYPE lval = NULL;
token = 0;
ncbytesclear(lexstate->yytext);
/* invariant: p always points to current char */
for(p=lexstate->next;token==0&&(c=*p);p++) {
if(c == '\n') {
lexstate->lineno++;
} else if(c <= ' ' || c == '\177') {
/* whitespace: ignore */
} else if(c == '#') {
/* single line comment */
while((c=*(++p))) {if(c == '\n') break;}
} else if(strchr(lexstate->worddelims,c) != NULL) {
/* don't put in lexstate->yytext to avoid memory leak */
token = c;
} else if(c == '"') {
int more = 1;
/* We have a string token; will be reported as WORD_STRING */
while(more && (c=*(++p))) {
if(c == '"') {
more = 0;
continue;
}
#ifdef DAP2ENCODE
if(c == '\\') {
/* Resolve spec ambiguity about handling of \c:
1. !KEEPSLASH: convert \c to c for any character c
2. KEEPSLASH: convert \c to \c for any character c;
that is, keep the backslash.
It is clear that the problem being addressed was \".
But it is unclear what to to do about \n: convert to
Ascii LF or leave as \n.
This code will leave as \n and assume higher levels
of code will address the issue.
*/
#ifdef KEEPSLASH
dapaddyytext(lexstate,c);
#endif
c=*(++p);
if(c == '\0') more = 0;
}
#else /*Non-standard*/
switch (c) {
case '\\':
c=*(++p);
switch (c) {
case 'r': c = '\r'; break;
case 'n': c = '\n'; break;
case 'f': c = '\f'; break;
case 't': c = '\t'; break;
case 'x': {
int d1,d2;
c = '?';
++p;
d1 = tohex(*p++);
if(d1 < 0) {
daperror(state,"Illegal \\xDD in TOKEN_STRING");
} else {
d2 = tohex(*p++);
if(d2 < 0) {
daperror(state,"Illegal \\xDD in TOKEN_STRING");
} else {
c=(((unsigned int)d1)<<4) | (unsigned int)d2;
}
}
} break;
default: break;
}
break;
default: break;
}
#endif /*!DAP2ENCODE*/
if(more) dapaddyytext(lexstate,c);
}
token=WORD_STRING;
} else if(strchr(lexstate->wordchars1,c) != NULL) {
int isdatamark = 0;
/* we have a WORD_WORD */
dapaddyytext(lexstate,c);
while((c=*(++p))) {
#ifdef URLCVT
if(c == '%' && p[1] != 0 && p[2] != 0
&& strchr(hexdigits,p[1]) != NULL
&& strchr(hexdigits,p[2]) != NULL) {
int d1,d2;
d1 = tohex(p[1]);
d2 = tohex(p[2]);
if(d1 >= 0 || d2 >= 0) {
c=(((unsigned int)d1)<<4) | (unsigned int)d2;
p+=2;
}
} else {
if(strchr(lexstate->wordcharsn,c) == NULL) {p--; break;}
}
dapaddyytext(lexstate,c);
#else
if(strchr(lexstate->wordcharsn,c) == NULL) {p--; break;}
dapaddyytext(lexstate,c);
#endif
}
/* Special check for Data: */
tmp = ncbytescontents(lexstate->yytext);
if(strcmp(tmp,"Data")==0 && *p == ':') {
dapaddyytext(lexstate,*p); p++;
if(p[0] == '\n') {
token = SCAN_DATA;
isdatamark = 1;
p++;
} else if(p[0] == '\r' && p[1] == '\n') {
token = SCAN_DATA;
isdatamark = 1;
p+=2;
}
}
if(!isdatamark) {
/* check for keyword */
token=WORD_WORD; /* assume */
for(i=0;;i++) {
if(keywords[i] == NULL) break;
if(strcasecmp(keywords[i],tmp)==0) {
token=keytokens[i];
break;
}
}
}
} else { /* illegal */
}
}
lexstate->next = p;
strncpy(lexstate->lasttokentext,ncbytescontents(lexstate->yytext),MAX_TOKEN_LENGTH);
lexstate->lasttoken = token;
if(ocdebug >= 2)
dumptoken(lexstate);
/*Put return value onto Bison stack*/
if(ncbyteslength(lexstate->yytext) == 0)
lval = NULL;
else {
lval = ncbytesdup(lexstate->yytext);
nclistpush(lexstate->reclaim,(void*)lval);
}
if(lvalp) *lvalp = lval;
return token; /* Return the type of the token. */
}
static int
printNode(D4printer* out, NCD4node* node, int depth)
{
int ret = NC_NOERR;
int i;
char* fqn = NULL;
switch (node->sort) {
case NCD4_GROUP:
if(node->group.isdataset)
printDataset(out,node,depth);
else
printGroup(out,node,depth);
break;
case NCD4_DIM:
INDENT(depth);
CAT("<Dimension");
if(node->name != NULL)
printXMLAttributeName(out, "name", node->name);
printXMLAttributeSize(out, "size", node->dim.size);
if(node->dim.isunlimited)
printXMLAttributeString(out, UCARTAGUNLIM, "1");
CAT("/>");
break;
case NCD4_TYPE:
switch (node->subsort) {
default: break;
case NC_OPAQUE:
INDENT(depth); CAT("<Opaque");
ncbytesclear(out->tmp);
printXMLAttributeName(out, "name", node->name);
if(node->opaque.size > 0)
printXMLAttributeSize(out, "size", node->opaque.size);
CAT("/>");
break;
case NC_ENUM:
INDENT(depth); CAT("<Enumeration");
printXMLAttributeName(out, "name", node->name);
if(node->basetype->subsort <= NC_MAX_ATOMIC_TYPE)
printXMLAttributeName(out, "basetype", node->basetype->name);
else {
char* fqn = NULL;
printXMLAttributeName(out, "basetype", (fqn = NCD4_makeFQN(node->basetype)));
nullfree(fqn);
}
CAT(">\n");
depth++;
for(i=0;i<nclistlength(node->en.econsts);i++) {
NCD4node* ec = (NCD4node*)nclistget(node->en.econsts,i);
INDENT(depth);
CAT("<EnumConst");
printXMLAttributeName(out, "name", ec->name);
printXMLAttributeAtomics(out, "value", &ec->en.ecvalue, node->basetype->subsort);
CAT("/>\n");
}
depth--;
INDENT(depth); CAT("</Enumeration>");
break;
case NC_STRUCT:
INDENT(depth);
CAT("<Structure");
printXMLAttributeName(out, "name", node->name);
CAT(">\n");
depth++;
for(i=0;i<nclistlength(node->vars);i++) {
NCD4node* field = (NCD4node*)nclistget(node->vars,i);
printVariable(out,field,depth);
CAT("\n");
}
if((ret=printMetaData(out,node,depth))) goto done;
depth--;
INDENT(depth);
CAT("</Structure>");
break;
case NC_SEQ:
INDENT(depth);
CAT("<Vlen");
printXMLAttributeName(out, "name", node->name);
printXMLAttributeName(out, "type", (fqn=NCD4_makeFQN(node->basetype)));
if(hasMetaData(node)) {
CAT(">\n");
depth++;
if((ret=printMetaData(out,node,depth))) goto done;
depth--;
INDENT(depth);
CAT("</Vlen>");
} else
CAT("/>");
break;
} break;
case NCD4_VAR: /* Only top-level vars are printed here */
if(ISTOPLEVEL(node)) {
if((ret=printVariable(out,node,depth))) goto done;
CAT("\n");
}
break;
default: abort(); break;
}
done:
nullfree(fqn);
return THROW(ret);
}
