Merge pull request #826 in HDFFV/hdf5 from ~BYRN/hdf5_adb:develop to develop

* commit 'e94ed99c5bf7c4ae5df56f75606ef1b486e16bb2':
  Add HD prefix
  HDFFV-9724 Remove VDS file cache functionality
  Removed incorrect MPI text
  Par example needs to link with mpi libs
  Because of MPI requirements in library ALWAYS add include path
  Cleanup comments and if() in TRY blocks
  Skip test if 1.6 API
  HDFFV-9724 Add ENV VAR to vds test
  HDFFV-9724 Copy efc_open search from Lextern_traverse
  Add prefix dir to the clear command
  HDFFV-9724 Add H5LS prefix test with ${ORIGIN}
  Add h5dump VDS prefix tests
  HDFFV-9724 combine efc and vds into one function
  Correct var name
  Fix VDS file cache var names
  Remove return from void functions
  Added java wrappers and tests
  HDFFV-9724 Initial changes and test
  Changed reference from dl to CMake variable
  H5detect and H5make_libsettings need include folder

1 files changed, 210 insertions, 210 deletions

diff --git a/src/H5Fprivate.h b/src/H5Fprivate.h
index daf0a52..96b8e36 100644
--- a/src/H5Fprivate.h
+++ b/src/H5Fprivate.h
@@ -25,13 +25,13 @@ typedef struct H5F_t H5F_t;
 #include "H5Fpublic.h"
 
 /* Public headers needed by this file */
-#include "H5FDpublic.h"		/* File drivers				*/
+#include "H5FDpublic.h"        /* File drivers                */
 
 /* Private headers needed by this file */
 #ifdef H5_HAVE_PARALLEL
-#include "H5Pprivate.h"		/* Property lists			*/
+#include "H5Pprivate.h"        /* Property lists            */
 #endif /* H5_HAVE_PARALLEL */
-#include "H5VMprivate.h"		/* Vectors and arrays */
+#include "H5VMprivate.h"        /* Vectors and arrays */
 
 
 /**************************/
@@ -43,68 +43,68 @@ typedef struct H5F_t H5F_t;
  * Currently, all file meta-data is little-endian.
  */
 
-#  define INT16ENCODE(p, i) {						      \
-   *(p) = (uint8_t)( (unsigned)(i)	 & 0xff); (p)++;		      \
-   *(p) = (uint8_t)(((unsigned)(i) >> 8) & 0xff); (p)++;		      \
+#  define INT16ENCODE(p, i) {                              \
+   *(p) = (uint8_t)( (unsigned)(i)     & 0xff); (p)++;              \
+   *(p) = (uint8_t)(((unsigned)(i) >> 8) & 0xff); (p)++;              \
 }
 
-#  define UINT16ENCODE(p, i) {						      \
-   *(p) = (uint8_t)( (unsigned)(i)	 & 0xff); (p)++;		      \
-   *(p) = (uint8_t)(((unsigned)(i) >> 8) & 0xff); (p)++;		      \
+#  define UINT16ENCODE(p, i) {                              \
+   *(p) = (uint8_t)( (unsigned)(i)     & 0xff); (p)++;              \
+   *(p) = (uint8_t)(((unsigned)(i) >> 8) & 0xff); (p)++;              \
 }
 
-#  define INT32ENCODE(p, i) {						      \
-   *(p) = (uint8_t)( (uint32_t)(i)	  & 0xff); (p)++;		      \
-   *(p) = (uint8_t)(((uint32_t)(i) >>  8) & 0xff); (p)++;		      \
-   *(p) = (uint8_t)(((uint32_t)(i) >> 16) & 0xff); (p)++;		      \
-   *(p) = (uint8_t)(((uint32_t)(i) >> 24) & 0xff); (p)++;		      \
+#  define INT32ENCODE(p, i) {                              \
+   *(p) = (uint8_t)( (uint32_t)(i)      & 0xff); (p)++;              \
+   *(p) = (uint8_t)(((uint32_t)(i) >>  8) & 0xff); (p)++;              \
+   *(p) = (uint8_t)(((uint32_t)(i) >> 16) & 0xff); (p)++;              \
+   *(p) = (uint8_t)(((uint32_t)(i) >> 24) & 0xff); (p)++;              \
 }
 
-#  define UINT32ENCODE(p, i) {						      \
-   *(p) = (uint8_t)( (i)        & 0xff); (p)++;				      \
-   *(p) = (uint8_t)(((i) >>  8) & 0xff); (p)++;				      \
-   *(p) = (uint8_t)(((i) >> 16) & 0xff); (p)++;				      \
-   *(p) = (uint8_t)(((i) >> 24) & 0xff); (p)++;				      \
+#  define UINT32ENCODE(p, i) {                              \
+   *(p) = (uint8_t)( (i)        & 0xff); (p)++;                      \
+   *(p) = (uint8_t)(((i) >>  8) & 0xff); (p)++;                      \
+   *(p) = (uint8_t)(((i) >> 16) & 0xff); (p)++;                      \
+   *(p) = (uint8_t)(((i) >> 24) & 0xff); (p)++;                      \
 }
 
 /* Encode an unsigned integer into a variable-sized buffer */
 /* (Assumes that the high bits of the integer are zero) */
-#  define ENCODE_VAR(p, typ, n, l) {					      \
-   typ _n = (n);							      \
-   size_t _i;								      \
-   uint8_t *_p = (uint8_t*)(p);						      \
-									      \
-   for(_i = 0; _i < l; _i++, _n >>= 8)					      \
-      *_p++ = (uint8_t)(_n & 0xff);					      \
-   (p) = (uint8_t*)(p) + l;						      \
+#  define ENCODE_VAR(p, typ, n, l) {                          \
+   typ _n = (n);                                  \
+   size_t _i;                                      \
+   uint8_t *_p = (uint8_t*)(p);                              \
+                                        \
+   for(_i = 0; _i < l; _i++, _n >>= 8)                          \
+      *_p++ = (uint8_t)(_n & 0xff);                          \
+   (p) = (uint8_t*)(p) + l;                              \
 }
 
 /* Encode a 32-bit unsigned integer into a variable-sized buffer */
 /* (Assumes that the high bits of the integer are zero) */
 #  define UINT32ENCODE_VAR(p, n, l)     ENCODE_VAR(p, uint32_t, n, l)
 
-#  define INT64ENCODE(p, n) {						      \
-   int64_t _n = (n);							      \
-   size_t _i;								      \
-   uint8_t *_p = (uint8_t*)(p);						      \
-									      \
-   for (_i = 0; _i < sizeof(int64_t); _i++, _n >>= 8)			      \
-      *_p++ = (uint8_t)(_n & 0xff);					      \
-   for (/*void*/; _i < 8; _i++)						      \
-      *_p++ = (n) < 0 ? 0xff : 0;					      \
-   (p) = (uint8_t*)(p)+8;						      \
+#  define INT64ENCODE(p, n) {                              \
+   int64_t _n = (n);                                  \
+   size_t _i;                                      \
+   uint8_t *_p = (uint8_t*)(p);                              \
+                                        \
+   for (_i = 0; _i < sizeof(int64_t); _i++, _n >>= 8)                  \
+      *_p++ = (uint8_t)(_n & 0xff);                          \
+   for (/*void*/; _i < 8; _i++)                              \
+      *_p++ = (n) < 0 ? 0xff : 0;                          \
+   (p) = (uint8_t*)(p)+8;                              \
 }
 
-#  define UINT64ENCODE(p, n) {						      \
-   uint64_t _n = (n);							      \
-   size_t _i;								      \
-   uint8_t *_p = (uint8_t*)(p);						      \
-									      \
-   for (_i = 0; _i < sizeof(uint64_t); _i++, _n >>= 8)			      \
-      *_p++ = (uint8_t)(_n & 0xff);					      \
-   for (/*void*/; _i < 8; _i++)						      \
-      *_p++ = 0;							      \
-   (p) = (uint8_t*)(p) + 8;						      \
+#  define UINT64ENCODE(p, n) {                              \
+   uint64_t _n = (n);                                  \
+   size_t _i;                                      \
+   uint8_t *_p = (uint8_t*)(p);                              \
+                                        \
+   for (_i = 0; _i < sizeof(uint64_t); _i++, _n >>= 8)                  \
+      *_p++ = (uint8_t)(_n & 0xff);                          \
+   for (/*void*/; _i < 8; _i++)                              \
+      *_p++ = 0;                                  \
+   (p) = (uint8_t*)(p) + 8;                              \
 }
 
 /* Encode a 64-bit unsigned integer into a variable-sized buffer */
@@ -113,31 +113,31 @@ typedef struct H5F_t H5F_t;
 
 /* Encode a 64-bit unsigned integer and its length into a variable-sized buffer */
 /* (Assumes that the high bits of the integer are zero) */
-#  define UINT64ENCODE_VARLEN(p, n) {					      \
-   uint64_t __n = (uint64_t)(n);							      \
-   unsigned _s = H5VM_limit_enc_size(__n);				      \
-									      \
-   *(p)++ = (uint8_t)_s;						      \
-   UINT64ENCODE_VAR(p, __n, _s);						      \
+#  define UINT64ENCODE_VARLEN(p, n) {                          \
+   uint64_t __n = (uint64_t)(n);                                  \
+   unsigned _s = H5VM_limit_enc_size(__n);                      \
+                                        \
+   *(p)++ = (uint8_t)_s;                              \
+   UINT64ENCODE_VAR(p, __n, _s);                              \
 }
 
-#  define H5_ENCODE_UNSIGNED(p, n) {					      \
-    HDcompile_assert(sizeof(unsigned) == sizeof(uint32_t));		      \
-    UINT32ENCODE(p, n)							      \
+#  define H5_ENCODE_UNSIGNED(p, n) {                          \
+    HDcompile_assert(sizeof(unsigned) == sizeof(uint32_t));              \
+    UINT32ENCODE(p, n)                                  \
 }
 
 /* Assumes the endianness of uint64_t is the same as double */
-#  define H5_ENCODE_DOUBLE(p, n) {					      \
-    uint64_t _n;							      \
-    size_t _u;								      \
-    uint8_t *_p = (uint8_t*)(p);					      \
-									      \
-    HDcompile_assert(sizeof(double) == 8);				      \
-    HDcompile_assert(sizeof(double) == sizeof(uint64_t));		      \
-    HDmemcpy(&_n, &n, sizeof(double));					      \
-    for(_u = 0; _u < sizeof(uint64_t); _u++, _n >>= 8)			      \
-        *_p++ = (uint8_t)(_n & 0xff);					      \
-    (p) = (uint8_t *)(p) + 8;						      \
+#  define H5_ENCODE_DOUBLE(p, n) {                          \
+    uint64_t _n;                                  \
+    size_t _u;                                      \
+    uint8_t *_p = (uint8_t*)(p);                          \
+                                        \
+    HDcompile_assert(sizeof(double) == 8);                      \
+    HDcompile_assert(sizeof(double) == sizeof(uint64_t));              \
+    HDmemcpy(&_n, &n, sizeof(double));                          \
+    for(_u = 0; _u < sizeof(uint64_t); _u++, _n >>= 8)                  \
+        *_p++ = (uint8_t)(_n & 0xff);                          \
+    (p) = (uint8_t *)(p) + 8;                              \
 }
 
 /* DECODE converts little endian bytes pointed by p to integer values and store
@@ -148,68 +148,68 @@ typedef struct H5F_t H5F_t;
  * correctly even if i is actually a 64bit int like in a Cray.
  */
 
-#  define INT16DECODE(p, i) {						      \
-   (i)	= (int16_t)((*(p) & 0xff));      (p)++;				      \
+#  define INT16DECODE(p, i) {                              \
+   (i)    = (int16_t)((*(p) & 0xff));      (p)++;                      \
    (i) |= (int16_t)(((*(p) & 0xff) << 8) |                                    \
-                   ((*(p) & 0x80) ? ~0xffff : 0x0)); (p)++;		      \
+                   ((*(p) & 0x80) ? ~0xffff : 0x0)); (p)++;              \
 }
 
-#  define UINT16DECODE(p, i) {						      \
-   (i)	= (uint16_t) (*(p) & 0xff);	  (p)++;			      \
-   (i) |= (uint16_t)((*(p) & 0xff) << 8); (p)++;			      \
+#  define UINT16DECODE(p, i) {                              \
+   (i)    = (uint16_t) (*(p) & 0xff);      (p)++;                  \
+   (i) |= (uint16_t)((*(p) & 0xff) << 8); (p)++;                  \
 }
 
-#  define INT32DECODE(p, i) {						      \
-   (i)	= ((int32_t)(*(p) & (unsigned)0xff));	  (p)++;		      \
-   (i) |= ((int32_t)(*(p) & (unsigned)0xff) <<  8); (p)++;		      \
-   (i) |= ((int32_t)(*(p) & (unsigned)0xff) << 16); (p)++;		      \
+#  define INT32DECODE(p, i) {                              \
+   (i)    = ((int32_t)(*(p) & (unsigned)0xff));      (p)++;              \
+   (i) |= ((int32_t)(*(p) & (unsigned)0xff) <<  8); (p)++;              \
+   (i) |= ((int32_t)(*(p) & (unsigned)0xff) << 16); (p)++;              \
    (i) |= ((int32_t)(((*(p) & (unsigned)0xff) << 24) |                        \
                    ((*(p) & (unsigned)0x80) ? (unsigned)(~0xffffffff) : (unsigned)0x0))); (p)++; \
 }
 
-#  define UINT32DECODE(p, i) {						      \
-   (i)	=  (uint32_t)(*(p) & 0xff);	   (p)++;			      \
-   (i) |= ((uint32_t)(*(p) & 0xff) <<  8); (p)++;			      \
-   (i) |= ((uint32_t)(*(p) & 0xff) << 16); (p)++;			      \
-   (i) |= ((uint32_t)(*(p) & 0xff) << 24); (p)++;			      \
+#  define UINT32DECODE(p, i) {                              \
+   (i)    =  (uint32_t)(*(p) & 0xff);       (p)++;                  \
+   (i) |= ((uint32_t)(*(p) & 0xff) <<  8); (p)++;                  \
+   (i) |= ((uint32_t)(*(p) & 0xff) << 16); (p)++;                  \
+   (i) |= ((uint32_t)(*(p) & 0xff) << 24); (p)++;                  \
 }
 
 /* Decode a variable-sized buffer */
 /* (Assumes that the high bits of the integer will be zero) */
-#  define DECODE_VAR(p, n, l) {						      \
-   size_t _i;								      \
-									      \
-   n = 0;								      \
-   (p) += l;								      \
-   for (_i = 0; _i < l; _i++)						      \
-      n = (n << 8) | *(--p);						      \
-   (p) += l;								      \
+#  define DECODE_VAR(p, n, l) {                              \
+   size_t _i;                                      \
+                                        \
+   n = 0;                                      \
+   (p) += l;                                      \
+   for (_i = 0; _i < l; _i++)                              \
+      n = (n << 8) | *(--p);                              \
+   (p) += l;                                      \
 }
 
 /* Decode a variable-sized buffer into a 32-bit unsigned integer */
 /* (Assumes that the high bits of the integer will be zero) */
 #  define UINT32DECODE_VAR(p, n, l)     DECODE_VAR(p, n, l)
 
-#  define INT64DECODE(p, n) {						      \
-   /* WE DON'T CHECK FOR OVERFLOW! */					      \
-   size_t _i;								      \
-									      \
-   n = 0;								      \
-   (p) += 8;								      \
-   for (_i = 0; _i < sizeof(int64_t); _i++)					      \
-      n = (n << 8) | *(--p);						      \
-   (p) += 8;								      \
+#  define INT64DECODE(p, n) {                              \
+   /* WE DON'T CHECK FOR OVERFLOW! */                          \
+   size_t _i;                                      \
+                                        \
+   n = 0;                                      \
+   (p) += 8;                                      \
+   for (_i = 0; _i < sizeof(int64_t); _i++)                          \
+      n = (n << 8) | *(--p);                              \
+   (p) += 8;                                      \
 }
 
-#  define UINT64DECODE(p, n) {						      \
-   /* WE DON'T CHECK FOR OVERFLOW! */					      \
-   size_t _i;								      \
-									      \
-   n = 0;								      \
-   (p) += 8;								      \
-   for (_i = 0; _i < sizeof(uint64_t); _i++)				      \
-      n = (n << 8) | *(--p);						      \
-   (p) += 8;								      \
+#  define UINT64DECODE(p, n) {                              \
+   /* WE DON'T CHECK FOR OVERFLOW! */                          \
+   size_t _i;                                      \
+                                        \
+   n = 0;                                      \
+   (p) += 8;                                      \
+   for (_i = 0; _i < sizeof(uint64_t); _i++)                      \
+      n = (n << 8) | *(--p);                              \
+   (p) += 8;                                      \
 }
 
 /* Decode a variable-sized buffer into a 64-bit unsigned integer */
@@ -218,58 +218,58 @@ typedef struct H5F_t H5F_t;
 
 /* Decode a 64-bit unsigned integer and its length from a variable-sized buffer */
 /* (Assumes that the high bits of the integer will be zero) */
-#  define UINT64DECODE_VARLEN(p, n) {					      \
-   unsigned _s = *(p)++;						      \
-									      \
-   UINT64DECODE_VAR(p, n, _s);						      \
+#  define UINT64DECODE_VARLEN(p, n) {                          \
+   unsigned _s = *(p)++;                              \
+                                        \
+   UINT64DECODE_VAR(p, n, _s);                              \
 }
 
-#  define H5_DECODE_UNSIGNED(p, n) {					      \
-    HDcompile_assert(sizeof(unsigned) == sizeof(uint32_t));		      \
-    UINT32DECODE(p, n)							      \
+#  define H5_DECODE_UNSIGNED(p, n) {                          \
+    HDcompile_assert(sizeof(unsigned) == sizeof(uint32_t));              \
+    UINT32DECODE(p, n)                                  \
 }
 
 /* Assumes the endianness of uint64_t is the same as double */
-#  define H5_DECODE_DOUBLE(p, n) {					      \
-    uint64_t _n;							      \
-    size_t _u;								      \
-									      \
-    HDcompile_assert(sizeof(double) == 8);				      \
-    HDcompile_assert(sizeof(double) == sizeof(uint64_t));		      \
-    _n = 0;								      \
-    (p) += 8;								      \
-    for(_u = 0; _u < sizeof(uint64_t); _u++)				      \
-        _n = (_n << 8) | *(--p);					      \
-    HDmemcpy(&(n), &_n, sizeof(double));					      \
-    (p) += 8;								      \
+#  define H5_DECODE_DOUBLE(p, n) {                          \
+    uint64_t _n;                                  \
+    size_t _u;                                      \
+                                        \
+    HDcompile_assert(sizeof(double) == 8);                      \
+    HDcompile_assert(sizeof(double) == sizeof(uint64_t));              \
+    _n = 0;                                      \
+    (p) += 8;                                      \
+    for(_u = 0; _u < sizeof(uint64_t); _u++)                      \
+        _n = (_n << 8) | *(--p);                          \
+    HDmemcpy(&(n), &_n, sizeof(double));                          \
+    (p) += 8;                                      \
 }
 
 /* Address-related macros */
-#define H5F_addr_overflow(X,Z)	(HADDR_UNDEF==(X) ||			      \
-				 HADDR_UNDEF==(X)+(haddr_t)(Z) ||	      \
-				 (X)+(haddr_t)(Z)<(X))
-#define H5F_addr_defined(X)	((X)!=HADDR_UNDEF)
+#define H5F_addr_overflow(X,Z)    (HADDR_UNDEF==(X) ||                  \
+                HADDR_UNDEF==(X)+(haddr_t)(Z) ||          \
+                (X)+(haddr_t)(Z)<(X))
+#define H5F_addr_defined(X)    ((X)!=HADDR_UNDEF)
 /* The H5F_addr_eq() macro guarantees that Y is not HADDR_UNDEF by making
  * certain that X is not HADDR_UNDEF and then checking that X equals Y
  */
-#define H5F_addr_eq(X,Y)	((X)!=HADDR_UNDEF &&			      \
-				 (X)==(Y))
-#define H5F_addr_ne(X,Y)	(!H5F_addr_eq((X),(Y)))
-#define H5F_addr_lt(X,Y) 	((X)!=HADDR_UNDEF &&			      \
-				 (Y)!=HADDR_UNDEF &&			      \
-				 (X)<(Y))
-#define H5F_addr_le(X,Y)	((X)!=HADDR_UNDEF &&			      \
-				 (Y)!=HADDR_UNDEF &&			      \
-				 (X)<=(Y))
-#define H5F_addr_gt(X,Y)	((X)!=HADDR_UNDEF &&			      \
-				 (Y)!=HADDR_UNDEF &&			      \
-				 (X)>(Y))
-#define H5F_addr_ge(X,Y)	((X)!=HADDR_UNDEF &&			      \
-				 (Y)!=HADDR_UNDEF &&			      \
-				 (X)>=(Y))
-#define H5F_addr_cmp(X,Y)	(H5F_addr_eq((X), (Y)) ? 0 :		      \
-				 (H5F_addr_lt((X), (Y)) ? -1 : 1))
-#define H5F_addr_pow2(N)	((haddr_t)1<<(N))
+#define H5F_addr_eq(X,Y)    ((X)!=HADDR_UNDEF &&                  \
+                (X)==(Y))
+#define H5F_addr_ne(X,Y)    (!H5F_addr_eq((X),(Y)))
+#define H5F_addr_lt(X,Y)     ((X)!=HADDR_UNDEF &&                  \
+                (Y)!=HADDR_UNDEF &&                  \
+                (X)<(Y))
+#define H5F_addr_le(X,Y)    ((X)!=HADDR_UNDEF &&                  \
+                (Y)!=HADDR_UNDEF &&                  \
+                (X)<=(Y))
+#define H5F_addr_gt(X,Y)    ((X)!=HADDR_UNDEF &&                  \
+                (Y)!=HADDR_UNDEF &&                  \
+                (X)>(Y))
+#define H5F_addr_ge(X,Y)    ((X)!=HADDR_UNDEF &&                  \
+                (Y)!=HADDR_UNDEF &&                  \
+                (X)>=(Y))
+#define H5F_addr_cmp(X,Y)    (H5F_addr_eq((X), (Y)) ? 0 :              \
+                (H5F_addr_lt((X), (Y)) ? -1 : 1))
+#define H5F_addr_pow2(N)    ((haddr_t)1<<(N))
 #define H5F_addr_overlap(O1,L1,O2,L2) (((O1) < (O2) && ((O1) + (L1)) > (O2)) || \
                                  ((O1) >= (O2) && (O1) < ((O2) + (L2))))
 
@@ -294,7 +294,7 @@ typedef struct H5F_t H5F_t;
 #define H5F_BASE_ADDR(F)        ((F)->shared->sblock->base_addr)
 #define H5F_SYM_LEAF_K(F)       ((F)->shared->sblock->sym_leaf_k)
 #define H5F_KVALUE(F,T)         ((F)->shared->sblock->btree_k[(T)->id])
-#define H5F_NREFS(F)		((F)->shared->nrefs)
+#define H5F_NREFS(F)        ((F)->shared->nrefs)
 #define H5F_SIZEOF_ADDR(F)      ((F)->shared->sizeof_addr)
 #define H5F_SIZEOF_SIZE(F)      ((F)->shared->sizeof_size)
 #define H5F_SOHM_ADDR(F)        ((F)->shared->sohm_addr)
@@ -325,8 +325,8 @@ typedef struct H5F_t H5F_t;
 #define H5F_USE_MDC_LOGGING(F)  ((F)->shared->use_mdc_logging)
 #define H5F_START_MDC_LOG_ON_ACCESS(F)  ((F)->shared->start_mdc_log_on_access)
 #define H5F_MDC_LOG_LOCATION(F) ((F)->shared->mdc_log_location)
-#define H5F_ALIGNMENT(F)   	((F)->shared->alignment)
-#define H5F_THRESHOLD(F)   	((F)->shared->threshold)
+#define H5F_ALIGNMENT(F)       ((F)->shared->alignment)
+#define H5F_THRESHOLD(F)       ((F)->shared->threshold)
 #define H5F_PGEND_META_THRES(F) ((F)->shared->fs.pgend_meta_thres)
 #define H5F_POINT_OF_NO_RETURN(F) ((F)->shared->fs.point_of_no_return)
 #define H5F_FIRST_ALLOC_DEALLOC(F) ((F)->shared->first_alloc_dealloc)
@@ -351,7 +351,7 @@ typedef struct H5F_t H5F_t;
 #define H5F_BASE_ADDR(F)        (H5F_get_base_addr(F))
 #define H5F_SYM_LEAF_K(F)       (H5F_sym_leaf_k(F))
 #define H5F_KVALUE(F,T)         (H5F_Kvalue(F,T))
-#define H5F_NREFS(F)		(H5F_get_nrefs(F))
+#define H5F_NREFS(F)        (H5F_get_nrefs(F))
 #define H5F_SIZEOF_ADDR(F)      (H5F_sizeof_addr(F))
 #define H5F_SIZEOF_SIZE(F)      (H5F_sizeof_size(F))
 #define H5F_SOHM_ADDR(F)        (H5F_get_sohm_addr(F))
@@ -382,8 +382,8 @@ typedef struct H5F_t H5F_t;
 #define H5F_USE_MDC_LOGGING(F)  (H5F_use_mdc_logging(F))
 #define H5F_START_MDC_LOG_ON_ACCESS(F)  (H5F_start_mdc_log_on_access(F))
 #define H5F_MDC_LOG_LOCATION(F) (H5F_mdc_log_location(F))
-#define H5F_ALIGNMENT(F)    	(H5F_get_alignment(F))
-#define H5F_THRESHOLD(F)    	(H5F_get_threshold(F))
+#define H5F_ALIGNMENT(F)        (H5F_get_alignment(F))
+#define H5F_THRESHOLD(F)        (H5F_get_threshold(F))
 #define H5F_PGEND_META_THRES(F) (H5F_get_pgend_meta_thres(F))
 #define H5F_POINT_OF_NO_RETURN(F) (H5F_get_point_of_no_return(F))
 #define H5F_FIRST_ALLOC_DEALLOC(F) (H5F_get_first_alloc_dealloc(F))
@@ -392,32 +392,32 @@ typedef struct H5F_t H5F_t;
 
 
 /* Macros to encode/decode offset/length's for storing in the file */
-#define H5F_ENCODE_OFFSET(f,p,o) switch(H5F_SIZEOF_ADDR(f)) {		      \
-    case 4: UINT32ENCODE(p,o); break;					      \
-    case 8: UINT64ENCODE(p,o); break;					      \
-    case 2: UINT16ENCODE(p,o); break;					      \
+#define H5F_ENCODE_OFFSET(f,p,o) switch(H5F_SIZEOF_ADDR(f)) {              \
+    case 4: UINT32ENCODE(p,o); break;                          \
+    case 8: UINT64ENCODE(p,o); break;                          \
+    case 2: UINT16ENCODE(p,o); break;                          \
 }
 
-#define H5F_DECODE_OFFSET(f,p,o) switch (H5F_SIZEOF_ADDR (f)) {		      \
-    case 4: UINT32DECODE(p, o); break;					      \
-    case 8: UINT64DECODE(p, o); break;					      \
-    case 2: UINT16DECODE(p, o); break;					      \
+#define H5F_DECODE_OFFSET(f,p,o) switch (H5F_SIZEOF_ADDR (f)) {              \
+    case 4: UINT32DECODE(p, o); break;                          \
+    case 8: UINT64DECODE(p, o); break;                          \
+    case 2: UINT16DECODE(p, o); break;                          \
 }
 
-#define H5F_ENCODE_LENGTH_LEN(p,l,s) switch(s) {		      	      \
-    case 4: UINT32ENCODE(p,l); break;					      \
-    case 8: UINT64ENCODE(p,l); break;					      \
-    case 2: UINT16ENCODE(p,l); break;					      \
-    default: HDassert("bad sizeof size" && 0);				      \
+#define H5F_ENCODE_LENGTH_LEN(p,l,s) switch(s) {                        \
+    case 4: UINT32ENCODE(p,l); break;                          \
+    case 8: UINT64ENCODE(p,l); break;                          \
+    case 2: UINT16ENCODE(p,l); break;                          \
+    default: HDassert("bad sizeof size" && 0);                      \
 }
 
 #define H5F_ENCODE_LENGTH(f,p,l) H5F_ENCODE_LENGTH_LEN(p,l,H5F_SIZEOF_SIZE(f))
 
-#define H5F_DECODE_LENGTH_LEN(p,l,s) switch(s) {		              \
-    case 4: UINT32DECODE(p,l); break;					      \
-    case 8: UINT64DECODE(p,l); break;					      \
-    case 2: UINT16DECODE(p,l); break;					      \
-    default: HDassert("bad sizeof size" && 0);				      \
+#define H5F_DECODE_LENGTH_LEN(p,l,s) switch(s) {                      \
+    case 4: UINT32DECODE(p,l); break;                          \
+    case 8: UINT64DECODE(p,l); break;                          \
+    case 2: UINT16DECODE(p,l); break;                          \
+    default: HDassert("bad sizeof size" && 0);                      \
 }
 
 #define H5F_DECODE_LENGTH(f,p,l) H5F_DECODE_LENGTH_LEN(p,l,H5F_SIZEOF_SIZE(f))
@@ -427,13 +427,13 @@ typedef struct H5F_t H5F_t;
  * with.
  */
 #if (H5_SIZEOF_SIZE_T >= H5_SIZEOF_OFF_T)
-#   define H5F_OVERFLOW_SIZET2OFFT(X)					      \
+#   define H5F_OVERFLOW_SIZET2OFFT(X)                          \
     ((size_t)(X)>=(size_t)((size_t)1<<(8*sizeof(HDoff_t)-1)))
 #else
 #   define H5F_OVERFLOW_SIZET2OFFT(X) 0
 #endif
 #if (H5_SIZEOF_HSIZE_T >= H5_SIZEOF_OFF_T)
-#   define H5F_OVERFLOW_HSIZET2OFFT(X)					      \
+#   define H5F_OVERFLOW_HSIZET2OFFT(X)                          \
     ((hsize_t)(X) >= (hsize_t)((hsize_t)1 << (8 * sizeof(HDoff_t) - 1)))
 #else
 #   define H5F_OVERFLOW_HSIZET2OFFT(X) 0
@@ -461,14 +461,14 @@ typedef struct H5F_t H5F_t;
 #define H5F_CRT_SHMSG_LIST_MAX_NAME  "shmsg_list_max"   /* Shared message list maximum size */
 #define H5F_CRT_SHMSG_BTREE_MIN_NAME "shmsg_btree_min"  /* Shared message B-tree minimum size */
 #define H5F_CRT_FILE_SPACE_STRATEGY_NAME "file_space_strategy"  /* File space handling strategy */
-#define H5F_CRT_FREE_SPACE_PERSIST_NAME "free_space_persist"  	/* Free-space persisting status */
+#define H5F_CRT_FREE_SPACE_PERSIST_NAME "free_space_persist"      /* Free-space persisting status */
 #define H5F_CRT_FREE_SPACE_THRESHOLD_NAME "free_space_threshold"  /* Free space section threshold */
 #define H5F_CRT_FILE_SPACE_PAGE_SIZE_NAME "file_space_page_size"  /* File space page size */
 
 
 
 /* ========= File Access properties ============ */
-#define H5F_ACS_META_CACHE_INIT_CONFIG_NAME	"mdc_initCacheCfg" /* Initial metadata cache resize configuration */
+#define H5F_ACS_META_CACHE_INIT_CONFIG_NAME    "mdc_initCacheCfg" /* Initial metadata cache resize configuration */
 #define H5F_ACS_DATA_CACHE_NUM_SLOTS_NAME       "rdcc_nslots"   /* Size of raw data chunk cache(slots) */
 #define H5F_ACS_DATA_CACHE_BYTE_SIZE_NAME       "rdcc_nbytes"   /* Size of raw data chunk cache(bytes) */
 #define H5F_ACS_PREEMPT_READ_CHUNKS_NAME        "rdcc_w0"       /* Preemption read chunks first */
@@ -487,7 +487,7 @@ typedef struct H5F_t H5F_t;
 #define H5F_ACS_LATEST_FORMAT_NAME              "latest_format" /* 'Use latest format version' flag */
 #define H5F_ACS_WANT_POSIX_FD_NAME              "want_posix_fd" /* Internal: query the file descriptor from the core VFD, instead of the memory address */
 #define H5F_ACS_METADATA_READ_ATTEMPTS_NAME     "metadata_read_attempts" /* # of metadata read attempts */
-#define H5F_ACS_OBJECT_FLUSH_CB_NAME            "object_flush_cb" 	 /* Object flush callback */
+#define H5F_ACS_OBJECT_FLUSH_CB_NAME            "object_flush_cb"      /* Object flush callback */
 #define H5F_ACS_EFC_SIZE_NAME                   "efc_size"      /* Size of external file cache */
 #define H5F_ACS_FILE_IMAGE_INFO_NAME            "file_image_info" /* struct containing initial file image and callback info */
 #define H5F_ACS_CLEAR_STATUS_FLAGS_NAME         "clear_status_flags" /* Whether to clear superblock status_flags (private property only used by h5clear) */
@@ -504,7 +504,7 @@ typedef struct H5F_t H5F_t;
 #define H5F_ACS_PAGE_BUFFER_MIN_RAW_PERC_NAME   "page_buffer_min_raw_perc" /* the min raw data percentage for the page buffer cache */
 
 /* ======================== File Mount properties ====================*/
-#define H5F_MNT_SYM_LOCAL_NAME 		"local"                 /* Whether absolute symlinks local to file. */
+#define H5F_MNT_SYM_LOCAL_NAME         "local"                 /* Whether absolute symlinks local to file. */
 
 
 #ifdef H5_HAVE_PARALLEL
@@ -513,20 +513,20 @@ typedef struct H5F_t H5F_t;
 #endif /* H5_HAVE_PARALLEL */
 
 /* Define the HDF5 file signature */
-#define H5F_SIGNATURE	  "\211HDF\r\n\032\n"
+#define H5F_SIGNATURE      "\211HDF\r\n\032\n"
 #define H5F_SIGNATURE_LEN 8
 
 /* Version #'s of the major components of the file format */
-#define HDF5_SUPERBLOCK_VERSION_DEF	0	/* The default super block format	  */
-#define HDF5_SUPERBLOCK_VERSION_1	1	/* Version with non-default B-tree 'K' value */
-#define HDF5_SUPERBLOCK_VERSION_2	2	/* Revised version with superblock extension and checksum */
-#define HDF5_SUPERBLOCK_VERSION_3	3	/* With file locking and consistency flags (at least this version for SWMR support) */
-#define HDF5_SUPERBLOCK_VERSION_LATEST	HDF5_SUPERBLOCK_VERSION_3	/* The maximum super block format    */
+#define HDF5_SUPERBLOCK_VERSION_DEF    0    /* The default super block format      */
+#define HDF5_SUPERBLOCK_VERSION_1    1    /* Version with non-default B-tree 'K' value */
+#define HDF5_SUPERBLOCK_VERSION_2    2    /* Revised version with superblock extension and checksum */
+#define HDF5_SUPERBLOCK_VERSION_3    3    /* With file locking and consistency flags (at least this version for SWMR support) */
+#define HDF5_SUPERBLOCK_VERSION_LATEST    HDF5_SUPERBLOCK_VERSION_3    /* The maximum super block format    */
 #define HDF5_SUPERBLOCK_VERSION_V18_LATEST HDF5_SUPERBLOCK_VERSION_2    /* The latest superblock version for v18 */
-#define HDF5_FREESPACE_VERSION	        0	/* of the Free-Space Info	  */
-#define HDF5_OBJECTDIR_VERSION	        0	/* of the Object Directory format */
-#define HDF5_SHAREDHEADER_VERSION       0	/* of the Shared-Header Info	  */
-#define HDF5_DRIVERINFO_VERSION_0       0	/* of the Driver Information Block*/
+#define HDF5_FREESPACE_VERSION            0    /* of the Free-Space Info      */
+#define HDF5_OBJECTDIR_VERSION            0    /* of the Object Directory format */
+#define HDF5_SHAREDHEADER_VERSION       0    /* of the Shared-Header Info      */
+#define HDF5_DRIVERINFO_VERSION_0       0    /* of the Driver Information Block*/
 
 /* B-tree internal 'K' values */
 #define HDF5_BTREE_SNODE_IK_DEF         16
@@ -536,54 +536,54 @@ typedef struct H5F_t H5F_t;
                                                     if it is changed, the code
                                                     must compensate. -QAK
                                                  */
-#define HDF5_BTREE_IK_MAX_ENTRIES       65536 	/* 2^16 - 2 bytes for storing entries (children) */
-						/* See format specification on version 1 B-trees */
+#define HDF5_BTREE_IK_MAX_ENTRIES       65536     /* 2^16 - 2 bytes for storing entries (children) */
+                        /* See format specification on version 1 B-trees */
 
 /* Default file space handling strategy */
-#define H5F_FILE_SPACE_STRATEGY_DEF	        H5F_FSPACE_STRATEGY_FSM_AGGR
+#define H5F_FILE_SPACE_STRATEGY_DEF            H5F_FSPACE_STRATEGY_FSM_AGGR
 
 /* Default free space section threshold used by free-space managers */
-#define H5F_FREE_SPACE_PERSIST_DEF	        FALSE
+#define H5F_FREE_SPACE_PERSIST_DEF            FALSE
 
 /* Default free space section threshold used by free-space managers */
-#define H5F_FREE_SPACE_THRESHOLD_DEF	        1
+#define H5F_FREE_SPACE_THRESHOLD_DEF            1
 
 /* For paged aggregation: default file space page size when not set */
-#define H5F_FILE_SPACE_PAGE_SIZE_DEF     	4096    
+#define H5F_FILE_SPACE_PAGE_SIZE_DEF         4096
 /* For paged aggregation: minimum value for file space page size */
-#define H5F_FILE_SPACE_PAGE_SIZE_MIN     	512
+#define H5F_FILE_SPACE_PAGE_SIZE_MIN         512
 /* For paged aggregation: maxiumum value for file space page size: 1 gigabyte */
-#define H5F_FILE_SPACE_PAGE_SIZE_MAX     	1024*1024*1024
+#define H5F_FILE_SPACE_PAGE_SIZE_MAX         1024*1024*1024
 
 /* For paged aggregation: drop free-space with size <= this threshold for small meta section */
 #define H5F_FILE_SPACE_PGEND_META_THRES  0
 
 /* Default for threshold for alignment (can be set via H5Pset_alignment()) */
-#define H5F_ALIGN_DEF			1
+#define H5F_ALIGN_DEF            1
 /* Default for alignment (can be set via H5Pset_alignment()) */
-#define H5F_ALIGN_THRHD_DEF		1
+#define H5F_ALIGN_THRHD_DEF        1
 /* Default size for meta data aggregation block (can be set via H5Pset_meta_block_size()) */
-#define H5F_META_BLOCK_SIZE_DEF		2048
+#define H5F_META_BLOCK_SIZE_DEF        2048
 /* Default size for small data aggregation block (can be set via H5Pset_small_data_block_size()) */
-#define H5F_SDATA_BLOCK_SIZE_DEF	2048
+#define H5F_SDATA_BLOCK_SIZE_DEF    2048
 
 /* Check for file using paged aggregation */
 #define H5F_PAGED_AGGR(F) (F->shared->fs_strategy == H5F_FSPACE_STRATEGY_PAGE && F->shared->fs_page_size)
 
 /* Metadata read attempt values */
-#define H5F_METADATA_READ_ATTEMPTS		1	/* Default # of read attempts for non-SWMR access */
-#define H5F_SWMR_METADATA_READ_ATTEMPTS		100	/* Default # of read attempts for SWMR access */
+#define H5F_METADATA_READ_ATTEMPTS        1    /* Default # of read attempts for non-SWMR access */
+#define H5F_SWMR_METADATA_READ_ATTEMPTS        100    /* Default # of read attempts for SWMR access */
 
 
 /* Macros to define signatures of all objects in the file */
 
 /* Size of signature information (on disk) */
 /* (all on-disk signatures should be this length) */
-#define H5_SIZEOF_MAGIC                 4
+#define H5_SIZEOF_MAGIC                   4
 
 /* Size of checksum information (on disk) */
 /* (all on-disk checksums should be this length) */
-#define H5_SIZEOF_CHKSUM              	4
+#define H5_SIZEOF_CHKSUM                  4
 
 /* v1 B-tree node signature */
 #define H5B_MAGIC                       "TREE"
@@ -704,11 +704,11 @@ typedef enum H5F_fs_state_t {
 typedef enum H5F_mem_page_t {
     H5F_MEM_PAGE_DEFAULT = 0,       /* Not used */
     H5F_MEM_PAGE_SUPER = 1,
-    H5F_MEM_PAGE_BTREE = 2,          
-    H5F_MEM_PAGE_DRAW = 3, 
-    H5F_MEM_PAGE_GHEAP = 4,      
-    H5F_MEM_PAGE_LHEAP = 5,      
-    H5F_MEM_PAGE_OHDR = 6,      
+    H5F_MEM_PAGE_BTREE = 2,
+    H5F_MEM_PAGE_DRAW = 3,
+    H5F_MEM_PAGE_GHEAP = 4,
+    H5F_MEM_PAGE_LHEAP = 5,
+    H5F_MEM_PAGE_OHDR = 6,
     H5F_MEM_PAGE_LARGE_SUPER = 7,
     H5F_MEM_PAGE_LARGE_BTREE = 8,
     H5F_MEM_PAGE_LARGE_DRAW = 9,