mirror of
https://github.com/Unidata/netcdf-c.git
synced 2024-11-21 03:13:42 +08:00
c99058741a
Ncgen is unable to resolve ambiguous references to an enum constant when two different enums have same econstant name. Solved by allowing more specific forms for econstant references. 1. /.../enumname.enumconstname 2. enumname.enumconstname 3. enumconstname Case 1 is resolved by using the econstant in the specific enum definition. If none is found, an error is reported. Case 2 is resolved by 1. finding an enclosing group with an enum definition with the specified name and containing the specified econstant. If there are more than one, then an error is reported 2. finding all enum definitions in the dataset that have the specified enum name and contain the specified econstant. If more than one is found, then an error is reported. If the above two methods fail, then report an error. Case 3 is similar to case 2, but all enums, irrespective of name are used if they contains the specified enum constant. The ref_tst_econst.cdl test in ncdump is causing ncdump to fail. So there may be yet some problem.
299 lines
6.5 KiB
C
299 lines
6.5 KiB
C
/*********************************************************************
|
|
* Copyright 2009, UCAR/Unidata
|
|
* See netcdf/COPYRIGHT file for copying and redistribution conditions.
|
|
*********************************************************************/
|
|
/* $Id: dump.c,v 1.3 2010/05/24 19:59:57 dmh Exp $ */
|
|
/* $Header: /upc/share/CVS/netcdf-3/ncgen/dump.c,v 1.3 2010/05/24 19:59:57 dmh Exp $ */
|
|
|
|
#include "includes.h"
|
|
#include "dump.h"
|
|
|
|
#define DEBUGSRC
|
|
|
|
/* Forward */
|
|
static void dumpdataprim(NCConstant*,Bytebuffer*);
|
|
|
|
char*
|
|
indentstr(int n)
|
|
{
|
|
static char indentline[1024];
|
|
memset(indentline,' ',n+1);
|
|
indentline[n+1] = '\0';
|
|
return indentline;
|
|
}
|
|
|
|
|
|
void
|
|
dumpconstant(NCConstant* con, char* tag)
|
|
{
|
|
Bytebuffer* buf = bbNew();
|
|
Datalist* dl = builddatalist(1);
|
|
dlappend(dl,con);
|
|
bufdump(dl,buf);
|
|
fprintf(stderr,"%s: %s\n",tag,bbContents(buf));
|
|
bbFree(buf);
|
|
}
|
|
|
|
void
|
|
dumpdatalist(Datalist* list, char* tag)
|
|
{
|
|
Bytebuffer* buf = bbNew();
|
|
bufdump(list,buf);
|
|
fprintf(stderr,"%s: %s\n",tag,bbContents(buf));
|
|
bbFree(buf);
|
|
}
|
|
|
|
void
|
|
bufdump(Datalist* list, Bytebuffer* buf)
|
|
{
|
|
int i;
|
|
NCConstant* dp;
|
|
unsigned int count;
|
|
|
|
if(list == NULL) {
|
|
bbCat(buf,"NULL");
|
|
return;
|
|
}
|
|
|
|
count = list->length;
|
|
for(dp=list->data,i=0;i<count;i++,dp++) {
|
|
switch (dp->nctype) {
|
|
case NC_COMPOUND:
|
|
bbCat(buf,"{");
|
|
bufdump(dp->value.compoundv,buf);
|
|
bbCat(buf,"}");
|
|
break;
|
|
case NC_ARRAY:
|
|
bbCat(buf,"[");
|
|
bufdump(dp->value.compoundv,buf);
|
|
bbCat(buf,"]");
|
|
break;
|
|
case NC_VLEN:
|
|
bbCat(buf,"{*");
|
|
bufdump(dp->value.compoundv,buf);
|
|
bbCat(buf,"}");
|
|
break;
|
|
default:
|
|
if(isprimplus(dp->nctype) || dp->nctype == NC_FILLVALUE) {
|
|
bbCat(buf," ");
|
|
dumpdataprim(dp,buf);
|
|
} else {
|
|
char tmp[64];
|
|
sprintf(tmp,"?%d? ",dp->nctype);
|
|
bbCat(buf,tmp);
|
|
} break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
dumpdataprim(NCConstant* ci, Bytebuffer* buf)
|
|
{
|
|
char tmp[64];
|
|
ASSERT(isprimplus(ci->nctype) || ci->nctype == NC_FILLVALUE);
|
|
switch (ci->nctype) {
|
|
case NC_CHAR: {
|
|
bbCat(buf,"'");
|
|
escapifychar(ci->value.charv,tmp,'\'');
|
|
bbCat(buf,tmp);
|
|
bbCat(buf,"'");
|
|
} break;
|
|
case NC_BYTE:
|
|
sprintf(tmp,"%hhd",ci->value.int8v);
|
|
bbCat(buf,tmp);
|
|
break;
|
|
case NC_SHORT:
|
|
sprintf(tmp,"%hd",ci->value.int16v);
|
|
bbCat(buf,tmp);
|
|
break;
|
|
case NC_INT:
|
|
sprintf(tmp,"%d",ci->value.int32v);
|
|
bbCat(buf,tmp);
|
|
break;
|
|
case NC_FLOAT:
|
|
sprintf(tmp,"%g",ci->value.floatv);
|
|
bbCat(buf,tmp);
|
|
break;
|
|
case NC_DOUBLE:
|
|
sprintf(tmp,"%lg",ci->value.doublev);
|
|
bbCat(buf,tmp);
|
|
break;
|
|
case NC_UBYTE:
|
|
sprintf(tmp,"%hhu",ci->value.int8v);
|
|
bbCat(buf,tmp);
|
|
break;
|
|
case NC_USHORT:
|
|
sprintf(tmp,"%hu",ci->value.uint16v);
|
|
bbCat(buf,tmp);
|
|
break;
|
|
case NC_UINT:
|
|
sprintf(tmp,"%u",ci->value.uint32v);
|
|
bbCat(buf,tmp);
|
|
break;
|
|
case NC_INT64:
|
|
sprintf(tmp,"%lld",ci->value.int64v);
|
|
bbCat(buf,tmp);
|
|
break;
|
|
case NC_UINT64:
|
|
sprintf(tmp,"%llu",ci->value.uint64v);
|
|
bbCat(buf,tmp);
|
|
break;
|
|
case NC_ECONST:
|
|
sprintf(tmp,"%s",ci->value.enumv->fqn);
|
|
bbCat(buf,tmp);
|
|
break;
|
|
case NC_STRING:
|
|
bbCat(buf,"\"");
|
|
bbCat(buf,ci->value.stringv.stringv);
|
|
bbCat(buf,"\"");
|
|
break;
|
|
case NC_OPAQUE:
|
|
bbCat(buf,"0x");
|
|
bbCat(buf,ci->value.opaquev.stringv);
|
|
break;
|
|
case NC_FILLVALUE:
|
|
bbCat(buf,"_");
|
|
break;
|
|
default: PANIC1("dumpdataprim: bad type code:%d",ci->nctype);
|
|
}
|
|
}
|
|
|
|
void
|
|
dumpgroup(Symbol* g)
|
|
{
|
|
if(debug <= 1) return;
|
|
fdebug("group %s {\n",(g==NULL?"null":g->name));
|
|
if(g != NULL && g->subnodes != NULL) {
|
|
int i;
|
|
for(i=0;i<listlength(g->subnodes);i++) {
|
|
Symbol* sym = (Symbol*)listget(g->subnodes,i);
|
|
char* tname;
|
|
if(sym->objectclass == NC_PRIM
|
|
|| sym->objectclass == NC_TYPE) {
|
|
tname = nctypename(sym->subclass);
|
|
} else
|
|
tname = nctypename(sym->objectclass);
|
|
fdebug(" %3d: %s\t%s\t%s\n",
|
|
i,
|
|
sym->name,
|
|
tname,
|
|
(sym->ref.is_ref?"ref":"")
|
|
);
|
|
}
|
|
}
|
|
fdebug("}\n");
|
|
}
|
|
|
|
void
|
|
dumpconstant1(NCConstant* con)
|
|
{
|
|
switch (con->nctype) {
|
|
case NC_COMPOUND: {
|
|
Datalist* dl = con->value.compoundv;
|
|
Bytebuffer* buf = bbNew();
|
|
bufdump(dl,buf);
|
|
/* fprintf(stderr,"(0x%lx){",(unsigned long)dl);*/
|
|
fprintf(stderr,"{%s}",bbDup(buf));
|
|
bbFree(buf);
|
|
} break;
|
|
case NC_STRING:
|
|
if(con->value.stringv.len > 0 && con->value.stringv.stringv != NULL)
|
|
fprintf(stderr,"\"%s\"",con->value.stringv.stringv);
|
|
else
|
|
fprintf(stderr,"\"\"");
|
|
break;
|
|
case NC_OPAQUE:
|
|
if(con->value.opaquev.len > 0 && con->value.opaquev.stringv != NULL)
|
|
fprintf(stderr,"0x%s",con->value.opaquev.stringv);
|
|
else
|
|
fprintf(stderr,"0x--");
|
|
break;
|
|
case NC_ECONST:
|
|
fprintf(stderr,"%s",(con->value.enumv==NULL?"?":con->value.enumv->name));
|
|
break;
|
|
case NC_FILLVALUE:
|
|
fprintf(stderr,"_");
|
|
break;
|
|
case NC_CHAR:
|
|
fprintf(stderr,"'%c'",con->value.charv);
|
|
break;
|
|
case NC_BYTE:
|
|
fprintf(stderr,"%hhd",con->value.int8v);
|
|
break;
|
|
case NC_UBYTE:
|
|
fprintf(stderr,"%hhu",con->value.uint8v);
|
|
break;
|
|
case NC_SHORT:
|
|
fprintf(stderr,"%hd",con->value.int16v);
|
|
break;
|
|
case NC_USHORT:
|
|
fprintf(stderr,"%hu",con->value.uint16v);
|
|
break;
|
|
case NC_INT:
|
|
fprintf(stderr,"%d",con->value.int32v);
|
|
break;
|
|
case NC_UINT:
|
|
fprintf(stderr,"%u",con->value.uint32v);
|
|
break;
|
|
case NC_INT64:
|
|
fprintf(stderr,"%lld",con->value.int64v);
|
|
break;
|
|
case NC_UINT64:
|
|
fprintf(stderr,"%llu",con->value.uint64v);
|
|
break;
|
|
case NC_FLOAT:
|
|
fprintf(stderr,"%g",con->value.floatv);
|
|
break;
|
|
case NC_DOUBLE:
|
|
fprintf(stderr,"%g",con->value.doublev);
|
|
break;
|
|
default:
|
|
fprintf(stderr,"<unknown>");
|
|
break;
|
|
}
|
|
fflush(stderr);
|
|
}
|
|
|
|
#define MAXELEM 8
|
|
#define MAXDEPTH 4
|
|
|
|
void
|
|
dumpsrc0(Datasrc* src,char* tag)
|
|
{
|
|
int i, count, index, depth;
|
|
depth = MAXDEPTH;
|
|
count = src->length;
|
|
index = src->index;
|
|
if(count > MAXELEM) count = MAXELEM;
|
|
if(index > count) index = count;
|
|
fprintf(stderr,"%s:: ",(tag?tag:""));
|
|
do {
|
|
fprintf(stderr,"[%d/%d]",src->index,src->length);
|
|
for(i=0;i<index;i++) {
|
|
fprintf(stderr," ");
|
|
dumpconstant1(&src->data[i]);
|
|
}
|
|
fprintf(stderr,"^");
|
|
for(i=index;i<count;i++) {
|
|
fprintf(stderr," ");
|
|
dumpconstant1(&src->data[i]);
|
|
}
|
|
if(count < src->length) fprintf(stderr,"...");
|
|
fprintf(stderr," | ");
|
|
src = src->prev;
|
|
} while(src != NULL && depth > 0);
|
|
if(src != NULL) fprintf(stderr,"---");
|
|
fprintf(stderr,"\n");
|
|
fflush(stderr);
|
|
}
|
|
|
|
void
|
|
dumpsrc(Datasrc* src,char* tag)
|
|
{
|
|
#ifndef DEBUGSRC
|
|
if(debug == 0) return;
|
|
#endif
|
|
dumpsrc0(src,tag);
|
|
}
|