/********************************************************************* * Copyright 1993, University Corporation for Atmospheric Research * 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 before in order to obtain a * definition for va_list from the GNU C compiler. */ #include #include #include #include #include #include #include #ifndef NO_FLOAT_H #include /* for FLT_EPSILON, DBL_EPSILON */ #endif /* NO_FLOAT_H */ #include #include #include "ncdump.h" #include "dumplib.h" #include "isnan.h" #include "nctime.h" #include "utils.h" static float float_eps; static double double_eps; 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); static vnode* newvnode(void); 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"; #ifndef HAVE_STRLCAT /* $OpenBSD: strlcat.c,v 1.12 2005/03/30 20:13:52 otto Exp $ */ /* * Copyright (c) 1998 Todd C. Miller * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ /* * Appends src to string dst of size siz (unlike strncat, siz is the * full size of dst, not space left). At most siz-1 characters * will be copied. Always NUL terminates (unless siz <= strlen(dst)). * Returns strlen(src) + MIN(siz, strlen(initial dst)). * If retval >= siz, truncation occurred. */ size_t strlcat(char *dst, const char *src, size_t siz) { char *d = dst; const char *s = src; size_t n = siz; size_t dlen; /* Find the end of dst and adjust bytes left but don't go past end */ while (n-- != 0 && *d != '\0') d++; dlen = d - dst; n = siz - dlen; if (n == 0) return(dlen + strlen(s)); while (*s != '\0') { if (n != 1) { *d++ = *s; n--; } s++; } *d = '\0'; return(dlen + (s - src)); /* count does not include NUL */ } #endif /* ! HAVE_STRLCAT */ /* 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; if (len == 0) return 0; 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 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 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); 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 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); assert( res < s1->len ); s1->cl += s2len; assert(SAFEBUF_CHECK(s1)); } /* Return length of string in sbuf */ size_t 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; res = snprintf(float_var_fmt, strlen(float_var_fmt) + 1, "%%.%dg", float_digits) + 1; assert(res <= sizeof(float_var_fmt)); res = snprintf(double_var_fmt, strlen(double_var_fmt) + 1, "%%.%dg", double_digits) + 1; assert(res <= sizeof(double_var_fmt)); res = snprintf(float_att_fmt, strlen(float_att_fmt) + 1, "%%#.%dgf", float_digits) + 1; assert(res <= sizeof(float_att_fmt)); res = snprintf(float_attx_fmt, strlen(float_attx_fmt) + 1, "%%#.%dg", float_digits) + 1; assert(res <= sizeof(float_attx_fmt)); res = snprintf(double_att_fmt, strlen(double_att_fmt) + 1, "%%#.%dg", 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]; /* 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", 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", 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; #ifdef USE_NETCDF4 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\""; #endif /* USE_NETCDF4 */ 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; return get_default_fmt(typeid); } static vnode* newvnode(void) { vnode *newvp = (vnode*) emalloc(sizeof(vnode)); return newvp; } /* * Get a new, empty variable list. */ vnode* newvlist(void) { vnode *vp = newvnode(); vp -> next = 0; vp -> id = -1; /* bad id */ return vp; } void varadd(vnode* vlist, int varid) { vnode *newvp = newvnode(); newvp -> next = vlist -> next; newvp -> id = varid; vlist -> next = newvp; } /* * return 1 if variable identified by varid is member of variable * list vlist points to. */ int varmember(const vnode* vlist, int varid) { vnode *vp = vlist -> next; for (; vp ; vp = vp->next) if (vp->id == varid) return 1; return 0; } /* 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"; #ifdef USE_NETCDF4 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"; #endif /* USE_NETCDF4 */ default: error("prim_type_name: bad type %d", type); return "bogus"; } } static int max_type = 0; 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)); 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 typeid */ static int max_typeid(int ncid) { int maxtypes = NC_DOUBLE; /*ignore NC_NAT?*/ #ifdef USE_NETCDF4 int nuser = 0; 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); #endif max_type = maxtypes; 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); */ /* } */ /* } */ /* } */ boolean ncbyte_val_equals(const nctype_t *this, const void *v1p, const void *v2p) { return ( *(signed char* )v1p == *(signed char* )v2p); } boolean ncchar_val_equals(const nctype_t *this, const void *v1p, const void *v2p) { return ( *(char* )v1p == *(char* )v2p); } boolean ncshort_val_equals(const nctype_t *this, const void *v1p, const void *v2p) { return ( *(short* )v1p == *(short* )v2p); } boolean ncint_val_equals(const nctype_t *this, const void *v1p, const void *v2p) { return ( *(int* )v1p == *(int* )v2p); } #define absval(x) ( (x) < 0 ? -(x) : (x) ) /* * Return ( *(float* )v1p == *(float* )v2p); * except use floating epsilon to compare very close vals as equal * and handle IEEE NaNs and infinities. */ boolean ncfloat_val_equals(const nctype_t *this, 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; } /* * Return ( *(double* )v1p == *(double* )v2p); * except use floating epsilon to compare very close vals as equal * and handle IEEE NaNs and infinities. */ boolean ncdouble_val_equals(const nctype_t *this, 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; } #ifdef USE_NETCDF4 boolean ncubyte_val_equals(const nctype_t *this, const void *v1p, const void *v2p) { return ( *(unsigned char* )v1p == *(unsigned char* )v2p); } boolean ncushort_val_equals(const nctype_t *this, const void *v1p, const void *v2p) { return ( *(unsigned short* )v1p == *(unsigned short* )v2p); } boolean ncuint_val_equals(const nctype_t *this, const void *v1p, const void *v2p) { return ( *(unsigned int* )v1p == *(unsigned int* )v2p); } boolean ncint64_val_equals(const nctype_t *this, const void *v1p, const void *v2p) { return ( *(long long* )v1p == *(long long* )v2p); } boolean ncuint64_val_equals(const nctype_t *this, const void *v1p, const void *v2p) { return ( *(unsigned long long* )v1p == *(unsigned long long* )v2p); } boolean ncstring_val_equals(const nctype_t *this, const void *v1p, const void *v2p) { return (strcmp(*((char **)v1p), *((char **)v2p)) == 0); } boolean ncopaque_val_equals(const nctype_t *this, 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; } boolean ncvlen_val_equals(const nctype_t *this, 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, (const void *)v2dat) != true) return false; v1dat += base_size; v2dat += base_size; } } return true; } /* Determine if two compound values are equal, by testing eqaulity of * each member field. */ boolean nccomp_val_equals(const nctype_t *this, 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, (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; } } } 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]; int res; res = snprintf(sout, PRIM_LEN, typ->fmt, *(char *)valp); 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); } #ifdef USE_NETCDF4 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); } int ncstring_typ_tostring(const nctype_t *typ, safebuf_t *sfbf, const void *valp) { size_t slen; char *sout; int res; slen = 3 + strlen(((char **)valp)[0]); /* need "'s around string */ sout = emalloc(slen); res = snprintf(sout, slen, "\"%s\"", ((char **)valp)[0]); assert(res > 0); sbuf_cpy(sfbf, sout); free(sout); return sbuf_len(sfbf); } int ncenum_typ_tostring(const nctype_t *typ, safebuf_t *sfbf, const void *valp) { char symbol[NC_MAX_NAME + 1]; long long val; 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, 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'; sbuf_cpy(sbuf, sout); 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; 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; #ifdef USE_NETCDF4 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; #endif /* USE_NETCDF4 */ 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); if(isfinite(vv)) { int res; sout[0]='"'; cdRel2Iso(varp->timeinfo->calendar, varp->timeinfo->units, vv, &sout[1]); 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); } #ifdef USE_NETCDF4 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); } 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 */ static val_equals_func eq_funcs[] = { ncbyte_val_equals, ncchar_val_equals, ncshort_val_equals, ncint_val_equals, ncfloat_val_equals, ncdouble_val_equals #ifdef USE_NETCDF4 , ncubyte_val_equals, ncushort_val_equals, ncuint_val_equals, ncint64_val_equals, ncuint64_val_equals, ncstring_val_equals #endif /* USE_NETCDF4 */ }; static typ_tostring_func ts_funcs[] = { ncbyte_typ_tostring, ncchar_typ_tostring, ncshort_typ_tostring, ncint_typ_tostring, ncfloat_typ_tostring, ncdouble_typ_tostring #ifdef USE_NETCDF4 , ncubyte_typ_tostring, ncushort_typ_tostring, ncuint_typ_tostring, ncint64_typ_tostring, ncuint64_typ_tostring, ncstring_typ_tostring #endif /* USE_NETCDF4 */ }; /* 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, fspec_t *specp) { val_tostring_func tostring_funcs[] = { ncbyte_val_tostring, ncchar_val_tostring, ncshort_val_tostring, ncint_val_tostring, ncfloat_val_tostring, ncdouble_val_tostring #ifdef USE_NETCDF4 , ncubyte_val_tostring, ncushort_val_tostring, ncuint_val_tostring, ncint64_val_tostring, ncuint64_val_tostring, ncstring_val_tostring #endif /* USE_NETCDF4 */ }; if(varp->has_timeval && specp->iso_times) { 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", varp->tinfo->class); } #endif /* USE_NETCDF4 */ return; } #ifdef USE_NETCDF4 /* Returns 1 if string s1 ends with string s2, 0 otherwise. */ static int strendswith(const char *s1, const char *s2) { size_t m1 = strlen(s1); size_t m2 = strlen(s2); if (m1 < m2) return 0; return (strcmp(s1 + (m1 - m2), s2) == 0); } #endif #define NC_GRP_DELIM '/' /* Get varid of variable with name using nested group syntax * "gp1/gp2/var" or "/gp1/gp2/var". In the former case, grpname of * grp corresponding to grpid must end in "gp1/gp2". In the latter * case, grpname for grpid must be exactly "/gp1/gp2". If variable * named "var" is not in group grpid, returns NC_ENOTVAR, else sets * varid and returns NC_NOERR. */ int nc_inq_gvarid(int grpid, const char *varname, int *varidp) { /* if varname has no "/" chars, then return varidp from nc_inq_varid(grpid, varname, varidp) if varname begins with "/" else get groupname corresponding to grpid get vargroup = substring of varname up to last "/" get relname = substring of varname after last "/" if (varname starts with "/" and groupname == vargroup) || (groupname ends with vargroup) return nc_inq_varid(grpid, relname, varidp) else return NC_ENOTVAR */ #ifdef USE_NETCDF4 #ifdef UNUSED const char *vp = varname; #endif char *vargroup; char *relname; char *groupname; int status; if (varname[0] == '\0') return NC_ENOTVAR; vargroup = strdup(varname); if (vargroup == NULL) return NC_ENOMEM; relname = strrchr(vargroup, NC_GRP_DELIM); if (relname != NULL) { /* name has a "/" in it */ size_t len; /* length of full group name for grpid */ *relname++ = '\0'; /* split vargroup string in two, * vargroup and relname */ if ( (status = nc_inq_grpname_full(grpid, &len, NULL)) != NC_NOERR ) { free(vargroup); return status; } groupname = (char *)emalloc(len + 1); if ( (status = nc_inq_grpname_full(grpid, &len, groupname)) == NC_NOERR ) { if(varname[0] == NC_GRP_DELIM) { if( strcmp(groupname, vargroup) == 0) status = nc_inq_varid(grpid, relname, varidp); else status = NC_ENOTVAR; } else { if(strendswith(groupname, vargroup)) status = nc_inq_varid(grpid, relname, varidp); else status = NC_ENOTVAR; } } free(vargroup); free(groupname); return status; } free(vargroup); #endif /* USE_NETCDF4 */ return nc_inq_varid(grpid, varname, varidp); } /* Initialize typelist with primitive types. For netCDF-3 only need primitive types. */ static void init_prim_types(int ncid) { nctype_t *tp; int i; int types[] = { NC_BYTE, NC_CHAR, NC_SHORT, NC_INT, NC_FLOAT, NC_DOUBLE #ifdef USE_NETCDF4 , NC_UBYTE, NC_USHORT, NC_UINT, NC_INT64, NC_UINT64, NC_STRING #endif /* USE_NETCDF4 */ }; size_t sizes[] = { sizeof(char), sizeof(char), sizeof(short), sizeof(int), sizeof(float), sizeof(double) #ifdef USE_NETCDF4 , sizeof(unsigned char), sizeof(unsigned short), sizeof(unsigned int), sizeof(long long), sizeof(unsigned long long), sizeof(char **) #endif /* USE_NETCDF4 */ }; for(i=0; i < sizeof(types)/sizeof(int); i++) { 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. */ 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)); 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, &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) * sizeof(nc_type)); tinfo->offsets = (size_t *) emalloc((tinfo->nfields + 1) * sizeof(size_t)); tinfo->ranks = (int *) emalloc((tinfo->nfields + 1) * sizeof(int)); tinfo->sides = (int **) emalloc((tinfo->nfields + 1) * sizeof(int *)); tinfo->nvals = (int *) emalloc((tinfo->nfields + 1) * 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, 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; } 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; #ifdef UNUSED int format; #endif /* 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; int dimid; int* dimids = 0; ncdim_t *dims = 0; int include_parents = 1; 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 */ NC_CHECK( nc_inq_ndims(ncid, &ndims) ); 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); for (dimid = 0; dimid < ndims; dimid++) { NC_CHECK( nc_inq_dimname(ncid, dimids[dimid], dims[dimid].name) ); } NC_CHECK( nc_inq_varname(ncid, varid, varname) ); NC_CHECK( nc_inq_varndims(ncid, varid, &varndims) ); 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); return is_coord; } /* * return 1 if varid identifies a record variable * else return 0 */ int isrecvar(int ncid, int varid) { int ndims; int is_recvar = 0; int *dimids; NC_CHECK( nc_inq_varndims(ncid, varid, &ndims) ); #ifdef USE_NETCDF4 if (ndims > 0) { int nunlimdims; int *recdimids; int dim, recdim; dimids = (int *) emalloc((ndims + 1) * sizeof(int)); NC_CHECK( nc_inq_vardimid(ncid, varid, dimids) ); NC_CHECK( nc_inq_unlimdims(ncid, &nunlimdims, NULL) ); recdimids = (int *) emalloc((nunlimdims + 1) * sizeof(int)); NC_CHECK( nc_inq_unlimdims(ncid, NULL, recdimids) ); for (dim = 0; dim < ndims && is_recvar == 0; dim++) { for(recdim = 0; recdim < nunlimdims; recdim++) { if(dimids[dim] == recdimids[recdim]) { is_recvar = 1; break; } } } free(dimids); free(recdimids); } #else if (ndims > 0) { int recdimid; dimids = (int *) emalloc((ndims + 1) * sizeof(int)); NC_CHECK( nc_inq_vardimid(ncid, varid, dimids) ); NC_CHECK( nc_inq_unlimdim(ncid, &recdimid) ); if(dimids[0] == recdimid) is_recvar = 1; free(dimids); } #endif /* USE_NETCDF4 */ return is_recvar; } /* Return true if user-defined type */ int is_user_defined_type(nc_type type) { nctype_t *typeinfop = get_typeinfo(type); return (typeinfop->class > 0); } /* * 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_inq_user_type(ncid, type, name, NULL, NULL, NULL, NULL); } 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 */ } /* * 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]; 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 */ 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); if (type_inherited == 0) { char *gname = nctypes[typeid]->grps; print_name(gname); fputs("/", stdout); } } #endif /* USE_NETCDF4 */ fputs(ename, stdout); free(ename); }