netcdf-c/ncdump/dumplib.c

1903 lines
50 KiB
C
Raw Normal View History

2010-06-03 21:24:43 +08:00
/*********************************************************************
* Copyright 2018, University Corporation for Atmospheric Research
2010-06-03 21:24:43 +08:00
* See netcdf/README file for copying and redistribution conditions.
* $Header: /upc/share/CVS/netcdf-3/ncdump/dumplib.c,v 1.85 2010/05/05 22:15:39 dmh Exp $
*********************************************************************/
/*
* We potentially include <stdarg.h> before <stdio.h> in order to obtain a
* definition for va_list from the GNU C compiler.
*/
2012-09-11 05:19:57 +08:00
Primary change: add dap4 support Specific changes: 1. Add dap4 code: libdap4 and dap4_test. Note that until the d4ts server problem is solved, dap4 is turned off. 2. Modify various files to support dap4 flags: configure.ac, Makefile.am, CMakeLists.txt, etc. 3. Add nc_test/test_common.sh. This centralizes the handling of the locations of various things in the build tree: e.g. where is ncgen.exe located. See nc_test/test_common.sh for details. 4. Modify .sh files to use test_common.sh 5. Obsolete separate oc2 by moving it to be part of netcdf-c. This means replacing code with netcdf-c equivalents. 5. Add --with-testserver to configure.ac to allow override of the servers to be used for --enable-dap-remote-tests. 6. There were multiple versions of nctypealignment code. Try to centralize in libdispatch/doffset.c and include/ncoffsets.h 7. Add a unit test for the ncuri code because of its complexity. 8. Move the findserver code out of libdispatch and into a separate, self contained program in ncdap_test and dap4_test. 9. Move the dispatch header files (nc{3,4}dispatch.h) to .../include because they are now shared by modules. 10. Revamp the handling of TOPSRCDIR and TOPBUILDDIR for shell scripts. 11. Make use of MREMAP if available 12. Misc. minor changes e.g. - #include <config.h> -> #include "config.h" - Add some no-install headers to /include - extern -> EXTERNL and vice versa as needed - misc header cleanup - clean up checking for misc. unix vs microsoft functions 13. Change copyright decls in some files to point to LICENSE file. 14. Add notes to RELEASENOTES.md
2017-03-09 08:01:10 +08:00
#include "config.h"
2010-06-03 21:24:43 +08:00
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#ifndef NO_FLOAT_H
#include <float.h> /* for FLT_EPSILON, DBL_EPSILON */
#endif /* NO_FLOAT_H */
#include <math.h>
#include <netcdf.h>
#include "utils.h"
#include "nccomps.h"
2010-06-03 21:24:43 +08:00
#include "dumplib.h"
2011-09-22 07:10:03 +08:00
#include "ncdump.h"
2010-06-03 21:24:43 +08:00
#include "isnan.h"
2011-09-19 04:57:51 +08:00
#include "nctime0.h"
2010-06-03 21:24:43 +08:00
static float float_eps;
static double double_eps;
extern fspec_t formatting_specs; /* set from command-line options */
2010-06-03 21:24:43 +08:00
static float
float_epsilon(void)
{
float float_eps;
#ifndef NO_FLOAT_H
float_eps = FLT_EPSILON;
#else /* NO_FLOAT_H */
{
float etop, ebot, eps;
float one = 1.0;
float two = 2.0;
etop = 1.0;
ebot = 0.0;
eps = ebot + (etop - ebot)/two;
while (eps != ebot && eps != etop) {
float epsp1;
epsp1 = one + eps;
if (epsp1 > one)
etop = eps;
else
ebot = eps;
eps = ebot + (etop - ebot)/two;
}
float_eps = two * etop;
}
#endif /* NO_FLOAT_H */
return float_eps;
}
static double
double_epsilon(void)
{
double double_eps;
#ifndef NO_FLOAT_H
double_eps = DBL_EPSILON;
#else /* NO_FLOAT_H */
{
double etop, ebot, eps;
double one = 1.0;
double two = 2.0;
etop = 1.0;
ebot = 0.0;
eps = ebot + (etop - ebot)/two;
while (eps != ebot && eps != etop) {
double epsp1;
epsp1 = one + eps;
if (epsp1 > one)
etop = eps;
else
ebot = eps;
eps = ebot + (etop - ebot)/two;
}
double_eps = two * etop;
}
#endif /* NO_FLOAT_H */
return double_eps;
}
void
init_epsilons(void)
{
float_eps = float_epsilon();
double_eps = double_epsilon();
}
static char* has_c_format_att(int ncid, int varid);
int float_precision_specified = 0; /* -p option specified float precision */
int double_precision_specified = 0; /* -p option specified double precision */
char float_var_fmt[] = "%.NNg";
char double_var_fmt[] = "%.NNg";
char float_att_fmt[] = "%#.NNgf";
char float_attx_fmt[] = "%#.NNg";
char double_att_fmt[] = "%#.NNg";
/* magic number stored in a safebuf and checked, hoping it will be
* changed if buffer was overwritten inadvertently */
#define SAFEBUF_CERT 2147114711
/* expression for where SAFEBUF_CERT is stored within safebuf (at end
* of buffer, after data) */
#define SAFEBUF_EXPR(sbuf) (*(int *)((sbuf)->buf + (sbuf)->len))
/* expression to be checked whenever a safebuf is used */
#define SAFEBUF_CHECK(sbuf) (SAFEBUF_EXPR(sbuf) == SAFEBUF_CERT)
/* somewhat arbitrary initial size of safebufs, grow as needed */
#define SAFEBUF_INIT_LEN 128
/* initialize safe buffer */
safebuf_t *
sbuf_new() {
size_t len = SAFEBUF_INIT_LEN;
safebuf_t *sb;
sb = (safebuf_t *) emalloc(sizeof(safebuf_t));
sb->buf = (char *)emalloc(len + sizeof(int));
sb->len = len;
/* write a "stamp" in last 4 bytes of buffer for id and to check for overflow */
SAFEBUF_EXPR(sb) = SAFEBUF_CERT;
sb->buf[0] = 0;
sb->cl = strlen(sb->buf);
assert(SAFEBUF_CHECK(sb));
return sb;
}
/* grow buffer to at least len bytes, copying previous contents if
* necessary */
void
sbuf_grow(safebuf_t *sb, size_t len) {
size_t m = sb->len;
void *tmp;
assert(SAFEBUF_CHECK(sb));
if (len <= m)
return;
/* Make sure we at least double size of buffer to get what's
* needed. If we just used realloc(), no guarantee that length
* would be expanded by a multiple, which we want. */
while(len > m) {
m *= 2;
}
tmp = emalloc(m + sizeof(int));
memcpy(tmp, sb->buf, sb->len);
sb->len = m;
free(sb->buf);
sb->buf = tmp;
SAFEBUF_EXPR(sb) = SAFEBUF_CERT;
assert(SAFEBUF_CHECK(sb));
}
/* Copy string s2 to safe buffer, growing if necessary */
void
2010-06-03 21:24:43 +08:00
sbuf_cpy(safebuf_t *sb, const char *s2) {
size_t s2len;
assert(SAFEBUF_CHECK(sb));
s2len = strlen(s2);
sbuf_grow(sb, 1 + s2len);
strncpy(sb->buf, s2, sb->len);
sb->cl = s2len;
assert(SAFEBUF_CHECK(sb));
}
/* Concatenate string s2 to end of string in safe buffer, growing if necessary */
void
2010-06-03 21:24:43 +08:00
sbuf_cat(safebuf_t *sb, const char *s2) {
size_t s2len;
size_t res;
assert(SAFEBUF_CHECK(sb));
s2len = strlen(s2);
sbuf_grow(sb, 1 + sb->cl + s2len);
res = strlcat(sb->buf + sb->cl, s2, sb->len - sb->cl);
2010-06-03 21:24:43 +08:00
assert( res < sb->len );
sb->cl += s2len;
assert(SAFEBUF_CHECK(sb));
}
/* Concatenate string in safebuf s2 to end of string in safebuf s1,
* growing if necessary */
void
2010-06-03 21:24:43 +08:00
sbuf_catb(safebuf_t *s1, const safebuf_t *s2) {
size_t s2len;
size_t res;
assert(SAFEBUF_CHECK(s1));
assert(SAFEBUF_CHECK(s2));
s2len = sbuf_len(s2);
sbuf_grow(s1, 1 + s1->cl + s2len);
res = strlcat(s1->buf + s1->cl, s2->buf, s1->len - s1->cl);
2010-06-03 21:24:43 +08:00
assert( res < s1->len );
s1->cl += s2len;
assert(SAFEBUF_CHECK(s1));
}
/* Return length of string in sbuf */
size_t
2010-06-03 21:24:43 +08:00
sbuf_len(const safebuf_t *sb) {
assert(SAFEBUF_CHECK(sb));
return sb->cl;
}
/* Return C string in an sbuf */
char *
sbuf_str(const safebuf_t *sb) {
assert(SAFEBUF_CHECK(sb));
return sb->buf;
}
/* free safe buffer */
void
sbuf_free(safebuf_t *sb) {
assert(SAFEBUF_CHECK(sb));
free(sb->buf);
free(sb);
}
/* In case different formats specified with -d option, set them here. */
void
set_formats(int float_digits, int double_digits)
{
int res;
2020-07-15 20:37:46 +08:00
res = snprintf(float_var_fmt, sizeof float_var_fmt, "%%.%dg",
2010-06-03 21:24:43 +08:00
float_digits) + 1;
assert(res <= sizeof(float_var_fmt));
2020-07-15 20:37:46 +08:00
res = snprintf(double_var_fmt, sizeof double_var_fmt, "%%.%dg",
2010-06-03 21:24:43 +08:00
double_digits) + 1;
assert(res <= sizeof(double_var_fmt));
2020-07-15 20:37:46 +08:00
res = snprintf(float_att_fmt, sizeof float_att_fmt, "%%#.%dgf",
2010-06-03 21:24:43 +08:00
float_digits) + 1;
assert(res <= sizeof(float_att_fmt));
2020-07-15 20:37:46 +08:00
res = snprintf(float_attx_fmt, sizeof float_attx_fmt, "%%#.%dg",
2010-06-03 21:24:43 +08:00
float_digits) + 1;
assert(res <= sizeof(float_attx_fmt));
2020-07-15 20:37:46 +08:00
res = snprintf(double_att_fmt, sizeof double_att_fmt, "%%#.%dg",
2010-06-03 21:24:43 +08:00
double_digits) + 1;
assert(res <= sizeof(double_att_fmt));
}
static char *
has_c_format_att(
int ncid, /* netcdf id */
int varid /* variable id */
)
{
nc_type cfmt_type;
size_t cfmt_len;
#define C_FMT_NAME "C_format" /* name of C format attribute */
#define MAX_CFMT_LEN 100 /* max length of C format attribute */
static char cfmt[MAX_CFMT_LEN];
2010-06-03 21:24:43 +08:00
/* we expect nc_inq_att to fail if there is no "C_format" attribute */
int nc_stat = nc_inq_att(ncid, varid, "C_format", &cfmt_type, &cfmt_len);
switch(nc_stat) {
case NC_NOERR:
if (cfmt_type == NC_CHAR && cfmt_len != 0 && cfmt_len < MAX_CFMT_LEN) {
int nc_stat = nc_get_att_text(ncid, varid, "C_format", cfmt);
if(nc_stat != NC_NOERR) {
fprintf(stderr, "Getting 'C_format' attribute %s\n",
2010-06-03 21:24:43 +08:00
nc_strerror(nc_stat));
(void) fflush(stderr);
}
cfmt[cfmt_len] = '\0';
return &cfmt[0];
}
break;
case NC_ENOTATT:
break;
default:
fprintf(stderr, "Inquiring about 'C_format' attribute %s\n",
2010-06-03 21:24:43 +08:00
nc_strerror(nc_stat));
(void) fflush(stderr);
break;
}
return 0;
}
/* Return default format to use for a primitive type */
const char *
get_default_fmt(nc_type typeid) {
/* Otherwise return sensible default. */
switch (typeid) {
case NC_BYTE:
return "%d";
case NC_CHAR:
return "%s";
case NC_SHORT:
return "%d";
case NC_INT:
return "%d";
case NC_FLOAT:
return float_var_fmt;
case NC_DOUBLE:
return double_var_fmt;
case NC_UBYTE:
return "%u";
case NC_USHORT:
return "%u";
case NC_UINT:
return "%u";
case NC_INT64:
return "%lld";
case NC_UINT64:
return "%llu";
case NC_STRING:
return "\"%s\"";
default:
break;
}
return ""; /* user-defined types don't use fmt member */
}
/*
* Determine print format to use for each primitive value for this
* variable. Use value of attribute C_format if it exists, otherwise
* a sensible default.
*/
const char *
get_fmt(
int ncid,
int varid,
nc_type typeid
)
{
char *c_format_att;
/* float or double precision specified with -p option overrides any
C_format attribute value, so check for that first. */
if (float_precision_specified && typeid == NC_FLOAT)
return float_var_fmt;
if (double_precision_specified && typeid == NC_DOUBLE)
return double_var_fmt;
/* If C_format attribute exists, return it */
c_format_att = has_c_format_att(ncid, varid);
if (c_format_att)
return c_format_att;
2010-06-03 21:24:43 +08:00
return get_default_fmt(typeid);
}
/* Return primitive type name */
static const char *
prim_type_name(nc_type type)
{
switch (type) {
case NC_BYTE:
return "byte";
case NC_CHAR:
return "char";
case NC_SHORT:
return "short";
case NC_INT:
return "int";
case NC_FLOAT:
return "float";
case NC_DOUBLE:
return "double";
case NC_UBYTE:
return "ubyte";
case NC_USHORT:
return "ushort";
case NC_UINT:
return "uint";
case NC_INT64:
return "int64";
case NC_UINT64:
return "uint64";
case NC_STRING:
return "string";
default:
error("prim_type_name: bad type %d", type);
return "bogus";
}
}
static int max_type = 0;
static int max_atomic_type = 0;
2010-06-03 21:24:43 +08:00
static nctype_t **nctypes = 0; /* holds all types in a netCDF dataset */
#ifdef USE_NETCDF4
/* return number of user-defined types in a group and all its subgroups */
static int
count_udtypes(int ncid) {
int ntypes = 0;
int numgrps;
int *ncids;
int i;
int format;
NC_CHECK( nc_inq_format(ncid, &format) );
if (format == NC_FORMAT_NETCDF4) {
/* Get number of types in this group */
NC_CHECK( nc_inq_typeids(ncid, &ntypes, NULL) ) ;
NC_CHECK( nc_inq_grps(ncid, &numgrps, NULL) ) ;
ncids = (int *) emalloc(sizeof(int) * (numgrps + 1));
2010-06-03 21:24:43 +08:00
NC_CHECK( nc_inq_grps(ncid, NULL, ncids) ) ;
/* Add number of types in each subgroup, if any */
for (i=0; i < numgrps; i++) {
ntypes += count_udtypes(ncids[i]);
}
free(ncids);
}
return ntypes;
}
#endif /*USE_NETCDF4*/
/* This routine really is intended to return the max atomic typeid */
2010-06-03 21:24:43 +08:00
static int
max_typeid(int ncid) {
int maxtypes = NC_NAT;
int maxatomictypes = NC_NAT;
int format = 0;
int err = NC_NOERR;
/* get the file type */
err = nc_inq_format(ncid,&format);
if(err) {
fprintf(stderr,"%s: Cannot get file format.\n",nc_strerror(err));
return 0;
}
switch (format) {
case NC_FORMAT_CLASSIC:
case NC_FORMAT_NETCDF4_CLASSIC:
case NC_FORMAT_64BIT_OFFSET:
maxatomictypes = (maxtypes = NC_DOUBLE); /*ignore NC_NAT?*/
break;
case NC_FORMAT_64BIT_DATA:
maxatomictypes = (maxtypes = NC_UINT64);
break;
case NC_FORMAT_NETCDF4:
2010-06-03 21:24:43 +08:00
#ifdef USE_NETCDF4
{
int nuser = 0;
maxatomictypes = (maxtypes = NC_STRING); /* extra netCDF-4 primitive types */
maxtypes += 4; /* user-defined classes */
nuser = count_udtypes(ncid);
if(nuser > 0)
maxtypes = NC_FIRSTUSERTYPEID + (nuser - 1);
} break;
#else
/* fallthru */
2010-06-03 21:24:43 +08:00
#endif
default:
fprintf(stderr,"Unexpected file format: %d\n",format);
return 0;
}
2010-06-03 21:24:43 +08:00
max_type = maxtypes;
max_atomic_type = maxatomictypes;
2010-06-03 21:24:43 +08:00
return maxtypes;
}
void typeadd(nctype_t *typep) {
nctypes[typep->tid] = typep;
}
/* From type id, get full type info */
nctype_t *
get_typeinfo ( int typeid ) {
if(typeid < 0 || typeid > max_type)
error("ncdump: %d is an invalid type id", typeid);
return nctypes[typeid];
}
/* void */
/* xfree_typeinfo(int ncid) { */
/* int i; */
/* for (i = 0; i < number_of_types; i++) { */
/* nctype_t *tinfop = nctypes[i]; */
/* if (tinfop) { */
/* if(tinfop->name) */
/* free(tinfop->name); */
/* if(tinfop->grps) */
/* free(tinfop->grps); */
/* free(tinfop); */
/* } */
/* } */
/* } */
bool_t
ncbyte_val_equals(const nctype_t *this,
2010-06-03 21:24:43 +08:00
const void *v1p, const void *v2p) {
return ( *(signed char* )v1p == *(signed char* )v2p);
}
bool_t
ncchar_val_equals(const nctype_t *this,
2010-06-03 21:24:43 +08:00
const void *v1p, const void *v2p) {
return ( *(char* )v1p == *(char* )v2p);
}
bool_t
ncshort_val_equals(const nctype_t *this,
2010-06-03 21:24:43 +08:00
const void *v1p, const void *v2p) {
return ( *(short* )v1p == *(short* )v2p);
}
bool_t
ncint_val_equals(const nctype_t *this,
2010-06-03 21:24:43 +08:00
const void *v1p, const void *v2p) {
return ( *(int* )v1p == *(int* )v2p);
}
#define absval(x) ( (x) < 0 ? -(x) : (x) )
/*
2010-06-03 21:24:43 +08:00
* Return ( *(float* )v1p == *(float* )v2p);
* except use floating epsilon to compare very close vals as equal
* and handle IEEE NaNs and infinities.
*/
bool_t
ncfloat_val_equals(const nctype_t *this,
2010-06-03 21:24:43 +08:00
const void *v1p, const void *v2p) {
float v1 = *(float* )v1p;
float v2 = *(float* )v2p;
if((v1 > 0.0f) != (v2 > 0.0f)) /* avoid overflow */
return false;
if(isfinite(v1) && isfinite(v2))
return (absval(v1 - v2) <= absval(float_eps * v2)) ;
if(isnan(v1) && isnan(v2))
return true;
if(isinf(v1) && isinf(v2))
return true;
return false;
}
/*
2010-06-03 21:24:43 +08:00
* Return ( *(double* )v1p == *(double* )v2p);
* except use floating epsilon to compare very close vals as equal
* and handle IEEE NaNs and infinities.
*/
bool_t
ncdouble_val_equals(const nctype_t *this,
2010-06-03 21:24:43 +08:00
const void *v1p, const void *v2p) {
double v1 = *(double* )v1p;
double v2 = *(double* )v2p;
if((v1 > 0.0) != (v2 > 0.0)) /* avoid overflow */
return false;
if(isfinite(v1) && isfinite(v2))
return (absval(v1 - v2) <= absval(double_eps * v2)) ;
if(isnan(v1) && isnan(v2))
return true;
if(isinf(v1) && isinf(v2))
return true;
return false;
}
bool_t
ncubyte_val_equals(const nctype_t *this,
2010-06-03 21:24:43 +08:00
const void *v1p, const void *v2p) {
return ( *(unsigned char* )v1p == *(unsigned char* )v2p);
}
bool_t
ncushort_val_equals(const nctype_t *this,
2010-06-03 21:24:43 +08:00
const void *v1p, const void *v2p) {
return ( *(unsigned short* )v1p == *(unsigned short* )v2p);
}
bool_t
ncuint_val_equals(const nctype_t *this,
2010-06-03 21:24:43 +08:00
const void *v1p, const void *v2p) {
return ( *(unsigned int* )v1p == *(unsigned int* )v2p);
}
bool_t
ncint64_val_equals(const nctype_t *this,
2010-06-03 21:24:43 +08:00
const void *v1p, const void *v2p) {
return ( *(long long* )v1p == *(long long* )v2p);
}
bool_t
ncuint64_val_equals(const nctype_t *this,
2010-06-03 21:24:43 +08:00
const void *v1p, const void *v2p) {
return ( *(unsigned long long* )v1p == *(unsigned long long* )v2p);
}
bool_t
ncstring_val_equals(const nctype_t *this,
2010-06-03 21:24:43 +08:00
const void *v1p, const void *v2p) {
if (NULL == *((char **)v1p) && NULL == *((char **)v2p))
return(1);
else if (NULL != *((char **)v1p) && NULL == *((char **)v2p))
return(0);
else if (NULL == *((char **)v1p) && NULL != *((char **)v2p))
return(0);
2010-06-03 21:24:43 +08:00
return (strcmp(*((char **)v1p), *((char **)v2p)) == 0);
}
#ifdef USE_NETCDF4
bool_t
ncopaque_val_equals(const nctype_t *this,
2010-06-03 21:24:43 +08:00
const void *v1p, const void *v2p) {
size_t nbytes = this->size;
const char *c1p = (const char *) v1p;
const char *c2p = (const char *) v2p;
int i;
for (i=0; i < nbytes; i++) {
if (*c1p++ != *c2p++)
return false;
}
return true;
}
bool_t
ncvlen_val_equals(const nctype_t *this,
2010-06-03 21:24:43 +08:00
const void *v1p, const void *v2p) {
size_t v1len = ((nc_vlen_t *)v1p)->len;
size_t v2len = ((nc_vlen_t *)v2p)->len;
if (v1len != v2len)
return false;
{
size_t base_size = this->size;
nc_type base_type = this->base_tid;
nctype_t *base_info = get_typeinfo(base_type);
val_equals_func base_val_equals = base_info->val_equals;
const char *v1dat = ((nc_vlen_t *)v1p)->p;
const char *v2dat = ((nc_vlen_t *)v2p)->p;
size_t i;
for(i = 0; i < v1len; i++) {
if (base_val_equals(base_info, (const void *)v1dat,
2010-06-03 21:24:43 +08:00
(const void *)v2dat) != true)
return false;
v1dat += base_size;
v2dat += base_size;
}
}
return true;
}
2019-09-18 10:27:43 +08:00
/* Determine if two compound values are equal, by testing equality of
2010-06-03 21:24:43 +08:00
* each member field. */
bool_t
nccomp_val_equals(const nctype_t *this,
2010-06-03 21:24:43 +08:00
const void *v1p, const void *v2p) {
int nfields = this->nfields;
int fidx; /* field id */
for (fidx = 0; fidx < nfields; fidx++) {
size_t offset = this->offsets[fidx];
nc_type fid = this->fids[fidx]; /* field type id */
nctype_t *finfo = get_typeinfo(fid);
if(finfo->ranks == 0 || finfo->ranks[fidx] == 0) {
if(! finfo->val_equals(finfo,
2010-06-03 21:24:43 +08:00
(char *)v1p + offset, (char *)v2p + offset))
return false;
} else { /* this field is an array */
int i; /* array element counter when rank > 0 */
void *v1elem = (char *)v1p + offset;
void *v2elem = (char *)v2p + offset;
for(i = 0; i < finfo->nvals[fidx]; i++) {
if(! finfo->val_equals(finfo, v1elem, v2elem))
return false;
v1elem = (char *)v1elem + finfo->size;
v2elem = (char *)v1elem + finfo->size;
}
}
2010-06-03 21:24:43 +08:00
}
return true;
}
#endif /* USE_NETCDF4 */
int
ncbyte_typ_tostring(const nctype_t *typ, safebuf_t *sfbf, const void *valp) {
char sout[PRIM_LEN];
int res;
res = snprintf(sout, PRIM_LEN, typ->fmt, *(signed char *)valp);
assert(res < PRIM_LEN);
sbuf_cpy(sfbf, sout);
return sbuf_len(sfbf);
}
int
ncchar_typ_tostring(const nctype_t *typ, safebuf_t *sfbf, const void *valp) {
char sout[PRIM_LEN];
char cstr[2];
2010-06-03 21:24:43 +08:00
int res;
cstr[0] = *(char*)valp;
cstr[1] = '\0';
res = snprintf(sout, PRIM_LEN, typ->fmt, cstr);
2010-06-03 21:24:43 +08:00
assert(res < PRIM_LEN);
sbuf_cpy(sfbf, sout);
return sbuf_len(sfbf);
}
int
ncshort_typ_tostring(const nctype_t *typ, safebuf_t *sfbf, const void *valp) {
char sout[PRIM_LEN];
int res;
res = snprintf(sout, PRIM_LEN, typ->fmt, *(short *)valp);
assert(res < PRIM_LEN);
sbuf_cpy(sfbf, sout);
return sbuf_len(sfbf);
}
int
ncint_typ_tostring(const nctype_t *typ, safebuf_t *sfbf, const void *valp) {
char sout[PRIM_LEN];
int res;
res = snprintf(sout, PRIM_LEN, typ->fmt, *(int *)valp);
assert(res < PRIM_LEN);
sbuf_cpy(sfbf, sout);
return sbuf_len(sfbf);
}
/* CDL canonical representations of some special floating point values */
#define NCDL_NANF "NaNf"
#define NCDL_NAN "NaN"
#define NCDL_INFF "Infinityf"
#define NCDL_INF "Infinity"
/* Convert a float NaN or Infinity to an allocated string large enough
* to hold it (at least PRIM_LEN chars) */
static void
float_special_tostring(float vv, char *sout) {
if(isnan(vv)) {
snprintf(sout, PRIM_LEN, "%s", NCDL_NANF);
} else if(isinf(vv)) {
if(vv < 0.0) {
snprintf(sout, PRIM_LEN, "-%s", NCDL_INFF);
} else {
snprintf(sout, PRIM_LEN, "%s", NCDL_INFF);
}
} else
assert(false); /* vv was finite */
}
/* Convert a double NaN or Infinity to an allocated string large enough
* to hold it (at least PRIM_LEN chars) */
static void
double_special_tostring(double vv, char *sout) {
if(isnan(vv)) {
snprintf(sout, PRIM_LEN, "%s", NCDL_NAN);
} else if(isinf(vv)) {
if(vv < 0.0) {
snprintf(sout, PRIM_LEN, "-%s", NCDL_INF);
} else {
snprintf(sout, PRIM_LEN, "%s", NCDL_INF);
}
} else
assert(false); /* vv was finite */
}
int
ncfloat_typ_tostring(const nctype_t *typ, safebuf_t *sfbf, const void *valp) {
char sout[PRIM_LEN];
float vv = *(float *)valp;
if(isfinite(vv)) {
int res;
res = snprintf(sout, PRIM_LEN, typ->fmt, vv);
assert(res < PRIM_LEN);
} else {
float_special_tostring(vv, sout);
}
sbuf_cpy(sfbf, sout);
return sbuf_len(sfbf);
}
int
ncdouble_typ_tostring(const nctype_t *typ, safebuf_t *sfbf, const void *valp) {
char sout[PRIM_LEN];
double vv = *(double *)valp;
if(isfinite(vv)) {
int res;
res = snprintf(sout, PRIM_LEN, typ->fmt, vv);
assert(res < PRIM_LEN);
} else {
double_special_tostring(vv, sout);
}
sbuf_cpy(sfbf, sout);
return sbuf_len(sfbf);
}
int
ncubyte_typ_tostring(const nctype_t *typ, safebuf_t *sfbf, const void *valp) {
char sout[PRIM_LEN];
int res;
res = snprintf(sout, PRIM_LEN, typ->fmt, *(unsigned char *)valp);
assert(res < PRIM_LEN);
sbuf_cpy(sfbf, sout);
return sbuf_len(sfbf);
}
int
ncushort_typ_tostring(const nctype_t *typ, safebuf_t *sfbf, const void *valp) {
char sout[PRIM_LEN];
int res;
res = snprintf(sout, PRIM_LEN, typ->fmt, *(unsigned short *)valp);
assert(res < PRIM_LEN);
sbuf_cpy(sfbf, sout);
return sbuf_len(sfbf);
}
int
ncuint_typ_tostring(const nctype_t *typ, safebuf_t *sfbf, const void *valp) {
char sout[PRIM_LEN];
int res;
res = snprintf(sout, PRIM_LEN, typ->fmt, *(unsigned int *)valp);
assert(res < PRIM_LEN);
sbuf_cpy(sfbf, sout);
return sbuf_len(sfbf);
}
int
ncint64_typ_tostring(const nctype_t *typ, safebuf_t *sfbf, const void *valp) {
char sout[PRIM_LEN];
int res;
res = snprintf(sout, PRIM_LEN, typ->fmt, *(long long *)valp);
assert(res < PRIM_LEN);
sbuf_cpy(sfbf, sout);
return sbuf_len(sfbf);
}
int
ncuint64_typ_tostring(const nctype_t *typ, safebuf_t *sfbf, const void *valp) {
char sout[PRIM_LEN];
int res;
res = snprintf(sout, PRIM_LEN, typ->fmt, *(unsigned long long *)valp);
assert(res < PRIM_LEN);
sbuf_cpy(sfbf, sout);
return sbuf_len(sfbf);
}
Revert/Improve nc_create + NC_DISKLESS behavior re: https://github.com/Unidata/netcdf-c/issues/1154 Inadvertently, the behavior of NC_DISKLESS with nc_create() was changed in release 4.6.1. Previously, the NC_WRITE flag needed to be explicitly used with NC_DISKLESS in order to cause the created file to be persisted to disk. Additional analyis indicated that the current NC_DISKLESS implementation was seriously flawed. This PR attempts to clean up and regularize the situation with respect to NC_DISKLESS control. One important aspect of diskless operation is that there are two different notions of write. 1. The file is read-write vs read-only when using the netcdf API. 2. The file is persisted or not to disk at nc_close(). Previously, these two were conflated. The rules now are as follows. 1. NC_DISKLESS + NC_WRITE means that the file is read/write using the netcdf API 2. NC_DISKLESS + NC_PERSIST means that the file is persisted to a disk file at nc_close. 3. NC_DISKLESS + NC_PERSIST + NC_WRITE means both 1 and 2. The NC_PERSIST flag is new and takes over the obsolete NC_MPIPOSIX flag. NC_MPIPOSIX is still defined, but is now an alias for the NC_MPIIO flag. It is also now the case that for netcdf-4, NC_DISKLESS is independent of NC_INMEMORY and in fact it is an error to specify both flags simultaneously. Finally, the MMAP code was fixed to use NC_PERSIST as well. Also marked MMAP as deprecated. Also added a test case to test various combinations of NC_DISKLESS, NC_PERSIST, and NC_WRITE. This PR affects a number of files and especially test cases that used NC_DISKLESS. Misc. Unrelated fixes 1. fixed some warnings in ncdump/dumplib.c
2018-10-11 03:32:17 +08:00
int ncstring_typ_tostring(const nctype_t *typ, safebuf_t *sfbf, const void *valp)
{
const char *cp;
2010-06-03 21:24:43 +08:00
cp = ((char **)valp)[0];
if(cp) {
size_t slen;
char *sout;
char *sp;
unsigned char uc;
Revert/Improve nc_create + NC_DISKLESS behavior re: https://github.com/Unidata/netcdf-c/issues/1154 Inadvertently, the behavior of NC_DISKLESS with nc_create() was changed in release 4.6.1. Previously, the NC_WRITE flag needed to be explicitly used with NC_DISKLESS in order to cause the created file to be persisted to disk. Additional analyis indicated that the current NC_DISKLESS implementation was seriously flawed. This PR attempts to clean up and regularize the situation with respect to NC_DISKLESS control. One important aspect of diskless operation is that there are two different notions of write. 1. The file is read-write vs read-only when using the netcdf API. 2. The file is persisted or not to disk at nc_close(). Previously, these two were conflated. The rules now are as follows. 1. NC_DISKLESS + NC_WRITE means that the file is read/write using the netcdf API 2. NC_DISKLESS + NC_PERSIST means that the file is persisted to a disk file at nc_close. 3. NC_DISKLESS + NC_PERSIST + NC_WRITE means both 1 and 2. The NC_PERSIST flag is new and takes over the obsolete NC_MPIPOSIX flag. NC_MPIPOSIX is still defined, but is now an alias for the NC_MPIIO flag. It is also now the case that for netcdf-4, NC_DISKLESS is independent of NC_INMEMORY and in fact it is an error to specify both flags simultaneously. Finally, the MMAP code was fixed to use NC_PERSIST as well. Also marked MMAP as deprecated. Also added a test case to test various combinations of NC_DISKLESS, NC_PERSIST, and NC_WRITE. This PR affects a number of files and especially test cases that used NC_DISKLESS. Misc. Unrelated fixes 1. fixed some warnings in ncdump/dumplib.c
2018-10-11 03:32:17 +08:00
slen = 4 + 5 * strlen(cp); /* need "'s around string, and extra space to escape control characters */
slen++; /* nul term */
sout = emalloc(slen);
sp = sout;
*sp++ = '"' ;
while(*cp) {
switch (uc = *cp++ & 0377) {
case '\b':
*sp++ = '\\';
*sp++ = 'b' ;
break;
case '\f':
*sp++ = '\\';
*sp++ = 'f';
break;
case '\n':
*sp++ = '\\';
*sp++ = 'n';
break;
case '\r':
*sp++ = '\\';
*sp++ = 'r';
break;
case '\t':
*sp++ = '\\';
*sp++ = 't';
break;
case '\v':
*sp++ = '\\';
*sp++ = 'n';
break;
case '\\':
*sp++ = '\\';
*sp++ = '\\';
break;
case '\'':
*sp++ = '\\';
*sp++ = '\'';
break;
case '\"':
*sp++ = '\\';
*sp++ = '\"';
break;
default:
if (iscntrl(uc)) {
Revert/Improve nc_create + NC_DISKLESS behavior re: https://github.com/Unidata/netcdf-c/issues/1154 Inadvertently, the behavior of NC_DISKLESS with nc_create() was changed in release 4.6.1. Previously, the NC_WRITE flag needed to be explicitly used with NC_DISKLESS in order to cause the created file to be persisted to disk. Additional analyis indicated that the current NC_DISKLESS implementation was seriously flawed. This PR attempts to clean up and regularize the situation with respect to NC_DISKLESS control. One important aspect of diskless operation is that there are two different notions of write. 1. The file is read-write vs read-only when using the netcdf API. 2. The file is persisted or not to disk at nc_close(). Previously, these two were conflated. The rules now are as follows. 1. NC_DISKLESS + NC_WRITE means that the file is read/write using the netcdf API 2. NC_DISKLESS + NC_PERSIST means that the file is persisted to a disk file at nc_close. 3. NC_DISKLESS + NC_PERSIST + NC_WRITE means both 1 and 2. The NC_PERSIST flag is new and takes over the obsolete NC_MPIPOSIX flag. NC_MPIPOSIX is still defined, but is now an alias for the NC_MPIIO flag. It is also now the case that for netcdf-4, NC_DISKLESS is independent of NC_INMEMORY and in fact it is an error to specify both flags simultaneously. Finally, the MMAP code was fixed to use NC_PERSIST as well. Also marked MMAP as deprecated. Also added a test case to test various combinations of NC_DISKLESS, NC_PERSIST, and NC_WRITE. This PR affects a number of files and especially test cases that used NC_DISKLESS. Misc. Unrelated fixes 1. fixed some warnings in ncdump/dumplib.c
2018-10-11 03:32:17 +08:00
snprintf(sp,4+1,"\\%03o",uc); /* +1 for nul */
sp += 4;
}
else
*sp++ = uc;
break;
}
}
*sp++ = '"' ;
*sp = '\0' ;
sbuf_cpy(sfbf, sout);
free(sout);
}
else {
sbuf_cpy(sfbf, "NIL");
}
2010-06-03 21:24:43 +08:00
return sbuf_len(sfbf);
}
#ifdef USE_NETCDF4
2010-06-03 21:24:43 +08:00
int
ncenum_typ_tostring(const nctype_t *typ, safebuf_t *sfbf, const void *valp) {
char symbol[NC_MAX_NAME + 1];
long long val = 0;
2010-06-03 21:24:43 +08:00
switch (typ->base_tid) {
case NC_BYTE:
val = *(signed char *)valp;
break;
case NC_UBYTE:
val = *(unsigned char *)valp;
break;
case NC_SHORT:
val = *(short *)valp;
break;
case NC_USHORT:
val = *(unsigned short *)valp;
break;
case NC_INT:
val = *(int *)valp;
break;
case NC_UINT:
val = *(unsigned int *)valp;
break;
case NC_INT64:
val = *(long long *)valp;
break;
case NC_UINT64:
val = *(long long *)valp;
break;
default:
error("bad base type for enum");
break;
}
NC_CHECK( nc_inq_enum_ident(typ->ncid, typ->tid, val, symbol));
sbuf_cpy(sfbf, symbol);
return sbuf_len(sfbf);
}
/* Given an opaque type size and opaque value, convert to a string,
* represented as hexadecimal characters, returning number of chars in
* output string */
int
ncopaque_val_as_hex(size_t size, char *sout, const void *valp) {
const unsigned char *cp = valp;
char *sp = sout;
int i;
char *prefix = "0X";
int prelen = strlen(prefix);
snprintf(sp, prelen + 1, "%s", prefix);
sp += prelen;
for(i = 0; i < size; i++) {
int res;
res = snprintf(sp, prelen + 1, "%.2X", *cp++);
assert (res == 2);
sp += 2;
}
*sp = '\0';
return 2*size + prelen;
}
/* Convert an opaque value to a string, represented as hexadecimal
* characters */
int
ncopaque_typ_tostring(const nctype_t *typ, safebuf_t *sfbf,
2010-06-03 21:24:43 +08:00
const void *valp) {
char* sout = (char *) emalloc(2 * typ->size + strlen("0X") + 1);
(void) ncopaque_val_as_hex(typ->size, sout, valp);
sbuf_cpy(sfbf, sout);
free(sout);
return sbuf_len(sfbf);
}
/* Convert a vlen value to a string, by using tostring function for base type */
int
ncvlen_typ_tostring(const nctype_t *tinfo, safebuf_t *sfbf, const void *valp) {
nc_type base_type = tinfo->base_tid;
nctype_t *base_info = get_typeinfo(base_type);
size_t base_size = base_info->size;
size_t len = ((nc_vlen_t *)valp)->len;
typ_tostring_func base_typ_tostring = base_info->typ_tostring;
size_t i;
const char *vp; /* instead of void* so can increment to next */
safebuf_t* sout2 = sbuf_new();
sbuf_cpy(sfbf, "{");
/* put each val in sout2, then append sout2 to sfbf */
vp = ((nc_vlen_t *)valp)->p;
for(i = 0; i < len; i++) {
(void) base_typ_tostring(base_info, sout2, vp);
sbuf_catb(sfbf, sout2);
if(i < len - 1) {
sbuf_cat(sfbf, ", ");
}
vp += base_size;
}
sbuf_cat(sfbf, "}");
sbuf_free(sout2);
return sbuf_len(sfbf);
}
/*
* Print a number of char values as a text string.
*/
static int
chars_tostring(
safebuf_t *sbuf, /* for output */
size_t len, /* number of characters */
const char *vals /* pointer to block of values */
)
{
long iel;
const char *sp;
char *sout = (char *)emalloc(4*len + 5); /* max len of string */
char *cp = sout;
*cp++ = '"';
/* adjust len so trailing nulls don't get printed */
sp = vals + len;
while (len != 0 && *--sp == '\0')
len--;
for (iel = 0; iel < len; iel++) {
unsigned char uc;
switch (uc = *vals++ & 0377) {
case '\b':
case '\f':
case '\n':
case '\r':
case '\t':
case '\v':
case '\\':
case '\'':
case '\"':
*cp++ = '\\';
*cp++ = *(char *)&uc; /* just copy, even if char is signed */
break;
default:
if (isprint(uc))
*cp++ = *(char *)&uc; /* just copy, even if char is signed */
else {
sprintf(cp,"\\%.3o",uc);
cp += 4;
}
break;
}
}
*cp++ = '"';
*cp = '\0';
2010-06-03 21:24:43 +08:00
sbuf_cpy(sbuf, sout);
free(sout);
2010-06-03 21:24:43 +08:00
return sbuf_len(sbuf);
}
/* Convert a compound value to a string, by using tostring function for
each member field */
int
nccomp_typ_tostring(const nctype_t *tinfo, safebuf_t *sfbf, const void *valp) {
int nfields = tinfo->nfields;
int fidx; /* field id */
safebuf_t* sout2 = sbuf_new();
sbuf_cpy(sfbf, "{");
/* put each val in sout2, then append sout2 to sfbf if enough room */
for (fidx = 0; fidx < nfields; fidx++) {
size_t offset = tinfo->offsets[fidx];
nc_type fid = tinfo->fids[fidx]; /* field type id */
nctype_t *finfo = get_typeinfo(fid);
if(tinfo->ranks[fidx] == 0) {
if(finfo->tid == NC_CHAR) { /* aggregate char rows into strings */
chars_tostring(sout2, 1, ((char *)valp + offset));
} else {
finfo->typ_tostring(finfo, sout2, ((char *)valp + offset));
}
} else { /* this field is an array */
int i; /* array element counter when rank > 0 */
void *vp = (char *)valp + offset;
safebuf_t *sout3 = sbuf_new();
sbuf_cpy(sout2, "{");
if(finfo->tid == NC_CHAR) { /* aggregate char rows into strings */
int rank = tinfo->ranks[fidx];
size_t nstrings;
size_t slen;
int j;
slen = tinfo->sides[fidx][rank-1];
nstrings = 1; /* product of all but last array dimension */
for(j=0; j < rank-1; j++) {
nstrings *= tinfo->sides[fidx][j];
}
for(i=0; i < nstrings; i++) { /* loop on product of all but
last index of array */
chars_tostring(sout3, slen, (char *)vp);
vp = (char *)vp + slen;
if(i < nstrings - 1) {
sbuf_cat(sout3, ", ");
}
sbuf_catb(sout2, sout3);
}
} else {
for(i = 0; i < tinfo->nvals[fidx]; i++) {
(void) finfo->typ_tostring(finfo, sout3, vp);
vp = (char *)vp + finfo->size;
if(i < tinfo->nvals[fidx] - 1) {
sbuf_cat(sout3, ", ");
}
sbuf_catb(sout2, sout3);
}
}
sbuf_cat(sout2, "}");
sbuf_free(sout3);
}
sbuf_catb(sfbf, sout2);
if(fidx < nfields - 1) {
sbuf_cat(sfbf, ", ");
}
}
sbuf_cat(sfbf, "}");
sbuf_free(sout2);
return sbuf_len(sfbf);
}
#endif /* USE_NETCDF4 */
int
ncbyte_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {
char sout[PRIM_LEN];
int res;
res = snprintf(sout, PRIM_LEN, varp->fmt, *(signed char *)valp);
assert(res < PRIM_LEN);
sbuf_cpy(sfbf, sout);
return sbuf_len(sfbf);
}
int
ncchar_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {
char sout[PRIM_LEN];
int res;
res = snprintf(sout, PRIM_LEN, varp->fmt, *(char *)valp);
assert(res < PRIM_LEN);
sbuf_cpy(sfbf, sout);
return sbuf_len(sfbf);
}
int
ncshort_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {
char sout[PRIM_LEN];
int res;
res = snprintf(sout, PRIM_LEN, varp->fmt, *(short *)valp);
assert(res < PRIM_LEN);
sbuf_cpy(sfbf, sout);
return sbuf_len(sfbf);
}
int
ncint_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {
char sout[PRIM_LEN];
int res;
res = snprintf(sout, PRIM_LEN, varp->fmt, *(int *)valp);
assert(res < PRIM_LEN);
sbuf_cpy(sfbf, sout);
return sbuf_len(sfbf);
}
int
ncfloat_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {
char sout[PRIM_LEN];
float vv = *(float *)valp;
if(isfinite(vv)) {
int res;
res = snprintf(sout, PRIM_LEN, varp->fmt, vv);
assert(res < PRIM_LEN);
} else {
float_special_tostring(vv, sout);
}
sbuf_cpy(sfbf, sout);
return sbuf_len(sfbf);
}
int
ncdouble_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {
char sout[PRIM_LEN];
double vv = *(double *)valp;
if(isfinite(vv)) {
int res;
res = snprintf(sout, PRIM_LEN, varp->fmt, vv);
assert(res < PRIM_LEN);
} else {
double_special_tostring(vv, sout);
}
sbuf_cpy(sfbf, sout);
return sbuf_len(sfbf);
}
/* Convert value of any numeric type to a double. Beware, this may
* lose precision for values of type NC_INT64 or NC_UINT64 */
static
double to_double(const ncvar_t *varp, const void *valp) {
double dd = 0.0;
2010-06-03 21:24:43 +08:00
switch (varp->type) {
case NC_BYTE:
dd = *(signed char *)valp;
break;
case NC_SHORT:
dd = *(short *)valp;
break;
case NC_INT:
dd = *(int *)valp;
break;
case NC_FLOAT:
dd = *(float *)valp;
break;
case NC_DOUBLE:
dd = *(double *)valp;
break;
case NC_UBYTE:
dd = *(unsigned char *)valp;
break;
case NC_USHORT:
dd = *(unsigned short *)valp;
break;
case NC_UINT:
dd = *(unsigned int *)valp;
break;
case NC_INT64:
dd = *(long long *)valp;
break;
case NC_UINT64:
dd = *(unsigned long long *)valp;
break;
default:
error("to_double: type not numeric primitive");
}
return dd;
}
int
nctime_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {
char sout[PRIM_LEN];
double vv = to_double(varp, valp);
int separator = formatting_specs.iso_separator ? 'T' : ' ';
2010-06-03 21:24:43 +08:00
if(isfinite(vv)) {
int oldopts = 0;
int newopts = 0;
2010-06-03 21:24:43 +08:00
int res;
sout[0]='"';
/* Make nctime dump error messages */
oldopts = cdSetErrOpts(0);
newopts = oldopts | CU_VERBOSE;
cdSetErrOpts(newopts);
cdRel2Iso(varp->timeinfo->calendar, varp->timeinfo->units, separator, vv, &sout[1]);
cdSetErrOpts(oldopts);
2010-06-03 21:24:43 +08:00
res = strlen(sout);
sout[res++] = '"';
sout[res] = '\0';
assert(res < PRIM_LEN);
} else {
double_special_tostring(vv, sout);
}
sbuf_cpy(sfbf, sout);
return sbuf_len(sfbf);
}
int
ncubyte_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {
char sout[PRIM_LEN];
int res;
res = snprintf(sout, PRIM_LEN, varp->fmt, *(unsigned char *)valp);
assert(res < PRIM_LEN);
sbuf_cpy(sfbf, sout);
return sbuf_len(sfbf);
}
int
ncushort_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {
char sout[PRIM_LEN];
int res;
res = snprintf(sout, PRIM_LEN, varp->fmt, *(unsigned short *)valp);
assert(res < PRIM_LEN);
sbuf_cpy(sfbf, sout);
return sbuf_len(sfbf);
}
int
ncuint_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {
char sout[PRIM_LEN];
int res;
res = snprintf(sout, PRIM_LEN, varp->fmt, *(unsigned int *)valp);
assert(res < PRIM_LEN);
sbuf_cpy(sfbf, sout);
return sbuf_len(sfbf);
}
int
ncint64_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {
char sout[PRIM_LEN];
int res;
res = snprintf(sout, PRIM_LEN, varp->fmt, *(long long *)valp);
assert(res < PRIM_LEN);
sbuf_cpy(sfbf, sout);
return sbuf_len(sfbf);
}
int
ncuint64_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {
char sout[PRIM_LEN];
int res;
res = snprintf(sout, PRIM_LEN, varp->fmt, *(unsigned long long *)valp);
assert(res < PRIM_LEN);
sbuf_cpy(sfbf, sout);
return sbuf_len(sfbf);
}
int
ncstring_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {
return ncstring_typ_tostring(varp->tinfo, sfbf, valp);
}
#ifdef USE_NETCDF4
2010-06-03 21:24:43 +08:00
int
ncenum_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {
return ncenum_typ_tostring(varp->tinfo, sfbf, valp);
}
/* Convert an opaque value to a string, represented as hexadecimal
* characters */
int
ncopaque_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {
return ncopaque_typ_tostring(varp->tinfo, sfbf, valp);
}
/* Convert a vlen value to a string, by using tostring function for base type */
int
ncvlen_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {
return ncvlen_typ_tostring(varp->tinfo, sfbf, valp);
}
int
nccomp_val_tostring(const ncvar_t *varp, safebuf_t *sfbf, const void *valp) {
return nccomp_typ_tostring(varp->tinfo, sfbf, valp);
}
#endif /*USE_NETCDF4*/
2010-06-03 21:24:43 +08:00
static val_equals_func eq_funcs[] = {
ncbyte_val_equals,
ncchar_val_equals,
ncshort_val_equals,
ncint_val_equals,
ncfloat_val_equals,
ncdouble_val_equals,
2010-06-03 21:24:43 +08:00
ncubyte_val_equals,
ncushort_val_equals,
ncuint_val_equals,
ncint64_val_equals,
ncuint64_val_equals,
ncstring_val_equals
};
static typ_tostring_func ts_funcs[] = {
ncbyte_typ_tostring,
ncchar_typ_tostring,
ncshort_typ_tostring,
ncint_typ_tostring,
ncfloat_typ_tostring,
ncdouble_typ_tostring,
2010-06-03 21:24:43 +08:00
ncubyte_typ_tostring,
ncushort_typ_tostring,
ncuint_typ_tostring,
ncint64_typ_tostring,
ncuint64_typ_tostring,
ncstring_typ_tostring
};
/* Set function pointer of function to convert a value to a string for
* the variable pointed to by varp. */
void
set_tostring_func(ncvar_t *varp) {
2010-06-03 21:24:43 +08:00
val_tostring_func tostring_funcs[] = {
ncbyte_val_tostring,
ncchar_val_tostring,
ncshort_val_tostring,
ncint_val_tostring,
ncfloat_val_tostring,
ncdouble_val_tostring,
2010-06-03 21:24:43 +08:00
ncubyte_val_tostring,
ncushort_val_tostring,
ncuint_val_tostring,
ncint64_val_tostring,
ncuint64_val_tostring,
ncstring_val_tostring
};
if(varp->has_timeval && formatting_specs.string_times) {
2010-06-03 21:24:43 +08:00
varp->val_tostring = (val_tostring_func) nctime_val_tostring;
return;
}
if( !is_user_defined_type(varp->type) ) {
varp->val_tostring = tostring_funcs[varp->type - 1];
return;
}
#ifdef USE_NETCDF4
switch(varp->tinfo->class) {
case NC_VLEN:
varp->val_tostring = (val_tostring_func) ncvlen_val_tostring;
break;
case NC_OPAQUE:
varp->val_tostring = (val_tostring_func) ncopaque_val_tostring;
break;
case NC_ENUM:
varp->val_tostring = (val_tostring_func) ncenum_val_tostring;
break;
case NC_COMPOUND:
varp->val_tostring = (val_tostring_func) nccomp_val_tostring;
break;
default:
error("unrecognized class of user defined type: %d",
2010-06-03 21:24:43 +08:00
varp->tinfo->class);
}
2010-06-03 21:24:43 +08:00
#endif /* USE_NETCDF4 */
return;
}
/* Initialize typelist with primitive types. For netCDF-3 only need primitive
types. */
2010-06-03 21:24:43 +08:00
static void
init_prim_types(int ncid) {
nctype_t *tp;
int i;
int types[] =
{
2010-06-03 21:24:43 +08:00
NC_BYTE,
NC_CHAR,
NC_SHORT,
NC_INT,
NC_FLOAT,
NC_DOUBLE,
2010-06-03 21:24:43 +08:00
NC_UBYTE,
NC_USHORT,
NC_UINT,
NC_INT64,
NC_UINT64,
NC_STRING
};
size_t sizes[] = {
sizeof(char),
sizeof(char),
sizeof(short),
sizeof(int),
sizeof(float),
sizeof(double),
2010-06-03 21:24:43 +08:00
sizeof(unsigned char),
sizeof(unsigned short),
sizeof(unsigned int),
sizeof(long long),
sizeof(unsigned long long),
sizeof(char **)
};
#if 0
2010-06-03 21:24:43 +08:00
for(i=0; i < sizeof(types)/sizeof(int); i++) {
#else
for(i=0; i < max_atomic_type; i++) {
#endif
2010-06-03 21:24:43 +08:00
tp = (nctype_t *)emalloc(sizeof(nctype_t));
tp->ncid = ncid;
tp->tid = types[i];
tp->name = strdup(prim_type_name(tp->tid));
tp->grps = 0;
tp->class = 0; /* primitive type */
tp->size = sizes[i];
tp->base_tid = NC_NAT; /* not used for primitive types */
tp->nfields = 0; /* not used for primitive types */
tp->fmt = get_default_fmt(types[i]);
tp->fids = 0; /* not used for primitive types */
tp->offsets = 0; /* not used for primitive types */
tp->ranks = 0; /* not used for primitive types */
tp->sides = 0; /* not used for primitive types */
tp->nvals = 0; /* not used for primitive types */
tp->val_equals = (val_equals_func) eq_funcs[i];
tp->typ_tostring = (typ_tostring_func) ts_funcs[i];
typeadd(tp);
}
}
/* Initialize typelist.
*
* This must be done over all groups in netCDF-4, because
* variables in one group may be declared using types in a
* different group. For netCDF-3, this is just the info about
* primitive types.
*/
2010-06-03 21:24:43 +08:00
void
init_types(int ncid) {
#ifdef USE_NETCDF4
int ntypes;
#endif
if (max_type == 0) { /* if called for first time */
int maxtype = max_typeid(ncid);
int i;
nctypes = (nctype_t **) emalloc((maxtype + 2) * sizeof(nctype_t *));
for(i=0; i < maxtype+1; i++)
nctypes[i] = NULL; /* so can later skip over unused type slots */
init_prim_types(ncid);
}
#ifdef USE_NETCDF4
/* Are there any user defined types in this group? */
NC_CHECK( nc_inq_typeids(ncid, &ntypes, NULL) );
if (ntypes)
{
int t;
int *typeids = emalloc((ntypes + 1) * sizeof(int));
2010-06-03 21:24:43 +08:00
NC_CHECK( nc_inq_typeids(ncid, NULL, typeids) );
for (t = 0; t < ntypes; t++) {
nctype_t *tinfo; /* details about the type */
char type_name[NC_MAX_NAME + 1];
size_t group_name_len;
char* group_name;
int fidx; /* for compound type, field index */
tinfo = (nctype_t *) emalloc(sizeof(nctype_t));
NC_CHECK( nc_inq_user_type(ncid, typeids[t], type_name, &tinfo->size,
&tinfo->base_tid, &tinfo->nfields,
2010-06-03 21:24:43 +08:00
&tinfo->class) );
tinfo->tid = typeids[t];
tinfo->ncid = ncid;
tinfo->name = strdup(type_name);
tinfo->grps = 0;
if(tinfo->class == NC_VLEN) {
tinfo->size = sizeof(nc_vlen_t); /* not size of base type */
}
NC_CHECK( nc_inq_grpname_full(ncid, &group_name_len, NULL) );
group_name = (char *) emalloc(group_name_len + 1);
NC_CHECK( nc_inq_grpname_full(ncid, &group_name_len, group_name) );
tinfo->grps = strdup(group_name);
free(group_name);
switch(tinfo->class) {
case NC_ENUM:
tinfo->val_equals = eq_funcs[tinfo->base_tid-1];
tinfo->typ_tostring = (typ_tostring_func) ncenum_typ_tostring;
break;
case NC_COMPOUND:
tinfo->val_equals = (val_equals_func) nccomp_val_equals;
tinfo->typ_tostring = (typ_tostring_func) nccomp_typ_tostring;
tinfo->fids = (nc_type *) emalloc((tinfo->nfields + 1)
2010-06-03 21:24:43 +08:00
* sizeof(nc_type));
tinfo->offsets = (size_t *) emalloc((tinfo->nfields + 1)
2010-06-03 21:24:43 +08:00
* sizeof(size_t));
tinfo->ranks = (int *) emalloc((tinfo->nfields + 1)
2010-06-03 21:24:43 +08:00
* sizeof(int));
tinfo->sides = (int **) emalloc((tinfo->nfields + 1)
2010-06-03 21:24:43 +08:00
* sizeof(int *));
tinfo->nvals = (int *) emalloc((tinfo->nfields + 1)
2010-06-03 21:24:43 +08:00
* sizeof(int));
for (fidx = 0; fidx < tinfo->nfields; fidx++) {
size_t offset;
nc_type ftype;
int rank;
int *sides;
int i;
sides = NULL;
NC_CHECK( nc_inq_compound_field(ncid, tinfo->tid, fidx, NULL,
&offset, &ftype, &rank,
2010-06-03 21:24:43 +08:00
sides) );
if(rank > 0) sides = (int *) emalloc(rank * sizeof(int));
NC_CHECK( nc_inq_compound_field(ncid, tinfo->tid, fidx, NULL,
NULL, NULL, NULL, sides) );
tinfo->fids[fidx] = ftype;
tinfo->offsets[fidx] = offset;
tinfo->ranks[fidx] = rank;
if (rank > 0)
tinfo->sides[fidx] = (int *) emalloc(rank * sizeof(int));
tinfo->nvals[fidx] = 1;
for(i = 0; i < rank; i++) {
tinfo->sides[fidx][i] = sides[i];
tinfo->nvals[fidx] *= sides[i];
}
if (rank > 0)
free(sides);
}
break;
case NC_VLEN:
tinfo->val_equals = (val_equals_func) ncvlen_val_equals;
tinfo->typ_tostring = (typ_tostring_func) ncvlen_typ_tostring;
break;
case NC_OPAQUE:
tinfo->val_equals = (val_equals_func) ncopaque_val_equals;
tinfo->typ_tostring = (typ_tostring_func) ncopaque_typ_tostring;
break;
default:
error("bad class: %d", tinfo->class);
break;
}
2010-06-03 21:24:43 +08:00
typeadd(tinfo);
}
free(typeids);
}
/* For netCDF-4, check to see if this group has any subgroups and call
* recursively on each of them. */
{
int g, numgrps, *ncids;
/* See how many groups there are. */
NC_CHECK( nc_inq_grps(ncid, &numgrps, NULL) );
if (numgrps > 0) {
ncids = (int *) emalloc(numgrps * sizeof(int));
/* Get the list of group ids. */
NC_CHECK( nc_inq_grps(ncid, NULL, ncids) );
/* Call this function for each group. */
for (g = 0; g < numgrps; g++) {
init_types(ncids[g]);
}
free(ncids);
}
}
#endif /* USE_NETCDF4 */
}
/*
* return 1 if varid identifies a coordinate variable
* else return 0
*/
int
iscoordvar(int ncid, int varid)
{
int ndims, ndims1;
2010-06-03 21:24:43 +08:00
int dimid;
int* dimids = 0;
ncdim_t *dims = 0;
#ifdef USE_NETCDF4
int include_parents = 1;
#endif
2010-06-03 21:24:43 +08:00
int is_coord = 0; /* true if variable is a coordinate variable */
char varname[NC_MAX_NAME];
int varndims;
do { /* be safe in case someone is currently adding
* dimensions */
#ifdef USE_NETCDF4
NC_CHECK( nc_inq_dimids(ncid, &ndims, NULL, include_parents ) );
#else
NC_CHECK( nc_inq_ndims(ncid, &ndims) );
#endif
if (dims)
free(dims);
dims = (ncdim_t *) emalloc((ndims + 1) * sizeof(ncdim_t));
if (dimids)
free(dimids);
dimids = (int *) emalloc((ndims + 1) * sizeof(int));
#ifdef USE_NETCDF4
NC_CHECK( nc_inq_dimids(ncid, &ndims1, dimids, include_parents ) );
#else
{
int i;
for(i = 0; i < ndims; i++) {
dimids[i] = i; /* for netCDF-3, dimids are 0, 1, ..., ndims-1 */
}
NC_CHECK( nc_inq_ndims(ncid, &ndims1) );
}
#endif /* USE_NETCDF4 */
} while (ndims != ndims1);
2010-06-03 21:24:43 +08:00
for (dimid = 0; dimid < ndims; dimid++) {
NC_CHECK( nc_inq_dimname(ncid, dimids[dimid], dims[dimid].name) );
2010-06-03 21:24:43 +08:00
}
NC_CHECK( nc_inq_varname(ncid, varid, varname) );
NC_CHECK( nc_inq_varndims(ncid, varid, &varndims) );
2010-06-03 21:24:43 +08:00
for (dimid = 0; dimid < ndims; dimid++) {
if (strcmp(dims[dimid].name, varname) == 0 && varndims == 1) {
is_coord = 1;
break;
}
}
if(dims)
free(dims);
if(dimids)
free(dimids);
2010-06-03 21:24:43 +08:00
return is_coord;
}
/* Return true if user-defined type */
int
is_user_defined_type(nc_type type) {
nctype_t *typeinfop = get_typeinfo(type);
return (typeinfop->class > 0);
}
/*
2010-06-03 21:24:43 +08:00
* Return name of type in user-allocated space, whether built-in
* primitive type or user-defined type. Note: name must have enough
* space allocated to hold type name.
*/
void
get_type_name(int ncid, nc_type type, char *name)
{
#ifdef USE_NETCDF4
if (is_user_defined_type(type)) {
NC_CHECK(nc_inq_user_type(ncid, type, name, NULL, NULL, NULL, NULL));
2010-06-03 21:24:43 +08:00
} else {
strncpy(name, prim_type_name(type), NC_MAX_NAME + 1);
}
#else
strncpy(name, prim_type_name(type), NC_MAX_NAME + 1);
#endif /* USE_NETCDF4 */
}
/*
2010-06-03 21:24:43 +08:00
* Print type name with CDL escapes for special characters. locid is
* the id of the group in which the type is referenced, which is
* needed to determine whether an absolute type name must be printed.
* If the type is defined in the referenced group or in some ancestor
* group, only the simple type name is printed. If the type is
* defined in some other non-ancestor group, an absolute path for the
* typename is printed instead.
*/
void
print_type_name(int locid, int typeid) {
char *ename;
#ifdef USE_NETCDF4
char name[NC_MAX_NAME+1];
2010-06-03 21:24:43 +08:00
int type_inherited = 0;
int curlocid; /* group we are searching in */
int parent_groupid = locid;
int ntypes;
int stat;
#endif
assert(typeid > 0 && typeid <= max_type);
ename = escaped_name(nctypes[typeid]->name);
#ifdef USE_NETCDF4
if(is_user_defined_type(typeid)) {
/* determine if type is inherited, that is if defined in this
* group or any ancestor group */
name[NC_MAX_NAME] = '\0';
2010-06-03 21:24:43 +08:00
strncpy(name,nctypes[typeid]->name,NC_MAX_NAME);
do {
curlocid = parent_groupid;
NC_CHECK( nc_inq_typeids(curlocid, &ntypes, NULL) );
if(ntypes > 0) {
int *typeids = (int *) emalloc((ntypes + 1) * sizeof(int));
int i;
NC_CHECK( nc_inq_typeids(curlocid, &ntypes, typeids) );
for(i = 0; i < ntypes; i++) {
char curname[NC_MAX_NAME];
NC_CHECK( nc_inq_type(curlocid, typeids[i], curname, NULL) );
if(strncmp(name, curname, NC_MAX_NAME) == 0) {
type_inherited = 1;
break;
}
}
free(typeids);
if(type_inherited)
break;
}
stat = nc_inq_grp_parent(curlocid, &parent_groupid);
} while (stat != NC_ENOGRP && stat != NC_ENOTNC4);
2010-06-03 21:24:43 +08:00
if (type_inherited == 0) {
char *gname = nctypes[typeid]->grps;
print_name(gname);
fputs("/", stdout);
}
}
#endif /* USE_NETCDF4 */
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. */
2015-08-16 06:26:35 +08:00
#ifdef USE_NETCDF4
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 max_dimid = -1; /* maximum dimid across whole dataset */
int num_undims = 0; /* total number of unlimited dimensions in all groups */
int *grpids = NULL; /* temporary list of all grpids */
int igrp;
int grpid;
/* 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 */
/* Warning: we cannot assume that the dimension ids are packed */
/* Find maximum dimension id */
max_dimid = -1;
2012-11-21 05:49:28 +08:00
for(igrp = 0; igrp < num_grps; igrp++) {
int i,ndims;
int* dimids = NULL;
2012-11-21 05:49:28 +08:00
grpid = grpids[igrp];
NC_CHECK( nc_inq_dimids(grpid, &ndims, NULL, DONT_INCLUDE_PARENTS) );
num_dims += ndims;
dimids = (int*)emalloc(ndims*sizeof(int));
NC_CHECK( nc_inq_dimids(grpid, &ndims, dimids, DONT_INCLUDE_PARENTS) );
for(i=0;i<ndims;i++) {if(dimids[i] > max_dimid) max_dimid = dimids[i];}
free(dimids);
}
assert(max_dimid >= 0);
*is_unlim_p = emalloc((max_dimid + 1 + 1) * sizeof(int));
2012-11-21 05:49:28 +08:00
for(igrp = 0; igrp < num_grps; igrp++) {
int ndims, idim, *dimids, nundims;
2012-11-21 05:49:28 +08:00
grpid = grpids[igrp];
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++) {
int* isunlim = *is_unlim_p;
int did = dimids[idim];
isunlim[did] = 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++) {
int* isunlim = *is_unlim_p;
int did = dimids[idim];
isunlim[did] = 1;
num_undims++;
}
if(dimids)
free(dimids);
}
free(grpids);
return NC_NOERR;
}
2015-08-16 06:26:35 +08:00
#endif /* USE_NETCDF4 */
/* 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) {
2015-08-16 06:26:35 +08:00
NC_CHECK(init_is_unlim(ncid, &is_unlim));
for_ncid = ncid;
}
assert(is_unlim);
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;
}