mirror/netcdf-c
2
0
Fork 0
mirror of https://github.com/Unidata/netcdf-c.git synced 2024-12-09 08:11:38 +08:00
Code Issues Packages Projects Releases Wiki Activity
aca696afb0
netcdf-c/libdap2/dapdump.c

633 lines
17 KiB
C
Raw Normal View History

2011-04-18 02:56:10 +08:00
/*********************************************************************
* Copyright 1993, UCAR/Unidata
* See netcdf/COPYRIGHT file for copying and redistribution conditions.
* $Header: /upc/share/CVS/netcdf-3/libncdap3/dapdump.c,v 1.21 2010/05/26 21:43:31 dmh Exp $
*********************************************************************/
1. The duplicate name checking in oc2 was effectively o(n cubed); modified to be o(n squared). 2. If the list of prefetched variables is too long, (something on the order of 400 variables), then the server may reject it. Modified code so that in the case that the set of prefetch'd vars is the in fact all variables, it does not create a long request. This does not actually solve the problem if the prefetch list is long, but not all inclusive.
2013-07-28 04:54:50 +08:00
2011-04-18 02:56:10 +08:00
#include "config.h"
#ifdef USE_PARALLEL
#include "netcdf_par.h"
#endif
#include "ncdap3.h"
#include "dapdump.h"
completely rewritten constraint system
2011-11-14 12:20:19 +08:00
#include "dceconstraints.h"
2011-04-18 02:56:10 +08:00
#define CHECK(n) if((n) != NC_NOERR) {return (n);} else {}
completely rewritten constraint system
2011-11-14 12:20:19 +08:00
static void dumptreer(CDFnode* root, NCbytes* buf, int indent, int visible);
2011-04-18 02:56:10 +08:00
int
dumpmetadata(int ncid, NChdr** hdrp)
{
int stat,i,j,k;
NChdr* hdr = (NChdr*)calloc(1,sizeof(NChdr));
MEMCHECK(hdr,NC_ENOMEM);
hdr->ncid = ncid;
hdr->content = ncbytesnew();
if(hdrp) *hdrp = hdr;
stat = nc_inq(hdr->ncid,
&hdr->ndims,
&hdr->nvars,
&hdr->ngatts,
&hdr->unlimid);
CHECK(stat);
if(ncdap3debug > 0) {
fprintf(stdout,"ncid=%d ngatts=%d ndims=%d nvars=%d unlimid=%d\n",
hdr->ncid,hdr->ngatts,hdr->ndims,hdr->nvars,hdr->unlimid);
}
hdr->gatts = (NCattribute*)calloc(1,hdr->ngatts*sizeof(NCattribute));
MEMCHECK(hdr->gatts,NC_ENOMEM);
if(hdr->ngatts > 0)
fprintf(stdout,"global attributes:\n");
for(i=0;i<hdr->ngatts;i++) {
NCattribute* att = &hdr->gatts[i];
char attname[NC_MAX_NAME];
nc_type nctype;
size_t typesize;
size_t nvalues;
stat = nc_inq_attname(hdr->ncid,NC_GLOBAL,i,attname);
CHECK(stat);
att->name = nulldup(attname);
stat = nc_inq_att(hdr->ncid,NC_GLOBAL,att->name,&nctype,&nvalues);
CHECK(stat);
att->etype = nctypetodap(nctype);
typesize = nctypesizeof(att->etype);
fprintf(stdout,"\t[%d]: name=%s type=%s values(%lu)=",
i,att->name,nctypetostring(octypetonc(att->etype)),
(unsigned long)nvalues);
if(nctype == NC_CHAR) {
size_t len = typesize*nvalues;
char* values = (char*)malloc(len+1);/* for null terminate*/
MEMCHECK(values,NC_ENOMEM);
stat = nc_get_att(hdr->ncid,NC_GLOBAL,att->name,values);
CHECK(stat);
values[len] = '\0';
fprintf(stdout," '%s'",values);
} else {
size_t len = typesize*nvalues;
char* values = (char*)malloc(len);
MEMCHECK(values,NC_ENOMEM);
stat = nc_get_att(hdr->ncid,NC_GLOBAL,att->name,values);
CHECK(stat);
for(k=0;k<nvalues;k++) {
fprintf(stdout," ");
dumpdata1(octypetonc(att->etype),k,values);
}
}
fprintf(stdout,"\n");
}
hdr->dims = (Dim*)malloc(hdr->ndims*sizeof(Dim));
MEMCHECK(hdr->dims,NC_ENOMEM);
for(i=0;i<hdr->ndims;i++) {
hdr->dims[i].dimid = i;
stat = nc_inq_dim(hdr->ncid,
hdr->dims[i].dimid,
hdr->dims[i].name,
&hdr->dims[i].size);
CHECK(stat);
fprintf(stdout,"dim[%d]: name=%s size=%lu\n",
i,hdr->dims[i].name,(unsigned long)hdr->dims[i].size);
}
hdr->vars = (Var*)malloc(hdr->nvars*sizeof(Var));
MEMCHECK(hdr->vars,NC_ENOMEM);
for(i=0;i<hdr->nvars;i++) {
Var* var = &hdr->vars[i];
nc_type nctype;
var->varid = i;
stat = nc_inq_var(hdr->ncid,
var->varid,
var->name,
&nctype,
&var->ndims,
var->dimids,
&var->natts);
CHECK(stat);
var->nctype = (nctype);
fprintf(stdout,"var[%d]: name=%s type=%s |dims|=%d",
i,
var->name,
nctypetostring(var->nctype),
var->ndims);
fprintf(stdout," dims={");
for(j=0;j<var->ndims;j++) {
fprintf(stdout," %d",var->dimids[j]);
}
fprintf(stdout,"}\n");
var->atts = (NCattribute*)malloc(var->natts*sizeof(NCattribute));
MEMCHECK(var->atts,NC_ENOMEM);
for(j=0;j<var->natts;j++) {
NCattribute* att = &var->atts[j];
char attname[NC_MAX_NAME];
size_t typesize;
char* values;
nc_type nctype;
size_t nvalues;
stat = nc_inq_attname(hdr->ncid,var->varid,j,attname);
CHECK(stat);
att->name = nulldup(attname);
stat = nc_inq_att(hdr->ncid,var->varid,att->name,&nctype,&nvalues);
CHECK(stat);
att->etype = nctypetodap(nctype);
typesize = nctypesizeof(att->etype);
values = (char*)malloc(typesize*nvalues);
MEMCHECK(values,NC_ENOMEM);
stat = nc_get_att(hdr->ncid,var->varid,att->name,values);
CHECK(stat);
fprintf(stdout,"\tattr[%d]: name=%s type=%s values(%lu)=",
j,att->name,nctypetostring(octypetonc(att->etype)),(unsigned long)nvalues);
for(k=0;k<nvalues;k++) {
fprintf(stdout," ");
dumpdata1(octypetonc(att->etype),k,values);
}
fprintf(stdout,"\n");
}
}
fflush(stdout);
return NC_NOERR;
}
void
dumpdata1(nc_type nctype, size_t index, char* data)
{
switch (nctype) {
case NC_CHAR:
fprintf(stdout,"'%c' %hhd",data[index],data[index]);
break;
case NC_BYTE:
fprintf(stdout,"%hdB",((signed char*)data)[index]);
break;
case NC_UBYTE:
fprintf(stdout,"%huB",((unsigned char*)data)[index]);
break;
case NC_SHORT:
fprintf(stdout,"%hdS",((short*)data)[index]);
break;
case NC_USHORT:
fprintf(stdout,"%hdUS",((unsigned short*)data)[index]);
break;
case NC_INT:
fprintf(stdout,"%d",((int*)data)[index]);
break;
case NC_UINT:
fprintf(stdout,"%uU",((unsigned int*)data)[index]);
break;
case NC_FLOAT:
fprintf(stdout,"%#gF",((float*)data)[index]);
break;
case NC_DOUBLE:
fprintf(stdout,"%#gD",((double*)data)[index]);
break;
case NC_STRING:
fprintf(stdout,"\"%s\"",((char**)data)[index]);
break;
default:
fprintf(stdout,"Unknown type: %i",nctype);
break;
}
fflush(stdout);
}
/* Following should be kept consistent with
the makeXXXstring3 routines in constraints3.c
*/
/* Convert an NCprojection instance into a string
that can be used with the url
*/
char*
dumpprojections(NClist* projections)
{
completely rewritten constraint system
2011-11-14 12:20:19 +08:00
char* tmp;
int v = dceverbose;
dceverbose = 1;
tmp = dcelisttostring(projections,",");
dceverbose = v;
return tmp;
2011-04-18 02:56:10 +08:00
}
char*
dumpprojection(DCEprojection* proj)
{
completely rewritten constraint system
2011-11-14 12:20:19 +08:00
char* tmp;
int v = dceverbose;
dceverbose = 1;
tmp = dcetostring((DCEnode*)proj);
dceverbose = v;
return tmp;
2011-04-18 02:56:10 +08:00
}
char*
dumpselections(NClist* selections)
{
return dcelisttostring(selections,"&");
}
char*
dumpselection(DCEselection* sel)
{
return dcetostring((DCEnode*)sel);
}
char*
dumpconstraint(DCEconstraint* con)
{
completely rewritten constraint system
2011-11-14 12:20:19 +08:00
char* tmp;
int v = dceverbose;
dceverbose = 1;
tmp = dcetostring((DCEnode*)con);
dceverbose = v;
return tmp;
2011-04-18 02:56:10 +08:00
}
char*
dumpsegments(NClist* segments)
{
return dcelisttostring(segments,".");
}
char*
dumppath(CDFnode* leaf)
{
NClist* path = nclistnew();
NCbytes* buf = ncbytesnew();
char* result;
int i;
if(leaf == NULL) return nulldup("");
collectnodepath3(leaf,path,!WITHDATASET);
for(i=0;i<nclistlength(path);i++) {
CDFnode* node = (CDFnode*)nclistget(path,i);
if(i > 0) ncbytescat(buf,".");
completely rewritten constraint system
2011-11-14 12:20:19 +08:00
ncbytescat(buf,node->ncbasename);
2011-04-18 02:56:10 +08:00
}
result = ncbytesdup(buf);
ncbytesfree(buf);
nclistfree(path);
return result;
}
static void
dumpindent(int indent, NCbytes* buf)
{
static char* indentstr = " ";
int i;
for(i=0;i<indent;i++) ncbytescat(buf,indentstr);
}
static void
dumptreer1(CDFnode* root, NCbytes* buf, int indent, char* tag, int visible)
{
int i;
dumpindent(indent,buf);
ncbytescat(buf,tag);
ncbytescat(buf," {\n");
for(i=0;i<nclistlength(root->subnodes);i++) {
CDFnode* node = (CDFnode*)nclistget(root->subnodes,i);
Primary change is to add ability to do prefetch on either a lazy or eager basis. Lazy means that the prefetch does not occur until and unless the client actually makes a get_var request. Also repaired a problem where doing prefetch wrt a url that has a constraint will prefetch a whole variable if its constrained size is small enough, even if the underlying variable is too large to warrant prefetch.
2013-03-03 12:06:43 +08:00
if(visible && root->invisible) continue;
2011-04-18 02:56:10 +08:00
if(root->nctype == NC_Grid) {
if(i==0) {
dumpindent(indent+1,buf);
ncbytescat(buf,"Array:\n");
} else if(i==1) {
dumpindent(indent+1,buf);
ncbytescat(buf,"Maps:\n");
}
dumptreer(node,buf,indent+2,visible);
} else {
dumptreer(node,buf,indent+1,visible);
}
}
dumpindent(indent,buf);
ncbytescat(buf,"} ");
jira: NCF-232: bad conversion of grids
2013-02-26 12:31:06 +08:00
ncbytescat(buf,(root->ncbasename?root->ncbasename:"<?>"));
2011-04-18 02:56:10 +08:00
}
static void
dumptreer(CDFnode* root, NCbytes* buf, int indent, int visible)
{
int i;
char* primtype = NULL;
completely rewritten constraint system
2011-11-14 12:20:19 +08:00
NClist* dimset = NULL;
Primary change is to add ability to do prefetch on either a lazy or eager basis. Lazy means that the prefetch does not occur until and unless the client actually makes a get_var request. Also repaired a problem where doing prefetch wrt a url that has a constraint will prefetch a whole variable if its constrained size is small enough, even if the underlying variable is too large to warrant prefetch.
2013-03-03 12:06:43 +08:00
if(visible && root->invisible) return;
2011-04-18 02:56:10 +08:00
switch (root->nctype) {
case NC_Dataset:
dumptreer1(root,buf,indent,"Dataset",visible);
break;
case NC_Sequence:
dumptreer1(root,buf,indent,"Sequence",visible);
break;
case NC_Structure:
dumptreer1(root,buf,indent,"Structure",visible);
break;
case NC_Grid:
dumptreer1(root,buf,indent,"Grid",visible);
break;
move from oc1.0 to oc2.0; create new dir oc2
2012-08-01 04:34:13 +08:00
case NC_Atomic:
2011-04-18 02:56:10 +08:00
switch (root->etype) {
case NC_BYTE: primtype = "byte"; break;
case NC_CHAR: primtype = "char"; break;
case NC_SHORT: primtype = "short"; break;
case NC_INT: primtype = "int"; break;
case NC_FLOAT: primtype = "float"; break;
case NC_DOUBLE: primtype = "double"; break;
case NC_UBYTE: primtype = "ubyte"; break;
case NC_USHORT: primtype = "ushort"; break;
case NC_UINT: primtype = "uint"; break;
case NC_INT64: primtype = "int64"; break;
case NC_UINT64: primtype = "uint64"; break;
case NC_STRING: primtype = "string"; break;
default: break;
}
dumpindent(indent,buf);
ncbytescat(buf,primtype);
ncbytescat(buf," ");
jira: NCF-232: bad conversion of grids
2013-02-26 12:31:06 +08:00
ncbytescat(buf,(root->ncbasename?root->ncbasename:"<?>"));
2011-04-18 02:56:10 +08:00
break;
default: break;
}
completely rewritten constraint system
2011-11-14 12:20:19 +08:00
if(nclistlength(root->array.dimsetplus) > 0) dimset = root->array.dimsetplus;
else if(nclistlength(root->array.dimset0) > 0) dimset = root->array.dimset0;
if(dimset != NULL) {
for(i=0;i<nclistlength(dimset);i++) {
CDFnode* dim = (CDFnode*)nclistget(dimset,i);
2011-04-18 02:56:10 +08:00
char tmp[64];
ncbytescat(buf,"[");
completely rewritten constraint system
2011-11-14 12:20:19 +08:00
if(dim->ncbasename != NULL) {
ncbytescat(buf,dim->ncbasename);
2011-04-18 02:56:10 +08:00
ncbytescat(buf,"=");
}
snprintf(tmp,sizeof(tmp),"%lu",(unsigned long)dim->dim.declsize);
ncbytescat(buf,tmp);
ncbytescat(buf,"]");
}
}
ncbytescat(buf,";\n");
}
char*
dumptree(CDFnode* root)
{
NCbytes* buf = ncbytesnew();
char* result;
dumptreer(root,buf,0,0);
result = ncbytesdup(buf);
ncbytesfree(buf);
return result;
}
char*
dumpvisible(CDFnode* root)
{
NCbytes* buf = ncbytesnew();
char* result;
dumptreer(root,buf,0,1);
result = ncbytesdup(buf);
ncbytesfree(buf);
return result;
}
/* Provide detailed data on a CDFnode */
char*
dumpnode(CDFnode* node)
{
NCbytes* buf = ncbytesnew();
char* result;
int i;
char* nctype = NULL;
char* primtype = NULL;
char tmp[1024];
switch (node->nctype) {
case NC_Dataset: nctype = "Dataset"; break;
case NC_Sequence: nctype = "Sequence"; break;
case NC_Structure: nctype = "Structure"; break;
case NC_Grid: nctype = "Grid"; break;
move from oc1.0 to oc2.0; create new dir oc2
2012-08-01 04:34:13 +08:00
case NC_Atomic:
2011-04-18 02:56:10 +08:00
switch (node->etype) {
case NC_BYTE: primtype = "byte"; break;
case NC_CHAR: primtype = "char"; break;
case NC_SHORT: primtype = "short"; break;
case NC_INT: primtype = "int"; break;
case NC_FLOAT: primtype = "float"; break;
case NC_DOUBLE: primtype = "double"; break;
case NC_UBYTE: primtype = "ubyte"; break;
case NC_USHORT: primtype = "ushort"; break;
case NC_UINT: primtype = "uint"; break;
case NC_INT64: primtype = "int64"; break;
case NC_UINT64: primtype = "uint64"; break;
case NC_STRING: primtype = "string"; break;
default: break;
}
break;
default: break;
}
snprintf(tmp,sizeof(tmp),"%s %s {\n",
completely rewritten constraint system
2011-11-14 12:20:19 +08:00
(nctype?nctype:primtype),node->ocname);
2011-04-18 02:56:10 +08:00
ncbytescat(buf,tmp);
fix dap string handling
2012-02-04 05:31:50 +08:00
snprintf(tmp,sizeof(tmp),"ocnode=%lx\n",(unsigned long)node->ocnode);
2011-04-18 02:56:10 +08:00
ncbytescat(buf,tmp);
snprintf(tmp,sizeof(tmp),"container=%s\n",
completely rewritten constraint system
2011-11-14 12:20:19 +08:00
(node->container?node->container->ocname:"null"));
2011-04-18 02:56:10 +08:00
ncbytescat(buf,tmp);
snprintf(tmp,sizeof(tmp),"root=%s\n",
completely rewritten constraint system
2011-11-14 12:20:19 +08:00
(node->root?node->root->ocname:"null"));
2011-04-18 02:56:10 +08:00
ncbytescat(buf,tmp);
snprintf(tmp,sizeof(tmp),"ncbasename=%s\n",node->ncbasename);
ncbytescat(buf,tmp);
snprintf(tmp,sizeof(tmp),"ncfullname=%s\n",node->ncfullname);
ncbytescat(buf,tmp);
update nchashmap; move some old stuff in libdap2; fix new debug code
2012-08-20 05:12:35 +08:00
snprintf(tmp,sizeof(tmp),"|subnodes|=%ld\n",nclistlength(node->subnodes));
2011-04-18 02:56:10 +08:00
ncbytescat(buf,tmp);
snprintf(tmp,sizeof(tmp),"externaltype=%d\n",node->externaltype);
ncbytescat(buf,tmp);
snprintf(tmp,sizeof(tmp),"ncid=%d\n",node->ncid);
ncbytescat(buf,tmp);
snprintf(tmp,sizeof(tmp),"maxstringlength=%ld\n",node->maxstringlength);
ncbytescat(buf,tmp);
snprintf(tmp,sizeof(tmp),"sequencelimit=%ld\n",node->sequencelimit);
ncbytescat(buf,tmp);
snprintf(tmp,sizeof(tmp),"usesequence=%d\n",node->usesequence);
ncbytescat(buf,tmp);
snprintf(tmp,sizeof(tmp),"elided=%d\n",node->elided);
ncbytescat(buf,tmp);
Primary change is to add ability to do prefetch on either a lazy or eager basis. Lazy means that the prefetch does not occur until and unless the client actually makes a get_var request. Also repaired a problem where doing prefetch wrt a url that has a constraint will prefetch a whole variable if its constrained size is small enough, even if the underlying variable is too large to warrant prefetch.
2013-03-03 12:06:43 +08:00
snprintf(tmp,sizeof(tmp),"invisible=%d\n",node->invisible);
2011-04-18 02:56:10 +08:00
ncbytescat(buf,tmp);
snprintf(tmp,sizeof(tmp),"attachment=%s\n",
completely rewritten constraint system
2011-11-14 12:20:19 +08:00
(node->attachment?node->attachment->ocname:"null"));
2011-04-18 02:56:10 +08:00
ncbytescat(buf,tmp);
update nchashmap; move some old stuff in libdap2; fix new debug code
2012-08-20 05:12:35 +08:00
snprintf(tmp,sizeof(tmp),"rank=%lu\n",nclistlength(node->array.dimset0));
2011-04-18 02:56:10 +08:00
ncbytescat(buf,tmp);
completely rewritten constraint system
2011-11-14 12:20:19 +08:00
for(i=0;i<nclistlength(node->array.dimset0);i++) {
CDFnode* dim = (CDFnode*)nclistget(node->array.dimset0,i);
2011-04-18 02:56:10 +08:00
snprintf(tmp,sizeof(tmp),"dims[%d]={\n",i);
ncbytescat(buf,tmp);
completely rewritten constraint system
2011-11-14 12:20:19 +08:00
snprintf(tmp,sizeof(tmp)," ocname=%s\n",dim->ocname);
ncbytescat(buf,tmp);
snprintf(tmp,sizeof(tmp)," ncbasename=%s\n",dim->ncbasename);
2011-04-18 02:56:10 +08:00
ncbytescat(buf,tmp);
snprintf(tmp,sizeof(tmp)," dimflags=%u\n",
(unsigned int)dim->dim.dimflags);
ncbytescat(buf,tmp);
snprintf(tmp,sizeof(tmp)," declsize=%lu\n",
(unsigned long)dim->dim.declsize);
ncbytescat(buf,tmp);
snprintf(tmp,sizeof(tmp)," }\n");
ncbytescat(buf,tmp);
}
result = ncbytesdup(buf);
ncbytesfree(buf);
return result;
}
char*
dumpalign(NCalignment* ncalign)
{
char* result;
char tmp[1024];
if(ncalign == NULL)
result = nulldup("NCalignment{size=-- alignment=-- offset=--}");
else {
snprintf(tmp,sizeof(tmp),"NCalignment{size=%lu alignment=%lu offset=%lu}",
ncalign->size,ncalign->alignment,ncalign->offset);
result = nulldup(tmp);
}
return result;
}
char*
dumpcachenode(NCcachenode* node)
{
char* result = NULL;
char tmp[8192];
int i;
NCbytes* buf;
if(node == NULL) return strdup("cachenode{null}");
buf = ncbytesnew();
completely rewritten constraint system
2011-11-14 12:20:19 +08:00
result = buildconstraintstring3(node->constraint);
2011-04-18 02:56:10 +08:00
snprintf(tmp,sizeof(tmp),"cachenode%s(%lx){size=%lu; constraint=%s; vars=",
1. The duplicate name checking in oc2 was effectively o(n cubed); modified to be o(n squared). 2. If the list of prefetched variables is too long, (something on the order of 400 variables), then the server may reject it. Modified code so that in the case that the set of prefetch'd vars is the in fact all variables, it does not create a long request. This does not actually solve the problem if the prefetch list is long, but not all inclusive.
2013-07-28 04:20:13 +08:00
node->isprefetch?"*":"",
2011-04-18 02:56:10 +08:00
(unsigned long)node,
(unsigned long)node->xdrsize,
completely rewritten constraint system
2011-11-14 12:20:19 +08:00
result);
2011-04-18 02:56:10 +08:00
ncbytescat(buf,tmp);
if(nclistlength(node->vars)==0)
ncbytescat(buf,"null");
else for(i=0;i<nclistlength(node->vars);i++) {
CDFnode* var = (CDFnode*)nclistget(node->vars,i);
if(i > 0) ncbytescat(buf,",");
fix dap string handling
2012-02-04 05:31:50 +08:00
ncbytescat(buf,makecdfpathstring3(var,"."));
2011-04-18 02:56:10 +08:00
}
ncbytescat(buf,"}");
result = ncbytesdup(buf);
ncbytesfree(buf);
return result;
}
char*
dumpcache(NCcache* cache)
{
char* result = NULL;
char tmp[8192];
int i;
NCbytes* buf;
if(cache == NULL) return strdup("cache{null}");
buf = ncbytesnew();
snprintf(tmp,sizeof(tmp),"cache{limit=%lu; size=%lu;\n",
(unsigned long)cache->cachelimit,
(unsigned long)cache->cachesize);
ncbytescat(buf,tmp);
if(cache->prefetch) {
ncbytescat(buf,"\tprefetch=");
ncbytescat(buf,dumpcachenode(cache->prefetch));
ncbytescat(buf,"\n");
}
if(nclistlength(cache->nodes) > 0) {
for(i=0;i<nclistlength(cache->nodes);i++) {
NCcachenode* node = (NCcachenode*)nclistget(cache->nodes,i);
ncbytescat(buf,"\t");
ncbytescat(buf,dumpcachenode(node));
ncbytescat(buf,"\n");
}
}
ncbytescat(buf,"}");
result = ncbytesdup(buf);
ncbytesfree(buf);
return result;
}
/* This should be consistent with makeslicestring3 in constraints3.c */
char*
dumpslice(DCEslice* slice)
{
Rebuilt the compose operation in dceconstraints.c. The revisions are simpler, and I hope, clearer than the all previous versions. Part of the code taken from the ucar.nc2.Range.compose function. Modified to handle edge cases not handled in the Range.compose function.
2013-04-20 03:55:43 +08:00
char buf[8192];
char tmp[8192];
buf[0] = '\0';
if(slice->last > slice->declsize && slice->declsize > 0)
slice->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)slice->last);
} else {
snprintf(tmp,sizeof(tmp),"[%lu:%lu:%lu]",
(unsigned long)slice->first,
(unsigned long)slice->stride,
(unsigned long)slice->last);
}
strcat(buf,tmp);
return strdup(tmp);
2011-04-18 02:56:10 +08:00
}
char*
dumpslices(DCEslice* slice, unsigned int rank)
{
int i;
NCbytes* buf;
char* result = NULL;
buf = ncbytesnew();
for(i=0;i<rank;i++,slice++) {
ncbytescat(buf,dumpslice(slice));
}
result = ncbytesdup(buf);
ncbytesfree(buf);
return result;
}
completely rewritten constraint system
2011-11-14 12:20:19 +08:00
move from oc1.0 to oc2.0; create new dir oc2
2012-08-01 04:34:13 +08:00
void
dumpraw(void* o)
{
fprintf(stderr,"%s\n",dcerawtostring(o));
fflush(stderr);
}
void
dumplistraw(NClist* l)
{
fprintf(stderr,"%s\n",dcerawlisttostring(l));
fflush(stderr);
}
/* For debugging */
void
dumpstringlist(NClist* l)
{
int i;
for(i=0;i<nclistlength(l);i++) {
const char* s = (const char*)nclistget(l,i);
fprintf(stderr,"[%d]: |%s|\n",i,s);
}
fflush(stderr);
}
Reference in New Issue Copy Permalink