mirror of
https://github.com/Unidata/netcdf-c.git
synced 2025-03-31 17:50:26 +08:00
Merge branch 'master' into eliminate_need_for_hdf5-1.6-API
This commit is contained in:
Greg Sjaardema
GitHub
commit
e2d0bbb8ea
15
.github/workflows/run_tests.yml
vendored
15
.github/workflows/run_tests.yml
vendored
@ -124,6 +124,7 @@ jobs:
|
||||
- name: Configure
|
||||
shell: bash -l {0}
|
||||
run: CFLAGS=${CFLAGS} LDFLAGS=${LDFLAGS} LD_LIBRARY_PATH=${LD_LIBRARY_PATH} ./configure ${ENABLE_HDF4} ${ENABLE_NC4} ${ENABLE_DAP} ${ENABLE_NCZARR}
|
||||
if: ${{ success() }}
|
||||
|
||||
- name: Look at config.log if error
|
||||
shell: bash -l {0}
|
||||
@ -149,9 +150,17 @@ jobs:
|
||||
run: CFLAGS=${CFLAGS} LDFLAGS=${LDFLAGS} LD_LIBRARY_PATH=${LD_LIBRARY_PATH} make check -j
|
||||
if: ${{ success() }}
|
||||
|
||||
#- name: Make Distcheck
|
||||
# shell: bash -l {0}
|
||||
# run: CFLAGS=${CFLAGS} LDFLAGS=${LDFLAGS} LD_LIBRARY_PATH=${LD_LIBRARY_PATH} make distcheck -j
|
||||
# - name: Make Distcheck
|
||||
# shell: bash -l {0}
|
||||
# run: CFLAGS=${CFLAGS} LDFLAGS=${LDFLAGS} LD_LIBRARY_PATH=${LD_LIBRARY_PATH} DISTCHECK_CONFIGURE_FLAGS="${ENABLE_HDF4} ${ENABLE_NC4} ${ENABLE_DAP} ${ENABLE_NCZARR}" make distcheck
|
||||
# if: ${{ success() }}
|
||||
|
||||
#- name: Start SSH Debug
|
||||
# uses: luchihoratiu/debug-via-ssh@main
|
||||
# with:
|
||||
# NGROK_AUTH_TOKEN: ${{ secrets.NGROK_AUTH_TOKEN }}
|
||||
# SSH_PASS: ${{ secrets.SSH_PASS }}
|
||||
# if: ${{ failure() }}
|
||||
|
||||
nc-cmake:
|
||||
|
||||
|
||||
1
.gitignore
vendored
1
.gitignore
vendored
@ -40,7 +40,6 @@ CMakeLists.txt.user
|
||||
scan-build
|
||||
.deps
|
||||
.libs
|
||||
*.zip
|
||||
Makefile
|
||||
.DS_Store
|
||||
build-par
|
||||
|
||||
@ -727,7 +727,7 @@ IF(USE_HDF5)
|
||||
ENDIF()
|
||||
|
||||
#Check to see if H5Z_SZIP exists in HDF5_Libraries. If so, we must use szip library.
|
||||
set (CMAKE_REQUIRED_INCLUDES ${HAVE_HDF5_H})
|
||||
set (CMAKE_REQUIRED_INCLUDES ${HDF5_INCLUDE_DIR})
|
||||
CHECK_C_SOURCE_COMPILES("#include <H5public.h>
|
||||
#if !H5_HAVE_FILTER_SZIP
|
||||
#error
|
||||
@ -769,11 +769,6 @@ IF(USE_HDF5)
|
||||
CHECK_LIBRARY_EXISTS(${HDF5_C_LIBRARY_hdf5} H5allocate_memory "" HAVE_H5ALLOCATE_MEMORY)
|
||||
CHECK_LIBRARY_EXISTS(${HDF5_C_LIBRARY_hdf5} H5resize_memory "" HAVE_H5RESIZE_MEMORY)
|
||||
|
||||
|
||||
##
|
||||
# End H5Literate checks
|
||||
##
|
||||
|
||||
IF(HDF5_PARALLEL)
|
||||
SET(HDF5_CC h5pcc)
|
||||
ELSE()
|
||||
|
||||
@ -4,8 +4,18 @@ Release Notes {#RELEASE_NOTES}
|
||||
\brief Release notes file for the netcdf-c package.
|
||||
|
||||
This file contains a high-level description of this package's evolution. Releases are in reverse chronological order (most recent first). Note that, as of netcdf 4.2, the `netcdf-c++` and `netcdf-fortran` libraries have been separated into their own libraries.
|
||||
|
||||
## 4.8.1 - TBD
|
||||
|
||||
|
||||
* [Bug Fix] Fix ncdump bug when printing VLENs with basetype char. See [Github #1986](https://github.com/Unidata/netcdf-c/issues/1986).
|
||||
* [Bug Fixes] The netcdf-c library was incorrectly determining the scope of types referred to by nc_inq_type_equal. See [Github #1959](https://github.com/Unidata/netcdf-c/pull/1959) for more information.
|
||||
* [Bug Fix] Fix bug in use of XGetopt when building under Mingw. See [Github #2009](https://github.com/Unidata/netcdf-c/issues/2009).
|
||||
* [Enhancement] Improve the error reporting when attempting to use a filter for which no implementation can be found in HDF5_PLUGIN_PATH. See [Github #2000](https://github.com/Unidata/netcdf-c/pull/2000) for more information.
|
||||
* [Bug Fix] Fix `make distcheck` issue in `nczarr_test/` directory. See [Github #2007](https://github.com/Unidata/netcdf-c/issues/2007).
|
||||
* [Bug Fix] Fix bug in NCclosedir in dpathmgr.c. See [Github #2003](https://github.com/Unidata/netcdf-c/issues/2003).
|
||||
* [Bug Fix] Fix bug in ncdump that assumes that there is a relationship between the total number of dimensions and the max dimension id. See [Github #2004](https://github.com/Unidata/netcdf-c/issues/2004).
|
||||
* [Bug Fix] Fix bug in JSON processing of strings with embedded quotes. See [Github #1993](https://github.com/Unidata/netcdf-c/issues/1993).
|
||||
* [Enhancement] Add support for the new "dimension_separator" enhancement to Zarr v2. See [Github #1990](https://github.com/Unidata/netcdf-c/pull/1990) for more information.
|
||||
* [Bug Fix] Fix hack for handling failure of shell programs to properly handle escape characters. See [Github #1989](https://github.com/Unidata/netcdf-c/issues/1989).
|
||||
* [Bug Fix] Allow some primitive type names to be used as identifiers depending on the file format. See [Github #1984](https://github.com/Unidata/netcdf-c/issues/1984).
|
||||
@ -16,7 +26,6 @@ This file contains a high-level description of this package's evolution. Release
|
||||
## 4.8.0 - March 30, 2021
|
||||
|
||||
* [Enhancement] Bump the NC_DISPATCH_VERSION from 2 to 3, and as a side effect, unify the definition of NC_DISPATCH_VERSION so it only needs to be defined in CMakeLists.txt and configure.ac. See [Github #1945](https://github.com/Unidata/netcdf-c/pull/1945) for more information.
|
||||
>>>>>>> master
|
||||
* [Enhancement] Provide better cross platform path name management. This converts paths for various platforms (e.g. Windows, MSYS, etc.) so that they are in the proper format for the executing platform. See [Github #1958](https://github.com/Unidata/netcdf-c/pull/1958) for more information.
|
||||
* [Bug Fixes] The nccopy program was treating -d0 as turning deflation on rather than interpreting it as "turn off deflation". See [Github #1944](https://github.com/Unidata/netcdf-c/pull/1944) for more information.
|
||||
* [Enhancement] Add support for storing NCZarr data in zip files. See [Github #1942](https://github.com/Unidata/netcdf-c/pull/1942) for more information.
|
||||
|
||||
@ -1095,10 +1095,16 @@ AC_C_BIGENDIAN
|
||||
# Figure out platforms of special interest
|
||||
case "`uname`" in
|
||||
CYGWIN*) ISCYGWIN=yes;;
|
||||
Darwin*) ISOSX=yes;;
|
||||
WIN*) ISMSVC=yes;;
|
||||
esac
|
||||
AM_CONDITIONAL(ISCYGWIN, [test "x$ISCYGWIN" = xyes])
|
||||
AM_CONDITIONAL(ISMSVC, [test "x$ISMSVC" = xyes])
|
||||
AM_CONDITIONAL(ISOSX, [test "x$ISOSX" = xyes])
|
||||
|
||||
AC_SUBST([ISMSVC], [${ISMSVC}])
|
||||
AC_SUBST([ISCYGWIN], [${ISCYGWIN}])
|
||||
AC_SUBST([ISOSX], [${ISOSX}])
|
||||
|
||||
###
|
||||
# Crude hack to work around an issue
|
||||
@ -1722,8 +1728,6 @@ AC_DEFINE_UNQUOTED([NC_DISPATCH_VERSION], [${NC_DISPATCH_VERSION}], [Dispatch ta
|
||||
# End netcdf_meta.h definitions.
|
||||
#####
|
||||
|
||||
# This would be true for a visual studio build.
|
||||
AC_SUBST([ISMSVC], [${ISMSVC}])
|
||||
# This would be true for a cmake build.
|
||||
AC_SUBST([ISCMAKE], [])
|
||||
|
||||
|
||||
@ -15,7 +15,7 @@
|
||||
#include <getopt.h>
|
||||
#endif
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#if defined(_WIN32) && !defined(__MINGW32__)
|
||||
#include "XGetopt.h"
|
||||
#define snprintf _snprintf
|
||||
#endif
|
||||
|
||||
@ -95,6 +95,8 @@ typedef struct NC_HDF5_VAR_INFO
|
||||
HDF5_OBJID_T *dimscale_hdf5_objids;
|
||||
nc_bool_t dimscale; /**< True if var is a dimscale. */
|
||||
nc_bool_t *dimscale_attached; /**< Array of flags that are true if dimscale is attached for that dim index. */
|
||||
int flags;
|
||||
# define NC_HDF5_VAR_FILTER_MISSING 1 /* if any filter is missing */
|
||||
} NC_HDF5_VAR_INFO_T;
|
||||
|
||||
/* Struct to hold HDF5-specific info for a field. */
|
||||
@ -186,6 +188,7 @@ int NC4_hdf5_inq_var_filter_info(int ncid, int varid, unsigned int filterid, siz
|
||||
/* The NC_VAR_INFO_T->filters field is an NClist of this struct */
|
||||
struct NC_HDF5_Filter {
|
||||
int flags; /**< Flags describing state of this filter. */
|
||||
# define NC_HDF5_FILTER_MISSING 1 /* Filter implementation is not accessible */
|
||||
unsigned int filterid; /**< ID for arbitrary filter. */
|
||||
size_t nparams; /**< nparams for arbitrary filter. */
|
||||
unsigned int* params; /**< Params for arbitrary filter. */
|
||||
@ -193,8 +196,9 @@ struct NC_HDF5_Filter {
|
||||
|
||||
int NC4_hdf5_filter_remove(NC_VAR_INFO_T* var, unsigned int id);
|
||||
int NC4_hdf5_filter_lookup(NC_VAR_INFO_T* var, unsigned int id, struct NC_HDF5_Filter** fi);
|
||||
int NC4_hdf5_addfilter(NC_VAR_INFO_T* var, unsigned int id, size_t nparams, const unsigned int* params);
|
||||
int NC4_hdf5_addfilter(NC_VAR_INFO_T* var, unsigned int id, size_t nparams, const unsigned int* params, int flags);
|
||||
int NC4_hdf5_filter_freelist(NC_VAR_INFO_T* var);
|
||||
int NC4_hdf5_find_missing_filter(NC_VAR_INFO_T* var, unsigned int* idp);
|
||||
|
||||
/* Support functions for provenance info (defined in nc4hdf.c) */
|
||||
extern int NC4_hdf5get_libversion(unsigned*,unsigned*,unsigned*);/*libsrc4/nc4hdf.c*/
|
||||
|
||||
@ -16,6 +16,9 @@
|
||||
#ifdef HAVE_STDIO_H
|
||||
#include <stdio.h>
|
||||
#endif
|
||||
#ifdef HAVE_STDINT_H
|
||||
#include <stdint.h>
|
||||
#endif
|
||||
|
||||
/*
|
||||
This is included in bottom
|
||||
|
||||
@ -14,6 +14,9 @@
|
||||
#ifdef HAVE_DIRENT_H
|
||||
#include <dirent.h>
|
||||
#endif
|
||||
#ifdef HAVE_SYS_STAT_H
|
||||
#include <sys/stat.h>
|
||||
#endif
|
||||
#ifdef HAVE_FCNTL_H
|
||||
#include <fcntl.h>
|
||||
#endif
|
||||
@ -99,6 +102,9 @@ EXTERNL int NChasdriveletter(const char* path);
|
||||
/* Canonicalize and make absolute by prefixing the current working directory */
|
||||
EXTERNL char* NCpathabsolute(const char* name);
|
||||
|
||||
/* Check if this path appears to start with a windows drive letter */
|
||||
EXTERNL int NChasdriveletter(const char* path);
|
||||
|
||||
/* Convert from the local coding (e.g. ANSI) to utf-8;
|
||||
note that this can produce unexpected results for Windows
|
||||
because it first converts to wide character and then to utf8. */
|
||||
@ -133,11 +139,11 @@ EXTERNL int NCclosedir(DIR* ent);
|
||||
#define NCaccess(path,mode) access(path,mode)
|
||||
#define NCmkdir(path,mode) mkdir(path,mode)
|
||||
#define NCgetcwd(buf,len) getcwd(buf,len)
|
||||
#define NCcwd(buf, len) getcwd(buf,len)
|
||||
#define NCrmdir(path) rmdir(path)
|
||||
#ifdef HAVE_SYS_STAT_H
|
||||
#define NCstat(path,buf) stat(path,buf)
|
||||
#endif
|
||||
#define NCcwd(buf, len) getcwd(buf,len)
|
||||
#define NCrmdir(path) rmdir(path)
|
||||
#ifdef HAVE_DIRENT_H
|
||||
#define NCopendir(path) opendir(path)
|
||||
#define NCclosedir(ent) closedir(ent)
|
||||
|
||||
@ -490,7 +490,6 @@ movetor(NCDAPCOMMON* nccomm,
|
||||
CDFnode* xnode = (CDFnode*)nclistget(path,depth);
|
||||
OCdatanode reccontent = NULL;
|
||||
OCdatanode dimcontent = NULL;
|
||||
OCdatanode fieldcontent = NULL;
|
||||
Dapodometer* odom = NULL;
|
||||
int hasstringdim = 0;
|
||||
DCEsegment* segment;
|
||||
@ -605,7 +604,6 @@ fprintf(stderr," segment=%s hasstringdim=%d\n",
|
||||
|
||||
done:
|
||||
oc_data_free(conn,dimcontent);
|
||||
oc_data_free(conn,fieldcontent);
|
||||
oc_data_free(conn,reccontent);
|
||||
if(ocstat != OC_NOERR) ncstat = ocerrtoncerr(ocstat);
|
||||
if(odom) dapodom_free(odom);
|
||||
@ -627,8 +625,6 @@ movetofield(NCDAPCOMMON* nccomm,
|
||||
size_t fieldindex,gridindex;
|
||||
OClink conn = nccomm->oc.conn;
|
||||
CDFnode* xnode = (CDFnode*)nclistget(path,depth);
|
||||
OCdatanode reccontent = NULL;
|
||||
OCdatanode dimcontent = NULL;
|
||||
OCdatanode fieldcontent = NULL;
|
||||
CDFnode* xnext;
|
||||
int newdepth;
|
||||
@ -675,9 +671,7 @@ movetofield(NCDAPCOMMON* nccomm,
|
||||
segments);
|
||||
|
||||
done:
|
||||
oc_data_free(conn,dimcontent);
|
||||
oc_data_free(conn,fieldcontent);
|
||||
oc_data_free(conn,reccontent);
|
||||
if(ocstat != OC_NOERR) ncstat = ocerrtoncerr(ocstat);
|
||||
return THROW(ncstat);
|
||||
}
|
||||
|
||||
@ -1626,7 +1626,6 @@ getseqdimsize(NCDAPCOMMON* dapcomm, CDFnode* seq, size_t* sizep)
|
||||
NCerror ncstat = NC_NOERR;
|
||||
OCerror ocstat = OC_NOERR;
|
||||
OClink conn = dapcomm->oc.conn;
|
||||
OCdatanode rootcontent = NULL;
|
||||
OCddsnode ocroot;
|
||||
CDFnode* dxdroot;
|
||||
CDFnode* xseq;
|
||||
@ -1685,7 +1684,6 @@ fprintf(stderr,"sequencesize: %s = %lu\n",seq->ocname,(unsigned long)seqsize);
|
||||
|
||||
fail:
|
||||
ncbytesfree(seqcountconstraints);
|
||||
oc_data_free(conn,rootcontent);
|
||||
if(ocstat != OC_NOERR) ncstat = ocerrtoncerr(ocstat);
|
||||
return ncstat;
|
||||
}
|
||||
|
||||
@ -10,8 +10,13 @@
|
||||
#include "config.h"
|
||||
#include "ncdispatch.h"
|
||||
#include "nc_logging.h"
|
||||
#include "nclist.h"
|
||||
|
||||
#ifdef USE_NETCDF4
|
||||
|
||||
static int searchgroup(int ncid1, int tid1, int grp, int* tid2);
|
||||
static int searchgrouptree(int ncid1, int tid1, int grp, int* tid2);
|
||||
|
||||
/**
|
||||
* @internal Compare two netcdf types for equality. Must have the
|
||||
* ncids as well, to find user-defined types.
|
||||
@ -27,8 +32,7 @@
|
||||
* @author Ed Hartnett
|
||||
*/
|
||||
static int
|
||||
NC_compare_nc_types(int ncid1, int typeid1, int ncid2, int typeid2,
|
||||
int *equalp)
|
||||
NC_compare_nc_types(int ncid1, int typeid1, int ncid2, int typeid2, int *equalp)
|
||||
{
|
||||
int ret = NC_NOERR;
|
||||
|
||||
@ -152,8 +156,15 @@ NC_compare_nc_types(int ncid1, int typeid1, int ncid2, int typeid2,
|
||||
}
|
||||
|
||||
/**
|
||||
* @internal Recursively hunt for a netCDF type id. (Code from
|
||||
* nc4internal.c); Return matching typeid or 0 if not found.
|
||||
* @internal Recursively hunt for a netCDF type id, tid2, that is "equal" to tid1.
|
||||
* Question is: what search order do we use? Ncgen uses root group tree in pre-order.
|
||||
* But NC4_inq_typeid uses these rules:
|
||||
* 1. ncid2
|
||||
* 2. parents of ncid2 (up the tree to root)
|
||||
* 3. root group tree in pre-order.
|
||||
* We will leave ncgen for another day and use the nc_inq_typeid rule.
|
||||
*
|
||||
* Return matching typeid or 0 if not found.
|
||||
*
|
||||
* @param ncid1 File ID.
|
||||
* @param tid1 Type ID.
|
||||
@ -161,68 +172,35 @@ NC_compare_nc_types(int ncid1, int typeid1, int ncid2, int typeid2,
|
||||
* @param tid2 Pointer that gets type ID of equal type.
|
||||
*
|
||||
* @return ::NC_NOERR No error.
|
||||
* @author Ed Hartnett
|
||||
* @author Ed Hartnett, Dennis Heimbigner
|
||||
*/
|
||||
static int
|
||||
NC_rec_find_nc_type(int ncid1, nc_type tid1, int ncid2, nc_type* tid2)
|
||||
{
|
||||
int i,ret = NC_NOERR;
|
||||
int nids;
|
||||
int* ids = NULL;
|
||||
int ret = NC_NOERR;
|
||||
int parent;
|
||||
|
||||
/* Get all types in grp ncid2 */
|
||||
if(tid2)
|
||||
*tid2 = 0;
|
||||
if ((ret = nc_inq_typeids(ncid2, &nids, NULL)))
|
||||
return ret;
|
||||
if (nids)
|
||||
{
|
||||
if (!(ids = (int *)malloc((size_t)nids * sizeof(int))))
|
||||
return NC_ENOMEM;
|
||||
if ((ret = nc_inq_typeids(ncid2, &nids, ids)))
|
||||
return ret;
|
||||
for(i = 0; i < nids; i++)
|
||||
{
|
||||
int equal = 0;
|
||||
if ((ret = NC_compare_nc_types(ncid1, tid1, ncid2, ids[i], &equal)))
|
||||
return ret;
|
||||
if(equal)
|
||||
{
|
||||
if(tid2)
|
||||
*tid2 = ids[i];
|
||||
free(ids);
|
||||
return NC_NOERR;
|
||||
}
|
||||
}
|
||||
free(ids);
|
||||
if((ret = searchgroup(ncid1,tid1,ncid2,tid2)))
|
||||
goto done;
|
||||
if(*tid2 != 0)
|
||||
goto done; /* found */
|
||||
|
||||
/* Look in the parents of ncid2 upto the root */
|
||||
switch (ret = nc_inq_grp_parent(ncid2,&parent)) {
|
||||
case NC_NOERR:
|
||||
/* Recurse up using parent grp */
|
||||
ret = NC_rec_find_nc_type(ncid1, tid1, parent, tid2);
|
||||
break;
|
||||
case NC_ENOGRP:
|
||||
/* do the breadth-first pre-order search of the whole tree */
|
||||
/* ncid2 should be root group */
|
||||
ret = searchgrouptree(ncid1,tid1,ncid2,tid2);
|
||||
break;
|
||||
default: break;
|
||||
}
|
||||
|
||||
/* recurse */
|
||||
if ((ret = nc_inq_grps(ncid1, &nids, NULL)))
|
||||
return ret;
|
||||
if (nids)
|
||||
{
|
||||
if (!(ids = (int *)malloc((size_t)nids * sizeof(int))))
|
||||
return NC_ENOMEM;
|
||||
if ((ret = nc_inq_grps(ncid1, &nids, ids)))
|
||||
{
|
||||
free(ids);
|
||||
return ret;
|
||||
}
|
||||
for (i = 0; i < nids; i++)
|
||||
{
|
||||
ret = NC_rec_find_nc_type(ncid1, tid1, ids[i], tid2);
|
||||
if (ret && ret != NC_EBADTYPE)
|
||||
break;
|
||||
if (tid2 && *tid2 != 0) /* found */
|
||||
{
|
||||
free(ids);
|
||||
return NC_NOERR;
|
||||
}
|
||||
}
|
||||
free(ids);
|
||||
}
|
||||
return NC_EBADTYPE; /* not found */
|
||||
done:
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -711,3 +689,92 @@ nc_copy_att(int ncid_in, int varid_in, const char *name,
|
||||
|
||||
return NC_NOERR;
|
||||
}
|
||||
|
||||
#ifdef USE_NETCDF4
|
||||
|
||||
/* Helper function for NC_rec_find_nc_type();
|
||||
search a specified group for matching type.
|
||||
*/
|
||||
static int
|
||||
searchgroup(int ncid1, int tid1, int grp, int* tid2)
|
||||
{
|
||||
int i,ret = NC_NOERR;
|
||||
int nids;
|
||||
int* ids = NULL;
|
||||
|
||||
/* Get all types in grp */
|
||||
if(tid2)
|
||||
*tid2 = 0;
|
||||
if ((ret = nc_inq_typeids(grp, &nids, NULL)))
|
||||
goto done;
|
||||
if (nids)
|
||||
{
|
||||
if (!(ids = (int *)malloc((size_t)nids * sizeof(int))))
|
||||
{ret = NC_ENOMEM; goto done;}
|
||||
if ((ret = nc_inq_typeids(grp, &nids, ids)))
|
||||
goto done;
|
||||
for(i = 0; i < nids; i++)
|
||||
{
|
||||
int equal = 0;
|
||||
if ((ret = NC_compare_nc_types(ncid1, tid1, grp, ids[i], &equal)))
|
||||
goto done;
|
||||
if(equal)
|
||||
{
|
||||
if(tid2)
|
||||
*tid2 = ids[i];
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
done:
|
||||
nullfree(ids);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Helper function for NC_rec_find_nc_type();
|
||||
search a tree of groups for a matching type
|
||||
using a breadth first queue
|
||||
*/
|
||||
static int
|
||||
searchgrouptree(int ncid1, int tid1, int grp, int* tid2)
|
||||
{
|
||||
int i,ret = NC_NOERR;
|
||||
int nids;
|
||||
int* ids = NULL;
|
||||
NClist* queue = nclistnew();
|
||||
int gid;
|
||||
uintptr_t id;
|
||||
|
||||
id = grp;
|
||||
nclistpush(queue,(void*)id); /* prime the queue */
|
||||
while(nclistlength(queue) > 0) {
|
||||
id = (uintptr_t)nclistremove(queue,0);
|
||||
gid = (int)id;
|
||||
if((ret = searchgroup(ncid1,tid1,gid,tid2)))
|
||||
goto done;
|
||||
if(*tid2 != 0)
|
||||
goto done; /*we found it*/
|
||||
/* Get subgroups of gid and push onto front of the queue (for breadth first) */
|
||||
if((ret = nc_inq_grps(gid,&nids,NULL)))
|
||||
goto done;
|
||||
if (!(ids = (int *)malloc((size_t)nids * sizeof(int))))
|
||||
{ret = NC_ENOMEM; goto done;}
|
||||
if ((ret = nc_inq_grps(gid, &nids, ids)))
|
||||
goto done;
|
||||
/* push onto the end of the queue */
|
||||
for(i=0;i<nids;i++) {
|
||||
id = ids[i];
|
||||
nclistpush(queue,(void*)id);
|
||||
}
|
||||
}
|
||||
/* Not found */
|
||||
ret = NC_EBADTYPE;
|
||||
|
||||
done:
|
||||
nclistfree(queue);
|
||||
nullfree(ids);
|
||||
return ret;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@ -261,7 +261,7 @@ const char *nc_strerror(int ncerr1)
|
||||
case NC_EFILTER:
|
||||
return "NetCDF: Filter error: bad id or parameters";
|
||||
case NC_ENOFILTER:
|
||||
return "NetCDF: Filter error: filter not defined for variable";
|
||||
return "NetCDF: Filter error: unimplemented filter encountered";
|
||||
case NC_ECANTEXTEND:
|
||||
return "NetCDF: Attempt to extend dataset during NC_INDEPENDENT I/O operation. Use nc_var_par_access to set mode NC_COLLECTIVE before extending variable.";
|
||||
case NC_EMPI: return "NetCDF: MPI operation failed.";
|
||||
|
||||
@ -44,7 +44,7 @@ struct MagicFile {
|
||||
struct NCURI* uri;
|
||||
int omode;
|
||||
NCmodel* model;
|
||||
long long filelen;
|
||||
size64_t filelen;
|
||||
int use_parallel;
|
||||
void* parameters; /* !NULL if inmemory && !diskless */
|
||||
FILE* fp;
|
||||
|
||||
@ -356,10 +356,7 @@ int
|
||||
NCclosedir(DIR* ent)
|
||||
{
|
||||
int stat = NC_NOERR;
|
||||
char* cvtname = NCpathcvt(path);
|
||||
if(cvtname == NULL) {errno = ENOENT; return -1;}
|
||||
stat = closedir(cvtname);
|
||||
free(cvtname);
|
||||
if(closedir(ent) < 0) stat = errno;
|
||||
return stat;
|
||||
}
|
||||
#endif
|
||||
@ -911,33 +908,3 @@ printutf8hex(const char* s, char* sx)
|
||||
}
|
||||
*q = '\0';
|
||||
}
|
||||
|
||||
/**************************************************/
|
||||
#if 0
|
||||
#ifdef HAVE_DIRENT_H
|
||||
EXTERNL
|
||||
DIR*
|
||||
NCopendir(const char* path)
|
||||
{
|
||||
DIR* ent = NULL;
|
||||
char* cvtpath = NCpathcvt(path);
|
||||
if(cvtpath == NULL) return -1;
|
||||
ent = opendir(cvtpath);
|
||||
free(cvtpath);
|
||||
return ent;
|
||||
}
|
||||
|
||||
EXTERNL
|
||||
int
|
||||
NCclosedir(DIR* ent)
|
||||
{
|
||||
int stat = 0;
|
||||
char* cvtpath = NCpathcvt(path);
|
||||
if(cvtpath == NULL) return -1;
|
||||
stat = closedir(cvtpath);
|
||||
free(cvtpath);
|
||||
return stat;
|
||||
}
|
||||
#endif
|
||||
#endif /*0*/
|
||||
|
||||
|
||||
@ -248,7 +248,7 @@ done:
|
||||
}
|
||||
|
||||
int
|
||||
NC4_hdf5_addfilter(NC_VAR_INFO_T* var, unsigned int id, size_t nparams, const unsigned int* params)
|
||||
NC4_hdf5_addfilter(NC_VAR_INFO_T* var, unsigned int id, size_t nparams, const unsigned int* params, int flags)
|
||||
{
|
||||
int stat = NC_NOERR;
|
||||
struct NC_HDF5_Filter* fi = NULL;
|
||||
@ -280,6 +280,7 @@ NC4_hdf5_addfilter(NC_VAR_INFO_T* var, unsigned int id, size_t nparams, const un
|
||||
{stat = NC_ENOMEM; goto done;}
|
||||
memcpy(fi->params,params,sizeof(unsigned int)*fi->nparams);
|
||||
}
|
||||
fi->flags = flags;
|
||||
if(!olddef) {
|
||||
nclistpush(flist,fi);
|
||||
PRINTFILTERLIST(var,"add");
|
||||
@ -346,6 +347,8 @@ NC4_hdf5_def_var_filter(int ncid, int varid, unsigned int id, size_t nparams,
|
||||
NC_GRP_INFO_T* grp = NULL;
|
||||
NC_VAR_INFO_T* var = NULL;
|
||||
struct NC_HDF5_Filter* oldspec = NULL;
|
||||
int flags = 0;
|
||||
htri_t avail = -1;
|
||||
#ifdef HAVE_H5Z_SZIP
|
||||
int havedeflate = 0;
|
||||
int haveszip = 0;
|
||||
@ -398,6 +401,16 @@ NC4_hdf5_def_var_filter(int ncid, int varid, unsigned int id, size_t nparams,
|
||||
}
|
||||
#endif /* HAVE_H5Z_SZIP */
|
||||
|
||||
/* See if this filter is missing or not */
|
||||
if((avail = H5Zfilter_avail(id)) < 0)
|
||||
{stat = NC_EHDFERR; goto done;} /* Something in HDF5 went wrong */
|
||||
if(!avail) {
|
||||
NC_HDF5_VAR_INFO_T* hdf5_var = (NC_HDF5_VAR_INFO_T *)var->format_var_info;
|
||||
flags |= NC_HDF5_FILTER_MISSING;
|
||||
/* mark variable as unreadable */
|
||||
hdf5_var->flags |= NC_HDF5_VAR_FILTER_MISSING;
|
||||
}
|
||||
|
||||
/* If incoming filter not already defined, then check for conflicts */
|
||||
if(oldspec == NULL) {
|
||||
if(id == H5Z_FILTER_DEFLATE) {
|
||||
@ -454,7 +467,7 @@ NC4_hdf5_def_var_filter(int ncid, int varid, unsigned int id, size_t nparams,
|
||||
}
|
||||
#endif
|
||||
/* addfilter can handle case where filter is already defined, and will just replace parameters */
|
||||
if((stat = NC4_hdf5_addfilter(var,id,nparams,params)))
|
||||
if((stat = NC4_hdf5_addfilter(var,id,nparams,params,flags)))
|
||||
goto done;
|
||||
#ifdef USE_PARALLEL
|
||||
#ifdef HDF5_SUPPORTS_PAR_FILTERS
|
||||
@ -542,3 +555,19 @@ done:
|
||||
return stat;
|
||||
|
||||
}
|
||||
|
||||
/* Return ID for the first missing filter; 0 if no missing filters */
|
||||
int
|
||||
NC4_hdf5_find_missing_filter(NC_VAR_INFO_T* var, unsigned int* idp)
|
||||
{
|
||||
int i,stat = NC_NOERR;
|
||||
NClist* flist = (NClist*)var->filters;
|
||||
int id = 0;
|
||||
|
||||
for(i=0;i<nclistlength(flist);i++) {
|
||||
struct NC_HDF5_Filter* spec = (struct NC_HDF5_Filter*)nclistget(flist,i);
|
||||
if(spec->flags & NC_HDF5_FILTER_MISSING) {id = spec->filterid; break;}
|
||||
}
|
||||
if(idp) *idp = id;
|
||||
return stat;
|
||||
}
|
||||
|
||||
@ -1013,22 +1013,35 @@ static int get_filter_info(hid_t propid, NC_VAR_INFO_T *var)
|
||||
size_t cd_nelems;
|
||||
int f;
|
||||
int stat = NC_NOERR;
|
||||
NC_HDF5_VAR_INFO_T *hdf5_var;
|
||||
|
||||
assert(var);
|
||||
|
||||
/* Get HDF5-sepecific var info. */
|
||||
hdf5_var = (NC_HDF5_VAR_INFO_T *)var->format_var_info;
|
||||
|
||||
if ((num_filters = H5Pget_nfilters(propid)) < 0)
|
||||
{stat = NC_EHDFERR; goto done;}
|
||||
|
||||
for (f = 0; f < num_filters; f++)
|
||||
{
|
||||
int flags = 0;
|
||||
htri_t avail = -1;
|
||||
cd_nelems = 0;
|
||||
if ((filter = H5Pget_filter2(propid, f, NULL, &cd_nelems, NULL, 0, NULL, NULL)) < 0)
|
||||
{stat = NC_EHDFERR; goto done;}
|
||||
{stat = NC_ENOFILTER; goto done;} /* Assume this means an unknown filter */
|
||||
if((avail = H5Zfilter_avail(filter)) < 0)
|
||||
{stat = NC_EHDFERR; goto done;} /* Something in HDF5 went wrong */
|
||||
if(!avail) {
|
||||
flags |= NC_HDF5_FILTER_MISSING;
|
||||
/* mark variable as unreadable */
|
||||
hdf5_var->flags |= NC_HDF5_VAR_FILTER_MISSING;
|
||||
}
|
||||
if((cd_values = calloc(sizeof(unsigned int),cd_nelems))==NULL)
|
||||
{stat = NC_EHDFERR; goto done;}
|
||||
{stat = NC_ENOMEM; goto done;}
|
||||
if ((filter = H5Pget_filter2(propid, f, NULL, &cd_nelems, cd_values, 0, NULL, NULL)) < 0)
|
||||
{stat = NC_EHDFERR; goto done;}
|
||||
switch (filter)
|
||||
{stat = NC_EHDFERR; goto done;} /* Something in HDF5 went wrong */
|
||||
switch (filter)
|
||||
{
|
||||
case H5Z_FILTER_SHUFFLE:
|
||||
var->shuffle = NC_TRUE;
|
||||
@ -1042,7 +1055,7 @@ static int get_filter_info(hid_t propid, NC_VAR_INFO_T *var)
|
||||
if (cd_nelems != CD_NELEMS_ZLIB ||
|
||||
cd_values[0] > NC_MAX_DEFLATE_LEVEL)
|
||||
{stat = NC_EHDFERR; goto done;}
|
||||
if((stat = NC4_hdf5_addfilter(var,filter,cd_nelems,cd_values)))
|
||||
if((stat = NC4_hdf5_addfilter(var,filter,cd_nelems,cd_values,flags)))
|
||||
goto done;
|
||||
break;
|
||||
|
||||
@ -1050,7 +1063,7 @@ static int get_filter_info(hid_t propid, NC_VAR_INFO_T *var)
|
||||
/* Szip is tricky because the filter code expands the set of parameters from 2 to 4
|
||||
and changes some of the parameter values; try to compensate */
|
||||
if(cd_nelems == 0) {
|
||||
if((stat = NC4_hdf5_addfilter(var,filter,0,NULL)))
|
||||
if((stat = NC4_hdf5_addfilter(var,filter,0,NULL,flags)))
|
||||
goto done;
|
||||
} else {
|
||||
/* fix up the parameters and the #params */
|
||||
@ -1060,16 +1073,16 @@ static int get_filter_info(hid_t propid, NC_VAR_INFO_T *var)
|
||||
/* Fix up changed params */
|
||||
cd_values[0] &= (H5_SZIP_ALL_MASKS);
|
||||
/* Save info */
|
||||
stat = NC4_hdf5_addfilter(var,filter,cd_nelems,cd_values);
|
||||
stat = NC4_hdf5_addfilter(var,filter,cd_nelems,cd_values,flags);
|
||||
if(stat) goto done;
|
||||
}
|
||||
} break;
|
||||
|
||||
default:
|
||||
if(cd_nelems == 0) {
|
||||
if((stat = NC4_hdf5_addfilter(var,filter,0,NULL))) goto done;
|
||||
if((stat = NC4_hdf5_addfilter(var,filter,0,NULL,flags))) goto done;
|
||||
} else {
|
||||
stat = NC4_hdf5_addfilter(var,filter,cd_nelems,cd_values);
|
||||
stat = NC4_hdf5_addfilter(var,filter,cd_nelems,cd_values,flags);
|
||||
if(stat) goto done;
|
||||
}
|
||||
break;
|
||||
|
||||
@ -1375,6 +1375,14 @@ NC4_put_vars(int ncid, int varid, const size_t *startp, const size_t *countp,
|
||||
return retval;
|
||||
assert(hdf5_var->hdf_datasetid && (!var->ndims || (startp && countp)));
|
||||
|
||||
/* Verify that all the variable's filters are available */
|
||||
if(hdf5_var->flags & NC_HDF5_VAR_FILTER_MISSING) {
|
||||
unsigned id = 0;
|
||||
NC4_hdf5_find_missing_filter(var, &id);
|
||||
LOG((0,"missing filter: variable=%s id=%u",var->hdr.name,id));
|
||||
return NC_ENOFILTER;
|
||||
}
|
||||
|
||||
/* Convert from size_t and ptrdiff_t to hssize_t, and hsize_t. */
|
||||
/* Also do sanity checks */
|
||||
for (i = 0; i < var->ndims; i++)
|
||||
@ -1693,6 +1701,14 @@ NC4_get_vars(int ncid, int varid, const size_t *startp, const size_t *countp,
|
||||
return retval;
|
||||
assert(hdf5_var->hdf_datasetid && (!var->ndims || (startp && countp)));
|
||||
|
||||
/* Verify that all the variable's filters are available */
|
||||
if(hdf5_var->flags & NC_HDF5_VAR_FILTER_MISSING) {
|
||||
unsigned id = 0;
|
||||
NC4_hdf5_find_missing_filter(var, &id);
|
||||
LOG((0,"missing filter: variable=%s id=%u",var->hdr.name,id));
|
||||
return NC_ENOFILTER;
|
||||
}
|
||||
|
||||
/* Convert from size_t and ptrdiff_t to hsize_t. Also do sanity
|
||||
* checks. */
|
||||
for (i = 0; i < var->ndims; i++)
|
||||
|
||||
@ -29,8 +29,8 @@ extern int ncz_unload_jatts(NCZ_FILE_INFO_T*, NC_OBJ* container, NCjson* jattrs,
|
||||
extern int ncz_close_file(NC_FILE_INFO_T* file, int abort);
|
||||
|
||||
/* zcvt.c */
|
||||
extern int NCZ_convert1(NCjson* jsrc, nc_type, char* memory0);
|
||||
extern int NCZ_stringconvert1(nc_type typid, char* src, char** strp);
|
||||
extern int NCZ_convert1(NCjson* jsrc, nc_type, unsigned char* memory0);
|
||||
extern int NCZ_stringconvert1(nc_type typid, unsigned char* src, char** strp);
|
||||
extern int NCZ_stringconvert(nc_type typid, size_t len, void* data0, NCjson** jdatap);
|
||||
|
||||
/* zsync.c */
|
||||
|
||||
@ -23,7 +23,7 @@ struct ZCVT {
|
||||
};
|
||||
|
||||
int
|
||||
NCZ_convert1(NCjson* jsrc, nc_type dsttype, char* memory)
|
||||
NCZ_convert1(NCjson* jsrc, nc_type dsttype, unsigned char* memory)
|
||||
{
|
||||
int stat = NC_NOERR;
|
||||
nc_type srctype;
|
||||
@ -234,7 +234,7 @@ done:
|
||||
}
|
||||
|
||||
int
|
||||
NCZ_stringconvert1(nc_type srctype, char* src, char** strp)
|
||||
NCZ_stringconvert1(nc_type srctype, unsigned char* src, char** strp)
|
||||
{
|
||||
int stat = NC_NOERR;
|
||||
struct ZCVT zcvt;
|
||||
|
||||
@ -9,7 +9,7 @@
|
||||
#undef ZDEBUG1 /* detailed debug */
|
||||
|
||||
#undef ZCATCH /* Warning: significant performance impact */
|
||||
#define ZTRACING /* Warning: significant performance impact */
|
||||
#undef ZTRACING /* Warning: significant performance impact */
|
||||
|
||||
#include "ncexternl.h"
|
||||
#include "nclog.h"
|
||||
|
||||
@ -26,7 +26,7 @@
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
#endif
|
||||
#ifdef _MSC_VER
|
||||
#ifdef _WIN32
|
||||
#include <malloc.h>
|
||||
#endif
|
||||
|
||||
|
||||
@ -225,6 +225,7 @@ int ncz_find_default_chunksizes2(NC_GRP_INFO_T *grp, NC_VAR_INFO_T *var);
|
||||
/* The NC_VAR_INFO_T->filters field is an NClist of this struct */
|
||||
struct NCZ_Filter {
|
||||
int flags; /**< Flags describing state of this filter. */
|
||||
#define NCZ_FILTER_MISSING 1 /* Signal filter implementation is not available */
|
||||
unsigned int filterid; /**< ID for arbitrary filter. */
|
||||
size_t nparams; /**< nparams for arbitrary filter. */
|
||||
unsigned int* params; /**< Params for arbitrary filter. */
|
||||
|
||||
@ -318,7 +318,7 @@ NCJlex(NCJparser* parser)
|
||||
start = parser->pos;
|
||||
for(;;) {
|
||||
c = *parser->pos++;
|
||||
if(c == NCJ_ESCAPE) c++;
|
||||
if(c == NCJ_ESCAPE) parser->pos++;
|
||||
else if(c == NCJ_QUOTE || c == '\0') break;
|
||||
}
|
||||
if(c == '\0') {
|
||||
|
||||
@ -377,13 +377,16 @@ nczm_localize(const char* path, char** localpathp, int localize)
|
||||
char* p;
|
||||
int forward = 1;
|
||||
int offset = 0;
|
||||
static const char* windrive = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
||||
|
||||
#ifdef _MSC_VER
|
||||
forward = (localize?0:1);
|
||||
#endif
|
||||
/* If path comes from a url, then it may start with: /x:/...
|
||||
where x is a drive letter. If so, then remove leading / */
|
||||
if(path[0] == '/' && NChasdriveletter(path+1))
|
||||
if(strlen(path) >= 4
|
||||
&& path[0] == '/' && strchr(windrive,path[1]) != NULL
|
||||
&& path[2] == ':' && path[3] == '/')
|
||||
offset = 1;
|
||||
if((localpath = strdup(path+offset))==NULL) return NC_ENOMEM;
|
||||
|
||||
|
||||
@ -30,7 +30,7 @@ static int parsedimrefs(NC_FILE_INFO_T*, NClist* dimnames, size64_t* shape, NC_
|
||||
static int decodeints(NCjson* jshape, size64_t* shapes);
|
||||
static int computeattrdata(nc_type* typeidp, NCjson* values, size_t* lenp, void** datap);
|
||||
static int inferattrtype(NCjson* values, nc_type* typeidp);
|
||||
static int mininttype(unsigned long long u64);
|
||||
static int mininttype(unsigned long long u64, int negative);
|
||||
static int computedimrefs(NC_FILE_INFO_T* file, NC_VAR_INFO_T* var, int purezarr, int xarray, int ndims, NClist* dimnames, size64_t* shapes, NC_DIM_INFO_T** dims);
|
||||
|
||||
/**************************************************/
|
||||
@ -825,7 +825,7 @@ zconvert(nc_type typeid, size_t typelen, void* dst0, NCjson* src)
|
||||
int stat = NC_NOERR;
|
||||
int i;
|
||||
size_t len;
|
||||
char* dst = dst0; /* Work in char* space so we can do pointer arithmetic */
|
||||
unsigned char* dst = dst0; /* Work in char* space so we can do pointer arithmetic */
|
||||
|
||||
switch (src->sort) {
|
||||
case NCJ_ARRAY:
|
||||
@ -902,6 +902,7 @@ computeattrdata(nc_type* typeidp, NCjson* values, size_t* lenp, void** datap)
|
||||
void* data = NULL;
|
||||
size_t typelen;
|
||||
nc_type typeid = NC_NAT;
|
||||
int reclaimvalues = 0;
|
||||
|
||||
/* Get assumed type */
|
||||
if(typeidp) typeid = *typeidp;
|
||||
@ -941,56 +942,42 @@ computeattrdata(nc_type* typeidp, NCjson* values, size_t* lenp, void** datap)
|
||||
if(typeidp) *typeidp = typeid; /* return possibly inferred type */
|
||||
|
||||
done:
|
||||
if(reclaimvalues) NCJreclaim(values); /* we created it */
|
||||
nullfree(data);
|
||||
return THROW(stat);
|
||||
}
|
||||
|
||||
static int
|
||||
inferattrtype(NCjson* values, nc_type* typeidp)
|
||||
inferattrtype(NCjson* value, nc_type* typeidp)
|
||||
{
|
||||
nc_type typeid;
|
||||
NCjson* j = NULL;
|
||||
unsigned long long u64;
|
||||
long long i64;
|
||||
int negative = 0;
|
||||
|
||||
if(NCJlength(values) == 0) return NC_EINVAL;
|
||||
switch (values->sort) {
|
||||
case NCJ_ARRAY:
|
||||
/* use the first value to decide */
|
||||
if(NCJarrayith(values,0,&j)) return NC_EINVAL;
|
||||
switch(j->sort) {
|
||||
case NCJ_INT:
|
||||
if(j->value[0] == '-') {
|
||||
sscanf(j->value,"%lld",&i64);
|
||||
u64 = (unsigned long long)i64;
|
||||
} else
|
||||
sscanf(j->value,"%llu",&u64);
|
||||
typeid = mininttype(u64);
|
||||
break;
|
||||
case NCJ_DOUBLE:
|
||||
typeid = NC_DOUBLE;
|
||||
break;
|
||||
case NCJ_BOOLEAN:
|
||||
typeid = NC_UBYTE;
|
||||
break;
|
||||
default: return NC_EINTERNAL;
|
||||
}
|
||||
break;
|
||||
/* Might be a singleton */
|
||||
if(NCJlength(value) == 0) return NC_EINVAL;
|
||||
if(value->sort == NCJ_ARRAY) {
|
||||
if(NCJarrayith(value,0,&j)) return NC_EINVAL;
|
||||
return inferattrtype(j,typeidp);
|
||||
}
|
||||
if(value->value)
|
||||
negative = (value->value[0] == '-');
|
||||
switch (value->sort) {
|
||||
case NCJ_INT:
|
||||
if(values->value[0] == '-') {
|
||||
sscanf(values->value,"%lld",&i64);
|
||||
u64 = (unsigned long long)i64;
|
||||
} else
|
||||
sscanf(values->value,"%llu",&u64);
|
||||
typeid = mininttype(u64);
|
||||
break;
|
||||
if(negative) {
|
||||
sscanf(value->value,"%lld",&i64);
|
||||
u64 = (unsigned long long)i64;
|
||||
} else
|
||||
sscanf(value->value,"%llu",&u64);
|
||||
typeid = mininttype(u64,negative);
|
||||
break;
|
||||
case NCJ_DOUBLE:
|
||||
typeid = NC_DOUBLE;
|
||||
break;
|
||||
typeid = NC_DOUBLE;
|
||||
break;
|
||||
case NCJ_BOOLEAN:
|
||||
typeid = NC_UBYTE;
|
||||
break;
|
||||
typeid = NC_UBYTE;
|
||||
break;
|
||||
case NCJ_STRING: /* requires special handling as an array of characters */
|
||||
typeid = NC_CHAR;
|
||||
break;
|
||||
@ -1002,10 +989,10 @@ inferattrtype(NCjson* values, nc_type* typeidp)
|
||||
}
|
||||
|
||||
static int
|
||||
mininttype(unsigned long long u64)
|
||||
mininttype(unsigned long long u64, int negative)
|
||||
{
|
||||
long long i64 = (long long)u64; /* keep bit pattern */
|
||||
if(u64 >= NC_MAX_INT64) return NC_UINT64;
|
||||
if(!negative && u64 >= NC_MAX_INT64) return NC_UINT64;
|
||||
if(i64 < 0) {
|
||||
if(i64 >= NC_MIN_BYTE) return NC_BYTE;
|
||||
if(i64 >= NC_MIN_SHORT) return NC_SHORT;
|
||||
@ -1175,7 +1162,7 @@ ncz_read_atts(NC_FILE_INFO_T* file, NC_OBJ* container)
|
||||
|
||||
if(jattrs != NULL) {
|
||||
/* Iterate over the attributes to create the in-memory attributes */
|
||||
/* Watch for reading _FillValue and possibly _ARRAY_DIMENSIONS (xarray) */
|
||||
/* Watch for special cases: _FillValue and _ARRAY_DIMENSIONS (xarray) */
|
||||
for(i=0;i<nclistlength(jattrs->contents);i+=2) {
|
||||
NCjson* key = nclistget(jattrs->contents,i);
|
||||
NCjson* value = nclistget(jattrs->contents,i+1);
|
||||
@ -2032,3 +2019,43 @@ done:
|
||||
NCJreclaim(jatts);
|
||||
return THROW(stat);
|
||||
}
|
||||
|
||||
#if 0
|
||||
Not currently used
|
||||
Special compatibility case:
|
||||
if the value of the attribute is a dictionary,
|
||||
or an array with non-atomic values, then
|
||||
then stringify it and pretend it is of char type.
|
||||
/* Return 1 if this json is not an
|
||||
atomic value or an array of atomic values.
|
||||
That is, it does not look like valid
|
||||
attribute data.
|
||||
*/
|
||||
static int
|
||||
iscomplexjson(NCjson* j)
|
||||
{
|
||||
int i;
|
||||
switch(j->sort) {
|
||||
case NCJ_ARRAY:
|
||||
/* verify that the elements of the array are not complex */
|
||||
for(i=0;i<nclistlength(j->contents);i++) {
|
||||
switch (((NCjson*)nclistget(j->contents,i))->sort) {
|
||||
case NCJ_DICT:
|
||||
case NCJ_ARRAY:
|
||||
case NCJ_UNDEF:
|
||||
case NCJ_NULL:
|
||||
return 1;
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
case NCJ_DICT:
|
||||
case NCJ_UNDEF:
|
||||
case NCJ_NULL:
|
||||
break;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -554,8 +554,8 @@ NC4_inq_typeid(int ncid, const char *name, nc_type *typeidp)
|
||||
NC_GRP_INFO_T *grptwo;
|
||||
NC_FILE_INFO_T *h5;
|
||||
NC_TYPE_INFO_T *type = NULL;
|
||||
char *norm_name;
|
||||
int i, retval;
|
||||
char *norm_name = NULL;
|
||||
int i, retval = NC_NOERR;
|
||||
|
||||
/* Handle atomic types. */
|
||||
for (i = 0; i < NUM_ATOMIC_TYPES; i++)
|
||||
@ -563,27 +563,47 @@ NC4_inq_typeid(int ncid, const char *name, nc_type *typeidp)
|
||||
{
|
||||
if (typeidp)
|
||||
*typeidp = i;
|
||||
return NC_NOERR;
|
||||
goto done;
|
||||
}
|
||||
|
||||
/* Find info for this file and group, and set pointer to each. */
|
||||
if ((retval = nc4_find_grp_h5(ncid, &grp, &h5)))
|
||||
return retval;
|
||||
goto done;
|
||||
assert(h5 && grp);
|
||||
|
||||
/* If the first char is a /, this is a fully-qualified
|
||||
* name. Otherwise, this had better be a local name (i.e. no / in
|
||||
* the middle). */
|
||||
if (name[0] != '/' && strstr(name, "/"))
|
||||
return NC_EINVAL;
|
||||
{retval = NC_EINVAL; goto done;}
|
||||
|
||||
/* Normalize name. */
|
||||
if (!(norm_name = (char*)malloc(strlen(name) + 1)))
|
||||
return NC_ENOMEM;
|
||||
if ((retval = nc4_normalize_name(name, norm_name))) {
|
||||
free(norm_name);
|
||||
return retval;
|
||||
{retval = NC_ENOMEM; goto done;}
|
||||
if ((retval = nc4_normalize_name(name, norm_name)))
|
||||
goto done;
|
||||
|
||||
/* If this is a fqn, then walk the sequence of parent groups to the last group
|
||||
and see if that group has a type of the right name */
|
||||
if(name[0] == '/') { /* FQN */
|
||||
int rootncid = (grp->nc4_info->root_grp->hdr.id | grp->nc4_info->controller->ext_ncid);
|
||||
int parent = 0;
|
||||
char* lastname = strrchr(norm_name,'/'); /* break off the last segment: the type name */
|
||||
if(lastname == norm_name)
|
||||
{retval = NC_EINVAL; goto done;}
|
||||
*lastname++ = '\0'; /* break off the lastsegment */
|
||||
if((retval = NC4_inq_grp_full_ncid(rootncid,norm_name,&parent)))
|
||||
goto done;
|
||||
/* Get parent info */
|
||||
if((retval=nc4_find_nc4_grp(parent,&grp)))
|
||||
goto done;
|
||||
/* See if type exists in this group */
|
||||
type = (NC_TYPE_INFO_T*)ncindexlookup(grp->type,lastname);
|
||||
if(type == NULL)
|
||||
{retval = NC_EBADTYPE; goto done;}
|
||||
goto done;
|
||||
}
|
||||
|
||||
/* Is the type in this group? If not, search parents. */
|
||||
for (grptwo = grp; grptwo; grptwo = grptwo->parent) {
|
||||
type = (NC_TYPE_INFO_T*)ncindexlookup(grptwo->type,norm_name);
|
||||
@ -602,13 +622,13 @@ NC4_inq_typeid(int ncid, const char *name, nc_type *typeidp)
|
||||
if (typeidp)
|
||||
*typeidp = type->hdr.id;
|
||||
|
||||
free(norm_name);
|
||||
|
||||
/* OK, I give up already! */
|
||||
if (!type)
|
||||
return NC_EBADTYPE;
|
||||
{retval = NC_EBADTYPE; goto done;}
|
||||
|
||||
return NC_NOERR;
|
||||
done:
|
||||
nullfree(norm_name);
|
||||
return retval;
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -28,6 +28,7 @@ IF(BUILD_UTILITIES)
|
||||
SET(NC4_TESTS ${NC4_TESTS} tst_xplatform)
|
||||
build_bin_test(renamegroup)
|
||||
add_sh_test(nc_test4 run_grp_rename)
|
||||
build_bin_test(tst_charvlenbug)
|
||||
ADD_SH_TEST(nc_test4 tst_misc)
|
||||
build_bin_test(tst_fillonly)
|
||||
ADD_SH_TEST(nc_test4 test_fillonly)
|
||||
|
||||
@ -35,7 +35,7 @@ tst_h_scalar tst_rename tst_rename2 tst_rename3 tst_h5_endians \
|
||||
tst_atts_string_rewrite tst_hdf5_file_compat tst_fill_attr_vanish \
|
||||
tst_rehash tst_filterparser tst_bug324 tst_types tst_atts3 \
|
||||
tst_put_vars tst_elatefill tst_udf tst_put_vars_two_unlim_dim \
|
||||
tst_bug1442
|
||||
tst_bug1442 tst_charvlenbug
|
||||
|
||||
# Temporary I hoped, but hoped in vain.
|
||||
if !ISCYGWIN
|
||||
|
||||
@ -27,14 +27,8 @@ FP_NAME="$1"
|
||||
# Figure out the compiler (some values from ./configure)
|
||||
FP_ISCMAKE=@ISCMAKE@
|
||||
FP_ISMSVC=@ISMSVC@
|
||||
|
||||
# Are we operating under OS-X? (test using uname)
|
||||
FP_OS=`uname | cut -d '_' -f 1`
|
||||
if test "x$FP_OS" = xDarwin ; then FP_ISOSX=1; fi
|
||||
|
||||
# Are we operating under CYGWIN? (test using uname)
|
||||
FP_OS=`uname | cut -d '_' -f 1`
|
||||
if test "x$FP_OS" = xCYGWIN ; then FP_ISCYGWIN=1; fi
|
||||
FP_ISCYGWIN=@ISCYGWIN@
|
||||
FP_ISOSX=@ISOSX@
|
||||
|
||||
FP_PLUGINS="$TOPBUILDDIR/plugins"
|
||||
|
||||
|
||||
111
nc_test4/tst_charvlenbug.c
Executable file
111
nc_test4/tst_charvlenbug.c
Executable file
@ -0,0 +1,111 @@
|
||||
#define AFIRST
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include "netcdf.h"
|
||||
|
||||
#define FILE "tst_charvlenbug.nc"
|
||||
|
||||
void checkErrorCode(int status, const char* message){
|
||||
if (status != NC_NOERR){
|
||||
fprintf(stderr,"Error code: %d: %s\n",status,message);
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
main(int argc, const char * argv[])
|
||||
{
|
||||
int ncid;
|
||||
int retval;
|
||||
int dimid_a;
|
||||
int dimid_b;
|
||||
int dimids[2];
|
||||
int varid;
|
||||
int typeid;
|
||||
int ndims, dimids_read[NC_MAX_VAR_DIMS];
|
||||
size_t dimlen;
|
||||
size_t num_items;
|
||||
ptrdiff_t stride[2] = {1, 1};
|
||||
nc_vlen_t vlenPointers[4];
|
||||
nc_vlen_t* readVlenPointers;
|
||||
|
||||
#ifdef AFIRST
|
||||
size_t start[2] = {1, 0};
|
||||
size_t count[2] = {2, 2};
|
||||
#else
|
||||
size_t start[2] = {0, 1};
|
||||
size_t count[2] = {2, 2};
|
||||
#endif
|
||||
|
||||
// set up data
|
||||
|
||||
vlenPointers[0].len = 1; vlenPointers[0].p = "a";
|
||||
vlenPointers[1].len = 2; vlenPointers[1].p = "aa";
|
||||
vlenPointers[2].len = 1; vlenPointers[2].p = "b";
|
||||
vlenPointers[3].len = 2; vlenPointers[3].p = "bb";
|
||||
|
||||
// -- WRITE --
|
||||
|
||||
retval = nc_create(FILE, NC_NETCDF4, &ncid);
|
||||
checkErrorCode(retval, "nc_create");
|
||||
|
||||
// Define dimensions
|
||||
retval = nc_def_dim(ncid, "a", NC_UNLIMITED, &dimid_a);
|
||||
checkErrorCode(retval, "nc_def_dim for 'a'");
|
||||
|
||||
retval = nc_def_dim(ncid, "b", 4, &dimid_b);
|
||||
checkErrorCode(retval, "nc_def_dim for 'b'");
|
||||
|
||||
/* Define VLEN type */
|
||||
retval = nc_def_vlen(ncid,"str",NC_CHAR,&typeid);
|
||||
checkErrorCode(retval, "nc_def_vlen");
|
||||
|
||||
// Define variable
|
||||
#ifdef AFIRST
|
||||
dimids[0] = dimid_a;
|
||||
dimids[1] = dimid_b;
|
||||
#else
|
||||
dimids[0] = dimid_b;
|
||||
dimids[1] = dimid_a;
|
||||
#endif
|
||||
retval = nc_def_var(ncid, "var", typeid, 2, dimids, &varid);
|
||||
checkErrorCode(retval, "nc_def_var");
|
||||
|
||||
// Put variable
|
||||
|
||||
retval = nc_put_vars(ncid, varid, start, count, stride, vlenPointers);
|
||||
// retval = nc_put_vara_string(ncid, varid, start, count, vlenPointers);
|
||||
checkErrorCode(retval, "nc_put_vars_string");
|
||||
|
||||
retval = nc_close(ncid);
|
||||
checkErrorCode(retval, "nc_close(1)");
|
||||
|
||||
// -- READ --
|
||||
retval = nc_open(FILE, NC_NOWRITE, &ncid);
|
||||
checkErrorCode(retval, "nc_open");
|
||||
|
||||
// get dimensions
|
||||
retval = nc_inq_var(ncid, varid, NULL, NULL, &ndims, dimids_read, NULL);
|
||||
checkErrorCode(retval, "nc_inq_var");
|
||||
|
||||
// calculate num elements to read
|
||||
dimlen = 0;
|
||||
num_items = 1;
|
||||
for ( int j = 0; j < ndims; ++j ) {
|
||||
retval = nc_inq_dimlen(ncid, dimids_read[j], &dimlen);
|
||||
checkErrorCode(retval, "nc_inq_dimlen");
|
||||
num_items *= dimlen;
|
||||
}
|
||||
|
||||
// get var
|
||||
readVlenPointers = (nc_vlen_t*)malloc(sizeof(nc_vlen_t)*num_items);
|
||||
retval = nc_get_var(ncid, varid, readVlenPointers);
|
||||
checkErrorCode(retval, "nc_get_var");
|
||||
|
||||
retval = nc_close(ncid);
|
||||
checkErrorCode(retval, "nc_close(2)");
|
||||
|
||||
free(readVlenPointers);
|
||||
return retval;
|
||||
}
|
||||
@ -1,4 +1,4 @@
|
||||
#!/bin/sh
|
||||
#!/bin/bash
|
||||
|
||||
if test "x$srcdir" = x ; then srcdir=`pwd`; fi
|
||||
. ../test_common.sh
|
||||
@ -41,10 +41,23 @@ trimleft() {
|
||||
sed -e 's/[ ]*\([^ ].*\)/\1/' <$1 >$2
|
||||
}
|
||||
|
||||
# Hide/unhide the bzip2 filter
|
||||
hidebzip2() {
|
||||
rm -fr ${HDF5_PLUGIN_PATH}/save
|
||||
mkdir ${HDF5_PLUGIN_PATH}/save
|
||||
mv ${BZIP2PATH} ${HDF5_PLUGIN_PATH}/save
|
||||
}
|
||||
|
||||
unhidebzip2() {
|
||||
mv ${HDF5_PLUGIN_PATH}/save/${BZIP2LIB} ${HDF5_PLUGIN_PATH}
|
||||
rm -fr ${HDF5_PLUGIN_PATH}/save
|
||||
}
|
||||
|
||||
# Locate the plugin path and the library names; argument order is critical
|
||||
# Find bzip2 and capture
|
||||
findplugin h5bzip2
|
||||
BZIP2PATH="${HDF5_PLUGIN_PATH}/${HDF5_PLUGIN_LIB}"
|
||||
BZIP2LIB="${HDF5_PLUGIN_LIB}"
|
||||
BZIP2PATH="${HDF5_PLUGIN_PATH}/${BZIP2LIB}"
|
||||
# Find misc and capture
|
||||
findplugin misc
|
||||
MISCPATH="${HDF5_PLUGIN_PATH}/${HDF5_PLUGIN_LIB}"
|
||||
@ -169,23 +182,31 @@ fi
|
||||
if test "x$UNK" = x1 ; then
|
||||
echo "*** Testing access to filter info when filter dll is not available"
|
||||
rm -f bzip2.nc ./tst_filter.txt
|
||||
# build bzip2.nc
|
||||
# xfail build bzip2.nc
|
||||
hidebzip2
|
||||
if ${NCGEN} -lb -4 -o bzip2.nc ${srcdir}/bzip2.cdl ; then
|
||||
echo "*** FAIL: ncgen"
|
||||
else
|
||||
echo "*** XFAIL: ncgen"
|
||||
fi
|
||||
unhidebzip2
|
||||
# build bzip2.nc
|
||||
${NCGEN} -lb -4 -o bzip2.nc ${srcdir}/bzip2.cdl
|
||||
# dump and clean bzip2.nc header only when filter is avail
|
||||
${NCDUMP} -hs bzip2.nc > ./tst_filter.txt
|
||||
# Remove irrelevant -s output
|
||||
sclean ./tst_filter.txt bzip2.dump
|
||||
# Now hide the filter code
|
||||
mv ${BZIP2PATH} ${BZIP2PATH}.save
|
||||
# dump and clean bzip2.nc header only when filter is not avail
|
||||
hidebzip2
|
||||
rm -f ./tst_filter.txt
|
||||
# This will xfail
|
||||
if ${NCDUMP} -s bzip2.nc > ./tst_filter.txt ; then
|
||||
echo "*** FAIL: ncdump -hs bzip2.nc"
|
||||
else
|
||||
echo "*** XFAIL: ncdump -hs bzip2.nc"
|
||||
fi
|
||||
# Restore the filter code
|
||||
unhidebzip2
|
||||
# Verify we can see filter when using -h
|
||||
rm -f ./tst_filter.txt
|
||||
${NCDUMP} -hs bzip2.nc > ./tst_filter.txt
|
||||
# Remove irrelevant -s output
|
||||
sclean ./tst_filter.txt bzip2x.dump
|
||||
# Restore the filter code
|
||||
mv ${BZIP2PATH}.save ${BZIP2PATH}
|
||||
diff -b -w ./bzip2.dump ./bzip2x.dump
|
||||
echo "*** Pass: ncgen dynamic filter"
|
||||
echo "*** Pass: unknown filter"
|
||||
fi
|
||||
|
||||
if test "x$NGC" = x1 ; then
|
||||
|
||||
@ -5,16 +5,27 @@ if test "x$srcdir" = x ; then srcdir=`pwd`; fi
|
||||
|
||||
set -e
|
||||
|
||||
ECODE=0
|
||||
|
||||
echo "*** Testing phony dimension creation on pure h5 file"
|
||||
rm -f ./tmp
|
||||
if $NCDUMP -L0 -K ${srcdir}/tdset.h5 >./tmp ; then
|
||||
echo "*** Pass: phony dimension creation"
|
||||
ECODE=0
|
||||
else
|
||||
echo "*** Fail: phony dimension creation"
|
||||
ECODE=1
|
||||
fi
|
||||
|
||||
echo "*** Testing char(*) type printout error in ncdump"
|
||||
rm -f ./tst_charvlenbug.nc ./tmp
|
||||
${execdir}/tst_charvlenbug
|
||||
if $NCDUMP ./tst_charvlenbug.nc 2>1 >./tmp ; then
|
||||
echo "*** Pass: char(*) ncdump printout"
|
||||
else
|
||||
echo "*** Fail: char(*) ncdump printout"
|
||||
ECODE=1
|
||||
fi
|
||||
|
||||
rm -f tmp
|
||||
|
||||
exit $ECODE
|
||||
|
||||
@ -13,6 +13,7 @@ SET(ncdump_FILES ncdump.c vardata.c dumplib.c indent.c nctime0.c utils.c nciter.
|
||||
SET(nccopy_FILES nccopy.c nciter.c chunkspec.c utils.c dimmap.c list.c)
|
||||
SET(ocprint_FILES ocprint.c)
|
||||
SET(ncvalidator_FILES ncvalidator.c)
|
||||
SET(printfqn_FILES printfqn.c)
|
||||
|
||||
IF(USE_X_GETOPT)
|
||||
SET(ncdump_FILES ${ncdump_FILES} XGetopt.c)
|
||||
@ -27,6 +28,7 @@ ADD_EXECUTABLE(ncvalidator ${ncvalidator_FILES})
|
||||
|
||||
IF(USE_HDF5)
|
||||
ADD_EXECUTABLE(nc4print nc4print.c nc4printer.c)
|
||||
ADD_EXECUTABLE(printfqn ${printfqn_FILES})
|
||||
ENDIF(USE_HDF5)
|
||||
|
||||
IF(ENABLE_DAP)
|
||||
@ -39,6 +41,7 @@ TARGET_LINK_LIBRARIES(ncvalidator netcdf ${ALL_TLL_LIBS})
|
||||
|
||||
IF(USE_HDF5)
|
||||
TARGET_LINK_LIBRARIES(nc4print netcdf ${ALL_TLL_LIBS})
|
||||
TARGET_LINK_LIBRARIES(printfqn netcdf ${ALL_TLL_LIBS})
|
||||
ENDIF(USE_HDF5)
|
||||
|
||||
IF(ENABLE_DAP)
|
||||
@ -81,6 +84,15 @@ IF(MSVC)
|
||||
${CMAKE_CURRENT_BINARY_DIR})
|
||||
SET_TARGET_PROPERTIES(ncvalidator PROPERTIES RUNTIME_OUTPUT_DIRECTORY_RELEASE
|
||||
${CMAKE_CURRENT_BINARY_DIR})
|
||||
|
||||
SET_TARGET_PROPERTIES(printfqn PROPERTIES RUNTIME_OUTPUT_DIRECTORY
|
||||
${CMAKE_CURRENT_BINARY_DIR})
|
||||
SET_TARGET_PROPERTIES(printfqn PROPERTIES RUNTIME_OUTPUT_DIRECTORY_DEBUG
|
||||
${CMAKE_CURRENT_BINARY_DIR})
|
||||
SET_TARGET_PROPERTIES(printfqn PROPERTIES RUNTIME_OUTPUT_DIRECTORY_RELEASE
|
||||
${CMAKE_CURRENT_BINARY_DIR})
|
||||
|
||||
|
||||
ENDIF(USE_HDF5)
|
||||
|
||||
IF(ENABLE_DAP)
|
||||
@ -315,8 +327,14 @@ IF(ENABLE_TESTS)
|
||||
add_sh_test(ncdump test_keywords)
|
||||
ENDIF()
|
||||
|
||||
|
||||
IF(USE_HDF5)
|
||||
add_sh_test(ncdump test_scope)
|
||||
ENDIF()
|
||||
|
||||
add_sh_test(ncdump test_rcmerge)
|
||||
|
||||
|
||||
ENDIF(ENABLE_TESTS)
|
||||
|
||||
#IF(MSVC)
|
||||
|
||||
@ -46,6 +46,13 @@ if USE_HDF5
|
||||
bin_PROGRAMS += nc4print
|
||||
noinst_PROGRAMS += nc4print
|
||||
nc4print_SOURCES = nc4print.c nc4printer.c
|
||||
|
||||
# Create a helper program for tst_scope.sh
|
||||
# Program prints out the fqn of the type of
|
||||
# a specified variable in the .nc file.
|
||||
noinst_PROGRAMS += printfqn
|
||||
printfqn_SOURCES = printfqn.c
|
||||
|
||||
endif
|
||||
|
||||
# Conditionally build the ocprint program, but do not install
|
||||
@ -66,7 +73,7 @@ bom tst_dimsizes nctrunc tst_rcmerge
|
||||
# Tests for classic and 64-bit offset files.
|
||||
TESTS = tst_inttags.sh run_tests.sh tst_64bit.sh ref_ctest \
|
||||
ref_ctest64 tst_output.sh tst_lengths.sh tst_calendars.sh \
|
||||
run_utf8_tests.sh test_unicode_directory.sh tst_nccopy3.sh tst_nccopy3_subset.sh \
|
||||
run_utf8_tests.sh tst_nccopy3.sh tst_nccopy3_subset.sh \
|
||||
tst_charfill.sh tst_iter.sh tst_formatx3.sh tst_bom.sh \
|
||||
tst_dimsizes.sh run_ncgen_tests.sh tst_ncgen4_classic.sh test_radix.sh test_rcmerge.sh
|
||||
|
||||
@ -80,6 +87,10 @@ if USE_STRICT_NULL_BYTE_HEADER_PADDING
|
||||
XFAIL_TESTS += tst_null_byte_padding.sh
|
||||
endif
|
||||
|
||||
if ! ISCYGWIN
|
||||
TESTS += test_unicode_directory.sh
|
||||
endif
|
||||
|
||||
if LARGE_FILE_TESTS
|
||||
TESTS += tst_iter.sh
|
||||
endif
|
||||
@ -99,7 +110,7 @@ TESTS += tst_fileinfo.sh tst_hdf5_offset.sh tst_inttags4.sh \
|
||||
tst_netcdf4.sh tst_fillbug.sh tst_netcdf4_4.sh tst_nccopy4.sh \
|
||||
tst_nccopy5.sh tst_grp_spec.sh tst_mud.sh tst_h_scalar.sh tst_formatx4.sh \
|
||||
run_utf8_nc4_tests.sh run_back_comp_tests.sh run_ncgen_nc4_tests.sh \
|
||||
tst_ncgen4.sh
|
||||
tst_ncgen4.sh test_scope.sh
|
||||
|
||||
# Record interscript dependencies so parallel builds work.
|
||||
tst_nccopy4.log: run_ncgen_tests.log tst_output.log tst_ncgen4.log \
|
||||
@ -162,10 +173,10 @@ ref_provenance_v1.nc ref_tst_radix.cdl tst_radix.cdl test_radix.sh \
|
||||
ref_nccopy_w.cdl tst_nccopy_w3.sh tst_nccopy_w4.sh \
|
||||
ref_no_ncproperty.nc test_unicode_directory.sh \
|
||||
ref_roman_szip_simple.cdl ref_roman_szip_unlim.cdl ref_tst_perdimspecs.cdl \
|
||||
test_keywords.sh ref_keyword1.cdl ref_keyword2.cdl \
|
||||
ref_keyword3.cdl ref_keyword4.cdl \
|
||||
ref_tst_nofilters.cdl test_unicode_path.sh test_rcmerge.sh \
|
||||
ref_rcmerge1.txt ref_rcmerge2.txt ref_rcmerge3.txt
|
||||
test_keywords.sh ref_keyword1.cdl ref_keyword2.cdl ref_keyword3.cdl ref_keyword4.cdl \
|
||||
ref_tst_nofilters.cdl test_scope.sh type_group_only.cdl type_ancestor_only.cdl \
|
||||
type_ancestor_subgroup.cdl type_preorder.cdl test_unicode_path.sh \
|
||||
test_rcmerge.sh ref_rcmerge1.txt ref_rcmerge2.txt ref_rcmerge3.txt
|
||||
|
||||
# The L512.bin file is file containing exactly 512 bytes each of value 0.
|
||||
# It is used for creating hdf5 files with varying offsets for testing.
|
||||
@ -202,9 +213,11 @@ ctest64.c nccopy3_subset_out.nc camrun.c tst_ncf213.cdl tst_ncf213.nc \
|
||||
tst_radix.nc tmp_radix.cdl ctest_small_3.c ctest_small_4.c \
|
||||
ctest_special_atts_4.c tst_roman_szip_simple.cdl \
|
||||
tst_roman_szip_unlim.cdl tst_perdimpspecs.nc tmppds.* \
|
||||
keyword1.nc keyword2.nc keyword3.nc keyword4.nc \
|
||||
tmp_keyword1.cdl tmp_keyword2.cdl tmp_keyword3.cdl tmp_keyword4.cdl
|
||||
keyword1.nc keyword2.nc keyword3.nc keyword4.nc \
|
||||
tmp_keyword1.cdl tmp_keyword2.cdl tmp_keyword3.cdl tmp_keyword4.cdl \
|
||||
type_*.nc copy_type_*.cdl
|
||||
|
||||
# Remove directories
|
||||
clean-local:
|
||||
rm -fr rcmergedir
|
||||
|
||||
|
||||
@ -696,8 +696,11 @@ ncbyte_typ_tostring(const nctype_t *typ, safebuf_t *sfbf, const void *valp) {
|
||||
int
|
||||
ncchar_typ_tostring(const nctype_t *typ, safebuf_t *sfbf, const void *valp) {
|
||||
char sout[PRIM_LEN];
|
||||
char cstr[2];
|
||||
int res;
|
||||
res = snprintf(sout, PRIM_LEN, typ->fmt, *(char *)valp);
|
||||
cstr[0] = *(char*)valp;
|
||||
cstr[1] = '\0';
|
||||
res = snprintf(sout, PRIM_LEN, typ->fmt, cstr);
|
||||
assert(res < PRIM_LEN);
|
||||
sbuf_cpy(sfbf, sout);
|
||||
return sbuf_len(sfbf);
|
||||
@ -1803,6 +1806,7 @@ 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;
|
||||
@ -1822,13 +1826,22 @@ init_is_unlim(int ncid, int **is_unlim_p)
|
||||
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;
|
||||
for(igrp = 0; igrp < num_grps; igrp++) {
|
||||
int ndims;
|
||||
int i,ndims;
|
||||
int* dimids = NULL;
|
||||
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);
|
||||
}
|
||||
*is_unlim_p = emalloc((num_dims + 1) * sizeof(int));
|
||||
assert(max_dimid >= 0);
|
||||
*is_unlim_p = emalloc((max_dimid + 1 + 1) * sizeof(int));
|
||||
for(igrp = 0; igrp < num_grps; igrp++) {
|
||||
int ndims, idim, *dimids, nundims;
|
||||
grpid = grpids[igrp];
|
||||
@ -1837,13 +1850,17 @@ init_is_unlim(int ncid, int **is_unlim_p)
|
||||
NC_CHECK( nc_inq_dimids(grpid, &ndims, dimids, DONT_INCLUDE_PARENTS) );
|
||||
/* mark all dims in this group as fixed-size */
|
||||
for(idim = 0; idim < ndims; idim++) {
|
||||
(*is_unlim_p)[dimids[idim]] = 0;
|
||||
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++) {
|
||||
(*is_unlim_p)[dimids[idim]] = 1;
|
||||
int* isunlim = *is_unlim_p;
|
||||
int did = dimids[idim];
|
||||
isunlim[did] = 1;
|
||||
num_undims++;
|
||||
}
|
||||
if(dimids)
|
||||
|
||||
@ -13,7 +13,7 @@
|
||||
#include <getopt.h>
|
||||
#endif
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#if defined(_WIN32) && !defined(__MINGW32__)
|
||||
#include "XGetopt.h"
|
||||
#define snprintf _snprintf
|
||||
#endif
|
||||
|
||||
@ -8,7 +8,8 @@ Research/Unidata. See \ref copyright file for more info. */
|
||||
#ifdef HAVE_GETOPT_H
|
||||
#include <getopt.h>
|
||||
#endif
|
||||
#ifdef _MSC_VER
|
||||
|
||||
#if defined(_WIN32) && !defined(__MINGW32__)
|
||||
#include "XGetopt.h"
|
||||
#define snprintf _snprintf
|
||||
#endif
|
||||
|
||||
@ -73,7 +73,7 @@ THIS SOFTWARE.
|
||||
#include <unistd.h> /* read() getopt() */
|
||||
#endif
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#if defined(_WIN32) && !defined(__MINGW32__)
|
||||
#include <io.h>
|
||||
#include "XGetopt.h"
|
||||
#define snprintf _snprintf
|
||||
|
||||
@ -31,7 +31,7 @@
|
||||
#include "oc.h"
|
||||
#include "ocx.h"
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#if defined(_WIN32) && !defined(__MINGW32__)
|
||||
#include "XGetopt.h"
|
||||
#endif
|
||||
|
||||
|
||||
143
ncdump/printfqn.c
Normal file
143
ncdump/printfqn.c
Normal file
@ -0,0 +1,143 @@
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <assert.h>
|
||||
#include <netcdf.h>
|
||||
|
||||
#define CHECK(err) {if(err) report(err,__LINE__);}
|
||||
|
||||
static void
|
||||
report(int err, int lineno)
|
||||
{
|
||||
fprintf(stderr,"Error: %d: %s\n", lineno, nc_strerror(err));
|
||||
exit(1);
|
||||
}
|
||||
|
||||
void
|
||||
usage(void)
|
||||
{
|
||||
fprintf(stderr,"usage: printfqn <filename> <varname>\n");
|
||||
exit(0);
|
||||
}
|
||||
|
||||
int
|
||||
get_type_parent(int ncid, int tid, int* parentp)
|
||||
{
|
||||
int stat = NC_NOERR;
|
||||
int i;
|
||||
int nids;
|
||||
int ids[4096];
|
||||
|
||||
/* Does this group have the type we are searching for? */
|
||||
if((stat=nc_inq_typeids(ncid,&nids,ids))) goto done;
|
||||
assert(nids < 4096);
|
||||
|
||||
/* Search for this typeid */
|
||||
for(i=0;i<nids;i++) {
|
||||
if(ids[i] == tid) {
|
||||
if(parentp) *parentp = ncid;
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
|
||||
/* Else Search subgroups. */
|
||||
if((stat=nc_inq_grps(ncid,&nids,ids))) goto done;
|
||||
assert(nids < 4096);
|
||||
|
||||
/* Recurse on each subgroup */
|
||||
for(i=0;i<nids;i++) {
|
||||
switch (stat = get_type_parent(ids[i],tid,parentp)) {
|
||||
case NC_EBADTYPE: break; /* not found; keep looking */
|
||||
case NC_NOERR: goto done; /* found it */
|
||||
default: goto done; /* some other error */
|
||||
}
|
||||
}
|
||||
stat = NC_EBADTYPE; /* Not found */
|
||||
|
||||
done:
|
||||
return stat;
|
||||
|
||||
}
|
||||
|
||||
int
|
||||
get_variable_info(int ncid, const char* name, int* gidp, int* vidp)
|
||||
{
|
||||
int stat = NC_NOERR;
|
||||
int i;
|
||||
int nids;
|
||||
int ids[4096];
|
||||
char varname[NC_MAX_NAME];
|
||||
|
||||
/* Assume only one occurrence of the variable in dataset */
|
||||
|
||||
/* Does this group have the variable we are searching for? */
|
||||
if((stat=nc_inq_varids(ncid,&nids,ids))) goto done;
|
||||
assert(nids < 4096);
|
||||
|
||||
/* Search for this variable name */
|
||||
for(i=0;i<nids;i++) {
|
||||
if((stat = nc_inq_varname(ncid,ids[i],varname))) goto done;
|
||||
if(strcmp(name,varname)==0) {
|
||||
if(gidp) *gidp = ncid;
|
||||
if(vidp) *vidp = ids[i];
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
|
||||
/* Else Search subgroups. */
|
||||
if((stat=nc_inq_grps(ncid,&nids,ids))) goto done;
|
||||
assert(nids < 4096);
|
||||
|
||||
/* Recurse on each subgroup */
|
||||
for(i=0;i<nids;i++) {
|
||||
switch (stat = get_variable_info(ids[i],name,gidp,vidp)) {
|
||||
case NC_ENOTVAR: break; /* not found; keep looking */
|
||||
case NC_NOERR: goto done; /* found it */
|
||||
default: goto done; /* some other error */
|
||||
}
|
||||
}
|
||||
stat = NC_ENOTVAR; /* Not found */
|
||||
|
||||
done:
|
||||
return stat;
|
||||
}
|
||||
|
||||
int
|
||||
main(int argc, char** argv)
|
||||
{
|
||||
int ncid, varid, gid, tid;
|
||||
const char* filename = NULL;
|
||||
char varname[NC_MAX_NAME];
|
||||
size_t fqnlen, namelen;
|
||||
char fqn[4096];
|
||||
char name[NC_MAX_NAME];
|
||||
|
||||
if(argc < 3) usage();
|
||||
|
||||
filename = argv[1];
|
||||
strcpy(varname,argv[2]);
|
||||
|
||||
CHECK(nc_open(filename,NC_NETCDF4,&ncid));
|
||||
|
||||
/* Locate the parent group for the variable */
|
||||
CHECK(get_variable_info(ncid,varname,&gid,&varid));
|
||||
|
||||
/* Get the type id of the variable */
|
||||
CHECK(nc_inq_vartype(gid,varid,&tid));
|
||||
/* Get the type name */
|
||||
CHECK(nc_inq_type(ncid,tid,name,&namelen));
|
||||
|
||||
/* Get the containing group id for the type */
|
||||
CHECK(get_type_parent(ncid,tid,&gid));
|
||||
|
||||
/* Get the FQN name for the containing type */
|
||||
CHECK(nc_inq_grpname_full(gid,&fqnlen,fqn));
|
||||
assert(fqnlen < sizeof(fqn));
|
||||
|
||||
if(strcmp(fqn,"/")==0) fqn[0] = '\0';
|
||||
|
||||
/* report result with no newline */
|
||||
printf("|%s/%s|",fqn,name);
|
||||
|
||||
return 0;
|
||||
}
|
||||
46
ncdump/test_scope.sh
Executable file
46
ncdump/test_scope.sh
Executable file
@ -0,0 +1,46 @@
|
||||
#!/bin/bash
|
||||
|
||||
if test "x$srcdir" = x ; then srcdir=`pwd`; fi
|
||||
. ../test_common.sh
|
||||
|
||||
set -x
|
||||
set -e
|
||||
|
||||
# Test cases
|
||||
# group_only - type defined in same group as var/attr
|
||||
# ancestor_only - type defined in some ancestor group of var/attr
|
||||
# ancestor_subgroup - type defined in both ancestor group and subgroup
|
||||
# preorder - type defined in some preceding, non ancestor group
|
||||
|
||||
TSTS="type_group_only type_ancestor_only type_ancestor_subgroup type_preorder"
|
||||
|
||||
SETUP=1
|
||||
|
||||
setup() {
|
||||
${NCGEN} -4 -lb ${srcdir}/$1.cdl
|
||||
}
|
||||
|
||||
testscope() {
|
||||
${NCCOPY} ${execdir}/$1.nc ${execdir}/$1_copy.nc
|
||||
${NCDUMP} -h -n $1 ${execdir}/$1_copy.nc > copy_$1.cdl
|
||||
diff -wB ${srcdir}/$1.cdl ${execdir}/copy_$1.cdl
|
||||
REFT=`${execdir}/printfqn ${execdir}/$1.nc test_variable`
|
||||
COPYT=`${execdir}/printfqn ${execdir}/$1_copy.nc test_variable`
|
||||
if test "x$REFT" != "x$COPYT" ; then
|
||||
echo "***Fail: ref=${REFT} copy=${COPYT}"
|
||||
fi
|
||||
}
|
||||
|
||||
if test "x$SETUP" = x1 ; then
|
||||
for t in $TSTS ; do
|
||||
setup $t
|
||||
done
|
||||
fi
|
||||
|
||||
for t in $TSTS ; do
|
||||
testscope $t
|
||||
done
|
||||
|
||||
exit 0
|
||||
|
||||
|
||||
21
ncdump/type_ancestor_only.cdl
Normal file
21
ncdump/type_ancestor_only.cdl
Normal file
@ -0,0 +1,21 @@
|
||||
netcdf type_ancestor_only {
|
||||
types:
|
||||
ubyte enum test_enum_type {OPTION1 = 0, OPTION2 = 1, OPTION3 = 2} ;
|
||||
|
||||
group: test_group {
|
||||
variables:
|
||||
test_enum_type test_variable ;
|
||||
test_enum_type test_variable:_FillValue = OPTION1 ;
|
||||
|
||||
group: test_subgroup1 {
|
||||
|
||||
group: test_subsubgroup {
|
||||
} // group test_subsubgroup
|
||||
|
||||
} // group test_subgroup1
|
||||
|
||||
group: test_subgroup2 {
|
||||
} // group test_subgroup2
|
||||
|
||||
} // group test_group
|
||||
}
|
||||
15
ncdump/type_ancestor_subgroup.cdl
Normal file
15
ncdump/type_ancestor_subgroup.cdl
Normal file
@ -0,0 +1,15 @@
|
||||
netcdf type_ancestor_subgroup {
|
||||
types:
|
||||
ubyte enum test_enum_type {OPTION1 = 0, OPTION2 = 1, OPTION3 = 2} ;
|
||||
|
||||
group: test_group {
|
||||
variables:
|
||||
test_enum_type test_variable ;
|
||||
test_enum_type test_variable:_FillValue = OPTION1 ;
|
||||
group: sub_group {
|
||||
types:
|
||||
ubyte enum test_enum_type {OPTION1 = 0, OPTION2 = 1, OPTION3 = 2} ;
|
||||
} // group sub_group
|
||||
|
||||
} // group test_group
|
||||
}
|
||||
10
ncdump/type_group_only.cdl
Normal file
10
ncdump/type_group_only.cdl
Normal file
@ -0,0 +1,10 @@
|
||||
netcdf type_group_only {
|
||||
|
||||
group: test_group {
|
||||
types:
|
||||
ubyte enum test_enum_type {OPTION1 = 0, OPTION2 = 1, OPTION3 = 2} ;
|
||||
variables:
|
||||
test_enum_type test_variable ;
|
||||
test_enum_type test_variable:_FillValue = OPTION1 ;
|
||||
} // group test_group
|
||||
}
|
||||
13
ncdump/type_preorder.cdl
Normal file
13
ncdump/type_preorder.cdl
Normal file
@ -0,0 +1,13 @@
|
||||
netcdf type_preorder {
|
||||
|
||||
group: preorder {
|
||||
types:
|
||||
ubyte enum test_enum_type {OPTION1 = 0, OPTION2 = 1, OPTION3 = 2} ;
|
||||
} // group preorder
|
||||
|
||||
group: test_group {
|
||||
variables:
|
||||
/preorder/test_enum_type test_variable ;
|
||||
/preorder/test_enum_type test_variable:_FillValue = OPTION1 ;
|
||||
} // group test_group
|
||||
}
|
||||
@ -12,7 +12,7 @@
|
||||
#include <getopt.h>
|
||||
#endif
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#if defined(_WIN32) && !defined(__MINGW32__)
|
||||
#include "XGetopt.h"
|
||||
#endif
|
||||
|
||||
|
||||
@ -15,7 +15,7 @@
|
||||
#include <getopt.h>
|
||||
#endif
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#if defined(_WIN32) && !defined(__MINGW32__)
|
||||
#include "XGetopt.h"
|
||||
#define snprintf _snprintf
|
||||
#endif
|
||||
|
||||
@ -23,7 +23,7 @@ LDADD = ${top_builddir}/liblib/libnetcdf.la
|
||||
check_PROGRAMS =
|
||||
TESTS =
|
||||
|
||||
check_PROGRAMS += ut_map ut_mapapi ut_json ut_projections ut_chunking
|
||||
check_PROGRAMS += ut_map ut_mapapi ut_json ut_projections ut_chunking
|
||||
|
||||
commonsrc = ut_util.c ut_test.c ut_includes.h ut_test.h ut_util.h test_nczarr_utils.h
|
||||
tstcommonsrc = tst_utils.c tst_utils.h
|
||||
@ -62,7 +62,7 @@ TESTS += run_misc.sh
|
||||
endif
|
||||
|
||||
if BUILD_BENCHMARKS
|
||||
if BUILD_UTILITIES
|
||||
if BUILD_UTILITIES
|
||||
|
||||
UTILSRC = bm_utils.c timer_utils.c tst_utils.c
|
||||
|
||||
@ -114,10 +114,8 @@ ref_skip.cdl ref_skip.txt ref_skipw.cdl \
|
||||
ref_rem.cdl ref_rem.dmp ref_ndims.cdl ref_ndims.dmp \
|
||||
ref_misc1.cdl ref_misc1.dmp ref_misc2.cdl \
|
||||
ref_avail1.cdl ref_avail1.dmp ref_avail1.txt \
|
||||
ref_xarray.cdl ref_purezarr.cdl ref_purezarr_base.cdl ref_nczarr2zarr.cdl
|
||||
|
||||
# Interoperability files
|
||||
EXTRA_DIST += power_901_constants.zip ref_power_901_constants.cdl
|
||||
ref_xarray.cdl ref_purezarr.cdl ref_purezarr_base.cdl ref_nczarr2zarr.cdl \
|
||||
ref_power_901_constants.zip ref_power_901_constants.cdl ref_quotes.zip ref_quotes.cdl
|
||||
|
||||
CLEANFILES = ut_*.txt ut*.cdl tmp*.nc tmp*.cdl tmp*.txt tmp*.dmp tmp*.zip tmp*.nc
|
||||
|
||||
@ -126,3 +124,4 @@ clean-local:
|
||||
rm -fr tmp*.file results.file results.s3 results.zip
|
||||
rm -fr power_901_constants.file
|
||||
rm -fr rcmiscdir
|
||||
rm -rf ref_power_901_constants.file
|
||||
|
||||
@ -15,7 +15,7 @@
|
||||
#include <getopt.h>
|
||||
#endif
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#if defined(_WIN32) && !defined(__MINGW32__)
|
||||
#include "XGetopt.h"
|
||||
#endif
|
||||
|
||||
|
||||
@ -10,7 +10,7 @@
|
||||
#include <getopt.h>
|
||||
#endif
|
||||
|
||||
#ifdef _WIN32
|
||||
#if defined(_WIN32) && !defined(__MINGW32__)
|
||||
#include "XGetopt.h"
|
||||
#endif
|
||||
|
||||
|
||||
Binary file not shown.
@ -1,4 +1,4 @@
|
||||
netcdf power_901_constants {
|
||||
netcdf ref_power_901_constants {
|
||||
dimensions:
|
||||
lat = 361 ;
|
||||
lon = 576 ;
|
||||
|
||||
BIN
nczarr_test/ref_power_901_constants.zip
Normal file
BIN
nczarr_test/ref_power_901_constants.zip
Normal file
Binary file not shown.
19
nczarr_test/ref_quotes.cdl
Normal file
19
nczarr_test/ref_quotes.cdl
Normal file
@ -0,0 +1,19 @@
|
||||
netcdf ref_quotes {
|
||||
dimensions:
|
||||
time = 10 ;
|
||||
lat = 20 ;
|
||||
lon = 30 ;
|
||||
variables:
|
||||
float fractional_snow_cover(time, lat, lon) ;
|
||||
fractional_snow_cover:ID = 68b ;
|
||||
fractional_snow_cover:esa_cci_path = NaN ;
|
||||
fractional_snow_cover:long_name = "Surface Fraction Covered by Snow" ;
|
||||
fractional_snow_cover:orig_attrs = "{\'comment\': \'Grid cell fractional snow cover based on the Globsnow CCI product.\', \'long_name\': \'Surface fraction covered by snow.\', \'project_name\': \'GlobSnow\', \'references\': \'Luojus, Kari, et al. \"ESA DUE Globsnow-Global Snow Database for Climate Research.\" ESA Special Publication. Vol. 686. 2010.\', \'source_name\': \'MFSC\', \'standard_name\': \'surface_snow_area_fraction\', \'units\': \'percent\', \'url\': \'http://www.globsnow.info/\'}" ;
|
||||
fractional_snow_cover:orig_version = "v2.0" ;
|
||||
fractional_snow_cover:project_name = "GlobSnow" ;
|
||||
fractional_snow_cover:time_coverage_end = "2013-01-05" ;
|
||||
fractional_snow_cover:time_coverage_resolution = "P8D" ;
|
||||
fractional_snow_cover:time_coverage_start = "2003-01-05" ;
|
||||
fractional_snow_cover:units = "percent" ;
|
||||
fractional_snow_cover:url = "http://www.globsnow.info/" ;
|
||||
}
|
||||
BIN
nczarr_test/ref_quotes.zip
Normal file
BIN
nczarr_test/ref_quotes.zip
Normal file
Binary file not shown.
@ -19,7 +19,7 @@ testcasefile() {
|
||||
fileargs ${execdir}/$ref "mode=$mode,$zext"
|
||||
rm -f tmp_${ref}_${zext}.cdl
|
||||
${NCDUMP} $flags $fileurl > tmp_${ref}_${zext}.cdl
|
||||
diff -b ${srcdir}/ref_${ref}.cdl tmp_${ref}_${zext}.cdl
|
||||
diff -b ${srcdir}/${ref}.cdl tmp_${ref}_${zext}.cdl
|
||||
}
|
||||
|
||||
testcasezip() {
|
||||
@ -30,7 +30,7 @@ testcasezip() {
|
||||
fileargs ${execdir}/$ref "mode=$mode,$zext"
|
||||
rm -f tmp_${ref}_${zext}.cdl
|
||||
${NCDUMP} $flags $fileurl > tmp_${ref}_${zext}.cdl
|
||||
diff -b ${srcdir}/ref_${ref}.cdl tmp_${ref}_${zext}.cdl
|
||||
diff -b ${srcdir}/${ref}.cdl tmp_${ref}_${zext}.cdl
|
||||
}
|
||||
|
||||
testallcases() {
|
||||
@ -38,17 +38,20 @@ zext=$1
|
||||
case "$zext" in
|
||||
file)
|
||||
# need to unpack
|
||||
rm -fr power_901_constants power_901_constants.file
|
||||
unzip ${srcdir}/power_901_constants.zip > /dev/null
|
||||
mv power_901_constants power_901_constants.file
|
||||
testcasefile power_901_constants zarr metaonly; # test xarray as default
|
||||
rm -fr ref_power_901_constants ref_power_901_constants.file
|
||||
unzip ${srcdir}/ref_power_901_constants.zip > /dev/null
|
||||
mv ref_power_901_constants ref_power_901_constants.file
|
||||
testcasefile ref_power_901_constants zarr metaonly; # test xarray as default
|
||||
;;
|
||||
zip)
|
||||
# Move into position
|
||||
if test "x$srcdir" != "x$execdir" ; then
|
||||
cp ${srcdir}/power_901_constants.zip ${execdir}
|
||||
cp ${srcdir}/ref_power_901_constants.zip ${execdir}
|
||||
cp ${srcdir}/ref_quotes.zip ${execdir}
|
||||
fi
|
||||
testcasezip power_901_constants xarray metaonly
|
||||
testcasezip ref_power_901_constants xarray metaonly
|
||||
# Test large constant interoperability
|
||||
testcasezip ref_quotes zarr metaonly
|
||||
;;
|
||||
*) echo "unimplemented kind: $1" ; exit 1;;
|
||||
esac
|
||||
|
||||
@ -13,7 +13,8 @@
|
||||
#ifdef HAVE_GETOPT_H
|
||||
#include <getopt.h>
|
||||
#endif
|
||||
#ifdef _WIN32
|
||||
|
||||
#if defined(_WIN32) && !defined(__MINGW32__)
|
||||
#include "XGetopt.h"
|
||||
#endif
|
||||
|
||||
|
||||
@ -21,7 +21,7 @@
|
||||
#include <getopt.h>
|
||||
#endif
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#if defined(_WIN32) && !defined(__MINGW32__)
|
||||
#include "XGetopt.h"
|
||||
#endif
|
||||
|
||||
|
||||
@ -14,7 +14,7 @@
|
||||
#include <getopt.h>
|
||||
#endif
|
||||
|
||||
#ifdef _WIN32
|
||||
#if defined(_WIN32) && !defined(__MINGW32__)
|
||||
#include "XGetopt.h"
|
||||
#endif
|
||||
|
||||
|
||||
@ -11,7 +11,7 @@ x * Copyright 2018, University Corporation for Atmospheric Research
|
||||
#include <getopt.h>
|
||||
#endif
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#if defined(_WIN32) && !defined(__MINGW32__)
|
||||
#include "XGetopt.h"
|
||||
#endif
|
||||
|
||||
|
||||
@ -13,7 +13,8 @@
|
||||
#ifdef HAVE_GETOPT_H
|
||||
#include <getopt.h>
|
||||
#endif
|
||||
#ifdef _WIN32
|
||||
|
||||
#if defined(_WIN32) && !defined(__MINGW32__)
|
||||
#include "XGetopt.h"
|
||||
#endif
|
||||
|
||||
@ -36,7 +37,8 @@ typedef enum OBJKIND {
|
||||
OK_NONE=0,
|
||||
OK_META=1,
|
||||
OK_CHUNK=2,
|
||||
OK_GROUP=3
|
||||
OK_GROUP=3,
|
||||
OK_IGNORE=4
|
||||
} OBJKIND;
|
||||
|
||||
static struct Mops {
|
||||
@ -75,6 +77,8 @@ struct Dumpptions {
|
||||
NCZM_IMPL impl;
|
||||
char* rootpath;
|
||||
const struct Type* nctype;
|
||||
int xflags;
|
||||
# define XNOZMETADATA 1
|
||||
} dumpoptions;
|
||||
|
||||
/* Forward */
|
||||
@ -129,10 +133,11 @@ main(int argc, char** argv)
|
||||
{
|
||||
int stat = NC_NOERR;
|
||||
int c;
|
||||
char* p;
|
||||
|
||||
memset((void*)&dumpoptions,0,sizeof(dumpoptions));
|
||||
|
||||
while ((c = getopt(argc, argv, "dvx:t:T:")) != EOF) {
|
||||
while ((c = getopt(argc, argv, "dvx:t:T:X:")) != EOF) {
|
||||
switch(c) {
|
||||
case 'd':
|
||||
dumpoptions.debug = 1;
|
||||
@ -151,6 +156,14 @@ main(int argc, char** argv)
|
||||
case 'T':
|
||||
nctracelevel(atoi(optarg));
|
||||
break;
|
||||
case 'X':
|
||||
for(p=optarg;*p;p++) {
|
||||
switch (*p) {
|
||||
case 'm': dumpoptions.xflags |= XNOZMETADATA; break;
|
||||
default: fprintf(stderr,"Unknown -X argument: %c",*p); break;
|
||||
}
|
||||
};
|
||||
break;
|
||||
case '?':
|
||||
fprintf(stderr,"unknown option\n");
|
||||
goto fail;
|
||||
@ -323,7 +336,9 @@ objdump(void)
|
||||
printf("[%d] %s : (%llu)",depth,obj,len);
|
||||
if(kind == OK_CHUNK) printf(" (%s)",dumpoptions.nctype->typename);
|
||||
printf(" |");
|
||||
printcontent(len,content,kind);
|
||||
if(kind != OK_IGNORE) {
|
||||
printcontent(len,content,kind);
|
||||
}
|
||||
printf("|\n");
|
||||
} else {
|
||||
printf("[%d] %s : (%llu) ||\n",depth,obj,len);
|
||||
@ -445,9 +460,12 @@ keykind(const char* key)
|
||||
if(suffix) {
|
||||
if(suffix[0] != '/')
|
||||
kind = OK_NONE;
|
||||
else if(suffix[1] == '.')
|
||||
kind = OK_META;
|
||||
else if(suffix[strlen(suffix)-1] == '/')
|
||||
else if(suffix[1] == '.') {
|
||||
if(strcmp(&suffix[1],".zmetadata")==0 && (dumpoptions.xflags & XNOZMETADATA))
|
||||
kind = OK_IGNORE;
|
||||
else
|
||||
kind = OK_META;
|
||||
} else if(suffix[strlen(suffix)-1] == '/')
|
||||
kind = OK_GROUP;
|
||||
else {
|
||||
char* p = suffix+1;
|
||||
|
||||
@ -5,13 +5,16 @@
|
||||
|
||||
#include "config.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#ifdef HAVE_UNISTD_H
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
#ifdef HAVE_GETOPT_H
|
||||
#include <getopt.h>
|
||||
#endif
|
||||
#ifdef _WIN32
|
||||
|
||||
#if defined(_WIN32) && !defined(__MINGW32__)
|
||||
#include "XGetopt.h"
|
||||
#endif
|
||||
|
||||
|
||||
@ -10,6 +10,7 @@ TOPSRCDIR='@abs_top_srcdir@'
|
||||
TOPBUILDDIR='@abs_top_builddir@'
|
||||
FP_ISCMAKE=@ISCMAKE@
|
||||
FP_ISMSVC=@ISMSVC@
|
||||
FP_ISCYGWIN=@ISCYGWIN@
|
||||
|
||||
# Feature flags
|
||||
FEATURE_HDF5=@HAS_HDF5@
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user