mirror/netcdf-c
2
0
Fork 0
mirror of https://github.com/Unidata/netcdf-c.git synced 2025-03-31 17:50:26 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fixed bug NCF-144 (ncdump of variables with multiple unlimited

Browse Source 
dimensions).  Added comprehensive tests that include variables with
lots of combinations of 0 through 4 fixed and unlimited dimensions.
This commit is contained in:
Russ Rew 2012-11-16 21:37:43 +00:00
parent afa67452f6
commit 8e98e3727d
15 changed files with 492 additions and 184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libsrc4/nc4file.c
View File

@ -2304,7 +2304,7 @@ nc4_open_file(const char *path, int mode, MPI_Comm comm,
#endif
if (!nc4_info) return retval;
if (nc4_info->hdfid > 0) H5Fclose(nc4_info->hdfid);
if (nc4_info) free(nc4_info);
free(nc4_info);
return retval;
}

6
ncdump/Makefile.am
View File

@ -48,7 +48,7 @@ TESTS += tst_create_files tst_group_data tst_enum_data tst_opaque_data \
tst_string_data tst_vlen_data tst_comp tst_comp2 tst_nans \
tst_special_atts tst_netcdf4.sh tst_h_rdc0 tst_unicode tst_fillbug \
tst_fillbug.sh tst_netcdf4_4.sh tst_compress tst_nccopy4.sh \
tst_grp_spec.sh
tst_grp_spec.sh tst_mud.sh
if EXTRA_TESTS
TESTS += run_back_comp_tests.sh
@ -101,7 +101,7 @@ tst_vlen_data.cdl tst_solar_1.cdl tst_format_att.cdl tst_inflated.nc \
tmp_subset.cdl tst_inflated4.nc tst_deflated.nc tst_chunking.nc tmp*.nc \
tst_charfill.nc tmp_tst_charfill.cdl \
iter.* \
tst_nc_test_netcdf4_4_0.cdl
tst_nc_test_netcdf4_4_0.cdl tst_mud4.nc tst_mud4.cdl
# These files all have to be included with the distribution.
EXTRA_DIST = run_tests.sh tst_64bit.sh tst_output.sh test0.cdl \
@ -121,7 +121,7 @@ tst_nccopy4.sh ref_nc_test_netcdf4_4_0.nc run_back_comp_tests.sh \
ref_nc_test_netcdf4.cdl ref_tst_special_atts3.cdl tst_brecs.cdl \
ref_tst_grp_spec0.cdl ref_tst_grp_spec.cdl tst_grp_spec.sh \
ref_tst_charfill.cdl tst_charfill.cdl tst_charfill.sh \
tst_iter.sh
tst_iter.sh tst_mud.sh ref_tst_mud4.cdl
# NCGEN4 additions

126
ncdump/dumplib.c
View File

@ -453,9 +453,9 @@ idadd(idnode_t* vlist, int varid)
/*
* return true if id is member of list that vlist points to.
* return true if id is member of list that idlist points to.
*/
boolen
bool_t
idmember(const idnode_t* idlist, int id)
{
idnode_t *vp = idlist -> next;
@ -470,7 +470,7 @@ idmember(const idnode_t* idlist, int id)
* return true if group identified by grpid is member of group
* list specified on command line by -g.
*/
boolen
bool_t
group_wanted(int grpid)
{
/* If -g not specified, all groups are wanted */
@ -593,25 +593,25 @@ get_typeinfo ( int typeid ) {
/* } */
boolen
bool_t
ncbyte_val_equals(const nctype_t *this,
const void *v1p, const void *v2p) {
return ( *(signed char* )v1p == *(signed char* )v2p);
}
boolen
bool_t
ncchar_val_equals(const nctype_t *this,
const void *v1p, const void *v2p) {
return ( *(char* )v1p == *(char* )v2p);
}
boolen
bool_t
ncshort_val_equals(const nctype_t *this,
const void *v1p, const void *v2p) {
return ( *(short* )v1p == *(short* )v2p);
}
boolen
bool_t
ncint_val_equals(const nctype_t *this,
const void *v1p, const void *v2p) {
return ( *(int* )v1p == *(int* )v2p);
@ -624,7 +624,7 @@ ncint_val_equals(const nctype_t *this,
* except use floating epsilon to compare very close vals as equal
* and handle IEEE NaNs and infinities.
*/
boolen
bool_t
ncfloat_val_equals(const nctype_t *this,
const void *v1p, const void *v2p) {
float v1 = *(float* )v1p;
@ -645,7 +645,7 @@ ncfloat_val_equals(const nctype_t *this,
* except use floating epsilon to compare very close vals as equal
* and handle IEEE NaNs and infinities.
*/
boolen
bool_t
ncdouble_val_equals(const nctype_t *this,
const void *v1p, const void *v2p) {
double v1 = *(double* )v1p;
@ -662,43 +662,43 @@ ncdouble_val_equals(const nctype_t *this,
}
#ifdef USE_NETCDF4
boolen
bool_t
ncubyte_val_equals(const nctype_t *this,
const void *v1p, const void *v2p) {
return ( *(unsigned char* )v1p == *(unsigned char* )v2p);
}
boolen
bool_t
ncushort_val_equals(const nctype_t *this,
const void *v1p, const void *v2p) {
return ( *(unsigned short* )v1p == *(unsigned short* )v2p);
}
boolen
bool_t
ncuint_val_equals(const nctype_t *this,
const void *v1p, const void *v2p) {
return ( *(unsigned int* )v1p == *(unsigned int* )v2p);
}
boolen
bool_t
ncint64_val_equals(const nctype_t *this,
const void *v1p, const void *v2p) {
return ( *(long long* )v1p == *(long long* )v2p);
}
boolen
bool_t
ncuint64_val_equals(const nctype_t *this,
const void *v1p, const void *v2p) {
return ( *(unsigned long long* )v1p == *(unsigned long long* )v2p);
}
boolen
bool_t
ncstring_val_equals(const nctype_t *this,
const void *v1p, const void *v2p) {
return (strcmp(*((char **)v1p), *((char **)v2p)) == 0);
}
boolen
bool_t
ncopaque_val_equals(const nctype_t *this,
const void *v1p, const void *v2p) {
size_t nbytes = this->size;
@ -712,7 +712,7 @@ ncopaque_val_equals(const nctype_t *this,
return true;
}
boolen
bool_t
ncvlen_val_equals(const nctype_t *this,
const void *v1p, const void *v2p) {
size_t v1len = ((nc_vlen_t *)v1p)->len;
@ -740,7 +740,7 @@ ncvlen_val_equals(const nctype_t *this,
/* Determine if two compound values are equal, by testing eqaulity of
* each member field. */
boolen
bool_t
nccomp_val_equals(const nctype_t *this,
const void *v1p, const void *v2p) {
int nfields = this->nfields;
@ -1957,3 +1957,93 @@ print_type_name(int locid, int typeid) {
fputs(ename, stdout);
free(ename);
}
/* Allocate and initialize table of unlimited dimensions for ncid, for
* use by is_unlim_dim() function. If ncid is a subgroup of a netCDF
* dataset, the table will still be initialized for the whole dataset
* in which the subgroup resides. */
static int
init_is_unlim(int ncid, int **is_unlim_p)
{
int num_grps; /* total number of groups */
int num_dims = 0; /* total number of dimensions in all groups */
int num_undims = 0; /* total number of unlimited dimensions in all groups */
int *grpids = NULL; /* temporary list of all grpids */
int *dimids = NULL; /* temporary list of dimids */
int igrp;
int grpid;
#ifdef USE_NETCDF4
/* if ncid is not root group, find its ancestor root group id */
int status = nc_inq_grp_parent(ncid, &grpid);
while(status == NC_NOERR && grpid != ncid) {
ncid = grpid;
status = nc_inq_grp_parent(ncid, &grpid);
}
if (status != NC_ENOGRP)
return NC_EBADGRPID;
/* Now ncid is root group. Get total number of groups and their ids */
NC_CHECK( nc_inq_grps_full(ncid, &num_grps, NULL) );
grpids = emalloc((num_grps + 1) * sizeof(int));
NC_CHECK( nc_inq_grps_full(ncid, &num_grps, grpids) );
#define DONT_INCLUDE_PARENTS 0
/* Get all dimensions in groups and info about which ones are unlimited */
for(igrp = 0, grpid = grpids[igrp]; igrp < num_grps; igrp++) {
int ndims;
NC_CHECK( nc_inq_dimids(grpid, &ndims, NULL, DONT_INCLUDE_PARENTS) );
num_dims += ndims;
}
*is_unlim_p = emalloc((num_dims + 1) * sizeof(int));
for(igrp = 0, grpid = grpids[igrp]; igrp < num_grps; igrp++) {
int ndims, idim, *dimids, nundims;
NC_CHECK( nc_inq_dimids(grpid, &ndims, NULL, DONT_INCLUDE_PARENTS) );
dimids = emalloc((ndims + 1) * sizeof(int));
NC_CHECK( nc_inq_dimids(grpid, &ndims, dimids, DONT_INCLUDE_PARENTS) );
/* mark all dims in this group as fixed-size */
for(idim = 0; idim < ndims; idim++) {
(*is_unlim_p)[dimids[idim]] = 0;
}
NC_CHECK( nc_inq_unlimdims(grpid, &nundims, dimids) );
assert(nundims <= ndims);
/* mark the subset of dims in this group that are unlimited */
for(idim = 0; idim < nundims; idim++) {
(*is_unlim_p)[dimids[idim]] = 1;
num_undims++;
}
if(dimids)
free(dimids);
}
free(grpids);
#endif /* USE_NETCDF4 */
return NC_NOERR;
}
/* TODO: make list of these arrays for multiple open datasets, such as
* the idnode_t lists above. For now, we just have one of these, for
* the unique input dataset for this invocation of ncdump. */
#define UNLIM_NOT_INITIALIZED (-1)
/* Is dimid the dimension ID of an unlimited dimension? */
bool_t
is_unlim_dim(int ncid, int dimid) {
bool_t result; /* 0 if fixed, 1 if unlimited size */
static int for_ncid = UNLIM_NOT_INITIALIZED; /* ensure only ever called for one ncid */
#ifdef USE_NETCDF4
static int *is_unlim = NULL; /* gets allocated by init_is_unlim() */
if(for_ncid == UNLIM_NOT_INITIALIZED) {
NC_CHECK( init_is_unlim(ncid, &is_unlim) );
for_ncid = ncid;
}
result = is_unlim[dimid]; /* 0 if fixed, 1 if unlimited size */
#else
static int unlimdimid;
if(for_ncid == UNLIM_NOT_INITIALIZED) {
NC_CHECK( nc_inq_unlimdim(ncid, &unlimdimid) );
for_ncid = ncid;
}
result = (dimid == unlimdimid) ;
#endif /* USE_NETCDF4 */
return result;
}

8
ncdump/dumplib.h
View File

@ -70,10 +70,10 @@ extern idnode_t* newidlist ( void );
extern void idadd ( idnode_t* idlist, int id );
/* Test if a variable id is in variable list */
extern boolen idmember ( const idnode_t* idlist, int id );
extern bool_t idmember ( const idnode_t* idlist, int id );
/* Test if a group id is in group list */
extern boolen group_wanted ( int grpid );
extern bool_t group_wanted ( int grpid );
/* Add type info to type list */
extern void typeadd ( nctype_t *typep );
@ -142,6 +142,10 @@ void print_name(const char *name);
void print_type_name(int locid, int typeid);
int nctime_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp);
/* Return true if dimid is an unlimited dimension */
extern bool_t is_unlim_dim(int ncid, int dimid);
#ifdef __cplusplus
}
#endif

2
ncdump/indent.c
View File

@ -54,6 +54,8 @@ indent_more(){ /* increment current indent */
void
indent_less(){ /* decrement current indent */
indent -= indent_increment;
if(indent < 0)
indent = 0;
}
int

8
ncdump/nccomps.h
View File

@ -20,7 +20,7 @@ struct timeinfo_t;
* Member function to determine if values for this type are equal,
* used to compare with fill value.
*/
typedef boolen (*val_equals_func)(const struct nctype_t *this,
typedef bool_t (*val_equals_func)(const struct nctype_t *this,
const void *v1p, const void *v2p);
/*
* Member function to convert value of this type to a string. Returns
@ -72,11 +72,11 @@ typedef struct ncvar_t { /* variable */
int ndims; /* number of dimensions (rank) */
int *dims; /* dimension ids */
int natts; /* number of attributes */
boolen has_fillval; /* has a fill value defined? */
bool_t has_fillval; /* has a fill value defined? */
void* fillvalp; /* pointer to the fill value, if any */
boolen has_timeval; /* has date-time values, for -t output option */
bool_t has_timeval; /* has date-time values, for -t output option */
struct timeinfo_t *timeinfo;/* if time values, units, calendar, and origin */
boolen is_bnds_var; /* cell bounds variable, inherits timeinfo */
bool_t is_bnds_var; /* cell bounds variable, inherits timeinfo */
const char *fmt; /* overriding variable-specific format for
printing values or base values, if any */
int locid; /* group id */

6
ncdump/nccopy.c
View File

@ -91,9 +91,9 @@ nc_inq_parid(int ncid, const char *fullname, int *locidp) {
char *slash = "/"; /* groupname separator */
char *last_slash;
if(parent == NULL) {
NC_CHECK(NC_ENOMEM);
} else
last_slash = strrchr(parent, '/');
NC_CHECK(NC_ENOMEM); /* exits */
}
last_slash = strrchr(parent, '/');
if(last_slash == parent || last_slash == NULL) { /* parent is root */
free(parent);
parent = strdup(slash);

6
ncdump/ncdump.c
View File

@ -1681,7 +1681,7 @@ do_ncdumpx(int ncid, const char *path)
ncvar_t var; /* variable */
int ia; /* attribute number */
int iv; /* variable number */
idnode_t* vlist = 0; /* list for vars specified with -v option */
idnode_t* vlist = 0; /* list for vars specified with -v option */
/*
* If any vars were specified with -v option, get list of associated
@ -2327,8 +2327,8 @@ main(int argc, char *argv[])
int i;
int max_len = 80; /* default maximum line length */
int nameopt = 0;
boolen xml_out = false; /* if true, output NcML instead of CDL */
boolen kind_out = false; /* if true, just output kind of netCDF file */
bool_t xml_out = false; /* if true, output NcML instead of CDL */
bool_t kind_out = false; /* if true, just output kind of netCDF file */
#if defined(WIN32) || defined(msdos) || defined(WIN64)
putenv("PRINTF_EXPONENT_DIGITS=2"); /* Enforce unix/linux style exponent formatting. */

16
ncdump/ncdump.h
View File

@ -14,32 +14,32 @@ typedef struct { /* specification for how to format dump */
char *name; /* name specified with -n or derived from
* file name */
boolen header_only; /* if true, don't print any variable data */
bool_t header_only; /* if true, don't print any variable data */
boolen coord_vals; /* if true, print header and coordinate
bool_t coord_vals; /* if true, print header and coordinate
* dimension values (values of variables
* that are also dimensions), but no other
* variable data */
boolen brief_data_cmnts; /* if true, put // comments in data section
bool_t brief_data_cmnts; /* if true, put // comments in data section
* identifying variable and indices, useful
* for navigating through large
* multi-dimensional data lists. */
boolen full_data_cmnts; /* if true, put // comments in data section
bool_t full_data_cmnts; /* if true, put // comments in data section
* identifying every value, useful for
* navigating through large
* multi-dimensional data lists. */
boolen string_times; /* if true, output date-time values as
bool_t string_times; /* if true, output date-time values as
* human-readable strings. */
boolen iso_separator; /* if true, use 'T' separator between
bool_t iso_separator; /* if true, use 'T' separator between
* date and time components of
* human-readable strings, otherwise
* use ' ' */
boolen special_atts; /* if true, output special attributes
bool_t special_atts; /* if true, output special attributes
* for optimization characteristics:
* _Compression, _Chunking,
* _Endianness, _Format, _Checksum,
@ -50,7 +50,7 @@ typedef struct { /* specification for how to format dump */
* column major) or LANG_F (Fortran,
* 1-based, row major) */
boolen with_cache; /* For DAP URLs, get data with client-side
bool_t with_cache; /* For DAP URLs, get data with client-side
* caching when each variable is first accessed */
int nlvars; /* Number of variables specified with -v

14
ncdump/nctime0.c
View File

@ -95,7 +95,7 @@ calendar_type(int ncid, int varid) {
return ctype;
}
boolen
bool_t
is_bounds_var(char *varname, int *pargrpidp, int *parvaridp) {
bounds_node_t *bp = bounds_list.first;
for(; bp; bp = bp->next) {
@ -113,13 +113,13 @@ is_bounds_var(char *varname, int *pargrpidp, int *parvaridp) {
* where
* <time_unit>:
*/
boolen
bool_t
is_valid_time_unit(const char *units) {
char charunits[CD_MAX_RELUNITS];
char basetime_1[CD_MAX_CHARTIME];
char basetime_2[CD_MAX_CHARTIME];
int nconv1, nconv2;
boolen okunit = false;
bool_t okunit = false;
/* Allow ISO-8601 "T" date-time separator as well as blank separator */
nconv1 = sscanf(units,"%s since %[^T]T%s", charunits, basetime_1, basetime_2);
@ -158,7 +158,7 @@ is_valid_time_unit(const char *units) {
}
/* Return true only if this is a "bounds" attribute */
boolen
bool_t
is_bounds_att(ncatt_t *attp) {
if(attp->type == NC_CHAR && attp->valgp && STREQ((char *)attp->name, "bounds")) {
return true;
@ -176,7 +176,7 @@ is_bounds_att(ncatt_t *attp) {
* other variables. att must be a variable "bounds" attribute. */
void
insert_bounds_info(int ncid, int varid, ncatt_t *attp) {
static boolen uninitialized = true;
static bool_t uninitialized = true;
if(uninitialized) {
bounds_list.nbnds = 0;
@ -278,8 +278,8 @@ print_att_times(
)
{
nc_type type = att->type; /* local copy */
boolen wrap;
boolen first_item;
bool_t wrap;
bool_t first_item;
ncvar_t var; /* fake var structure for the att values; */
/* will add only the minimum necessary info */

114
ncdump/ref_tst_mud4.cdl Normal file
View File

@ -0,0 +1,114 @@
netcdf tst_mud4 {
dimensions:
F0 = 1 ;
F1 = 2 ;
F2 = 3 ;
F3 = 5 ;
U0 = UNLIMITED ; // (1 currently)
U1 = UNLIMITED ; // (2 currently)
U2 = UNLIMITED ; // (3 currently)
U3 = UNLIMITED ; // (5 currently)
variables:
int ff(F1, F2) ;
int uf(U1, F2) ;
int fu(F1, U2) ;
int uu(U1, U2) ;
int ufff(U0, F1, F2, F3) ;
int uffu(U0, F1, F2, U3) ;
int ufuf(U0, F1, U2, F3) ;
int ufuu(U0, F1, U2, U3) ;
int uuff(U0, U1, F2, F3) ;
int uufu(U0, U1, F2, U3) ;
int uuuf(U0, U1, U2, F3) ;
int uuuu(U0, U1, U2, U3) ;
int ffff(F0, F1, F2, F3) ;
data:
ff =
1, 2, 3,
4, 5, 6 ;
uf =
1, 2, 3,
4, 5, 6 ;
fu =
{1, 2, 3},
{4, 5, 6} ;
uu =
{1, 2, 3},
{4, 5, 6} ;
ufff =
1, 2, 3, 4, 5,
6, 7, 8, 9, 10,
11, 12, 13, 14, 15,
16, 17, 18, 19, 20,
21, 22, 23, 24, 25,
26, 27, 28, 29, 30 ;
uffu =
{1, 2, 3, 4, 5},
{6, 7, 8, 9, 10},
{11, 12, 13, 14, 15},
{16, 17, 18, 19, 20},
{21, 22, 23, 24, 25},
{26, 27, 28, 29, 30} ;
ufuf =
{1, 2, 3, 4, 5,
6, 7, 8, 9, 10,
11, 12, 13, 14, 15},
{16, 17, 18, 19, 20,
21, 22, 23, 24, 25,
26, 27, 28, 29, 30} ;
ufuu =
{{1, 2, 3, 4, 5},
{6, 7, 8, 9, 10},
{11, 12, 13, 14, 15}},
{{16, 17, 18, 19, 20},
{21, 22, 23, 24, 25},
{26, 27, 28, 29, 30}} ;
uuff =
{1, 2, 3, 4, 5,
6, 7, 8, 9, 10,
11, 12, 13, 14, 15,
16, 17, 18, 19, 20,
21, 22, 23, 24, 25,
26, 27, 28, 29, 30} ;
uufu =
{{1, 2, 3, 4, 5},
{6, 7, 8, 9, 10},
{11, 12, 13, 14, 15},
{16, 17, 18, 19, 20},
{21, 22, 23, 24, 25},
{26, 27, 28, 29, 30}} ;
uuuf =
{{1, 2, 3, 4, 5,
6, 7, 8, 9, 10,
11, 12, 13, 14, 15},
{16, 17, 18, 19, 20,
21, 22, 23, 24, 25,
26, 27, 28, 29, 30}} ;
uuuu =
{{{1, 2, 3, 4, 5},
{6, 7, 8, 9, 10},
{11, 12, 13, 14, 15}},
{{16, 17, 18, 19, 20},
{21, 22, 23, 24, 25},
{26, 27, 28, 29, 30}}} ;
ffff =
1, 2, 3, 4, 5,
6, 7, 8, 9, 10,
11, 12, 13, 14, 15,
16, 17, 18, 19, 20,
21, 22, 23, 24, 25,
26, 27, 28, 29, 30 ;
}

23
ncdump/tst_mud.sh Executable file
View File

@ -0,0 +1,23 @@
#!/bin/sh
# This shell script tests ncdump and ncgen on netCDF-4 variables with multiple
# unlimited dimensions.
# $Id $
set -e
if test "x$srcdir" = "x"; then
srcdir=`dirname $0`;
fi
# add hack for sunos
export srcdir;
echo ""
echo "*** Testing ncdump output for multiple unlimited dimensions"
echo "*** creating netcdf file tst_mud4.nc from ref_tst_mud4.cdl ..."
../ncgen/ncgen -k3 -b -o tst_mud4.nc $srcdir/ref_tst_mud4.cdl
echo "*** creating tst_mud4.cdl from tst_mud4.nc ..."
./ncdump tst_mud4.nc > tst_mud4.cdl
# echo "*** comparing tst_mud4.cdl with ref_tst_mud4.cdl..."
diff -b tst_mud4.cdl $srcdir/ref_tst_mud4.cdl
echo "*** All ncdump test output for multiple unlimited dimensions passed!"
exit 0

2
ncdump/utils.h
View File

@ -10,7 +10,7 @@
#define STREQ(a, b) (*(a) == *(b) && strcmp((a), (b)) == 0)
typedef int boolen;
typedef int bool_t;
enum {false=0, true=1};
struct safebuf_t;

341
ncdump/vardata.c
View File

@ -27,7 +27,7 @@ extern fspec_t formatting_specs; /* set from command-line options */
/* Only read this many values at a time, if last dimension is larger
than this */
#define VALBUFSIZ 8096
#define VALBUFSIZ 10000
static int linep; /* line position, not counting global indent */
static int max_line_len; /* max chars per line, not counting global indent */
@ -50,7 +50,8 @@ set_max_len(int len) {
* Output a string that should not be split across lines. If it would
* make current line too long, first output a newline and current
* (nested group) indentation, then continuation indentation, then
* output string.
* output string. If string ends with a newline to force short line,
* reset indentation after output.
*/
void
lput(const char *cp) {
@ -63,7 +64,10 @@ lput(const char *cp) {
linep = (int)strlen(LINEPIND) + indent_get();
}
(void) fputs(cp,stdout);
linep += nn;
if (cp[nn - 1] == '\n') {
linep = indent_get();
} else
linep += nn;
}
@ -85,15 +89,15 @@ lput(const char *cp) {
void
lput2(
const char *cp, /* string to print */
boolen first_item, /* identify first item in list */
boolen wrap /* line wrap control: true=enable,
bool_t first_item, /* identify first item in list */
bool_t wrap /* line wrap control: true=enable,
* false=stay on same line */
)
{
static int linep; /* current line position (number of */
/* chars); saved between calls */
int len_prefix = strlen (CDL_COMMENT_PREFIX);
boolen make_newline;
bool_t make_newline;
size_t len1 = strlen(cp); /* length of input string */
@ -173,7 +177,7 @@ print_any_val(
* print last delimiter in each line before annotation (, or ;)
*/
static void
lastdelim (boolen more, boolen lastrow)
lastdelim (bool_t more, bool_t lastrow)
{
if (more) {
printf(", ");
@ -190,7 +194,7 @@ lastdelim (boolen more, boolen lastrow)
* print last delimiter in each line before annotation (, or ;)
*/
static void
lastdelim2 (boolen more, boolen lastrow)
lastdelim2 (bool_t more, bool_t lastrow)
{
if (more) {
lput(", ");
@ -231,13 +235,55 @@ pr_any_att_vals(
sbuf_free(sb);
}
/*
* Prints brief annotation for a row of data values
*/
static void
annotate_brief(
const ncvar_t *vp, /* variable */
const size_t *cor, /* corner coordinates */
size_t vdims[] /* variable dimension sizes */
)
{
int vrank = vp->ndims;
int id;
printf ("// ");
print_name(vp->name);
printf("(");
switch (formatting_specs.data_lang) {
case LANG_C:
/* print brief comment with C variable indices */
for (id = 0; id < vrank-1; id++)
printf("%lu,", (unsigned long)cor[id]);
if (vdims[vrank-1] == 1)
printf("0");
else
printf(" 0-%lu", (unsigned long)vdims[vrank-1]-1);
break;
case LANG_F:
/* print brief comment with Fortran variable indices */
if (vdims[vrank-1] == 1)
printf("1");
else
printf("1-%lu ", (unsigned long)vdims[vrank-1]);
for (id = vrank-2; id >=0 ; id--) {
printf(",%lu", (unsigned long)(1 + cor[id]));
}
break;
}
printf(")\n");
indent_out();
printf(" ");
set_indent(4 + indent_get());
}
/*
* Annotates a value in data section with var name and indices in comment
*/
static void
annotate(
const ncvar_t *vp, /* variable */
const ncvar_t *vp, /* variable */
const size_t *cor, /* corner coordinates */
long iel /* which element in current row */
)
@ -269,6 +315,7 @@ annotate(
}
/*
* Print a number of variable values, where the optional comments
* for each value identify the variable, and each dimension index.
@ -277,9 +324,7 @@ static void
pr_any_vals(
const ncvar_t *vp, /* variable */
size_t len, /* number of values to print */
boolen more, /* true if more data for this row will
* follow, so add trailing comma */
boolen lastrow, /* true if this is the last row for this
bool_t lastrow, /* true if this is the last row for this
* variable, so terminate with ";" instead
* of "," */
const void *vals, /* pointer to block of values */
@ -304,11 +349,11 @@ pr_any_vals(
print_any_val(sb, vp, (void *)valp);
if (formatting_specs.full_data_cmnts) {
printf("%s", sbuf_str(sb));
lastdelim (more, lastrow);
lastdelim (0, lastrow);
annotate (vp, cor, iel);
} else {
lput(sbuf_str(sb));
lastdelim2 (more, lastrow);
lastdelim2 (0, lastrow);
}
sbuf_free(sb);
}
@ -323,9 +368,7 @@ static void
pr_tvals(
const ncvar_t *vp, /* variable */
size_t len, /* number of values to print */
boolen more, /* true if more data for this row will
* follow, so add trailing comma */
boolen lastrow, /* true if this is the last row for this
bool_t lastrow, /* true if this is the last row for this
* variable, so terminate with ";" instead
* of "," */
const char *vals, /* pointer to block of values */
@ -381,10 +424,10 @@ pr_tvals(
printf("\"");
/* if (fsp && formatting_specs.full_data_cmnts) { */
if (formatting_specs.full_data_cmnts) {
lastdelim (more, lastrow);
lastdelim (0, lastrow);
annotate (vp, (size_t *)cor, 0L);
} else {
lastdelim2 (more, lastrow);
lastdelim2 (0, lastrow);
}
}
@ -417,6 +460,103 @@ upcorner(
return ret;
}
/* Print data values for variable varid.
*
* Recursive to handle possibility of variables with multiple
* unlimited dimensions, for which the CDL syntax requires use of "{"
* and "}" in data section to disambiguate the size of nested records
* in a simple linear list of values.
*/
static int
print_rows(
int level, /* 0 at top-level, incremented for each recursive level */
int ncid, /* netcdf id */
int varid, /* variable id */
const ncvar_t *vp, /* variable */
size_t ncols, /* number of values in a row */
int rank, /* number of elements in following 3 arrays */
size_t vdims[], /* variable dimension sizes */
size_t cor[], /* corner coordinates */
size_t edg[], /* edges of hypercube */
void *vals, /* allocated buffer for ncols values in a row */
int marks_pending /* number of pending closing "}" record markers */
)
{
int d0 = 0;
size_t inc = 1;
int i;
bool_t mark_record = (level > 0 && is_unlim_dim(ncid, vp->dims[level]));
safebuf_t *sb = sbuf_new();
if (rank > 0)
d0 = vdims[level];
for(i = level + 1; i < rank; i++) {
inc *= vdims[i];
}
if(mark_record) { /* the whole point of this recursion is printing these "{}" */
lput("{");
marks_pending++; /* matching "}"s to emit after last "row" */
}
if(rank - level > 1) { /* this level is just d0 next levels */
size_t *local_cor = emalloc((rank + 1) * sizeof(size_t));
size_t *local_edg = emalloc((rank + 1) * sizeof(size_t));
for(i = 0; i < rank; i++) {
local_cor[i] = cor[i];
local_edg[i] = edg[i];
}
local_cor[level] = 0;
local_edg[level] = 1;
for(i = 0; i < d0 - 1; i++) {
print_rows(level + 1, ncid, varid, vp, ncols, rank, vdims,
local_cor, local_edg, vals, 0);
local_cor[level] += 1;
}
print_rows(level + 1, ncid, varid, vp, ncols, rank, vdims,
local_cor, local_edg, vals, marks_pending);
free(local_edg);
free(local_cor);
} else { /* bottom out of recursion */
void *valp = vals;
bool_t lastrow;
NC_CHECK(nc_get_vara(ncid, varid, cor, edg, valp));
for(i=0; i < d0 - 1; i++) {
print_any_val(sb, vp, (void *)valp);
valp += vp->tinfo->size; /* next value according to type */
if (formatting_specs.full_data_cmnts) {
printf("%s, ", sb->buf);
annotate (vp, cor, i);
} else {
sbuf_cat(sb, ", ");
lput(sbuf_str(sb));
}
}
print_any_val(sb, vp, (void *)valp);
/* determine if this is the last row */
lastrow = true;
for(i = 0; i < rank - 1; i++) {
if (cor[i] != vdims[i] - 1) {
lastrow = false;
break;
}
}
if (formatting_specs.full_data_cmnts) {
for (i = 0; i < marks_pending; i++) {
sbuf_cat(sb, "}");
}
printf("%s", sbuf_str(sb));
lastdelim (0, lastrow);
annotate (vp, cor, i);
} else {
for (i = 0; i < marks_pending; i++) {
sbuf_cat(sb, "}");
}
lput(sbuf_str(sb));
lastdelim2 (0, lastrow);
}
}
sbuf_free(sb);
return NC_NOERR;
}
/* Output the data for a single variable, in CDL syntax. */
int
@ -430,7 +570,6 @@ vardata(
size_t *cor; /* corner coordinates */
size_t *edg; /* edges of hypercube */
size_t *add; /* "odometer" increment to next "row" */
size_t gulp;
void *vals;
int id;
@ -448,19 +587,17 @@ vardata(
if(vrank == 0) { /*scalar*/
cor[0] = 0;
edg[0] = 1;
} for (id = 0; id < vrank; id++) {
cor[id] = 0;
edg[id] = 1;
nels *= vdims[id]; /* total number of values for variable */
} else {
for (id = 0; id < vrank; id++) {
cor[id] = 0;
edg[id] = 1;
nels *= vdims[id]; /* total number of values for variable */
}
}
printf("\n");
indent_out();
/* printf(" %s = ", vp->name); */
/* or */
/* printf(" %s =\n ", vp->name); */
printf(" ");
print_name(vp->name);
printf(" ");
print_name(vp->name);
if (vrank <= 1) {
printf(" = ");
set_indent ((int)strlen(vp->name) + 4 + indent_get());
@ -469,92 +606,41 @@ vardata(
set_indent (2 + indent_get());
}
if (vrank < 1) {
if (vrank == 0) {
ncols = 1;
} else {
ncols = vdims[vrank-1]; /* size of "row" along last dimension */
edg[vrank-1] = vdims[vrank-1];
edg[vrank-1] = ncols;
for (id = 0; id < vrank; id++)
add[id] = 0;
if (vrank > 1)
add[vrank-2] = 1;
}
nrows = nels/ncols; /* number of "rows" */
gulp = ncols < VALBUFSIZ ? ncols : VALBUFSIZ;
vals = emalloc(gulp * vp->tinfo->size);
vals = emalloc(ncols * vp->tinfo->size);
for (ir = 0; ir < nrows; ir++) {
/*
* rather than just printing a whole row at once (which might
* exceed the capacity of some platforms), we break each row
* into smaller chunks, if necessary.
*/
size_t corsav = 0;
int left = (int)ncols;
boolen lastrow;
if (vrank > 0) {
corsav = cor[vrank-1];
if (formatting_specs.brief_data_cmnts != false
&& vrank > 1
&& left > 0) { /* print brief comment with indices range */
/* printf("// %s(",vp->name); */
printf("// ");
print_name(vp->name);
printf("(");
switch (formatting_specs.data_lang) {
case LANG_C:
/* print brief comment with C variable indices */
for (id = 0; id < vrank-1; id++)
printf("%lu,", (unsigned long)cor[id]);
if (vdims[vrank-1] == 1)
printf("0");
else
printf(" 0-%lu", (unsigned long)vdims[vrank-1]-1);
break;
case LANG_F:
/* print brief comment with Fortran variable indices */
if (vdims[vrank-1] == 1)
printf("1");
else
printf("1-%lu ", (unsigned long)vdims[vrank-1]);
for (id = vrank-2; id >=0 ; id--) {
printf(",%lu", (unsigned long)(1 + cor[id]));
}
break;
/* Test if we should treat array of chars as a string */
if(vp->type == NC_CHAR && (vp->fmt == 0 || STREQ(vp->fmt,"%s") || STREQ(vp->fmt,""))) {
for (ir = 0; ir < nrows; ir++) {
if (vrank > 0) {
if (formatting_specs.brief_data_cmnts != false && vrank > 1 && ncols > 0) {
annotate_brief(vp, cor, vdims);
}
printf(")\n");
indent_out();
printf(" ");
set_indent(4 + indent_get());
}
}
lastrow = (boolen)(ir == nrows-1);
while (left > 0) {
size_t toget = left < gulp ? left : gulp;
if (vrank > 0)
edg[vrank-1] = toget;
NC_CHECK(nc_get_vara(ncid, varid, cor, edg, vals));
/* Test if we should treat array of chars as a string */
if(vp->type == NC_CHAR &&
(vp->fmt == 0 || STREQ(vp->fmt,"%s") || STREQ(vp->fmt,""))) {
pr_tvals(vp, toget, left > toget, lastrow, (char *) vals, cor);
} else {
pr_any_vals(vp, toget, left > toget, lastrow, vals, cor);
}
left -= toget;
if (vrank > 0)
cor[vrank-1] += toget;
pr_tvals(vp, ncols, (ir == nrows-1), (char *) vals, cor);
if (ir < nrows-1)
if (!upcorner(vdims, vp->ndims, cor, add))
error("vardata: odometer overflowed!");
set_indent(2);
}
if (vrank > 0)
cor[vrank-1] = corsav;
if (ir < nrows-1)
if (!upcorner(vdims,vp->ndims,cor,add))
error("vardata: odometer overflowed!");
set_indent(2);
} else {
int level = 0;
int rank = vp->ndims;
int marks_pending = 0;
NC_CHECK(print_rows(level, ncid, varid, vp, ncols, rank, vdims, cor, edg,
vals, marks_pending));
}
free(vals);
free(cor);
free(edg);
@ -568,7 +654,7 @@ vardata(
* print last delimiter in each line before annotation (, or ;)
*/
static void
lastdelim2x (boolen more, boolen lastrow)
lastdelim2x (bool_t more, bool_t lastrow)
{
if (more) {
lput(" ");
@ -589,9 +675,9 @@ static void
pr_tvalsx(
const ncvar_t *vp, /* variable */
size_t len, /* number of values to print */
boolen more, /* true if more data for this row will
bool_t more, /* true if more data for this row will
* follow, so add trailing comma */
boolen lastrow, /* true if this is the last row for this
bool_t lastrow, /* true if this is the last row for this
* variable, so terminate with ";" instead
* of "," */
const char *vals /* pointer to block of values */
@ -655,9 +741,9 @@ static void
pr_any_valsx(
const ncvar_t *vp, /* variable */
size_t len, /* number of values to print */
boolen more, /* true if more data for this row will
bool_t more, /* true if more data for this row will
* follow, so add trailing comma */
boolen lastrow, /* true if this is the last row for this
bool_t lastrow, /* true if this is the last row for this
* variable, so terminate with ";" instead
* of "," */
const void *vals /* pointer to block of values */
@ -693,7 +779,6 @@ vardatax(
size_t *cor; /* corner coordinates */
size_t *edg; /* edges of hypercube */
size_t *add; /* "odometer" increment to next "row" */
size_t gulp;
void *vals;
int id;
@ -728,41 +813,31 @@ vardatax(
add[vrank-2] = 1;
}
nrows = nels/ncols; /* number of "rows" */
gulp = ncols < VALBUFSIZ ? VALBUFSIZ : ncols;
vals = emalloc(gulp * vp->tinfo->size);
vals = emalloc(ncols * vp->tinfo->size);
for (ir = 0; ir < nrows; ir++) {
/*
* rather than just printing a whole row at once (which might
* exceed the capacity of some platforms), we break each row
* into smaller chunks, if necessary.
*/
size_t corsav;
int left = (int)ncols;
boolen lastrow;
bool_t lastrow;
if (vrank > 0) {
corsav = cor[vrank-1];
}
lastrow = (boolen)(ir == nrows-1);
while (left > 0) {
size_t toget = left < gulp ? left : gulp;
if (vrank > 0)
edg[vrank-1] = toget;
NC_CHECK(nc_get_vara(ncid, varid, cor, edg, vals) );
lastrow = (bool_t)(ir == nrows-1);
/* Test if we should treat array of chars as a string */
if(vp->type == NC_CHAR &&
(vp->fmt == 0 || STREQ(vp->fmt,"%s") || STREQ(vp->fmt,""))) {
pr_tvalsx(vp, toget, left > toget, lastrow, (char *) vals);
} else {
pr_any_valsx(vp, toget, left > toget, lastrow, vals);
}
left -= toget;
if (vrank > 0)
cor[vrank-1] += toget;
if (vrank > 0)
edg[vrank-1] = ncols;
NC_CHECK(nc_get_vara(ncid, varid, cor, edg, vals) );
/* Test if we should treat array of chars as a string */
if(vp->type == NC_CHAR &&
(vp->fmt == 0 || STREQ(vp->fmt,"%s") || STREQ(vp->fmt,""))) {
pr_tvalsx(vp, ncols, 0, lastrow, (char *) vals);
} else {
pr_any_valsx(vp, ncols, 0, lastrow, vals);
}
if (vrank > 0)
cor[vrank-1] += ncols;
if (vrank > 0)
cor[vrank-1] = corsav;
if (ir < nrows-1)

2
ncdump/vardata.h
View File

@ -35,7 +35,7 @@ extern void set_max_len ( int len );
extern void lput( const char *string );
/* like lput, but with options to support formatting with appended comments */
extern void lput2( const char *string, boolen first, boolen wrap);
extern void lput2( const char *string, bool_t first, bool_t wrap);
/* print values of an attribute */
extern void pr_any_att_vals( const ncatt_t *attp, const void *vals );